leds-powernv.c 8.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * PowerNV LED Driver
  4. *
  5. * Copyright IBM Corp. 2015
  6. *
  7. * Author: Vasant Hegde <hegdevasant@linux.vnet.ibm.com>
  8. * Author: Anshuman Khandual <khandual@linux.vnet.ibm.com>
  9. */
  10. #include <linux/leds.h>
  11. #include <linux/module.h>
  12. #include <linux/of.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/slab.h>
  15. #include <linux/types.h>
  16. #include <asm/opal.h>
  17. /* Map LED type to description. */
  18. struct led_type_map {
  19. const int type;
  20. const char *desc;
  21. };
  22. static const struct led_type_map led_type_map[] = {
  23. {OPAL_SLOT_LED_TYPE_ID, "identify"},
  24. {OPAL_SLOT_LED_TYPE_FAULT, "fault"},
  25. {OPAL_SLOT_LED_TYPE_ATTN, "attention"},
  26. {-1, NULL},
  27. };
  28. struct powernv_led_common {
  29. /*
  30. * By default unload path resets all the LEDs. But on PowerNV
  31. * platform we want to retain LED state across reboot as these
  32. * are controlled by firmware. Also service processor can modify
  33. * the LEDs independent of OS. Hence avoid resetting LEDs in
  34. * unload path.
  35. */
  36. bool led_disabled;
  37. /* Max supported LED type */
  38. __be64 max_led_type;
  39. /* glabal lock */
  40. struct mutex lock;
  41. };
  42. /* PowerNV LED data */
  43. struct powernv_led_data {
  44. struct led_classdev cdev;
  45. char *loc_code; /* LED location code */
  46. int led_type; /* OPAL_SLOT_LED_TYPE_* */
  47. struct powernv_led_common *common;
  48. };
  49. /* Returns OPAL_SLOT_LED_TYPE_* for given led type string */
  50. static int powernv_get_led_type(const char *led_type_desc)
  51. {
  52. int i;
  53. for (i = 0; i < ARRAY_SIZE(led_type_map); i++)
  54. if (!strcmp(led_type_map[i].desc, led_type_desc))
  55. return led_type_map[i].type;
  56. return -1;
  57. }
  58. /*
  59. * This commits the state change of the requested LED through an OPAL call.
  60. * This function is called from work queue task context when ever it gets
  61. * scheduled. This function can sleep at opal_async_wait_response call.
  62. */
  63. static int powernv_led_set(struct powernv_led_data *powernv_led,
  64. enum led_brightness value)
  65. {
  66. int rc, token;
  67. u64 led_mask, led_value = 0;
  68. __be64 max_type;
  69. struct opal_msg msg;
  70. struct device *dev = powernv_led->cdev.dev;
  71. struct powernv_led_common *powernv_led_common = powernv_led->common;
  72. /* Prepare for the OPAL call */
  73. max_type = powernv_led_common->max_led_type;
  74. led_mask = OPAL_SLOT_LED_STATE_ON << powernv_led->led_type;
  75. if (value)
  76. led_value = led_mask;
  77. /* OPAL async call */
  78. token = opal_async_get_token_interruptible();
  79. if (token < 0) {
  80. if (token != -ERESTARTSYS)
  81. dev_err(dev, "%s: Couldn't get OPAL async token\n",
  82. __func__);
  83. return token;
  84. }
  85. rc = opal_leds_set_ind(token, powernv_led->loc_code,
  86. led_mask, led_value, &max_type);
  87. if (rc != OPAL_ASYNC_COMPLETION) {
  88. dev_err(dev, "%s: OPAL set LED call failed for %s [rc=%d]\n",
  89. __func__, powernv_led->loc_code, rc);
  90. goto out_token;
  91. }
  92. rc = opal_async_wait_response(token, &msg);
  93. if (rc) {
  94. dev_err(dev,
  95. "%s: Failed to wait for the async response [rc=%d]\n",
  96. __func__, rc);
  97. goto out_token;
  98. }
  99. rc = opal_get_async_rc(msg);
  100. if (rc != OPAL_SUCCESS)
  101. dev_err(dev, "%s : OAPL async call returned failed [rc=%d]\n",
  102. __func__, rc);
  103. out_token:
  104. opal_async_release_token(token);
  105. return rc;
  106. }
  107. /*
  108. * This function fetches the LED state for a given LED type for
  109. * mentioned LED classdev structure.
  110. */
  111. static enum led_brightness powernv_led_get(struct powernv_led_data *powernv_led)
  112. {
  113. int rc;
  114. __be64 mask, value, max_type;
  115. u64 led_mask, led_value;
  116. struct device *dev = powernv_led->cdev.dev;
  117. struct powernv_led_common *powernv_led_common = powernv_led->common;
  118. /* Fetch all LED status */
  119. mask = cpu_to_be64(0);
  120. value = cpu_to_be64(0);
  121. max_type = powernv_led_common->max_led_type;
  122. rc = opal_leds_get_ind(powernv_led->loc_code,
  123. &mask, &value, &max_type);
  124. if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL) {
  125. dev_err(dev, "%s: OPAL get led call failed [rc=%d]\n",
  126. __func__, rc);
  127. return LED_OFF;
  128. }
  129. led_mask = be64_to_cpu(mask);
  130. led_value = be64_to_cpu(value);
  131. /* LED status available */
  132. if (!((led_mask >> powernv_led->led_type) & OPAL_SLOT_LED_STATE_ON)) {
  133. dev_err(dev, "%s: LED status not available for %s\n",
  134. __func__, powernv_led->cdev.name);
  135. return LED_OFF;
  136. }
  137. /* LED status value */
  138. if ((led_value >> powernv_led->led_type) & OPAL_SLOT_LED_STATE_ON)
  139. return LED_FULL;
  140. return LED_OFF;
  141. }
  142. /*
  143. * LED classdev 'brightness_get' function. This schedules work
  144. * to update LED state.
  145. */
  146. static int powernv_brightness_set(struct led_classdev *led_cdev,
  147. enum led_brightness value)
  148. {
  149. struct powernv_led_data *powernv_led =
  150. container_of(led_cdev, struct powernv_led_data, cdev);
  151. struct powernv_led_common *powernv_led_common = powernv_led->common;
  152. int rc;
  153. /* Do not modify LED in unload path */
  154. if (powernv_led_common->led_disabled)
  155. return 0;
  156. mutex_lock(&powernv_led_common->lock);
  157. rc = powernv_led_set(powernv_led, value);
  158. mutex_unlock(&powernv_led_common->lock);
  159. return rc;
  160. }
  161. /* LED classdev 'brightness_get' function */
  162. static enum led_brightness powernv_brightness_get(struct led_classdev *led_cdev)
  163. {
  164. struct powernv_led_data *powernv_led =
  165. container_of(led_cdev, struct powernv_led_data, cdev);
  166. return powernv_led_get(powernv_led);
  167. }
  168. /*
  169. * This function registers classdev structure for any given type of LED on
  170. * a given child LED device node.
  171. */
  172. static int powernv_led_create(struct device *dev,
  173. struct powernv_led_data *powernv_led,
  174. const char *led_type_desc)
  175. {
  176. int rc;
  177. /* Make sure LED type is supported */
  178. powernv_led->led_type = powernv_get_led_type(led_type_desc);
  179. if (powernv_led->led_type == -1) {
  180. dev_warn(dev, "%s: No support for led type : %s\n",
  181. __func__, led_type_desc);
  182. return -EINVAL;
  183. }
  184. /* Create the name for classdev */
  185. powernv_led->cdev.name = devm_kasprintf(dev, GFP_KERNEL, "%s:%s",
  186. powernv_led->loc_code,
  187. led_type_desc);
  188. if (!powernv_led->cdev.name)
  189. return -ENOMEM;
  190. powernv_led->cdev.brightness_set_blocking = powernv_brightness_set;
  191. powernv_led->cdev.brightness_get = powernv_brightness_get;
  192. powernv_led->cdev.brightness = LED_OFF;
  193. powernv_led->cdev.max_brightness = LED_FULL;
  194. /* Register the classdev */
  195. rc = devm_led_classdev_register(dev, &powernv_led->cdev);
  196. if (rc) {
  197. dev_err(dev, "%s: Classdev registration failed for %s\n",
  198. __func__, powernv_led->cdev.name);
  199. }
  200. return rc;
  201. }
  202. /* Go through LED device tree node and register LED classdev structure */
  203. static int powernv_led_classdev(struct platform_device *pdev,
  204. struct device_node *led_node,
  205. struct powernv_led_common *powernv_led_common)
  206. {
  207. const char *cur = NULL;
  208. int rc = -1;
  209. struct property *p;
  210. struct device_node *np;
  211. struct powernv_led_data *powernv_led;
  212. struct device *dev = &pdev->dev;
  213. for_each_available_child_of_node(led_node, np) {
  214. p = of_find_property(np, "led-types", NULL);
  215. while ((cur = of_prop_next_string(p, cur)) != NULL) {
  216. powernv_led = devm_kzalloc(dev, sizeof(*powernv_led),
  217. GFP_KERNEL);
  218. if (!powernv_led) {
  219. of_node_put(np);
  220. return -ENOMEM;
  221. }
  222. powernv_led->common = powernv_led_common;
  223. powernv_led->loc_code = (char *)np->name;
  224. rc = powernv_led_create(dev, powernv_led, cur);
  225. if (rc) {
  226. of_node_put(np);
  227. return rc;
  228. }
  229. } /* while end */
  230. }
  231. return rc;
  232. }
  233. /* Platform driver probe */
  234. static int powernv_led_probe(struct platform_device *pdev)
  235. {
  236. struct device_node *led_node;
  237. struct powernv_led_common *powernv_led_common;
  238. struct device *dev = &pdev->dev;
  239. int rc;
  240. led_node = of_find_node_by_path("/ibm,opal/leds");
  241. if (!led_node) {
  242. dev_err(dev, "%s: LED parent device node not found\n",
  243. __func__);
  244. return -EINVAL;
  245. }
  246. powernv_led_common = devm_kzalloc(dev, sizeof(*powernv_led_common),
  247. GFP_KERNEL);
  248. if (!powernv_led_common) {
  249. rc = -ENOMEM;
  250. goto out;
  251. }
  252. mutex_init(&powernv_led_common->lock);
  253. powernv_led_common->max_led_type = cpu_to_be64(OPAL_SLOT_LED_TYPE_MAX);
  254. platform_set_drvdata(pdev, powernv_led_common);
  255. rc = powernv_led_classdev(pdev, led_node, powernv_led_common);
  256. out:
  257. of_node_put(led_node);
  258. return rc;
  259. }
  260. /* Platform driver remove */
  261. static int powernv_led_remove(struct platform_device *pdev)
  262. {
  263. struct powernv_led_common *powernv_led_common;
  264. /* Disable LED operation */
  265. powernv_led_common = platform_get_drvdata(pdev);
  266. powernv_led_common->led_disabled = true;
  267. /* Destroy lock */
  268. mutex_destroy(&powernv_led_common->lock);
  269. dev_info(&pdev->dev, "PowerNV led module unregistered\n");
  270. return 0;
  271. }
  272. /* Platform driver property match */
  273. static const struct of_device_id powernv_led_match[] = {
  274. {
  275. .compatible = "ibm,opal-v3-led",
  276. },
  277. {},
  278. };
  279. MODULE_DEVICE_TABLE(of, powernv_led_match);
  280. static struct platform_driver powernv_led_driver = {
  281. .probe = powernv_led_probe,
  282. .remove = powernv_led_remove,
  283. .driver = {
  284. .name = "powernv-led-driver",
  285. .of_match_table = powernv_led_match,
  286. },
  287. };
  288. module_platform_driver(powernv_led_driver);
  289. MODULE_LICENSE("GPL v2");
  290. MODULE_DESCRIPTION("PowerNV LED driver");
  291. MODULE_AUTHOR("Vasant Hegde <hegdevasant@linux.vnet.ibm.com>");