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