dsi_pwr.c 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
  4. */
  5. #include <linux/of.h>
  6. #include <linux/delay.h>
  7. #include <linux/slab.h>
  8. #include "dsi_pwr.h"
  9. #include "dsi_parser.h"
  10. /*
  11. * dsi_pwr_parse_supply_node() - parse power supply node from root device node
  12. */
  13. static int dsi_pwr_parse_supply_node(struct dsi_parser_utils *utils,
  14. struct device_node *root,
  15. struct dsi_regulator_info *regs)
  16. {
  17. int rc = 0;
  18. int i = 0;
  19. u32 tmp = 0;
  20. struct device_node *node = NULL;
  21. dsi_for_each_child_node(root, node) {
  22. const char *st = NULL;
  23. rc = utils->read_string(node, "qcom,supply-name", &st);
  24. if (rc) {
  25. pr_err("failed to read name, rc = %d\n", rc);
  26. goto error;
  27. }
  28. snprintf(regs->vregs[i].vreg_name,
  29. ARRAY_SIZE(regs->vregs[i].vreg_name),
  30. "%s", st);
  31. rc = utils->read_u32(node, "qcom,supply-min-voltage", &tmp);
  32. if (rc) {
  33. pr_err("failed to read min voltage, rc = %d\n", rc);
  34. goto error;
  35. }
  36. regs->vregs[i].min_voltage = tmp;
  37. rc = utils->read_u32(node, "qcom,supply-max-voltage", &tmp);
  38. if (rc) {
  39. pr_err("failed to read max voltage, rc = %d\n", rc);
  40. goto error;
  41. }
  42. regs->vregs[i].max_voltage = tmp;
  43. rc = utils->read_u32(node, "qcom,supply-enable-load", &tmp);
  44. if (rc) {
  45. pr_err("failed to read enable load, rc = %d\n", rc);
  46. goto error;
  47. }
  48. regs->vregs[i].enable_load = tmp;
  49. rc = utils->read_u32(node, "qcom,supply-disable-load", &tmp);
  50. if (rc) {
  51. pr_err("failed to read disable load, rc = %d\n", rc);
  52. goto error;
  53. }
  54. regs->vregs[i].disable_load = tmp;
  55. /* Optional values */
  56. rc = utils->read_u32(node, "qcom,supply-pre-on-sleep", &tmp);
  57. if (rc) {
  58. pr_debug("pre-on-sleep not specified\n");
  59. rc = 0;
  60. } else {
  61. regs->vregs[i].pre_on_sleep = tmp;
  62. }
  63. rc = utils->read_u32(node, "qcom,supply-pre-off-sleep", &tmp);
  64. if (rc) {
  65. pr_debug("pre-off-sleep not specified\n");
  66. rc = 0;
  67. } else {
  68. regs->vregs[i].pre_off_sleep = tmp;
  69. }
  70. rc = utils->read_u32(node, "qcom,supply-post-on-sleep", &tmp);
  71. if (rc) {
  72. pr_debug("post-on-sleep not specified\n");
  73. rc = 0;
  74. } else {
  75. regs->vregs[i].post_on_sleep = tmp;
  76. }
  77. rc = utils->read_u32(node, "qcom,supply-post-off-sleep", &tmp);
  78. if (rc) {
  79. pr_debug("post-off-sleep not specified\n");
  80. rc = 0;
  81. } else {
  82. regs->vregs[i].post_off_sleep = tmp;
  83. }
  84. pr_debug("[%s] minv=%d maxv=%d, en_load=%d, dis_load=%d\n",
  85. regs->vregs[i].vreg_name,
  86. regs->vregs[i].min_voltage,
  87. regs->vregs[i].max_voltage,
  88. regs->vregs[i].enable_load,
  89. regs->vregs[i].disable_load);
  90. ++i;
  91. }
  92. error:
  93. return rc;
  94. }
  95. /**
  96. * dsi_pwr_enable_vregs() - enable/disable regulators
  97. */
  98. static int dsi_pwr_enable_vregs(struct dsi_regulator_info *regs, bool enable)
  99. {
  100. int rc = 0, i = 0;
  101. struct dsi_vreg *vreg;
  102. int num_of_v = 0;
  103. if (enable) {
  104. for (i = 0; i < regs->count; i++) {
  105. vreg = &regs->vregs[i];
  106. if (vreg->pre_on_sleep)
  107. msleep(vreg->pre_on_sleep);
  108. rc = regulator_set_load(vreg->vreg,
  109. vreg->enable_load);
  110. if (rc < 0) {
  111. pr_err("Setting optimum mode failed for %s\n",
  112. vreg->vreg_name);
  113. goto error;
  114. }
  115. num_of_v = regulator_count_voltages(vreg->vreg);
  116. if (num_of_v > 0) {
  117. rc = regulator_set_voltage(vreg->vreg,
  118. vreg->min_voltage,
  119. vreg->max_voltage);
  120. if (rc) {
  121. pr_err("Set voltage(%s) fail, rc=%d\n",
  122. vreg->vreg_name, rc);
  123. goto error_disable_opt_mode;
  124. }
  125. }
  126. rc = regulator_enable(vreg->vreg);
  127. if (rc) {
  128. pr_err("enable failed for %s, rc=%d\n",
  129. vreg->vreg_name, rc);
  130. goto error_disable_voltage;
  131. }
  132. if (vreg->post_on_sleep)
  133. msleep(vreg->post_on_sleep);
  134. }
  135. } else {
  136. for (i = (regs->count - 1); i >= 0; i--) {
  137. if (regs->vregs[i].pre_off_sleep)
  138. msleep(regs->vregs[i].pre_off_sleep);
  139. (void)regulator_set_load(regs->vregs[i].vreg,
  140. regs->vregs[i].disable_load);
  141. (void)regulator_disable(regs->vregs[i].vreg);
  142. if (regs->vregs[i].post_off_sleep)
  143. msleep(regs->vregs[i].post_off_sleep);
  144. }
  145. }
  146. return 0;
  147. error_disable_opt_mode:
  148. (void)regulator_set_load(regs->vregs[i].vreg,
  149. regs->vregs[i].disable_load);
  150. error_disable_voltage:
  151. if (num_of_v > 0)
  152. (void)regulator_set_voltage(regs->vregs[i].vreg,
  153. 0, regs->vregs[i].max_voltage);
  154. error:
  155. for (i--; i >= 0; i--) {
  156. if (regs->vregs[i].pre_off_sleep)
  157. msleep(regs->vregs[i].pre_off_sleep);
  158. (void)regulator_set_load(regs->vregs[i].vreg,
  159. regs->vregs[i].disable_load);
  160. num_of_v = regulator_count_voltages(regs->vregs[i].vreg);
  161. if (num_of_v > 0)
  162. (void)regulator_set_voltage(regs->vregs[i].vreg,
  163. 0, regs->vregs[i].max_voltage);
  164. (void)regulator_disable(regs->vregs[i].vreg);
  165. if (regs->vregs[i].post_off_sleep)
  166. msleep(regs->vregs[i].post_off_sleep);
  167. }
  168. return rc;
  169. }
  170. /**
  171. * dsi_pwr_of_get_vreg_data - Parse regulator supply information
  172. * @of_node: Device of node to parse for supply information.
  173. * @regs: Pointer where regulator information will be copied to.
  174. * @supply_name: Name of the supply node.
  175. *
  176. * return: error code in case of failure or 0 for success.
  177. */
  178. int dsi_pwr_of_get_vreg_data(struct dsi_parser_utils *utils,
  179. struct dsi_regulator_info *regs,
  180. char *supply_name)
  181. {
  182. int rc = 0;
  183. struct device_node *supply_root_node = NULL;
  184. if (!utils || !regs) {
  185. pr_err("Bad params\n");
  186. return -EINVAL;
  187. }
  188. regs->count = 0;
  189. supply_root_node = utils->get_child_by_name(utils->data, supply_name);
  190. if (!supply_root_node) {
  191. supply_root_node = of_parse_phandle(utils->node,
  192. supply_name, 0);
  193. if (!supply_root_node) {
  194. pr_debug("No supply entry present for %s\n",
  195. supply_name);
  196. return -EINVAL;
  197. }
  198. }
  199. regs->count = utils->get_available_child_count(supply_root_node);
  200. if (regs->count == 0) {
  201. pr_err("No vregs defined for %s\n", supply_name);
  202. return -EINVAL;
  203. }
  204. regs->vregs = kcalloc(regs->count, sizeof(*regs->vregs), GFP_KERNEL);
  205. if (!regs->vregs) {
  206. regs->count = 0;
  207. return -ENOMEM;
  208. }
  209. rc = dsi_pwr_parse_supply_node(utils, supply_root_node, regs);
  210. if (rc) {
  211. pr_err("failed to parse supply node for %s, rc = %d\n",
  212. supply_name, rc);
  213. kfree(regs->vregs);
  214. regs->vregs = NULL;
  215. regs->count = 0;
  216. }
  217. return rc;
  218. }
  219. /**
  220. * dsi_pwr_get_dt_vreg_data - parse regulator supply information
  221. * @dev: Device whose of_node needs to be parsed.
  222. * @regs: Pointer where regulator information will be copied to.
  223. * @supply_name: Name of the supply node.
  224. *
  225. * return: error code in case of failure or 0 for success.
  226. */
  227. int dsi_pwr_get_dt_vreg_data(struct device *dev,
  228. struct dsi_regulator_info *regs,
  229. char *supply_name)
  230. {
  231. int rc = 0;
  232. struct device_node *of_node = NULL;
  233. struct device_node *supply_node = NULL;
  234. struct device_node *supply_root_node = NULL;
  235. struct dsi_parser_utils utils = *dsi_parser_get_of_utils();
  236. if (!dev || !regs) {
  237. pr_err("Bad params\n");
  238. return -EINVAL;
  239. }
  240. of_node = dev->of_node;
  241. regs->count = 0;
  242. supply_root_node = of_get_child_by_name(of_node, supply_name);
  243. if (!supply_root_node) {
  244. supply_root_node = of_parse_phandle(of_node, supply_name, 0);
  245. if (!supply_root_node) {
  246. pr_debug("No supply entry present for %s\n",
  247. supply_name);
  248. return -EINVAL;
  249. }
  250. }
  251. for_each_child_of_node(supply_root_node, supply_node)
  252. regs->count++;
  253. if (regs->count == 0) {
  254. pr_err("No vregs defined for %s\n", supply_name);
  255. return -EINVAL;
  256. }
  257. regs->vregs = devm_kcalloc(dev, regs->count, sizeof(*regs->vregs),
  258. GFP_KERNEL);
  259. if (!regs->vregs) {
  260. regs->count = 0;
  261. return -ENOMEM;
  262. }
  263. utils.data = of_node;
  264. utils.node = of_node;
  265. rc = dsi_pwr_parse_supply_node(&utils, supply_root_node, regs);
  266. if (rc) {
  267. pr_err("failed to parse supply node for %s, rc = %d\n",
  268. supply_name, rc);
  269. devm_kfree(dev, regs->vregs);
  270. regs->vregs = NULL;
  271. regs->count = 0;
  272. }
  273. return rc;
  274. }
  275. /**
  276. * dsi_pwr_enable_regulator() - enable a set of regulators
  277. * @regs: Pointer to set of regulators to enable or disable.
  278. * @enable: Enable/Disable regulators.
  279. *
  280. * return: error code in case of failure or 0 for success.
  281. */
  282. int dsi_pwr_enable_regulator(struct dsi_regulator_info *regs, bool enable)
  283. {
  284. int rc = 0;
  285. if (regs->count == 0) {
  286. pr_debug("No valid regulators to enable\n");
  287. return 0;
  288. }
  289. if (!regs->vregs) {
  290. pr_err("Invalid params\n");
  291. return -EINVAL;
  292. }
  293. if (enable) {
  294. if (regs->refcount == 0) {
  295. rc = dsi_pwr_enable_vregs(regs, true);
  296. if (rc)
  297. pr_err("failed to enable regulators\n");
  298. }
  299. regs->refcount++;
  300. } else {
  301. if (regs->refcount == 0) {
  302. pr_err("Unbalanced regulator off:%s\n",
  303. regs->vregs->vreg_name);
  304. } else {
  305. regs->refcount--;
  306. if (regs->refcount == 0) {
  307. rc = dsi_pwr_enable_vregs(regs, false);
  308. if (rc)
  309. pr_err("failed to disable vregs\n");
  310. }
  311. }
  312. }
  313. return rc;
  314. }