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