1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Fuel gauge driver for CellWise 2017
4 *
5 * Copyright (C) 2012, RockChip
6 *
7 * Authors: Shunqing Chen <csq@rock-chips.com>
8 */
9
10 #include <linux/bits.h>
11 #include <linux/delay.h>
12 #include <linux/i2c.h>
13 #include <linux/gfp.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/power_supply.h>
18 #include <linux/property.h>
19 #include <linux/regmap.h>
20 #include <linux/time.h>
21 #include <linux/workqueue.h>
22
23 #define CW2017_SIZE_BATINFO 80
24
25 #define CW2017_REG_VERSION 0x00
26 #define CW2017_REG_VCELL_H 0x02
27 #define CW2017_REG_VCELL_L 0x03
28 #define CW2017_REG_SOC_INT 0x04
29 #define CW2017_REG_SOC_DECIMAL 0x05
30 #define CW2017_REG_TEMP 0x06
31 #define CW2017_REG_MODE_CONFIG 0x08
32 #define CW2017_REG_INT_CONFIG 0x0A
33 #define CW2017_REG_SOC_ALERT 0x0B
34 #define CW2017_REG_TEMP_MAX 0x0C
35 #define CW2017_REG_TEMP_MIN 0x0D
36 #define CW2017_REG_VOLT_ID_H 0x0E
37 #define CW2017_REG_VOLT_ID_L 0x0F
38 #define CW2017_REG_BATINFO 0x10
39
40 #define CW2017_MODE_SLEEP 0x30
41 #define CW2017_MODE_NORMAL 0x00
42 #define CW2017_MODE_DEFAULT 0xF0
43
44 #define CW2017_CONFIG_UPDATE_FLG 0x80
45 #define NO_START_VERSION 160
46
47 #define TEMP_MAX_ALERT 0xFFFF
48 #define TEMP_MIN_ALERT 0xFFFF
49 #define TEMP_ALERT_DISABLE 0xFFFF
50
51 #define INT_CONFIG_MIN_TEMP_MARK BIT(4)
52 #define INT_CONFIG_MAX_TEMP_MARK BIT(5)
53 #define INT_CONFIG_SOC_CHANGE_MARK BIT(6)
54
55 #define DEF_DESIGN_CAPACITY 4000
56
57 #define CW2017_MASK_ATHD GENMASK(7, 0)
58
59 /* reset gauge of no valid state of charge could be polled for 40s */
60 #define CW2017_BAT_SOC_ERROR_MS (40 * MSEC_PER_SEC)
61 /* reset gauge if state of charge stuck for half an hour during charging */
62 #define CW2017_BAT_CHARGING_STUCK_MS (1800 * MSEC_PER_SEC)
63
64 /* poll interval from CellWise GPL Android driver example */
65 #define CW2017_DEFAULT_POLL_INTERVAL_MS 8000
66
67 struct cw_battery {
68 struct device *dev;
69 struct workqueue_struct *battery_workqueue;
70 struct delayed_work battery_delay_work;
71 struct regmap *regmap;
72 struct power_supply *rk_bat;
73 struct power_supply_battery_info battery;
74 u8 *bat_profile;
75
76 bool charger_attached;
77 bool battery_changed;
78
79 int soc;
80 int voltage_mv;
81 int status;
82 int charge_count;
83 int design_capacity;
84
85 u32 poll_interval_ms;
86 u32 alert_level;
87 int temp_max;
88 int temp_min;
89 int temp;
90
91 bool dual_cell;
92
93 unsigned int read_errors;
94 unsigned int charge_stuck_cnt;
95 };
96
cw_read_word(struct cw_battery * cw_bat,u8 reg,u16 * val)97 static int cw_read_word(struct cw_battery *cw_bat, u8 reg, u16 *val)
98 {
99 __be16 value;
100 int ret;
101
102 ret = regmap_bulk_read(cw_bat->regmap, reg, &value, sizeof(value));
103 if (ret)
104 return ret;
105
106 *val = be16_to_cpu(value);
107 return 0;
108 }
109
cw2017_enable(struct cw_battery * cw_bat)110 static void cw2017_enable(struct cw_battery *cw_bat)
111 {
112 unsigned char reg_val = CW2017_MODE_DEFAULT;
113
114 regmap_write(cw_bat->regmap, CW2017_REG_MODE_CONFIG, reg_val);
115 msleep(20);
116 reg_val = CW2017_MODE_SLEEP;
117 regmap_write(cw_bat->regmap, CW2017_REG_MODE_CONFIG, reg_val);
118 msleep(20);
119 reg_val = CW2017_MODE_NORMAL;
120 regmap_write(cw_bat->regmap, CW2017_REG_MODE_CONFIG, reg_val);
121 msleep(20);
122 }
123
cw_update_profile(struct cw_battery * cw_bat)124 static int cw_update_profile(struct cw_battery *cw_bat)
125 {
126 int ret;
127 unsigned int reg_val = 0;
128 unsigned char int_mask = 0;
129
130 /* write new battery info */
131 ret = regmap_raw_write(cw_bat->regmap, CW2017_REG_BATINFO,
132 cw_bat->bat_profile,
133 CW2017_SIZE_BATINFO);
134 if (ret)
135 return ret;
136
137 /* set config update flag */
138 reg_val |= CW2017_CONFIG_UPDATE_FLG;
139 reg_val &= ~CW2017_MASK_ATHD;
140 reg_val |= cw_bat->alert_level;
141 regmap_write(cw_bat->regmap, CW2017_REG_SOC_ALERT, reg_val);
142
143 if (cw_bat->alert_level)
144 int_mask |= INT_CONFIG_SOC_CHANGE_MARK;
145
146 cw_bat->temp_max = TEMP_MAX_ALERT;
147 cw_bat->temp_min = TEMP_MIN_ALERT;
148 if (cw_bat->temp_max != TEMP_ALERT_DISABLE) {
149 int_mask |= INT_CONFIG_MAX_TEMP_MARK;
150 reg_val = (cw_bat->temp_max + 40) * 2;
151 regmap_write(cw_bat->regmap, CW2017_REG_TEMP_MAX, reg_val);
152 }
153 if (cw_bat->temp_min != TEMP_ALERT_DISABLE) {
154 int_mask |= INT_CONFIG_MIN_TEMP_MARK;
155 reg_val = (cw_bat->temp_min + 40) * 2;
156 regmap_write(cw_bat->regmap, CW2017_REG_TEMP_MIN, reg_val);
157 }
158 regmap_write(cw_bat->regmap, CW2017_REG_INT_CONFIG, int_mask);
159
160 /* wait for gauge to reset */
161 msleep(20);
162
163 /* wait for gauge to become ready */
164 ret = regmap_read_poll_timeout(cw_bat->regmap, CW2017_REG_SOC_INT,
165 reg_val, reg_val <= 100,
166 10 * USEC_PER_MSEC, 10 * USEC_PER_SEC);
167 if (ret)
168 dev_err(cw_bat->dev,
169 "Gauge did not become ready after profile upload\n");
170 else
171 dev_dbg(cw_bat->dev, "Battery profile updated\n");
172
173 cw2017_enable(cw_bat);
174 dev_dbg(cw_bat->dev, "Battery profile configured\n");
175
176 return ret;
177 }
178
cw_init(struct cw_battery * cw_bat)179 static int cw_init(struct cw_battery *cw_bat)
180 {
181 int ret;
182 unsigned int reg_val;
183 unsigned int config_flg;
184
185 regmap_read(cw_bat->regmap, CW2017_REG_MODE_CONFIG, ®_val);
186 regmap_read(cw_bat->regmap, CW2017_REG_SOC_ALERT, &config_flg);
187
188 if (reg_val != CW2017_MODE_NORMAL || !(config_flg & CW2017_CONFIG_UPDATE_FLG)) {
189 dev_dbg(cw_bat->dev,
190 "Battery profile not present, uploading battery profile\n");
191 if (cw_bat->bat_profile) {
192 ret = cw_update_profile(cw_bat);
193 if (ret) {
194 dev_err(cw_bat->dev,
195 "Failed to upload battery profile\n");
196 return ret;
197 }
198 } else {
199 dev_warn(cw_bat->dev,
200 "No profile specified, continuing without profile\n");
201 }
202 } else if (cw_bat->bat_profile) {
203 u8 bat_info[CW2017_SIZE_BATINFO];
204
205 ret = regmap_raw_read(cw_bat->regmap, CW2017_REG_BATINFO,
206 bat_info, CW2017_SIZE_BATINFO);
207 if (ret) {
208 dev_err(cw_bat->dev,
209 "Failed to read stored battery profile\n");
210 return ret;
211 }
212
213 if (memcmp(bat_info, cw_bat->bat_profile, CW2017_SIZE_BATINFO)) {
214 dev_warn(cw_bat->dev, "Replacing stored battery profile\n");
215 ret = cw_update_profile(cw_bat);
216 if (ret)
217 return ret;
218 }
219 } else {
220 dev_warn(cw_bat->dev,
221 "Can't check current battery profile, no profile provided\n");
222 }
223
224 return 0;
225 }
226
227 #define HYSTERESIS(current, previous, up, down) \
228 (((current) < (previous) + (up)) && ((current) > (previous) - (down)))
229
cw_get_soc(struct cw_battery * cw_bat)230 static int cw_get_soc(struct cw_battery *cw_bat)
231 {
232 unsigned int soc;
233
234 regmap_read(cw_bat->regmap, CW2017_REG_SOC_INT, &soc);
235 if (soc > 100) {
236 int max_error_cycles =
237 CW2017_BAT_SOC_ERROR_MS / cw_bat->poll_interval_ms;
238
239 dev_err(cw_bat->dev, "Invalid SoC %d%%\n", soc);
240 cw_bat->read_errors++;
241 if (cw_bat->read_errors > max_error_cycles) {
242 dev_warn(cw_bat->dev,
243 "Too many invalid SoC reports, resetting gauge\n");
244 cw_bat->read_errors = 0;
245 }
246 return cw_bat->soc;
247 }
248 cw_bat->read_errors = 0;
249
250 /* Reset gauge if stuck while charging */
251 if (cw_bat->status == POWER_SUPPLY_STATUS_CHARGING && soc == cw_bat->soc) {
252 int max_stuck_cycles =
253 CW2017_BAT_CHARGING_STUCK_MS / cw_bat->poll_interval_ms;
254
255 cw_bat->charge_stuck_cnt++;
256 if (cw_bat->charge_stuck_cnt > max_stuck_cycles) {
257 dev_warn(cw_bat->dev,
258 "SoC stuck @%u%%, resetting gauge\n", soc);
259 cw_bat->charge_stuck_cnt = 0;
260 }
261 } else {
262 cw_bat->charge_stuck_cnt = 0;
263 }
264
265 /* Ignore voltage dips during charge */
266 if (cw_bat->charger_attached && HYSTERESIS(soc, cw_bat->soc, 0, 3))
267 soc = cw_bat->soc;
268
269 /* Ignore voltage spikes during discharge */
270 if (!cw_bat->charger_attached && HYSTERESIS(soc, cw_bat->soc, 3, 0))
271 soc = cw_bat->soc;
272
273 return soc;
274 }
275
cw_get_voltage(struct cw_battery * cw_bat)276 static int cw_get_voltage(struct cw_battery *cw_bat)
277 {
278 int voltage_mv;
279 u16 reg_val = 0;
280
281 cw_read_word(cw_bat, CW2017_REG_VCELL_H, ®_val);
282 reg_val &= 0x3fff;
283 voltage_mv = reg_val * 5 / 16;
284 if (cw_bat->dual_cell)
285 voltage_mv *= 2;
286
287 dev_dbg(cw_bat->dev, "Read voltage: %d mV, raw=0x%04x\n",
288 voltage_mv, reg_val);
289
290 return voltage_mv;
291 }
292
cw_update_charge_status(struct cw_battery * cw_bat)293 static void cw_update_charge_status(struct cw_battery *cw_bat)
294 {
295 int ret;
296
297 ret = power_supply_am_i_supplied(cw_bat->rk_bat);
298 if (ret < 0) {
299 dev_warn(cw_bat->dev, "Failed to get supply state: %d\n", ret);
300 } else {
301 bool charger_attached;
302
303 charger_attached = !!ret;
304 if (cw_bat->charger_attached != charger_attached) {
305 cw_bat->battery_changed = true;
306 if (charger_attached)
307 cw_bat->charge_count++;
308 }
309 cw_bat->charger_attached = charger_attached;
310 }
311 }
312
cw_update_soc(struct cw_battery * cw_bat)313 static void cw_update_soc(struct cw_battery *cw_bat)
314 {
315 int soc;
316
317 soc = cw_get_soc(cw_bat);
318 if (soc < 0)
319 dev_err(cw_bat->dev, "Failed to get SoC from gauge: %d\n", soc);
320 else if (cw_bat->soc != soc) {
321 cw_bat->soc = soc;
322 cw_bat->battery_changed = true;
323 }
324 }
325
cw_update_voltage(struct cw_battery * cw_bat)326 static void cw_update_voltage(struct cw_battery *cw_bat)
327 {
328 int voltage_mv;
329
330 voltage_mv = cw_get_voltage(cw_bat);
331 if (voltage_mv < 0)
332 dev_err(cw_bat->dev, "Failed to get voltage from gauge: %d\n",
333 voltage_mv);
334 else
335 cw_bat->voltage_mv = voltage_mv;
336 }
337
cw_update_temp(struct cw_battery * cw_bat)338 static int cw_update_temp(struct cw_battery *cw_bat)
339 {
340 unsigned int val = 0;
341
342 regmap_read(cw_bat->regmap, CW2017_REG_TEMP, &val);
343 cw_bat->temp = val * 10 / 2 - 400;
344
345 return cw_bat->temp;
346 }
347
cw_update_status(struct cw_battery * cw_bat)348 static void cw_update_status(struct cw_battery *cw_bat)
349 {
350 int status = POWER_SUPPLY_STATUS_DISCHARGING;
351
352 if (cw_bat->charger_attached) {
353 if (cw_bat->soc >= 100)
354 status = POWER_SUPPLY_STATUS_FULL;
355 else
356 status = POWER_SUPPLY_STATUS_CHARGING;
357 }
358
359 if (cw_bat->status != status)
360 cw_bat->battery_changed = true;
361 cw_bat->status = status;
362 }
363
cw_bat_work(struct work_struct * work)364 static void cw_bat_work(struct work_struct *work)
365 {
366 struct delayed_work *delay_work;
367 struct cw_battery *cw_bat;
368
369 delay_work = to_delayed_work(work);
370 cw_bat = container_of(delay_work, struct cw_battery, battery_delay_work);
371
372 cw_update_soc(cw_bat);
373 cw_update_voltage(cw_bat);
374 cw_update_charge_status(cw_bat);
375 cw_update_temp(cw_bat);
376 cw_update_status(cw_bat);
377
378 dev_dbg(cw_bat->dev, "charger_attached = %d\n", cw_bat->charger_attached);
379 dev_dbg(cw_bat->dev, "status = %d\n", cw_bat->status);
380 dev_dbg(cw_bat->dev, "soc = %d%%\n", cw_bat->soc);
381 dev_dbg(cw_bat->dev, "voltage = %dmV\n", cw_bat->voltage_mv);
382
383 if (cw_bat->battery_changed)
384 power_supply_changed(cw_bat->rk_bat);
385 cw_bat->battery_changed = false;
386
387 queue_delayed_work(cw_bat->battery_workqueue,
388 &cw_bat->battery_delay_work,
389 msecs_to_jiffies(cw_bat->poll_interval_ms));
390 }
391
cw_battery_get_property(struct power_supply * psy,enum power_supply_property psp,union power_supply_propval * val)392 static int cw_battery_get_property(struct power_supply *psy,
393 enum power_supply_property psp,
394 union power_supply_propval *val)
395 {
396 struct cw_battery *cw_bat;
397
398 cw_bat = power_supply_get_drvdata(psy);
399 switch (psp) {
400 case POWER_SUPPLY_PROP_CAPACITY:
401 val->intval = cw_bat->soc;
402 break;
403
404 case POWER_SUPPLY_PROP_STATUS:
405 val->intval = cw_bat->status;
406 break;
407
408 case POWER_SUPPLY_PROP_PRESENT:
409 val->intval = !!cw_bat->voltage_mv;
410 break;
411
412 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
413 val->intval = cw_bat->voltage_mv * 1000;
414 break;
415
416 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
417 val->intval = 0;
418 break;
419
420 case POWER_SUPPLY_PROP_TECHNOLOGY:
421 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
422 break;
423
424 case POWER_SUPPLY_PROP_CHARGE_COUNTER:
425 val->intval = cw_bat->charge_count;
426 break;
427
428 case POWER_SUPPLY_PROP_TEMP:
429 val->intval = cw_bat->temp;
430 break;
431
432 case POWER_SUPPLY_PROP_CHARGE_FULL:
433 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
434 if (cw_bat->battery.charge_full_design_uah > 0)
435 val->intval = cw_bat->battery.charge_full_design_uah;
436 else
437 val->intval = cw_bat->design_capacity * 1000;
438 break;
439
440 case POWER_SUPPLY_PROP_CURRENT_NOW:
441 val->intval = 0;
442 break;
443
444 default:
445 break;
446 }
447 return 0;
448 }
449
450 static enum power_supply_property cw_battery_properties[] = {
451 POWER_SUPPLY_PROP_CAPACITY,
452 POWER_SUPPLY_PROP_STATUS,
453 POWER_SUPPLY_PROP_PRESENT,
454 POWER_SUPPLY_PROP_VOLTAGE_NOW,
455 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
456 POWER_SUPPLY_PROP_TECHNOLOGY,
457 POWER_SUPPLY_PROP_CHARGE_COUNTER,
458 POWER_SUPPLY_PROP_TEMP,
459 POWER_SUPPLY_PROP_CHARGE_FULL,
460 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
461 POWER_SUPPLY_PROP_CURRENT_NOW,
462 };
463
464 static const struct power_supply_desc cw2017_bat_desc = {
465 .name = "cw2017-battery",
466 .type = POWER_SUPPLY_TYPE_BATTERY,
467 .properties = cw_battery_properties,
468 .num_properties = ARRAY_SIZE(cw_battery_properties),
469 .get_property = cw_battery_get_property,
470 };
471
cw2017_parse_properties(struct cw_battery * cw_bat)472 static int cw2017_parse_properties(struct cw_battery *cw_bat)
473 {
474 struct device *dev = cw_bat->dev;
475 int length;
476 int ret;
477
478 length = device_property_count_u8(dev, "cellwise,battery-profile");
479 if (length < 0) {
480 dev_warn(cw_bat->dev,
481 "No battery-profile found, using current flash contents\n");
482 } else if (length != CW2017_SIZE_BATINFO) {
483 dev_err(cw_bat->dev, "battery-profile must be %d bytes\n",
484 CW2017_SIZE_BATINFO);
485 return -EINVAL;
486 }
487
488 cw_bat->bat_profile = devm_kzalloc(dev, length, GFP_KERNEL);
489 if (!cw_bat->bat_profile)
490 return -ENOMEM;
491
492 ret = device_property_read_u8_array(dev,
493 "cellwise,battery-profile",
494 cw_bat->bat_profile,
495 length);
496 if (ret)
497 return ret;
498
499 ret = device_property_read_u32(dev, "cellwise,design-capacity-amh",
500 &cw_bat->design_capacity);
501 if (ret) {
502 dev_info(cw_bat->dev, "Missing design capacity\n");
503 cw_bat->design_capacity = DEF_DESIGN_CAPACITY;
504 }
505
506 device_property_read_u32(dev, "cellwise,alert-level",
507 &cw_bat->alert_level);
508
509 cw_bat->dual_cell = device_property_read_bool(dev, "cellwise,dual-cell");
510
511 ret = device_property_read_u32(dev, "cellwise,monitor-interval-ms",
512 &cw_bat->poll_interval_ms);
513 if (ret) {
514 dev_dbg(cw_bat->dev, "Using default poll interval\n");
515 cw_bat->poll_interval_ms = CW2017_DEFAULT_POLL_INTERVAL_MS;
516 }
517
518 return 0;
519 }
520
521 static const struct regmap_range regmap_ranges_rd_yes[] = {
522 regmap_reg_range(CW2017_REG_VERSION, CW2017_REG_VERSION),
523 regmap_reg_range(CW2017_REG_VCELL_H, CW2017_REG_TEMP),
524 regmap_reg_range(CW2017_REG_MODE_CONFIG, CW2017_REG_MODE_CONFIG),
525 regmap_reg_range(CW2017_REG_INT_CONFIG,
526 CW2017_REG_BATINFO + CW2017_SIZE_BATINFO - 1),
527 };
528
529 static const struct regmap_access_table regmap_rd_table = {
530 .yes_ranges = regmap_ranges_rd_yes,
531 .n_yes_ranges = ARRAY_SIZE(regmap_ranges_rd_yes),
532 };
533
534 static const struct regmap_range regmap_ranges_wr_yes[] = {
535 regmap_reg_range(CW2017_REG_MODE_CONFIG, CW2017_REG_MODE_CONFIG),
536 regmap_reg_range(CW2017_REG_INT_CONFIG, CW2017_REG_TEMP_MIN),
537 regmap_reg_range(CW2017_REG_BATINFO,
538 CW2017_REG_BATINFO + CW2017_SIZE_BATINFO - 1),
539 };
540
541 static const struct regmap_access_table regmap_wr_table = {
542 .yes_ranges = regmap_ranges_wr_yes,
543 .n_yes_ranges = ARRAY_SIZE(regmap_ranges_wr_yes),
544 };
545
546 static const struct regmap_range regmap_ranges_vol_yes[] = {
547 regmap_reg_range(CW2017_REG_VCELL_H, CW2017_REG_TEMP),
548 };
549
550 static const struct regmap_access_table regmap_vol_table = {
551 .yes_ranges = regmap_ranges_vol_yes,
552 .n_yes_ranges = ARRAY_SIZE(regmap_ranges_vol_yes),
553 };
554
555 static const struct regmap_config cw2017_regmap_config = {
556 .reg_bits = 8,
557 .val_bits = 8,
558 .rd_table = ®map_rd_table,
559 .wr_table = ®map_wr_table,
560 .volatile_table = ®map_vol_table,
561 .max_register = CW2017_REG_BATINFO + CW2017_SIZE_BATINFO - 1,
562 };
563
cw_bat_probe(struct i2c_client * client)564 static int cw_bat_probe(struct i2c_client *client)
565 {
566 int ret;
567 struct cw_battery *cw_bat;
568 struct power_supply_config psy_cfg = { 0 };
569
570 cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
571 if (!cw_bat)
572 return -ENOMEM;
573
574 i2c_set_clientdata(client, cw_bat);
575 cw_bat->dev = &client->dev;
576 cw_bat->soc = 1;
577
578 ret = cw2017_parse_properties(cw_bat);
579 if (ret) {
580 dev_err(cw_bat->dev, "Failed to parse cw2017 properties\n");
581 return ret;
582 }
583
584 cw_bat->regmap = devm_regmap_init_i2c(client, &cw2017_regmap_config);
585 if (IS_ERR(cw_bat->regmap)) {
586 dev_err(cw_bat->dev, "Failed to allocate regmap: %ld\n",
587 PTR_ERR(cw_bat->regmap));
588 return PTR_ERR(cw_bat->regmap);
589 }
590
591 ret = cw_init(cw_bat);
592 if (ret) {
593 dev_err(cw_bat->dev, "Init failed: %d\n", ret);
594 return ret;
595 }
596
597 psy_cfg.drv_data = cw_bat;
598 psy_cfg.fwnode = dev_fwnode(cw_bat->dev);
599
600 cw_bat->rk_bat = devm_power_supply_register(&client->dev,
601 &cw2017_bat_desc,
602 &psy_cfg);
603 if (IS_ERR(cw_bat->rk_bat)) {
604 dev_err(cw_bat->dev, "Failed to register power supply\n");
605 return PTR_ERR(cw_bat->rk_bat);
606 }
607
608 ret = power_supply_get_battery_info(cw_bat->rk_bat, &cw_bat->battery);
609 if (ret) {
610 dev_warn(cw_bat->dev,
611 "No monitored battery, some properties will be missing\n");
612 }
613
614 cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
615 INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
616 queue_delayed_work(cw_bat->battery_workqueue,
617 &cw_bat->battery_delay_work, msecs_to_jiffies(10));
618
619 return 0;
620 }
621
cw_bat_suspend(struct device * dev)622 static int __maybe_unused cw_bat_suspend(struct device *dev)
623 {
624 struct i2c_client *client = to_i2c_client(dev);
625 struct cw_battery *cw_bat = i2c_get_clientdata(client);
626
627 cancel_delayed_work_sync(&cw_bat->battery_delay_work);
628 return 0;
629 }
630
cw_bat_resume(struct device * dev)631 static int __maybe_unused cw_bat_resume(struct device *dev)
632 {
633 struct i2c_client *client = to_i2c_client(dev);
634 struct cw_battery *cw_bat = i2c_get_clientdata(client);
635
636 queue_delayed_work(cw_bat->battery_workqueue,
637 &cw_bat->battery_delay_work, 0);
638 return 0;
639 }
640
641 static SIMPLE_DEV_PM_OPS(cw_bat_pm_ops, cw_bat_suspend, cw_bat_resume);
642
cw_bat_remove(struct i2c_client * client)643 static int cw_bat_remove(struct i2c_client *client)
644 {
645 struct cw_battery *cw_bat = i2c_get_clientdata(client);
646
647 cancel_delayed_work_sync(&cw_bat->battery_delay_work);
648 power_supply_put_battery_info(cw_bat->rk_bat, &cw_bat->battery);
649 return 0;
650 }
651
652 static const struct i2c_device_id cw_bat_id_table[] = {
653 { "cw2017", 0 },
654 { }
655 };
656
657 static const struct of_device_id cw2017_of_match[] = {
658 { .compatible = "cellwise,cw2017" },
659 { }
660 };
661 MODULE_DEVICE_TABLE(of, cw2017_of_match);
662
663 static struct i2c_driver cw_bat_driver = {
664 .driver = {
665 .name = "cw2017",
666 .of_match_table = cw2017_of_match,
667 .pm = &cw_bat_pm_ops,
668 },
669 .probe_new = cw_bat_probe,
670 .remove = cw_bat_remove,
671 .id_table = cw_bat_id_table,
672 };
673
674 module_i2c_driver(cw_bat_driver);
675
676 MODULE_AUTHOR("Shunqing Chen<csq@rock-chips.com>");
677 MODULE_DESCRIPTION("cw2017 battery driver");
678 MODULE_LICENSE("GPL");
679