sandbox.c 8.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2015 Samsung Electronics
  4. * Przemyslaw Marczak <p.marczak@samsung.com>
  5. */
  6. #include <common.h>
  7. #include <fdtdec.h>
  8. #include <errno.h>
  9. #include <dm.h>
  10. #include <i2c.h>
  11. #include <power/pmic.h>
  12. #include <power/regulator.h>
  13. #include <power/sandbox_pmic.h>
  14. #define MODE(_id, _val, _name) [_id] = { \
  15. .id = _id, \
  16. .register_value = _val, \
  17. .name = _name, \
  18. }
  19. #define RANGE(_min, _max, _step) { \
  20. .min = _min, \
  21. .max = _max, \
  22. .step = _step, \
  23. }
  24. /*
  25. * struct output_range - helper structure type to define the range of output
  26. * operating values (current/voltage), limited by the PMIC IC design.
  27. *
  28. * @min - minimum value
  29. * @max - maximum value
  30. * @step - step value
  31. */
  32. struct output_range {
  33. int min;
  34. int max;
  35. int step;
  36. };
  37. /* BUCK: 1,2 - voltage range */
  38. static struct output_range buck_voltage_range[] = {
  39. RANGE(OUT_BUCK1_UV_MIN, OUT_BUCK1_UV_MAX, OUT_BUCK1_UV_STEP),
  40. RANGE(OUT_BUCK2_UV_MIN, OUT_BUCK2_UV_MAX, OUT_BUCK2_UV_STEP),
  41. };
  42. /* BUCK: 1 - current range */
  43. static struct output_range buck_current_range[] = {
  44. RANGE(OUT_BUCK1_UA_MIN, OUT_BUCK1_UA_MAX, OUT_BUCK1_UA_STEP),
  45. };
  46. /* BUCK operating modes */
  47. static struct dm_regulator_mode sandbox_buck_modes[] = {
  48. MODE(BUCK_OM_OFF, OM2REG(BUCK_OM_OFF), "OFF"),
  49. MODE(BUCK_OM_ON, OM2REG(BUCK_OM_ON), "ON"),
  50. MODE(BUCK_OM_PWM, OM2REG(BUCK_OM_PWM), "PWM"),
  51. };
  52. /* LDO: 1,2 - voltage range */
  53. static struct output_range ldo_voltage_range[] = {
  54. RANGE(OUT_LDO1_UV_MIN, OUT_LDO1_UV_MAX, OUT_LDO1_UV_STEP),
  55. RANGE(OUT_LDO2_UV_MIN, OUT_LDO2_UV_MAX, OUT_LDO2_UV_STEP),
  56. };
  57. /* LDO: 1 - current range */
  58. static struct output_range ldo_current_range[] = {
  59. RANGE(OUT_LDO1_UA_MIN, OUT_LDO1_UA_MAX, OUT_LDO1_UA_STEP),
  60. };
  61. /* LDO operating modes */
  62. static struct dm_regulator_mode sandbox_ldo_modes[] = {
  63. MODE(LDO_OM_OFF, OM2REG(LDO_OM_OFF), "OFF"),
  64. MODE(LDO_OM_ON, OM2REG(LDO_OM_ON), "ON"),
  65. MODE(LDO_OM_SLEEP, OM2REG(LDO_OM_SLEEP), "SLEEP"),
  66. MODE(LDO_OM_STANDBY, OM2REG(LDO_OM_STANDBY), "STANDBY"),
  67. };
  68. int out_get_value(struct udevice *dev, int output_count, int reg_type,
  69. struct output_range *range)
  70. {
  71. uint8_t reg_val;
  72. uint reg;
  73. int ret;
  74. if (dev->driver_data > output_count) {
  75. pr_err("Unknown regulator number: %lu for PMIC %s!",
  76. dev->driver_data, dev->name);
  77. return -EINVAL;
  78. }
  79. reg = (dev->driver_data - 1) * OUT_REG_COUNT + reg_type;
  80. ret = pmic_read(dev->parent, reg, &reg_val, 1);
  81. if (ret) {
  82. pr_err("PMIC read failed: %d\n", ret);
  83. return ret;
  84. }
  85. ret = REG2VAL(range[dev->driver_data - 1].min,
  86. range[dev->driver_data - 1].step,
  87. reg_val);
  88. return ret;
  89. }
  90. static int out_set_value(struct udevice *dev, int output_count, int reg_type,
  91. struct output_range *range, int value)
  92. {
  93. uint8_t reg_val;
  94. uint reg;
  95. int ret;
  96. int max_value;
  97. if (dev->driver_data > output_count) {
  98. pr_err("Unknown regulator number: %lu for PMIC %s!",
  99. dev->driver_data, dev->name);
  100. return -EINVAL;
  101. }
  102. max_value = range[dev->driver_data - 1].max;
  103. if (value > max_value) {
  104. pr_err("Wrong value for %s: %lu. Max is: %d.",
  105. dev->name, dev->driver_data, max_value);
  106. return -EINVAL;
  107. }
  108. reg_val = VAL2REG(range[dev->driver_data - 1].min,
  109. range[dev->driver_data - 1].step,
  110. value);
  111. reg = (dev->driver_data - 1) * OUT_REG_COUNT + reg_type;
  112. ret = pmic_write(dev->parent, reg, &reg_val, 1);
  113. if (ret) {
  114. pr_err("PMIC write failed: %d\n", ret);
  115. return ret;
  116. }
  117. return 0;
  118. }
  119. static int out_get_mode(struct udevice *dev)
  120. {
  121. struct dm_regulator_uclass_plat *uc_pdata;
  122. uint8_t reg_val;
  123. uint reg;
  124. int ret;
  125. int i;
  126. uc_pdata = dev_get_uclass_plat(dev);
  127. reg = (dev->driver_data - 1) * OUT_REG_COUNT + OUT_REG_OM;
  128. ret = pmic_read(dev->parent, reg, &reg_val, 1);
  129. if (ret) {
  130. pr_err("PMIC read failed: %d\n", ret);
  131. return ret;
  132. }
  133. for (i = 0; i < uc_pdata->mode_count; i++) {
  134. if (reg_val == uc_pdata->mode[i].register_value)
  135. return uc_pdata->mode[i].id;
  136. }
  137. pr_err("Unknown operation mode for %s!", dev->name);
  138. return -EINVAL;
  139. }
  140. static int out_set_mode(struct udevice *dev, int mode)
  141. {
  142. struct dm_regulator_uclass_plat *uc_pdata;
  143. int reg_val = -1;
  144. uint reg;
  145. int ret;
  146. int i;
  147. uc_pdata = dev_get_uclass_plat(dev);
  148. if (mode >= uc_pdata->mode_count)
  149. return -EINVAL;
  150. for (i = 0; i < uc_pdata->mode_count; i++) {
  151. if (mode == uc_pdata->mode[i].id) {
  152. reg_val = uc_pdata->mode[i].register_value;
  153. break;
  154. }
  155. }
  156. if (reg_val == -1) {
  157. pr_err("Unknown operation mode for %s!", dev->name);
  158. return -EINVAL;
  159. }
  160. reg = (dev->driver_data - 1) * OUT_REG_COUNT + OUT_REG_OM;
  161. ret = pmic_write(dev->parent, reg, (uint8_t *)&reg_val, 1);
  162. if (ret) {
  163. pr_err("PMIC write failed: %d\n", ret);
  164. return ret;
  165. }
  166. return 0;
  167. }
  168. static int buck_get_voltage(struct udevice *dev)
  169. {
  170. return out_get_value(dev, SANDBOX_BUCK_COUNT, OUT_REG_UV,
  171. buck_voltage_range);
  172. }
  173. static int buck_set_voltage(struct udevice *dev, int uV)
  174. {
  175. return out_set_value(dev, SANDBOX_BUCK_COUNT, OUT_REG_UV,
  176. buck_voltage_range, uV);
  177. }
  178. static int buck_get_current(struct udevice *dev)
  179. {
  180. /* BUCK2 - unsupported */
  181. if (dev->driver_data == 2)
  182. return -ENOSYS;
  183. return out_get_value(dev, SANDBOX_BUCK_COUNT, OUT_REG_UA,
  184. buck_current_range);
  185. }
  186. static int buck_set_current(struct udevice *dev, int uA)
  187. {
  188. /* BUCK2 - unsupported */
  189. if (dev->driver_data == 2)
  190. return -ENOSYS;
  191. return out_set_value(dev, SANDBOX_BUCK_COUNT, OUT_REG_UA,
  192. buck_current_range, uA);
  193. }
  194. static int buck_get_enable(struct udevice *dev)
  195. {
  196. if (out_get_mode(dev) == BUCK_OM_OFF)
  197. return false;
  198. return true;
  199. }
  200. static int buck_set_enable(struct udevice *dev, bool enable)
  201. {
  202. return out_set_mode(dev, enable ? BUCK_OM_ON : BUCK_OM_OFF);
  203. }
  204. static int sandbox_buck_probe(struct udevice *dev)
  205. {
  206. struct dm_regulator_uclass_plat *uc_pdata;
  207. uc_pdata = dev_get_uclass_plat(dev);
  208. uc_pdata->type = REGULATOR_TYPE_BUCK;
  209. uc_pdata->mode = sandbox_buck_modes;
  210. uc_pdata->mode_count = ARRAY_SIZE(sandbox_buck_modes);
  211. return 0;
  212. }
  213. static const struct dm_regulator_ops sandbox_buck_ops = {
  214. .get_value = buck_get_voltage,
  215. .set_value = buck_set_voltage,
  216. .get_current = buck_get_current,
  217. .set_current = buck_set_current,
  218. .get_enable = buck_get_enable,
  219. .set_enable = buck_set_enable,
  220. .get_mode = out_get_mode,
  221. .set_mode = out_set_mode,
  222. };
  223. U_BOOT_DRIVER(sandbox_buck) = {
  224. .name = SANDBOX_BUCK_DRIVER,
  225. .id = UCLASS_REGULATOR,
  226. .ops = &sandbox_buck_ops,
  227. .probe = sandbox_buck_probe,
  228. };
  229. static int ldo_get_voltage(struct udevice *dev)
  230. {
  231. return out_get_value(dev, SANDBOX_LDO_COUNT, OUT_REG_UV,
  232. ldo_voltage_range);
  233. }
  234. static int ldo_set_voltage(struct udevice *dev, int uV)
  235. {
  236. return out_set_value(dev, SANDBOX_LDO_COUNT, OUT_REG_UV,
  237. ldo_voltage_range, uV);
  238. }
  239. static int ldo_get_current(struct udevice *dev)
  240. {
  241. /* LDO2 - unsupported */
  242. if (dev->driver_data == 2)
  243. return -ENOSYS;
  244. return out_get_value(dev, SANDBOX_LDO_COUNT, OUT_REG_UA,
  245. ldo_current_range);
  246. }
  247. static int ldo_set_current(struct udevice *dev, int uA)
  248. {
  249. /* LDO2 - unsupported */
  250. if (dev->driver_data == 2)
  251. return -ENOSYS;
  252. return out_set_value(dev, SANDBOX_LDO_COUNT, OUT_REG_UA,
  253. ldo_current_range, uA);
  254. }
  255. static int ldo_get_enable(struct udevice *dev)
  256. {
  257. if (out_get_mode(dev) == LDO_OM_OFF)
  258. return false;
  259. return true;
  260. }
  261. static int ldo_set_enable(struct udevice *dev, bool enable)
  262. {
  263. return out_set_mode(dev, enable ? LDO_OM_ON : LDO_OM_OFF);
  264. }
  265. static int sandbox_ldo_probe(struct udevice *dev)
  266. {
  267. struct dm_regulator_uclass_plat *uc_pdata;
  268. uc_pdata = dev_get_uclass_plat(dev);
  269. uc_pdata->type = REGULATOR_TYPE_LDO;
  270. uc_pdata->mode = sandbox_ldo_modes;
  271. uc_pdata->mode_count = ARRAY_SIZE(sandbox_ldo_modes);
  272. return 0;
  273. }
  274. static const struct dm_regulator_ops sandbox_ldo_ops = {
  275. .get_value = ldo_get_voltage,
  276. .set_value = ldo_set_voltage,
  277. .get_current = ldo_get_current,
  278. .set_current = ldo_set_current,
  279. .get_enable = ldo_get_enable,
  280. .set_enable = ldo_set_enable,
  281. .get_mode = out_get_mode,
  282. .set_mode = out_set_mode,
  283. };
  284. U_BOOT_DRIVER(sandbox_ldo) = {
  285. .name = SANDBOX_LDO_DRIVER,
  286. .id = UCLASS_REGULATOR,
  287. .ops = &sandbox_ldo_ops,
  288. .probe = sandbox_ldo_probe,
  289. };