projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
smb347_charger: Cleanup power supply registration code in probe
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / power / smb347-charger.c
CommitLineData
ed1a230f
BR		 1/*
2 * Summit Microelectronics SMB347 Battery Charger Driver
3 *
4 * Copyright (C) 2011, Intel Corporation
5 *
6 * Authors: Bruce E. Robertson <bruce.e.robertson@intel.com>
7 * Mika Westerberg <mika.westerberg@linux.intel.com>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14#include <linux/debugfs.h>
15#include <linux/gpio.h>
16#include <linux/kernel.h>
17#include <linux/module.h>
18#include <linux/init.h>
19#include <linux/interrupt.h>
20#include <linux/i2c.h>
21#include <linux/mutex.h>
22#include <linux/power_supply.h>
23#include <linux/power/smb347-charger.h>
24#include <linux/seq_file.h>
25
26/*
27 * Configuration registers. These are mirrored to volatile RAM and can be
28 * written once %CMD_A_ALLOW_WRITE is set in %CMD_A register. They will be
29 * reloaded from non-volatile registers after POR.
30 */
31#define CFG_CHARGE_CURRENT 0x00
32#define CFG_CHARGE_CURRENT_FCC_MASK 0xe0
33#define CFG_CHARGE_CURRENT_FCC_SHIFT 5
34#define CFG_CHARGE_CURRENT_PCC_MASK 0x18
35#define CFG_CHARGE_CURRENT_PCC_SHIFT 3
36#define CFG_CHARGE_CURRENT_TC_MASK 0x07
37#define CFG_CURRENT_LIMIT 0x01
38#define CFG_CURRENT_LIMIT_DC_MASK 0xf0
39#define CFG_CURRENT_LIMIT_DC_SHIFT 4
40#define CFG_CURRENT_LIMIT_USB_MASK 0x0f
41#define CFG_FLOAT_VOLTAGE 0x03
42#define CFG_FLOAT_VOLTAGE_THRESHOLD_MASK 0xc0
43#define CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT 6
44#define CFG_STAT 0x05
45#define CFG_STAT_DISABLED BIT(5)
46#define CFG_STAT_ACTIVE_HIGH BIT(7)
47#define CFG_PIN 0x06
48#define CFG_PIN_EN_CTRL_MASK 0x60
49#define CFG_PIN_EN_CTRL_ACTIVE_HIGH 0x40
50#define CFG_PIN_EN_CTRL_ACTIVE_LOW 0x60
51#define CFG_PIN_EN_APSD_IRQ BIT(1)
52#define CFG_PIN_EN_CHARGER_ERROR BIT(2)
53#define CFG_THERM 0x07
54#define CFG_THERM_SOFT_HOT_COMPENSATION_MASK 0x03
55#define CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT 0
56#define CFG_THERM_SOFT_COLD_COMPENSATION_MASK 0x0c
57#define CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT 2
58#define CFG_THERM_MONITOR_DISABLED BIT(4)
59#define CFG_SYSOK 0x08
60#define CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED BIT(2)
61#define CFG_OTHER 0x09
62#define CFG_OTHER_RID_MASK 0xc0
63#define CFG_OTHER_RID_ENABLED_AUTO_OTG 0xc0
64#define CFG_OTG 0x0a
65#define CFG_OTG_TEMP_THRESHOLD_MASK 0x30
66#define CFG_OTG_TEMP_THRESHOLD_SHIFT 4
67#define CFG_OTG_CC_COMPENSATION_MASK 0xc0
68#define CFG_OTG_CC_COMPENSATION_SHIFT 6
69#define CFG_TEMP_LIMIT 0x0b
70#define CFG_TEMP_LIMIT_SOFT_HOT_MASK 0x03
71#define CFG_TEMP_LIMIT_SOFT_HOT_SHIFT 0
72#define CFG_TEMP_LIMIT_SOFT_COLD_MASK 0x0c
73#define CFG_TEMP_LIMIT_SOFT_COLD_SHIFT 2
74#define CFG_TEMP_LIMIT_HARD_HOT_MASK 0x30
75#define CFG_TEMP_LIMIT_HARD_HOT_SHIFT 4
76#define CFG_TEMP_LIMIT_HARD_COLD_MASK 0xc0
77#define CFG_TEMP_LIMIT_HARD_COLD_SHIFT 6
78#define CFG_FAULT_IRQ 0x0c
79#define CFG_FAULT_IRQ_DCIN_UV BIT(2)
80#define CFG_STATUS_IRQ 0x0d
81#define CFG_STATUS_IRQ_TERMINATION_OR_TAPER BIT(4)
82#define CFG_ADDRESS 0x0e
83
84/* Command registers */
85#define CMD_A 0x30
86#define CMD_A_CHG_ENABLED BIT(1)
87#define CMD_A_SUSPEND_ENABLED BIT(2)
88#define CMD_A_ALLOW_WRITE BIT(7)
89#define CMD_B 0x31
90#define CMD_C 0x33
91
92/* Interrupt Status registers */
93#define IRQSTAT_A 0x35
94#define IRQSTAT_C 0x37
95#define IRQSTAT_C_TERMINATION_STAT BIT(0)
96#define IRQSTAT_C_TERMINATION_IRQ BIT(1)
97#define IRQSTAT_C_TAPER_IRQ BIT(3)
98#define IRQSTAT_E 0x39
99#define IRQSTAT_E_USBIN_UV_STAT BIT(0)
100#define IRQSTAT_E_USBIN_UV_IRQ BIT(1)
101#define IRQSTAT_E_DCIN_UV_STAT BIT(4)
102#define IRQSTAT_E_DCIN_UV_IRQ BIT(5)
103#define IRQSTAT_F 0x3a
104
105/* Status registers */
106#define STAT_A 0x3b
107#define STAT_A_FLOAT_VOLTAGE_MASK 0x3f
108#define STAT_B 0x3c
109#define STAT_C 0x3d
110#define STAT_C_CHG_ENABLED BIT(0)
111#define STAT_C_CHG_MASK 0x06
112#define STAT_C_CHG_SHIFT 1
113#define STAT_C_CHARGER_ERROR BIT(6)
114#define STAT_E 0x3f
115
116/**
117 * struct smb347_charger - smb347 charger instance
118 * @lock: protects concurrent access to online variables
119 * @client: pointer to i2c client
120 * @mains: power_supply instance for AC/DC power
121 * @usb: power_supply instance for USB power
122 * @battery: power_supply instance for battery
123 * @mains_online: is AC/DC input connected
124 * @usb_online: is USB input connected
125 * @charging_enabled: is charging enabled
126 * @dentry: for debugfs
127 * @pdata: pointer to platform data
128 */
129struct smb347_charger {
130 struct mutex lock;
131 struct i2c_client *client;
132 struct power_supply mains;
133 struct power_supply usb;
134 struct power_supply battery;
135 bool mains_online;
136 bool usb_online;
137 bool charging_enabled;
138 struct dentry *dentry;
139 const struct smb347_charger_platform_data *pdata;
140};
141
142/* Fast charge current in uA */
143static const unsigned int fcc_tbl[] = {
144 700000,
145 900000,
146 1200000,
147 1500000,
148 1800000,
149 2000000,
150 2200000,
151 2500000,
152};
153
154/* Pre-charge current in uA */
155static const unsigned int pcc_tbl[] = {
156 100000,
157 150000,
158 200000,
159 250000,
160};
161
162/* Termination current in uA */
163static const unsigned int tc_tbl[] = {
164 37500,
165 50000,
166 100000,
167 150000,
168 200000,
169 250000,
170 500000,
171 600000,
172};
173
174/* Input current limit in uA */
175static const unsigned int icl_tbl[] = {
176 300000,
177 500000,
178 700000,
179 900000,
180 1200000,
181 1500000,
182 1800000,
183 2000000,
184 2200000,
185 2500000,
186};
187
188/* Charge current compensation in uA */
189static const unsigned int ccc_tbl[] = {
190 250000,
191 700000,
192 900000,
193 1200000,
194};
195
196/* Convert register value to current using lookup table */
197static int hw_to_current(const unsigned int *tbl, size_t size, unsigned int val)
198{
199 if (val >= size)
200 return -EINVAL;
201 return tbl[val];
202}
203
204/* Convert current to register value using lookup table */
205static int current_to_hw(const unsigned int *tbl, size_t size, unsigned int val)
206{
207 size_t i;
208
209 for (i = 0; i < size; i++)
210 if (val < tbl[i])
211 break;
212 return i > 0 ? i - 1 : -EINVAL;
213}
214
215static int smb347_read(struct smb347_charger *smb, u8 reg)
216{
217 int ret;
218
219 ret = i2c_smbus_read_byte_data(smb->client, reg);
220 if (ret < 0)
221 dev_warn(&smb->client->dev, "failed to read reg 0x%x: %d\n",
222 reg, ret);
223 return ret;
224}
225
226static int smb347_write(struct smb347_charger *smb, u8 reg, u8 val)
227{
228 int ret;
229
230 ret = i2c_smbus_write_byte_data(smb->client, reg, val);
231 if (ret < 0)
232 dev_warn(&smb->client->dev, "failed to write reg 0x%x: %d\n",
233 reg, ret);
234 return ret;
235}
236
237/**
238 * smb347_update_status - updates the charging status
239 * @smb: pointer to smb347 charger instance
240 *
241 * Function checks status of the charging and updates internal state
242 * accordingly. Returns %0 if there is no change in status, %1 if the
243 * status has changed and negative errno in case of failure.
244 */
245static int smb347_update_status(struct smb347_charger *smb)
246{
247 bool usb = false;
248 bool dc = false;
249 int ret;
250
251 ret = smb347_read(smb, IRQSTAT_E);
252 if (ret < 0)
253 return ret;
254
255 /*
256 * Dc and usb are set depending on whether they are enabled in
257 * platform data _and_ whether corresponding undervoltage is set.
258 */
259 if (smb->pdata->use_mains)
260 dc = !(ret & IRQSTAT_E_DCIN_UV_STAT);
261 if (smb->pdata->use_usb)
262 usb = !(ret & IRQSTAT_E_USBIN_UV_STAT);
263
264 mutex_lock(&smb->lock);
265 ret = smb->mains_online != dc || smb->usb_online != usb;
266 smb->mains_online = dc;
267 smb->usb_online = usb;
268 mutex_unlock(&smb->lock);
269
270 return ret;
271}
272
273/*
274 * smb347_is_online - returns whether input power source is connected
275 * @smb: pointer to smb347 charger instance
276 *
277 * Returns %true if input power source is connected. Note that this is
278 * dependent on what platform has configured for usable power sources. For
279 * example if USB is disabled, this will return %false even if the USB
280 * cable is connected.
281 */
282static bool smb347_is_online(struct smb347_charger *smb)
283{
284 bool ret;
285
286 mutex_lock(&smb->lock);
287 ret = smb->usb_online || smb->mains_online;
288 mutex_unlock(&smb->lock);
289
290 return ret;
291}
292
293/**
294 * smb347_charging_status - returns status of charging
295 * @smb: pointer to smb347 charger instance
296 *
297 * Function returns charging status. %0 means no charging is in progress,
298 * %1 means pre-charging, %2 fast-charging and %3 taper-charging.
299 */
300static int smb347_charging_status(struct smb347_charger *smb)
301{
302 int ret;
303
304 if (!smb347_is_online(smb))
305 return 0;
306
307 ret = smb347_read(smb, STAT_C);
308 if (ret < 0)
309 return 0;
310
311 return (ret & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT;
312}
313
314static int smb347_charging_set(struct smb347_charger *smb, bool enable)
315{
316 int ret = 0;
317
318 if (smb->pdata->enable_control != SMB347_CHG_ENABLE_SW) {
319 dev_dbg(&smb->client->dev,
320 "charging enable/disable in SW disabled\n");
321 return 0;
322 }
323
324 mutex_lock(&smb->lock);
325 if (smb->charging_enabled != enable) {
326 ret = smb347_read(smb, CMD_A);
327 if (ret < 0)
328 goto out;
329
330 smb->charging_enabled = enable;
331
332 if (enable)
333 ret |= CMD_A_CHG_ENABLED;
334 else
335 ret &= ~CMD_A_CHG_ENABLED;
336
337 ret = smb347_write(smb, CMD_A, ret);
338 }
339out:
340 mutex_unlock(&smb->lock);
341 return ret;
342}
343
344static inline int smb347_charging_enable(struct smb347_charger *smb)
345{
346 return smb347_charging_set(smb, true);
347}
348
349static inline int smb347_charging_disable(struct smb347_charger *smb)
350{
351 return smb347_charging_set(smb, false);
352}
353
354static int smb347_update_online(struct smb347_charger *smb)
355{
356 int ret;
357
358 /*
359 * Depending on whether valid power source is connected or not, we
360 * disable or enable the charging. We do it manually because it
361 * depends on how the platform has configured the valid inputs.
362 */
363 if (smb347_is_online(smb)) {
364 ret = smb347_charging_enable(smb);
365 if (ret < 0)
366 dev_err(&smb->client->dev,
367 "failed to enable charging\n");
368 } else {
369 ret = smb347_charging_disable(smb);
370 if (ret < 0)
371 dev_err(&smb->client->dev,
372 "failed to disable charging\n");
373 }
374
375 return ret;
376}
377
378static int smb347_set_charge_current(struct smb347_charger *smb)
379{
380 int ret, val;
381
382 ret = smb347_read(smb, CFG_CHARGE_CURRENT);
383 if (ret < 0)
384 return ret;
385
386 if (smb->pdata->max_charge_current) {
387 val = current_to_hw(fcc_tbl, ARRAY_SIZE(fcc_tbl),
388 smb->pdata->max_charge_current);
389 if (val < 0)
390 return val;
391
392 ret &= ~CFG_CHARGE_CURRENT_FCC_MASK;
393 ret |= val << CFG_CHARGE_CURRENT_FCC_SHIFT;
394 }
395
396 if (smb->pdata->pre_charge_current) {
397 val = current_to_hw(pcc_tbl, ARRAY_SIZE(pcc_tbl),
398 smb->pdata->pre_charge_current);
399 if (val < 0)
400 return val;
401
402 ret &= ~CFG_CHARGE_CURRENT_PCC_MASK;
403 ret |= val << CFG_CHARGE_CURRENT_PCC_SHIFT;
404 }
405
406 if (smb->pdata->termination_current) {
407 val = current_to_hw(tc_tbl, ARRAY_SIZE(tc_tbl),
408 smb->pdata->termination_current);
409 if (val < 0)
410 return val;
411
412 ret &= ~CFG_CHARGE_CURRENT_TC_MASK;
413 ret |= val;
414 }
415
416 return smb347_write(smb, CFG_CHARGE_CURRENT, ret);
417}
418
419static int smb347_set_current_limits(struct smb347_charger *smb)
420{
421 int ret, val;
422
423 ret = smb347_read(smb, CFG_CURRENT_LIMIT);
424 if (ret < 0)
425 return ret;
426
427 if (smb->pdata->mains_current_limit) {
428 val = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
429 smb->pdata->mains_current_limit);
430 if (val < 0)
431 return val;
432
433 ret &= ~CFG_CURRENT_LIMIT_DC_MASK;
434 ret |= val << CFG_CURRENT_LIMIT_DC_SHIFT;
435 }
436
437 if (smb->pdata->usb_hc_current_limit) {
438 val = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
439 smb->pdata->usb_hc_current_limit);
440 if (val < 0)
441 return val;
442
443 ret &= ~CFG_CURRENT_LIMIT_USB_MASK;
444 ret |= val;
445 }
446
447 return smb347_write(smb, CFG_CURRENT_LIMIT, ret);
448}
449
450static int smb347_set_voltage_limits(struct smb347_charger *smb)
451{
452 int ret, val;
453
454 ret = smb347_read(smb, CFG_FLOAT_VOLTAGE);
455 if (ret < 0)
456 return ret;
457
458 if (smb->pdata->pre_to_fast_voltage) {
459 val = smb->pdata->pre_to_fast_voltage;
460
461 /* uV */
462 val = clamp_val(val, 2400000, 3000000) - 2400000;
463 val /= 200000;
464
465 ret &= ~CFG_FLOAT_VOLTAGE_THRESHOLD_MASK;
466 ret |= val << CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT;
467 }
468
469 if (smb->pdata->max_charge_voltage) {
470 val = smb->pdata->max_charge_voltage;
471
472 /* uV */
473 val = clamp_val(val, 3500000, 4500000) - 3500000;
474 val /= 20000;
475
476 ret |= val;
477 }
478
479 return smb347_write(smb, CFG_FLOAT_VOLTAGE, ret);
480}
481
482static int smb347_set_temp_limits(struct smb347_charger *smb)
483{
484 bool enable_therm_monitor = false;
485 int ret, val;
486
487 if (smb->pdata->chip_temp_threshold) {
488 val = smb->pdata->chip_temp_threshold;
489
490 /* degree C */
491 val = clamp_val(val, 100, 130) - 100;
492 val /= 10;
493
494 ret = smb347_read(smb, CFG_OTG);
495 if (ret < 0)
496 return ret;
497
498 ret &= ~CFG_OTG_TEMP_THRESHOLD_MASK;
499 ret |= val << CFG_OTG_TEMP_THRESHOLD_SHIFT;
500
501 ret = smb347_write(smb, CFG_OTG, ret);
502 if (ret < 0)
503 return ret;
504 }
505
506 ret = smb347_read(smb, CFG_TEMP_LIMIT);
507 if (ret < 0)
508 return ret;
509
510 if (smb->pdata->soft_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
511 val = smb->pdata->soft_cold_temp_limit;
512
513 val = clamp_val(val, 0, 15);
514 val /= 5;
515 /* this goes from higher to lower so invert the value */
516 val = ~val & 0x3;
517
518 ret &= ~CFG_TEMP_LIMIT_SOFT_COLD_MASK;
519 ret |= val << CFG_TEMP_LIMIT_SOFT_COLD_SHIFT;
520
521 enable_therm_monitor = true;
522 }
523
524 if (smb->pdata->soft_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
525 val = smb->pdata->soft_hot_temp_limit;
526
527 val = clamp_val(val, 40, 55) - 40;
528 val /= 5;
529
530 ret &= ~CFG_TEMP_LIMIT_SOFT_HOT_MASK;
531 ret |= val << CFG_TEMP_LIMIT_SOFT_HOT_SHIFT;
532
533 enable_therm_monitor = true;
534 }
535
536 if (smb->pdata->hard_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
537 val = smb->pdata->hard_cold_temp_limit;
538
539 val = clamp_val(val, -5, 10) + 5;
540 val /= 5;
541 /* this goes from higher to lower so invert the value */
542 val = ~val & 0x3;
543
544 ret &= ~CFG_TEMP_LIMIT_HARD_COLD_MASK;
545 ret |= val << CFG_TEMP_LIMIT_HARD_COLD_SHIFT;
546
547 enable_therm_monitor = true;
548 }
549
550 if (smb->pdata->hard_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
551 val = smb->pdata->hard_hot_temp_limit;
552
553 val = clamp_val(val, 50, 65) - 50;
554 val /= 5;
555
556 ret &= ~CFG_TEMP_LIMIT_HARD_HOT_MASK;
557 ret |= val << CFG_TEMP_LIMIT_HARD_HOT_SHIFT;
558
559 enable_therm_monitor = true;
560 }
561
562 ret = smb347_write(smb, CFG_TEMP_LIMIT, ret);
563 if (ret < 0)
564 return ret;
565
566 /*
567 * If any of the temperature limits are set, we also enable the
568 * thermistor monitoring.
569 *
570 * When soft limits are hit, the device will start to compensate
571 * current and/or voltage depending on the configuration.
572 *
573 * When hard limit is hit, the device will suspend charging
574 * depending on the configuration.
575 */
576 if (enable_therm_monitor) {
577 ret = smb347_read(smb, CFG_THERM);
578 if (ret < 0)
579 return ret;
580
581 ret &= ~CFG_THERM_MONITOR_DISABLED;
582
583 ret = smb347_write(smb, CFG_THERM, ret);
584 if (ret < 0)
585 return ret;
586 }
587
588 if (smb->pdata->suspend_on_hard_temp_limit) {
589 ret = smb347_read(smb, CFG_SYSOK);
590 if (ret < 0)
591 return ret;
592
593 ret &= ~CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED;
594
595 ret = smb347_write(smb, CFG_SYSOK, ret);
596 if (ret < 0)
597 return ret;
598 }
599
600 if (smb->pdata->soft_temp_limit_compensation !=
601 SMB347_SOFT_TEMP_COMPENSATE_DEFAULT) {
602 val = smb->pdata->soft_temp_limit_compensation & 0x3;
603
604 ret = smb347_read(smb, CFG_THERM);
605 if (ret < 0)
606 return ret;
607
608 ret &= ~CFG_THERM_SOFT_HOT_COMPENSATION_MASK;
609 ret |= val << CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT;
610
611 ret &= ~CFG_THERM_SOFT_COLD_COMPENSATION_MASK;
612 ret |= val << CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT;
613
614 ret = smb347_write(smb, CFG_THERM, ret);
615 if (ret < 0)
616 return ret;
617 }
618
619 if (smb->pdata->charge_current_compensation) {
620 val = current_to_hw(ccc_tbl, ARRAY_SIZE(ccc_tbl),
621 smb->pdata->charge_current_compensation);
622 if (val < 0)
623 return val;
624
625 ret = smb347_read(smb, CFG_OTG);
626 if (ret < 0)
627 return ret;
628
629 ret &= ~CFG_OTG_CC_COMPENSATION_MASK;
630 ret |= (val & 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT;
631
632 ret = smb347_write(smb, CFG_OTG, ret);
633 if (ret < 0)
634 return ret;
635 }
636
637 return ret;
638}
639
640/*
641 * smb347_set_writable - enables/disables writing to non-volatile registers
642 * @smb: pointer to smb347 charger instance
643 *
644 * You can enable/disable writing to the non-volatile configuration
645 * registers by calling this function.
646 *
647 * Returns %0 on success and negative errno in case of failure.
648 */
649static int smb347_set_writable(struct smb347_charger *smb, bool writable)
650{
651 int ret;
652
653 ret = smb347_read(smb, CMD_A);
654 if (ret < 0)
655 return ret;
656
657 if (writable)
658 ret |= CMD_A_ALLOW_WRITE;
659 else
660 ret &= ~CMD_A_ALLOW_WRITE;
661
662 return smb347_write(smb, CMD_A, ret);
663}
664
665static int smb347_hw_init(struct smb347_charger *smb)
666{
667 int ret;
668
669 ret = smb347_set_writable(smb, true);
670 if (ret < 0)
671 return ret;
672
673 /*
674 * Program the platform specific configuration values to the device
675 * first.
676 */
677 ret = smb347_set_charge_current(smb);
678 if (ret < 0)
679 goto fail;
680
681 ret = smb347_set_current_limits(smb);
682 if (ret < 0)
683 goto fail;
684
685 ret = smb347_set_voltage_limits(smb);
686 if (ret < 0)
687 goto fail;
688
689 ret = smb347_set_temp_limits(smb);
690 if (ret < 0)
691 goto fail;
692
693 /* If USB charging is disabled we put the USB in suspend mode */
694 if (!smb->pdata->use_usb) {
695 ret = smb347_read(smb, CMD_A);
696 if (ret < 0)
697 goto fail;
698
699 ret |= CMD_A_SUSPEND_ENABLED;
700
701 ret = smb347_write(smb, CMD_A, ret);
702 if (ret < 0)
703 goto fail;
704 }
705
706 ret = smb347_read(smb, CFG_OTHER);
707 if (ret < 0)
708 goto fail;
709
710 /*
711 * If configured by platform data, we enable hardware Auto-OTG
712 * support for driving VBUS. Otherwise we disable it.
713 */
714 ret &= ~CFG_OTHER_RID_MASK;
715 if (smb->pdata->use_usb_otg)
716 ret |= CFG_OTHER_RID_ENABLED_AUTO_OTG;
717
718 ret = smb347_write(smb, CFG_OTHER, ret);
719 if (ret < 0)
720 goto fail;
721
722 ret = smb347_read(smb, CFG_PIN);
723 if (ret < 0)
724 goto fail;
725
726 /*
727 * Make the charging functionality controllable by a write to the
728 * command register unless pin control is specified in the platform
729 * data.
730 */
731 ret &= ~CFG_PIN_EN_CTRL_MASK;
732
733 switch (smb->pdata->enable_control) {
734 case SMB347_CHG_ENABLE_SW:
735 /* Do nothing, 0 means i2c control */
736 break;
737 case SMB347_CHG_ENABLE_PIN_ACTIVE_LOW:
738 ret |= CFG_PIN_EN_CTRL_ACTIVE_LOW;
739 break;
740 case SMB347_CHG_ENABLE_PIN_ACTIVE_HIGH:
741 ret |= CFG_PIN_EN_CTRL_ACTIVE_HIGH;
742 break;
743 }
744
745 /* Disable Automatic Power Source Detection (APSD) interrupt. */
746 ret &= ~CFG_PIN_EN_APSD_IRQ;
747
748 ret = smb347_write(smb, CFG_PIN, ret);
749 if (ret < 0)
750 goto fail;
751
752 ret = smb347_update_status(smb);
753 if (ret < 0)
754 goto fail;
755
756 ret = smb347_update_online(smb);
757
758fail:
759 smb347_set_writable(smb, false);
760 return ret;
761}
762
763static irqreturn_t smb347_interrupt(int irq, void *data)
764{
765 struct smb347_charger *smb = data;
766 int stat_c, irqstat_e, irqstat_c;
767 irqreturn_t ret = IRQ_NONE;
768
769 stat_c = smb347_read(smb, STAT_C);
770 if (stat_c < 0) {
771 dev_warn(&smb->client->dev, "reading STAT_C failed\n");
772 return IRQ_NONE;
773 }
774
775 irqstat_c = smb347_read(smb, IRQSTAT_C);
776 if (irqstat_c < 0) {
777 dev_warn(&smb->client->dev, "reading IRQSTAT_C failed\n");
778 return IRQ_NONE;
779 }
780
781 irqstat_e = smb347_read(smb, IRQSTAT_E);
782 if (irqstat_e < 0) {
783 dev_warn(&smb->client->dev, "reading IRQSTAT_E failed\n");
784 return IRQ_NONE;
785 }
786
787 /*
788 * If we get charger error we report the error back to user and
789 * disable charging.
790 */
791 if (stat_c & STAT_C_CHARGER_ERROR) {
792 dev_err(&smb->client->dev,
793 "error in charger, disabling charging\n");
794
795 smb347_charging_disable(smb);
796 power_supply_changed(&smb->battery);
797
798 ret = IRQ_HANDLED;
799 }
800
801 /*
802 * If we reached the termination current the battery is charged and
803 * we can update the status now. Charging is automatically
804 * disabled by the hardware.
805 */
806 if (irqstat_c & (IRQSTAT_C_TERMINATION_IRQ | IRQSTAT_C_TAPER_IRQ)) {
807 if (irqstat_c & IRQSTAT_C_TERMINATION_STAT)
808 power_supply_changed(&smb->battery);
809 ret = IRQ_HANDLED;
810 }
811
812 /*
813 * If we got an under voltage interrupt it means that AC/USB input
814 * was connected or disconnected.
815 */
816 if (irqstat_e & (IRQSTAT_E_USBIN_UV_IRQ | IRQSTAT_E_DCIN_UV_IRQ)) {
817 if (smb347_update_status(smb) > 0) {
818 smb347_update_online(smb);
e6fe3597
RP		 819 if (smb->pdata->use_mains)
820 power_supply_changed(&smb->mains);
821 if (smb->pdata->use_usb)
822 power_supply_changed(&smb->usb);
ed1a230f
BR		 823 }
824 ret = IRQ_HANDLED;
825 }
826
827 return ret;
828}
829
830static int smb347_irq_set(struct smb347_charger *smb, bool enable)
831{
832 int ret;
833
834 ret = smb347_set_writable(smb, true);
835 if (ret < 0)
836 return ret;
837
838 /*
839 * Enable/disable interrupts for:
840 * - under voltage
841 * - termination current reached
842 * - charger error
843 */
844 if (enable) {
845 ret = smb347_write(smb, CFG_FAULT_IRQ, CFG_FAULT_IRQ_DCIN_UV);
846 if (ret < 0)
847 goto fail;
848
849 ret = smb347_write(smb, CFG_STATUS_IRQ,
850 CFG_STATUS_IRQ_TERMINATION_OR_TAPER);
851 if (ret < 0)
852 goto fail;
853
854 ret = smb347_read(smb, CFG_PIN);
855 if (ret < 0)
856 goto fail;
857
858 ret |= CFG_PIN_EN_CHARGER_ERROR;
859
860 ret = smb347_write(smb, CFG_PIN, ret);
861 } else {
862 ret = smb347_write(smb, CFG_FAULT_IRQ, 0);
863 if (ret < 0)
864 goto fail;
865
866 ret = smb347_write(smb, CFG_STATUS_IRQ, 0);
867 if (ret < 0)
868 goto fail;
869
870 ret = smb347_read(smb, CFG_PIN);
871 if (ret < 0)
872 goto fail;
873
874 ret &= ~CFG_PIN_EN_CHARGER_ERROR;
875
876 ret = smb347_write(smb, CFG_PIN, ret);
877 }
878
879fail:
880 smb347_set_writable(smb, false);
881 return ret;
882}
883
884static inline int smb347_irq_enable(struct smb347_charger *smb)
885{
886 return smb347_irq_set(smb, true);
887}
888
889static inline int smb347_irq_disable(struct smb347_charger *smb)
890{
891 return smb347_irq_set(smb, false);
892}
893
894static int smb347_irq_init(struct smb347_charger *smb)
895{
896 const struct smb347_charger_platform_data *pdata = smb->pdata;
897 int ret, irq = gpio_to_irq(pdata->irq_gpio);
898
899 ret = gpio_request_one(pdata->irq_gpio, GPIOF_IN, smb->client->name);
900 if (ret < 0)
901 goto fail;
902
903 ret = request_threaded_irq(irq, NULL, smb347_interrupt,
904 IRQF_TRIGGER_FALLING, smb->client->name,
905 smb);
906 if (ret < 0)
907 goto fail_gpio;
908
909 ret = smb347_set_writable(smb, true);
910 if (ret < 0)
911 goto fail_irq;
912
913 /*
914 * Configure the STAT output to be suitable for interrupts: disable
915 * all other output (except interrupts) and make it active low.
916 */
917 ret = smb347_read(smb, CFG_STAT);
918 if (ret < 0)
919 goto fail_readonly;
920
921 ret &= ~CFG_STAT_ACTIVE_HIGH;
922 ret |= CFG_STAT_DISABLED;
923
924 ret = smb347_write(smb, CFG_STAT, ret);
925 if (ret < 0)
926 goto fail_readonly;
927
928 ret = smb347_irq_enable(smb);
929 if (ret < 0)
930 goto fail_readonly;
931
932 smb347_set_writable(smb, false);
933 smb->client->irq = irq;
934 return 0;
935
936fail_readonly:
937 smb347_set_writable(smb, false);
938fail_irq:
939 free_irq(irq, smb);
940fail_gpio:
941 gpio_free(pdata->irq_gpio);
942fail:
943 smb->client->irq = 0;
944 return ret;
945}
946
947static int smb347_mains_get_property(struct power_supply *psy,
948 enum power_supply_property prop,
949 union power_supply_propval *val)
950{
951 struct smb347_charger *smb =
952 container_of(psy, struct smb347_charger, mains);
953
954 if (prop == POWER_SUPPLY_PROP_ONLINE) {
955 val->intval = smb->mains_online;
956 return 0;
957 }
958 return -EINVAL;
959}
960
961static enum power_supply_property smb347_mains_properties[] = {
962 POWER_SUPPLY_PROP_ONLINE,
963};
964
965static int smb347_usb_get_property(struct power_supply *psy,
966 enum power_supply_property prop,
967 union power_supply_propval *val)
968{
969 struct smb347_charger *smb =
970 container_of(psy, struct smb347_charger, usb);
971
972 if (prop == POWER_SUPPLY_PROP_ONLINE) {
973 val->intval = smb->usb_online;
974 return 0;
975 }
976 return -EINVAL;
977}
978
979static enum power_supply_property smb347_usb_properties[] = {
980 POWER_SUPPLY_PROP_ONLINE,
981};
982
983static int smb347_battery_get_property(struct power_supply *psy,
984 enum power_supply_property prop,
985 union power_supply_propval *val)
986{
987 struct smb347_charger *smb =
988 container_of(psy, struct smb347_charger, battery);
989 const struct smb347_charger_platform_data *pdata = smb->pdata;
990 int ret;
991
992 ret = smb347_update_status(smb);
993 if (ret < 0)
994 return ret;
995
996 switch (prop) {
997 case POWER_SUPPLY_PROP_STATUS:
998 if (!smb347_is_online(smb)) {
999 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1000 break;
1001 }
1002 if (smb347_charging_status(smb))
1003 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1004 else
1005 val->intval = POWER_SUPPLY_STATUS_FULL;
1006 break;
1007
1008 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1009 if (!smb347_is_online(smb))
1010 return -ENODATA;
1011
1012 /*
1013 * We handle trickle and pre-charging the same, and taper
1014 * and none the same.
1015 */
1016 switch (smb347_charging_status(smb)) {
1017 case 1:
1018 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1019 break;
1020 case 2:
1021 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1022 break;
1023 default:
1024 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1025 break;
1026 }
1027 break;
1028
1029 case POWER_SUPPLY_PROP_TECHNOLOGY:
1030 val->intval = pdata->battery_info.technology;
1031 break;
1032
1033 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1034 val->intval = pdata->battery_info.voltage_min_design;
1035 break;
1036
1037 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
1038 val->intval = pdata->battery_info.voltage_max_design;
1039 break;
1040
1041 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1042 if (!smb347_is_online(smb))
1043 return -ENODATA;
1044 ret = smb347_read(smb, STAT_A);
1045 if (ret < 0)
1046 return ret;
1047
1048 ret &= STAT_A_FLOAT_VOLTAGE_MASK;
1049 if (ret > 0x3d)
1050 ret = 0x3d;
1051
1052 val->intval = 3500000 + ret * 20000;
1053 break;
1054
1055 case POWER_SUPPLY_PROP_CURRENT_NOW:
1056 if (!smb347_is_online(smb))
1057 return -ENODATA;
1058
1059 ret = smb347_read(smb, STAT_B);
1060 if (ret < 0)
1061 return ret;
1062
1063 /*
1064 * The current value is composition of FCC and PCC values
1065 * and we can detect which table to use from bit 5.
1066 */
1067 if (ret & 0x20) {
1068 val->intval = hw_to_current(fcc_tbl,
1069 ARRAY_SIZE(fcc_tbl),
1070 ret & 7);
1071 } else {
1072 ret >>= 3;
1073 val->intval = hw_to_current(pcc_tbl,
1074 ARRAY_SIZE(pcc_tbl),
1075 ret & 7);
1076 }
1077 break;
1078
1079 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
1080 val->intval = pdata->battery_info.charge_full_design;
1081 break;
1082
1083 case POWER_SUPPLY_PROP_MODEL_NAME:
1084 val->strval = pdata->battery_info.name;
1085 break;
1086
1087 default:
1088 return -EINVAL;
1089 }
1090
1091 return 0;
1092}
1093
1094static enum power_supply_property smb347_battery_properties[] = {
1095 POWER_SUPPLY_PROP_STATUS,
1096 POWER_SUPPLY_PROP_CHARGE_TYPE,
1097 POWER_SUPPLY_PROP_TECHNOLOGY,
1098 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
1099 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
1100 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1101 POWER_SUPPLY_PROP_CURRENT_NOW,
1102 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
1103 POWER_SUPPLY_PROP_MODEL_NAME,
1104};
1105
1106static int smb347_debugfs_show(struct seq_file *s, void *data)
1107{
1108 struct smb347_charger *smb = s->private;
1109 int ret;
1110 u8 reg;
1111
1112 seq_printf(s, "Control registers:\n");
1113 seq_printf(s, "==================\n");
1114 for (reg = CFG_CHARGE_CURRENT; reg <= CFG_ADDRESS; reg++) {
1115 ret = smb347_read(smb, reg);
1116 seq_printf(s, "0x%02x:\t0x%02x\n", reg, ret);
1117 }
1118 seq_printf(s, "\n");
1119
1120 seq_printf(s, "Command registers:\n");
1121 seq_printf(s, "==================\n");
1122 ret = smb347_read(smb, CMD_A);
1123 seq_printf(s, "0x%02x:\t0x%02x\n", CMD_A, ret);
1124 ret = smb347_read(smb, CMD_B);
1125 seq_printf(s, "0x%02x:\t0x%02x\n", CMD_B, ret);
1126 ret = smb347_read(smb, CMD_C);
1127 seq_printf(s, "0x%02x:\t0x%02x\n", CMD_C, ret);
1128 seq_printf(s, "\n");
1129
1130 seq_printf(s, "Interrupt status registers:\n");
1131 seq_printf(s, "===========================\n");
1132 for (reg = IRQSTAT_A; reg <= IRQSTAT_F; reg++) {
1133 ret = smb347_read(smb, reg);
1134 seq_printf(s, "0x%02x:\t0x%02x\n", reg, ret);
1135 }
1136 seq_printf(s, "\n");
1137
1138 seq_printf(s, "Status registers:\n");
1139 seq_printf(s, "=================\n");
1140 for (reg = STAT_A; reg <= STAT_E; reg++) {
1141 ret = smb347_read(smb, reg);
1142 seq_printf(s, "0x%02x:\t0x%02x\n", reg, ret);
1143 }
1144
1145 return 0;
1146}
1147
1148static int smb347_debugfs_open(struct inode *inode, struct file *file)
1149{
1150 return single_open(file, smb347_debugfs_show, inode->i_private);
1151}
1152
1153static const struct file_operations smb347_debugfs_fops = {
1154 .open = smb347_debugfs_open,
1155 .read = seq_read,
1156 .llseek = seq_lseek,
1157 .release = single_release,
1158};
1159
1160static int smb347_probe(struct i2c_client *client,
1161 const struct i2c_device_id *id)
1162{
1163 static char *battery[] = { "smb347-battery" };
1164 const struct smb347_charger_platform_data *pdata;
1165 struct device *dev = &client->dev;
1166 struct smb347_charger *smb;
1167 int ret;
1168
1169 pdata = dev->platform_data;
1170 if (!pdata)
1171 return -EINVAL;
1172
1173 if (!pdata->use_mains && !pdata->use_usb)
1174 return -EINVAL;
1175
1176 smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL);
1177 if (!smb)
1178 return -ENOMEM;
1179
1180 i2c_set_clientdata(client, smb);
1181
1182 mutex_init(&smb->lock);
1183 smb->client = client;
1184 smb->pdata = pdata;
1185
1186 ret = smb347_hw_init(smb);
1187 if (ret < 0)
1188 return ret;
1189
e6fe3597
RP		 1190 if (smb->pdata->use_mains) {
1191 smb->mains.name = "smb347-mains";
1192 smb->mains.type = POWER_SUPPLY_TYPE_MAINS;
1193 smb->mains.get_property = smb347_mains_get_property;
1194 smb->mains.properties = smb347_mains_properties;
1195 smb->mains.num_properties = ARRAY_SIZE(smb347_mains_properties);
1196 smb->mains.supplied_to = battery;
1197 smb->mains.num_supplicants = ARRAY_SIZE(battery);
1198 ret = power_supply_register(dev, &smb->mains);
1199 if (ret < 0)
1200 return ret;
1201 }
1202
1203 if (smb->pdata->use_usb) {
1204 smb->usb.name = "smb347-usb";
1205 smb->usb.type = POWER_SUPPLY_TYPE_USB;
1206 smb->usb.get_property = smb347_usb_get_property;
1207 smb->usb.properties = smb347_usb_properties;
1208 smb->usb.num_properties = ARRAY_SIZE(smb347_usb_properties);
1209 smb->usb.supplied_to = battery;
1210 smb->usb.num_supplicants = ARRAY_SIZE(battery);
1211 ret = power_supply_register(dev, &smb->usb);
1212 if (ret < 0) {
1213 if (smb->pdata->use_mains)
1214 power_supply_unregister(&smb->mains);
1215 return ret;
1216 }
1217 }
ed1a230f
BR		 1218
1219 smb->battery.name = "smb347-battery";
1220 smb->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1221 smb->battery.get_property = smb347_battery_get_property;
1222 smb->battery.properties = smb347_battery_properties;
1223 smb->battery.num_properties = ARRAY_SIZE(smb347_battery_properties);
1224
ed1a230f
BR		 1225
1226 ret = power_supply_register(dev, &smb->battery);
1227 if (ret < 0) {
e6fe3597
RP		 1228 if (smb->pdata->use_usb)
1229 power_supply_unregister(&smb->usb);
1230 if (smb->pdata->use_mains)
1231 power_supply_unregister(&smb->mains);
ed1a230f
BR		 1232 return ret;
1233 }
1234
1235 /*
1236 * Interrupt pin is optional. If it is connected, we setup the
1237 * interrupt support here.
1238 */
1239 if (pdata->irq_gpio >= 0) {
1240 ret = smb347_irq_init(smb);
1241 if (ret < 0) {
1242 dev_warn(dev, "failed to initialize IRQ: %d\n", ret);
1243 dev_warn(dev, "disabling IRQ support\n");
1244 }
1245 }
1246
1247 smb->dentry = debugfs_create_file("smb347-regs", S_IRUSR, NULL, smb,
1248 &smb347_debugfs_fops);
1249 return 0;
1250}
1251
1252static int smb347_remove(struct i2c_client *client)
1253{
1254 struct smb347_charger *smb = i2c_get_clientdata(client);
1255
1256 if (!IS_ERR_OR_NULL(smb->dentry))
1257 debugfs_remove(smb->dentry);
1258
1259 if (client->irq) {
1260 smb347_irq_disable(smb);
1261 free_irq(client->irq, smb);
1262 gpio_free(smb->pdata->irq_gpio);
1263 }
1264
1265 power_supply_unregister(&smb->battery);
e6fe3597
RP		 1266 if (smb->pdata->use_usb)
1267 power_supply_unregister(&smb->usb);
1268 if (smb->pdata->use_mains)
1269 power_supply_unregister(&smb->mains);
ed1a230f
BR		 1270 return 0;
1271}
1272
1273static const struct i2c_device_id smb347_id[] = {
1274 { "smb347", 0 },
1275 { }
1276};
1277MODULE_DEVICE_TABLE(i2c, smb347_id);
1278
1279static struct i2c_driver smb347_driver = {
1280 .driver = {
1281 .name = "smb347",
1282 },
1283 .probe = smb347_probe,
1284 .remove = __devexit_p(smb347_remove),
1285 .id_table = smb347_id,
1286};
1287
1288static int __init smb347_init(void)
1289{
1290 return i2c_add_driver(&smb347_driver);
1291}
1292module_init(smb347_init);
1293
1294static void __exit smb347_exit(void)
1295{
1296 i2c_del_driver(&smb347_driver);
1297}
1298module_exit(smb347_exit);
1299
1300MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>");
1301MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
1302MODULE_DESCRIPTION("SMB347 battery charger driver");
1303MODULE_LICENSE("GPL");
1304MODULE_ALIAS("i2c:smb347");
kernel source for telekom puls (alcatel/mediatek)