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/err.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/regmap.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_FLOAT_MASK 0x3f
43 #define CFG_FLOAT_VOLTAGE_THRESHOLD_MASK 0xc0
44 #define CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT 6
46 #define CFG_STAT_DISABLED BIT(5)
47 #define CFG_STAT_ACTIVE_HIGH BIT(7)
49 #define CFG_PIN_EN_CTRL_MASK 0x60
50 #define CFG_PIN_EN_CTRL_ACTIVE_HIGH 0x40
51 #define CFG_PIN_EN_CTRL_ACTIVE_LOW 0x60
52 #define CFG_PIN_EN_APSD_IRQ BIT(1)
53 #define CFG_PIN_EN_CHARGER_ERROR BIT(2)
54 #define CFG_THERM 0x07
55 #define CFG_THERM_SOFT_HOT_COMPENSATION_MASK 0x03
56 #define CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT 0
57 #define CFG_THERM_SOFT_COLD_COMPENSATION_MASK 0x0c
58 #define CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT 2
59 #define CFG_THERM_MONITOR_DISABLED BIT(4)
60 #define CFG_SYSOK 0x08
61 #define CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED BIT(2)
62 #define CFG_OTHER 0x09
63 #define CFG_OTHER_RID_MASK 0xc0
64 #define CFG_OTHER_RID_ENABLED_AUTO_OTG 0xc0
66 #define CFG_OTG_TEMP_THRESHOLD_MASK 0x30
67 #define CFG_OTG_TEMP_THRESHOLD_SHIFT 4
68 #define CFG_OTG_CC_COMPENSATION_MASK 0xc0
69 #define CFG_OTG_CC_COMPENSATION_SHIFT 6
70 #define CFG_TEMP_LIMIT 0x0b
71 #define CFG_TEMP_LIMIT_SOFT_HOT_MASK 0x03
72 #define CFG_TEMP_LIMIT_SOFT_HOT_SHIFT 0
73 #define CFG_TEMP_LIMIT_SOFT_COLD_MASK 0x0c
74 #define CFG_TEMP_LIMIT_SOFT_COLD_SHIFT 2
75 #define CFG_TEMP_LIMIT_HARD_HOT_MASK 0x30
76 #define CFG_TEMP_LIMIT_HARD_HOT_SHIFT 4
77 #define CFG_TEMP_LIMIT_HARD_COLD_MASK 0xc0
78 #define CFG_TEMP_LIMIT_HARD_COLD_SHIFT 6
79 #define CFG_FAULT_IRQ 0x0c
80 #define CFG_FAULT_IRQ_DCIN_UV BIT(2)
81 #define CFG_STATUS_IRQ 0x0d
82 #define CFG_STATUS_IRQ_TERMINATION_OR_TAPER BIT(4)
83 #define CFG_ADDRESS 0x0e
85 /* Command registers */
87 #define CMD_A_CHG_ENABLED BIT(1)
88 #define CMD_A_SUSPEND_ENABLED BIT(2)
89 #define CMD_A_ALLOW_WRITE BIT(7)
93 /* Interrupt Status registers */
94 #define IRQSTAT_A 0x35
95 #define IRQSTAT_C 0x37
96 #define IRQSTAT_C_TERMINATION_STAT BIT(0)
97 #define IRQSTAT_C_TERMINATION_IRQ BIT(1)
98 #define IRQSTAT_C_TAPER_IRQ BIT(3)
99 #define IRQSTAT_E 0x39
100 #define IRQSTAT_E_USBIN_UV_STAT BIT(0)
101 #define IRQSTAT_E_USBIN_UV_IRQ BIT(1)
102 #define IRQSTAT_E_DCIN_UV_STAT BIT(4)
103 #define IRQSTAT_E_DCIN_UV_IRQ BIT(5)
104 #define IRQSTAT_F 0x3a
106 /* Status registers */
108 #define STAT_A_FLOAT_VOLTAGE_MASK 0x3f
111 #define STAT_C_CHG_ENABLED BIT(0)
112 #define STAT_C_CHG_MASK 0x06
113 #define STAT_C_CHG_SHIFT 1
114 #define STAT_C_CHARGER_ERROR BIT(6)
117 #define SMB347_MAX_REGISTER 0x3f
120 * struct smb347_charger - smb347 charger instance
121 * @lock: protects concurrent access to online variables
122 * @dev: pointer to device
123 * @regmap: pointer to driver regmap
124 * @mains: power_supply instance for AC/DC power
125 * @usb: power_supply instance for USB power
126 * @battery: power_supply instance for battery
127 * @mains_online: is AC/DC input connected
128 * @usb_online: is USB input connected
129 * @charging_enabled: is charging enabled
130 * @pdata: pointer to platform data
132 struct smb347_charger {
135 struct regmap *regmap;
136 struct power_supply mains;
137 struct power_supply usb;
138 struct power_supply battery;
141 bool charging_enabled;
142 const struct smb347_charger_platform_data *pdata;
145 /* Fast charge current in uA */
146 static const unsigned int fcc_tbl[] = {
157 /* Pre-charge current in uA */
158 static const unsigned int pcc_tbl[] = {
165 /* Termination current in uA */
166 static const unsigned int tc_tbl[] = {
177 /* Input current limit in uA */
178 static const unsigned int icl_tbl[] = {
191 /* Charge current compensation in uA */
192 static const unsigned int ccc_tbl[] = {
199 /* Convert register value to current using lookup table */
200 static int hw_to_current(const unsigned int *tbl, size_t size, unsigned int val)
207 /* Convert current to register value using lookup table */
208 static int current_to_hw(const unsigned int *tbl, size_t size, unsigned int val)
212 for (i = 0; i < size; i++)
215 return i > 0 ? i - 1 : -EINVAL;
219 * smb347_update_ps_status - refreshes the power source status
220 * @smb: pointer to smb347 charger instance
222 * Function checks whether any power source is connected to the charger and
223 * updates internal state accordingly. If there is a change to previous state
224 * function returns %1, otherwise %0 and negative errno in case of errror.
226 static int smb347_update_ps_status(struct smb347_charger *smb)
233 ret = regmap_read(smb->regmap, IRQSTAT_E, &val);
238 * Dc and usb are set depending on whether they are enabled in
239 * platform data _and_ whether corresponding undervoltage is set.
241 if (smb->pdata->use_mains)
242 dc = !(val & IRQSTAT_E_DCIN_UV_STAT);
243 if (smb->pdata->use_usb)
244 usb = !(val & IRQSTAT_E_USBIN_UV_STAT);
246 mutex_lock(&smb->lock);
247 ret = smb->mains_online != dc || smb->usb_online != usb;
248 smb->mains_online = dc;
249 smb->usb_online = usb;
250 mutex_unlock(&smb->lock);
256 * smb347_is_ps_online - returns whether input power source is connected
257 * @smb: pointer to smb347 charger instance
259 * Returns %true if input power source is connected. Note that this is
260 * dependent on what platform has configured for usable power sources. For
261 * example if USB is disabled, this will return %false even if the USB cable
264 static bool smb347_is_ps_online(struct smb347_charger *smb)
268 mutex_lock(&smb->lock);
269 ret = smb->usb_online || smb->mains_online;
270 mutex_unlock(&smb->lock);
276 * smb347_charging_status - returns status of charging
277 * @smb: pointer to smb347 charger instance
279 * Function returns charging status. %0 means no charging is in progress,
280 * %1 means pre-charging, %2 fast-charging and %3 taper-charging.
282 static int smb347_charging_status(struct smb347_charger *smb)
287 if (!smb347_is_ps_online(smb))
290 ret = regmap_read(smb->regmap, STAT_C, &val);
294 return (val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT;
297 static int smb347_charging_set(struct smb347_charger *smb, bool enable)
301 if (smb->pdata->enable_control != SMB347_CHG_ENABLE_SW) {
302 dev_dbg(smb->dev, "charging enable/disable in SW disabled\n");
306 mutex_lock(&smb->lock);
307 if (smb->charging_enabled != enable) {
308 ret = regmap_update_bits(smb->regmap, CMD_A, CMD_A_CHG_ENABLED,
309 enable ? CMD_A_CHG_ENABLED : 0);
311 smb->charging_enabled = enable;
313 mutex_unlock(&smb->lock);
317 static inline int smb347_charging_enable(struct smb347_charger *smb)
319 return smb347_charging_set(smb, true);
322 static inline int smb347_charging_disable(struct smb347_charger *smb)
324 return smb347_charging_set(smb, false);
327 static int smb347_start_stop_charging(struct smb347_charger *smb)
332 * Depending on whether valid power source is connected or not, we
333 * disable or enable the charging. We do it manually because it
334 * depends on how the platform has configured the valid inputs.
336 if (smb347_is_ps_online(smb)) {
337 ret = smb347_charging_enable(smb);
339 dev_err(smb->dev, "failed to enable charging\n");
341 ret = smb347_charging_disable(smb);
343 dev_err(smb->dev, "failed to disable charging\n");
349 static int smb347_set_charge_current(struct smb347_charger *smb)
353 if (smb->pdata->max_charge_current) {
354 ret = current_to_hw(fcc_tbl, ARRAY_SIZE(fcc_tbl),
355 smb->pdata->max_charge_current);
359 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
360 CFG_CHARGE_CURRENT_FCC_MASK,
361 ret << CFG_CHARGE_CURRENT_FCC_SHIFT);
366 if (smb->pdata->pre_charge_current) {
367 ret = current_to_hw(pcc_tbl, ARRAY_SIZE(pcc_tbl),
368 smb->pdata->pre_charge_current);
372 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
373 CFG_CHARGE_CURRENT_PCC_MASK,
374 ret << CFG_CHARGE_CURRENT_PCC_SHIFT);
379 if (smb->pdata->termination_current) {
380 ret = current_to_hw(tc_tbl, ARRAY_SIZE(tc_tbl),
381 smb->pdata->termination_current);
385 ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
386 CFG_CHARGE_CURRENT_TC_MASK, ret);
394 static int smb347_set_current_limits(struct smb347_charger *smb)
398 if (smb->pdata->mains_current_limit) {
399 ret = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
400 smb->pdata->mains_current_limit);
404 ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
405 CFG_CURRENT_LIMIT_DC_MASK,
406 ret << CFG_CURRENT_LIMIT_DC_SHIFT);
411 if (smb->pdata->usb_hc_current_limit) {
412 ret = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
413 smb->pdata->usb_hc_current_limit);
417 ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
418 CFG_CURRENT_LIMIT_USB_MASK, ret);
426 static int smb347_set_voltage_limits(struct smb347_charger *smb)
430 if (smb->pdata->pre_to_fast_voltage) {
431 ret = smb->pdata->pre_to_fast_voltage;
434 ret = clamp_val(ret, 2400000, 3000000) - 2400000;
437 ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
438 CFG_FLOAT_VOLTAGE_THRESHOLD_MASK,
439 ret << CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT);
444 if (smb->pdata->max_charge_voltage) {
445 ret = smb->pdata->max_charge_voltage;
448 ret = clamp_val(ret, 3500000, 4500000) - 3500000;
451 ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
452 CFG_FLOAT_VOLTAGE_FLOAT_MASK, ret);
460 static int smb347_set_temp_limits(struct smb347_charger *smb)
462 bool enable_therm_monitor = false;
466 if (smb->pdata->chip_temp_threshold) {
467 val = smb->pdata->chip_temp_threshold;
470 val = clamp_val(val, 100, 130) - 100;
473 ret = regmap_update_bits(smb->regmap, CFG_OTG,
474 CFG_OTG_TEMP_THRESHOLD_MASK,
475 val << CFG_OTG_TEMP_THRESHOLD_SHIFT);
480 if (smb->pdata->soft_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
481 val = smb->pdata->soft_cold_temp_limit;
483 val = clamp_val(val, 0, 15);
485 /* this goes from higher to lower so invert the value */
488 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
489 CFG_TEMP_LIMIT_SOFT_COLD_MASK,
490 val << CFG_TEMP_LIMIT_SOFT_COLD_SHIFT);
494 enable_therm_monitor = true;
497 if (smb->pdata->soft_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
498 val = smb->pdata->soft_hot_temp_limit;
500 val = clamp_val(val, 40, 55) - 40;
503 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
504 CFG_TEMP_LIMIT_SOFT_HOT_MASK,
505 val << CFG_TEMP_LIMIT_SOFT_HOT_SHIFT);
509 enable_therm_monitor = true;
512 if (smb->pdata->hard_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
513 val = smb->pdata->hard_cold_temp_limit;
515 val = clamp_val(val, -5, 10) + 5;
517 /* this goes from higher to lower so invert the value */
520 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
521 CFG_TEMP_LIMIT_HARD_COLD_MASK,
522 val << CFG_TEMP_LIMIT_HARD_COLD_SHIFT);
526 enable_therm_monitor = true;
529 if (smb->pdata->hard_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
530 val = smb->pdata->hard_hot_temp_limit;
532 val = clamp_val(val, 50, 65) - 50;
535 ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
536 CFG_TEMP_LIMIT_HARD_HOT_MASK,
537 val << CFG_TEMP_LIMIT_HARD_HOT_SHIFT);
541 enable_therm_monitor = true;
545 * If any of the temperature limits are set, we also enable the
546 * thermistor monitoring.
548 * When soft limits are hit, the device will start to compensate
549 * current and/or voltage depending on the configuration.
551 * When hard limit is hit, the device will suspend charging
552 * depending on the configuration.
554 if (enable_therm_monitor) {
555 ret = regmap_update_bits(smb->regmap, CFG_THERM,
556 CFG_THERM_MONITOR_DISABLED, 0);
561 if (smb->pdata->suspend_on_hard_temp_limit) {
562 ret = regmap_update_bits(smb->regmap, CFG_SYSOK,
563 CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED, 0);
568 if (smb->pdata->soft_temp_limit_compensation !=
569 SMB347_SOFT_TEMP_COMPENSATE_DEFAULT) {
570 val = smb->pdata->soft_temp_limit_compensation & 0x3;
572 ret = regmap_update_bits(smb->regmap, CFG_THERM,
573 CFG_THERM_SOFT_HOT_COMPENSATION_MASK,
574 val << CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT);
578 ret = regmap_update_bits(smb->regmap, CFG_THERM,
579 CFG_THERM_SOFT_COLD_COMPENSATION_MASK,
580 val << CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT);
585 if (smb->pdata->charge_current_compensation) {
586 val = current_to_hw(ccc_tbl, ARRAY_SIZE(ccc_tbl),
587 smb->pdata->charge_current_compensation);
591 ret = regmap_update_bits(smb->regmap, CFG_OTG,
592 CFG_OTG_CC_COMPENSATION_MASK,
593 (val & 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT);
602 * smb347_set_writable - enables/disables writing to non-volatile registers
603 * @smb: pointer to smb347 charger instance
605 * You can enable/disable writing to the non-volatile configuration
606 * registers by calling this function.
608 * Returns %0 on success and negative errno in case of failure.
610 static int smb347_set_writable(struct smb347_charger *smb, bool writable)
612 return regmap_update_bits(smb->regmap, CMD_A, CMD_A_ALLOW_WRITE,
613 writable ? CMD_A_ALLOW_WRITE : 0);
616 static int smb347_hw_init(struct smb347_charger *smb)
621 ret = smb347_set_writable(smb, true);
626 * Program the platform specific configuration values to the device
629 ret = smb347_set_charge_current(smb);
633 ret = smb347_set_current_limits(smb);
637 ret = smb347_set_voltage_limits(smb);
641 ret = smb347_set_temp_limits(smb);
645 /* If USB charging is disabled we put the USB in suspend mode */
646 if (!smb->pdata->use_usb) {
647 ret = regmap_update_bits(smb->regmap, CMD_A,
648 CMD_A_SUSPEND_ENABLED,
649 CMD_A_SUSPEND_ENABLED);
655 * If configured by platform data, we enable hardware Auto-OTG
656 * support for driving VBUS. Otherwise we disable it.
658 ret = regmap_update_bits(smb->regmap, CFG_OTHER, CFG_OTHER_RID_MASK,
659 smb->pdata->use_usb_otg ? CFG_OTHER_RID_ENABLED_AUTO_OTG : 0);
664 * Make the charging functionality controllable by a write to the
665 * command register unless pin control is specified in the platform
668 switch (smb->pdata->enable_control) {
669 case SMB347_CHG_ENABLE_PIN_ACTIVE_LOW:
670 val = CFG_PIN_EN_CTRL_ACTIVE_LOW;
672 case SMB347_CHG_ENABLE_PIN_ACTIVE_HIGH:
673 val = CFG_PIN_EN_CTRL_ACTIVE_HIGH;
680 ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL_MASK,
685 /* Disable Automatic Power Source Detection (APSD) interrupt. */
686 ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_APSD_IRQ, 0);
690 ret = smb347_update_ps_status(smb);
694 ret = smb347_start_stop_charging(smb);
697 smb347_set_writable(smb, false);
701 static irqreturn_t smb347_interrupt(int irq, void *data)
703 struct smb347_charger *smb = data;
704 unsigned int stat_c, irqstat_e, irqstat_c;
705 bool handled = false;
708 ret = regmap_read(smb->regmap, STAT_C, &stat_c);
710 dev_warn(smb->dev, "reading STAT_C failed\n");
714 ret = regmap_read(smb->regmap, IRQSTAT_C, &irqstat_c);
716 dev_warn(smb->dev, "reading IRQSTAT_C failed\n");
720 ret = regmap_read(smb->regmap, IRQSTAT_E, &irqstat_e);
722 dev_warn(smb->dev, "reading IRQSTAT_E failed\n");
727 * If we get charger error we report the error back to user and
730 if (stat_c & STAT_C_CHARGER_ERROR) {
731 dev_err(smb->dev, "error in charger, disabling charging\n");
733 smb347_charging_disable(smb);
734 power_supply_changed(&smb->battery);
739 * If we reached the termination current the battery is charged and
740 * we can update the status now. Charging is automatically
741 * disabled by the hardware.
743 if (irqstat_c & (IRQSTAT_C_TERMINATION_IRQ | IRQSTAT_C_TAPER_IRQ)) {
744 if (irqstat_c & IRQSTAT_C_TERMINATION_STAT)
745 power_supply_changed(&smb->battery);
750 * If we got an under voltage interrupt it means that AC/USB input
751 * was connected or disconnected.
753 if (irqstat_e & (IRQSTAT_E_USBIN_UV_IRQ | IRQSTAT_E_DCIN_UV_IRQ)) {
754 if (smb347_update_ps_status(smb) > 0) {
755 smb347_start_stop_charging(smb);
756 if (smb->pdata->use_mains)
757 power_supply_changed(&smb->mains);
758 if (smb->pdata->use_usb)
759 power_supply_changed(&smb->usb);
764 return handled ? IRQ_HANDLED : IRQ_NONE;
767 static int smb347_irq_set(struct smb347_charger *smb, bool enable)
771 ret = smb347_set_writable(smb, true);
776 * Enable/disable interrupts for:
778 * - termination current reached
781 ret = regmap_update_bits(smb->regmap, CFG_FAULT_IRQ, 0xff,
782 enable ? CFG_FAULT_IRQ_DCIN_UV : 0);
786 ret = regmap_update_bits(smb->regmap, CFG_STATUS_IRQ, 0xff,
787 enable ? CFG_STATUS_IRQ_TERMINATION_OR_TAPER : 0);
791 ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CHARGER_ERROR,
792 enable ? CFG_PIN_EN_CHARGER_ERROR : 0);
794 smb347_set_writable(smb, false);
798 static inline int smb347_irq_enable(struct smb347_charger *smb)
800 return smb347_irq_set(smb, true);
803 static inline int smb347_irq_disable(struct smb347_charger *smb)
805 return smb347_irq_set(smb, false);
808 static int smb347_irq_init(struct smb347_charger *smb,
809 struct i2c_client *client)
811 const struct smb347_charger_platform_data *pdata = smb->pdata;
812 int ret, irq = gpio_to_irq(pdata->irq_gpio);
814 ret = gpio_request_one(pdata->irq_gpio, GPIOF_IN, client->name);
818 ret = request_threaded_irq(irq, NULL, smb347_interrupt,
819 IRQF_TRIGGER_FALLING, client->name, smb);
823 ret = smb347_set_writable(smb, true);
828 * Configure the STAT output to be suitable for interrupts: disable
829 * all other output (except interrupts) and make it active low.
831 ret = regmap_update_bits(smb->regmap, CFG_STAT,
832 CFG_STAT_ACTIVE_HIGH | CFG_STAT_DISABLED,
837 smb347_set_writable(smb, false);
842 smb347_set_writable(smb, false);
846 gpio_free(pdata->irq_gpio);
853 * Returns the constant charge current programmed
854 * into the charger in uA.
856 static int get_const_charge_current(struct smb347_charger *smb)
861 if (!smb347_is_ps_online(smb))
864 ret = regmap_read(smb->regmap, STAT_B, &v);
869 * The current value is composition of FCC and PCC values
870 * and we can detect which table to use from bit 5.
873 intval = hw_to_current(fcc_tbl, ARRAY_SIZE(fcc_tbl), v & 7);
876 intval = hw_to_current(pcc_tbl, ARRAY_SIZE(pcc_tbl), v & 7);
883 * Returns the constant charge voltage programmed
884 * into the charger in uV.
886 static int get_const_charge_voltage(struct smb347_charger *smb)
891 if (!smb347_is_ps_online(smb))
894 ret = regmap_read(smb->regmap, STAT_A, &v);
898 v &= STAT_A_FLOAT_VOLTAGE_MASK;
902 intval = 3500000 + v * 20000;
907 static int smb347_mains_get_property(struct power_supply *psy,
908 enum power_supply_property prop,
909 union power_supply_propval *val)
911 struct smb347_charger *smb =
912 container_of(psy, struct smb347_charger, mains);
916 case POWER_SUPPLY_PROP_ONLINE:
917 val->intval = smb->mains_online;
920 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
921 ret = get_const_charge_voltage(smb);
928 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
929 ret = get_const_charge_current(smb);
943 static enum power_supply_property smb347_mains_properties[] = {
944 POWER_SUPPLY_PROP_ONLINE,
945 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
946 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
949 static int smb347_usb_get_property(struct power_supply *psy,
950 enum power_supply_property prop,
951 union power_supply_propval *val)
953 struct smb347_charger *smb =
954 container_of(psy, struct smb347_charger, usb);
958 case POWER_SUPPLY_PROP_ONLINE:
959 val->intval = smb->usb_online;
962 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
963 ret = get_const_charge_voltage(smb);
970 case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
971 ret = get_const_charge_current(smb);
985 static enum power_supply_property smb347_usb_properties[] = {
986 POWER_SUPPLY_PROP_ONLINE,
987 POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
988 POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
991 static int smb347_battery_get_property(struct power_supply *psy,
992 enum power_supply_property prop,
993 union power_supply_propval *val)
995 struct smb347_charger *smb =
996 container_of(psy, struct smb347_charger, battery);
997 const struct smb347_charger_platform_data *pdata = smb->pdata;
1000 ret = smb347_update_ps_status(smb);
1005 case POWER_SUPPLY_PROP_STATUS:
1006 if (!smb347_is_ps_online(smb)) {
1007 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1010 if (smb347_charging_status(smb))
1011 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1013 val->intval = POWER_SUPPLY_STATUS_FULL;
1016 case POWER_SUPPLY_PROP_CHARGE_TYPE:
1017 if (!smb347_is_ps_online(smb))
1021 * We handle trickle and pre-charging the same, and taper
1022 * and none the same.
1024 switch (smb347_charging_status(smb)) {
1026 val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1029 val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1032 val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1037 case POWER_SUPPLY_PROP_TECHNOLOGY:
1038 val->intval = pdata->battery_info.technology;
1041 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1042 val->intval = pdata->battery_info.voltage_min_design;
1045 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
1046 val->intval = pdata->battery_info.voltage_max_design;
1049 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
1050 val->intval = pdata->battery_info.charge_full_design;
1053 case POWER_SUPPLY_PROP_MODEL_NAME:
1054 val->strval = pdata->battery_info.name;
1064 static enum power_supply_property smb347_battery_properties[] = {
1065 POWER_SUPPLY_PROP_STATUS,
1066 POWER_SUPPLY_PROP_CHARGE_TYPE,
1067 POWER_SUPPLY_PROP_TECHNOLOGY,
1068 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
1069 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
1070 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
1071 POWER_SUPPLY_PROP_MODEL_NAME,
1074 static bool smb347_volatile_reg(struct device *dev, unsigned int reg)
1091 static bool smb347_readable_reg(struct device *dev, unsigned int reg)
1094 case CFG_CHARGE_CURRENT:
1095 case CFG_CURRENT_LIMIT:
1096 case CFG_FLOAT_VOLTAGE:
1103 case CFG_TEMP_LIMIT:
1105 case CFG_STATUS_IRQ:
1113 return smb347_volatile_reg(dev, reg);
1116 static const struct regmap_config smb347_regmap = {
1119 .max_register = SMB347_MAX_REGISTER,
1120 .volatile_reg = smb347_volatile_reg,
1121 .readable_reg = smb347_readable_reg,
1124 static int smb347_probe(struct i2c_client *client,
1125 const struct i2c_device_id *id)
1127 static char *battery[] = { "smb347-battery" };
1128 const struct smb347_charger_platform_data *pdata;
1129 struct device *dev = &client->dev;
1130 struct smb347_charger *smb;
1133 pdata = dev->platform_data;
1137 if (!pdata->use_mains && !pdata->use_usb)
1140 smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL);
1144 i2c_set_clientdata(client, smb);
1146 mutex_init(&smb->lock);
1147 smb->dev = &client->dev;
1150 smb->regmap = devm_regmap_init_i2c(client, &smb347_regmap);
1151 if (IS_ERR(smb->regmap))
1152 return PTR_ERR(smb->regmap);
1154 ret = smb347_hw_init(smb);
1158 if (smb->pdata->use_mains) {
1159 smb->mains.name = "smb347-mains";
1160 smb->mains.type = POWER_SUPPLY_TYPE_MAINS;
1161 smb->mains.get_property = smb347_mains_get_property;
1162 smb->mains.properties = smb347_mains_properties;
1163 smb->mains.num_properties = ARRAY_SIZE(smb347_mains_properties);
1164 smb->mains.supplied_to = battery;
1165 smb->mains.num_supplicants = ARRAY_SIZE(battery);
1166 ret = power_supply_register(dev, &smb->mains);
1171 if (smb->pdata->use_usb) {
1172 smb->usb.name = "smb347-usb";
1173 smb->usb.type = POWER_SUPPLY_TYPE_USB;
1174 smb->usb.get_property = smb347_usb_get_property;
1175 smb->usb.properties = smb347_usb_properties;
1176 smb->usb.num_properties = ARRAY_SIZE(smb347_usb_properties);
1177 smb->usb.supplied_to = battery;
1178 smb->usb.num_supplicants = ARRAY_SIZE(battery);
1179 ret = power_supply_register(dev, &smb->usb);
1181 if (smb->pdata->use_mains)
1182 power_supply_unregister(&smb->mains);
1187 smb->battery.name = "smb347-battery";
1188 smb->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1189 smb->battery.get_property = smb347_battery_get_property;
1190 smb->battery.properties = smb347_battery_properties;
1191 smb->battery.num_properties = ARRAY_SIZE(smb347_battery_properties);
1194 ret = power_supply_register(dev, &smb->battery);
1196 if (smb->pdata->use_usb)
1197 power_supply_unregister(&smb->usb);
1198 if (smb->pdata->use_mains)
1199 power_supply_unregister(&smb->mains);
1204 * Interrupt pin is optional. If it is connected, we setup the
1205 * interrupt support here.
1207 if (pdata->irq_gpio >= 0) {
1208 ret = smb347_irq_init(smb, client);
1210 dev_warn(dev, "failed to initialize IRQ: %d\n", ret);
1211 dev_warn(dev, "disabling IRQ support\n");
1213 smb347_irq_enable(smb);
1220 static int smb347_remove(struct i2c_client *client)
1222 struct smb347_charger *smb = i2c_get_clientdata(client);
1225 smb347_irq_disable(smb);
1226 free_irq(client->irq, smb);
1227 gpio_free(smb->pdata->irq_gpio);
1230 power_supply_unregister(&smb->battery);
1231 if (smb->pdata->use_usb)
1232 power_supply_unregister(&smb->usb);
1233 if (smb->pdata->use_mains)
1234 power_supply_unregister(&smb->mains);
1238 static const struct i2c_device_id smb347_id[] = {
1242 MODULE_DEVICE_TABLE(i2c, smb347_id);
1244 static struct i2c_driver smb347_driver = {
1248 .probe = smb347_probe,
1249 .remove = __devexit_p(smb347_remove),
1250 .id_table = smb347_id,
1253 module_i2c_driver(smb347_driver);
1255 MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>");
1256 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
1257 MODULE_DESCRIPTION("SMB347 battery charger driver");
1258 MODULE_LICENSE("GPL");
1259 MODULE_ALIAS("i2c:smb347");