pcf50633-charger.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /* NXP PCF50633 Main Battery Charger Driver
  3. *
  4. * (C) 2006-2008 by Openmoko, Inc.
  5. * Author: Balaji Rao <balajirrao@openmoko.org>
  6. * All rights reserved.
  7. *
  8. * Broken down from monstrous PCF50633 driver mainly by
  9. * Harald Welte, Andy Green and Werner Almesberger
  10. */
  11. #include <linux/kernel.h>
  12. #include <linux/module.h>
  13. #include <linux/slab.h>
  14. #include <linux/init.h>
  15. #include <linux/types.h>
  16. #include <linux/device.h>
  17. #include <linux/sysfs.h>
  18. #include <linux/platform_device.h>
  19. #include <linux/power_supply.h>
  20. #include <linux/mfd/pcf50633/core.h>
  21. #include <linux/mfd/pcf50633/mbc.h>
  22. struct pcf50633_mbc {
  23. struct pcf50633 *pcf;
  24. int adapter_online;
  25. int usb_online;
  26. struct power_supply *usb;
  27. struct power_supply *adapter;
  28. struct power_supply *ac;
  29. };
  30. int pcf50633_mbc_usb_curlim_set(struct pcf50633 *pcf, int ma)
  31. {
  32. struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
  33. int ret = 0;
  34. u8 bits;
  35. u8 mbcs2, chgmod;
  36. unsigned int mbcc5;
  37. if (ma >= 1000) {
  38. bits = PCF50633_MBCC7_USB_1000mA;
  39. ma = 1000;
  40. } else if (ma >= 500) {
  41. bits = PCF50633_MBCC7_USB_500mA;
  42. ma = 500;
  43. } else if (ma >= 100) {
  44. bits = PCF50633_MBCC7_USB_100mA;
  45. ma = 100;
  46. } else {
  47. bits = PCF50633_MBCC7_USB_SUSPEND;
  48. ma = 0;
  49. }
  50. ret = pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC7,
  51. PCF50633_MBCC7_USB_MASK, bits);
  52. if (ret)
  53. dev_err(pcf->dev, "error setting usb curlim to %d mA\n", ma);
  54. else
  55. dev_info(pcf->dev, "usb curlim to %d mA\n", ma);
  56. /*
  57. * We limit the charging current to be the USB current limit.
  58. * The reason is that on pcf50633, when it enters PMU Standby mode,
  59. * which it does when the device goes "off", the USB current limit
  60. * reverts to the variant default. In at least one common case, that
  61. * default is 500mA. By setting the charging current to be the same
  62. * as the USB limit we set here before PMU standby, we enforce it only
  63. * using the correct amount of current even when the USB current limit
  64. * gets reset to the wrong thing
  65. */
  66. if (mbc->pcf->pdata->charger_reference_current_ma) {
  67. mbcc5 = (ma << 8) / mbc->pcf->pdata->charger_reference_current_ma;
  68. if (mbcc5 > 255)
  69. mbcc5 = 255;
  70. pcf50633_reg_write(mbc->pcf, PCF50633_REG_MBCC5, mbcc5);
  71. }
  72. mbcs2 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS2);
  73. chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);
  74. /* If chgmod == BATFULL, setting chgena has no effect.
  75. * Datasheet says we need to set resume instead but when autoresume is
  76. * used resume doesn't work. Clear and set chgena instead.
  77. */
  78. if (chgmod != PCF50633_MBCS2_MBC_BAT_FULL)
  79. pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC1,
  80. PCF50633_MBCC1_CHGENA, PCF50633_MBCC1_CHGENA);
  81. else {
  82. pcf50633_reg_clear_bits(pcf, PCF50633_REG_MBCC1,
  83. PCF50633_MBCC1_CHGENA);
  84. pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC1,
  85. PCF50633_MBCC1_CHGENA, PCF50633_MBCC1_CHGENA);
  86. }
  87. power_supply_changed(mbc->usb);
  88. return ret;
  89. }
  90. EXPORT_SYMBOL_GPL(pcf50633_mbc_usb_curlim_set);
  91. int pcf50633_mbc_get_status(struct pcf50633 *pcf)
  92. {
  93. struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
  94. int status = 0;
  95. u8 chgmod;
  96. if (!mbc)
  97. return 0;
  98. chgmod = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS2)
  99. & PCF50633_MBCS2_MBC_MASK;
  100. if (mbc->usb_online)
  101. status |= PCF50633_MBC_USB_ONLINE;
  102. if (chgmod == PCF50633_MBCS2_MBC_USB_PRE ||
  103. chgmod == PCF50633_MBCS2_MBC_USB_PRE_WAIT ||
  104. chgmod == PCF50633_MBCS2_MBC_USB_FAST ||
  105. chgmod == PCF50633_MBCS2_MBC_USB_FAST_WAIT)
  106. status |= PCF50633_MBC_USB_ACTIVE;
  107. if (mbc->adapter_online)
  108. status |= PCF50633_MBC_ADAPTER_ONLINE;
  109. if (chgmod == PCF50633_MBCS2_MBC_ADP_PRE ||
  110. chgmod == PCF50633_MBCS2_MBC_ADP_PRE_WAIT ||
  111. chgmod == PCF50633_MBCS2_MBC_ADP_FAST ||
  112. chgmod == PCF50633_MBCS2_MBC_ADP_FAST_WAIT)
  113. status |= PCF50633_MBC_ADAPTER_ACTIVE;
  114. return status;
  115. }
  116. EXPORT_SYMBOL_GPL(pcf50633_mbc_get_status);
  117. int pcf50633_mbc_get_usb_online_status(struct pcf50633 *pcf)
  118. {
  119. struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
  120. if (!mbc)
  121. return 0;
  122. return mbc->usb_online;
  123. }
  124. EXPORT_SYMBOL_GPL(pcf50633_mbc_get_usb_online_status);
  125. static ssize_t
  126. show_chgmode(struct device *dev, struct device_attribute *attr, char *buf)
  127. {
  128. struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
  129. u8 mbcs2 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS2);
  130. u8 chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);
  131. return sprintf(buf, "%d\n", chgmod);
  132. }
  133. static DEVICE_ATTR(chgmode, S_IRUGO, show_chgmode, NULL);
  134. static ssize_t
  135. show_usblim(struct device *dev, struct device_attribute *attr, char *buf)
  136. {
  137. struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
  138. u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
  139. PCF50633_MBCC7_USB_MASK;
  140. unsigned int ma;
  141. if (usblim == PCF50633_MBCC7_USB_1000mA)
  142. ma = 1000;
  143. else if (usblim == PCF50633_MBCC7_USB_500mA)
  144. ma = 500;
  145. else if (usblim == PCF50633_MBCC7_USB_100mA)
  146. ma = 100;
  147. else
  148. ma = 0;
  149. return sprintf(buf, "%u\n", ma);
  150. }
  151. static ssize_t set_usblim(struct device *dev,
  152. struct device_attribute *attr, const char *buf, size_t count)
  153. {
  154. struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
  155. unsigned long ma;
  156. int ret;
  157. ret = kstrtoul(buf, 10, &ma);
  158. if (ret)
  159. return ret;
  160. pcf50633_mbc_usb_curlim_set(mbc->pcf, ma);
  161. return count;
  162. }
  163. static DEVICE_ATTR(usb_curlim, S_IRUGO | S_IWUSR, show_usblim, set_usblim);
  164. static ssize_t
  165. show_chglim(struct device *dev, struct device_attribute *attr, char *buf)
  166. {
  167. struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
  168. u8 mbcc5 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC5);
  169. unsigned int ma;
  170. if (!mbc->pcf->pdata->charger_reference_current_ma)
  171. return -ENODEV;
  172. ma = (mbc->pcf->pdata->charger_reference_current_ma * mbcc5) >> 8;
  173. return sprintf(buf, "%u\n", ma);
  174. }
  175. static ssize_t set_chglim(struct device *dev,
  176. struct device_attribute *attr, const char *buf, size_t count)
  177. {
  178. struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
  179. unsigned long ma;
  180. unsigned int mbcc5;
  181. int ret;
  182. if (!mbc->pcf->pdata->charger_reference_current_ma)
  183. return -ENODEV;
  184. ret = kstrtoul(buf, 10, &ma);
  185. if (ret)
  186. return ret;
  187. mbcc5 = (ma << 8) / mbc->pcf->pdata->charger_reference_current_ma;
  188. if (mbcc5 > 255)
  189. mbcc5 = 255;
  190. pcf50633_reg_write(mbc->pcf, PCF50633_REG_MBCC5, mbcc5);
  191. return count;
  192. }
  193. /*
  194. * This attribute allows to change MBC charging limit on the fly
  195. * independently of usb current limit. It also gets set automatically every
  196. * time usb current limit is changed.
  197. */
  198. static DEVICE_ATTR(chg_curlim, S_IRUGO | S_IWUSR, show_chglim, set_chglim);
  199. static struct attribute *pcf50633_mbc_sysfs_attrs[] = {
  200. &dev_attr_chgmode.attr,
  201. &dev_attr_usb_curlim.attr,
  202. &dev_attr_chg_curlim.attr,
  203. NULL,
  204. };
  205. ATTRIBUTE_GROUPS(pcf50633_mbc_sysfs);
  206. static void
  207. pcf50633_mbc_irq_handler(int irq, void *data)
  208. {
  209. struct pcf50633_mbc *mbc = data;
  210. /* USB */
  211. if (irq == PCF50633_IRQ_USBINS) {
  212. mbc->usb_online = 1;
  213. } else if (irq == PCF50633_IRQ_USBREM) {
  214. mbc->usb_online = 0;
  215. pcf50633_mbc_usb_curlim_set(mbc->pcf, 0);
  216. }
  217. /* Adapter */
  218. if (irq == PCF50633_IRQ_ADPINS)
  219. mbc->adapter_online = 1;
  220. else if (irq == PCF50633_IRQ_ADPREM)
  221. mbc->adapter_online = 0;
  222. power_supply_changed(mbc->ac);
  223. power_supply_changed(mbc->usb);
  224. power_supply_changed(mbc->adapter);
  225. if (mbc->pcf->pdata->mbc_event_callback)
  226. mbc->pcf->pdata->mbc_event_callback(mbc->pcf, irq);
  227. }
  228. static int adapter_get_property(struct power_supply *psy,
  229. enum power_supply_property psp,
  230. union power_supply_propval *val)
  231. {
  232. struct pcf50633_mbc *mbc = power_supply_get_drvdata(psy);
  233. int ret = 0;
  234. switch (psp) {
  235. case POWER_SUPPLY_PROP_ONLINE:
  236. val->intval = mbc->adapter_online;
  237. break;
  238. default:
  239. ret = -EINVAL;
  240. break;
  241. }
  242. return ret;
  243. }
  244. static int usb_get_property(struct power_supply *psy,
  245. enum power_supply_property psp,
  246. union power_supply_propval *val)
  247. {
  248. struct pcf50633_mbc *mbc = power_supply_get_drvdata(psy);
  249. int ret = 0;
  250. u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
  251. PCF50633_MBCC7_USB_MASK;
  252. switch (psp) {
  253. case POWER_SUPPLY_PROP_ONLINE:
  254. val->intval = mbc->usb_online &&
  255. (usblim <= PCF50633_MBCC7_USB_500mA);
  256. break;
  257. default:
  258. ret = -EINVAL;
  259. break;
  260. }
  261. return ret;
  262. }
  263. static int ac_get_property(struct power_supply *psy,
  264. enum power_supply_property psp,
  265. union power_supply_propval *val)
  266. {
  267. struct pcf50633_mbc *mbc = power_supply_get_drvdata(psy);
  268. int ret = 0;
  269. u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
  270. PCF50633_MBCC7_USB_MASK;
  271. switch (psp) {
  272. case POWER_SUPPLY_PROP_ONLINE:
  273. val->intval = mbc->usb_online &&
  274. (usblim == PCF50633_MBCC7_USB_1000mA);
  275. break;
  276. default:
  277. ret = -EINVAL;
  278. break;
  279. }
  280. return ret;
  281. }
  282. static enum power_supply_property power_props[] = {
  283. POWER_SUPPLY_PROP_ONLINE,
  284. };
  285. static const u8 mbc_irq_handlers[] = {
  286. PCF50633_IRQ_ADPINS,
  287. PCF50633_IRQ_ADPREM,
  288. PCF50633_IRQ_USBINS,
  289. PCF50633_IRQ_USBREM,
  290. PCF50633_IRQ_BATFULL,
  291. PCF50633_IRQ_CHGHALT,
  292. PCF50633_IRQ_THLIMON,
  293. PCF50633_IRQ_THLIMOFF,
  294. PCF50633_IRQ_USBLIMON,
  295. PCF50633_IRQ_USBLIMOFF,
  296. PCF50633_IRQ_LOWSYS,
  297. PCF50633_IRQ_LOWBAT,
  298. };
  299. static const struct power_supply_desc pcf50633_mbc_adapter_desc = {
  300. .name = "adapter",
  301. .type = POWER_SUPPLY_TYPE_MAINS,
  302. .properties = power_props,
  303. .num_properties = ARRAY_SIZE(power_props),
  304. .get_property = &adapter_get_property,
  305. };
  306. static const struct power_supply_desc pcf50633_mbc_usb_desc = {
  307. .name = "usb",
  308. .type = POWER_SUPPLY_TYPE_USB,
  309. .properties = power_props,
  310. .num_properties = ARRAY_SIZE(power_props),
  311. .get_property = usb_get_property,
  312. };
  313. static const struct power_supply_desc pcf50633_mbc_ac_desc = {
  314. .name = "ac",
  315. .type = POWER_SUPPLY_TYPE_MAINS,
  316. .properties = power_props,
  317. .num_properties = ARRAY_SIZE(power_props),
  318. .get_property = ac_get_property,
  319. };
  320. static int pcf50633_mbc_probe(struct platform_device *pdev)
  321. {
  322. struct power_supply_config psy_cfg = {};
  323. struct power_supply_config usb_psy_cfg;
  324. struct pcf50633_mbc *mbc;
  325. int i;
  326. u8 mbcs1;
  327. mbc = devm_kzalloc(&pdev->dev, sizeof(*mbc), GFP_KERNEL);
  328. if (!mbc)
  329. return -ENOMEM;
  330. platform_set_drvdata(pdev, mbc);
  331. mbc->pcf = dev_to_pcf50633(pdev->dev.parent);
  332. /* Set up IRQ handlers */
  333. for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++)
  334. pcf50633_register_irq(mbc->pcf, mbc_irq_handlers[i],
  335. pcf50633_mbc_irq_handler, mbc);
  336. psy_cfg.supplied_to = mbc->pcf->pdata->batteries;
  337. psy_cfg.num_supplicants = mbc->pcf->pdata->num_batteries;
  338. psy_cfg.drv_data = mbc;
  339. /* Create power supplies */
  340. mbc->adapter = power_supply_register(&pdev->dev,
  341. &pcf50633_mbc_adapter_desc,
  342. &psy_cfg);
  343. if (IS_ERR(mbc->adapter)) {
  344. dev_err(mbc->pcf->dev, "failed to register adapter\n");
  345. return PTR_ERR(mbc->adapter);
  346. }
  347. usb_psy_cfg = psy_cfg;
  348. usb_psy_cfg.attr_grp = pcf50633_mbc_sysfs_groups;
  349. mbc->usb = power_supply_register(&pdev->dev, &pcf50633_mbc_usb_desc,
  350. &usb_psy_cfg);
  351. if (IS_ERR(mbc->usb)) {
  352. dev_err(mbc->pcf->dev, "failed to register usb\n");
  353. power_supply_unregister(mbc->adapter);
  354. return PTR_ERR(mbc->usb);
  355. }
  356. mbc->ac = power_supply_register(&pdev->dev, &pcf50633_mbc_ac_desc,
  357. &psy_cfg);
  358. if (IS_ERR(mbc->ac)) {
  359. dev_err(mbc->pcf->dev, "failed to register ac\n");
  360. power_supply_unregister(mbc->adapter);
  361. power_supply_unregister(mbc->usb);
  362. return PTR_ERR(mbc->ac);
  363. }
  364. mbcs1 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS1);
  365. if (mbcs1 & PCF50633_MBCS1_USBPRES)
  366. pcf50633_mbc_irq_handler(PCF50633_IRQ_USBINS, mbc);
  367. if (mbcs1 & PCF50633_MBCS1_ADAPTPRES)
  368. pcf50633_mbc_irq_handler(PCF50633_IRQ_ADPINS, mbc);
  369. return 0;
  370. }
  371. static int pcf50633_mbc_remove(struct platform_device *pdev)
  372. {
  373. struct pcf50633_mbc *mbc = platform_get_drvdata(pdev);
  374. int i;
  375. /* Remove IRQ handlers */
  376. for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++)
  377. pcf50633_free_irq(mbc->pcf, mbc_irq_handlers[i]);
  378. power_supply_unregister(mbc->usb);
  379. power_supply_unregister(mbc->adapter);
  380. power_supply_unregister(mbc->ac);
  381. return 0;
  382. }
  383. static struct platform_driver pcf50633_mbc_driver = {
  384. .driver = {
  385. .name = "pcf50633-mbc",
  386. },
  387. .probe = pcf50633_mbc_probe,
  388. .remove = pcf50633_mbc_remove,
  389. };
  390. module_platform_driver(pcf50633_mbc_driver);
  391. MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
  392. MODULE_DESCRIPTION("PCF50633 mbc driver");
  393. MODULE_LICENSE("GPL");
  394. MODULE_ALIAS("platform:pcf50633-mbc");