2 * Summit Microelectronics SMB347 Battery Charger Driver
4 * Copyright (C) 2011, Intel Corporation
6 * Authors: Bruce E. Robertson <bruce.e.robertson@intel.com>
7 * Mika Westerberg <mika.westerberg@linux.intel.com>
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.
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>
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.
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
45 #define CFG_STAT_DISABLED BIT(5)
46 #define CFG_STAT_ACTIVE_HIGH BIT(7)
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
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
84 /* Command registers */
86 #define CMD_A_CHG_ENABLED BIT(1)
87 #define CMD_A_SUSPEND_ENABLED BIT(2)
88 #define CMD_A_ALLOW_WRITE BIT(7)
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
105 /* Status registers */
107 #define STAT_A_FLOAT_VOLTAGE_MASK 0x3f
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)
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
129 struct smb347_charger
{
131 struct i2c_client
*client
;
132 struct power_supply mains
;
133 struct power_supply usb
;
134 struct power_supply battery
;
137 bool charging_enabled
;
138 struct dentry
*dentry
;
139 const struct smb347_charger_platform_data
*pdata
;
142 /* Fast charge current in uA */
143 static const unsigned int fcc_tbl
[] = {
154 /* Pre-charge current in uA */
155 static const unsigned int pcc_tbl
[] = {
162 /* Termination current in uA */
163 static const unsigned int tc_tbl
[] = {
174 /* Input current limit in uA */
175 static const unsigned int icl_tbl
[] = {
188 /* Charge current compensation in uA */
189 static const unsigned int ccc_tbl
[] = {
196 /* Convert register value to current using lookup table */
197 static int hw_to_current(const unsigned int *tbl
, size_t size
, unsigned int val
)
204 /* Convert current to register value using lookup table */
205 static int current_to_hw(const unsigned int *tbl
, size_t size
, unsigned int val
)
209 for (i
= 0; i
< size
; i
++)
212 return i
> 0 ? i
- 1 : -EINVAL
;
215 static int smb347_read(struct smb347_charger
*smb
, u8 reg
)
219 ret
= i2c_smbus_read_byte_data(smb
->client
, reg
);
221 dev_warn(&smb
->client
->dev
, "failed to read reg 0x%x: %d\n",
226 static int smb347_write(struct smb347_charger
*smb
, u8 reg
, u8 val
)
230 ret
= i2c_smbus_write_byte_data(smb
->client
, reg
, val
);
232 dev_warn(&smb
->client
->dev
, "failed to write reg 0x%x: %d\n",
238 * smb347_update_status - updates the charging status
239 * @smb: pointer to smb347 charger instance
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.
245 static int smb347_update_status(struct smb347_charger
*smb
)
251 ret
= smb347_read(smb
, IRQSTAT_E
);
256 * Dc and usb are set depending on whether they are enabled in
257 * platform data _and_ whether corresponding undervoltage is set.
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
);
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
);
274 * smb347_is_online - returns whether input power source is connected
275 * @smb: pointer to smb347 charger instance
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.
282 static bool smb347_is_online(struct smb347_charger
*smb
)
286 mutex_lock(&smb
->lock
);
287 ret
= smb
->usb_online
|| smb
->mains_online
;
288 mutex_unlock(&smb
->lock
);
294 * smb347_charging_status - returns status of charging
295 * @smb: pointer to smb347 charger instance
297 * Function returns charging status. %0 means no charging is in progress,
298 * %1 means pre-charging, %2 fast-charging and %3 taper-charging.
300 static int smb347_charging_status(struct smb347_charger
*smb
)
304 if (!smb347_is_online(smb
))
307 ret
= smb347_read(smb
, STAT_C
);
311 return (ret
& STAT_C_CHG_MASK
) >> STAT_C_CHG_SHIFT
;
314 static int smb347_charging_set(struct smb347_charger
*smb
, bool enable
)
318 if (smb
->pdata
->enable_control
!= SMB347_CHG_ENABLE_SW
) {
319 dev_dbg(&smb
->client
->dev
,
320 "charging enable/disable in SW disabled\n");
324 mutex_lock(&smb
->lock
);
325 if (smb
->charging_enabled
!= enable
) {
326 ret
= smb347_read(smb
, CMD_A
);
330 smb
->charging_enabled
= enable
;
333 ret
|= CMD_A_CHG_ENABLED
;
335 ret
&= ~CMD_A_CHG_ENABLED
;
337 ret
= smb347_write(smb
, CMD_A
, ret
);
340 mutex_unlock(&smb
->lock
);
344 static inline int smb347_charging_enable(struct smb347_charger
*smb
)
346 return smb347_charging_set(smb
, true);
349 static inline int smb347_charging_disable(struct smb347_charger
*smb
)
351 return smb347_charging_set(smb
, false);
354 static int smb347_update_online(struct smb347_charger
*smb
)
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.
363 if (smb347_is_online(smb
)) {
364 ret
= smb347_charging_enable(smb
);
366 dev_err(&smb
->client
->dev
,
367 "failed to enable charging\n");
369 ret
= smb347_charging_disable(smb
);
371 dev_err(&smb
->client
->dev
,
372 "failed to disable charging\n");
378 static int smb347_set_charge_current(struct smb347_charger
*smb
)
382 ret
= smb347_read(smb
, CFG_CHARGE_CURRENT
);
386 if (smb
->pdata
->max_charge_current
) {
387 val
= current_to_hw(fcc_tbl
, ARRAY_SIZE(fcc_tbl
),
388 smb
->pdata
->max_charge_current
);
392 ret
&= ~CFG_CHARGE_CURRENT_FCC_MASK
;
393 ret
|= val
<< CFG_CHARGE_CURRENT_FCC_SHIFT
;
396 if (smb
->pdata
->pre_charge_current
) {
397 val
= current_to_hw(pcc_tbl
, ARRAY_SIZE(pcc_tbl
),
398 smb
->pdata
->pre_charge_current
);
402 ret
&= ~CFG_CHARGE_CURRENT_PCC_MASK
;
403 ret
|= val
<< CFG_CHARGE_CURRENT_PCC_SHIFT
;
406 if (smb
->pdata
->termination_current
) {
407 val
= current_to_hw(tc_tbl
, ARRAY_SIZE(tc_tbl
),
408 smb
->pdata
->termination_current
);
412 ret
&= ~CFG_CHARGE_CURRENT_TC_MASK
;
416 return smb347_write(smb
, CFG_CHARGE_CURRENT
, ret
);
419 static int smb347_set_current_limits(struct smb347_charger
*smb
)
423 ret
= smb347_read(smb
, CFG_CURRENT_LIMIT
);
427 if (smb
->pdata
->mains_current_limit
) {
428 val
= current_to_hw(icl_tbl
, ARRAY_SIZE(icl_tbl
),
429 smb
->pdata
->mains_current_limit
);
433 ret
&= ~CFG_CURRENT_LIMIT_DC_MASK
;
434 ret
|= val
<< CFG_CURRENT_LIMIT_DC_SHIFT
;
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
);
443 ret
&= ~CFG_CURRENT_LIMIT_USB_MASK
;
447 return smb347_write(smb
, CFG_CURRENT_LIMIT
, ret
);
450 static int smb347_set_voltage_limits(struct smb347_charger
*smb
)
454 ret
= smb347_read(smb
, CFG_FLOAT_VOLTAGE
);
458 if (smb
->pdata
->pre_to_fast_voltage
) {
459 val
= smb
->pdata
->pre_to_fast_voltage
;
462 val
= clamp_val(val
, 2400000, 3000000) - 2400000;
465 ret
&= ~CFG_FLOAT_VOLTAGE_THRESHOLD_MASK
;
466 ret
|= val
<< CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT
;
469 if (smb
->pdata
->max_charge_voltage
) {
470 val
= smb
->pdata
->max_charge_voltage
;
473 val
= clamp_val(val
, 3500000, 4500000) - 3500000;
479 return smb347_write(smb
, CFG_FLOAT_VOLTAGE
, ret
);
482 static int smb347_set_temp_limits(struct smb347_charger
*smb
)
484 bool enable_therm_monitor
= false;
487 if (smb
->pdata
->chip_temp_threshold
) {
488 val
= smb
->pdata
->chip_temp_threshold
;
491 val
= clamp_val(val
, 100, 130) - 100;
494 ret
= smb347_read(smb
, CFG_OTG
);
498 ret
&= ~CFG_OTG_TEMP_THRESHOLD_MASK
;
499 ret
|= val
<< CFG_OTG_TEMP_THRESHOLD_SHIFT
;
501 ret
= smb347_write(smb
, CFG_OTG
, ret
);
506 ret
= smb347_read(smb
, CFG_TEMP_LIMIT
);
510 if (smb
->pdata
->soft_cold_temp_limit
!= SMB347_TEMP_USE_DEFAULT
) {
511 val
= smb
->pdata
->soft_cold_temp_limit
;
513 val
= clamp_val(val
, 0, 15);
515 /* this goes from higher to lower so invert the value */
518 ret
&= ~CFG_TEMP_LIMIT_SOFT_COLD_MASK
;
519 ret
|= val
<< CFG_TEMP_LIMIT_SOFT_COLD_SHIFT
;
521 enable_therm_monitor
= true;
524 if (smb
->pdata
->soft_hot_temp_limit
!= SMB347_TEMP_USE_DEFAULT
) {
525 val
= smb
->pdata
->soft_hot_temp_limit
;
527 val
= clamp_val(val
, 40, 55) - 40;
530 ret
&= ~CFG_TEMP_LIMIT_SOFT_HOT_MASK
;
531 ret
|= val
<< CFG_TEMP_LIMIT_SOFT_HOT_SHIFT
;
533 enable_therm_monitor
= true;
536 if (smb
->pdata
->hard_cold_temp_limit
!= SMB347_TEMP_USE_DEFAULT
) {
537 val
= smb
->pdata
->hard_cold_temp_limit
;
539 val
= clamp_val(val
, -5, 10) + 5;
541 /* this goes from higher to lower so invert the value */
544 ret
&= ~CFG_TEMP_LIMIT_HARD_COLD_MASK
;
545 ret
|= val
<< CFG_TEMP_LIMIT_HARD_COLD_SHIFT
;
547 enable_therm_monitor
= true;
550 if (smb
->pdata
->hard_hot_temp_limit
!= SMB347_TEMP_USE_DEFAULT
) {
551 val
= smb
->pdata
->hard_hot_temp_limit
;
553 val
= clamp_val(val
, 50, 65) - 50;
556 ret
&= ~CFG_TEMP_LIMIT_HARD_HOT_MASK
;
557 ret
|= val
<< CFG_TEMP_LIMIT_HARD_HOT_SHIFT
;
559 enable_therm_monitor
= true;
562 ret
= smb347_write(smb
, CFG_TEMP_LIMIT
, ret
);
567 * If any of the temperature limits are set, we also enable the
568 * thermistor monitoring.
570 * When soft limits are hit, the device will start to compensate
571 * current and/or voltage depending on the configuration.
573 * When hard limit is hit, the device will suspend charging
574 * depending on the configuration.
576 if (enable_therm_monitor
) {
577 ret
= smb347_read(smb
, CFG_THERM
);
581 ret
&= ~CFG_THERM_MONITOR_DISABLED
;
583 ret
= smb347_write(smb
, CFG_THERM
, ret
);
588 if (smb
->pdata
->suspend_on_hard_temp_limit
) {
589 ret
= smb347_read(smb
, CFG_SYSOK
);
593 ret
&= ~CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED
;
595 ret
= smb347_write(smb
, CFG_SYSOK
, ret
);
600 if (smb
->pdata
->soft_temp_limit_compensation
!=
601 SMB347_SOFT_TEMP_COMPENSATE_DEFAULT
) {
602 val
= smb
->pdata
->soft_temp_limit_compensation
& 0x3;
604 ret
= smb347_read(smb
, CFG_THERM
);
608 ret
&= ~CFG_THERM_SOFT_HOT_COMPENSATION_MASK
;
609 ret
|= val
<< CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT
;
611 ret
&= ~CFG_THERM_SOFT_COLD_COMPENSATION_MASK
;
612 ret
|= val
<< CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT
;
614 ret
= smb347_write(smb
, CFG_THERM
, ret
);
619 if (smb
->pdata
->charge_current_compensation
) {
620 val
= current_to_hw(ccc_tbl
, ARRAY_SIZE(ccc_tbl
),
621 smb
->pdata
->charge_current_compensation
);
625 ret
= smb347_read(smb
, CFG_OTG
);
629 ret
&= ~CFG_OTG_CC_COMPENSATION_MASK
;
630 ret
|= (val
& 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT
;
632 ret
= smb347_write(smb
, CFG_OTG
, ret
);
641 * smb347_set_writable - enables/disables writing to non-volatile registers
642 * @smb: pointer to smb347 charger instance
644 * You can enable/disable writing to the non-volatile configuration
645 * registers by calling this function.
647 * Returns %0 on success and negative errno in case of failure.
649 static int smb347_set_writable(struct smb347_charger
*smb
, bool writable
)
653 ret
= smb347_read(smb
, CMD_A
);
658 ret
|= CMD_A_ALLOW_WRITE
;
660 ret
&= ~CMD_A_ALLOW_WRITE
;
662 return smb347_write(smb
, CMD_A
, ret
);
665 static int smb347_hw_init(struct smb347_charger
*smb
)
669 ret
= smb347_set_writable(smb
, true);
674 * Program the platform specific configuration values to the device
677 ret
= smb347_set_charge_current(smb
);
681 ret
= smb347_set_current_limits(smb
);
685 ret
= smb347_set_voltage_limits(smb
);
689 ret
= smb347_set_temp_limits(smb
);
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
);
699 ret
|= CMD_A_SUSPEND_ENABLED
;
701 ret
= smb347_write(smb
, CMD_A
, ret
);
706 ret
= smb347_read(smb
, CFG_OTHER
);
711 * If configured by platform data, we enable hardware Auto-OTG
712 * support for driving VBUS. Otherwise we disable it.
714 ret
&= ~CFG_OTHER_RID_MASK
;
715 if (smb
->pdata
->use_usb_otg
)
716 ret
|= CFG_OTHER_RID_ENABLED_AUTO_OTG
;
718 ret
= smb347_write(smb
, CFG_OTHER
, ret
);
722 ret
= smb347_read(smb
, CFG_PIN
);
727 * Make the charging functionality controllable by a write to the
728 * command register unless pin control is specified in the platform
731 ret
&= ~CFG_PIN_EN_CTRL_MASK
;
733 switch (smb
->pdata
->enable_control
) {
734 case SMB347_CHG_ENABLE_SW
:
735 /* Do nothing, 0 means i2c control */
737 case SMB347_CHG_ENABLE_PIN_ACTIVE_LOW
:
738 ret
|= CFG_PIN_EN_CTRL_ACTIVE_LOW
;
740 case SMB347_CHG_ENABLE_PIN_ACTIVE_HIGH
:
741 ret
|= CFG_PIN_EN_CTRL_ACTIVE_HIGH
;
745 /* Disable Automatic Power Source Detection (APSD) interrupt. */
746 ret
&= ~CFG_PIN_EN_APSD_IRQ
;
748 ret
= smb347_write(smb
, CFG_PIN
, ret
);
752 ret
= smb347_update_status(smb
);
756 ret
= smb347_update_online(smb
);
759 smb347_set_writable(smb
, false);
763 static irqreturn_t
smb347_interrupt(int irq
, void *data
)
765 struct smb347_charger
*smb
= data
;
766 int stat_c
, irqstat_e
, irqstat_c
;
767 irqreturn_t ret
= IRQ_NONE
;
769 stat_c
= smb347_read(smb
, STAT_C
);
771 dev_warn(&smb
->client
->dev
, "reading STAT_C failed\n");
775 irqstat_c
= smb347_read(smb
, IRQSTAT_C
);
777 dev_warn(&smb
->client
->dev
, "reading IRQSTAT_C failed\n");
781 irqstat_e
= smb347_read(smb
, IRQSTAT_E
);
783 dev_warn(&smb
->client
->dev
, "reading IRQSTAT_E failed\n");
788 * If we get charger error we report the error back to user and
791 if (stat_c
& STAT_C_CHARGER_ERROR
) {
792 dev_err(&smb
->client
->dev
,
793 "error in charger, disabling charging\n");
795 smb347_charging_disable(smb
);
796 power_supply_changed(&smb
->battery
);
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.
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
);
813 * If we got an under voltage interrupt it means that AC/USB input
814 * was connected or disconnected.
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
);
819 power_supply_changed(&smb
->mains
);
820 power_supply_changed(&smb
->usb
);
828 static int smb347_irq_set(struct smb347_charger
*smb
, bool enable
)
832 ret
= smb347_set_writable(smb
, true);
837 * Enable/disable interrupts for:
839 * - termination current reached
843 ret
= smb347_write(smb
, CFG_FAULT_IRQ
, CFG_FAULT_IRQ_DCIN_UV
);
847 ret
= smb347_write(smb
, CFG_STATUS_IRQ
,
848 CFG_STATUS_IRQ_TERMINATION_OR_TAPER
);
852 ret
= smb347_read(smb
, CFG_PIN
);
856 ret
|= CFG_PIN_EN_CHARGER_ERROR
;
858 ret
= smb347_write(smb
, CFG_PIN
, ret
);
860 ret
= smb347_write(smb
, CFG_FAULT_IRQ
, 0);
864 ret
= smb347_write(smb
, CFG_STATUS_IRQ
, 0);
868 ret
= smb347_read(smb
, CFG_PIN
);
872 ret
&= ~CFG_PIN_EN_CHARGER_ERROR
;
874 ret
= smb347_write(smb
, CFG_PIN
, ret
);
878 smb347_set_writable(smb
, false);
882 static inline int smb347_irq_enable(struct smb347_charger
*smb
)
884 return smb347_irq_set(smb
, true);
887 static inline int smb347_irq_disable(struct smb347_charger
*smb
)
889 return smb347_irq_set(smb
, false);
892 static int smb347_irq_init(struct smb347_charger
*smb
)
894 const struct smb347_charger_platform_data
*pdata
= smb
->pdata
;
895 int ret
, irq
= gpio_to_irq(pdata
->irq_gpio
);
897 ret
= gpio_request_one(pdata
->irq_gpio
, GPIOF_IN
, smb
->client
->name
);
901 ret
= request_threaded_irq(irq
, NULL
, smb347_interrupt
,
902 IRQF_TRIGGER_FALLING
, smb
->client
->name
,
907 ret
= smb347_set_writable(smb
, true);
912 * Configure the STAT output to be suitable for interrupts: disable
913 * all other output (except interrupts) and make it active low.
915 ret
= smb347_read(smb
, CFG_STAT
);
919 ret
&= ~CFG_STAT_ACTIVE_HIGH
;
920 ret
|= CFG_STAT_DISABLED
;
922 ret
= smb347_write(smb
, CFG_STAT
, ret
);
926 ret
= smb347_irq_enable(smb
);
930 smb347_set_writable(smb
, false);
931 smb
->client
->irq
= irq
;
935 smb347_set_writable(smb
, false);
939 gpio_free(pdata
->irq_gpio
);
941 smb
->client
->irq
= 0;
945 static int smb347_mains_get_property(struct power_supply
*psy
,
946 enum power_supply_property prop
,
947 union power_supply_propval
*val
)
949 struct smb347_charger
*smb
=
950 container_of(psy
, struct smb347_charger
, mains
);
952 if (prop
== POWER_SUPPLY_PROP_ONLINE
) {
953 val
->intval
= smb
->mains_online
;
959 static enum power_supply_property smb347_mains_properties
[] = {
960 POWER_SUPPLY_PROP_ONLINE
,
963 static int smb347_usb_get_property(struct power_supply
*psy
,
964 enum power_supply_property prop
,
965 union power_supply_propval
*val
)
967 struct smb347_charger
*smb
=
968 container_of(psy
, struct smb347_charger
, usb
);
970 if (prop
== POWER_SUPPLY_PROP_ONLINE
) {
971 val
->intval
= smb
->usb_online
;
977 static enum power_supply_property smb347_usb_properties
[] = {
978 POWER_SUPPLY_PROP_ONLINE
,
981 static int smb347_battery_get_property(struct power_supply
*psy
,
982 enum power_supply_property prop
,
983 union power_supply_propval
*val
)
985 struct smb347_charger
*smb
=
986 container_of(psy
, struct smb347_charger
, battery
);
987 const struct smb347_charger_platform_data
*pdata
= smb
->pdata
;
990 ret
= smb347_update_status(smb
);
995 case POWER_SUPPLY_PROP_STATUS
:
996 if (!smb347_is_online(smb
)) {
997 val
->intval
= POWER_SUPPLY_STATUS_DISCHARGING
;
1000 if (smb347_charging_status(smb
))
1001 val
->intval
= POWER_SUPPLY_STATUS_CHARGING
;
1003 val
->intval
= POWER_SUPPLY_STATUS_FULL
;
1006 case POWER_SUPPLY_PROP_CHARGE_TYPE
:
1007 if (!smb347_is_online(smb
))
1011 * We handle trickle and pre-charging the same, and taper
1012 * and none the same.
1014 switch (smb347_charging_status(smb
)) {
1016 val
->intval
= POWER_SUPPLY_CHARGE_TYPE_TRICKLE
;
1019 val
->intval
= POWER_SUPPLY_CHARGE_TYPE_FAST
;
1022 val
->intval
= POWER_SUPPLY_CHARGE_TYPE_NONE
;
1027 case POWER_SUPPLY_PROP_TECHNOLOGY
:
1028 val
->intval
= pdata
->battery_info
.technology
;
1031 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
:
1032 val
->intval
= pdata
->battery_info
.voltage_min_design
;
1035 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
:
1036 val
->intval
= pdata
->battery_info
.voltage_max_design
;
1039 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
1040 if (!smb347_is_online(smb
))
1042 ret
= smb347_read(smb
, STAT_A
);
1046 ret
&= STAT_A_FLOAT_VOLTAGE_MASK
;
1050 val
->intval
= 3500000 + ret
* 20000;
1053 case POWER_SUPPLY_PROP_CURRENT_NOW
:
1054 if (!smb347_is_online(smb
))
1057 ret
= smb347_read(smb
, STAT_B
);
1062 * The current value is composition of FCC and PCC values
1063 * and we can detect which table to use from bit 5.
1066 val
->intval
= hw_to_current(fcc_tbl
,
1067 ARRAY_SIZE(fcc_tbl
),
1071 val
->intval
= hw_to_current(pcc_tbl
,
1072 ARRAY_SIZE(pcc_tbl
),
1077 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
:
1078 val
->intval
= pdata
->battery_info
.charge_full_design
;
1081 case POWER_SUPPLY_PROP_MODEL_NAME
:
1082 val
->strval
= pdata
->battery_info
.name
;
1092 static enum power_supply_property smb347_battery_properties
[] = {
1093 POWER_SUPPLY_PROP_STATUS
,
1094 POWER_SUPPLY_PROP_CHARGE_TYPE
,
1095 POWER_SUPPLY_PROP_TECHNOLOGY
,
1096 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
,
1097 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
,
1098 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
1099 POWER_SUPPLY_PROP_CURRENT_NOW
,
1100 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
,
1101 POWER_SUPPLY_PROP_MODEL_NAME
,
1104 static int smb347_debugfs_show(struct seq_file
*s
, void *data
)
1106 struct smb347_charger
*smb
= s
->private;
1110 seq_printf(s
, "Control registers:\n");
1111 seq_printf(s
, "==================\n");
1112 for (reg
= CFG_CHARGE_CURRENT
; reg
<= CFG_ADDRESS
; reg
++) {
1113 ret
= smb347_read(smb
, reg
);
1114 seq_printf(s
, "0x%02x:\t0x%02x\n", reg
, ret
);
1116 seq_printf(s
, "\n");
1118 seq_printf(s
, "Command registers:\n");
1119 seq_printf(s
, "==================\n");
1120 ret
= smb347_read(smb
, CMD_A
);
1121 seq_printf(s
, "0x%02x:\t0x%02x\n", CMD_A
, ret
);
1122 ret
= smb347_read(smb
, CMD_B
);
1123 seq_printf(s
, "0x%02x:\t0x%02x\n", CMD_B
, ret
);
1124 ret
= smb347_read(smb
, CMD_C
);
1125 seq_printf(s
, "0x%02x:\t0x%02x\n", CMD_C
, ret
);
1126 seq_printf(s
, "\n");
1128 seq_printf(s
, "Interrupt status registers:\n");
1129 seq_printf(s
, "===========================\n");
1130 for (reg
= IRQSTAT_A
; reg
<= IRQSTAT_F
; reg
++) {
1131 ret
= smb347_read(smb
, reg
);
1132 seq_printf(s
, "0x%02x:\t0x%02x\n", reg
, ret
);
1134 seq_printf(s
, "\n");
1136 seq_printf(s
, "Status registers:\n");
1137 seq_printf(s
, "=================\n");
1138 for (reg
= STAT_A
; reg
<= STAT_E
; reg
++) {
1139 ret
= smb347_read(smb
, reg
);
1140 seq_printf(s
, "0x%02x:\t0x%02x\n", reg
, ret
);
1146 static int smb347_debugfs_open(struct inode
*inode
, struct file
*file
)
1148 return single_open(file
, smb347_debugfs_show
, inode
->i_private
);
1151 static const struct file_operations smb347_debugfs_fops
= {
1152 .open
= smb347_debugfs_open
,
1154 .llseek
= seq_lseek
,
1155 .release
= single_release
,
1158 static int smb347_probe(struct i2c_client
*client
,
1159 const struct i2c_device_id
*id
)
1161 static char *battery
[] = { "smb347-battery" };
1162 const struct smb347_charger_platform_data
*pdata
;
1163 struct device
*dev
= &client
->dev
;
1164 struct smb347_charger
*smb
;
1167 pdata
= dev
->platform_data
;
1171 if (!pdata
->use_mains
&& !pdata
->use_usb
)
1174 smb
= devm_kzalloc(dev
, sizeof(*smb
), GFP_KERNEL
);
1178 i2c_set_clientdata(client
, smb
);
1180 mutex_init(&smb
->lock
);
1181 smb
->client
= client
;
1184 ret
= smb347_hw_init(smb
);
1188 smb
->mains
.name
= "smb347-mains";
1189 smb
->mains
.type
= POWER_SUPPLY_TYPE_MAINS
;
1190 smb
->mains
.get_property
= smb347_mains_get_property
;
1191 smb
->mains
.properties
= smb347_mains_properties
;
1192 smb
->mains
.num_properties
= ARRAY_SIZE(smb347_mains_properties
);
1193 smb
->mains
.supplied_to
= battery
;
1194 smb
->mains
.num_supplicants
= ARRAY_SIZE(battery
);
1196 smb
->usb
.name
= "smb347-usb";
1197 smb
->usb
.type
= POWER_SUPPLY_TYPE_USB
;
1198 smb
->usb
.get_property
= smb347_usb_get_property
;
1199 smb
->usb
.properties
= smb347_usb_properties
;
1200 smb
->usb
.num_properties
= ARRAY_SIZE(smb347_usb_properties
);
1201 smb
->usb
.supplied_to
= battery
;
1202 smb
->usb
.num_supplicants
= ARRAY_SIZE(battery
);
1204 smb
->battery
.name
= "smb347-battery";
1205 smb
->battery
.type
= POWER_SUPPLY_TYPE_BATTERY
;
1206 smb
->battery
.get_property
= smb347_battery_get_property
;
1207 smb
->battery
.properties
= smb347_battery_properties
;
1208 smb
->battery
.num_properties
= ARRAY_SIZE(smb347_battery_properties
);
1210 ret
= power_supply_register(dev
, &smb
->mains
);
1214 ret
= power_supply_register(dev
, &smb
->usb
);
1216 power_supply_unregister(&smb
->mains
);
1220 ret
= power_supply_register(dev
, &smb
->battery
);
1222 power_supply_unregister(&smb
->usb
);
1223 power_supply_unregister(&smb
->mains
);
1228 * Interrupt pin is optional. If it is connected, we setup the
1229 * interrupt support here.
1231 if (pdata
->irq_gpio
>= 0) {
1232 ret
= smb347_irq_init(smb
);
1234 dev_warn(dev
, "failed to initialize IRQ: %d\n", ret
);
1235 dev_warn(dev
, "disabling IRQ support\n");
1239 smb
->dentry
= debugfs_create_file("smb347-regs", S_IRUSR
, NULL
, smb
,
1240 &smb347_debugfs_fops
);
1244 static int smb347_remove(struct i2c_client
*client
)
1246 struct smb347_charger
*smb
= i2c_get_clientdata(client
);
1248 if (!IS_ERR_OR_NULL(smb
->dentry
))
1249 debugfs_remove(smb
->dentry
);
1252 smb347_irq_disable(smb
);
1253 free_irq(client
->irq
, smb
);
1254 gpio_free(smb
->pdata
->irq_gpio
);
1257 power_supply_unregister(&smb
->battery
);
1258 power_supply_unregister(&smb
->usb
);
1259 power_supply_unregister(&smb
->mains
);
1263 static const struct i2c_device_id smb347_id
[] = {
1267 MODULE_DEVICE_TABLE(i2c
, smb347_id
);
1269 static struct i2c_driver smb347_driver
= {
1273 .probe
= smb347_probe
,
1274 .remove
= __devexit_p(smb347_remove
),
1275 .id_table
= smb347_id
,
1278 static int __init
smb347_init(void)
1280 return i2c_add_driver(&smb347_driver
);
1282 module_init(smb347_init
);
1284 static void __exit
smb347_exit(void)
1286 i2c_del_driver(&smb347_driver
);
1288 module_exit(smb347_exit
);
1290 MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>");
1291 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
1292 MODULE_DESCRIPTION("SMB347 battery charger driver");
1293 MODULE_LICENSE("GPL");
1294 MODULE_ALIAS("i2c:smb347");