2 * Gas Gauge driver for SBS Compliant Batteries
4 * Copyright (c) 2010, NVIDIA Corporation.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/err.h>
25 #include <linux/power_supply.h>
26 #include <linux/i2c.h>
27 #include <linux/slab.h>
28 #include <linux/interrupt.h>
29 #include <linux/gpio/consumer.h>
31 #include <linux/stat.h>
33 #include <linux/power/sbs-battery.h>
36 REG_MANUFACTURER_DATA
,
47 REG_REMAINING_CAPACITY
,
48 REG_REMAINING_CAPACITY_CHARGE
,
49 REG_FULL_CHARGE_CAPACITY
,
50 REG_FULL_CHARGE_CAPACITY_CHARGE
,
52 REG_DESIGN_CAPACITY_CHARGE
,
53 REG_DESIGN_VOLTAGE_MIN
,
54 REG_DESIGN_VOLTAGE_MAX
,
59 /* Battery Mode defines */
60 #define BATTERY_MODE_OFFSET 0x03
61 #define BATTERY_MODE_MASK 0x8000
62 enum sbs_battery_mode
{
67 /* manufacturer access defines */
68 #define MANUFACTURER_ACCESS_STATUS 0x0006
69 #define MANUFACTURER_ACCESS_SLEEP 0x0011
71 /* battery status value bits */
72 #define BATTERY_INITIALIZED 0x80
73 #define BATTERY_DISCHARGING 0x40
74 #define BATTERY_FULL_CHARGED 0x20
75 #define BATTERY_FULL_DISCHARGED 0x10
77 /* min_value and max_value are only valid for numerical data */
78 #define SBS_DATA(_psp, _addr, _min_value, _max_value) { \
81 .min_value = _min_value, \
82 .max_value = _max_value, \
85 static const struct chip_data
{
86 enum power_supply_property psp
;
91 [REG_MANUFACTURER_DATA
] =
92 SBS_DATA(POWER_SUPPLY_PROP_PRESENT
, 0x00, 0, 65535),
94 SBS_DATA(POWER_SUPPLY_PROP_TEMP
, 0x08, 0, 65535),
96 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_NOW
, 0x09, 0, 20000),
98 SBS_DATA(POWER_SUPPLY_PROP_CURRENT_NOW
, 0x0A, -32768, 32767),
100 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY
, 0x0D, 0, 100),
101 [REG_REMAINING_CAPACITY
] =
102 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_NOW
, 0x0F, 0, 65535),
103 [REG_REMAINING_CAPACITY_CHARGE
] =
104 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_NOW
, 0x0F, 0, 65535),
105 [REG_FULL_CHARGE_CAPACITY
] =
106 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL
, 0x10, 0, 65535),
107 [REG_FULL_CHARGE_CAPACITY_CHARGE
] =
108 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL
, 0x10, 0, 65535),
109 [REG_TIME_TO_EMPTY
] =
110 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG
, 0x12, 0, 65535),
112 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG
, 0x13, 0, 65535),
114 SBS_DATA(POWER_SUPPLY_PROP_STATUS
, 0x16, 0, 65535),
115 [REG_CAPACITY_LEVEL
] =
116 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY_LEVEL
, 0x16, 0, 65535),
118 SBS_DATA(POWER_SUPPLY_PROP_CYCLE_COUNT
, 0x17, 0, 65535),
119 [REG_DESIGN_CAPACITY
] =
120 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN
, 0x18, 0, 65535),
121 [REG_DESIGN_CAPACITY_CHARGE
] =
122 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
, 0x18, 0, 65535),
123 [REG_DESIGN_VOLTAGE_MIN
] =
124 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
, 0x19, 0, 65535),
125 [REG_DESIGN_VOLTAGE_MAX
] =
126 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
, 0x19, 0, 65535),
127 [REG_SERIAL_NUMBER
] =
128 SBS_DATA(POWER_SUPPLY_PROP_SERIAL_NUMBER
, 0x1C, 0, 65535),
129 /* Properties of type `const char *' */
131 SBS_DATA(POWER_SUPPLY_PROP_MANUFACTURER
, 0x20, 0, 65535),
133 SBS_DATA(POWER_SUPPLY_PROP_MODEL_NAME
, 0x21, 0, 65535)
136 static enum power_supply_property sbs_properties
[] = {
137 POWER_SUPPLY_PROP_STATUS
,
138 POWER_SUPPLY_PROP_CAPACITY_LEVEL
,
139 POWER_SUPPLY_PROP_HEALTH
,
140 POWER_SUPPLY_PROP_PRESENT
,
141 POWER_SUPPLY_PROP_TECHNOLOGY
,
142 POWER_SUPPLY_PROP_CYCLE_COUNT
,
143 POWER_SUPPLY_PROP_VOLTAGE_NOW
,
144 POWER_SUPPLY_PROP_CURRENT_NOW
,
145 POWER_SUPPLY_PROP_CAPACITY
,
146 POWER_SUPPLY_PROP_TEMP
,
147 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG
,
148 POWER_SUPPLY_PROP_TIME_TO_FULL_AVG
,
149 POWER_SUPPLY_PROP_SERIAL_NUMBER
,
150 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
,
151 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
,
152 POWER_SUPPLY_PROP_ENERGY_NOW
,
153 POWER_SUPPLY_PROP_ENERGY_FULL
,
154 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN
,
155 POWER_SUPPLY_PROP_CHARGE_NOW
,
156 POWER_SUPPLY_PROP_CHARGE_FULL
,
157 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
,
158 /* Properties of type `const char *' */
159 POWER_SUPPLY_PROP_MANUFACTURER
,
160 POWER_SUPPLY_PROP_MODEL_NAME
164 struct i2c_client
*client
;
165 struct power_supply
*power_supply
;
166 struct sbs_platform_data
*pdata
;
168 struct gpio_desc
*gpio_detect
;
169 bool enable_detection
;
173 int poll_retry_count
;
174 struct delayed_work work
;
178 static char model_name
[I2C_SMBUS_BLOCK_MAX
+ 1];
179 static char manufacturer
[I2C_SMBUS_BLOCK_MAX
+ 1];
180 static bool force_load
;
182 static int sbs_read_word_data(struct i2c_client
*client
, u8 address
)
184 struct sbs_info
*chip
= i2c_get_clientdata(client
);
189 retries
= max(chip
->i2c_retry_count
+ 1, 1);
191 while (retries
> 0) {
192 ret
= i2c_smbus_read_word_data(client
, address
);
199 dev_dbg(&client
->dev
,
200 "%s: i2c read at address 0x%x failed\n",
205 return le16_to_cpu(ret
);
208 static int sbs_read_string_data(struct i2c_client
*client
, u8 address
,
211 struct sbs_info
*chip
= i2c_get_clientdata(client
);
212 s32 ret
= 0, block_length
= 0;
213 int retries_length
= 1, retries_block
= 1;
214 u8 block_buffer
[I2C_SMBUS_BLOCK_MAX
+ 1];
217 retries_length
= max(chip
->i2c_retry_count
+ 1, 1);
218 retries_block
= max(chip
->i2c_retry_count
+ 1, 1);
221 /* Adapter needs to support these two functions */
222 if (!i2c_check_functionality(client
->adapter
,
223 I2C_FUNC_SMBUS_BYTE_DATA
|
224 I2C_FUNC_SMBUS_I2C_BLOCK
)){
228 /* Get the length of block data */
229 while (retries_length
> 0) {
230 ret
= i2c_smbus_read_byte_data(client
, address
);
237 dev_dbg(&client
->dev
,
238 "%s: i2c read at address 0x%x failed\n",
243 /* block_length does not include NULL terminator */
245 if (block_length
> I2C_SMBUS_BLOCK_MAX
) {
246 dev_err(&client
->dev
,
247 "%s: Returned block_length is longer than 0x%x\n",
248 __func__
, I2C_SMBUS_BLOCK_MAX
);
252 /* Get the block data */
253 while (retries_block
> 0) {
254 ret
= i2c_smbus_read_i2c_block_data(
256 block_length
+ 1, block_buffer
);
263 dev_dbg(&client
->dev
,
264 "%s: i2c read at address 0x%x failed\n",
269 /* block_buffer[0] == block_length */
270 memcpy(values
, block_buffer
+ 1, block_length
);
271 values
[block_length
] = '\0';
273 return le16_to_cpu(ret
);
276 static int sbs_write_word_data(struct i2c_client
*client
, u8 address
,
279 struct sbs_info
*chip
= i2c_get_clientdata(client
);
284 retries
= max(chip
->i2c_retry_count
+ 1, 1);
286 while (retries
> 0) {
287 ret
= i2c_smbus_write_word_data(client
, address
,
295 dev_dbg(&client
->dev
,
296 "%s: i2c write to address 0x%x failed\n",
304 static int sbs_get_battery_presence_and_health(
305 struct i2c_client
*client
, enum power_supply_property psp
,
306 union power_supply_propval
*val
)
309 struct sbs_info
*chip
= i2c_get_clientdata(client
);
311 if (psp
== POWER_SUPPLY_PROP_PRESENT
&& chip
->gpio_detect
) {
312 ret
= gpiod_get_value_cansleep(chip
->gpio_detect
);
316 chip
->is_present
= val
->intval
;
320 /* Write to ManufacturerAccess with
321 * ManufacturerAccess command and then
323 ret
= sbs_write_word_data(client
, sbs_data
[REG_MANUFACTURER_DATA
].addr
,
324 MANUFACTURER_ACCESS_STATUS
);
326 if (psp
== POWER_SUPPLY_PROP_PRESENT
)
327 val
->intval
= 0; /* battery removed */
331 ret
= sbs_read_word_data(client
, sbs_data
[REG_MANUFACTURER_DATA
].addr
);
335 if (ret
< sbs_data
[REG_MANUFACTURER_DATA
].min_value
||
336 ret
> sbs_data
[REG_MANUFACTURER_DATA
].max_value
) {
341 /* Mask the upper nibble of 2nd byte and
342 * lower byte of response then
343 * shift the result by 8 to get status*/
346 if (psp
== POWER_SUPPLY_PROP_PRESENT
) {
348 /* battery removed */
352 } else if (psp
== POWER_SUPPLY_PROP_HEALTH
) {
354 val
->intval
= POWER_SUPPLY_HEALTH_UNSPEC_FAILURE
;
355 else if (ret
== 0x0B)
356 val
->intval
= POWER_SUPPLY_HEALTH_OVERHEAT
;
357 else if (ret
== 0x0C)
358 val
->intval
= POWER_SUPPLY_HEALTH_DEAD
;
360 val
->intval
= POWER_SUPPLY_HEALTH_GOOD
;
366 static int sbs_get_battery_property(struct i2c_client
*client
,
367 int reg_offset
, enum power_supply_property psp
,
368 union power_supply_propval
*val
)
370 struct sbs_info
*chip
= i2c_get_clientdata(client
);
373 ret
= sbs_read_word_data(client
, sbs_data
[reg_offset
].addr
);
377 /* returned values are 16 bit */
378 if (sbs_data
[reg_offset
].min_value
< 0)
381 if (ret
>= sbs_data
[reg_offset
].min_value
&&
382 ret
<= sbs_data
[reg_offset
].max_value
) {
384 if (psp
== POWER_SUPPLY_PROP_CAPACITY_LEVEL
) {
385 if (!(ret
& BATTERY_INITIALIZED
))
387 POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN
;
388 else if (ret
& BATTERY_FULL_CHARGED
)
390 POWER_SUPPLY_CAPACITY_LEVEL_FULL
;
391 else if (ret
& BATTERY_FULL_DISCHARGED
)
393 POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL
;
396 POWER_SUPPLY_CAPACITY_LEVEL_NORMAL
;
398 } else if (psp
!= POWER_SUPPLY_PROP_STATUS
) {
402 if (ret
& BATTERY_FULL_CHARGED
)
403 val
->intval
= POWER_SUPPLY_STATUS_FULL
;
404 else if (ret
& BATTERY_DISCHARGING
)
405 val
->intval
= POWER_SUPPLY_STATUS_DISCHARGING
;
407 val
->intval
= POWER_SUPPLY_STATUS_CHARGING
;
409 if (chip
->poll_time
== 0)
410 chip
->last_state
= val
->intval
;
411 else if (chip
->last_state
!= val
->intval
) {
412 cancel_delayed_work_sync(&chip
->work
);
413 power_supply_changed(chip
->power_supply
);
417 if (psp
== POWER_SUPPLY_PROP_STATUS
)
418 val
->intval
= POWER_SUPPLY_STATUS_UNKNOWN
;
426 static int sbs_get_battery_string_property(struct i2c_client
*client
,
427 int reg_offset
, enum power_supply_property psp
, char *val
)
431 ret
= sbs_read_string_data(client
, sbs_data
[reg_offset
].addr
, val
);
439 static void sbs_unit_adjustment(struct i2c_client
*client
,
440 enum power_supply_property psp
, union power_supply_propval
*val
)
442 #define BASE_UNIT_CONVERSION 1000
443 #define BATTERY_MODE_CAP_MULT_WATT (10 * BASE_UNIT_CONVERSION)
444 #define TIME_UNIT_CONVERSION 60
445 #define TEMP_KELVIN_TO_CELSIUS 2731
447 case POWER_SUPPLY_PROP_ENERGY_NOW
:
448 case POWER_SUPPLY_PROP_ENERGY_FULL
:
449 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN
:
450 /* sbs provides energy in units of 10mWh.
453 val
->intval
*= BATTERY_MODE_CAP_MULT_WATT
;
456 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
457 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
:
458 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
:
459 case POWER_SUPPLY_PROP_CURRENT_NOW
:
460 case POWER_SUPPLY_PROP_CHARGE_NOW
:
461 case POWER_SUPPLY_PROP_CHARGE_FULL
:
462 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
:
463 val
->intval
*= BASE_UNIT_CONVERSION
;
466 case POWER_SUPPLY_PROP_TEMP
:
467 /* sbs provides battery temperature in 0.1K
468 * so convert it to 0.1°C
470 val
->intval
-= TEMP_KELVIN_TO_CELSIUS
;
473 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG
:
474 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG
:
475 /* sbs provides time to empty and time to full in minutes.
478 val
->intval
*= TIME_UNIT_CONVERSION
;
482 dev_dbg(&client
->dev
,
483 "%s: no need for unit conversion %d\n", __func__
, psp
);
487 static enum sbs_battery_mode
sbs_set_battery_mode(struct i2c_client
*client
,
488 enum sbs_battery_mode mode
)
490 int ret
, original_val
;
492 original_val
= sbs_read_word_data(client
, BATTERY_MODE_OFFSET
);
493 if (original_val
< 0)
496 if ((original_val
& BATTERY_MODE_MASK
) == mode
)
499 if (mode
== BATTERY_MODE_AMPS
)
500 ret
= original_val
& ~BATTERY_MODE_MASK
;
502 ret
= original_val
| BATTERY_MODE_MASK
;
504 ret
= sbs_write_word_data(client
, BATTERY_MODE_OFFSET
, ret
);
508 return original_val
& BATTERY_MODE_MASK
;
511 static int sbs_get_battery_capacity(struct i2c_client
*client
,
512 int reg_offset
, enum power_supply_property psp
,
513 union power_supply_propval
*val
)
516 enum sbs_battery_mode mode
= BATTERY_MODE_WATTS
;
518 if (power_supply_is_amp_property(psp
))
519 mode
= BATTERY_MODE_AMPS
;
521 mode
= sbs_set_battery_mode(client
, mode
);
525 ret
= sbs_read_word_data(client
, sbs_data
[reg_offset
].addr
);
529 if (psp
== POWER_SUPPLY_PROP_CAPACITY
) {
530 /* sbs spec says that this can be >100 %
531 * even if max value is 100 % */
532 val
->intval
= min(ret
, 100);
536 ret
= sbs_set_battery_mode(client
, mode
);
543 static char sbs_serial
[5];
544 static int sbs_get_battery_serial_number(struct i2c_client
*client
,
545 union power_supply_propval
*val
)
549 ret
= sbs_read_word_data(client
, sbs_data
[REG_SERIAL_NUMBER
].addr
);
553 ret
= sprintf(sbs_serial
, "%04x", ret
);
554 val
->strval
= sbs_serial
;
559 static int sbs_get_property_index(struct i2c_client
*client
,
560 enum power_supply_property psp
)
563 for (count
= 0; count
< ARRAY_SIZE(sbs_data
); count
++)
564 if (psp
== sbs_data
[count
].psp
)
567 dev_warn(&client
->dev
,
568 "%s: Invalid Property - %d\n", __func__
, psp
);
573 static int sbs_get_property(struct power_supply
*psy
,
574 enum power_supply_property psp
,
575 union power_supply_propval
*val
)
578 struct sbs_info
*chip
= power_supply_get_drvdata(psy
);
579 struct i2c_client
*client
= chip
->client
;
582 case POWER_SUPPLY_PROP_PRESENT
:
583 case POWER_SUPPLY_PROP_HEALTH
:
584 ret
= sbs_get_battery_presence_and_health(client
, psp
, val
);
585 if (psp
== POWER_SUPPLY_PROP_PRESENT
)
589 case POWER_SUPPLY_PROP_TECHNOLOGY
:
590 val
->intval
= POWER_SUPPLY_TECHNOLOGY_LION
;
591 goto done
; /* don't trigger power_supply_changed()! */
593 case POWER_SUPPLY_PROP_ENERGY_NOW
:
594 case POWER_SUPPLY_PROP_ENERGY_FULL
:
595 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN
:
596 case POWER_SUPPLY_PROP_CHARGE_NOW
:
597 case POWER_SUPPLY_PROP_CHARGE_FULL
:
598 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN
:
599 case POWER_SUPPLY_PROP_CAPACITY
:
600 ret
= sbs_get_property_index(client
, psp
);
604 ret
= sbs_get_battery_capacity(client
, ret
, psp
, val
);
607 case POWER_SUPPLY_PROP_SERIAL_NUMBER
:
608 ret
= sbs_get_battery_serial_number(client
, val
);
611 case POWER_SUPPLY_PROP_STATUS
:
612 case POWER_SUPPLY_PROP_CAPACITY_LEVEL
:
613 case POWER_SUPPLY_PROP_CYCLE_COUNT
:
614 case POWER_SUPPLY_PROP_VOLTAGE_NOW
:
615 case POWER_SUPPLY_PROP_CURRENT_NOW
:
616 case POWER_SUPPLY_PROP_TEMP
:
617 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG
:
618 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG
:
619 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN
:
620 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN
:
621 ret
= sbs_get_property_index(client
, psp
);
625 ret
= sbs_get_battery_property(client
, ret
, psp
, val
);
628 case POWER_SUPPLY_PROP_MODEL_NAME
:
629 ret
= sbs_get_property_index(client
, psp
);
633 ret
= sbs_get_battery_string_property(client
, ret
, psp
,
635 val
->strval
= model_name
;
638 case POWER_SUPPLY_PROP_MANUFACTURER
:
639 ret
= sbs_get_property_index(client
, psp
);
643 ret
= sbs_get_battery_string_property(client
, ret
, psp
,
645 val
->strval
= manufacturer
;
649 dev_err(&client
->dev
,
650 "%s: INVALID property\n", __func__
);
654 if (!chip
->enable_detection
)
657 if (!chip
->gpio_detect
&&
658 chip
->is_present
!= (ret
>= 0)) {
659 chip
->is_present
= (ret
>= 0);
660 power_supply_changed(chip
->power_supply
);
665 /* Convert units to match requirements for power supply class */
666 sbs_unit_adjustment(client
, psp
, val
);
669 dev_dbg(&client
->dev
,
670 "%s: property = %d, value = %x\n", __func__
, psp
, val
->intval
);
672 if (ret
&& chip
->is_present
)
675 /* battery not present, so return NODATA for properties */
682 static irqreturn_t
sbs_irq(int irq
, void *devid
)
684 struct sbs_info
*chip
= devid
;
685 struct power_supply
*battery
= chip
->power_supply
;
688 ret
= gpiod_get_value_cansleep(chip
->gpio_detect
);
691 chip
->is_present
= ret
;
692 power_supply_changed(battery
);
697 static void sbs_external_power_changed(struct power_supply
*psy
)
699 struct sbs_info
*chip
= power_supply_get_drvdata(psy
);
701 if (chip
->ignore_changes
> 0) {
702 chip
->ignore_changes
--;
706 /* cancel outstanding work */
707 cancel_delayed_work_sync(&chip
->work
);
709 schedule_delayed_work(&chip
->work
, HZ
);
710 chip
->poll_time
= chip
->pdata
->poll_retry_count
;
713 static void sbs_delayed_work(struct work_struct
*work
)
715 struct sbs_info
*chip
;
718 chip
= container_of(work
, struct sbs_info
, work
.work
);
720 ret
= sbs_read_word_data(chip
->client
, sbs_data
[REG_STATUS
].addr
);
721 /* if the read failed, give up on this work */
727 if (ret
& BATTERY_FULL_CHARGED
)
728 ret
= POWER_SUPPLY_STATUS_FULL
;
729 else if (ret
& BATTERY_DISCHARGING
)
730 ret
= POWER_SUPPLY_STATUS_DISCHARGING
;
732 ret
= POWER_SUPPLY_STATUS_CHARGING
;
734 if (chip
->last_state
!= ret
) {
736 power_supply_changed(chip
->power_supply
);
739 if (chip
->poll_time
> 0) {
740 schedule_delayed_work(&chip
->work
, HZ
);
746 static const struct power_supply_desc sbs_default_desc
= {
747 .type
= POWER_SUPPLY_TYPE_BATTERY
,
748 .properties
= sbs_properties
,
749 .num_properties
= ARRAY_SIZE(sbs_properties
),
750 .get_property
= sbs_get_property
,
751 .external_power_changed
= sbs_external_power_changed
,
754 static int sbs_probe(struct i2c_client
*client
,
755 const struct i2c_device_id
*id
)
757 struct sbs_info
*chip
;
758 struct power_supply_desc
*sbs_desc
;
759 struct sbs_platform_data
*pdata
= client
->dev
.platform_data
;
760 struct power_supply_config psy_cfg
= {};
764 sbs_desc
= devm_kmemdup(&client
->dev
, &sbs_default_desc
,
765 sizeof(*sbs_desc
), GFP_KERNEL
);
769 sbs_desc
->name
= devm_kasprintf(&client
->dev
, GFP_KERNEL
, "sbs-%s",
770 dev_name(&client
->dev
));
774 chip
= devm_kzalloc(&client
->dev
, sizeof(struct sbs_info
), GFP_KERNEL
);
778 chip
->client
= client
;
779 chip
->enable_detection
= false;
780 psy_cfg
.of_node
= client
->dev
.of_node
;
781 psy_cfg
.drv_data
= chip
;
782 /* ignore first notification of external change, it is generated
783 * from the power_supply_register call back
785 chip
->ignore_changes
= 1;
786 chip
->last_state
= POWER_SUPPLY_STATUS_UNKNOWN
;
788 /* use pdata if available, fall back to DT properties,
789 * or hardcoded defaults if not
791 rc
= of_property_read_u32(client
->dev
.of_node
, "sbs,i2c-retry-count",
792 &chip
->i2c_retry_count
);
794 chip
->i2c_retry_count
= 1;
796 rc
= of_property_read_u32(client
->dev
.of_node
, "sbs,poll-retry-count",
797 &chip
->poll_retry_count
);
799 chip
->poll_retry_count
= 0;
802 chip
->poll_retry_count
= pdata
->poll_retry_count
;
803 chip
->i2c_retry_count
= pdata
->i2c_retry_count
;
806 chip
->gpio_detect
= devm_gpiod_get_optional(&client
->dev
,
807 "sbs,battery-detect", GPIOD_IN
);
808 if (IS_ERR(chip
->gpio_detect
)) {
809 dev_err(&client
->dev
, "Failed to get gpio: %ld\n",
810 PTR_ERR(chip
->gpio_detect
));
811 return PTR_ERR(chip
->gpio_detect
);
814 i2c_set_clientdata(client
, chip
);
816 if (!chip
->gpio_detect
)
819 irq
= gpiod_to_irq(chip
->gpio_detect
);
821 dev_warn(&client
->dev
, "Failed to get gpio as irq: %d\n", irq
);
825 rc
= devm_request_threaded_irq(&client
->dev
, irq
, NULL
, sbs_irq
,
826 IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
,
827 dev_name(&client
->dev
), chip
);
829 dev_warn(&client
->dev
, "Failed to request irq: %d\n", rc
);
835 * Before we register, we might need to make sure we can actually talk
838 if (!(force_load
|| chip
->gpio_detect
)) {
839 rc
= sbs_read_word_data(client
, sbs_data
[REG_STATUS
].addr
);
842 dev_err(&client
->dev
, "%s: Failed to get device status\n",
848 chip
->power_supply
= devm_power_supply_register(&client
->dev
, sbs_desc
,
850 if (IS_ERR(chip
->power_supply
)) {
851 dev_err(&client
->dev
,
852 "%s: Failed to register power supply\n", __func__
);
853 rc
= PTR_ERR(chip
->power_supply
);
857 dev_info(&client
->dev
,
858 "%s: battery gas gauge device registered\n", client
->name
);
860 INIT_DELAYED_WORK(&chip
->work
, sbs_delayed_work
);
862 chip
->enable_detection
= true;
870 static int sbs_remove(struct i2c_client
*client
)
872 struct sbs_info
*chip
= i2c_get_clientdata(client
);
874 cancel_delayed_work_sync(&chip
->work
);
879 #if defined CONFIG_PM_SLEEP
881 static int sbs_suspend(struct device
*dev
)
883 struct i2c_client
*client
= to_i2c_client(dev
);
884 struct sbs_info
*chip
= i2c_get_clientdata(client
);
887 if (chip
->poll_time
> 0)
888 cancel_delayed_work_sync(&chip
->work
);
890 /* write to manufacturer access with sleep command */
891 ret
= sbs_write_word_data(client
, sbs_data
[REG_MANUFACTURER_DATA
].addr
,
892 MANUFACTURER_ACCESS_SLEEP
);
893 if (chip
->is_present
&& ret
< 0)
899 static SIMPLE_DEV_PM_OPS(sbs_pm_ops
, sbs_suspend
, NULL
);
900 #define SBS_PM_OPS (&sbs_pm_ops)
903 #define SBS_PM_OPS NULL
906 static const struct i2c_device_id sbs_id
[] = {
908 { "sbs-battery", 1 },
911 MODULE_DEVICE_TABLE(i2c
, sbs_id
);
913 static const struct of_device_id sbs_dt_ids
[] = {
914 { .compatible
= "sbs,sbs-battery" },
915 { .compatible
= "ti,bq20z75" },
918 MODULE_DEVICE_TABLE(of
, sbs_dt_ids
);
920 static struct i2c_driver sbs_battery_driver
= {
922 .remove
= sbs_remove
,
925 .name
= "sbs-battery",
926 .of_match_table
= sbs_dt_ids
,
930 module_i2c_driver(sbs_battery_driver
);
932 MODULE_DESCRIPTION("SBS battery monitor driver");
933 MODULE_LICENSE("GPL");
935 module_param(force_load
, bool, S_IRUSR
| S_IRGRP
| S_IROTH
);
936 MODULE_PARM_DESC(force_load
,
937 "Attempt to load the driver even if no battery is connected");