watchdog: zx2967: add watchdog controller driver for ZTE's zx2967 family
[linux-2.6-microblaze.git] / drivers / leds / leds-powernv.c
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 int 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 token;
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 = opal_get_async_rc(msg);
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         return rc;
129 }
130
131 /*
132  * This function fetches the LED state for a given LED type for
133  * mentioned LED classdev structure.
134  */
135 static enum led_brightness powernv_led_get(struct powernv_led_data *powernv_led)
136 {
137         int rc;
138         __be64 mask, value, max_type;
139         u64 led_mask, led_value;
140         struct device *dev = powernv_led->cdev.dev;
141         struct powernv_led_common *powernv_led_common = powernv_led->common;
142
143         /* Fetch all LED status */
144         mask = cpu_to_be64(0);
145         value = cpu_to_be64(0);
146         max_type = powernv_led_common->max_led_type;
147
148         rc = opal_leds_get_ind(powernv_led->loc_code,
149                                &mask, &value, &max_type);
150         if (rc != OPAL_SUCCESS && rc != OPAL_PARTIAL) {
151                 dev_err(dev, "%s: OPAL get led call failed [rc=%d]\n",
152                         __func__, rc);
153                 return LED_OFF;
154         }
155
156         led_mask = be64_to_cpu(mask);
157         led_value = be64_to_cpu(value);
158
159         /* LED status available */
160         if (!((led_mask >> powernv_led->led_type) & OPAL_SLOT_LED_STATE_ON)) {
161                 dev_err(dev, "%s: LED status not available for %s\n",
162                         __func__, powernv_led->cdev.name);
163                 return LED_OFF;
164         }
165
166         /* LED status value */
167         if ((led_value >> powernv_led->led_type) & OPAL_SLOT_LED_STATE_ON)
168                 return LED_FULL;
169
170         return LED_OFF;
171 }
172
173 /*
174  * LED classdev 'brightness_get' function. This schedules work
175  * to update LED state.
176  */
177 static int powernv_brightness_set(struct led_classdev *led_cdev,
178                                    enum led_brightness value)
179 {
180         struct powernv_led_data *powernv_led =
181                 container_of(led_cdev, struct powernv_led_data, cdev);
182         struct powernv_led_common *powernv_led_common = powernv_led->common;
183         int rc;
184
185         /* Do not modify LED in unload path */
186         if (powernv_led_common->led_disabled)
187                 return 0;
188
189         mutex_lock(&powernv_led_common->lock);
190         rc = powernv_led_set(powernv_led, value);
191         mutex_unlock(&powernv_led_common->lock);
192
193         return rc;
194 }
195
196 /* LED classdev 'brightness_get' function */
197 static enum led_brightness powernv_brightness_get(struct led_classdev *led_cdev)
198 {
199         struct powernv_led_data *powernv_led =
200                 container_of(led_cdev, struct powernv_led_data, cdev);
201
202         return powernv_led_get(powernv_led);
203 }
204
205 /*
206  * This function registers classdev structure for any given type of LED on
207  * a given child LED device node.
208  */
209 static int powernv_led_create(struct device *dev,
210                               struct powernv_led_data *powernv_led,
211                               const char *led_type_desc)
212 {
213         int rc;
214
215         /* Make sure LED type is supported */
216         powernv_led->led_type = powernv_get_led_type(led_type_desc);
217         if (powernv_led->led_type == -1) {
218                 dev_warn(dev, "%s: No support for led type : %s\n",
219                          __func__, led_type_desc);
220                 return -EINVAL;
221         }
222
223         /* Create the name for classdev */
224         powernv_led->cdev.name = devm_kasprintf(dev, GFP_KERNEL, "%s:%s",
225                                                 powernv_led->loc_code,
226                                                 led_type_desc);
227         if (!powernv_led->cdev.name) {
228                 dev_err(dev,
229                         "%s: Memory allocation failed for classdev name\n",
230                         __func__);
231                 return -ENOMEM;
232         }
233
234         powernv_led->cdev.brightness_set_blocking = powernv_brightness_set;
235         powernv_led->cdev.brightness_get = powernv_brightness_get;
236         powernv_led->cdev.brightness = LED_OFF;
237         powernv_led->cdev.max_brightness = LED_FULL;
238
239         /* Register the classdev */
240         rc = devm_led_classdev_register(dev, &powernv_led->cdev);
241         if (rc) {
242                 dev_err(dev, "%s: Classdev registration failed for %s\n",
243                         __func__, powernv_led->cdev.name);
244         }
245
246         return rc;
247 }
248
249 /* Go through LED device tree node and register LED classdev structure */
250 static int powernv_led_classdev(struct platform_device *pdev,
251                                 struct device_node *led_node,
252                                 struct powernv_led_common *powernv_led_common)
253 {
254         const char *cur = NULL;
255         int rc = -1;
256         struct property *p;
257         struct device_node *np;
258         struct powernv_led_data *powernv_led;
259         struct device *dev = &pdev->dev;
260
261         for_each_child_of_node(led_node, np) {
262                 p = of_find_property(np, "led-types", NULL);
263
264                 while ((cur = of_prop_next_string(p, cur)) != NULL) {
265                         powernv_led = devm_kzalloc(dev, sizeof(*powernv_led),
266                                                    GFP_KERNEL);
267                         if (!powernv_led) {
268                                 of_node_put(np);
269                                 return -ENOMEM;
270                         }
271
272                         powernv_led->common = powernv_led_common;
273                         powernv_led->loc_code = (char *)np->name;
274
275                         rc = powernv_led_create(dev, powernv_led, cur);
276                         if (rc) {
277                                 of_node_put(np);
278                                 return rc;
279                         }
280                 } /* while end */
281         }
282
283         return rc;
284 }
285
286 /* Platform driver probe */
287 static int powernv_led_probe(struct platform_device *pdev)
288 {
289         struct device_node *led_node;
290         struct powernv_led_common *powernv_led_common;
291         struct device *dev = &pdev->dev;
292
293         led_node = of_find_node_by_path("/ibm,opal/leds");
294         if (!led_node) {
295                 dev_err(dev, "%s: LED parent device node not found\n",
296                         __func__);
297                 return -EINVAL;
298         }
299
300         powernv_led_common = devm_kzalloc(dev, sizeof(*powernv_led_common),
301                                           GFP_KERNEL);
302         if (!powernv_led_common)
303                 return -ENOMEM;
304
305         mutex_init(&powernv_led_common->lock);
306         powernv_led_common->max_led_type = cpu_to_be64(OPAL_SLOT_LED_TYPE_MAX);
307
308         platform_set_drvdata(pdev, powernv_led_common);
309
310         return powernv_led_classdev(pdev, led_node, powernv_led_common);
311 }
312
313 /* Platform driver remove */
314 static int powernv_led_remove(struct platform_device *pdev)
315 {
316         struct powernv_led_common *powernv_led_common;
317
318         /* Disable LED operation */
319         powernv_led_common = platform_get_drvdata(pdev);
320         powernv_led_common->led_disabled = true;
321
322         /* Destroy lock */
323         mutex_destroy(&powernv_led_common->lock);
324
325         dev_info(&pdev->dev, "PowerNV led module unregistered\n");
326         return 0;
327 }
328
329 /* Platform driver property match */
330 static const struct of_device_id powernv_led_match[] = {
331         {
332                 .compatible     = "ibm,opal-v3-led",
333         },
334         {},
335 };
336 MODULE_DEVICE_TABLE(of, powernv_led_match);
337
338 static struct platform_driver powernv_led_driver = {
339         .probe  = powernv_led_probe,
340         .remove = powernv_led_remove,
341         .driver = {
342                 .name = "powernv-led-driver",
343                 .of_match_table = powernv_led_match,
344         },
345 };
346
347 module_platform_driver(powernv_led_driver);
348
349 MODULE_LICENSE("GPL v2");
350 MODULE_DESCRIPTION("PowerNV LED driver");
351 MODULE_AUTHOR("Vasant Hegde <hegdevasant@linux.vnet.ibm.com>");