1/*
2 * Driver for batteries with DS2760 chips inside.
3 *
4 * Copyright © 2007 Anton Vorontsov
5 * 2004-2007 Matt Reimer
6 * 2004 Szabolcs Gyurko
7 *
8 * Use consistent with the GNU GPL is permitted,
9 * provided that this copyright notice is
10 * preserved in its entirety in all copies and derived works.
11 *
12 * Author: Anton Vorontsov <cbou@mail.ru>
13 * February 2007
14 *
15 * Matt Reimer <mreimer@vpop.net>
16 * April 2004, 2005, 2007
17 *
18 * Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>
19 * September 2004
20 */
21
22#include <linux/module.h>
23#include <linux/param.h>
24#include <linux/jiffies.h>
25#include <linux/workqueue.h>
26#include <linux/pm.h>
27#include <linux/slab.h>
28#include <linux/platform_device.h>
29#include <linux/power_supply.h>
30#include <linux/suspend.h>
31#include <linux/w1.h>
32#include <linux/of.h>
33
34static unsigned int cache_time = 1000;
35module_param(cache_time, uint, 0644);
36MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
37
38static bool pmod_enabled;
39module_param(pmod_enabled, bool, 0644);
40MODULE_PARM_DESC(pmod_enabled, "PMOD enable bit");
41
42static unsigned int rated_capacity;
43module_param(rated_capacity, uint, 0644);
44MODULE_PARM_DESC(rated_capacity, "rated battery capacity, 10*mAh or index");
45
46static unsigned int current_accum;
47module_param(current_accum, uint, 0644);
48MODULE_PARM_DESC(current_accum, "current accumulator value");
49
50#define W1_FAMILY_DS2760 0x30
51
52/* Known commands to the DS2760 chip */
53#define W1_DS2760_SWAP 0xAA
54#define W1_DS2760_READ_DATA 0x69
55#define W1_DS2760_WRITE_DATA 0x6C
56#define W1_DS2760_COPY_DATA 0x48
57#define W1_DS2760_RECALL_DATA 0xB8
58#define W1_DS2760_LOCK 0x6A
59
60/* Number of valid register addresses */
61#define DS2760_DATA_SIZE 0x40
62
63#define DS2760_PROTECTION_REG 0x00
64
65#define DS2760_STATUS_REG 0x01
66#define DS2760_STATUS_IE (1 << 2)
67#define DS2760_STATUS_SWEN (1 << 3)
68#define DS2760_STATUS_RNAOP (1 << 4)
69#define DS2760_STATUS_PMOD (1 << 5)
70
71#define DS2760_EEPROM_REG 0x07
72#define DS2760_SPECIAL_FEATURE_REG 0x08
73#define DS2760_VOLTAGE_MSB 0x0c
74#define DS2760_VOLTAGE_LSB 0x0d
75#define DS2760_CURRENT_MSB 0x0e
76#define DS2760_CURRENT_LSB 0x0f
77#define DS2760_CURRENT_ACCUM_MSB 0x10
78#define DS2760_CURRENT_ACCUM_LSB 0x11
79#define DS2760_TEMP_MSB 0x18
80#define DS2760_TEMP_LSB 0x19
81#define DS2760_EEPROM_BLOCK0 0x20
82#define DS2760_ACTIVE_FULL 0x20
83#define DS2760_EEPROM_BLOCK1 0x30
84#define DS2760_STATUS_WRITE_REG 0x31
85#define DS2760_RATED_CAPACITY 0x32
86#define DS2760_CURRENT_OFFSET_BIAS 0x33
87#define DS2760_ACTIVE_EMPTY 0x3b
88
89struct ds2760_device_info {
90 struct device *dev;
91
92 /* DS2760 data, valid after calling ds2760_battery_read_status() */
93 unsigned long update_time; /* jiffies when data read */
94 char raw[DS2760_DATA_SIZE]; /* raw DS2760 data */
95 int voltage_raw; /* units of 4.88 mV */
96 int voltage_uV; /* units of µV */
97 int current_raw; /* units of 0.625 mA */
98 int current_uA; /* units of µA */
99 int accum_current_raw; /* units of 0.25 mAh */
100 int accum_current_uAh; /* units of µAh */
101 int temp_raw; /* units of 0.125 °C */
102 int temp_C; /* units of 0.1 °C */
103 int rated_capacity; /* units of µAh */
104 int rem_capacity; /* percentage */
105 int full_active_uAh; /* units of µAh */
106 int empty_uAh; /* units of µAh */
107 int life_sec; /* units of seconds */
108 int charge_status; /* POWER_SUPPLY_STATUS_* */
109
110 int full_counter;
111 struct power_supply *bat;
112 struct power_supply_desc bat_desc;
113 struct workqueue_struct *monitor_wqueue;
114 struct delayed_work monitor_work;
115 struct delayed_work set_charged_work;
116 struct notifier_block pm_notifier;
117};
118
119static int w1_ds2760_io(struct device *dev, char *buf, int addr, size_t count,
120 int io)
121{
122 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
123
124 if (!dev)
125 return 0;
126
127 mutex_lock(&sl->master->bus_mutex);
128
129 if (addr > DS2760_DATA_SIZE || addr < 0) {
130 count = 0;
131 goto out;
132 }
133 if (addr + count > DS2760_DATA_SIZE)
134 count = DS2760_DATA_SIZE - addr;
135
136 if (!w1_reset_select_slave(sl)) {
137 if (!io) {
138 w1_write_8(sl->master, W1_DS2760_READ_DATA);
139 w1_write_8(sl->master, addr);
140 count = w1_read_block(sl->master, buf, count);
141 } else {
142 w1_write_8(sl->master, W1_DS2760_WRITE_DATA);
143 w1_write_8(sl->master, addr);
144 w1_write_block(sl->master, buf, count);
145 /* XXX w1_write_block returns void, not n_written */
146 }
147 }
148
149out:
150 mutex_unlock(lock: &sl->master->bus_mutex);
151
152 return count;
153}
154
155static int w1_ds2760_read(struct device *dev,
156 char *buf, int addr,
157 size_t count)
158{
159 return w1_ds2760_io(dev, buf, addr, count, io: 0);
160}
161
162static int w1_ds2760_write(struct device *dev,
163 char *buf,
164 int addr, size_t count)
165{
166 return w1_ds2760_io(dev, buf, addr, count, io: 1);
167}
168
169static int w1_ds2760_eeprom_cmd(struct device *dev, int addr, int cmd)
170{
171 struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
172
173 if (!dev)
174 return -EINVAL;
175
176 mutex_lock(&sl->master->bus_mutex);
177
178 if (w1_reset_select_slave(sl) == 0) {
179 w1_write_8(sl->master, cmd);
180 w1_write_8(sl->master, addr);
181 }
182
183 mutex_unlock(lock: &sl->master->bus_mutex);
184 return 0;
185}
186
187static int w1_ds2760_store_eeprom(struct device *dev, int addr)
188{
189 return w1_ds2760_eeprom_cmd(dev, addr, W1_DS2760_COPY_DATA);
190}
191
192static int w1_ds2760_recall_eeprom(struct device *dev, int addr)
193{
194 return w1_ds2760_eeprom_cmd(dev, addr, W1_DS2760_RECALL_DATA);
195}
196
197static ssize_t w1_slave_read(struct file *filp, struct kobject *kobj,
198 struct bin_attribute *bin_attr, char *buf,
199 loff_t off, size_t count)
200{
201 struct device *dev = kobj_to_dev(kobj);
202 return w1_ds2760_read(dev, buf, addr: off, count);
203}
204
205static BIN_ATTR_RO(w1_slave, DS2760_DATA_SIZE);
206
207static struct bin_attribute *w1_ds2760_bin_attrs[] = {
208 &bin_attr_w1_slave,
209 NULL,
210};
211
212static const struct attribute_group w1_ds2760_group = {
213 .bin_attrs = w1_ds2760_bin_attrs,
214};
215
216static const struct attribute_group *w1_ds2760_groups[] = {
217 &w1_ds2760_group,
218 NULL,
219};
220/* Some batteries have their rated capacity stored a N * 10 mAh, while
221 * others use an index into this table. */
222static int rated_capacities[] = {
223 0,
224 920, /* Samsung */
225 920, /* BYD */
226 920, /* Lishen */
227 920, /* NEC */
228 1440, /* Samsung */
229 1440, /* BYD */
230 1440, /* Lishen */
231 1440, /* NEC */
232 2880, /* Samsung */
233 2880, /* BYD */
234 2880, /* Lishen */
235 2880, /* NEC */
236};
237
238/* array is level at temps 0°C, 10°C, 20°C, 30°C, 40°C
239 * temp is in Celsius */
240static int battery_interpolate(int array[], int temp)
241{
242 int index, dt;
243
244 if (temp <= 0)
245 return array[0];
246 if (temp >= 40)
247 return array[4];
248
249 index = temp / 10;
250 dt = temp % 10;
251
252 return array[index] + (((array[index + 1] - array[index]) * dt) / 10);
253}
254
255static int ds2760_battery_read_status(struct ds2760_device_info *di)
256{
257 int ret, i, start, count, scale[5];
258
259 if (di->update_time && time_before(jiffies, di->update_time +
260 msecs_to_jiffies(cache_time)))
261 return 0;
262
263 /* The first time we read the entire contents of SRAM/EEPROM,
264 * but after that we just read the interesting bits that change. */
265 if (di->update_time == 0) {
266 start = 0;
267 count = DS2760_DATA_SIZE;
268 } else {
269 start = DS2760_VOLTAGE_MSB;
270 count = DS2760_TEMP_LSB - start + 1;
271 }
272
273 ret = w1_ds2760_read(dev: di->dev, buf: di->raw + start, addr: start, count);
274 if (ret != count) {
275 dev_warn(di->dev, "call to w1_ds2760_read failed (0x%p)\n",
276 di->dev);
277 return 1;
278 }
279
280 di->update_time = jiffies;
281
282 /* DS2760 reports voltage in units of 4.88mV, but the battery class
283 * reports in units of uV, so convert by multiplying by 4880. */
284 di->voltage_raw = (di->raw[DS2760_VOLTAGE_MSB] << 3) |
285 (di->raw[DS2760_VOLTAGE_LSB] >> 5);
286 di->voltage_uV = di->voltage_raw * 4880;
287
288 /* DS2760 reports current in signed units of 0.625mA, but the battery
289 * class reports in units of µA, so convert by multiplying by 625. */
290 di->current_raw =
291 (((signed char)di->raw[DS2760_CURRENT_MSB]) << 5) |
292 (di->raw[DS2760_CURRENT_LSB] >> 3);
293 di->current_uA = di->current_raw * 625;
294
295 /* DS2760 reports accumulated current in signed units of 0.25mAh. */
296 di->accum_current_raw =
297 (((signed char)di->raw[DS2760_CURRENT_ACCUM_MSB]) << 8) |
298 di->raw[DS2760_CURRENT_ACCUM_LSB];
299 di->accum_current_uAh = di->accum_current_raw * 250;
300
301 /* DS2760 reports temperature in signed units of 0.125°C, but the
302 * battery class reports in units of 1/10 °C, so we convert by
303 * multiplying by .125 * 10 = 1.25. */
304 di->temp_raw = (((signed char)di->raw[DS2760_TEMP_MSB]) << 3) |
305 (di->raw[DS2760_TEMP_LSB] >> 5);
306 di->temp_C = di->temp_raw + (di->temp_raw / 4);
307
308 /* At least some battery monitors (e.g. HP iPAQ) store the battery's
309 * maximum rated capacity. */
310 if (di->raw[DS2760_RATED_CAPACITY] < ARRAY_SIZE(rated_capacities))
311 di->rated_capacity = rated_capacities[
312 (unsigned int)di->raw[DS2760_RATED_CAPACITY]];
313 else
314 di->rated_capacity = di->raw[DS2760_RATED_CAPACITY] * 10;
315
316 di->rated_capacity *= 1000; /* convert to µAh */
317
318 /* Calculate the full level at the present temperature. */
319 di->full_active_uAh = di->raw[DS2760_ACTIVE_FULL] << 8 |
320 di->raw[DS2760_ACTIVE_FULL + 1];
321
322 /* If the full_active_uAh value is not given, fall back to the rated
323 * capacity. This is likely to happen when chips are not part of the
324 * battery pack and is therefore not bootstrapped. */
325 if (di->full_active_uAh == 0)
326 di->full_active_uAh = di->rated_capacity / 1000L;
327
328 scale[0] = di->full_active_uAh;
329 for (i = 1; i < 5; i++)
330 scale[i] = scale[i - 1] + di->raw[DS2760_ACTIVE_FULL + 1 + i];
331
332 di->full_active_uAh = battery_interpolate(array: scale, temp: di->temp_C / 10);
333 di->full_active_uAh *= 1000; /* convert to µAh */
334
335 /* Calculate the empty level at the present temperature. */
336 scale[4] = di->raw[DS2760_ACTIVE_EMPTY + 4];
337 for (i = 3; i >= 0; i--)
338 scale[i] = scale[i + 1] + di->raw[DS2760_ACTIVE_EMPTY + i];
339
340 di->empty_uAh = battery_interpolate(array: scale, temp: di->temp_C / 10);
341 di->empty_uAh *= 1000; /* convert to µAh */
342
343 if (di->full_active_uAh == di->empty_uAh)
344 di->rem_capacity = 0;
345 else
346 /* From Maxim Application Note 131: remaining capacity =
347 * ((ICA - Empty Value) / (Full Value - Empty Value)) x 100% */
348 di->rem_capacity = ((di->accum_current_uAh - di->empty_uAh) * 100L) /
349 (di->full_active_uAh - di->empty_uAh);
350
351 if (di->rem_capacity < 0)
352 di->rem_capacity = 0;
353 if (di->rem_capacity > 100)
354 di->rem_capacity = 100;
355
356 if (di->current_uA < -100L)
357 di->life_sec = -((di->accum_current_uAh - di->empty_uAh) * 36L)
358 / (di->current_uA / 100L);
359 else
360 di->life_sec = 0;
361
362 return 0;
363}
364
365static void ds2760_battery_set_current_accum(struct ds2760_device_info *di,
366 unsigned int acr_val)
367{
368 unsigned char acr[2];
369
370 /* acr is in units of 0.25 mAh */
371 acr_val *= 4L;
372 acr_val /= 1000;
373
374 acr[0] = acr_val >> 8;
375 acr[1] = acr_val & 0xff;
376
377 if (w1_ds2760_write(dev: di->dev, buf: acr, DS2760_CURRENT_ACCUM_MSB, count: 2) < 2)
378 dev_warn(di->dev, "ACR write failed\n");
379}
380
381static void ds2760_battery_update_status(struct ds2760_device_info *di)
382{
383 int old_charge_status = di->charge_status;
384
385 ds2760_battery_read_status(di);
386
387 if (di->charge_status == POWER_SUPPLY_STATUS_UNKNOWN)
388 di->full_counter = 0;
389
390 if (power_supply_am_i_supplied(psy: di->bat)) {
391 if (di->current_uA > 10000) {
392 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
393 di->full_counter = 0;
394 } else if (di->current_uA < -5000) {
395 if (di->charge_status != POWER_SUPPLY_STATUS_NOT_CHARGING)
396 dev_notice(di->dev, "not enough power to "
397 "charge\n");
398 di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
399 di->full_counter = 0;
400 } else if (di->current_uA < 10000 &&
401 di->charge_status != POWER_SUPPLY_STATUS_FULL) {
402
403 /* Don't consider the battery to be full unless
404 * we've seen the current < 10 mA at least two
405 * consecutive times. */
406
407 di->full_counter++;
408
409 if (di->full_counter < 2) {
410 di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
411 } else {
412 di->charge_status = POWER_SUPPLY_STATUS_FULL;
413 ds2760_battery_set_current_accum(di,
414 acr_val: di->full_active_uAh);
415 }
416 }
417 } else {
418 di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
419 di->full_counter = 0;
420 }
421
422 if (di->charge_status != old_charge_status)
423 power_supply_changed(psy: di->bat);
424}
425
426static void ds2760_battery_write_status(struct ds2760_device_info *di,
427 char status)
428{
429 if (status == di->raw[DS2760_STATUS_REG])
430 return;
431
432 w1_ds2760_write(dev: di->dev, buf: &status, DS2760_STATUS_WRITE_REG, count: 1);
433 w1_ds2760_store_eeprom(dev: di->dev, DS2760_EEPROM_BLOCK1);
434 w1_ds2760_recall_eeprom(dev: di->dev, DS2760_EEPROM_BLOCK1);
435}
436
437static void ds2760_battery_write_rated_capacity(struct ds2760_device_info *di,
438 unsigned char rated_capacity)
439{
440 if (rated_capacity == di->raw[DS2760_RATED_CAPACITY])
441 return;
442
443 w1_ds2760_write(dev: di->dev, buf: &rated_capacity, DS2760_RATED_CAPACITY, count: 1);
444 w1_ds2760_store_eeprom(dev: di->dev, DS2760_EEPROM_BLOCK1);
445 w1_ds2760_recall_eeprom(dev: di->dev, DS2760_EEPROM_BLOCK1);
446}
447
448static void ds2760_battery_write_active_full(struct ds2760_device_info *di,
449 int active_full)
450{
451 unsigned char tmp[2] = {
452 active_full >> 8,
453 active_full & 0xff
454 };
455
456 if (tmp[0] == di->raw[DS2760_ACTIVE_FULL] &&
457 tmp[1] == di->raw[DS2760_ACTIVE_FULL + 1])
458 return;
459
460 w1_ds2760_write(dev: di->dev, buf: tmp, DS2760_ACTIVE_FULL, count: sizeof(tmp));
461 w1_ds2760_store_eeprom(dev: di->dev, DS2760_EEPROM_BLOCK0);
462 w1_ds2760_recall_eeprom(dev: di->dev, DS2760_EEPROM_BLOCK0);
463
464 /* Write to the di->raw[] buffer directly - the DS2760_ACTIVE_FULL
465 * values won't be read back by ds2760_battery_read_status() */
466 di->raw[DS2760_ACTIVE_FULL] = tmp[0];
467 di->raw[DS2760_ACTIVE_FULL + 1] = tmp[1];
468}
469
470static void ds2760_battery_work(struct work_struct *work)
471{
472 struct ds2760_device_info *di = container_of(work,
473 struct ds2760_device_info, monitor_work.work);
474 const int interval = HZ * 60;
475
476 dev_dbg(di->dev, "%s\n", __func__);
477
478 ds2760_battery_update_status(di);
479 queue_delayed_work(wq: di->monitor_wqueue, dwork: &di->monitor_work, delay: interval);
480}
481
482static void ds2760_battery_external_power_changed(struct power_supply *psy)
483{
484 struct ds2760_device_info *di = power_supply_get_drvdata(psy);
485
486 dev_dbg(di->dev, "%s\n", __func__);
487
488 mod_delayed_work(wq: di->monitor_wqueue, dwork: &di->monitor_work, HZ/10);
489}
490
491
492static void ds2760_battery_set_charged_work(struct work_struct *work)
493{
494 char bias;
495 struct ds2760_device_info *di = container_of(work,
496 struct ds2760_device_info, set_charged_work.work);
497
498 dev_dbg(di->dev, "%s\n", __func__);
499
500 ds2760_battery_read_status(di);
501
502 /* When we get notified by external circuitry that the battery is
503 * considered fully charged now, we know that there is no current
504 * flow any more. However, the ds2760's internal current meter is
505 * too inaccurate to rely on - spec say something ~15% failure.
506 * Hence, we use the current offset bias register to compensate
507 * that error.
508 */
509
510 if (!power_supply_am_i_supplied(psy: di->bat))
511 return;
512
513 bias = (signed char) di->current_raw +
514 (signed char) di->raw[DS2760_CURRENT_OFFSET_BIAS];
515
516 dev_dbg(di->dev, "%s: bias = %d\n", __func__, bias);
517
518 w1_ds2760_write(dev: di->dev, buf: &bias, DS2760_CURRENT_OFFSET_BIAS, count: 1);
519 w1_ds2760_store_eeprom(dev: di->dev, DS2760_EEPROM_BLOCK1);
520 w1_ds2760_recall_eeprom(dev: di->dev, DS2760_EEPROM_BLOCK1);
521
522 /* Write to the di->raw[] buffer directly - the CURRENT_OFFSET_BIAS
523 * value won't be read back by ds2760_battery_read_status() */
524 di->raw[DS2760_CURRENT_OFFSET_BIAS] = bias;
525}
526
527static void ds2760_battery_set_charged(struct power_supply *psy)
528{
529 struct ds2760_device_info *di = power_supply_get_drvdata(psy);
530
531 /* postpone the actual work by 20 secs. This is for debouncing GPIO
532 * signals and to let the current value settle. See AN4188. */
533 mod_delayed_work(wq: di->monitor_wqueue, dwork: &di->set_charged_work, HZ * 20);
534}
535
536static int ds2760_battery_get_property(struct power_supply *psy,
537 enum power_supply_property psp,
538 union power_supply_propval *val)
539{
540 struct ds2760_device_info *di = power_supply_get_drvdata(psy);
541
542 switch (psp) {
543 case POWER_SUPPLY_PROP_STATUS:
544 val->intval = di->charge_status;
545 return 0;
546 default:
547 break;
548 }
549
550 ds2760_battery_read_status(di);
551
552 switch (psp) {
553 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
554 val->intval = di->voltage_uV;
555 break;
556 case POWER_SUPPLY_PROP_CURRENT_NOW:
557 val->intval = di->current_uA;
558 break;
559 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
560 val->intval = di->rated_capacity;
561 break;
562 case POWER_SUPPLY_PROP_CHARGE_FULL:
563 val->intval = di->full_active_uAh;
564 break;
565 case POWER_SUPPLY_PROP_CHARGE_EMPTY:
566 val->intval = di->empty_uAh;
567 break;
568 case POWER_SUPPLY_PROP_CHARGE_NOW:
569 val->intval = di->accum_current_uAh;
570 break;
571 case POWER_SUPPLY_PROP_TEMP:
572 val->intval = di->temp_C;
573 break;
574 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
575 val->intval = di->life_sec;
576 break;
577 case POWER_SUPPLY_PROP_CAPACITY:
578 val->intval = di->rem_capacity;
579 break;
580 default:
581 return -EINVAL;
582 }
583
584 return 0;
585}
586
587static int ds2760_battery_set_property(struct power_supply *psy,
588 enum power_supply_property psp,
589 const union power_supply_propval *val)
590{
591 struct ds2760_device_info *di = power_supply_get_drvdata(psy);
592
593 switch (psp) {
594 case POWER_SUPPLY_PROP_CHARGE_FULL:
595 /* the interface counts in uAh, convert the value */
596 ds2760_battery_write_active_full(di, active_full: val->intval / 1000L);
597 break;
598
599 case POWER_SUPPLY_PROP_CHARGE_NOW:
600 /* ds2760_battery_set_current_accum() does the conversion */
601 ds2760_battery_set_current_accum(di, acr_val: val->intval);
602 break;
603
604 default:
605 return -EPERM;
606 }
607
608 return 0;
609}
610
611static int ds2760_battery_property_is_writeable(struct power_supply *psy,
612 enum power_supply_property psp)
613{
614 switch (psp) {
615 case POWER_SUPPLY_PROP_CHARGE_FULL:
616 case POWER_SUPPLY_PROP_CHARGE_NOW:
617 return 1;
618
619 default:
620 break;
621 }
622
623 return 0;
624}
625
626static enum power_supply_property ds2760_battery_props[] = {
627 POWER_SUPPLY_PROP_STATUS,
628 POWER_SUPPLY_PROP_VOLTAGE_NOW,
629 POWER_SUPPLY_PROP_CURRENT_NOW,
630 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
631 POWER_SUPPLY_PROP_CHARGE_FULL,
632 POWER_SUPPLY_PROP_CHARGE_EMPTY,
633 POWER_SUPPLY_PROP_CHARGE_NOW,
634 POWER_SUPPLY_PROP_TEMP,
635 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
636 POWER_SUPPLY_PROP_CAPACITY,
637};
638
639static int ds2760_pm_notifier(struct notifier_block *notifier,
640 unsigned long pm_event,
641 void *unused)
642{
643 struct ds2760_device_info *di =
644 container_of(notifier, struct ds2760_device_info, pm_notifier);
645
646 switch (pm_event) {
647 case PM_HIBERNATION_PREPARE:
648 case PM_SUSPEND_PREPARE:
649 di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
650 break;
651
652 case PM_POST_RESTORE:
653 case PM_POST_HIBERNATION:
654 case PM_POST_SUSPEND:
655 di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
656 power_supply_changed(psy: di->bat);
657 mod_delayed_work(wq: di->monitor_wqueue, dwork: &di->monitor_work, HZ);
658
659 break;
660
661 case PM_RESTORE_PREPARE:
662 default:
663 break;
664 }
665
666 return NOTIFY_DONE;
667}
668
669static int w1_ds2760_add_slave(struct w1_slave *sl)
670{
671 struct power_supply_config psy_cfg = {};
672 struct ds2760_device_info *di;
673 struct device *dev = &sl->dev;
674 int retval = 0;
675 char name[32];
676 char status;
677
678 di = devm_kzalloc(dev, size: sizeof(*di), GFP_KERNEL);
679 if (!di) {
680 retval = -ENOMEM;
681 goto di_alloc_failed;
682 }
683
684 snprintf(buf: name, size: sizeof(name), fmt: "ds2760-battery.%d", dev->id);
685
686 di->dev = dev;
687 di->bat_desc.name = name;
688 di->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY;
689 di->bat_desc.properties = ds2760_battery_props;
690 di->bat_desc.num_properties = ARRAY_SIZE(ds2760_battery_props);
691 di->bat_desc.get_property = ds2760_battery_get_property;
692 di->bat_desc.set_property = ds2760_battery_set_property;
693 di->bat_desc.property_is_writeable =
694 ds2760_battery_property_is_writeable;
695 di->bat_desc.set_charged = ds2760_battery_set_charged;
696 di->bat_desc.external_power_changed =
697 ds2760_battery_external_power_changed;
698
699 psy_cfg.drv_data = di;
700
701 if (dev->of_node) {
702 u32 tmp;
703
704 psy_cfg.of_node = dev->of_node;
705
706 if (!of_property_read_bool(np: dev->of_node, propname: "maxim,pmod-enabled"))
707 pmod_enabled = true;
708
709 if (!of_property_read_u32(np: dev->of_node,
710 propname: "maxim,cache-time-ms", out_value: &tmp))
711 cache_time = tmp;
712
713 if (!of_property_read_u32(np: dev->of_node,
714 propname: "rated-capacity-microamp-hours",
715 out_value: &tmp))
716 rated_capacity = tmp / 10; /* property is in mAh */
717 }
718
719 di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
720
721 sl->family_data = di;
722
723 /* enable sleep mode feature */
724 ds2760_battery_read_status(di);
725 status = di->raw[DS2760_STATUS_REG];
726 if (pmod_enabled)
727 status |= DS2760_STATUS_PMOD;
728 else
729 status &= ~DS2760_STATUS_PMOD;
730
731 ds2760_battery_write_status(di, status);
732
733 /* set rated capacity from module param or device tree */
734 if (rated_capacity)
735 ds2760_battery_write_rated_capacity(di, rated_capacity);
736
737 /* set current accumulator if given as parameter.
738 * this should only be done for bootstrapping the value */
739 if (current_accum)
740 ds2760_battery_set_current_accum(di, acr_val: current_accum);
741
742 di->bat = power_supply_register(parent: dev, desc: &di->bat_desc, cfg: &psy_cfg);
743 if (IS_ERR(ptr: di->bat)) {
744 dev_err(di->dev, "failed to register battery\n");
745 retval = PTR_ERR(ptr: di->bat);
746 goto batt_failed;
747 }
748
749 INIT_DELAYED_WORK(&di->monitor_work, ds2760_battery_work);
750 INIT_DELAYED_WORK(&di->set_charged_work,
751 ds2760_battery_set_charged_work);
752 di->monitor_wqueue = alloc_ordered_workqueue(name, WQ_MEM_RECLAIM);
753 if (!di->monitor_wqueue) {
754 retval = -ESRCH;
755 goto workqueue_failed;
756 }
757 queue_delayed_work(wq: di->monitor_wqueue, dwork: &di->monitor_work, HZ * 1);
758
759 di->pm_notifier.notifier_call = ds2760_pm_notifier;
760 register_pm_notifier(nb: &di->pm_notifier);
761
762 goto success;
763
764workqueue_failed:
765 power_supply_unregister(psy: di->bat);
766batt_failed:
767di_alloc_failed:
768success:
769 return retval;
770}
771
772static void w1_ds2760_remove_slave(struct w1_slave *sl)
773{
774 struct ds2760_device_info *di = sl->family_data;
775
776 unregister_pm_notifier(nb: &di->pm_notifier);
777 cancel_delayed_work_sync(dwork: &di->monitor_work);
778 cancel_delayed_work_sync(dwork: &di->set_charged_work);
779 destroy_workqueue(wq: di->monitor_wqueue);
780 power_supply_unregister(psy: di->bat);
781}
782
783#ifdef CONFIG_OF
784static const struct of_device_id w1_ds2760_of_ids[] = {
785 { .compatible = "maxim,ds2760" },
786 {}
787};
788#endif
789
790static const struct w1_family_ops w1_ds2760_fops = {
791 .add_slave = w1_ds2760_add_slave,
792 .remove_slave = w1_ds2760_remove_slave,
793 .groups = w1_ds2760_groups,
794};
795
796static struct w1_family w1_ds2760_family = {
797 .fid = W1_FAMILY_DS2760,
798 .fops = &w1_ds2760_fops,
799 .of_match_table = of_match_ptr(w1_ds2760_of_ids),
800};
801module_w1_family(w1_ds2760_family);
802
803MODULE_AUTHOR("Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>, "
804 "Matt Reimer <mreimer@vpop.net>, "
805 "Anton Vorontsov <cbou@mail.ru>");
806MODULE_DESCRIPTION("1-wire Driver Dallas 2760 battery monitor chip");
807MODULE_LICENSE("GPL");
808MODULE_ALIAS("w1-family-" __stringify(W1_FAMILY_DS2760));
809

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