max8903_charger.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * max8903_charger.c - Maxim 8903 USB/Adapter Charger Driver
  4. *
  5. * Copyright (C) 2011 Samsung Electronics
  6. * MyungJoo Ham <myungjoo.ham@samsung.com>
  7. */
  8. #include <linux/gpio.h>
  9. #include <linux/interrupt.h>
  10. #include <linux/module.h>
  11. #include <linux/of.h>
  12. #include <linux/of_device.h>
  13. #include <linux/of_gpio.h>
  14. #include <linux/slab.h>
  15. #include <linux/power_supply.h>
  16. #include <linux/platform_device.h>
  17. #include <linux/power/max8903_charger.h>
  18. struct max8903_data {
  19. struct max8903_pdata *pdata;
  20. struct device *dev;
  21. struct power_supply *psy;
  22. struct power_supply_desc psy_desc;
  23. bool fault;
  24. bool usb_in;
  25. bool ta_in;
  26. };
  27. static enum power_supply_property max8903_charger_props[] = {
  28. POWER_SUPPLY_PROP_STATUS, /* Charger status output */
  29. POWER_SUPPLY_PROP_ONLINE, /* External power source */
  30. POWER_SUPPLY_PROP_HEALTH, /* Fault or OK */
  31. };
  32. static int max8903_get_property(struct power_supply *psy,
  33. enum power_supply_property psp,
  34. union power_supply_propval *val)
  35. {
  36. struct max8903_data *data = power_supply_get_drvdata(psy);
  37. switch (psp) {
  38. case POWER_SUPPLY_PROP_STATUS:
  39. val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
  40. if (gpio_is_valid(data->pdata->chg)) {
  41. if (gpio_get_value(data->pdata->chg) == 0)
  42. val->intval = POWER_SUPPLY_STATUS_CHARGING;
  43. else if (data->usb_in || data->ta_in)
  44. val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
  45. else
  46. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  47. }
  48. break;
  49. case POWER_SUPPLY_PROP_ONLINE:
  50. val->intval = 0;
  51. if (data->usb_in || data->ta_in)
  52. val->intval = 1;
  53. break;
  54. case POWER_SUPPLY_PROP_HEALTH:
  55. val->intval = POWER_SUPPLY_HEALTH_GOOD;
  56. if (data->fault)
  57. val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
  58. break;
  59. default:
  60. return -EINVAL;
  61. }
  62. return 0;
  63. }
  64. static irqreturn_t max8903_dcin(int irq, void *_data)
  65. {
  66. struct max8903_data *data = _data;
  67. struct max8903_pdata *pdata = data->pdata;
  68. bool ta_in;
  69. enum power_supply_type old_type;
  70. ta_in = gpio_get_value(pdata->dok) ? false : true;
  71. if (ta_in == data->ta_in)
  72. return IRQ_HANDLED;
  73. data->ta_in = ta_in;
  74. /* Set Current-Limit-Mode 1:DC 0:USB */
  75. if (gpio_is_valid(pdata->dcm))
  76. gpio_set_value(pdata->dcm, ta_in ? 1 : 0);
  77. /* Charger Enable / Disable (cen is negated) */
  78. if (gpio_is_valid(pdata->cen))
  79. gpio_set_value(pdata->cen, ta_in ? 0 :
  80. (data->usb_in ? 0 : 1));
  81. dev_dbg(data->dev, "TA(DC-IN) Charger %s.\n", ta_in ?
  82. "Connected" : "Disconnected");
  83. old_type = data->psy_desc.type;
  84. if (data->ta_in)
  85. data->psy_desc.type = POWER_SUPPLY_TYPE_MAINS;
  86. else if (data->usb_in)
  87. data->psy_desc.type = POWER_SUPPLY_TYPE_USB;
  88. else
  89. data->psy_desc.type = POWER_SUPPLY_TYPE_BATTERY;
  90. if (old_type != data->psy_desc.type)
  91. power_supply_changed(data->psy);
  92. return IRQ_HANDLED;
  93. }
  94. static irqreturn_t max8903_usbin(int irq, void *_data)
  95. {
  96. struct max8903_data *data = _data;
  97. struct max8903_pdata *pdata = data->pdata;
  98. bool usb_in;
  99. enum power_supply_type old_type;
  100. usb_in = gpio_get_value(pdata->uok) ? false : true;
  101. if (usb_in == data->usb_in)
  102. return IRQ_HANDLED;
  103. data->usb_in = usb_in;
  104. /* Do not touch Current-Limit-Mode */
  105. /* Charger Enable / Disable (cen is negated) */
  106. if (gpio_is_valid(pdata->cen))
  107. gpio_set_value(pdata->cen, usb_in ? 0 :
  108. (data->ta_in ? 0 : 1));
  109. dev_dbg(data->dev, "USB Charger %s.\n", usb_in ?
  110. "Connected" : "Disconnected");
  111. old_type = data->psy_desc.type;
  112. if (data->ta_in)
  113. data->psy_desc.type = POWER_SUPPLY_TYPE_MAINS;
  114. else if (data->usb_in)
  115. data->psy_desc.type = POWER_SUPPLY_TYPE_USB;
  116. else
  117. data->psy_desc.type = POWER_SUPPLY_TYPE_BATTERY;
  118. if (old_type != data->psy_desc.type)
  119. power_supply_changed(data->psy);
  120. return IRQ_HANDLED;
  121. }
  122. static irqreturn_t max8903_fault(int irq, void *_data)
  123. {
  124. struct max8903_data *data = _data;
  125. struct max8903_pdata *pdata = data->pdata;
  126. bool fault;
  127. fault = gpio_get_value(pdata->flt) ? false : true;
  128. if (fault == data->fault)
  129. return IRQ_HANDLED;
  130. data->fault = fault;
  131. if (fault)
  132. dev_err(data->dev, "Charger suffers a fault and stops.\n");
  133. else
  134. dev_err(data->dev, "Charger recovered from a fault.\n");
  135. return IRQ_HANDLED;
  136. }
  137. static struct max8903_pdata *max8903_parse_dt_data(struct device *dev)
  138. {
  139. struct device_node *np = dev->of_node;
  140. struct max8903_pdata *pdata = NULL;
  141. if (!np)
  142. return NULL;
  143. pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
  144. if (!pdata)
  145. return NULL;
  146. pdata->dc_valid = false;
  147. pdata->usb_valid = false;
  148. pdata->cen = of_get_named_gpio(np, "cen-gpios", 0);
  149. if (!gpio_is_valid(pdata->cen))
  150. pdata->cen = -EINVAL;
  151. pdata->chg = of_get_named_gpio(np, "chg-gpios", 0);
  152. if (!gpio_is_valid(pdata->chg))
  153. pdata->chg = -EINVAL;
  154. pdata->flt = of_get_named_gpio(np, "flt-gpios", 0);
  155. if (!gpio_is_valid(pdata->flt))
  156. pdata->flt = -EINVAL;
  157. pdata->usus = of_get_named_gpio(np, "usus-gpios", 0);
  158. if (!gpio_is_valid(pdata->usus))
  159. pdata->usus = -EINVAL;
  160. pdata->dcm = of_get_named_gpio(np, "dcm-gpios", 0);
  161. if (!gpio_is_valid(pdata->dcm))
  162. pdata->dcm = -EINVAL;
  163. pdata->dok = of_get_named_gpio(np, "dok-gpios", 0);
  164. if (!gpio_is_valid(pdata->dok))
  165. pdata->dok = -EINVAL;
  166. else
  167. pdata->dc_valid = true;
  168. pdata->uok = of_get_named_gpio(np, "uok-gpios", 0);
  169. if (!gpio_is_valid(pdata->uok))
  170. pdata->uok = -EINVAL;
  171. else
  172. pdata->usb_valid = true;
  173. return pdata;
  174. }
  175. static int max8903_setup_gpios(struct platform_device *pdev)
  176. {
  177. struct max8903_data *data = platform_get_drvdata(pdev);
  178. struct device *dev = &pdev->dev;
  179. struct max8903_pdata *pdata = pdev->dev.platform_data;
  180. int ret = 0;
  181. int gpio;
  182. int ta_in = 0;
  183. int usb_in = 0;
  184. if (pdata->dc_valid) {
  185. if (gpio_is_valid(pdata->dok)) {
  186. ret = devm_gpio_request(dev, pdata->dok,
  187. data->psy_desc.name);
  188. if (ret) {
  189. dev_err(dev,
  190. "Failed GPIO request for dok: %d err %d\n",
  191. pdata->dok, ret);
  192. return ret;
  193. }
  194. gpio = pdata->dok; /* PULL_UPed Interrupt */
  195. ta_in = gpio_get_value(gpio) ? 0 : 1;
  196. } else {
  197. dev_err(dev, "When DC is wired, DOK should be wired as well.\n");
  198. return -EINVAL;
  199. }
  200. }
  201. if (gpio_is_valid(pdata->dcm)) {
  202. ret = devm_gpio_request(dev, pdata->dcm, data->psy_desc.name);
  203. if (ret) {
  204. dev_err(dev,
  205. "Failed GPIO request for dcm: %d err %d\n",
  206. pdata->dcm, ret);
  207. return ret;
  208. }
  209. gpio = pdata->dcm; /* Output */
  210. gpio_set_value(gpio, ta_in);
  211. }
  212. if (pdata->usb_valid) {
  213. if (gpio_is_valid(pdata->uok)) {
  214. ret = devm_gpio_request(dev, pdata->uok,
  215. data->psy_desc.name);
  216. if (ret) {
  217. dev_err(dev,
  218. "Failed GPIO request for uok: %d err %d\n",
  219. pdata->uok, ret);
  220. return ret;
  221. }
  222. gpio = pdata->uok;
  223. usb_in = gpio_get_value(gpio) ? 0 : 1;
  224. } else {
  225. dev_err(dev, "When USB is wired, UOK should be wired."
  226. "as well.\n");
  227. return -EINVAL;
  228. }
  229. }
  230. if (gpio_is_valid(pdata->cen)) {
  231. ret = devm_gpio_request(dev, pdata->cen, data->psy_desc.name);
  232. if (ret) {
  233. dev_err(dev,
  234. "Failed GPIO request for cen: %d err %d\n",
  235. pdata->cen, ret);
  236. return ret;
  237. }
  238. gpio_set_value(pdata->cen, (ta_in || usb_in) ? 0 : 1);
  239. }
  240. if (gpio_is_valid(pdata->chg)) {
  241. ret = devm_gpio_request(dev, pdata->chg, data->psy_desc.name);
  242. if (ret) {
  243. dev_err(dev,
  244. "Failed GPIO request for chg: %d err %d\n",
  245. pdata->chg, ret);
  246. return ret;
  247. }
  248. }
  249. if (gpio_is_valid(pdata->flt)) {
  250. ret = devm_gpio_request(dev, pdata->flt, data->psy_desc.name);
  251. if (ret) {
  252. dev_err(dev,
  253. "Failed GPIO request for flt: %d err %d\n",
  254. pdata->flt, ret);
  255. return ret;
  256. }
  257. }
  258. if (gpio_is_valid(pdata->usus)) {
  259. ret = devm_gpio_request(dev, pdata->usus, data->psy_desc.name);
  260. if (ret) {
  261. dev_err(dev,
  262. "Failed GPIO request for usus: %d err %d\n",
  263. pdata->usus, ret);
  264. return ret;
  265. }
  266. }
  267. data->fault = false;
  268. data->ta_in = ta_in;
  269. data->usb_in = usb_in;
  270. return 0;
  271. }
  272. static int max8903_probe(struct platform_device *pdev)
  273. {
  274. struct max8903_data *data;
  275. struct device *dev = &pdev->dev;
  276. struct max8903_pdata *pdata = pdev->dev.platform_data;
  277. struct power_supply_config psy_cfg = {};
  278. int ret = 0;
  279. data = devm_kzalloc(dev, sizeof(struct max8903_data), GFP_KERNEL);
  280. if (!data)
  281. return -ENOMEM;
  282. if (IS_ENABLED(CONFIG_OF) && !pdata && dev->of_node)
  283. pdata = max8903_parse_dt_data(dev);
  284. if (!pdata) {
  285. dev_err(dev, "No platform data.\n");
  286. return -EINVAL;
  287. }
  288. pdev->dev.platform_data = pdata;
  289. data->pdata = pdata;
  290. data->dev = dev;
  291. platform_set_drvdata(pdev, data);
  292. if (pdata->dc_valid == false && pdata->usb_valid == false) {
  293. dev_err(dev, "No valid power sources.\n");
  294. return -EINVAL;
  295. }
  296. ret = max8903_setup_gpios(pdev);
  297. if (ret)
  298. return ret;
  299. data->psy_desc.name = "max8903_charger";
  300. data->psy_desc.type = (data->ta_in) ? POWER_SUPPLY_TYPE_MAINS :
  301. ((data->usb_in) ? POWER_SUPPLY_TYPE_USB :
  302. POWER_SUPPLY_TYPE_BATTERY);
  303. data->psy_desc.get_property = max8903_get_property;
  304. data->psy_desc.properties = max8903_charger_props;
  305. data->psy_desc.num_properties = ARRAY_SIZE(max8903_charger_props);
  306. psy_cfg.of_node = dev->of_node;
  307. psy_cfg.drv_data = data;
  308. data->psy = devm_power_supply_register(dev, &data->psy_desc, &psy_cfg);
  309. if (IS_ERR(data->psy)) {
  310. dev_err(dev, "failed: power supply register.\n");
  311. return PTR_ERR(data->psy);
  312. }
  313. if (pdata->dc_valid) {
  314. ret = devm_request_threaded_irq(dev, gpio_to_irq(pdata->dok),
  315. NULL, max8903_dcin,
  316. IRQF_TRIGGER_FALLING |
  317. IRQF_TRIGGER_RISING | IRQF_ONESHOT,
  318. "MAX8903 DC IN", data);
  319. if (ret) {
  320. dev_err(dev, "Cannot request irq %d for DC (%d)\n",
  321. gpio_to_irq(pdata->dok), ret);
  322. return ret;
  323. }
  324. }
  325. if (pdata->usb_valid) {
  326. ret = devm_request_threaded_irq(dev, gpio_to_irq(pdata->uok),
  327. NULL, max8903_usbin,
  328. IRQF_TRIGGER_FALLING |
  329. IRQF_TRIGGER_RISING | IRQF_ONESHOT,
  330. "MAX8903 USB IN", data);
  331. if (ret) {
  332. dev_err(dev, "Cannot request irq %d for USB (%d)\n",
  333. gpio_to_irq(pdata->uok), ret);
  334. return ret;
  335. }
  336. }
  337. if (gpio_is_valid(pdata->flt)) {
  338. ret = devm_request_threaded_irq(dev, gpio_to_irq(pdata->flt),
  339. NULL, max8903_fault,
  340. IRQF_TRIGGER_FALLING |
  341. IRQF_TRIGGER_RISING | IRQF_ONESHOT,
  342. "MAX8903 Fault", data);
  343. if (ret) {
  344. dev_err(dev, "Cannot request irq %d for Fault (%d)\n",
  345. gpio_to_irq(pdata->flt), ret);
  346. return ret;
  347. }
  348. }
  349. return 0;
  350. }
  351. static const struct of_device_id max8903_match_ids[] = {
  352. { .compatible = "maxim,max8903", },
  353. { /* sentinel */ }
  354. };
  355. MODULE_DEVICE_TABLE(of, max8903_match_ids);
  356. static struct platform_driver max8903_driver = {
  357. .probe = max8903_probe,
  358. .driver = {
  359. .name = "max8903-charger",
  360. .of_match_table = max8903_match_ids
  361. },
  362. };
  363. module_platform_driver(max8903_driver);
  364. MODULE_LICENSE("GPL");
  365. MODULE_DESCRIPTION("MAX8903 Charger Driver");
  366. MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
  367. MODULE_ALIAS("platform:max8903-charger");