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