axp20x_usb_power.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * AXP20x PMIC USB power supply status driver
  4. *
  5. * Copyright (C) 2015 Hans de Goede <hdegoede@redhat.com>
  6. * Copyright (C) 2014 Bruno Prémont <bonbons@linux-vserver.org>
  7. */
  8. #include <linux/bitops.h>
  9. #include <linux/device.h>
  10. #include <linux/init.h>
  11. #include <linux/interrupt.h>
  12. #include <linux/kernel.h>
  13. #include <linux/mfd/axp20x.h>
  14. #include <linux/module.h>
  15. #include <linux/of.h>
  16. #include <linux/of_device.h>
  17. #include <linux/platform_device.h>
  18. #include <linux/pm.h>
  19. #include <linux/power_supply.h>
  20. #include <linux/regmap.h>
  21. #include <linux/slab.h>
  22. #include <linux/iio/consumer.h>
  23. #include <linux/workqueue.h>
  24. #define DRVNAME "axp20x-usb-power-supply"
  25. #define AXP20X_PWR_STATUS_VBUS_PRESENT BIT(5)
  26. #define AXP20X_PWR_STATUS_VBUS_USED BIT(4)
  27. #define AXP20X_USB_STATUS_VBUS_VALID BIT(2)
  28. #define AXP20X_VBUS_PATH_SEL BIT(7)
  29. #define AXP20X_VBUS_PATH_SEL_OFFSET 7
  30. #define AXP20X_VBUS_VHOLD_uV(b) (4000000 + (((b) >> 3) & 7) * 100000)
  31. #define AXP20X_VBUS_VHOLD_MASK GENMASK(5, 3)
  32. #define AXP20X_VBUS_VHOLD_OFFSET 3
  33. #define AXP20X_VBUS_CLIMIT_MASK 3
  34. #define AXP20X_VBUS_CLIMIT_900mA 0
  35. #define AXP20X_VBUS_CLIMIT_500mA 1
  36. #define AXP20X_VBUS_CLIMIT_100mA 2
  37. #define AXP20X_VBUS_CLIMIT_NONE 3
  38. #define AXP813_VBUS_CLIMIT_900mA 0
  39. #define AXP813_VBUS_CLIMIT_1500mA 1
  40. #define AXP813_VBUS_CLIMIT_2000mA 2
  41. #define AXP813_VBUS_CLIMIT_2500mA 3
  42. #define AXP20X_ADC_EN1_VBUS_CURR BIT(2)
  43. #define AXP20X_ADC_EN1_VBUS_VOLT BIT(3)
  44. #define AXP20X_VBUS_MON_VBUS_VALID BIT(3)
  45. #define AXP813_BC_EN BIT(0)
  46. /*
  47. * Note do not raise the debounce time, we must report Vusb high within
  48. * 100ms otherwise we get Vbus errors in musb.
  49. */
  50. #define DEBOUNCE_TIME msecs_to_jiffies(50)
  51. struct axp20x_usb_power {
  52. struct regmap *regmap;
  53. struct power_supply *supply;
  54. enum axp20x_variants axp20x_id;
  55. struct iio_channel *vbus_v;
  56. struct iio_channel *vbus_i;
  57. struct delayed_work vbus_detect;
  58. unsigned int old_status;
  59. unsigned int online;
  60. unsigned int num_irqs;
  61. unsigned int irqs[];
  62. };
  63. static bool axp20x_usb_vbus_needs_polling(struct axp20x_usb_power *power)
  64. {
  65. /*
  66. * Polling is only necessary while VBUS is offline. While online, a
  67. * present->absent transition implies an online->offline transition
  68. * and will trigger the VBUS_REMOVAL IRQ.
  69. */
  70. if (power->axp20x_id >= AXP221_ID && !power->online)
  71. return true;
  72. return false;
  73. }
  74. static irqreturn_t axp20x_usb_power_irq(int irq, void *devid)
  75. {
  76. struct axp20x_usb_power *power = devid;
  77. power_supply_changed(power->supply);
  78. mod_delayed_work(system_wq, &power->vbus_detect, DEBOUNCE_TIME);
  79. return IRQ_HANDLED;
  80. }
  81. static void axp20x_usb_power_poll_vbus(struct work_struct *work)
  82. {
  83. struct axp20x_usb_power *power =
  84. container_of(work, struct axp20x_usb_power, vbus_detect.work);
  85. unsigned int val;
  86. int ret;
  87. ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &val);
  88. if (ret)
  89. goto out;
  90. val &= (AXP20X_PWR_STATUS_VBUS_PRESENT | AXP20X_PWR_STATUS_VBUS_USED);
  91. if (val != power->old_status)
  92. power_supply_changed(power->supply);
  93. power->old_status = val;
  94. power->online = val & AXP20X_PWR_STATUS_VBUS_USED;
  95. out:
  96. if (axp20x_usb_vbus_needs_polling(power))
  97. mod_delayed_work(system_wq, &power->vbus_detect, DEBOUNCE_TIME);
  98. }
  99. static int axp20x_get_current_max(struct axp20x_usb_power *power, int *val)
  100. {
  101. unsigned int v;
  102. int ret = regmap_read(power->regmap, AXP20X_VBUS_IPSOUT_MGMT, &v);
  103. if (ret)
  104. return ret;
  105. switch (v & AXP20X_VBUS_CLIMIT_MASK) {
  106. case AXP20X_VBUS_CLIMIT_100mA:
  107. if (power->axp20x_id == AXP221_ID)
  108. *val = -1; /* No 100mA limit */
  109. else
  110. *val = 100000;
  111. break;
  112. case AXP20X_VBUS_CLIMIT_500mA:
  113. *val = 500000;
  114. break;
  115. case AXP20X_VBUS_CLIMIT_900mA:
  116. *val = 900000;
  117. break;
  118. case AXP20X_VBUS_CLIMIT_NONE:
  119. *val = -1;
  120. break;
  121. }
  122. return 0;
  123. }
  124. static int axp813_get_current_max(struct axp20x_usb_power *power, int *val)
  125. {
  126. unsigned int v;
  127. int ret = regmap_read(power->regmap, AXP20X_VBUS_IPSOUT_MGMT, &v);
  128. if (ret)
  129. return ret;
  130. switch (v & AXP20X_VBUS_CLIMIT_MASK) {
  131. case AXP813_VBUS_CLIMIT_900mA:
  132. *val = 900000;
  133. break;
  134. case AXP813_VBUS_CLIMIT_1500mA:
  135. *val = 1500000;
  136. break;
  137. case AXP813_VBUS_CLIMIT_2000mA:
  138. *val = 2000000;
  139. break;
  140. case AXP813_VBUS_CLIMIT_2500mA:
  141. *val = 2500000;
  142. break;
  143. }
  144. return 0;
  145. }
  146. static int axp20x_usb_power_get_property(struct power_supply *psy,
  147. enum power_supply_property psp, union power_supply_propval *val)
  148. {
  149. struct axp20x_usb_power *power = power_supply_get_drvdata(psy);
  150. unsigned int input, v;
  151. int ret;
  152. switch (psp) {
  153. case POWER_SUPPLY_PROP_VOLTAGE_MIN:
  154. ret = regmap_read(power->regmap, AXP20X_VBUS_IPSOUT_MGMT, &v);
  155. if (ret)
  156. return ret;
  157. val->intval = AXP20X_VBUS_VHOLD_uV(v);
  158. return 0;
  159. case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  160. if (IS_ENABLED(CONFIG_AXP20X_ADC)) {
  161. ret = iio_read_channel_processed(power->vbus_v,
  162. &val->intval);
  163. if (ret)
  164. return ret;
  165. /*
  166. * IIO framework gives mV but Power Supply framework
  167. * gives uV.
  168. */
  169. val->intval *= 1000;
  170. return 0;
  171. }
  172. ret = axp20x_read_variable_width(power->regmap,
  173. AXP20X_VBUS_V_ADC_H, 12);
  174. if (ret < 0)
  175. return ret;
  176. val->intval = ret * 1700; /* 1 step = 1.7 mV */
  177. return 0;
  178. case POWER_SUPPLY_PROP_CURRENT_MAX:
  179. if (power->axp20x_id == AXP813_ID)
  180. return axp813_get_current_max(power, &val->intval);
  181. return axp20x_get_current_max(power, &val->intval);
  182. case POWER_SUPPLY_PROP_CURRENT_NOW:
  183. if (IS_ENABLED(CONFIG_AXP20X_ADC)) {
  184. ret = iio_read_channel_processed(power->vbus_i,
  185. &val->intval);
  186. if (ret)
  187. return ret;
  188. /*
  189. * IIO framework gives mA but Power Supply framework
  190. * gives uA.
  191. */
  192. val->intval *= 1000;
  193. return 0;
  194. }
  195. ret = axp20x_read_variable_width(power->regmap,
  196. AXP20X_VBUS_I_ADC_H, 12);
  197. if (ret < 0)
  198. return ret;
  199. val->intval = ret * 375; /* 1 step = 0.375 mA */
  200. return 0;
  201. default:
  202. break;
  203. }
  204. /* All the properties below need the input-status reg value */
  205. ret = regmap_read(power->regmap, AXP20X_PWR_INPUT_STATUS, &input);
  206. if (ret)
  207. return ret;
  208. switch (psp) {
  209. case POWER_SUPPLY_PROP_HEALTH:
  210. if (!(input & AXP20X_PWR_STATUS_VBUS_PRESENT)) {
  211. val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
  212. break;
  213. }
  214. val->intval = POWER_SUPPLY_HEALTH_GOOD;
  215. if (power->axp20x_id == AXP202_ID) {
  216. ret = regmap_read(power->regmap,
  217. AXP20X_USB_OTG_STATUS, &v);
  218. if (ret)
  219. return ret;
  220. if (!(v & AXP20X_USB_STATUS_VBUS_VALID))
  221. val->intval =
  222. POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
  223. }
  224. break;
  225. case POWER_SUPPLY_PROP_PRESENT:
  226. val->intval = !!(input & AXP20X_PWR_STATUS_VBUS_PRESENT);
  227. break;
  228. case POWER_SUPPLY_PROP_ONLINE:
  229. val->intval = !!(input & AXP20X_PWR_STATUS_VBUS_USED);
  230. break;
  231. default:
  232. return -EINVAL;
  233. }
  234. return 0;
  235. }
  236. static int axp813_usb_power_set_online(struct axp20x_usb_power *power,
  237. int intval)
  238. {
  239. int val = !intval << AXP20X_VBUS_PATH_SEL_OFFSET;
  240. return regmap_update_bits(power->regmap,
  241. AXP20X_VBUS_IPSOUT_MGMT,
  242. AXP20X_VBUS_PATH_SEL, val);
  243. }
  244. static int axp20x_usb_power_set_voltage_min(struct axp20x_usb_power *power,
  245. int intval)
  246. {
  247. int val;
  248. switch (intval) {
  249. case 4000000:
  250. case 4100000:
  251. case 4200000:
  252. case 4300000:
  253. case 4400000:
  254. case 4500000:
  255. case 4600000:
  256. case 4700000:
  257. val = (intval - 4000000) / 100000;
  258. return regmap_update_bits(power->regmap,
  259. AXP20X_VBUS_IPSOUT_MGMT,
  260. AXP20X_VBUS_VHOLD_MASK,
  261. val << AXP20X_VBUS_VHOLD_OFFSET);
  262. default:
  263. return -EINVAL;
  264. }
  265. return -EINVAL;
  266. }
  267. static int axp813_usb_power_set_current_max(struct axp20x_usb_power *power,
  268. int intval)
  269. {
  270. int val;
  271. switch (intval) {
  272. case 900000:
  273. return regmap_update_bits(power->regmap,
  274. AXP20X_VBUS_IPSOUT_MGMT,
  275. AXP20X_VBUS_CLIMIT_MASK,
  276. AXP813_VBUS_CLIMIT_900mA);
  277. case 1500000:
  278. case 2000000:
  279. case 2500000:
  280. val = (intval - 1000000) / 500000;
  281. return regmap_update_bits(power->regmap,
  282. AXP20X_VBUS_IPSOUT_MGMT,
  283. AXP20X_VBUS_CLIMIT_MASK, val);
  284. default:
  285. return -EINVAL;
  286. }
  287. return -EINVAL;
  288. }
  289. static int axp20x_usb_power_set_current_max(struct axp20x_usb_power *power,
  290. int intval)
  291. {
  292. int val;
  293. switch (intval) {
  294. case 100000:
  295. if (power->axp20x_id == AXP221_ID)
  296. return -EINVAL;
  297. fallthrough;
  298. case 500000:
  299. case 900000:
  300. val = (900000 - intval) / 400000;
  301. return regmap_update_bits(power->regmap,
  302. AXP20X_VBUS_IPSOUT_MGMT,
  303. AXP20X_VBUS_CLIMIT_MASK, val);
  304. default:
  305. return -EINVAL;
  306. }
  307. return -EINVAL;
  308. }
  309. static int axp20x_usb_power_set_property(struct power_supply *psy,
  310. enum power_supply_property psp,
  311. const union power_supply_propval *val)
  312. {
  313. struct axp20x_usb_power *power = power_supply_get_drvdata(psy);
  314. switch (psp) {
  315. case POWER_SUPPLY_PROP_ONLINE:
  316. if (power->axp20x_id != AXP813_ID)
  317. return -EINVAL;
  318. return axp813_usb_power_set_online(power, val->intval);
  319. case POWER_SUPPLY_PROP_VOLTAGE_MIN:
  320. return axp20x_usb_power_set_voltage_min(power, val->intval);
  321. case POWER_SUPPLY_PROP_CURRENT_MAX:
  322. if (power->axp20x_id == AXP813_ID)
  323. return axp813_usb_power_set_current_max(power,
  324. val->intval);
  325. return axp20x_usb_power_set_current_max(power, val->intval);
  326. default:
  327. return -EINVAL;
  328. }
  329. return -EINVAL;
  330. }
  331. static int axp20x_usb_power_prop_writeable(struct power_supply *psy,
  332. enum power_supply_property psp)
  333. {
  334. struct axp20x_usb_power *power = power_supply_get_drvdata(psy);
  335. /*
  336. * The VBUS path select flag works differently on on AXP288 and newer:
  337. * - On AXP20x and AXP22x, the flag enables VBUS (ignoring N_VBUSEN).
  338. * - On AXP288 and AXP8xx, the flag disables VBUS (ignoring N_VBUSEN).
  339. * We only expose the control on variants where it can be used to force
  340. * the VBUS input offline.
  341. */
  342. if (psp == POWER_SUPPLY_PROP_ONLINE)
  343. return power->axp20x_id == AXP813_ID;
  344. return psp == POWER_SUPPLY_PROP_VOLTAGE_MIN ||
  345. psp == POWER_SUPPLY_PROP_CURRENT_MAX;
  346. }
  347. static enum power_supply_property axp20x_usb_power_properties[] = {
  348. POWER_SUPPLY_PROP_HEALTH,
  349. POWER_SUPPLY_PROP_PRESENT,
  350. POWER_SUPPLY_PROP_ONLINE,
  351. POWER_SUPPLY_PROP_VOLTAGE_MIN,
  352. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  353. POWER_SUPPLY_PROP_CURRENT_MAX,
  354. POWER_SUPPLY_PROP_CURRENT_NOW,
  355. };
  356. static enum power_supply_property axp22x_usb_power_properties[] = {
  357. POWER_SUPPLY_PROP_HEALTH,
  358. POWER_SUPPLY_PROP_PRESENT,
  359. POWER_SUPPLY_PROP_ONLINE,
  360. POWER_SUPPLY_PROP_VOLTAGE_MIN,
  361. POWER_SUPPLY_PROP_CURRENT_MAX,
  362. };
  363. static const struct power_supply_desc axp20x_usb_power_desc = {
  364. .name = "axp20x-usb",
  365. .type = POWER_SUPPLY_TYPE_USB,
  366. .properties = axp20x_usb_power_properties,
  367. .num_properties = ARRAY_SIZE(axp20x_usb_power_properties),
  368. .property_is_writeable = axp20x_usb_power_prop_writeable,
  369. .get_property = axp20x_usb_power_get_property,
  370. .set_property = axp20x_usb_power_set_property,
  371. };
  372. static const struct power_supply_desc axp22x_usb_power_desc = {
  373. .name = "axp20x-usb",
  374. .type = POWER_SUPPLY_TYPE_USB,
  375. .properties = axp22x_usb_power_properties,
  376. .num_properties = ARRAY_SIZE(axp22x_usb_power_properties),
  377. .property_is_writeable = axp20x_usb_power_prop_writeable,
  378. .get_property = axp20x_usb_power_get_property,
  379. .set_property = axp20x_usb_power_set_property,
  380. };
  381. static const char * const axp20x_irq_names[] = {
  382. "VBUS_PLUGIN",
  383. "VBUS_REMOVAL",
  384. "VBUS_VALID",
  385. "VBUS_NOT_VALID",
  386. };
  387. static const char * const axp22x_irq_names[] = {
  388. "VBUS_PLUGIN",
  389. "VBUS_REMOVAL",
  390. };
  391. struct axp_data {
  392. const struct power_supply_desc *power_desc;
  393. const char * const *irq_names;
  394. unsigned int num_irq_names;
  395. enum axp20x_variants axp20x_id;
  396. };
  397. static const struct axp_data axp202_data = {
  398. .power_desc = &axp20x_usb_power_desc,
  399. .irq_names = axp20x_irq_names,
  400. .num_irq_names = ARRAY_SIZE(axp20x_irq_names),
  401. .axp20x_id = AXP202_ID,
  402. };
  403. static const struct axp_data axp221_data = {
  404. .power_desc = &axp22x_usb_power_desc,
  405. .irq_names = axp22x_irq_names,
  406. .num_irq_names = ARRAY_SIZE(axp22x_irq_names),
  407. .axp20x_id = AXP221_ID,
  408. };
  409. static const struct axp_data axp223_data = {
  410. .power_desc = &axp22x_usb_power_desc,
  411. .irq_names = axp22x_irq_names,
  412. .num_irq_names = ARRAY_SIZE(axp22x_irq_names),
  413. .axp20x_id = AXP223_ID,
  414. };
  415. static const struct axp_data axp813_data = {
  416. .power_desc = &axp22x_usb_power_desc,
  417. .irq_names = axp22x_irq_names,
  418. .num_irq_names = ARRAY_SIZE(axp22x_irq_names),
  419. .axp20x_id = AXP813_ID,
  420. };
  421. #ifdef CONFIG_PM_SLEEP
  422. static int axp20x_usb_power_suspend(struct device *dev)
  423. {
  424. struct axp20x_usb_power *power = dev_get_drvdata(dev);
  425. int i = 0;
  426. /*
  427. * Allow wake via VBUS_PLUGIN only.
  428. *
  429. * As nested threaded IRQs are not automatically disabled during
  430. * suspend, we must explicitly disable the remainder of the IRQs.
  431. */
  432. if (device_may_wakeup(&power->supply->dev))
  433. enable_irq_wake(power->irqs[i++]);
  434. while (i < power->num_irqs)
  435. disable_irq(power->irqs[i++]);
  436. return 0;
  437. }
  438. static int axp20x_usb_power_resume(struct device *dev)
  439. {
  440. struct axp20x_usb_power *power = dev_get_drvdata(dev);
  441. int i = 0;
  442. if (device_may_wakeup(&power->supply->dev))
  443. disable_irq_wake(power->irqs[i++]);
  444. while (i < power->num_irqs)
  445. enable_irq(power->irqs[i++]);
  446. mod_delayed_work(system_wq, &power->vbus_detect, DEBOUNCE_TIME);
  447. return 0;
  448. }
  449. #endif
  450. static SIMPLE_DEV_PM_OPS(axp20x_usb_power_pm_ops, axp20x_usb_power_suspend,
  451. axp20x_usb_power_resume);
  452. static int configure_iio_channels(struct platform_device *pdev,
  453. struct axp20x_usb_power *power)
  454. {
  455. power->vbus_v = devm_iio_channel_get(&pdev->dev, "vbus_v");
  456. if (IS_ERR(power->vbus_v)) {
  457. if (PTR_ERR(power->vbus_v) == -ENODEV)
  458. return -EPROBE_DEFER;
  459. return PTR_ERR(power->vbus_v);
  460. }
  461. power->vbus_i = devm_iio_channel_get(&pdev->dev, "vbus_i");
  462. if (IS_ERR(power->vbus_i)) {
  463. if (PTR_ERR(power->vbus_i) == -ENODEV)
  464. return -EPROBE_DEFER;
  465. return PTR_ERR(power->vbus_i);
  466. }
  467. return 0;
  468. }
  469. static int configure_adc_registers(struct axp20x_usb_power *power)
  470. {
  471. /* Enable vbus voltage and current measurement */
  472. return regmap_update_bits(power->regmap, AXP20X_ADC_EN1,
  473. AXP20X_ADC_EN1_VBUS_CURR |
  474. AXP20X_ADC_EN1_VBUS_VOLT,
  475. AXP20X_ADC_EN1_VBUS_CURR |
  476. AXP20X_ADC_EN1_VBUS_VOLT);
  477. }
  478. static int axp20x_usb_power_probe(struct platform_device *pdev)
  479. {
  480. struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
  481. struct power_supply_config psy_cfg = {};
  482. struct axp20x_usb_power *power;
  483. const struct axp_data *axp_data;
  484. int i, irq, ret;
  485. if (!of_device_is_available(pdev->dev.of_node))
  486. return -ENODEV;
  487. if (!axp20x) {
  488. dev_err(&pdev->dev, "Parent drvdata not set\n");
  489. return -EINVAL;
  490. }
  491. axp_data = of_device_get_match_data(&pdev->dev);
  492. power = devm_kzalloc(&pdev->dev,
  493. struct_size(power, irqs, axp_data->num_irq_names),
  494. GFP_KERNEL);
  495. if (!power)
  496. return -ENOMEM;
  497. platform_set_drvdata(pdev, power);
  498. power->axp20x_id = axp_data->axp20x_id;
  499. power->regmap = axp20x->regmap;
  500. power->num_irqs = axp_data->num_irq_names;
  501. INIT_DELAYED_WORK(&power->vbus_detect, axp20x_usb_power_poll_vbus);
  502. if (power->axp20x_id == AXP202_ID) {
  503. /* Enable vbus valid checking */
  504. ret = regmap_update_bits(power->regmap, AXP20X_VBUS_MON,
  505. AXP20X_VBUS_MON_VBUS_VALID,
  506. AXP20X_VBUS_MON_VBUS_VALID);
  507. if (ret)
  508. return ret;
  509. if (IS_ENABLED(CONFIG_AXP20X_ADC))
  510. ret = configure_iio_channels(pdev, power);
  511. else
  512. ret = configure_adc_registers(power);
  513. if (ret)
  514. return ret;
  515. }
  516. if (power->axp20x_id == AXP813_ID) {
  517. /* Enable USB Battery Charging specification detection */
  518. regmap_update_bits(axp20x->regmap, AXP288_BC_GLOBAL,
  519. AXP813_BC_EN, AXP813_BC_EN);
  520. }
  521. psy_cfg.of_node = pdev->dev.of_node;
  522. psy_cfg.drv_data = power;
  523. power->supply = devm_power_supply_register(&pdev->dev,
  524. axp_data->power_desc,
  525. &psy_cfg);
  526. if (IS_ERR(power->supply))
  527. return PTR_ERR(power->supply);
  528. /* Request irqs after registering, as irqs may trigger immediately */
  529. for (i = 0; i < axp_data->num_irq_names; i++) {
  530. irq = platform_get_irq_byname(pdev, axp_data->irq_names[i]);
  531. if (irq < 0) {
  532. dev_err(&pdev->dev, "No IRQ for %s: %d\n",
  533. axp_data->irq_names[i], irq);
  534. return irq;
  535. }
  536. power->irqs[i] = regmap_irq_get_virq(axp20x->regmap_irqc, irq);
  537. ret = devm_request_any_context_irq(&pdev->dev, power->irqs[i],
  538. axp20x_usb_power_irq, 0,
  539. DRVNAME, power);
  540. if (ret < 0) {
  541. dev_err(&pdev->dev, "Error requesting %s IRQ: %d\n",
  542. axp_data->irq_names[i], ret);
  543. return ret;
  544. }
  545. }
  546. if (axp20x_usb_vbus_needs_polling(power))
  547. queue_delayed_work(system_wq, &power->vbus_detect, 0);
  548. return 0;
  549. }
  550. static int axp20x_usb_power_remove(struct platform_device *pdev)
  551. {
  552. struct axp20x_usb_power *power = platform_get_drvdata(pdev);
  553. cancel_delayed_work_sync(&power->vbus_detect);
  554. return 0;
  555. }
  556. static const struct of_device_id axp20x_usb_power_match[] = {
  557. {
  558. .compatible = "x-powers,axp202-usb-power-supply",
  559. .data = &axp202_data,
  560. }, {
  561. .compatible = "x-powers,axp221-usb-power-supply",
  562. .data = &axp221_data,
  563. }, {
  564. .compatible = "x-powers,axp223-usb-power-supply",
  565. .data = &axp223_data,
  566. }, {
  567. .compatible = "x-powers,axp813-usb-power-supply",
  568. .data = &axp813_data,
  569. }, { /* sentinel */ }
  570. };
  571. MODULE_DEVICE_TABLE(of, axp20x_usb_power_match);
  572. static struct platform_driver axp20x_usb_power_driver = {
  573. .probe = axp20x_usb_power_probe,
  574. .remove = axp20x_usb_power_remove,
  575. .driver = {
  576. .name = DRVNAME,
  577. .of_match_table = axp20x_usb_power_match,
  578. .pm = &axp20x_usb_power_pm_ops,
  579. },
  580. };
  581. module_platform_driver(axp20x_usb_power_driver);
  582. MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
  583. MODULE_DESCRIPTION("AXP20x PMIC USB power supply status driver");
  584. MODULE_LICENSE("GPL");