Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
pcf50633-charger.c
Go to the documentation of this file.
1 /* NXP PCF50633 Main Battery Charger Driver
2  *
3  * (C) 2006-2008 by Openmoko, Inc.
4  * Author: Balaji Rao <[email protected]>
5  * All rights reserved.
6  *
7  * Broken down from monstrous PCF50633 driver mainly by
8  * Harald Welte, Andy Green and Werner Almesberger
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the
12  * Free Software Foundation; either version 2 of the License, or (at your
13  * option) any later version.
14  *
15  */
16 
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/slab.h>
20 #include <linux/init.h>
21 #include <linux/types.h>
22 #include <linux/device.h>
23 #include <linux/sysfs.h>
24 #include <linux/platform_device.h>
25 #include <linux/power_supply.h>
26 
28 #include <linux/mfd/pcf50633/mbc.h>
29 
30 struct pcf50633_mbc {
31  struct pcf50633 *pcf;
32 
35 
36  struct power_supply usb;
38  struct power_supply ac;
39 };
40 
41 int pcf50633_mbc_usb_curlim_set(struct pcf50633 *pcf, int ma)
42 {
43  struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
44  int ret = 0;
45  u8 bits;
46  int charging_start = 1;
47  u8 mbcs2, chgmod;
48  unsigned int mbcc5;
49 
50  if (ma >= 1000) {
52  ma = 1000;
53  } else if (ma >= 500) {
55  ma = 500;
56  } else if (ma >= 100) {
58  ma = 100;
59  } else {
61  charging_start = 0;
62  ma = 0;
63  }
64 
67  if (ret)
68  dev_err(pcf->dev, "error setting usb curlim to %d mA\n", ma);
69  else
70  dev_info(pcf->dev, "usb curlim to %d mA\n", ma);
71 
72  /*
73  * We limit the charging current to be the USB current limit.
74  * The reason is that on pcf50633, when it enters PMU Standby mode,
75  * which it does when the device goes "off", the USB current limit
76  * reverts to the variant default. In at least one common case, that
77  * default is 500mA. By setting the charging current to be the same
78  * as the USB limit we set here before PMU standby, we enforce it only
79  * using the correct amount of current even when the USB current limit
80  * gets reset to the wrong thing
81  */
82 
83  if (mbc->pcf->pdata->charger_reference_current_ma) {
84  mbcc5 = (ma << 8) / mbc->pcf->pdata->charger_reference_current_ma;
85  if (mbcc5 > 255)
86  mbcc5 = 255;
88  }
89 
91  chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);
92 
93  /* If chgmod == BATFULL, setting chgena has no effect.
94  * Datasheet says we need to set resume instead but when autoresume is
95  * used resume doesn't work. Clear and set chgena instead.
96  */
97  if (chgmod != PCF50633_MBCS2_MBC_BAT_FULL)
100  else {
105  }
106 
107  power_supply_changed(&mbc->usb);
108 
109  return ret;
110 }
112 
114 {
115  struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
116  int status = 0;
117  u8 chgmod;
118 
119  if (!mbc)
120  return 0;
121 
124 
125  if (mbc->usb_online)
126  status |= PCF50633_MBC_USB_ONLINE;
127  if (chgmod == PCF50633_MBCS2_MBC_USB_PRE ||
129  chgmod == PCF50633_MBCS2_MBC_USB_FAST ||
131  status |= PCF50633_MBC_USB_ACTIVE;
132  if (mbc->adapter_online)
133  status |= PCF50633_MBC_ADAPTER_ONLINE;
134  if (chgmod == PCF50633_MBCS2_MBC_ADP_PRE ||
136  chgmod == PCF50633_MBCS2_MBC_ADP_FAST ||
138  status |= PCF50633_MBC_ADAPTER_ACTIVE;
139 
140  return status;
141 }
143 
145 {
146  struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
147 
148  if (!mbc)
149  return 0;
150 
151  return mbc->usb_online;
152 }
154 
155 static ssize_t
156 show_chgmode(struct device *dev, struct device_attribute *attr, char *buf)
157 {
158  struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
159 
161  u8 chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);
162 
163  return sprintf(buf, "%d\n", chgmod);
164 }
165 static DEVICE_ATTR(chgmode, S_IRUGO, show_chgmode, NULL);
166 
167 static ssize_t
168 show_usblim(struct device *dev, struct device_attribute *attr, char *buf)
169 {
170  struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
171  u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
173  unsigned int ma;
174 
175  if (usblim == PCF50633_MBCC7_USB_1000mA)
176  ma = 1000;
177  else if (usblim == PCF50633_MBCC7_USB_500mA)
178  ma = 500;
179  else if (usblim == PCF50633_MBCC7_USB_100mA)
180  ma = 100;
181  else
182  ma = 0;
183 
184  return sprintf(buf, "%u\n", ma);
185 }
186 
187 static ssize_t set_usblim(struct device *dev,
188  struct device_attribute *attr, const char *buf, size_t count)
189 {
190  struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
191  unsigned long ma;
192  int ret;
193 
194  ret = strict_strtoul(buf, 10, &ma);
195  if (ret)
196  return -EINVAL;
197 
199 
200  return count;
201 }
202 
203 static DEVICE_ATTR(usb_curlim, S_IRUGO | S_IWUSR, show_usblim, set_usblim);
204 
205 static ssize_t
206 show_chglim(struct device *dev, struct device_attribute *attr, char *buf)
207 {
208  struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
210  unsigned int ma;
211 
212  if (!mbc->pcf->pdata->charger_reference_current_ma)
213  return -ENODEV;
214 
215  ma = (mbc->pcf->pdata->charger_reference_current_ma * mbcc5) >> 8;
216 
217  return sprintf(buf, "%u\n", ma);
218 }
219 
220 static ssize_t set_chglim(struct device *dev,
221  struct device_attribute *attr, const char *buf, size_t count)
222 {
223  struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
224  unsigned long ma;
225  unsigned int mbcc5;
226  int ret;
227 
228  if (!mbc->pcf->pdata->charger_reference_current_ma)
229  return -ENODEV;
230 
231  ret = strict_strtoul(buf, 10, &ma);
232  if (ret)
233  return -EINVAL;
234 
235  mbcc5 = (ma << 8) / mbc->pcf->pdata->charger_reference_current_ma;
236  if (mbcc5 > 255)
237  mbcc5 = 255;
239 
240  return count;
241 }
242 
243 /*
244  * This attribute allows to change MBC charging limit on the fly
245  * independently of usb current limit. It also gets set automatically every
246  * time usb current limit is changed.
247  */
248 static DEVICE_ATTR(chg_curlim, S_IRUGO | S_IWUSR, show_chglim, set_chglim);
249 
250 static struct attribute *pcf50633_mbc_sysfs_entries[] = {
251  &dev_attr_chgmode.attr,
252  &dev_attr_usb_curlim.attr,
253  &dev_attr_chg_curlim.attr,
254  NULL,
255 };
256 
257 static struct attribute_group mbc_attr_group = {
258  .name = NULL, /* put in device directory */
259  .attrs = pcf50633_mbc_sysfs_entries,
260 };
261 
262 static void
263 pcf50633_mbc_irq_handler(int irq, void *data)
264 {
265  struct pcf50633_mbc *mbc = data;
266 
267  /* USB */
268  if (irq == PCF50633_IRQ_USBINS) {
269  mbc->usb_online = 1;
270  } else if (irq == PCF50633_IRQ_USBREM) {
271  mbc->usb_online = 0;
273  }
274 
275  /* Adapter */
276  if (irq == PCF50633_IRQ_ADPINS)
277  mbc->adapter_online = 1;
278  else if (irq == PCF50633_IRQ_ADPREM)
279  mbc->adapter_online = 0;
280 
281  power_supply_changed(&mbc->ac);
282  power_supply_changed(&mbc->usb);
284 
285  if (mbc->pcf->pdata->mbc_event_callback)
286  mbc->pcf->pdata->mbc_event_callback(mbc->pcf, irq);
287 }
288 
289 static int adapter_get_property(struct power_supply *psy,
290  enum power_supply_property psp,
291  union power_supply_propval *val)
292 {
293  struct pcf50633_mbc *mbc = container_of(psy,
294  struct pcf50633_mbc, adapter);
295  int ret = 0;
296 
297  switch (psp) {
299  val->intval = mbc->adapter_online;
300  break;
301  default:
302  ret = -EINVAL;
303  break;
304  }
305  return ret;
306 }
307 
308 static int usb_get_property(struct power_supply *psy,
309  enum power_supply_property psp,
310  union power_supply_propval *val)
311 {
312  struct pcf50633_mbc *mbc = container_of(psy, struct pcf50633_mbc, usb);
313  int ret = 0;
314  u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
316 
317  switch (psp) {
319  val->intval = mbc->usb_online &&
320  (usblim <= PCF50633_MBCC7_USB_500mA);
321  break;
322  default:
323  ret = -EINVAL;
324  break;
325  }
326  return ret;
327 }
328 
329 static int ac_get_property(struct power_supply *psy,
330  enum power_supply_property psp,
331  union power_supply_propval *val)
332 {
333  struct pcf50633_mbc *mbc = container_of(psy, struct pcf50633_mbc, ac);
334  int ret = 0;
335  u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
337 
338  switch (psp) {
340  val->intval = mbc->usb_online &&
341  (usblim == PCF50633_MBCC7_USB_1000mA);
342  break;
343  default:
344  ret = -EINVAL;
345  break;
346  }
347  return ret;
348 }
349 
350 static enum power_supply_property power_props[] = {
352 };
353 
354 static const u8 mbc_irq_handlers[] = {
367 };
368 
369 static int __devinit pcf50633_mbc_probe(struct platform_device *pdev)
370 {
371  struct pcf50633_mbc *mbc;
372  int ret;
373  int i;
374  u8 mbcs1;
375 
376  mbc = kzalloc(sizeof(*mbc), GFP_KERNEL);
377  if (!mbc)
378  return -ENOMEM;
379 
380  platform_set_drvdata(pdev, mbc);
381  mbc->pcf = dev_to_pcf50633(pdev->dev.parent);
382 
383  /* Set up IRQ handlers */
384  for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++)
385  pcf50633_register_irq(mbc->pcf, mbc_irq_handlers[i],
386  pcf50633_mbc_irq_handler, mbc);
387 
388  /* Create power supplies */
389  mbc->adapter.name = "adapter";
390  mbc->adapter.type = POWER_SUPPLY_TYPE_MAINS;
391  mbc->adapter.properties = power_props;
392  mbc->adapter.num_properties = ARRAY_SIZE(power_props);
393  mbc->adapter.get_property = &adapter_get_property;
394  mbc->adapter.supplied_to = mbc->pcf->pdata->batteries;
395  mbc->adapter.num_supplicants = mbc->pcf->pdata->num_batteries;
396 
397  mbc->usb.name = "usb";
398  mbc->usb.type = POWER_SUPPLY_TYPE_USB;
399  mbc->usb.properties = power_props;
400  mbc->usb.num_properties = ARRAY_SIZE(power_props);
401  mbc->usb.get_property = usb_get_property;
402  mbc->usb.supplied_to = mbc->pcf->pdata->batteries;
403  mbc->usb.num_supplicants = mbc->pcf->pdata->num_batteries;
404 
405  mbc->ac.name = "ac";
406  mbc->ac.type = POWER_SUPPLY_TYPE_MAINS;
407  mbc->ac.properties = power_props;
408  mbc->ac.num_properties = ARRAY_SIZE(power_props);
409  mbc->ac.get_property = ac_get_property;
410  mbc->ac.supplied_to = mbc->pcf->pdata->batteries;
411  mbc->ac.num_supplicants = mbc->pcf->pdata->num_batteries;
412 
413  ret = power_supply_register(&pdev->dev, &mbc->adapter);
414  if (ret) {
415  dev_err(mbc->pcf->dev, "failed to register adapter\n");
416  kfree(mbc);
417  return ret;
418  }
419 
420  ret = power_supply_register(&pdev->dev, &mbc->usb);
421  if (ret) {
422  dev_err(mbc->pcf->dev, "failed to register usb\n");
424  kfree(mbc);
425  return ret;
426  }
427 
428  ret = power_supply_register(&pdev->dev, &mbc->ac);
429  if (ret) {
430  dev_err(mbc->pcf->dev, "failed to register ac\n");
433  kfree(mbc);
434  return ret;
435  }
436 
437  ret = sysfs_create_group(&pdev->dev.kobj, &mbc_attr_group);
438  if (ret)
439  dev_err(mbc->pcf->dev, "failed to create sysfs entries\n");
440 
442  if (mbcs1 & PCF50633_MBCS1_USBPRES)
443  pcf50633_mbc_irq_handler(PCF50633_IRQ_USBINS, mbc);
444  if (mbcs1 & PCF50633_MBCS1_ADAPTPRES)
445  pcf50633_mbc_irq_handler(PCF50633_IRQ_ADPINS, mbc);
446 
447  return 0;
448 }
449 
450 static int __devexit pcf50633_mbc_remove(struct platform_device *pdev)
451 {
452  struct pcf50633_mbc *mbc = platform_get_drvdata(pdev);
453  int i;
454 
455  /* Remove IRQ handlers */
456  for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++)
457  pcf50633_free_irq(mbc->pcf, mbc_irq_handlers[i]);
458 
459  sysfs_remove_group(&pdev->dev.kobj, &mbc_attr_group);
463 
464  kfree(mbc);
465 
466  return 0;
467 }
468 
469 static struct platform_driver pcf50633_mbc_driver = {
470  .driver = {
471  .name = "pcf50633-mbc",
472  },
473  .probe = pcf50633_mbc_probe,
474  .remove = __devexit_p(pcf50633_mbc_remove),
475 };
476 
477 module_platform_driver(pcf50633_mbc_driver);
478 
479 MODULE_AUTHOR("Balaji Rao <[email protected]>");
480 MODULE_DESCRIPTION("PCF50633 mbc driver");
481 MODULE_LICENSE("GPL");
482 MODULE_ALIAS("platform:pcf50633-mbc");