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 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>");