?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / power / supply / sbs-battery.c
blob6acd242eed488fc39d3cb083dd7a09b79d3d187b
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Gas Gauge driver for SBS Compliant Batteries
4 *
5 * Copyright (c) 2010, NVIDIA Corporation.
6 */
7
8 #include <linux/bits.h>
9 #include <linux/delay.h>
10 #include <linux/err.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/i2c.h>
13 #include <linux/init.h>
14 #include <linux/interrupt.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/of.h>
18 #include <linux/of_device.h>
19 #include <linux/power/sbs-battery.h>
20 #include <linux/power_supply.h>
21 #include <linux/slab.h>
22 #include <linux/stat.h>
23
24 enum {
25 REG_MANUFACTURER_DATA,
26 REG_TEMPERATURE,
27 REG_VOLTAGE,
28 REG_CURRENT,
29 REG_CAPACITY,
30 REG_TIME_TO_EMPTY,
31 REG_TIME_TO_FULL,
32 REG_STATUS,
33 REG_CAPACITY_LEVEL,
34 REG_CYCLE_COUNT,
35 REG_SERIAL_NUMBER,
36 REG_REMAINING_CAPACITY,
37 REG_REMAINING_CAPACITY_CHARGE,
38 REG_FULL_CHARGE_CAPACITY,
39 REG_FULL_CHARGE_CAPACITY_CHARGE,
40 REG_DESIGN_CAPACITY,
41 REG_DESIGN_CAPACITY_CHARGE,
42 REG_DESIGN_VOLTAGE_MIN,
43 REG_DESIGN_VOLTAGE_MAX,
44 REG_MANUFACTURER,
45 REG_MODEL_NAME,
46 };
47
48 /* Battery Mode defines */
49 #define BATTERY_MODE_OFFSET 0x03
50 #define BATTERY_MODE_CAPACITY_MASK BIT(15)
51 enum sbs_capacity_mode {
52 CAPACITY_MODE_AMPS = 0,
53 CAPACITY_MODE_WATTS = BATTERY_MODE_CAPACITY_MASK
54 };
55
56 /* manufacturer access defines */
57 #define MANUFACTURER_ACCESS_STATUS 0x0006
58 #define MANUFACTURER_ACCESS_SLEEP 0x0011
59
60 /* battery status value bits */
61 #define BATTERY_INITIALIZED 0x80
62 #define BATTERY_DISCHARGING 0x40
63 #define BATTERY_FULL_CHARGED 0x20
64 #define BATTERY_FULL_DISCHARGED 0x10
65
66 /* min_value and max_value are only valid for numerical data */
67 #define SBS_DATA(_psp, _addr, _min_value, _max_value) { \
68 .psp = _psp, \
69 .addr = _addr, \
70 .min_value = _min_value, \
71 .max_value = _max_value, \
72 }
73
74 static const struct chip_data {
75 enum power_supply_property psp;
76 u8 addr;
77 int min_value;
78 int max_value;
79 } sbs_data[] = {
80 [REG_MANUFACTURER_DATA] =
81 SBS_DATA(POWER_SUPPLY_PROP_PRESENT, 0x00, 0, 65535),
82 [REG_TEMPERATURE] =
83 SBS_DATA(POWER_SUPPLY_PROP_TEMP, 0x08, 0, 65535),
84 [REG_VOLTAGE] =
85 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_NOW, 0x09, 0, 20000),
86 [REG_CURRENT] =
87 SBS_DATA(POWER_SUPPLY_PROP_CURRENT_NOW, 0x0A, -32768, 32767),
88 [REG_CAPACITY] =
89 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0D, 0, 100),
90 [REG_REMAINING_CAPACITY] =
91 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535),
92 [REG_REMAINING_CAPACITY_CHARGE] =
93 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_NOW, 0x0F, 0, 65535),
94 [REG_FULL_CHARGE_CAPACITY] =
95 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535),
96 [REG_FULL_CHARGE_CAPACITY_CHARGE] =
97 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL, 0x10, 0, 65535),
98 [REG_TIME_TO_EMPTY] =
99 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0, 65535),
100 [REG_TIME_TO_FULL] =
101 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 0x13, 0, 65535),
102 [REG_STATUS] =
103 SBS_DATA(POWER_SUPPLY_PROP_STATUS, 0x16, 0, 65535),
104 [REG_CAPACITY_LEVEL] =
105 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY_LEVEL, 0x16, 0, 65535),
106 [REG_CYCLE_COUNT] =
107 SBS_DATA(POWER_SUPPLY_PROP_CYCLE_COUNT, 0x17, 0, 65535),
108 [REG_DESIGN_CAPACITY] =
109 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0, 65535),
110 [REG_DESIGN_CAPACITY_CHARGE] =
111 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 0x18, 0, 65535),
112 [REG_DESIGN_VOLTAGE_MIN] =
113 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, 0x19, 0, 65535),
114 [REG_DESIGN_VOLTAGE_MAX] =
115 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0, 65535),
116 [REG_SERIAL_NUMBER] =
117 SBS_DATA(POWER_SUPPLY_PROP_SERIAL_NUMBER, 0x1C, 0, 65535),
118 /* Properties of type `const char *' */
119 [REG_MANUFACTURER] =
120 SBS_DATA(POWER_SUPPLY_PROP_MANUFACTURER, 0x20, 0, 65535),
121 [REG_MODEL_NAME] =
122 SBS_DATA(POWER_SUPPLY_PROP_MODEL_NAME, 0x21, 0, 65535)
123 };
124
125 static enum power_supply_property sbs_properties[] = {
126 POWER_SUPPLY_PROP_STATUS,
127 POWER_SUPPLY_PROP_CAPACITY_LEVEL,
128 POWER_SUPPLY_PROP_HEALTH,
129 POWER_SUPPLY_PROP_PRESENT,
130 POWER_SUPPLY_PROP_TECHNOLOGY,
131 POWER_SUPPLY_PROP_CYCLE_COUNT,
132 POWER_SUPPLY_PROP_VOLTAGE_NOW,
133 POWER_SUPPLY_PROP_CURRENT_NOW,
134 POWER_SUPPLY_PROP_CAPACITY,
135 POWER_SUPPLY_PROP_TEMP,
136 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
137 POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
138 POWER_SUPPLY_PROP_SERIAL_NUMBER,
139 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
140 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
141 POWER_SUPPLY_PROP_ENERGY_NOW,
142 POWER_SUPPLY_PROP_ENERGY_FULL,
143 POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
144 POWER_SUPPLY_PROP_CHARGE_NOW,
145 POWER_SUPPLY_PROP_CHARGE_FULL,
146 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
147 /* Properties of type `const char *' */
148 POWER_SUPPLY_PROP_MANUFACTURER,
149 POWER_SUPPLY_PROP_MODEL_NAME
150 };
151
152 /* Supports special manufacturer commands from TI BQ20Z75 IC. */
153 #define SBS_FLAGS_TI_BQ20Z75 BIT(0)
154
155 struct sbs_info {
156 struct i2c_client *client;
157 struct power_supply *power_supply;
158 bool is_present;
159 struct gpio_desc *gpio_detect;
160 bool enable_detection;
161 int last_state;
162 int poll_time;
163 u32 i2c_retry_count;
164 u32 poll_retry_count;
165 struct delayed_work work;
166 struct mutex mode_lock;
167 u32 flags;
168 };
169
170 static char model_name[I2C_SMBUS_BLOCK_MAX + 1];
171 static char manufacturer[I2C_SMBUS_BLOCK_MAX + 1];
172 static bool force_load;
173
174 static int sbs_read_word_data(struct i2c_client *client, u8 address)
175 {
176 struct sbs_info *chip = i2c_get_clientdata(client);
177 int retries = chip->i2c_retry_count;
178 s32 ret = 0;
179
180 while (retries > 0) {
181 ret = i2c_smbus_read_word_data(client, address);
182 if (ret >= 0)
183 break;
184 retries--;
185 }
186
187 if (ret < 0) {
188 dev_dbg(&client->dev,
189 "%s: i2c read at address 0x%x failed\n",
190 __func__, address);
191 return ret;
192 }
193
194 return ret;
195 }
196
197 static int sbs_read_string_data(struct i2c_client *client, u8 address,
198 char *values)
199 {
200 struct sbs_info *chip = i2c_get_clientdata(client);
201 s32 ret = 0, block_length = 0;
202 int retries_length, retries_block;
203 u8 block_buffer[I2C_SMBUS_BLOCK_MAX + 1];
204
205 retries_length = chip->i2c_retry_count;
206 retries_block = chip->i2c_retry_count;
207
208 /* Adapter needs to support these two functions */
209 if (!i2c_check_functionality(client->adapter,
210 I2C_FUNC_SMBUS_BYTE_DATA |
211 I2C_FUNC_SMBUS_I2C_BLOCK)){
212 return -ENODEV;
213 }
214
215 /* Get the length of block data */
216 while (retries_length > 0) {
217 ret = i2c_smbus_read_byte_data(client, address);
218 if (ret >= 0)
219 break;
220 retries_length--;
221 }
222
223 if (ret < 0) {
224 dev_dbg(&client->dev,
225 "%s: i2c read at address 0x%x failed\n",
226 __func__, address);
227 return ret;
228 }
229
230 /* block_length does not include NULL terminator */
231 block_length = ret;
232 if (block_length > I2C_SMBUS_BLOCK_MAX) {
233 dev_err(&client->dev,
234 "%s: Returned block_length is longer than 0x%x\n",
235 __func__, I2C_SMBUS_BLOCK_MAX);
236 return -EINVAL;
237 }
238
239 /* Get the block data */
240 while (retries_block > 0) {
241 ret = i2c_smbus_read_i2c_block_data(
242 client, address,
243 block_length + 1, block_buffer);
244 if (ret >= 0)
245 break;
246 retries_block--;
247 }
248
249 if (ret < 0) {
250 dev_dbg(&client->dev,
251 "%s: i2c read at address 0x%x failed\n",
252 __func__, address);
253 return ret;
254 }
255
256 /* block_buffer[0] == block_length */
257 memcpy(values, block_buffer + 1, block_length);
258 values[block_length] = '\0';
259
260 return ret;
261 }
262
263 static int sbs_write_word_data(struct i2c_client *client, u8 address,
264 u16 value)
265 {
266 struct sbs_info *chip = i2c_get_clientdata(client);
267 int retries = chip->i2c_retry_count;
268 s32 ret = 0;
269
270 while (retries > 0) {
271 ret = i2c_smbus_write_word_data(client, address, value);
272 if (ret >= 0)
273 break;
274 retries--;
275 }
276
277 if (ret < 0) {
278 dev_dbg(&client->dev,
279 "%s: i2c write to address 0x%x failed\n",
280 __func__, address);
281 return ret;
282 }
283
284 return 0;
285 }
286
287 static int sbs_status_correct(struct i2c_client *client, int *intval)
288 {
289 int ret;
290
291 ret = sbs_read_word_data(client, sbs_data[REG_CURRENT].addr);
292 if (ret < 0)
293 return ret;
294
295 ret = (s16)ret;
296
297 /* Not drawing current means full (cannot be not charging) */
298 if (ret == 0)
299 *intval = POWER_SUPPLY_STATUS_FULL;
300
301 if (*intval == POWER_SUPPLY_STATUS_FULL) {
302 /* Drawing or providing current when full */
303 if (ret > 0)
304 *intval = POWER_SUPPLY_STATUS_CHARGING;
305 else if (ret < 0)
306 *intval = POWER_SUPPLY_STATUS_DISCHARGING;
307 }
308
309 return 0;
310 }
311
312 static int sbs_get_battery_presence_and_health(
313 struct i2c_client *client, enum power_supply_property psp,
314 union power_supply_propval *val)
315 {
316 int ret;
317
318 /* Dummy command; if it succeeds, battery is present. */
319 ret = sbs_read_word_data(client, sbs_data[REG_STATUS].addr);
320
321 if (ret < 0) { /* battery not present*/
322 if (psp == POWER_SUPPLY_PROP_PRESENT) {
323 val->intval = 0;
324 return 0;
325 }
326 return ret;
327 }
328
329 if (psp == POWER_SUPPLY_PROP_PRESENT)
330 val->intval = 1; /* battery present */
331 else /* POWER_SUPPLY_PROP_HEALTH */
332 /* SBS spec doesn't have a general health command. */
333 val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
334
335 return 0;
336 }
337
338 static int sbs_get_ti_battery_presence_and_health(
339 struct i2c_client *client, enum power_supply_property psp,
340 union power_supply_propval *val)
341 {
342 s32 ret;
343
344 /*
345 * Write to ManufacturerAccess with ManufacturerAccess command
346 * and then read the status.
347 */
348 ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr,
349 MANUFACTURER_ACCESS_STATUS);
350 if (ret < 0) {
351 if (psp == POWER_SUPPLY_PROP_PRESENT)
352 val->intval = 0; /* battery removed */
353 return ret;
354 }
355
356 ret = sbs_read_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr);
357 if (ret < 0) {
358 if (psp == POWER_SUPPLY_PROP_PRESENT)
359 val->intval = 0; /* battery removed */
360 return ret;
361 }
362
363 if (ret < sbs_data[REG_MANUFACTURER_DATA].min_value ||
364 ret > sbs_data[REG_MANUFACTURER_DATA].max_value) {
365 val->intval = 0;
366 return 0;
367 }
368
369 /* Mask the upper nibble of 2nd byte and
370 * lower byte of response then
371 * shift the result by 8 to get status*/
372 ret &= 0x0F00;
373 ret >>= 8;
374 if (psp == POWER_SUPPLY_PROP_PRESENT) {
375 if (ret == 0x0F)
376 /* battery removed */
377 val->intval = 0;
378 else
379 val->intval = 1;
380 } else if (psp == POWER_SUPPLY_PROP_HEALTH) {
381 if (ret == 0x09)
382 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
383 else if (ret == 0x0B)
384 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
385 else if (ret == 0x0C)
386 val->intval = POWER_SUPPLY_HEALTH_DEAD;
387 else
388 val->intval = POWER_SUPPLY_HEALTH_GOOD;
389 }
390
391 return 0;
392 }
393
394 static int sbs_get_battery_property(struct i2c_client *client,
395 int reg_offset, enum power_supply_property psp,
396 union power_supply_propval *val)
397 {
398 struct sbs_info *chip = i2c_get_clientdata(client);
399 s32 ret;
400
401 ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
402 if (ret < 0)
403 return ret;
404
405 /* returned values are 16 bit */
406 if (sbs_data[reg_offset].min_value < 0)
407 ret = (s16)ret;
408
409 if (ret >= sbs_data[reg_offset].min_value &&
410 ret <= sbs_data[reg_offset].max_value) {
411 val->intval = ret;
412 if (psp == POWER_SUPPLY_PROP_CAPACITY_LEVEL) {
413 if (!(ret & BATTERY_INITIALIZED))
414 val->intval =
415 POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
416 else if (ret & BATTERY_FULL_CHARGED)
417 val->intval =
418 POWER_SUPPLY_CAPACITY_LEVEL_FULL;
419 else if (ret & BATTERY_FULL_DISCHARGED)
420 val->intval =
421 POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
422 else
423 val->intval =
424 POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
425 return 0;
426 } else if (psp != POWER_SUPPLY_PROP_STATUS) {
427 return 0;
428 }
429
430 if (ret & BATTERY_FULL_CHARGED)
431 val->intval = POWER_SUPPLY_STATUS_FULL;
432 else if (ret & BATTERY_DISCHARGING)
433 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
434 else
435 val->intval = POWER_SUPPLY_STATUS_CHARGING;
436
437 sbs_status_correct(client, &val->intval);
438
439 if (chip->poll_time == 0)
440 chip->last_state = val->intval;
441 else if (chip->last_state != val->intval) {
442 cancel_delayed_work_sync(&chip->work);
443 power_supply_changed(chip->power_supply);
444 chip->poll_time = 0;
445 }
446 } else {
447 if (psp == POWER_SUPPLY_PROP_STATUS)
448 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
449 else if (psp == POWER_SUPPLY_PROP_CAPACITY)
450 /* sbs spec says that this can be >100 %
451 * even if max value is 100 %
452 */
453 val->intval = min(ret, 100);
454 else
455 val->intval = 0;
456 }
457
458 return 0;
459 }
460
461 static int sbs_get_battery_string_property(struct i2c_client *client,
462 int reg_offset, enum power_supply_property psp, char *val)
463 {
464 s32 ret;
465
466 ret = sbs_read_string_data(client, sbs_data[reg_offset].addr, val);
467
468 if (ret < 0)
469 return ret;
470
471 return 0;
472 }
473
474 static void sbs_unit_adjustment(struct i2c_client *client,
475 enum power_supply_property psp, union power_supply_propval *val)
476 {
477 #define BASE_UNIT_CONVERSION 1000
478 #define BATTERY_MODE_CAP_MULT_WATT (10 * BASE_UNIT_CONVERSION)
479 #define TIME_UNIT_CONVERSION 60
480 #define TEMP_KELVIN_TO_CELSIUS 2731
481 switch (psp) {
482 case POWER_SUPPLY_PROP_ENERGY_NOW:
483 case POWER_SUPPLY_PROP_ENERGY_FULL:
484 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
485 /* sbs provides energy in units of 10mWh.
486 * Convert to µWh
487 */
488 val->intval *= BATTERY_MODE_CAP_MULT_WATT;
489 break;
490
491 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
492 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
493 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
494 case POWER_SUPPLY_PROP_CURRENT_NOW:
495 case POWER_SUPPLY_PROP_CHARGE_NOW:
496 case POWER_SUPPLY_PROP_CHARGE_FULL:
497 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
498 val->intval *= BASE_UNIT_CONVERSION;
499 break;
500
501 case POWER_SUPPLY_PROP_TEMP:
502 /* sbs provides battery temperature in 0.1K
503 * so convert it to 0.1°C
504 */
505 val->intval -= TEMP_KELVIN_TO_CELSIUS;
506 break;
507
508 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
509 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
510 /* sbs provides time to empty and time to full in minutes.
511 * Convert to seconds
512 */
513 val->intval *= TIME_UNIT_CONVERSION;
514 break;
515
516 default:
517 dev_dbg(&client->dev,
518 "%s: no need for unit conversion %d\n", __func__, psp);
519 }
520 }
521
522 static enum sbs_capacity_mode sbs_set_capacity_mode(struct i2c_client *client,
523 enum sbs_capacity_mode mode)
524 {
525 int ret, original_val;
526
527 original_val = sbs_read_word_data(client, BATTERY_MODE_OFFSET);
528 if (original_val < 0)
529 return original_val;
530
531 if ((original_val & BATTERY_MODE_CAPACITY_MASK) == mode)
532 return mode;
533
534 if (mode == CAPACITY_MODE_AMPS)
535 ret = original_val & ~BATTERY_MODE_CAPACITY_MASK;
536 else
537 ret = original_val | BATTERY_MODE_CAPACITY_MASK;
538
539 ret = sbs_write_word_data(client, BATTERY_MODE_OFFSET, ret);
540 if (ret < 0)
541 return ret;
542
543 usleep_range(1000, 2000);
544
545 return original_val & BATTERY_MODE_CAPACITY_MASK;
546 }
547
548 static int sbs_get_battery_capacity(struct i2c_client *client,
549 int reg_offset, enum power_supply_property psp,
550 union power_supply_propval *val)
551 {
552 s32 ret;
553 enum sbs_capacity_mode mode = CAPACITY_MODE_WATTS;
554
555 if (power_supply_is_amp_property(psp))
556 mode = CAPACITY_MODE_AMPS;
557
558 mode = sbs_set_capacity_mode(client, mode);
559 if ((int)mode < 0)
560 return mode;
561
562 ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
563 if (ret < 0)
564 return ret;
565
566 val->intval = ret;
567
568 ret = sbs_set_capacity_mode(client, mode);
569 if (ret < 0)
570 return ret;
571
572 return 0;
573 }
574
575 static char sbs_serial[5];
576 static int sbs_get_battery_serial_number(struct i2c_client *client,
577 union power_supply_propval *val)
578 {
579 int ret;
580
581 ret = sbs_read_word_data(client, sbs_data[REG_SERIAL_NUMBER].addr);
582 if (ret < 0)
583 return ret;
584
585 sprintf(sbs_serial, "%04x", ret);
586 val->strval = sbs_serial;
587
588 return 0;
589 }
590
591 static int sbs_get_property_index(struct i2c_client *client,
592 enum power_supply_property psp)
593 {
594 int count;
595 for (count = 0; count < ARRAY_SIZE(sbs_data); count++)
596 if (psp == sbs_data[count].psp)
597 return count;
598
599 dev_warn(&client->dev,
600 "%s: Invalid Property - %d\n", __func__, psp);
601
602 return -EINVAL;
603 }
604
605 static int sbs_get_property(struct power_supply *psy,
606 enum power_supply_property psp,
607 union power_supply_propval *val)
608 {
609 int ret = 0;
610 struct sbs_info *chip = power_supply_get_drvdata(psy);
611 struct i2c_client *client = chip->client;
612
613 if (chip->gpio_detect) {
614 ret = gpiod_get_value_cansleep(chip->gpio_detect);
615 if (ret < 0)
616 return ret;
617 if (psp == POWER_SUPPLY_PROP_PRESENT) {
618 val->intval = ret;
619 chip->is_present = val->intval;
620 return 0;
621 }
622 if (ret == 0)
623 return -ENODATA;
624 }
625
626 switch (psp) {
627 case POWER_SUPPLY_PROP_PRESENT:
628 case POWER_SUPPLY_PROP_HEALTH:
629 if (chip->flags & SBS_FLAGS_TI_BQ20Z75)
630 ret = sbs_get_ti_battery_presence_and_health(client,
631 psp, val);
632 else
633 ret = sbs_get_battery_presence_and_health(client, psp,
634 val);
635
636 /* this can only be true if no gpio is used */
637 if (psp == POWER_SUPPLY_PROP_PRESENT)
638 return 0;
639 break;
640
641 case POWER_SUPPLY_PROP_TECHNOLOGY:
642 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
643 goto done; /* don't trigger power_supply_changed()! */
644
645 case POWER_SUPPLY_PROP_ENERGY_NOW:
646 case POWER_SUPPLY_PROP_ENERGY_FULL:
647 case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
648 case POWER_SUPPLY_PROP_CHARGE_NOW:
649 case POWER_SUPPLY_PROP_CHARGE_FULL:
650 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
651 ret = sbs_get_property_index(client, psp);
652 if (ret < 0)
653 break;
654
655 /* sbs_get_battery_capacity() will change the battery mode
656 * temporarily to read the requested attribute. Ensure we stay
657 * in the desired mode for the duration of the attribute read.
658 */
659 mutex_lock(&chip->mode_lock);
660 ret = sbs_get_battery_capacity(client, ret, psp, val);
661 mutex_unlock(&chip->mode_lock);
662 break;
663
664 case POWER_SUPPLY_PROP_SERIAL_NUMBER:
665 ret = sbs_get_battery_serial_number(client, val);
666 break;
667
668 case POWER_SUPPLY_PROP_STATUS:
669 case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
670 case POWER_SUPPLY_PROP_CYCLE_COUNT:
671 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
672 case POWER_SUPPLY_PROP_CURRENT_NOW:
673 case POWER_SUPPLY_PROP_TEMP:
674 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
675 case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
676 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
677 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
678 case POWER_SUPPLY_PROP_CAPACITY:
679 ret = sbs_get_property_index(client, psp);
680 if (ret < 0)
681 break;
682
683 ret = sbs_get_battery_property(client, ret, psp, val);
684 break;
685
686 case POWER_SUPPLY_PROP_MODEL_NAME:
687 ret = sbs_get_property_index(client, psp);
688 if (ret < 0)
689 break;
690
691 ret = sbs_get_battery_string_property(client, ret, psp,
692 model_name);
693 val->strval = model_name;
694 break;
695
696 case POWER_SUPPLY_PROP_MANUFACTURER:
697 ret = sbs_get_property_index(client, psp);
698 if (ret < 0)
699 break;
700
701 ret = sbs_get_battery_string_property(client, ret, psp,
702 manufacturer);
703 val->strval = manufacturer;
704 break;
705
706 default:
707 dev_err(&client->dev,
708 "%s: INVALID property\n", __func__);
709 return -EINVAL;
710 }
711
712 if (!chip->enable_detection)
713 goto done;
714
715 if (!chip->gpio_detect &&
716 chip->is_present != (ret >= 0)) {
717 chip->is_present = (ret >= 0);
718 power_supply_changed(chip->power_supply);
719 }
720
721 done:
722 if (!ret) {
723 /* Convert units to match requirements for power supply class */
724 sbs_unit_adjustment(client, psp, val);
725 }
726
727 dev_dbg(&client->dev,
728 "%s: property = %d, value = %x\n", __func__, psp, val->intval);
729
730 if (ret && chip->is_present)
731 return ret;
732
733 /* battery not present, so return NODATA for properties */
734 if (ret)
735 return -ENODATA;
736
737 return 0;
738 }
739
740 static void sbs_supply_changed(struct sbs_info *chip)
741 {
742 struct power_supply *battery = chip->power_supply;
743 int ret;
744
745 ret = gpiod_get_value_cansleep(chip->gpio_detect);
746 if (ret < 0)
747 return;
748 chip->is_present = ret;
749 power_supply_changed(battery);
750 }
751
752 static irqreturn_t sbs_irq(int irq, void *devid)
753 {
754 sbs_supply_changed(devid);
755 return IRQ_HANDLED;
756 }
757
758 static void sbs_alert(struct i2c_client *client, enum i2c_alert_protocol prot,
759 unsigned int data)
760 {
761 sbs_supply_changed(i2c_get_clientdata(client));
762 }
763
764 static void sbs_external_power_changed(struct power_supply *psy)
765 {
766 struct sbs_info *chip = power_supply_get_drvdata(psy);
767
768 /* cancel outstanding work */
769 cancel_delayed_work_sync(&chip->work);
770
771 schedule_delayed_work(&chip->work, HZ);
772 chip->poll_time = chip->poll_retry_count;
773 }
774
775 static void sbs_delayed_work(struct work_struct *work)
776 {
777 struct sbs_info *chip;
778 s32 ret;
779
780 chip = container_of(work, struct sbs_info, work.work);
781
782 ret = sbs_read_word_data(chip->client, sbs_data[REG_STATUS].addr);
783 /* if the read failed, give up on this work */
784 if (ret < 0) {
785 chip->poll_time = 0;
786 return;
787 }
788
789 if (ret & BATTERY_FULL_CHARGED)
790 ret = POWER_SUPPLY_STATUS_FULL;
791 else if (ret & BATTERY_DISCHARGING)
792 ret = POWER_SUPPLY_STATUS_DISCHARGING;
793 else
794 ret = POWER_SUPPLY_STATUS_CHARGING;
795
796 sbs_status_correct(chip->client, &ret);
797
798 if (chip->last_state != ret) {
799 chip->poll_time = 0;
800 power_supply_changed(chip->power_supply);
801 return;
802 }
803 if (chip->poll_time > 0) {
804 schedule_delayed_work(&chip->work, HZ);
805 chip->poll_time--;
806 return;
807 }
808 }
809
810 static const struct power_supply_desc sbs_default_desc = {
811 .type = POWER_SUPPLY_TYPE_BATTERY,
812 .properties = sbs_properties,
813 .num_properties = ARRAY_SIZE(sbs_properties),
814 .get_property = sbs_get_property,
815 .external_power_changed = sbs_external_power_changed,
816 };
817
818 static int sbs_probe(struct i2c_client *client,
819 const struct i2c_device_id *id)
820 {
821 struct sbs_info *chip;
822 struct power_supply_desc *sbs_desc;
823 struct sbs_platform_data *pdata = client->dev.platform_data;
824 struct power_supply_config psy_cfg = {};
825 int rc;
826 int irq;
827
828 sbs_desc = devm_kmemdup(&client->dev, &sbs_default_desc,
829 sizeof(*sbs_desc), GFP_KERNEL);
830 if (!sbs_desc)
831 return -ENOMEM;
832
833 sbs_desc->name = devm_kasprintf(&client->dev, GFP_KERNEL, "sbs-%s",
834 dev_name(&client->dev));
835 if (!sbs_desc->name)
836 return -ENOMEM;
837
838 chip = devm_kzalloc(&client->dev, sizeof(struct sbs_info), GFP_KERNEL);
839 if (!chip)
840 return -ENOMEM;
841
842 chip->flags = (u32)(uintptr_t)of_device_get_match_data(&client->dev);
843 chip->client = client;
844 chip->enable_detection = false;
845 psy_cfg.of_node = client->dev.of_node;
846 psy_cfg.drv_data = chip;
847 chip->last_state = POWER_SUPPLY_STATUS_UNKNOWN;
848 mutex_init(&chip->mode_lock);
849
850 /* use pdata if available, fall back to DT properties,
851 * or hardcoded defaults if not
852 */
853 rc = of_property_read_u32(client->dev.of_node, "sbs,i2c-retry-count",
854 &chip->i2c_retry_count);
855 if (rc)
856 chip->i2c_retry_count = 0;
857
858 rc = of_property_read_u32(client->dev.of_node, "sbs,poll-retry-count",
859 &chip->poll_retry_count);
860 if (rc)
861 chip->poll_retry_count = 0;
862
863 if (pdata) {
864 chip->poll_retry_count = pdata->poll_retry_count;
865 chip->i2c_retry_count = pdata->i2c_retry_count;
866 }
867 chip->i2c_retry_count = chip->i2c_retry_count + 1;
868
869 chip->gpio_detect = devm_gpiod_get_optional(&client->dev,
870 "sbs,battery-detect", GPIOD_IN);
871 if (IS_ERR(chip->gpio_detect)) {
872 dev_err(&client->dev, "Failed to get gpio: %ld\n",
873 PTR_ERR(chip->gpio_detect));
874 return PTR_ERR(chip->gpio_detect);
875 }
876
877 i2c_set_clientdata(client, chip);
878
879 if (!chip->gpio_detect)
880 goto skip_gpio;
881
882 irq = gpiod_to_irq(chip->gpio_detect);
883 if (irq <= 0) {
884 dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq);
885 goto skip_gpio;
886 }
887
888 rc = devm_request_threaded_irq(&client->dev, irq, NULL, sbs_irq,
889 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
890 dev_name(&client->dev), chip);
891 if (rc) {
892 dev_warn(&client->dev, "Failed to request irq: %d\n", rc);
893 goto skip_gpio;
894 }
895
896 skip_gpio:
897 /*
898 * Before we register, we might need to make sure we can actually talk
899 * to the battery.
900 */
901 if (!(force_load || chip->gpio_detect)) {
902 rc = sbs_read_word_data(client, sbs_data[REG_STATUS].addr);
903
904 if (rc < 0) {
905 dev_err(&client->dev, "%s: Failed to get device status\n",
906 __func__);
907 goto exit_psupply;
908 }
909 }
910
911 chip->power_supply = devm_power_supply_register(&client->dev, sbs_desc,
912 &psy_cfg);
913 if (IS_ERR(chip->power_supply)) {
914 dev_err(&client->dev,
915 "%s: Failed to register power supply\n", __func__);
916 rc = PTR_ERR(chip->power_supply);
917 goto exit_psupply;
918 }
919
920 dev_info(&client->dev,
921 "%s: battery gas gauge device registered\n", client->name);
922
923 INIT_DELAYED_WORK(&chip->work, sbs_delayed_work);
924
925 chip->enable_detection = true;
926
927 return 0;
928
929 exit_psupply:
930 return rc;
931 }
932
933 static int sbs_remove(struct i2c_client *client)
934 {
935 struct sbs_info *chip = i2c_get_clientdata(client);
936
937 cancel_delayed_work_sync(&chip->work);
938
939 return 0;
940 }
941
942 #if defined CONFIG_PM_SLEEP
943
944 static int sbs_suspend(struct device *dev)
945 {
946 struct i2c_client *client = to_i2c_client(dev);
947 struct sbs_info *chip = i2c_get_clientdata(client);
948 int ret;
949
950 if (chip->poll_time > 0)
951 cancel_delayed_work_sync(&chip->work);
952
953 if (chip->flags & SBS_FLAGS_TI_BQ20Z75) {
954 /* Write to manufacturer access with sleep command. */
955 ret = sbs_write_word_data(client,
956 sbs_data[REG_MANUFACTURER_DATA].addr,
957 MANUFACTURER_ACCESS_SLEEP);
958 if (chip->is_present && ret < 0)
959 return ret;
960 }
961
962 return 0;
963 }
964
965 static SIMPLE_DEV_PM_OPS(sbs_pm_ops, sbs_suspend, NULL);
966 #define SBS_PM_OPS (&sbs_pm_ops)
967
968 #else
969 #define SBS_PM_OPS NULL
970 #endif
971
972 static const struct i2c_device_id sbs_id[] = {
973 { "bq20z75", 0 },
974 { "sbs-battery", 1 },
975 {}
976 };
977 MODULE_DEVICE_TABLE(i2c, sbs_id);
978
979 static const struct of_device_id sbs_dt_ids[] = {
980 { .compatible = "sbs,sbs-battery" },
981 {
982 .compatible = "ti,bq20z75",
983 .data = (void *)SBS_FLAGS_TI_BQ20Z75,
984 },
985 { }
986 };
987 MODULE_DEVICE_TABLE(of, sbs_dt_ids);
988
989 static struct i2c_driver sbs_battery_driver = {
990 .probe = sbs_probe,
991 .remove = sbs_remove,
992 .alert = sbs_alert,
993 .id_table = sbs_id,
994 .driver = {
995 .name = "sbs-battery",
996 .of_match_table = sbs_dt_ids,
997 .pm = SBS_PM_OPS,
998 },
999 };
1000 module_i2c_driver(sbs_battery_driver);
1001
1002 MODULE_DESCRIPTION("SBS battery monitor driver");
1003 MODULE_LICENSE("GPL");
1004
1005 module_param(force_load, bool, 0444);
1006 MODULE_PARM_DESC(force_load,
1007 "Attempt to load the driver even if no battery is connected");
Linux with added FPC-III support