wm831x-ldo.c 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793
  1. /*
  2. * wm831x-ldo.c -- LDO driver for the WM831x series
  3. *
  4. * Copyright 2009 Wolfson Microelectronics PLC.
  5. *
  6. * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
  7. *
  8. * This program is free software; you can redistribute it and/or modify it
  9. * under the terms of the GNU General Public License as published by the
  10. * Free Software Foundation; either version 2 of the License, or (at your
  11. * option) any later version.
  12. */
  13. #include <linux/module.h>
  14. #include <linux/moduleparam.h>
  15. #include <linux/init.h>
  16. #include <linux/bitops.h>
  17. #include <linux/err.h>
  18. #include <linux/i2c.h>
  19. #include <linux/platform_device.h>
  20. #include <linux/regulator/driver.h>
  21. #include <linux/slab.h>
  22. #include <linux/mfd/wm831x/core.h>
  23. #include <linux/mfd/wm831x/regulator.h>
  24. #include <linux/mfd/wm831x/pdata.h>
  25. #define WM831X_LDO_MAX_NAME 9
  26. #define WM831X_LDO_CONTROL 0
  27. #define WM831X_LDO_ON_CONTROL 1
  28. #define WM831X_LDO_SLEEP_CONTROL 2
  29. #define WM831X_ALIVE_LDO_ON_CONTROL 0
  30. #define WM831X_ALIVE_LDO_SLEEP_CONTROL 1
  31. struct wm831x_ldo {
  32. char name[WM831X_LDO_MAX_NAME];
  33. char supply_name[WM831X_LDO_MAX_NAME];
  34. struct regulator_desc desc;
  35. int base;
  36. struct wm831x *wm831x;
  37. struct regulator_dev *regulator;
  38. };
  39. /*
  40. * Shared
  41. */
  42. static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data)
  43. {
  44. struct wm831x_ldo *ldo = data;
  45. regulator_notifier_call_chain(ldo->regulator,
  46. REGULATOR_EVENT_UNDER_VOLTAGE,
  47. NULL);
  48. return IRQ_HANDLED;
  49. }
  50. /*
  51. * General purpose LDOs
  52. */
  53. #define WM831X_GP_LDO_SELECTOR_LOW 0xe
  54. #define WM831X_GP_LDO_MAX_SELECTOR 0x1f
  55. static int wm831x_gp_ldo_list_voltage(struct regulator_dev *rdev,
  56. unsigned int selector)
  57. {
  58. /* 0.9-1.6V in 50mV steps */
  59. if (selector <= WM831X_GP_LDO_SELECTOR_LOW)
  60. return 900000 + (selector * 50000);
  61. /* 1.7-3.3V in 100mV steps */
  62. if (selector <= WM831X_GP_LDO_MAX_SELECTOR)
  63. return 1600000 + ((selector - WM831X_GP_LDO_SELECTOR_LOW)
  64. * 100000);
  65. return -EINVAL;
  66. }
  67. static int wm831x_gp_ldo_map_voltage(struct regulator_dev *rdev,
  68. int min_uV, int max_uV)
  69. {
  70. int volt, vsel;
  71. if (min_uV < 900000)
  72. vsel = 0;
  73. else if (min_uV < 1700000)
  74. vsel = ((min_uV - 900000) / 50000);
  75. else
  76. vsel = ((min_uV - 1700000) / 100000)
  77. + WM831X_GP_LDO_SELECTOR_LOW + 1;
  78. volt = wm831x_gp_ldo_list_voltage(rdev, vsel);
  79. if (volt < min_uV || volt > max_uV)
  80. return -EINVAL;
  81. return vsel;
  82. }
  83. static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
  84. int uV)
  85. {
  86. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  87. struct wm831x *wm831x = ldo->wm831x;
  88. int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
  89. sel = wm831x_gp_ldo_map_voltage(rdev, uV, uV);
  90. if (sel < 0)
  91. return sel;
  92. return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel);
  93. }
  94. static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
  95. {
  96. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  97. struct wm831x *wm831x = ldo->wm831x;
  98. int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
  99. int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
  100. int ret;
  101. ret = wm831x_reg_read(wm831x, on_reg);
  102. if (ret < 0)
  103. return ret;
  104. if (!(ret & WM831X_LDO1_ON_MODE))
  105. return REGULATOR_MODE_NORMAL;
  106. ret = wm831x_reg_read(wm831x, ctrl_reg);
  107. if (ret < 0)
  108. return ret;
  109. if (ret & WM831X_LDO1_LP_MODE)
  110. return REGULATOR_MODE_STANDBY;
  111. else
  112. return REGULATOR_MODE_IDLE;
  113. }
  114. static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev,
  115. unsigned int mode)
  116. {
  117. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  118. struct wm831x *wm831x = ldo->wm831x;
  119. int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
  120. int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
  121. int ret;
  122. switch (mode) {
  123. case REGULATOR_MODE_NORMAL:
  124. ret = wm831x_set_bits(wm831x, on_reg,
  125. WM831X_LDO1_ON_MODE, 0);
  126. if (ret < 0)
  127. return ret;
  128. break;
  129. case REGULATOR_MODE_IDLE:
  130. ret = wm831x_set_bits(wm831x, ctrl_reg,
  131. WM831X_LDO1_LP_MODE, 0);
  132. if (ret < 0)
  133. return ret;
  134. ret = wm831x_set_bits(wm831x, on_reg,
  135. WM831X_LDO1_ON_MODE,
  136. WM831X_LDO1_ON_MODE);
  137. if (ret < 0)
  138. return ret;
  139. break;
  140. case REGULATOR_MODE_STANDBY:
  141. ret = wm831x_set_bits(wm831x, ctrl_reg,
  142. WM831X_LDO1_LP_MODE,
  143. WM831X_LDO1_LP_MODE);
  144. if (ret < 0)
  145. return ret;
  146. ret = wm831x_set_bits(wm831x, on_reg,
  147. WM831X_LDO1_ON_MODE,
  148. WM831X_LDO1_ON_MODE);
  149. if (ret < 0)
  150. return ret;
  151. break;
  152. default:
  153. return -EINVAL;
  154. }
  155. return 0;
  156. }
  157. static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
  158. {
  159. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  160. struct wm831x *wm831x = ldo->wm831x;
  161. int mask = 1 << rdev_get_id(rdev);
  162. int ret;
  163. /* Is the regulator on? */
  164. ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
  165. if (ret < 0)
  166. return ret;
  167. if (!(ret & mask))
  168. return REGULATOR_STATUS_OFF;
  169. /* Is it reporting under voltage? */
  170. ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
  171. if (ret < 0)
  172. return ret;
  173. if (ret & mask)
  174. return REGULATOR_STATUS_ERROR;
  175. ret = wm831x_gp_ldo_get_mode(rdev);
  176. if (ret < 0)
  177. return ret;
  178. else
  179. return regulator_mode_to_status(ret);
  180. }
  181. static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
  182. int input_uV,
  183. int output_uV, int load_uA)
  184. {
  185. if (load_uA < 20000)
  186. return REGULATOR_MODE_STANDBY;
  187. if (load_uA < 50000)
  188. return REGULATOR_MODE_IDLE;
  189. return REGULATOR_MODE_NORMAL;
  190. }
  191. static struct regulator_ops wm831x_gp_ldo_ops = {
  192. .list_voltage = wm831x_gp_ldo_list_voltage,
  193. .map_voltage = wm831x_gp_ldo_map_voltage,
  194. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  195. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  196. .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
  197. .get_mode = wm831x_gp_ldo_get_mode,
  198. .set_mode = wm831x_gp_ldo_set_mode,
  199. .get_status = wm831x_gp_ldo_get_status,
  200. .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
  201. .get_bypass = regulator_get_bypass_regmap,
  202. .set_bypass = regulator_set_bypass_regmap,
  203. .is_enabled = regulator_is_enabled_regmap,
  204. .enable = regulator_enable_regmap,
  205. .disable = regulator_disable_regmap,
  206. };
  207. static int wm831x_gp_ldo_probe(struct platform_device *pdev)
  208. {
  209. struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
  210. struct wm831x_pdata *pdata = wm831x->dev->platform_data;
  211. struct regulator_config config = { };
  212. int id;
  213. struct wm831x_ldo *ldo;
  214. struct resource *res;
  215. int ret, irq;
  216. if (pdata && pdata->wm831x_num)
  217. id = (pdata->wm831x_num * 10) + 1;
  218. else
  219. id = 0;
  220. id = pdev->id - id;
  221. dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
  222. ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
  223. if (ldo == NULL) {
  224. dev_err(&pdev->dev, "Unable to allocate private data\n");
  225. return -ENOMEM;
  226. }
  227. ldo->wm831x = wm831x;
  228. res = platform_get_resource(pdev, IORESOURCE_REG, 0);
  229. if (res == NULL) {
  230. dev_err(&pdev->dev, "No REG resource\n");
  231. ret = -EINVAL;
  232. goto err;
  233. }
  234. ldo->base = res->start;
  235. snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
  236. ldo->desc.name = ldo->name;
  237. snprintf(ldo->supply_name, sizeof(ldo->supply_name),
  238. "LDO%dVDD", id + 1);
  239. ldo->desc.supply_name = ldo->supply_name;
  240. ldo->desc.id = id;
  241. ldo->desc.type = REGULATOR_VOLTAGE;
  242. ldo->desc.n_voltages = WM831X_GP_LDO_MAX_SELECTOR + 1;
  243. ldo->desc.ops = &wm831x_gp_ldo_ops;
  244. ldo->desc.owner = THIS_MODULE;
  245. ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
  246. ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK;
  247. ldo->desc.enable_reg = WM831X_LDO_ENABLE;
  248. ldo->desc.enable_mask = 1 << id;
  249. ldo->desc.bypass_reg = ldo->base;
  250. ldo->desc.bypass_mask = WM831X_LDO1_SWI;
  251. config.dev = pdev->dev.parent;
  252. if (pdata)
  253. config.init_data = pdata->ldo[id];
  254. config.driver_data = ldo;
  255. config.regmap = wm831x->regmap;
  256. ldo->regulator = regulator_register(&ldo->desc, &config);
  257. if (IS_ERR(ldo->regulator)) {
  258. ret = PTR_ERR(ldo->regulator);
  259. dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
  260. id + 1, ret);
  261. goto err;
  262. }
  263. irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
  264. ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq,
  265. IRQF_TRIGGER_RISING, ldo->name,
  266. ldo);
  267. if (ret != 0) {
  268. dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
  269. irq, ret);
  270. goto err_regulator;
  271. }
  272. platform_set_drvdata(pdev, ldo);
  273. return 0;
  274. err_regulator:
  275. regulator_unregister(ldo->regulator);
  276. err:
  277. return ret;
  278. }
  279. static int wm831x_gp_ldo_remove(struct platform_device *pdev)
  280. {
  281. struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
  282. platform_set_drvdata(pdev, NULL);
  283. free_irq(wm831x_irq(ldo->wm831x,
  284. platform_get_irq_byname(pdev, "UV")), ldo);
  285. regulator_unregister(ldo->regulator);
  286. return 0;
  287. }
  288. static struct platform_driver wm831x_gp_ldo_driver = {
  289. .probe = wm831x_gp_ldo_probe,
  290. .remove = wm831x_gp_ldo_remove,
  291. .driver = {
  292. .name = "wm831x-ldo",
  293. .owner = THIS_MODULE,
  294. },
  295. };
  296. /*
  297. * Analogue LDOs
  298. */
  299. #define WM831X_ALDO_SELECTOR_LOW 0xc
  300. #define WM831X_ALDO_MAX_SELECTOR 0x1f
  301. static int wm831x_aldo_list_voltage(struct regulator_dev *rdev,
  302. unsigned int selector)
  303. {
  304. /* 1-1.6V in 50mV steps */
  305. if (selector <= WM831X_ALDO_SELECTOR_LOW)
  306. return 1000000 + (selector * 50000);
  307. /* 1.7-3.5V in 100mV steps */
  308. if (selector <= WM831X_ALDO_MAX_SELECTOR)
  309. return 1600000 + ((selector - WM831X_ALDO_SELECTOR_LOW)
  310. * 100000);
  311. return -EINVAL;
  312. }
  313. static int wm831x_aldo_map_voltage(struct regulator_dev *rdev,
  314. int min_uV, int max_uV)
  315. {
  316. int volt, vsel;
  317. if (min_uV < 1000000)
  318. vsel = 0;
  319. else if (min_uV < 1700000)
  320. vsel = ((min_uV - 1000000) / 50000);
  321. else
  322. vsel = ((min_uV - 1700000) / 100000)
  323. + WM831X_ALDO_SELECTOR_LOW + 1;
  324. volt = wm831x_aldo_list_voltage(rdev, vsel);
  325. if (volt < min_uV || volt > max_uV)
  326. return -EINVAL;
  327. return vsel;
  328. }
  329. static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
  330. int uV)
  331. {
  332. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  333. struct wm831x *wm831x = ldo->wm831x;
  334. int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
  335. sel = wm831x_aldo_map_voltage(rdev, uV, uV);
  336. if (sel < 0)
  337. return sel;
  338. return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
  339. }
  340. static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
  341. {
  342. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  343. struct wm831x *wm831x = ldo->wm831x;
  344. int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
  345. int ret;
  346. ret = wm831x_reg_read(wm831x, on_reg);
  347. if (ret < 0)
  348. return 0;
  349. if (ret & WM831X_LDO7_ON_MODE)
  350. return REGULATOR_MODE_IDLE;
  351. else
  352. return REGULATOR_MODE_NORMAL;
  353. }
  354. static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
  355. unsigned int mode)
  356. {
  357. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  358. struct wm831x *wm831x = ldo->wm831x;
  359. int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
  360. int ret;
  361. switch (mode) {
  362. case REGULATOR_MODE_NORMAL:
  363. ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0);
  364. if (ret < 0)
  365. return ret;
  366. break;
  367. case REGULATOR_MODE_IDLE:
  368. ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE,
  369. WM831X_LDO7_ON_MODE);
  370. if (ret < 0)
  371. return ret;
  372. break;
  373. default:
  374. return -EINVAL;
  375. }
  376. return 0;
  377. }
  378. static int wm831x_aldo_get_status(struct regulator_dev *rdev)
  379. {
  380. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  381. struct wm831x *wm831x = ldo->wm831x;
  382. int mask = 1 << rdev_get_id(rdev);
  383. int ret;
  384. /* Is the regulator on? */
  385. ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
  386. if (ret < 0)
  387. return ret;
  388. if (!(ret & mask))
  389. return REGULATOR_STATUS_OFF;
  390. /* Is it reporting under voltage? */
  391. ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
  392. if (ret < 0)
  393. return ret;
  394. if (ret & mask)
  395. return REGULATOR_STATUS_ERROR;
  396. ret = wm831x_aldo_get_mode(rdev);
  397. if (ret < 0)
  398. return ret;
  399. else
  400. return regulator_mode_to_status(ret);
  401. }
  402. static struct regulator_ops wm831x_aldo_ops = {
  403. .list_voltage = wm831x_aldo_list_voltage,
  404. .map_voltage = wm831x_aldo_map_voltage,
  405. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  406. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  407. .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
  408. .get_mode = wm831x_aldo_get_mode,
  409. .set_mode = wm831x_aldo_set_mode,
  410. .get_status = wm831x_aldo_get_status,
  411. .set_bypass = regulator_set_bypass_regmap,
  412. .get_bypass = regulator_get_bypass_regmap,
  413. .is_enabled = regulator_is_enabled_regmap,
  414. .enable = regulator_enable_regmap,
  415. .disable = regulator_disable_regmap,
  416. };
  417. static int wm831x_aldo_probe(struct platform_device *pdev)
  418. {
  419. struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
  420. struct wm831x_pdata *pdata = wm831x->dev->platform_data;
  421. struct regulator_config config = { };
  422. int id;
  423. struct wm831x_ldo *ldo;
  424. struct resource *res;
  425. int ret, irq;
  426. if (pdata && pdata->wm831x_num)
  427. id = (pdata->wm831x_num * 10) + 1;
  428. else
  429. id = 0;
  430. id = pdev->id - id;
  431. dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
  432. ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
  433. if (ldo == NULL) {
  434. dev_err(&pdev->dev, "Unable to allocate private data\n");
  435. return -ENOMEM;
  436. }
  437. ldo->wm831x = wm831x;
  438. res = platform_get_resource(pdev, IORESOURCE_REG, 0);
  439. if (res == NULL) {
  440. dev_err(&pdev->dev, "No REG resource\n");
  441. ret = -EINVAL;
  442. goto err;
  443. }
  444. ldo->base = res->start;
  445. snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
  446. ldo->desc.name = ldo->name;
  447. snprintf(ldo->supply_name, sizeof(ldo->supply_name),
  448. "LDO%dVDD", id + 1);
  449. ldo->desc.supply_name = ldo->supply_name;
  450. ldo->desc.id = id;
  451. ldo->desc.type = REGULATOR_VOLTAGE;
  452. ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1;
  453. ldo->desc.ops = &wm831x_aldo_ops;
  454. ldo->desc.owner = THIS_MODULE;
  455. ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
  456. ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
  457. ldo->desc.enable_reg = WM831X_LDO_ENABLE;
  458. ldo->desc.enable_mask = 1 << id;
  459. ldo->desc.bypass_reg = ldo->base;
  460. ldo->desc.bypass_mask = WM831X_LDO7_SWI;
  461. config.dev = pdev->dev.parent;
  462. if (pdata)
  463. config.init_data = pdata->ldo[id];
  464. config.driver_data = ldo;
  465. config.regmap = wm831x->regmap;
  466. ldo->regulator = regulator_register(&ldo->desc, &config);
  467. if (IS_ERR(ldo->regulator)) {
  468. ret = PTR_ERR(ldo->regulator);
  469. dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
  470. id + 1, ret);
  471. goto err;
  472. }
  473. irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
  474. ret = request_threaded_irq(irq, NULL, wm831x_ldo_uv_irq,
  475. IRQF_TRIGGER_RISING, ldo->name, ldo);
  476. if (ret != 0) {
  477. dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
  478. irq, ret);
  479. goto err_regulator;
  480. }
  481. platform_set_drvdata(pdev, ldo);
  482. return 0;
  483. err_regulator:
  484. regulator_unregister(ldo->regulator);
  485. err:
  486. return ret;
  487. }
  488. static int wm831x_aldo_remove(struct platform_device *pdev)
  489. {
  490. struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
  491. free_irq(wm831x_irq(ldo->wm831x, platform_get_irq_byname(pdev, "UV")),
  492. ldo);
  493. regulator_unregister(ldo->regulator);
  494. return 0;
  495. }
  496. static struct platform_driver wm831x_aldo_driver = {
  497. .probe = wm831x_aldo_probe,
  498. .remove = wm831x_aldo_remove,
  499. .driver = {
  500. .name = "wm831x-aldo",
  501. .owner = THIS_MODULE,
  502. },
  503. };
  504. /*
  505. * Alive LDO
  506. */
  507. #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
  508. static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
  509. int uV)
  510. {
  511. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  512. struct wm831x *wm831x = ldo->wm831x;
  513. int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
  514. sel = regulator_map_voltage_linear(rdev, uV, uV);
  515. if (sel < 0)
  516. return sel;
  517. return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel);
  518. }
  519. static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
  520. {
  521. struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
  522. struct wm831x *wm831x = ldo->wm831x;
  523. int mask = 1 << rdev_get_id(rdev);
  524. int ret;
  525. /* Is the regulator on? */
  526. ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
  527. if (ret < 0)
  528. return ret;
  529. if (ret & mask)
  530. return REGULATOR_STATUS_ON;
  531. else
  532. return REGULATOR_STATUS_OFF;
  533. }
  534. static struct regulator_ops wm831x_alive_ldo_ops = {
  535. .list_voltage = regulator_list_voltage_linear,
  536. .map_voltage = regulator_map_voltage_linear,
  537. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  538. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  539. .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
  540. .get_status = wm831x_alive_ldo_get_status,
  541. .is_enabled = regulator_is_enabled_regmap,
  542. .enable = regulator_enable_regmap,
  543. .disable = regulator_disable_regmap,
  544. };
  545. static int wm831x_alive_ldo_probe(struct platform_device *pdev)
  546. {
  547. struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
  548. struct wm831x_pdata *pdata = wm831x->dev->platform_data;
  549. struct regulator_config config = { };
  550. int id;
  551. struct wm831x_ldo *ldo;
  552. struct resource *res;
  553. int ret;
  554. if (pdata && pdata->wm831x_num)
  555. id = (pdata->wm831x_num * 10) + 1;
  556. else
  557. id = 0;
  558. id = pdev->id - id;
  559. dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
  560. ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
  561. if (ldo == NULL) {
  562. dev_err(&pdev->dev, "Unable to allocate private data\n");
  563. return -ENOMEM;
  564. }
  565. ldo->wm831x = wm831x;
  566. res = platform_get_resource(pdev, IORESOURCE_REG, 0);
  567. if (res == NULL) {
  568. dev_err(&pdev->dev, "No REG resource\n");
  569. ret = -EINVAL;
  570. goto err;
  571. }
  572. ldo->base = res->start;
  573. snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
  574. ldo->desc.name = ldo->name;
  575. snprintf(ldo->supply_name, sizeof(ldo->supply_name),
  576. "LDO%dVDD", id + 1);
  577. ldo->desc.supply_name = ldo->supply_name;
  578. ldo->desc.id = id;
  579. ldo->desc.type = REGULATOR_VOLTAGE;
  580. ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
  581. ldo->desc.ops = &wm831x_alive_ldo_ops;
  582. ldo->desc.owner = THIS_MODULE;
  583. ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
  584. ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK;
  585. ldo->desc.enable_reg = WM831X_LDO_ENABLE;
  586. ldo->desc.enable_mask = 1 << id;
  587. ldo->desc.min_uV = 800000;
  588. ldo->desc.uV_step = 50000;
  589. ldo->desc.enable_time = 1000;
  590. config.dev = pdev->dev.parent;
  591. if (pdata)
  592. config.init_data = pdata->ldo[id];
  593. config.driver_data = ldo;
  594. config.regmap = wm831x->regmap;
  595. ldo->regulator = regulator_register(&ldo->desc, &config);
  596. if (IS_ERR(ldo->regulator)) {
  597. ret = PTR_ERR(ldo->regulator);
  598. dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
  599. id + 1, ret);
  600. goto err;
  601. }
  602. platform_set_drvdata(pdev, ldo);
  603. return 0;
  604. err:
  605. return ret;
  606. }
  607. static int wm831x_alive_ldo_remove(struct platform_device *pdev)
  608. {
  609. struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
  610. regulator_unregister(ldo->regulator);
  611. return 0;
  612. }
  613. static struct platform_driver wm831x_alive_ldo_driver = {
  614. .probe = wm831x_alive_ldo_probe,
  615. .remove = wm831x_alive_ldo_remove,
  616. .driver = {
  617. .name = "wm831x-alive-ldo",
  618. .owner = THIS_MODULE,
  619. },
  620. };
  621. static int __init wm831x_ldo_init(void)
  622. {
  623. int ret;
  624. ret = platform_driver_register(&wm831x_gp_ldo_driver);
  625. if (ret != 0)
  626. pr_err("Failed to register WM831x GP LDO driver: %d\n", ret);
  627. ret = platform_driver_register(&wm831x_aldo_driver);
  628. if (ret != 0)
  629. pr_err("Failed to register WM831x ALDO driver: %d\n", ret);
  630. ret = platform_driver_register(&wm831x_alive_ldo_driver);
  631. if (ret != 0)
  632. pr_err("Failed to register WM831x alive LDO driver: %d\n",
  633. ret);
  634. return 0;
  635. }
  636. subsys_initcall(wm831x_ldo_init);
  637. static void __exit wm831x_ldo_exit(void)
  638. {
  639. platform_driver_unregister(&wm831x_alive_ldo_driver);
  640. platform_driver_unregister(&wm831x_aldo_driver);
  641. platform_driver_unregister(&wm831x_gp_ldo_driver);
  642. }
  643. module_exit(wm831x_ldo_exit);
  644. /* Module information */
  645. MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
  646. MODULE_DESCRIPTION("WM831x LDO driver");
  647. MODULE_LICENSE("GPL");
  648. MODULE_ALIAS("platform:wm831x-ldo");
  649. MODULE_ALIAS("platform:wm831x-aldo");
  650. MODULE_ALIAS("platform:wm831x-aliveldo");