scmi-regulator.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421
  1. // SPDX-License-Identifier: GPL-2.0
  2. //
  3. // System Control and Management Interface (SCMI) based regulator driver
  4. //
  5. // Copyright (C) 2020 ARM Ltd.
  6. //
  7. // Implements a regulator driver on top of the SCMI Voltage Protocol.
  8. //
  9. // The ARM SCMI Protocol aims in general to hide as much as possible all the
  10. // underlying operational details while providing an abstracted interface for
  11. // its users to operate upon: as a consequence the resulting operational
  12. // capabilities and configurability of this regulator device are much more
  13. // limited than the ones usually available on a standard physical regulator.
  14. //
  15. // The supported SCMI regulator ops are restricted to the bare minimum:
  16. //
  17. // - 'status_ops': enable/disable/is_enabled
  18. // - 'voltage_ops': get_voltage_sel/set_voltage_sel
  19. // list_voltage/map_voltage
  20. //
  21. // Each SCMI regulator instance is associated, through the means of a proper DT
  22. // entry description, to a specific SCMI Voltage Domain.
  23. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  24. #include <linux/linear_range.h>
  25. #include <linux/module.h>
  26. #include <linux/of.h>
  27. #include <linux/regulator/driver.h>
  28. #include <linux/regulator/machine.h>
  29. #include <linux/regulator/of_regulator.h>
  30. #include <linux/scmi_protocol.h>
  31. #include <linux/slab.h>
  32. #include <linux/types.h>
  33. static const struct scmi_voltage_proto_ops *voltage_ops;
  34. struct scmi_regulator {
  35. u32 id;
  36. struct scmi_device *sdev;
  37. struct scmi_protocol_handle *ph;
  38. struct regulator_dev *rdev;
  39. struct device_node *of_node;
  40. struct regulator_desc desc;
  41. struct regulator_config conf;
  42. };
  43. struct scmi_regulator_info {
  44. int num_doms;
  45. struct scmi_regulator **sregv;
  46. };
  47. static int scmi_reg_enable(struct regulator_dev *rdev)
  48. {
  49. struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
  50. return voltage_ops->config_set(sreg->ph, sreg->id,
  51. SCMI_VOLTAGE_ARCH_STATE_ON);
  52. }
  53. static int scmi_reg_disable(struct regulator_dev *rdev)
  54. {
  55. struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
  56. return voltage_ops->config_set(sreg->ph, sreg->id,
  57. SCMI_VOLTAGE_ARCH_STATE_OFF);
  58. }
  59. static int scmi_reg_is_enabled(struct regulator_dev *rdev)
  60. {
  61. int ret;
  62. u32 config;
  63. struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
  64. ret = voltage_ops->config_get(sreg->ph, sreg->id, &config);
  65. if (ret) {
  66. dev_err(&sreg->sdev->dev,
  67. "Error %d reading regulator %s status.\n",
  68. ret, sreg->desc.name);
  69. return ret;
  70. }
  71. return config & SCMI_VOLTAGE_ARCH_STATE_ON;
  72. }
  73. static int scmi_reg_get_voltage_sel(struct regulator_dev *rdev)
  74. {
  75. int ret;
  76. s32 volt_uV;
  77. struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
  78. ret = voltage_ops->level_get(sreg->ph, sreg->id, &volt_uV);
  79. if (ret)
  80. return ret;
  81. return sreg->desc.ops->map_voltage(rdev, volt_uV, volt_uV);
  82. }
  83. static int scmi_reg_set_voltage_sel(struct regulator_dev *rdev,
  84. unsigned int selector)
  85. {
  86. s32 volt_uV;
  87. struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
  88. volt_uV = sreg->desc.ops->list_voltage(rdev, selector);
  89. if (volt_uV <= 0)
  90. return -EINVAL;
  91. return voltage_ops->level_set(sreg->ph, sreg->id, 0x0, volt_uV);
  92. }
  93. static const struct regulator_ops scmi_reg_fixed_ops = {
  94. .enable = scmi_reg_enable,
  95. .disable = scmi_reg_disable,
  96. .is_enabled = scmi_reg_is_enabled,
  97. };
  98. static const struct regulator_ops scmi_reg_linear_ops = {
  99. .enable = scmi_reg_enable,
  100. .disable = scmi_reg_disable,
  101. .is_enabled = scmi_reg_is_enabled,
  102. .get_voltage_sel = scmi_reg_get_voltage_sel,
  103. .set_voltage_sel = scmi_reg_set_voltage_sel,
  104. .list_voltage = regulator_list_voltage_linear,
  105. .map_voltage = regulator_map_voltage_linear,
  106. };
  107. static const struct regulator_ops scmi_reg_discrete_ops = {
  108. .enable = scmi_reg_enable,
  109. .disable = scmi_reg_disable,
  110. .is_enabled = scmi_reg_is_enabled,
  111. .get_voltage_sel = scmi_reg_get_voltage_sel,
  112. .set_voltage_sel = scmi_reg_set_voltage_sel,
  113. .list_voltage = regulator_list_voltage_table,
  114. .map_voltage = regulator_map_voltage_iterate,
  115. };
  116. static int
  117. scmi_config_linear_regulator_mappings(struct scmi_regulator *sreg,
  118. const struct scmi_voltage_info *vinfo)
  119. {
  120. s32 delta_uV;
  121. /*
  122. * Note that SCMI voltage domains describable by linear ranges
  123. * (segments) {low, high, step} are guaranteed to come in one single
  124. * triplet by the SCMI Voltage Domain protocol support itself.
  125. */
  126. delta_uV = (vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_HIGH] -
  127. vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW]);
  128. /* Rule out buggy negative-intervals answers from fw */
  129. if (delta_uV < 0) {
  130. dev_err(&sreg->sdev->dev,
  131. "Invalid volt-range %d-%duV for domain %d\n",
  132. vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW],
  133. vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_HIGH],
  134. sreg->id);
  135. return -EINVAL;
  136. }
  137. if (!delta_uV) {
  138. /* Just one fixed voltage exposed by SCMI */
  139. sreg->desc.fixed_uV =
  140. vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW];
  141. sreg->desc.n_voltages = 1;
  142. sreg->desc.ops = &scmi_reg_fixed_ops;
  143. } else {
  144. /* One simple linear mapping. */
  145. sreg->desc.min_uV =
  146. vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW];
  147. sreg->desc.uV_step =
  148. vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_STEP];
  149. sreg->desc.linear_min_sel = 0;
  150. sreg->desc.n_voltages = (delta_uV / sreg->desc.uV_step) + 1;
  151. sreg->desc.ops = &scmi_reg_linear_ops;
  152. }
  153. return 0;
  154. }
  155. static int
  156. scmi_config_discrete_regulator_mappings(struct scmi_regulator *sreg,
  157. const struct scmi_voltage_info *vinfo)
  158. {
  159. /* Discrete non linear levels are mapped to volt_table */
  160. sreg->desc.n_voltages = vinfo->num_levels;
  161. if (sreg->desc.n_voltages > 1) {
  162. sreg->desc.volt_table = (const unsigned int *)vinfo->levels_uv;
  163. sreg->desc.ops = &scmi_reg_discrete_ops;
  164. } else {
  165. sreg->desc.fixed_uV = vinfo->levels_uv[0];
  166. sreg->desc.ops = &scmi_reg_fixed_ops;
  167. }
  168. return 0;
  169. }
  170. static int scmi_regulator_common_init(struct scmi_regulator *sreg)
  171. {
  172. int ret;
  173. struct device *dev = &sreg->sdev->dev;
  174. const struct scmi_voltage_info *vinfo;
  175. vinfo = voltage_ops->info_get(sreg->ph, sreg->id);
  176. if (!vinfo) {
  177. dev_warn(dev, "Failure to get voltage domain %d\n",
  178. sreg->id);
  179. return -ENODEV;
  180. }
  181. /*
  182. * Regulator framework does not fully support negative voltages
  183. * so we discard any voltage domain reported as supporting negative
  184. * voltages: as a consequence each levels_uv entry is guaranteed to
  185. * be non-negative from here on.
  186. */
  187. if (vinfo->negative_volts_allowed) {
  188. dev_warn(dev, "Negative voltages NOT supported...skip %s\n",
  189. sreg->of_node->full_name);
  190. return -EOPNOTSUPP;
  191. }
  192. sreg->desc.name = devm_kasprintf(dev, GFP_KERNEL, "%s", vinfo->name);
  193. if (!sreg->desc.name)
  194. return -ENOMEM;
  195. sreg->desc.id = sreg->id;
  196. sreg->desc.type = REGULATOR_VOLTAGE;
  197. sreg->desc.owner = THIS_MODULE;
  198. sreg->desc.of_match_full_name = true;
  199. sreg->desc.of_match = sreg->of_node->full_name;
  200. sreg->desc.regulators_node = "regulators";
  201. if (vinfo->segmented)
  202. ret = scmi_config_linear_regulator_mappings(sreg, vinfo);
  203. else
  204. ret = scmi_config_discrete_regulator_mappings(sreg, vinfo);
  205. if (ret)
  206. return ret;
  207. /*
  208. * Using the scmi device here to have DT searched from Voltage
  209. * protocol node down.
  210. */
  211. sreg->conf.dev = dev;
  212. /* Store for later retrieval via rdev_get_drvdata() */
  213. sreg->conf.driver_data = sreg;
  214. return 0;
  215. }
  216. static int process_scmi_regulator_of_node(struct scmi_device *sdev,
  217. struct scmi_protocol_handle *ph,
  218. struct device_node *np,
  219. struct scmi_regulator_info *rinfo)
  220. {
  221. u32 dom, ret;
  222. ret = of_property_read_u32(np, "reg", &dom);
  223. if (ret)
  224. return ret;
  225. if (dom >= rinfo->num_doms)
  226. return -ENODEV;
  227. if (rinfo->sregv[dom]) {
  228. dev_err(&sdev->dev,
  229. "SCMI Voltage Domain %d already in use. Skipping: %s\n",
  230. dom, np->full_name);
  231. return -EINVAL;
  232. }
  233. rinfo->sregv[dom] = devm_kzalloc(&sdev->dev,
  234. sizeof(struct scmi_regulator),
  235. GFP_KERNEL);
  236. if (!rinfo->sregv[dom])
  237. return -ENOMEM;
  238. rinfo->sregv[dom]->id = dom;
  239. rinfo->sregv[dom]->sdev = sdev;
  240. rinfo->sregv[dom]->ph = ph;
  241. /* get hold of good nodes */
  242. of_node_get(np);
  243. rinfo->sregv[dom]->of_node = np;
  244. dev_dbg(&sdev->dev,
  245. "Found SCMI Regulator entry -- OF node [%d] -> %s\n",
  246. dom, np->full_name);
  247. return 0;
  248. }
  249. static int scmi_regulator_probe(struct scmi_device *sdev)
  250. {
  251. int d, ret, num_doms;
  252. struct device_node *np, *child;
  253. const struct scmi_handle *handle = sdev->handle;
  254. struct scmi_regulator_info *rinfo;
  255. struct scmi_protocol_handle *ph;
  256. if (!handle)
  257. return -ENODEV;
  258. voltage_ops = handle->devm_get_protocol(sdev,
  259. SCMI_PROTOCOL_VOLTAGE, &ph);
  260. if (IS_ERR(voltage_ops))
  261. return PTR_ERR(voltage_ops);
  262. num_doms = voltage_ops->num_domains_get(ph);
  263. if (num_doms <= 0) {
  264. if (!num_doms) {
  265. dev_err(&sdev->dev,
  266. "number of voltage domains invalid\n");
  267. num_doms = -EINVAL;
  268. } else {
  269. dev_err(&sdev->dev,
  270. "failed to get voltage domains - err:%d\n",
  271. num_doms);
  272. }
  273. return num_doms;
  274. }
  275. rinfo = devm_kzalloc(&sdev->dev, sizeof(*rinfo), GFP_KERNEL);
  276. if (!rinfo)
  277. return -ENOMEM;
  278. /* Allocate pointers array for all possible domains */
  279. rinfo->sregv = devm_kcalloc(&sdev->dev, num_doms,
  280. sizeof(void *), GFP_KERNEL);
  281. if (!rinfo->sregv)
  282. return -ENOMEM;
  283. rinfo->num_doms = num_doms;
  284. /*
  285. * Start collecting into rinfo->sregv possibly good SCMI Regulators as
  286. * described by a well-formed DT entry and associated with an existing
  287. * plausible SCMI Voltage Domain number, all belonging to this SCMI
  288. * platform instance node (handle->dev->of_node).
  289. */
  290. np = of_find_node_by_name(handle->dev->of_node, "regulators");
  291. for_each_child_of_node(np, child) {
  292. ret = process_scmi_regulator_of_node(sdev, ph, child, rinfo);
  293. /* abort on any mem issue */
  294. if (ret == -ENOMEM)
  295. return ret;
  296. }
  297. /*
  298. * Register a regulator for each valid regulator-DT-entry that we
  299. * can successfully reach via SCMI and has a valid associated voltage
  300. * domain.
  301. */
  302. for (d = 0; d < num_doms; d++) {
  303. struct scmi_regulator *sreg = rinfo->sregv[d];
  304. /* Skip empty slots */
  305. if (!sreg)
  306. continue;
  307. ret = scmi_regulator_common_init(sreg);
  308. /* Skip invalid voltage domains */
  309. if (ret)
  310. continue;
  311. sreg->rdev = devm_regulator_register(&sdev->dev, &sreg->desc,
  312. &sreg->conf);
  313. if (IS_ERR(sreg->rdev)) {
  314. sreg->rdev = NULL;
  315. continue;
  316. }
  317. dev_info(&sdev->dev,
  318. "Regulator %s registered for domain [%d]\n",
  319. sreg->desc.name, sreg->id);
  320. }
  321. dev_set_drvdata(&sdev->dev, rinfo);
  322. return 0;
  323. }
  324. static void scmi_regulator_remove(struct scmi_device *sdev)
  325. {
  326. int d;
  327. struct scmi_regulator_info *rinfo;
  328. rinfo = dev_get_drvdata(&sdev->dev);
  329. if (!rinfo)
  330. return;
  331. for (d = 0; d < rinfo->num_doms; d++) {
  332. if (!rinfo->sregv[d])
  333. continue;
  334. of_node_put(rinfo->sregv[d]->of_node);
  335. }
  336. }
  337. static const struct scmi_device_id scmi_regulator_id_table[] = {
  338. { SCMI_PROTOCOL_VOLTAGE, "regulator" },
  339. { },
  340. };
  341. MODULE_DEVICE_TABLE(scmi, scmi_regulator_id_table);
  342. static struct scmi_driver scmi_drv = {
  343. .name = "scmi-regulator",
  344. .probe = scmi_regulator_probe,
  345. .remove = scmi_regulator_remove,
  346. .id_table = scmi_regulator_id_table,
  347. };
  348. module_scmi_driver(scmi_drv);
  349. MODULE_AUTHOR("Cristian Marussi <cristian.marussi@arm.com>");
  350. MODULE_DESCRIPTION("ARM SCMI regulator driver");
  351. MODULE_LICENSE("GPL v2");