1// SPDX-License-Identifier: GPL-2.0
2/*
3 * stc3117_fuel_gauge.c - STMicroelectronics STC3117 Fuel Gauge Driver
4 *
5 * Copyright (c) 2024 Silicon Signals Pvt Ltd.
6 * Author: Hardevsinh Palaniya <hardevsinh.palaniya@siliconsignals.io>
7 * Bhavin Sharma <bhavin.sharma@siliconsignals.io>
8 */
9
10#include <linux/crc8.h>
11#include <linux/devm-helpers.h>
12#include <linux/i2c.h>
13#include <linux/power_supply.h>
14#include <linux/regmap.h>
15#include <linux/workqueue.h>
16
17#define STC3117_ADDR_MODE 0x00
18#define STC3117_ADDR_CTRL 0x01
19#define STC3117_ADDR_SOC_L 0x02
20#define STC3117_ADDR_SOC_H 0x03
21#define STC3117_ADDR_COUNTER_L 0x04
22#define STC3117_ADDR_COUNTER_H 0x05
23#define STC3117_ADDR_CURRENT_L 0x06
24#define STC3117_ADDR_CURRENT_H 0x07
25#define STC3117_ADDR_VOLTAGE_L 0x08
26#define STC3117_ADDR_VOLTAGE_H 0x09
27#define STC3117_ADDR_TEMPERATURE 0x0A
28#define STC3117_ADDR_AVG_CURRENT_L 0x0B
29#define STC3117_ADDR_AVG_CURRENT_H 0x0C
30#define STC3117_ADDR_OCV_L 0x0D
31#define STC3117_ADDR_OCV_H 0x0E
32#define STC3117_ADDR_CC_CNF_L 0x0F
33#define STC3117_ADDR_CC_CNF_H 0x10
34#define STC3117_ADDR_VM_CNF_L 0x11
35#define STC3117_ADDR_VM_CNF_H 0x12
36#define STC3117_ADDR_ALARM_soc 0x13
37#define STC3117_ADDR_ALARM_VOLTAGE 0x14
38#define STC3117_ADDR_ID 0x18
39#define STC3117_ADDR_CC_ADJ_L 0x1B
40#define STC3117_ADDR_CC_ADJ_H 0x1C
41#define STC3117_ADDR_VM_ADJ_L 0x1D
42#define STC3117_ADDR_VM_ADJ_H 0x1E
43#define STC3117_ADDR_RAM 0x20
44#define STC3117_ADDR_OCV_TABLE 0x30
45#define STC3117_ADDR_SOC_TABLE 0x30
46
47/* Bit mask definition */
48#define STC3117_ID 0x16
49#define STC3117_MIXED_MODE 0x00
50#define STC3117_VMODE BIT(0)
51#define STC3117_GG_RUN BIT(4)
52#define STC3117_CC_MODE BIT(5)
53#define STC3117_BATFAIL BIT(3)
54#define STC3117_PORDET BIT(4)
55#define STC3117_RAM_SIZE 16
56#define STC3117_OCV_TABLE_SIZE 16
57#define STC3117_RAM_TESTWORD 0x53A9
58#define STC3117_SOFT_RESET 0x11
59#define STC3117_NOMINAL_CAPACITY 2600
60
61#define VOLTAGE_LSB_VALUE 9011
62#define CURRENT_LSB_VALUE 24084
63#define APP_CUTOFF_VOLTAGE 2500
64#define MAX_HRSOC 51200
65#define MAX_SOC 1000
66#define CHG_MIN_CURRENT 200
67#define CHG_END_CURRENT 20
68#define APP_MIN_CURRENT (-5)
69#define BATTERY_FULL 95
70#define CRC8_POLYNOMIAL 0x07
71#define CRC8_INIT 0x00
72
73DECLARE_CRC8_TABLE(stc3117_crc_table);
74
75enum stc3117_state {
76 STC3117_INIT,
77 STC3117_RUNNING,
78 STC3117_POWERDN,
79};
80
81/* Default ocv curve Li-ion battery */
82static const int ocv_value[16] = {
83 3400, 3582, 3669, 3676, 3699, 3737, 3757, 3774,
84 3804, 3844, 3936, 3984, 4028, 4131, 4246, 4320
85};
86
87union stc3117_internal_ram {
88 u8 ram_bytes[STC3117_RAM_SIZE];
89 struct {
90 u16 testword; /* 0-1 Bytes */
91 u16 hrsoc; /* 2-3 Bytes */
92 u16 cc_cnf; /* 4-5 Bytes */
93 u16 vm_cnf; /* 6-7 Bytes */
94 u8 soc; /* 8 Byte */
95 u8 state; /* 9 Byte */
96 u8 unused[5]; /* 10-14 Bytes */
97 u8 crc; /* 15 Byte */
98 } reg;
99};
100
101struct stc3117_battery_info {
102 int voltage_min_mv;
103 int voltage_max_mv;
104 int battery_capacity_mah;
105 int sense_resistor;
106};
107
108struct stc3117_data {
109 struct i2c_client *client;
110 struct regmap *regmap;
111 struct delayed_work update_work;
112 struct power_supply *battery;
113 union stc3117_internal_ram ram_data;
114 struct stc3117_battery_info battery_info;
115
116 u8 soc_tab[16];
117 int cc_cnf;
118 int vm_cnf;
119 int cc_adj;
120 int vm_adj;
121 int avg_current;
122 int avg_voltage;
123 int batt_current;
124 int voltage;
125 int temp;
126 int soc;
127 int ocv;
128 int hrsoc;
129 int presence;
130};
131
132static int stc3117_convert(int value, int factor)
133{
134 value = (value * factor) / 4096;
135 return value * 1000;
136}
137
138static int stc3117_get_battery_data(struct stc3117_data *data)
139{
140 u8 reg_list[16];
141 u8 data_adjust[4];
142 int value, mode;
143
144 regmap_bulk_read(map: data->regmap, STC3117_ADDR_MODE,
145 val: reg_list, val_count: sizeof(reg_list));
146
147 /* soc */
148 value = (reg_list[3] << 8) + reg_list[2];
149 data->hrsoc = value;
150 data->soc = (value * 10 + 256) / 512;
151
152 /* current in uA*/
153 value = (reg_list[7] << 8) + reg_list[6];
154 data->batt_current = stc3117_convert(value,
155 CURRENT_LSB_VALUE / data->battery_info.sense_resistor);
156
157 /* voltage in uV */
158 value = (reg_list[9] << 8) + reg_list[8];
159 data->voltage = stc3117_convert(value, VOLTAGE_LSB_VALUE);
160
161 /* temp in 1/10 °C */
162 data->temp = reg_list[10] * 10;
163
164 /* Avg current in uA */
165 value = (reg_list[12] << 8) + reg_list[11];
166 regmap_read(map: data->regmap, STC3117_ADDR_MODE, val: &mode);
167 if (!(mode & STC3117_VMODE)) {
168 value = stc3117_convert(value,
169 CURRENT_LSB_VALUE / data->battery_info.sense_resistor);
170 value = value / 4;
171 } else {
172 value = stc3117_convert(value, factor: 36 * STC3117_NOMINAL_CAPACITY);
173 }
174 data->avg_current = value;
175
176 /* ocv in uV */
177 value = (reg_list[14] << 8) + reg_list[13];
178 value = stc3117_convert(value, VOLTAGE_LSB_VALUE);
179 value = (value + 2) / 4;
180 data->ocv = value;
181
182 /* CC & VM adjustment counters */
183 regmap_bulk_read(map: data->regmap, STC3117_ADDR_CC_ADJ_L,
184 val: data_adjust, val_count: sizeof(data_adjust));
185 value = (data_adjust[1] << 8) + data_adjust[0];
186 data->cc_adj = value;
187
188 value = (data_adjust[3] << 8) + data_adjust[2];
189 data->vm_adj = value;
190
191 return 0;
192}
193
194static int ram_write(struct stc3117_data *data)
195{
196 int ret;
197
198 ret = regmap_bulk_write(map: data->regmap, STC3117_ADDR_RAM,
199 val: data->ram_data.ram_bytes, STC3117_RAM_SIZE);
200 if (ret)
201 return ret;
202
203 return 0;
204};
205
206static int ram_read(struct stc3117_data *data)
207{
208 int ret;
209
210 ret = regmap_bulk_read(map: data->regmap, STC3117_ADDR_RAM,
211 val: data->ram_data.ram_bytes, STC3117_RAM_SIZE);
212 if (ret)
213 return ret;
214
215 return 0;
216};
217
218static int stc3117_set_para(struct stc3117_data *data)
219{
220 int ret;
221
222 ret = regmap_write(map: data->regmap, STC3117_ADDR_MODE, STC3117_VMODE);
223
224 for (int i = 0; i < STC3117_OCV_TABLE_SIZE; i++)
225 ret |= regmap_write(map: data->regmap, STC3117_ADDR_OCV_TABLE + i,
226 val: ocv_value[i] * 100 / 55);
227 if (data->soc_tab[1] != 0)
228 ret |= regmap_bulk_write(map: data->regmap, STC3117_ADDR_SOC_TABLE,
229 val: data->soc_tab, STC3117_OCV_TABLE_SIZE);
230
231 ret |= regmap_write(map: data->regmap, STC3117_ADDR_CC_CNF_H,
232 val: (data->ram_data.reg.cc_cnf >> 8) & 0xFF);
233
234 ret |= regmap_write(map: data->regmap, STC3117_ADDR_CC_CNF_L,
235 val: data->ram_data.reg.cc_cnf & 0xFF);
236
237 ret |= regmap_write(map: data->regmap, STC3117_ADDR_VM_CNF_H,
238 val: (data->ram_data.reg.vm_cnf >> 8) & 0xFF);
239
240 ret |= regmap_write(map: data->regmap, STC3117_ADDR_VM_CNF_L,
241 val: data->ram_data.reg.vm_cnf & 0xFF);
242
243 ret |= regmap_write(map: data->regmap, STC3117_ADDR_CTRL, val: 0x03);
244
245 ret |= regmap_write(map: data->regmap, STC3117_ADDR_MODE,
246 STC3117_MIXED_MODE | STC3117_GG_RUN);
247
248 return ret;
249};
250
251static int stc3117_init(struct stc3117_data *data)
252{
253 int id, ret;
254 int ctrl;
255 int ocv_m, ocv_l;
256
257 regmap_read(map: data->regmap, STC3117_ADDR_ID, val: &id);
258 if (id != STC3117_ID)
259 return -EINVAL;
260
261 data->cc_cnf = (data->battery_info.battery_capacity_mah *
262 data->battery_info.sense_resistor * 250 + 6194) / 12389;
263 data->vm_cnf = (data->battery_info.battery_capacity_mah
264 * 200 * 50 + 24444) / 48889;
265
266 /* Battery has not been removed */
267 data->presence = 1;
268
269 /* Read RAM data */
270 ret = ram_read(data);
271 if (ret)
272 return ret;
273
274 if (data->ram_data.reg.testword != STC3117_RAM_TESTWORD ||
275 (crc8(table: stc3117_crc_table, pdata: data->ram_data.ram_bytes,
276 STC3117_RAM_SIZE, CRC8_INIT)) != 0) {
277 data->ram_data.reg.testword = STC3117_RAM_TESTWORD;
278 data->ram_data.reg.cc_cnf = data->cc_cnf;
279 data->ram_data.reg.vm_cnf = data->vm_cnf;
280 data->ram_data.reg.crc = crc8(table: stc3117_crc_table,
281 pdata: data->ram_data.ram_bytes,
282 STC3117_RAM_SIZE - 1, CRC8_INIT);
283
284 ret = regmap_read(map: data->regmap, STC3117_ADDR_OCV_H, val: &ocv_m);
285
286 ret |= regmap_read(map: data->regmap, STC3117_ADDR_OCV_L, val: &ocv_l);
287
288 ret |= stc3117_set_para(data);
289
290 ret |= regmap_write(map: data->regmap, STC3117_ADDR_OCV_H, val: ocv_m);
291
292 ret |= regmap_write(map: data->regmap, STC3117_ADDR_OCV_L, val: ocv_l);
293 if (ret)
294 return ret;
295 } else {
296 ret = regmap_read(map: data->regmap, STC3117_ADDR_CTRL, val: &ctrl);
297 if (ret)
298 return ret;
299
300 if ((ctrl & STC3117_BATFAIL) != 0 ||
301 (ctrl & STC3117_PORDET) != 0) {
302 ret = regmap_read(map: data->regmap,
303 STC3117_ADDR_OCV_H, val: &ocv_m);
304
305 ret |= regmap_read(map: data->regmap,
306 STC3117_ADDR_OCV_L, val: &ocv_l);
307
308 ret |= stc3117_set_para(data);
309
310 ret |= regmap_write(map: data->regmap,
311 STC3117_ADDR_OCV_H, val: ocv_m);
312
313 ret |= regmap_write(map: data->regmap,
314 STC3117_ADDR_OCV_L, val: ocv_l);
315 if (ret)
316 return ret;
317 } else {
318 ret = stc3117_set_para(data);
319 ret |= regmap_write(map: data->regmap, STC3117_ADDR_SOC_H,
320 val: (data->ram_data.reg.hrsoc >> 8 & 0xFF));
321 ret |= regmap_write(map: data->regmap, STC3117_ADDR_SOC_L,
322 val: (data->ram_data.reg.hrsoc & 0xFF));
323 if (ret)
324 return ret;
325 }
326 }
327
328 data->ram_data.reg.state = STC3117_INIT;
329 data->ram_data.reg.crc = crc8(table: stc3117_crc_table,
330 pdata: data->ram_data.ram_bytes,
331 STC3117_RAM_SIZE - 1, CRC8_INIT);
332 ret = ram_write(data);
333 if (ret)
334 return ret;
335
336 return 0;
337};
338
339static int stc3117_task(struct stc3117_data *data)
340{
341 int id, mode, ret;
342 int count_l, count_m;
343 int ocv_l, ocv_m;
344
345 regmap_read(map: data->regmap, STC3117_ADDR_ID, val: &id);
346 if (id != STC3117_ID) {
347 data->presence = 0;
348 return -EINVAL;
349 }
350
351 stc3117_get_battery_data(data);
352
353 /* Read RAM data */
354 ret = ram_read(data);
355 if (ret)
356 return ret;
357
358 if (data->ram_data.reg.testword != STC3117_RAM_TESTWORD ||
359 (crc8(table: stc3117_crc_table, pdata: data->ram_data.ram_bytes,
360 STC3117_RAM_SIZE, CRC8_INIT) != 0)) {
361 data->ram_data.reg.testword = STC3117_RAM_TESTWORD;
362 data->ram_data.reg.cc_cnf = data->cc_cnf;
363 data->ram_data.reg.vm_cnf = data->vm_cnf;
364 data->ram_data.reg.crc = crc8(table: stc3117_crc_table,
365 pdata: data->ram_data.ram_bytes,
366 STC3117_RAM_SIZE - 1, CRC8_INIT);
367 data->ram_data.reg.state = STC3117_INIT;
368 }
369
370 /* check battery presence status */
371 ret = regmap_read(map: data->regmap, STC3117_ADDR_CTRL, val: &mode);
372 if ((mode & STC3117_BATFAIL) != 0) {
373 data->presence = 0;
374 data->ram_data.reg.testword = 0;
375 data->ram_data.reg.state = STC3117_INIT;
376 ret = ram_write(data);
377 ret |= regmap_write(map: data->regmap, STC3117_ADDR_CTRL, STC3117_PORDET);
378 if (ret)
379 return ret;
380 }
381
382 data->presence = 1;
383
384 ret = regmap_read(map: data->regmap, STC3117_ADDR_MODE, val: &mode);
385 if (ret)
386 return ret;
387 if ((mode & STC3117_GG_RUN) == 0) {
388 if (data->ram_data.reg.state > STC3117_INIT) {
389 ret = stc3117_set_para(data);
390
391 ret |= regmap_write(map: data->regmap, STC3117_ADDR_SOC_H,
392 val: (data->ram_data.reg.hrsoc >> 8 & 0xFF));
393 ret |= regmap_write(map: data->regmap, STC3117_ADDR_SOC_L,
394 val: (data->ram_data.reg.hrsoc & 0xFF));
395 if (ret)
396 return ret;
397 } else {
398 ret = regmap_read(map: data->regmap, STC3117_ADDR_OCV_H, val: &ocv_m);
399
400 ret |= regmap_read(map: data->regmap, STC3117_ADDR_OCV_L, val: &ocv_l);
401
402 ret |= stc3117_set_para(data);
403
404 ret |= regmap_write(map: data->regmap, STC3117_ADDR_OCV_H, val: ocv_m);
405
406 ret |= regmap_write(map: data->regmap, STC3117_ADDR_OCV_L, val: ocv_l);
407 if (ret)
408 return ret;
409 }
410 data->ram_data.reg.state = STC3117_INIT;
411 }
412
413 regmap_read(map: data->regmap, STC3117_ADDR_COUNTER_L, val: &count_l);
414 regmap_read(map: data->regmap, STC3117_ADDR_COUNTER_H, val: &count_m);
415
416 count_m = (count_m << 8) + count_l;
417
418 /* INIT state, wait for batt_current & temperature value available: */
419 if (data->ram_data.reg.state == STC3117_INIT && count_m > 4) {
420 data->avg_voltage = data->voltage;
421 data->avg_current = data->batt_current;
422 data->ram_data.reg.state = STC3117_RUNNING;
423 }
424
425 if (data->ram_data.reg.state != STC3117_RUNNING) {
426 data->batt_current = -ENODATA;
427 data->temp = -ENODATA;
428 } else {
429 if (data->voltage < APP_CUTOFF_VOLTAGE)
430 data->soc = -ENODATA;
431
432 if (mode & STC3117_VMODE) {
433 data->avg_current = -ENODATA;
434 data->batt_current = -ENODATA;
435 }
436 }
437
438 data->ram_data.reg.hrsoc = data->hrsoc;
439 data->ram_data.reg.soc = (data->soc + 5) / 10;
440 data->ram_data.reg.crc = crc8(table: stc3117_crc_table,
441 pdata: data->ram_data.ram_bytes,
442 STC3117_RAM_SIZE - 1, CRC8_INIT);
443
444 ret = ram_write(data);
445 if (ret)
446 return ret;
447 return 0;
448};
449
450static void fuel_gauge_update_work(struct work_struct *work)
451{
452 struct stc3117_data *data =
453 container_of(work, struct stc3117_data, update_work.work);
454
455 stc3117_task(data);
456
457 /* Schedule the work to run again in 2 seconds */
458 schedule_delayed_work(dwork: &data->update_work, delay: msecs_to_jiffies(m: 2000));
459}
460
461static int stc3117_get_property(struct power_supply *psy,
462 enum power_supply_property psp, union power_supply_propval *val)
463{
464 struct stc3117_data *data = power_supply_get_drvdata(psy);
465
466 switch (psp) {
467 case POWER_SUPPLY_PROP_STATUS:
468 if (data->soc > BATTERY_FULL)
469 val->intval = POWER_SUPPLY_STATUS_FULL;
470 else if (data->batt_current < 0)
471 val->intval = POWER_SUPPLY_STATUS_CHARGING;
472 else if (data->batt_current > 0)
473 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
474 else
475 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
476 break;
477 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
478 val->intval = data->voltage;
479 break;
480 case POWER_SUPPLY_PROP_CURRENT_NOW:
481 val->intval = data->batt_current;
482 break;
483 case POWER_SUPPLY_PROP_VOLTAGE_OCV:
484 val->intval = data->ocv;
485 break;
486 case POWER_SUPPLY_PROP_CURRENT_AVG:
487 val->intval = data->avg_current;
488 break;
489 case POWER_SUPPLY_PROP_CAPACITY:
490 val->intval = data->soc;
491 break;
492 case POWER_SUPPLY_PROP_TEMP:
493 val->intval = data->temp;
494 break;
495 case POWER_SUPPLY_PROP_PRESENT:
496 val->intval = data->presence;
497 break;
498 default:
499 return -EINVAL;
500 }
501 return 0;
502}
503
504static enum power_supply_property stc3117_battery_props[] = {
505 POWER_SUPPLY_PROP_STATUS,
506 POWER_SUPPLY_PROP_VOLTAGE_NOW,
507 POWER_SUPPLY_PROP_CURRENT_NOW,
508 POWER_SUPPLY_PROP_VOLTAGE_OCV,
509 POWER_SUPPLY_PROP_CURRENT_AVG,
510 POWER_SUPPLY_PROP_CAPACITY,
511 POWER_SUPPLY_PROP_TEMP,
512 POWER_SUPPLY_PROP_PRESENT,
513};
514
515static const struct power_supply_desc stc3117_battery_desc = {
516 .name = "stc3117-battery",
517 .type = POWER_SUPPLY_TYPE_BATTERY,
518 .get_property = stc3117_get_property,
519 .properties = stc3117_battery_props,
520 .num_properties = ARRAY_SIZE(stc3117_battery_props),
521};
522
523static const struct regmap_config stc3117_regmap_config = {
524 .reg_bits = 8,
525 .val_bits = 8,
526};
527
528static int stc3117_probe(struct i2c_client *client)
529{
530 struct stc3117_data *data;
531 struct power_supply_config psy_cfg = {};
532 struct power_supply_battery_info *info;
533 int ret;
534
535 data = devm_kzalloc(dev: &client->dev, size: sizeof(*data), GFP_KERNEL);
536 if (!data)
537 return -ENOMEM;
538
539 data->client = client;
540 data->regmap = devm_regmap_init_i2c(client, &stc3117_regmap_config);
541 if (IS_ERR(ptr: data->regmap))
542 return PTR_ERR(ptr: data->regmap);
543
544 psy_cfg.drv_data = data;
545 psy_cfg.fwnode = dev_fwnode(&client->dev);
546
547 crc8_populate_msb(table: stc3117_crc_table, CRC8_POLYNOMIAL);
548
549 data->battery = devm_power_supply_register(parent: &client->dev,
550 desc: &stc3117_battery_desc, cfg: &psy_cfg);
551 if (IS_ERR(ptr: data->battery))
552 return dev_err_probe(dev: &client->dev, err: PTR_ERR(ptr: data->battery),
553 fmt: "failed to register battery\n");
554
555 ret = device_property_read_u32(dev: &client->dev, propname: "shunt-resistor-micro-ohms",
556 val: &data->battery_info.sense_resistor);
557 if (ret)
558 return dev_err_probe(dev: &client->dev, err: ret,
559 fmt: "failed to get shunt-resistor-micro-ohms\n");
560 data->battery_info.sense_resistor = data->battery_info.sense_resistor / 1000;
561
562 ret = power_supply_get_battery_info(psy: data->battery, info_out: &info);
563 if (ret)
564 return dev_err_probe(dev: &client->dev, err: ret,
565 fmt: "failed to get battery information\n");
566
567 data->battery_info.battery_capacity_mah = info->charge_full_design_uah / 1000;
568 data->battery_info.voltage_min_mv = info->voltage_min_design_uv / 1000;
569 data->battery_info.voltage_max_mv = info->voltage_max_design_uv / 1000;
570
571 ret = stc3117_init(data);
572 if (ret)
573 return dev_err_probe(dev: &client->dev, err: ret,
574 fmt: "failed to initialize of stc3117\n");
575
576 ret = devm_delayed_work_autocancel(dev: &client->dev, w: &data->update_work,
577 worker: fuel_gauge_update_work);
578 if (ret)
579 return ret;
580
581 schedule_delayed_work(dwork: &data->update_work, delay: 0);
582
583 return 0;
584}
585
586static const struct i2c_device_id stc3117_id[] = {
587 { "stc3117", 0 },
588 { }
589};
590MODULE_DEVICE_TABLE(i2c, stc3117_id);
591
592static const struct of_device_id stc3117_of_match[] = {
593 { .compatible = "st,stc3117" },
594 { }
595};
596MODULE_DEVICE_TABLE(of, stc3117_of_match);
597
598static struct i2c_driver stc3117_i2c_driver = {
599 .driver = {
600 .name = "stc3117_i2c_driver",
601 .of_match_table = stc3117_of_match,
602 },
603 .probe = stc3117_probe,
604 .id_table = stc3117_id,
605};
606
607module_i2c_driver(stc3117_i2c_driver);
608
609MODULE_LICENSE("GPL");
610MODULE_AUTHOR("Hardevsinh Palaniya <hardevsinh.palaniya@siliconsignals.io>");
611MODULE_AUTHOR("Bhavin Sharma <bhavin.sharma@siliconsignals.io>");
612MODULE_DESCRIPTION("STC3117 Fuel Gauge Driver");
613

source code of linux/drivers/power/supply/stc3117_fuel_gauge.c