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 
34 static unsigned int cache_time = 1000;
35 module_param(cache_time, uint, 0644);
36 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
37 
38 static bool pmod_enabled;
39 module_param(pmod_enabled, bool, 0644);
40 MODULE_PARM_DESC(pmod_enabled, "PMOD enable bit");
41 
42 static unsigned int rated_capacity;
43 module_param(rated_capacity, uint, 0644);
44 MODULE_PARM_DESC(rated_capacity, "rated battery capacity, 10*mAh or index");
45 
46 static unsigned int current_accum;
47 module_param(current_accum, uint, 0644);
48 MODULE_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 
89 struct 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 
119 static 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 
149 out:
150 	mutex_unlock(&sl->master->bus_mutex);
151 
152 	return count;
153 }
154 
155 static 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, 0);
160 }
161 
162 static 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, 1);
167 }
168 
169 static 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(&sl->master->bus_mutex);
184 	return 0;
185 }
186 
187 static 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 
192 static 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 
197 static 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, off, count);
203 }
204 
205 static BIN_ATTR_RO(w1_slave, DS2760_DATA_SIZE);
206 
207 static struct bin_attribute *w1_ds2760_bin_attrs[] = {
208 	&bin_attr_w1_slave,
209 	NULL,
210 };
211 
212 static const struct attribute_group w1_ds2760_group = {
213 	.bin_attrs = w1_ds2760_bin_attrs,
214 };
215 
216 static 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. */
222 static int rated_capacities[] = {
223 	0,
224 	920,	/* Samsung */
225 	920,	/* BYD */
226 	920,	/* Lishen */
227 	920,	/* NEC */
228 	1440,	/* Samsung */
229 	1440,	/* BYD */
230 #ifdef CONFIG_MACH_H4700
231 	1800,	/* HP iPAQ hx4700 3.7V 1800mAh (359113-001) */
232 #else
233 	1440,	/* Lishen */
234 #endif
235 	1440,	/* NEC */
236 	2880,	/* Samsung */
237 	2880,	/* BYD */
238 	2880,	/* Lishen */
239 	2880,	/* NEC */
240 #ifdef CONFIG_MACH_H4700
241 	0,
242 	3600,	/* HP iPAQ hx4700 3.7V 3600mAh (359114-001) */
243 #endif
244 };
245 
246 /* array is level at temps 0°C, 10°C, 20°C, 30°C, 40°C
247  * temp is in Celsius */
248 static int battery_interpolate(int array[], int temp)
249 {
250 	int index, dt;
251 
252 	if (temp <= 0)
253 		return array[0];
254 	if (temp >= 40)
255 		return array[4];
256 
257 	index = temp / 10;
258 	dt    = temp % 10;
259 
260 	return array[index] + (((array[index + 1] - array[index]) * dt) / 10);
261 }
262 
263 static int ds2760_battery_read_status(struct ds2760_device_info *di)
264 {
265 	int ret, i, start, count, scale[5];
266 
267 	if (di->update_time && time_before(jiffies, di->update_time +
268 					   msecs_to_jiffies(cache_time)))
269 		return 0;
270 
271 	/* The first time we read the entire contents of SRAM/EEPROM,
272 	 * but after that we just read the interesting bits that change. */
273 	if (di->update_time == 0) {
274 		start = 0;
275 		count = DS2760_DATA_SIZE;
276 	} else {
277 		start = DS2760_VOLTAGE_MSB;
278 		count = DS2760_TEMP_LSB - start + 1;
279 	}
280 
281 	ret = w1_ds2760_read(di->dev, di->raw + start, start, count);
282 	if (ret != count) {
283 		dev_warn(di->dev, "call to w1_ds2760_read failed (0x%p)\n",
284 			 di->dev);
285 		return 1;
286 	}
287 
288 	di->update_time = jiffies;
289 
290 	/* DS2760 reports voltage in units of 4.88mV, but the battery class
291 	 * reports in units of uV, so convert by multiplying by 4880. */
292 	di->voltage_raw = (di->raw[DS2760_VOLTAGE_MSB] << 3) |
293 			  (di->raw[DS2760_VOLTAGE_LSB] >> 5);
294 	di->voltage_uV = di->voltage_raw * 4880;
295 
296 	/* DS2760 reports current in signed units of 0.625mA, but the battery
297 	 * class reports in units of µA, so convert by multiplying by 625. */
298 	di->current_raw =
299 	    (((signed char)di->raw[DS2760_CURRENT_MSB]) << 5) |
300 			  (di->raw[DS2760_CURRENT_LSB] >> 3);
301 	di->current_uA = di->current_raw * 625;
302 
303 	/* DS2760 reports accumulated current in signed units of 0.25mAh. */
304 	di->accum_current_raw =
305 	    (((signed char)di->raw[DS2760_CURRENT_ACCUM_MSB]) << 8) |
306 			   di->raw[DS2760_CURRENT_ACCUM_LSB];
307 	di->accum_current_uAh = di->accum_current_raw * 250;
308 
309 	/* DS2760 reports temperature in signed units of 0.125°C, but the
310 	 * battery class reports in units of 1/10 °C, so we convert by
311 	 * multiplying by .125 * 10 = 1.25. */
312 	di->temp_raw = (((signed char)di->raw[DS2760_TEMP_MSB]) << 3) |
313 				     (di->raw[DS2760_TEMP_LSB] >> 5);
314 	di->temp_C = di->temp_raw + (di->temp_raw / 4);
315 
316 	/* At least some battery monitors (e.g. HP iPAQ) store the battery's
317 	 * maximum rated capacity. */
318 	if (di->raw[DS2760_RATED_CAPACITY] < ARRAY_SIZE(rated_capacities))
319 		di->rated_capacity = rated_capacities[
320 			(unsigned int)di->raw[DS2760_RATED_CAPACITY]];
321 	else
322 		di->rated_capacity = di->raw[DS2760_RATED_CAPACITY] * 10;
323 
324 	di->rated_capacity *= 1000; /* convert to µAh */
325 
326 	/* Calculate the full level at the present temperature. */
327 	di->full_active_uAh = di->raw[DS2760_ACTIVE_FULL] << 8 |
328 			      di->raw[DS2760_ACTIVE_FULL + 1];
329 
330 	/* If the full_active_uAh value is not given, fall back to the rated
331 	 * capacity. This is likely to happen when chips are not part of the
332 	 * battery pack and is therefore not bootstrapped. */
333 	if (di->full_active_uAh == 0)
334 		di->full_active_uAh = di->rated_capacity / 1000L;
335 
336 	scale[0] = di->full_active_uAh;
337 	for (i = 1; i < 5; i++)
338 		scale[i] = scale[i - 1] + di->raw[DS2760_ACTIVE_FULL + 1 + i];
339 
340 	di->full_active_uAh = battery_interpolate(scale, di->temp_C / 10);
341 	di->full_active_uAh *= 1000; /* convert to µAh */
342 
343 	/* Calculate the empty level at the present temperature. */
344 	scale[4] = di->raw[DS2760_ACTIVE_EMPTY + 4];
345 	for (i = 3; i >= 0; i--)
346 		scale[i] = scale[i + 1] + di->raw[DS2760_ACTIVE_EMPTY + i];
347 
348 	di->empty_uAh = battery_interpolate(scale, di->temp_C / 10);
349 	di->empty_uAh *= 1000; /* convert to µAh */
350 
351 	if (di->full_active_uAh == di->empty_uAh)
352 		di->rem_capacity = 0;
353 	else
354 		/* From Maxim Application Note 131: remaining capacity =
355 		 * ((ICA - Empty Value) / (Full Value - Empty Value)) x 100% */
356 		di->rem_capacity = ((di->accum_current_uAh - di->empty_uAh) * 100L) /
357 				    (di->full_active_uAh - di->empty_uAh);
358 
359 	if (di->rem_capacity < 0)
360 		di->rem_capacity = 0;
361 	if (di->rem_capacity > 100)
362 		di->rem_capacity = 100;
363 
364 	if (di->current_uA < -100L)
365 		di->life_sec = -((di->accum_current_uAh - di->empty_uAh) * 36L)
366 					/ (di->current_uA / 100L);
367 	else
368 		di->life_sec = 0;
369 
370 	return 0;
371 }
372 
373 static void ds2760_battery_set_current_accum(struct ds2760_device_info *di,
374 					     unsigned int acr_val)
375 {
376 	unsigned char acr[2];
377 
378 	/* acr is in units of 0.25 mAh */
379 	acr_val *= 4L;
380 	acr_val /= 1000;
381 
382 	acr[0] = acr_val >> 8;
383 	acr[1] = acr_val & 0xff;
384 
385 	if (w1_ds2760_write(di->dev, acr, DS2760_CURRENT_ACCUM_MSB, 2) < 2)
386 		dev_warn(di->dev, "ACR write failed\n");
387 }
388 
389 static void ds2760_battery_update_status(struct ds2760_device_info *di)
390 {
391 	int old_charge_status = di->charge_status;
392 
393 	ds2760_battery_read_status(di);
394 
395 	if (di->charge_status == POWER_SUPPLY_STATUS_UNKNOWN)
396 		di->full_counter = 0;
397 
398 	if (power_supply_am_i_supplied(di->bat)) {
399 		if (di->current_uA > 10000) {
400 			di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
401 			di->full_counter = 0;
402 		} else if (di->current_uA < -5000) {
403 			if (di->charge_status != POWER_SUPPLY_STATUS_NOT_CHARGING)
404 				dev_notice(di->dev, "not enough power to "
405 					   "charge\n");
406 			di->charge_status = POWER_SUPPLY_STATUS_NOT_CHARGING;
407 			di->full_counter = 0;
408 		} else if (di->current_uA < 10000 &&
409 			    di->charge_status != POWER_SUPPLY_STATUS_FULL) {
410 
411 			/* Don't consider the battery to be full unless
412 			 * we've seen the current < 10 mA at least two
413 			 * consecutive times. */
414 
415 			di->full_counter++;
416 
417 			if (di->full_counter < 2) {
418 				di->charge_status = POWER_SUPPLY_STATUS_CHARGING;
419 			} else {
420 				di->charge_status = POWER_SUPPLY_STATUS_FULL;
421 				ds2760_battery_set_current_accum(di,
422 						di->full_active_uAh);
423 			}
424 		}
425 	} else {
426 		di->charge_status = POWER_SUPPLY_STATUS_DISCHARGING;
427 		di->full_counter = 0;
428 	}
429 
430 	if (di->charge_status != old_charge_status)
431 		power_supply_changed(di->bat);
432 }
433 
434 static void ds2760_battery_write_status(struct ds2760_device_info *di,
435 					char status)
436 {
437 	if (status == di->raw[DS2760_STATUS_REG])
438 		return;
439 
440 	w1_ds2760_write(di->dev, &status, DS2760_STATUS_WRITE_REG, 1);
441 	w1_ds2760_store_eeprom(di->dev, DS2760_EEPROM_BLOCK1);
442 	w1_ds2760_recall_eeprom(di->dev, DS2760_EEPROM_BLOCK1);
443 }
444 
445 static void ds2760_battery_write_rated_capacity(struct ds2760_device_info *di,
446 						unsigned char rated_capacity)
447 {
448 	if (rated_capacity == di->raw[DS2760_RATED_CAPACITY])
449 		return;
450 
451 	w1_ds2760_write(di->dev, &rated_capacity, DS2760_RATED_CAPACITY, 1);
452 	w1_ds2760_store_eeprom(di->dev, DS2760_EEPROM_BLOCK1);
453 	w1_ds2760_recall_eeprom(di->dev, DS2760_EEPROM_BLOCK1);
454 }
455 
456 static void ds2760_battery_write_active_full(struct ds2760_device_info *di,
457 					     int active_full)
458 {
459 	unsigned char tmp[2] = {
460 		active_full >> 8,
461 		active_full & 0xff
462 	};
463 
464 	if (tmp[0] == di->raw[DS2760_ACTIVE_FULL] &&
465 	    tmp[1] == di->raw[DS2760_ACTIVE_FULL + 1])
466 		return;
467 
468 	w1_ds2760_write(di->dev, tmp, DS2760_ACTIVE_FULL, sizeof(tmp));
469 	w1_ds2760_store_eeprom(di->dev, DS2760_EEPROM_BLOCK0);
470 	w1_ds2760_recall_eeprom(di->dev, DS2760_EEPROM_BLOCK0);
471 
472 	/* Write to the di->raw[] buffer directly - the DS2760_ACTIVE_FULL
473 	 * values won't be read back by ds2760_battery_read_status() */
474 	di->raw[DS2760_ACTIVE_FULL] = tmp[0];
475 	di->raw[DS2760_ACTIVE_FULL + 1] = tmp[1];
476 }
477 
478 static void ds2760_battery_work(struct work_struct *work)
479 {
480 	struct ds2760_device_info *di = container_of(work,
481 		struct ds2760_device_info, monitor_work.work);
482 	const int interval = HZ * 60;
483 
484 	dev_dbg(di->dev, "%s\n", __func__);
485 
486 	ds2760_battery_update_status(di);
487 	queue_delayed_work(di->monitor_wqueue, &di->monitor_work, interval);
488 }
489 
490 static void ds2760_battery_external_power_changed(struct power_supply *psy)
491 {
492 	struct ds2760_device_info *di = power_supply_get_drvdata(psy);
493 
494 	dev_dbg(di->dev, "%s\n", __func__);
495 
496 	mod_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ/10);
497 }
498 
499 
500 static void ds2760_battery_set_charged_work(struct work_struct *work)
501 {
502 	char bias;
503 	struct ds2760_device_info *di = container_of(work,
504 		struct ds2760_device_info, set_charged_work.work);
505 
506 	dev_dbg(di->dev, "%s\n", __func__);
507 
508 	ds2760_battery_read_status(di);
509 
510 	/* When we get notified by external circuitry that the battery is
511 	 * considered fully charged now, we know that there is no current
512 	 * flow any more. However, the ds2760's internal current meter is
513 	 * too inaccurate to rely on - spec say something ~15% failure.
514 	 * Hence, we use the current offset bias register to compensate
515 	 * that error.
516 	 */
517 
518 	if (!power_supply_am_i_supplied(di->bat))
519 		return;
520 
521 	bias = (signed char) di->current_raw +
522 		(signed char) di->raw[DS2760_CURRENT_OFFSET_BIAS];
523 
524 	dev_dbg(di->dev, "%s: bias = %d\n", __func__, bias);
525 
526 	w1_ds2760_write(di->dev, &bias, DS2760_CURRENT_OFFSET_BIAS, 1);
527 	w1_ds2760_store_eeprom(di->dev, DS2760_EEPROM_BLOCK1);
528 	w1_ds2760_recall_eeprom(di->dev, DS2760_EEPROM_BLOCK1);
529 
530 	/* Write to the di->raw[] buffer directly - the CURRENT_OFFSET_BIAS
531 	 * value won't be read back by ds2760_battery_read_status() */
532 	di->raw[DS2760_CURRENT_OFFSET_BIAS] = bias;
533 }
534 
535 static void ds2760_battery_set_charged(struct power_supply *psy)
536 {
537 	struct ds2760_device_info *di = power_supply_get_drvdata(psy);
538 
539 	/* postpone the actual work by 20 secs. This is for debouncing GPIO
540 	 * signals and to let the current value settle. See AN4188. */
541 	mod_delayed_work(di->monitor_wqueue, &di->set_charged_work, HZ * 20);
542 }
543 
544 static int ds2760_battery_get_property(struct power_supply *psy,
545 				       enum power_supply_property psp,
546 				       union power_supply_propval *val)
547 {
548 	struct ds2760_device_info *di = power_supply_get_drvdata(psy);
549 
550 	switch (psp) {
551 	case POWER_SUPPLY_PROP_STATUS:
552 		val->intval = di->charge_status;
553 		return 0;
554 	default:
555 		break;
556 	}
557 
558 	ds2760_battery_read_status(di);
559 
560 	switch (psp) {
561 	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
562 		val->intval = di->voltage_uV;
563 		break;
564 	case POWER_SUPPLY_PROP_CURRENT_NOW:
565 		val->intval = di->current_uA;
566 		break;
567 	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
568 		val->intval = di->rated_capacity;
569 		break;
570 	case POWER_SUPPLY_PROP_CHARGE_FULL:
571 		val->intval = di->full_active_uAh;
572 		break;
573 	case POWER_SUPPLY_PROP_CHARGE_EMPTY:
574 		val->intval = di->empty_uAh;
575 		break;
576 	case POWER_SUPPLY_PROP_CHARGE_NOW:
577 		val->intval = di->accum_current_uAh;
578 		break;
579 	case POWER_SUPPLY_PROP_TEMP:
580 		val->intval = di->temp_C;
581 		break;
582 	case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
583 		val->intval = di->life_sec;
584 		break;
585 	case POWER_SUPPLY_PROP_CAPACITY:
586 		val->intval = di->rem_capacity;
587 		break;
588 	default:
589 		return -EINVAL;
590 	}
591 
592 	return 0;
593 }
594 
595 static int ds2760_battery_set_property(struct power_supply *psy,
596 				       enum power_supply_property psp,
597 				       const union power_supply_propval *val)
598 {
599 	struct ds2760_device_info *di = power_supply_get_drvdata(psy);
600 
601 	switch (psp) {
602 	case POWER_SUPPLY_PROP_CHARGE_FULL:
603 		/* the interface counts in uAh, convert the value */
604 		ds2760_battery_write_active_full(di, val->intval / 1000L);
605 		break;
606 
607 	case POWER_SUPPLY_PROP_CHARGE_NOW:
608 		/* ds2760_battery_set_current_accum() does the conversion */
609 		ds2760_battery_set_current_accum(di, val->intval);
610 		break;
611 
612 	default:
613 		return -EPERM;
614 	}
615 
616 	return 0;
617 }
618 
619 static int ds2760_battery_property_is_writeable(struct power_supply *psy,
620 						enum power_supply_property psp)
621 {
622 	switch (psp) {
623 	case POWER_SUPPLY_PROP_CHARGE_FULL:
624 	case POWER_SUPPLY_PROP_CHARGE_NOW:
625 		return 1;
626 
627 	default:
628 		break;
629 	}
630 
631 	return 0;
632 }
633 
634 static enum power_supply_property ds2760_battery_props[] = {
635 	POWER_SUPPLY_PROP_STATUS,
636 	POWER_SUPPLY_PROP_VOLTAGE_NOW,
637 	POWER_SUPPLY_PROP_CURRENT_NOW,
638 	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
639 	POWER_SUPPLY_PROP_CHARGE_FULL,
640 	POWER_SUPPLY_PROP_CHARGE_EMPTY,
641 	POWER_SUPPLY_PROP_CHARGE_NOW,
642 	POWER_SUPPLY_PROP_TEMP,
643 	POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
644 	POWER_SUPPLY_PROP_CAPACITY,
645 };
646 
647 static int ds2760_pm_notifier(struct notifier_block *notifier,
648 			      unsigned long pm_event,
649 			      void *unused)
650 {
651 	struct ds2760_device_info *di =
652 		container_of(notifier, struct ds2760_device_info, pm_notifier);
653 
654 	switch (pm_event) {
655 	case PM_HIBERNATION_PREPARE:
656 	case PM_SUSPEND_PREPARE:
657 		di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
658 		break;
659 
660 	case PM_POST_RESTORE:
661 	case PM_POST_HIBERNATION:
662 	case PM_POST_SUSPEND:
663 		di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
664 		power_supply_changed(di->bat);
665 		mod_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ);
666 
667 		break;
668 
669 	case PM_RESTORE_PREPARE:
670 	default:
671 		break;
672 	}
673 
674 	return NOTIFY_DONE;
675 }
676 
677 static int w1_ds2760_add_slave(struct w1_slave *sl)
678 {
679 	struct power_supply_config psy_cfg = {};
680 	struct ds2760_device_info *di;
681 	struct device *dev = &sl->dev;
682 	int retval = 0;
683 	char name[32];
684 	char status;
685 
686 	di = devm_kzalloc(dev, sizeof(*di), GFP_KERNEL);
687 	if (!di) {
688 		retval = -ENOMEM;
689 		goto di_alloc_failed;
690 	}
691 
692 	snprintf(name, sizeof(name), "ds2760-battery.%d", dev->id);
693 
694 	di->dev				= dev;
695 	di->bat_desc.name		= name;
696 	di->bat_desc.type		= POWER_SUPPLY_TYPE_BATTERY;
697 	di->bat_desc.properties		= ds2760_battery_props;
698 	di->bat_desc.num_properties	= ARRAY_SIZE(ds2760_battery_props);
699 	di->bat_desc.get_property	= ds2760_battery_get_property;
700 	di->bat_desc.set_property	= ds2760_battery_set_property;
701 	di->bat_desc.property_is_writeable =
702 				  ds2760_battery_property_is_writeable;
703 	di->bat_desc.set_charged	= ds2760_battery_set_charged;
704 	di->bat_desc.external_power_changed =
705 				  ds2760_battery_external_power_changed;
706 
707 	psy_cfg.drv_data = di;
708 
709 	if (dev->of_node) {
710 		u32 tmp;
711 
712 		psy_cfg.of_node = dev->of_node;
713 
714 		if (!of_property_read_bool(dev->of_node, "maxim,pmod-enabled"))
715 			pmod_enabled = true;
716 
717 		if (!of_property_read_u32(dev->of_node,
718 					  "maxim,cache-time-ms", &tmp))
719 			cache_time = tmp;
720 
721 		if (!of_property_read_u32(dev->of_node,
722 					  "rated-capacity-microamp-hours",
723 					  &tmp))
724 			rated_capacity = tmp / 10; /* property is in mAh */
725 	}
726 
727 	di->charge_status = POWER_SUPPLY_STATUS_UNKNOWN;
728 
729 	sl->family_data = di;
730 
731 	/* enable sleep mode feature */
732 	ds2760_battery_read_status(di);
733 	status = di->raw[DS2760_STATUS_REG];
734 	if (pmod_enabled)
735 		status |= DS2760_STATUS_PMOD;
736 	else
737 		status &= ~DS2760_STATUS_PMOD;
738 
739 	ds2760_battery_write_status(di, status);
740 
741 	/* set rated capacity from module param or device tree */
742 	if (rated_capacity)
743 		ds2760_battery_write_rated_capacity(di, rated_capacity);
744 
745 	/* set current accumulator if given as parameter.
746 	 * this should only be done for bootstrapping the value */
747 	if (current_accum)
748 		ds2760_battery_set_current_accum(di, current_accum);
749 
750 	di->bat = power_supply_register(dev, &di->bat_desc, &psy_cfg);
751 	if (IS_ERR(di->bat)) {
752 		dev_err(di->dev, "failed to register battery\n");
753 		retval = PTR_ERR(di->bat);
754 		goto batt_failed;
755 	}
756 
757 	INIT_DELAYED_WORK(&di->monitor_work, ds2760_battery_work);
758 	INIT_DELAYED_WORK(&di->set_charged_work,
759 			  ds2760_battery_set_charged_work);
760 	di->monitor_wqueue = alloc_ordered_workqueue(name, WQ_MEM_RECLAIM);
761 	if (!di->monitor_wqueue) {
762 		retval = -ESRCH;
763 		goto workqueue_failed;
764 	}
765 	queue_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ * 1);
766 
767 	di->pm_notifier.notifier_call = ds2760_pm_notifier;
768 	register_pm_notifier(&di->pm_notifier);
769 
770 	goto success;
771 
772 workqueue_failed:
773 	power_supply_unregister(di->bat);
774 batt_failed:
775 di_alloc_failed:
776 success:
777 	return retval;
778 }
779 
780 static void w1_ds2760_remove_slave(struct w1_slave *sl)
781 {
782 	struct ds2760_device_info *di = sl->family_data;
783 
784 	unregister_pm_notifier(&di->pm_notifier);
785 	cancel_delayed_work_sync(&di->monitor_work);
786 	cancel_delayed_work_sync(&di->set_charged_work);
787 	destroy_workqueue(di->monitor_wqueue);
788 	power_supply_unregister(di->bat);
789 }
790 
791 #ifdef CONFIG_OF
792 static const struct of_device_id w1_ds2760_of_ids[] = {
793 	{ .compatible = "maxim,ds2760" },
794 	{}
795 };
796 #endif
797 
798 static const struct w1_family_ops w1_ds2760_fops = {
799 	.add_slave	= w1_ds2760_add_slave,
800 	.remove_slave	= w1_ds2760_remove_slave,
801 	.groups		= w1_ds2760_groups,
802 };
803 
804 static struct w1_family w1_ds2760_family = {
805 	.fid		= W1_FAMILY_DS2760,
806 	.fops		= &w1_ds2760_fops,
807 	.of_match_table	= of_match_ptr(w1_ds2760_of_ids),
808 };
809 module_w1_family(w1_ds2760_family);
810 
811 MODULE_AUTHOR("Szabolcs Gyurko <szabolcs.gyurko@tlt.hu>, "
812 	      "Matt Reimer <mreimer@vpop.net>, "
813 	      "Anton Vorontsov <cbou@mail.ru>");
814 MODULE_DESCRIPTION("1-wire Driver Dallas 2760 battery monitor chip");
815 MODULE_LICENSE("GPL");
816 MODULE_ALIAS("w1-family-" __stringify(W1_FAMILY_DS2760));
817