wm831x-ldo.c 16 KB

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