Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ds2760_battery.c
Go to the documentation of this file.
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 <[email protected]>
13  * February 2007
14  *
15  * Matt Reimer <[email protected]>
16  * April 2004, 2005, 2007
17  *
18  * Szabolcs Gyurko <[email protected]>
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 
31 #include "../w1/w1.h"
32 #include "../w1/slaves/w1_ds2760.h"
33 
35  struct device *dev;
36 
37  /* DS2760 data, valid after calling ds2760_battery_read_status() */
38  unsigned long update_time; /* jiffies when data read */
39  char raw[DS2760_DATA_SIZE]; /* raw DS2760 data */
40  int voltage_raw; /* units of 4.88 mV */
41  int voltage_uV; /* units of µV */
42  int current_raw; /* units of 0.625 mA */
43  int current_uA; /* units of µA */
44  int accum_current_raw; /* units of 0.25 mAh */
45  int accum_current_uAh; /* units of µAh */
46  int temp_raw; /* units of 0.125 °C */
47  int temp_C; /* units of 0.1 °C */
48  int rated_capacity; /* units of µAh */
49  int rem_capacity; /* percentage */
50  int full_active_uAh; /* units of µAh */
51  int empty_uAh; /* units of µAh */
52  int life_sec; /* units of seconds */
53  int charge_status; /* POWER_SUPPLY_STATUS_* */
54 
56  struct power_supply bat;
57  struct device *w1_dev;
61 };
62 
63 static unsigned int cache_time = 1000;
64 module_param(cache_time, uint, 0644);
65 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
66 
67 static bool pmod_enabled;
68 module_param(pmod_enabled, bool, 0644);
69 MODULE_PARM_DESC(pmod_enabled, "PMOD enable bit");
70 
71 static unsigned int rated_capacity;
72 module_param(rated_capacity, uint, 0644);
73 MODULE_PARM_DESC(rated_capacity, "rated battery capacity, 10*mAh or index");
74 
75 static unsigned int current_accum;
76 module_param(current_accum, uint, 0644);
77 MODULE_PARM_DESC(current_accum, "current accumulator value");
78 
79 /* Some batteries have their rated capacity stored a N * 10 mAh, while
80  * others use an index into this table. */
81 static int rated_capacities[] = {
82  0,
83  920, /* Samsung */
84  920, /* BYD */
85  920, /* Lishen */
86  920, /* NEC */
87  1440, /* Samsung */
88  1440, /* BYD */
89 #ifdef CONFIG_MACH_H4700
90  1800, /* HP iPAQ hx4700 3.7V 1800mAh (359113-001) */
91 #else
92  1440, /* Lishen */
93 #endif
94  1440, /* NEC */
95  2880, /* Samsung */
96  2880, /* BYD */
97  2880, /* Lishen */
98  2880, /* NEC */
99 #ifdef CONFIG_MACH_H4700
100  0,
101  3600, /* HP iPAQ hx4700 3.7V 3600mAh (359114-001) */
102 #endif
103 };
104 
105 /* array is level at temps 0°C, 10°C, 20°C, 30°C, 40°C
106  * temp is in Celsius */
107 static int battery_interpolate(int array[], int temp)
108 {
109  int index, dt;
110 
111  if (temp <= 0)
112  return array[0];
113  if (temp >= 40)
114  return array[4];
115 
116  index = temp / 10;
117  dt = temp % 10;
118 
119  return array[index] + (((array[index + 1] - array[index]) * dt) / 10);
120 }
121 
122 static int ds2760_battery_read_status(struct ds2760_device_info *di)
123 {
124  int ret, i, start, count, scale[5];
125 
126  if (di->update_time && time_before(jiffies, di->update_time +
127  msecs_to_jiffies(cache_time)))
128  return 0;
129 
130  /* The first time we read the entire contents of SRAM/EEPROM,
131  * but after that we just read the interesting bits that change. */
132  if (di->update_time == 0) {
133  start = 0;
134  count = DS2760_DATA_SIZE;
135  } else {
136  start = DS2760_VOLTAGE_MSB;
137  count = DS2760_TEMP_LSB - start + 1;
138  }
139 
140  ret = w1_ds2760_read(di->w1_dev, di->raw + start, start, count);
141  if (ret != count) {
142  dev_warn(di->dev, "call to w1_ds2760_read failed (0x%p)\n",
143  di->w1_dev);
144  return 1;
145  }
146 
147  di->update_time = jiffies;
148 
149  /* DS2760 reports voltage in units of 4.88mV, but the battery class
150  * reports in units of uV, so convert by multiplying by 4880. */
151  di->voltage_raw = (di->raw[DS2760_VOLTAGE_MSB] << 3) |
152  (di->raw[DS2760_VOLTAGE_LSB] >> 5);
153  di->voltage_uV = di->voltage_raw * 4880;
154 
155  /* DS2760 reports current in signed units of 0.625mA, but the battery
156  * class reports in units of µA, so convert by multiplying by 625. */
157  di->current_raw =
158  (((signed char)di->raw[DS2760_CURRENT_MSB]) << 5) |
159  (di->raw[DS2760_CURRENT_LSB] >> 3);
160  di->current_uA = di->current_raw * 625;
161 
162  /* DS2760 reports accumulated current in signed units of 0.25mAh. */
163  di->accum_current_raw =
164  (((signed char)di->raw[DS2760_CURRENT_ACCUM_MSB]) << 8) |
166  di->accum_current_uAh = di->accum_current_raw * 250;
167 
168  /* DS2760 reports temperature in signed units of 0.125°C, but the
169  * battery class reports in units of 1/10 °C, so we convert by
170  * multiplying by .125 * 10 = 1.25. */
171  di->temp_raw = (((signed char)di->raw[DS2760_TEMP_MSB]) << 3) |
172  (di->raw[DS2760_TEMP_LSB] >> 5);
173  di->temp_C = di->temp_raw + (di->temp_raw / 4);
174 
175  /* At least some battery monitors (e.g. HP iPAQ) store the battery's
176  * maximum rated capacity. */
177  if (di->raw[DS2760_RATED_CAPACITY] < ARRAY_SIZE(rated_capacities))
178  di->rated_capacity = rated_capacities[
179  (unsigned int)di->raw[DS2760_RATED_CAPACITY]];
180  else
181  di->rated_capacity = di->raw[DS2760_RATED_CAPACITY] * 10;
182 
183  di->rated_capacity *= 1000; /* convert to µAh */
184 
185  /* Calculate the full level at the present temperature. */
186  di->full_active_uAh = di->raw[DS2760_ACTIVE_FULL] << 8 |
187  di->raw[DS2760_ACTIVE_FULL + 1];
188 
189  /* If the full_active_uAh value is not given, fall back to the rated
190  * capacity. This is likely to happen when chips are not part of the
191  * battery pack and is therefore not bootstrapped. */
192  if (di->full_active_uAh == 0)
193  di->full_active_uAh = di->rated_capacity / 1000L;
194 
195  scale[0] = di->full_active_uAh;
196  for (i = 1; i < 5; i++)
197  scale[i] = scale[i - 1] + di->raw[DS2760_ACTIVE_FULL + 1 + i];
198 
199  di->full_active_uAh = battery_interpolate(scale, di->temp_C / 10);
200  di->full_active_uAh *= 1000; /* convert to µAh */
201 
202  /* Calculate the empty level at the present temperature. */
203  scale[4] = di->raw[DS2760_ACTIVE_EMPTY + 4];
204  for (i = 3; i >= 0; i--)
205  scale[i] = scale[i + 1] + di->raw[DS2760_ACTIVE_EMPTY + i];
206 
207  di->empty_uAh = battery_interpolate(scale, di->temp_C / 10);
208  di->empty_uAh *= 1000; /* convert to µAh */
209 
210  if (di->full_active_uAh == di->empty_uAh)
211  di->rem_capacity = 0;
212  else
213  /* From Maxim Application Note 131: remaining capacity =
214  * ((ICA - Empty Value) / (Full Value - Empty Value)) x 100% */
215  di->rem_capacity = ((di->accum_current_uAh - di->empty_uAh) * 100L) /
216  (di->full_active_uAh - di->empty_uAh);
217 
218  if (di->rem_capacity < 0)
219  di->rem_capacity = 0;
220  if (di->rem_capacity > 100)
221  di->rem_capacity = 100;
222 
223  if (di->current_uA < -100L)
224  di->life_sec = -((di->accum_current_uAh - di->empty_uAh) * 36L)
225  / (di->current_uA / 100L);
226  else
227  di->life_sec = 0;
228 
229  return 0;
230 }
231 
232 static void ds2760_battery_set_current_accum(struct ds2760_device_info *di,
233  unsigned int acr_val)
234 {
235  unsigned char acr[2];
236 
237  /* acr is in units of 0.25 mAh */
238  acr_val *= 4L;
239  acr_val /= 1000;
240 
241  acr[0] = acr_val >> 8;
242  acr[1] = acr_val & 0xff;
243 
244  if (w1_ds2760_write(di->w1_dev, acr, DS2760_CURRENT_ACCUM_MSB, 2) < 2)
245  dev_warn(di->dev, "ACR write failed\n");
246 }
247 
248 static void ds2760_battery_update_status(struct ds2760_device_info *di)
249 {
250  int old_charge_status = di->charge_status;
251 
252  ds2760_battery_read_status(di);
253 
255  di->full_counter = 0;
256 
257  if (power_supply_am_i_supplied(&di->bat)) {
258  if (di->current_uA > 10000) {
260  di->full_counter = 0;
261  } else if (di->current_uA < -5000) {
263  dev_notice(di->dev, "not enough power to "
264  "charge\n");
266  di->full_counter = 0;
267  } else if (di->current_uA < 10000 &&
269 
270  /* Don't consider the battery to be full unless
271  * we've seen the current < 10 mA at least two
272  * consecutive times. */
273 
274  di->full_counter++;
275 
276  if (di->full_counter < 2) {
278  } else {
280  ds2760_battery_set_current_accum(di,
281  di->full_active_uAh);
282  }
283  }
284  } else {
286  di->full_counter = 0;
287  }
288 
289  if (di->charge_status != old_charge_status)
291 }
292 
293 static void ds2760_battery_write_status(struct ds2760_device_info *di,
294  char status)
295 {
296  if (status == di->raw[DS2760_STATUS_REG])
297  return;
298 
302 }
303 
304 static void ds2760_battery_write_rated_capacity(struct ds2760_device_info *di,
305  unsigned char rated_capacity)
306 {
307  if (rated_capacity == di->raw[DS2760_RATED_CAPACITY])
308  return;
309 
310  w1_ds2760_write(di->w1_dev, &rated_capacity, DS2760_RATED_CAPACITY, 1);
313 }
314 
315 static void ds2760_battery_write_active_full(struct ds2760_device_info *di,
316  int active_full)
317 {
318  unsigned char tmp[2] = {
319  active_full >> 8,
320  active_full & 0xff
321  };
322 
323  if (tmp[0] == di->raw[DS2760_ACTIVE_FULL] &&
324  tmp[1] == di->raw[DS2760_ACTIVE_FULL + 1])
325  return;
326 
327  w1_ds2760_write(di->w1_dev, tmp, DS2760_ACTIVE_FULL, sizeof(tmp));
330 
331  /* Write to the di->raw[] buffer directly - the DS2760_ACTIVE_FULL
332  * values won't be read back by ds2760_battery_read_status() */
333  di->raw[DS2760_ACTIVE_FULL] = tmp[0];
334  di->raw[DS2760_ACTIVE_FULL + 1] = tmp[1];
335 }
336 
337 static void ds2760_battery_work(struct work_struct *work)
338 {
339  struct ds2760_device_info *di = container_of(work,
340  struct ds2760_device_info, monitor_work.work);
341  const int interval = HZ * 60;
342 
343  dev_dbg(di->dev, "%s\n", __func__);
344 
345  ds2760_battery_update_status(di);
346  queue_delayed_work(di->monitor_wqueue, &di->monitor_work, interval);
347 }
348 
349 #define to_ds2760_device_info(x) container_of((x), struct ds2760_device_info, \
350  bat);
351 
352 static void ds2760_battery_external_power_changed(struct power_supply *psy)
353 {
354  struct ds2760_device_info *di = to_ds2760_device_info(psy);
355 
356  dev_dbg(di->dev, "%s\n", __func__);
357 
359 }
360 
361 
362 static void ds2760_battery_set_charged_work(struct work_struct *work)
363 {
364  char bias;
365  struct ds2760_device_info *di = container_of(work,
366  struct ds2760_device_info, set_charged_work.work);
367 
368  dev_dbg(di->dev, "%s\n", __func__);
369 
370  ds2760_battery_read_status(di);
371 
372  /* When we get notified by external circuitry that the battery is
373  * considered fully charged now, we know that there is no current
374  * flow any more. However, the ds2760's internal current meter is
375  * too inaccurate to rely on - spec say something ~15% failure.
376  * Hence, we use the current offset bias register to compensate
377  * that error.
378  */
379 
380  if (!power_supply_am_i_supplied(&di->bat))
381  return;
382 
383  bias = (signed char) di->current_raw +
384  (signed char) di->raw[DS2760_CURRENT_OFFSET_BIAS];
385 
386  dev_dbg(di->dev, "%s: bias = %d\n", __func__, bias);
387 
391 
392  /* Write to the di->raw[] buffer directly - the CURRENT_OFFSET_BIAS
393  * value won't be read back by ds2760_battery_read_status() */
394  di->raw[DS2760_CURRENT_OFFSET_BIAS] = bias;
395 }
396 
397 static void ds2760_battery_set_charged(struct power_supply *psy)
398 {
399  struct ds2760_device_info *di = to_ds2760_device_info(psy);
400 
401  /* postpone the actual work by 20 secs. This is for debouncing GPIO
402  * signals and to let the current value settle. See AN4188. */
404 }
405 
406 static int ds2760_battery_get_property(struct power_supply *psy,
407  enum power_supply_property psp,
408  union power_supply_propval *val)
409 {
410  struct ds2760_device_info *di = to_ds2760_device_info(psy);
411 
412  switch (psp) {
414  val->intval = di->charge_status;
415  return 0;
416  default:
417  break;
418  }
419 
420  ds2760_battery_read_status(di);
421 
422  switch (psp) {
424  val->intval = di->voltage_uV;
425  break;
427  val->intval = di->current_uA;
428  break;
430  val->intval = di->rated_capacity;
431  break;
433  val->intval = di->full_active_uAh;
434  break;
436  val->intval = di->empty_uAh;
437  break;
439  val->intval = di->accum_current_uAh;
440  break;
442  val->intval = di->temp_C;
443  break;
445  val->intval = di->life_sec;
446  break;
448  val->intval = di->rem_capacity;
449  break;
450  default:
451  return -EINVAL;
452  }
453 
454  return 0;
455 }
456 
457 static int ds2760_battery_set_property(struct power_supply *psy,
458  enum power_supply_property psp,
459  const union power_supply_propval *val)
460 {
461  struct ds2760_device_info *di = to_ds2760_device_info(psy);
462 
463  switch (psp) {
465  /* the interface counts in uAh, convert the value */
466  ds2760_battery_write_active_full(di, val->intval / 1000L);
467  break;
468 
470  /* ds2760_battery_set_current_accum() does the conversion */
471  ds2760_battery_set_current_accum(di, val->intval);
472  break;
473 
474  default:
475  return -EPERM;
476  }
477 
478  return 0;
479 }
480 
481 static int ds2760_battery_property_is_writeable(struct power_supply *psy,
482  enum power_supply_property psp)
483 {
484  switch (psp) {
487  return 1;
488 
489  default:
490  break;
491  }
492 
493  return 0;
494 }
495 
496 static enum power_supply_property ds2760_battery_props[] = {
507 };
508 
509 static int ds2760_battery_probe(struct platform_device *pdev)
510 {
511  char status;
512  int retval = 0;
513  struct ds2760_device_info *di;
514 
515  di = kzalloc(sizeof(*di), GFP_KERNEL);
516  if (!di) {
517  retval = -ENOMEM;
518  goto di_alloc_failed;
519  }
520 
521  platform_set_drvdata(pdev, di);
522 
523  di->dev = &pdev->dev;
524  di->w1_dev = pdev->dev.parent;
525  di->bat.name = dev_name(&pdev->dev);
526  di->bat.type = POWER_SUPPLY_TYPE_BATTERY;
527  di->bat.properties = ds2760_battery_props;
528  di->bat.num_properties = ARRAY_SIZE(ds2760_battery_props);
529  di->bat.get_property = ds2760_battery_get_property;
530  di->bat.set_property = ds2760_battery_set_property;
531  di->bat.property_is_writeable =
532  ds2760_battery_property_is_writeable;
533  di->bat.set_charged = ds2760_battery_set_charged;
534  di->bat.external_power_changed =
535  ds2760_battery_external_power_changed;
536 
538 
539  /* enable sleep mode feature */
540  ds2760_battery_read_status(di);
541  status = di->raw[DS2760_STATUS_REG];
542  if (pmod_enabled)
543  status |= DS2760_STATUS_PMOD;
544  else
545  status &= ~DS2760_STATUS_PMOD;
546 
547  ds2760_battery_write_status(di, status);
548 
549  /* set rated capacity from module param */
550  if (rated_capacity)
551  ds2760_battery_write_rated_capacity(di, rated_capacity);
552 
553  /* set current accumulator if given as parameter.
554  * this should only be done for bootstrapping the value */
555  if (current_accum)
556  ds2760_battery_set_current_accum(di, current_accum);
557 
558  retval = power_supply_register(&pdev->dev, &di->bat);
559  if (retval) {
560  dev_err(di->dev, "failed to register battery\n");
561  goto batt_failed;
562  }
563 
564  INIT_DELAYED_WORK(&di->monitor_work, ds2760_battery_work);
566  ds2760_battery_set_charged_work);
567  di->monitor_wqueue = create_singlethread_workqueue(dev_name(&pdev->dev));
568  if (!di->monitor_wqueue) {
569  retval = -ESRCH;
570  goto workqueue_failed;
571  }
573 
574  goto success;
575 
576 workqueue_failed:
578 batt_failed:
579  kfree(di);
580 di_alloc_failed:
581 success:
582  return retval;
583 }
584 
585 static int ds2760_battery_remove(struct platform_device *pdev)
586 {
587  struct ds2760_device_info *di = platform_get_drvdata(pdev);
588 
593  kfree(di);
594 
595  return 0;
596 }
597 
598 #ifdef CONFIG_PM
599 
600 static int ds2760_battery_suspend(struct platform_device *pdev,
602 {
603  struct ds2760_device_info *di = platform_get_drvdata(pdev);
604 
606 
607  return 0;
608 }
609 
610 static int ds2760_battery_resume(struct platform_device *pdev)
611 {
612  struct ds2760_device_info *di = platform_get_drvdata(pdev);
613 
616 
618 
619  return 0;
620 }
621 
622 #else
623 
624 #define ds2760_battery_suspend NULL
625 #define ds2760_battery_resume NULL
626 
627 #endif /* CONFIG_PM */
628 
629 MODULE_ALIAS("platform:ds2760-battery");
630 
631 static struct platform_driver ds2760_battery_driver = {
632  .driver = {
633  .name = "ds2760-battery",
634  },
635  .probe = ds2760_battery_probe,
636  .remove = ds2760_battery_remove,
637  .suspend = ds2760_battery_suspend,
638  .resume = ds2760_battery_resume,
639 };
640 
641 module_platform_driver(ds2760_battery_driver);
642 
643 MODULE_LICENSE("GPL");
644 MODULE_AUTHOR("Szabolcs Gyurko <[email protected]>, "
645  "Matt Reimer <[email protected]>, "
646  "Anton Vorontsov <[email protected]>");
647 MODULE_DESCRIPTION("ds2760 battery driver");