hi655x-regulator.c 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216
  1. // SPDX-License-Identifier: GPL-2.0
  2. //
  3. // Device driver for regulators in Hi655x IC
  4. //
  5. // Copyright (c) 2016 Hisilicon.
  6. //
  7. // Authors:
  8. // Chen Feng <puck.chen@hisilicon.com>
  9. // Fei Wang <w.f@huawei.com>
  10. #include <linux/bitops.h>
  11. #include <linux/device.h>
  12. #include <linux/err.h>
  13. #include <linux/module.h>
  14. #include <linux/io.h>
  15. #include <linux/of.h>
  16. #include <linux/platform_device.h>
  17. #include <linux/regmap.h>
  18. #include <linux/regulator/driver.h>
  19. #include <linux/regulator/machine.h>
  20. #include <linux/regulator/of_regulator.h>
  21. #include <linux/mfd/hi655x-pmic.h>
  22. struct hi655x_regulator {
  23. unsigned int disable_reg;
  24. unsigned int status_reg;
  25. struct regulator_desc rdesc;
  26. };
  27. /* LDO7 & LDO10 */
  28. static const unsigned int ldo7_voltages[] = {
  29. 1800000, 1850000, 2850000, 2900000,
  30. 3000000, 3100000, 3200000, 3300000,
  31. };
  32. static const unsigned int ldo19_voltages[] = {
  33. 1800000, 1850000, 1900000, 1750000,
  34. 2800000, 2850000, 2900000, 3000000,
  35. };
  36. static const unsigned int ldo22_voltages[] = {
  37. 900000, 1000000, 1050000, 1100000,
  38. 1150000, 1175000, 1185000, 1200000,
  39. };
  40. enum hi655x_regulator_id {
  41. HI655X_LDO0,
  42. HI655X_LDO1,
  43. HI655X_LDO2,
  44. HI655X_LDO3,
  45. HI655X_LDO4,
  46. HI655X_LDO5,
  47. HI655X_LDO6,
  48. HI655X_LDO7,
  49. HI655X_LDO8,
  50. HI655X_LDO9,
  51. HI655X_LDO10,
  52. HI655X_LDO11,
  53. HI655X_LDO12,
  54. HI655X_LDO13,
  55. HI655X_LDO14,
  56. HI655X_LDO15,
  57. HI655X_LDO16,
  58. HI655X_LDO17,
  59. HI655X_LDO18,
  60. HI655X_LDO19,
  61. HI655X_LDO20,
  62. HI655X_LDO21,
  63. HI655X_LDO22,
  64. };
  65. static int hi655x_is_enabled(struct regulator_dev *rdev)
  66. {
  67. unsigned int value = 0;
  68. const struct hi655x_regulator *regulator = rdev_get_drvdata(rdev);
  69. regmap_read(rdev->regmap, regulator->status_reg, &value);
  70. return (value & rdev->desc->enable_mask);
  71. }
  72. static int hi655x_disable(struct regulator_dev *rdev)
  73. {
  74. const struct hi655x_regulator *regulator = rdev_get_drvdata(rdev);
  75. return regmap_write(rdev->regmap, regulator->disable_reg,
  76. rdev->desc->enable_mask);
  77. }
  78. static const struct regulator_ops hi655x_regulator_ops = {
  79. .enable = regulator_enable_regmap,
  80. .disable = hi655x_disable,
  81. .is_enabled = hi655x_is_enabled,
  82. .list_voltage = regulator_list_voltage_table,
  83. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  84. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  85. };
  86. static const struct regulator_ops hi655x_ldo_linear_ops = {
  87. .enable = regulator_enable_regmap,
  88. .disable = hi655x_disable,
  89. .is_enabled = hi655x_is_enabled,
  90. .list_voltage = regulator_list_voltage_linear,
  91. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  92. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  93. };
  94. #define HI655X_LDO(_ID, vreg, vmask, ereg, dreg, \
  95. sreg, cmask, vtable) { \
  96. .rdesc = { \
  97. .name = #_ID, \
  98. .of_match = of_match_ptr(#_ID), \
  99. .ops = &hi655x_regulator_ops, \
  100. .regulators_node = of_match_ptr("regulators"), \
  101. .type = REGULATOR_VOLTAGE, \
  102. .id = HI655X_##_ID, \
  103. .owner = THIS_MODULE, \
  104. .n_voltages = ARRAY_SIZE(vtable), \
  105. .volt_table = vtable, \
  106. .vsel_reg = HI655X_BUS_ADDR(vreg), \
  107. .vsel_mask = vmask, \
  108. .enable_reg = HI655X_BUS_ADDR(ereg), \
  109. .enable_mask = BIT(cmask), \
  110. }, \
  111. .disable_reg = HI655X_BUS_ADDR(dreg), \
  112. .status_reg = HI655X_BUS_ADDR(sreg), \
  113. }
  114. #define HI655X_LDO_LINEAR(_ID, vreg, vmask, ereg, dreg, \
  115. sreg, cmask, minv, nvolt, vstep) { \
  116. .rdesc = { \
  117. .name = #_ID, \
  118. .of_match = of_match_ptr(#_ID), \
  119. .ops = &hi655x_ldo_linear_ops, \
  120. .regulators_node = of_match_ptr("regulators"), \
  121. .type = REGULATOR_VOLTAGE, \
  122. .id = HI655X_##_ID, \
  123. .owner = THIS_MODULE, \
  124. .min_uV = minv, \
  125. .n_voltages = nvolt, \
  126. .uV_step = vstep, \
  127. .vsel_reg = HI655X_BUS_ADDR(vreg), \
  128. .vsel_mask = vmask, \
  129. .enable_reg = HI655X_BUS_ADDR(ereg), \
  130. .enable_mask = BIT(cmask), \
  131. }, \
  132. .disable_reg = HI655X_BUS_ADDR(dreg), \
  133. .status_reg = HI655X_BUS_ADDR(sreg), \
  134. }
  135. static const struct hi655x_regulator regulators[] = {
  136. HI655X_LDO_LINEAR(LDO2, 0x72, 0x07, 0x29, 0x2a, 0x2b, 0x01,
  137. 2500000, 8, 100000),
  138. HI655X_LDO(LDO7, 0x78, 0x07, 0x29, 0x2a, 0x2b, 0x06, ldo7_voltages),
  139. HI655X_LDO(LDO10, 0x78, 0x07, 0x29, 0x2a, 0x2b, 0x01, ldo7_voltages),
  140. HI655X_LDO_LINEAR(LDO13, 0x7e, 0x07, 0x2c, 0x2d, 0x2e, 0x04,
  141. 1600000, 8, 50000),
  142. HI655X_LDO_LINEAR(LDO14, 0x7f, 0x07, 0x2c, 0x2d, 0x2e, 0x05,
  143. 2500000, 8, 100000),
  144. HI655X_LDO_LINEAR(LDO15, 0x80, 0x07, 0x2c, 0x2d, 0x2e, 0x06,
  145. 1600000, 8, 50000),
  146. HI655X_LDO_LINEAR(LDO17, 0x82, 0x07, 0x2f, 0x30, 0x31, 0x00,
  147. 2500000, 8, 100000),
  148. HI655X_LDO(LDO19, 0x84, 0x07, 0x2f, 0x30, 0x31, 0x02, ldo19_voltages),
  149. HI655X_LDO_LINEAR(LDO21, 0x86, 0x07, 0x2f, 0x30, 0x31, 0x04,
  150. 1650000, 8, 50000),
  151. HI655X_LDO(LDO22, 0x87, 0x07, 0x2f, 0x30, 0x31, 0x05, ldo22_voltages),
  152. };
  153. static int hi655x_regulator_probe(struct platform_device *pdev)
  154. {
  155. unsigned int i;
  156. struct hi655x_pmic *pmic;
  157. struct regulator_config config = { };
  158. struct regulator_dev *rdev;
  159. pmic = dev_get_drvdata(pdev->dev.parent);
  160. if (!pmic) {
  161. dev_err(&pdev->dev, "no pmic in the regulator parent node\n");
  162. return -ENODEV;
  163. }
  164. config.dev = pdev->dev.parent;
  165. config.regmap = pmic->regmap;
  166. for (i = 0; i < ARRAY_SIZE(regulators); i++) {
  167. config.driver_data = (void *) &regulators[i];
  168. rdev = devm_regulator_register(&pdev->dev,
  169. &regulators[i].rdesc,
  170. &config);
  171. if (IS_ERR(rdev)) {
  172. dev_err(&pdev->dev, "failed to register regulator %s\n",
  173. regulators[i].rdesc.name);
  174. return PTR_ERR(rdev);
  175. }
  176. }
  177. return 0;
  178. }
  179. static const struct platform_device_id hi655x_regulator_table[] = {
  180. { .name = "hi655x-regulator" },
  181. {},
  182. };
  183. MODULE_DEVICE_TABLE(platform, hi655x_regulator_table);
  184. static struct platform_driver hi655x_regulator_driver = {
  185. .id_table = hi655x_regulator_table,
  186. .driver = {
  187. .name = "hi655x-regulator",
  188. },
  189. .probe = hi655x_regulator_probe,
  190. };
  191. module_platform_driver(hi655x_regulator_driver);
  192. MODULE_AUTHOR("Chen Feng <puck.chen@hisilicon.com>");
  193. MODULE_DESCRIPTION("Hisilicon Hi655x regulator driver");
  194. MODULE_LICENSE("GPL v2");