1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * leds-netxbig.c - Driver for the 2Big and 5Big Network series LEDs 4 * 5 * Copyright (C) 2010 LaCie 6 * 7 * Author: Simon Guinot <sguinot@lacie.com> 8 */ 9 10 #include <linux/module.h> 11 #include <linux/irq.h> 12 #include <linux/slab.h> 13 #include <linux/spinlock.h> 14 #include <linux/platform_device.h> 15 #include <linux/gpio/consumer.h> 16 #include <linux/leds.h> 17 #include <linux/of.h> 18 #include <linux/of_platform.h> 19 20 struct netxbig_gpio_ext { 21 struct gpio_desc **addr; 22 int num_addr; 23 struct gpio_desc **data; 24 int num_data; 25 struct gpio_desc *enable; 26 }; 27 28 enum netxbig_led_mode { 29 NETXBIG_LED_OFF, 30 NETXBIG_LED_ON, 31 NETXBIG_LED_SATA, 32 NETXBIG_LED_TIMER1, 33 NETXBIG_LED_TIMER2, 34 NETXBIG_LED_MODE_NUM, 35 }; 36 37 #define NETXBIG_LED_INVALID_MODE NETXBIG_LED_MODE_NUM 38 39 struct netxbig_led_timer { 40 unsigned long delay_on; 41 unsigned long delay_off; 42 enum netxbig_led_mode mode; 43 }; 44 45 struct netxbig_led { 46 const char *name; 47 const char *default_trigger; 48 int mode_addr; 49 int *mode_val; 50 int bright_addr; 51 int bright_max; 52 }; 53 54 struct netxbig_led_platform_data { 55 struct netxbig_gpio_ext *gpio_ext; 56 struct netxbig_led_timer *timer; 57 int num_timer; 58 struct netxbig_led *leds; 59 int num_leds; 60 }; 61 62 /* 63 * GPIO extension bus. 64 */ 65 66 static DEFINE_SPINLOCK(gpio_ext_lock); 67 68 static void gpio_ext_set_addr(struct netxbig_gpio_ext *gpio_ext, int addr) 69 { 70 int pin; 71 72 for (pin = 0; pin < gpio_ext->num_addr; pin++) 73 gpiod_set_value(gpio_ext->addr[pin], (addr >> pin) & 1); 74 } 75 76 static void gpio_ext_set_data(struct netxbig_gpio_ext *gpio_ext, int data) 77 { 78 int pin; 79 80 for (pin = 0; pin < gpio_ext->num_data; pin++) 81 gpiod_set_value(gpio_ext->data[pin], (data >> pin) & 1); 82 } 83 84 static void gpio_ext_enable_select(struct netxbig_gpio_ext *gpio_ext) 85 { 86 /* Enable select is done on the raising edge. */ 87 gpiod_set_value(gpio_ext->enable, 0); 88 gpiod_set_value(gpio_ext->enable, 1); 89 } 90 91 static void gpio_ext_set_value(struct netxbig_gpio_ext *gpio_ext, 92 int addr, int value) 93 { 94 unsigned long flags; 95 96 spin_lock_irqsave(&gpio_ext_lock, flags); 97 gpio_ext_set_addr(gpio_ext, addr); 98 gpio_ext_set_data(gpio_ext, value); 99 gpio_ext_enable_select(gpio_ext); 100 spin_unlock_irqrestore(&gpio_ext_lock, flags); 101 } 102 103 /* 104 * Class LED driver. 105 */ 106 107 struct netxbig_led_data { 108 struct netxbig_gpio_ext *gpio_ext; 109 struct led_classdev cdev; 110 int mode_addr; 111 int *mode_val; 112 int bright_addr; 113 struct netxbig_led_timer *timer; 114 int num_timer; 115 enum netxbig_led_mode mode; 116 int sata; 117 spinlock_t lock; 118 }; 119 120 static int netxbig_led_get_timer_mode(enum netxbig_led_mode *mode, 121 unsigned long delay_on, 122 unsigned long delay_off, 123 struct netxbig_led_timer *timer, 124 int num_timer) 125 { 126 int i; 127 128 for (i = 0; i < num_timer; i++) { 129 if (timer[i].delay_on == delay_on && 130 timer[i].delay_off == delay_off) { 131 *mode = timer[i].mode; 132 return 0; 133 } 134 } 135 return -EINVAL; 136 } 137 138 static int netxbig_led_blink_set(struct led_classdev *led_cdev, 139 unsigned long *delay_on, 140 unsigned long *delay_off) 141 { 142 struct netxbig_led_data *led_dat = 143 container_of(led_cdev, struct netxbig_led_data, cdev); 144 enum netxbig_led_mode mode; 145 int mode_val; 146 int ret; 147 148 /* Look for a LED mode with the requested timer frequency. */ 149 ret = netxbig_led_get_timer_mode(&mode, *delay_on, *delay_off, 150 led_dat->timer, led_dat->num_timer); 151 if (ret < 0) 152 return ret; 153 154 mode_val = led_dat->mode_val[mode]; 155 if (mode_val == NETXBIG_LED_INVALID_MODE) 156 return -EINVAL; 157 158 spin_lock_irq(&led_dat->lock); 159 160 gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val); 161 led_dat->mode = mode; 162 163 spin_unlock_irq(&led_dat->lock); 164 165 return 0; 166 } 167 168 static void netxbig_led_set(struct led_classdev *led_cdev, 169 enum led_brightness value) 170 { 171 struct netxbig_led_data *led_dat = 172 container_of(led_cdev, struct netxbig_led_data, cdev); 173 enum netxbig_led_mode mode; 174 int mode_val; 175 int set_brightness = 1; 176 unsigned long flags; 177 178 spin_lock_irqsave(&led_dat->lock, flags); 179 180 if (value == LED_OFF) { 181 mode = NETXBIG_LED_OFF; 182 set_brightness = 0; 183 } else { 184 if (led_dat->sata) 185 mode = NETXBIG_LED_SATA; 186 else if (led_dat->mode == NETXBIG_LED_OFF) 187 mode = NETXBIG_LED_ON; 188 else /* Keep 'timer' mode. */ 189 mode = led_dat->mode; 190 } 191 mode_val = led_dat->mode_val[mode]; 192 193 gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val); 194 led_dat->mode = mode; 195 /* 196 * Note that the brightness register is shared between all the 197 * SATA LEDs. So, change the brightness setting for a single 198 * SATA LED will affect all the others. 199 */ 200 if (set_brightness) 201 gpio_ext_set_value(led_dat->gpio_ext, 202 led_dat->bright_addr, value); 203 204 spin_unlock_irqrestore(&led_dat->lock, flags); 205 } 206 207 static ssize_t netxbig_led_sata_store(struct device *dev, 208 struct device_attribute *attr, 209 const char *buff, size_t count) 210 { 211 struct led_classdev *led_cdev = dev_get_drvdata(dev); 212 struct netxbig_led_data *led_dat = 213 container_of(led_cdev, struct netxbig_led_data, cdev); 214 unsigned long enable; 215 enum netxbig_led_mode mode; 216 int mode_val; 217 int ret; 218 219 ret = kstrtoul(buff, 10, &enable); 220 if (ret < 0) 221 return ret; 222 223 enable = !!enable; 224 225 spin_lock_irq(&led_dat->lock); 226 227 if (led_dat->sata == enable) { 228 ret = count; 229 goto exit_unlock; 230 } 231 232 if (led_dat->mode != NETXBIG_LED_ON && 233 led_dat->mode != NETXBIG_LED_SATA) 234 mode = led_dat->mode; /* Keep modes 'off' and 'timer'. */ 235 else if (enable) 236 mode = NETXBIG_LED_SATA; 237 else 238 mode = NETXBIG_LED_ON; 239 240 mode_val = led_dat->mode_val[mode]; 241 if (mode_val == NETXBIG_LED_INVALID_MODE) { 242 ret = -EINVAL; 243 goto exit_unlock; 244 } 245 246 gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val); 247 led_dat->mode = mode; 248 led_dat->sata = enable; 249 250 ret = count; 251 252 exit_unlock: 253 spin_unlock_irq(&led_dat->lock); 254 255 return ret; 256 } 257 258 static ssize_t netxbig_led_sata_show(struct device *dev, 259 struct device_attribute *attr, char *buf) 260 { 261 struct led_classdev *led_cdev = dev_get_drvdata(dev); 262 struct netxbig_led_data *led_dat = 263 container_of(led_cdev, struct netxbig_led_data, cdev); 264 265 return sprintf(buf, "%d\n", led_dat->sata); 266 } 267 268 static DEVICE_ATTR(sata, 0644, netxbig_led_sata_show, netxbig_led_sata_store); 269 270 static struct attribute *netxbig_led_attrs[] = { 271 &dev_attr_sata.attr, 272 NULL 273 }; 274 ATTRIBUTE_GROUPS(netxbig_led); 275 276 static int create_netxbig_led(struct platform_device *pdev, 277 struct netxbig_led_platform_data *pdata, 278 struct netxbig_led_data *led_dat, 279 const struct netxbig_led *template) 280 { 281 spin_lock_init(&led_dat->lock); 282 led_dat->gpio_ext = pdata->gpio_ext; 283 led_dat->cdev.name = template->name; 284 led_dat->cdev.default_trigger = template->default_trigger; 285 led_dat->cdev.blink_set = netxbig_led_blink_set; 286 led_dat->cdev.brightness_set = netxbig_led_set; 287 /* 288 * Because the GPIO extension bus don't allow to read registers 289 * value, there is no way to probe the LED initial state. 290 * So, the initial sysfs LED value for the "brightness" and "sata" 291 * attributes are inconsistent. 292 * 293 * Note that the initial LED state can't be reconfigured. 294 * The reason is that the LED behaviour must stay uniform during 295 * the whole boot process (bootloader+linux). 296 */ 297 led_dat->sata = 0; 298 led_dat->cdev.brightness = LED_OFF; 299 led_dat->cdev.max_brightness = template->bright_max; 300 led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME; 301 led_dat->mode_addr = template->mode_addr; 302 led_dat->mode_val = template->mode_val; 303 led_dat->bright_addr = template->bright_addr; 304 led_dat->timer = pdata->timer; 305 led_dat->num_timer = pdata->num_timer; 306 /* 307 * If available, expose the SATA activity blink capability through 308 * a "sata" sysfs attribute. 309 */ 310 if (led_dat->mode_val[NETXBIG_LED_SATA] != NETXBIG_LED_INVALID_MODE) 311 led_dat->cdev.groups = netxbig_led_groups; 312 313 return devm_led_classdev_register(&pdev->dev, &led_dat->cdev); 314 } 315 316 /** 317 * netxbig_gpio_ext_remove() - Clean up GPIO extension data 318 * @data: managed resource data to clean up 319 * 320 * Since we pick GPIO descriptors from another device than the device our 321 * driver is probing to, we need to register a specific callback to free 322 * these up using managed resources. 323 */ 324 static void netxbig_gpio_ext_remove(void *data) 325 { 326 struct netxbig_gpio_ext *gpio_ext = data; 327 int i; 328 329 for (i = 0; i < gpio_ext->num_addr; i++) 330 gpiod_put(gpio_ext->addr[i]); 331 for (i = 0; i < gpio_ext->num_data; i++) 332 gpiod_put(gpio_ext->data[i]); 333 gpiod_put(gpio_ext->enable); 334 } 335 336 /** 337 * netxbig_gpio_ext_get() - Obtain GPIO extension device data 338 * @dev: main LED device 339 * @gpio_ext_dev: the GPIO extension device 340 * @gpio_ext: the data structure holding the GPIO extension data 341 * 342 * This function walks the subdevice that only contain GPIO line 343 * handles in the device tree and obtains the GPIO descriptors from that 344 * device. 345 */ 346 static int netxbig_gpio_ext_get(struct device *dev, 347 struct device *gpio_ext_dev, 348 struct netxbig_gpio_ext *gpio_ext) 349 { 350 struct gpio_desc **addr, **data; 351 int num_addr, num_data; 352 struct gpio_desc *gpiod; 353 int ret; 354 int i; 355 356 ret = gpiod_count(gpio_ext_dev, "addr"); 357 if (ret < 0) { 358 dev_err(dev, 359 "Failed to count GPIOs in DT property addr-gpios\n"); 360 return ret; 361 } 362 num_addr = ret; 363 addr = devm_kcalloc(dev, num_addr, sizeof(*addr), GFP_KERNEL); 364 if (!addr) 365 return -ENOMEM; 366 367 /* 368 * We cannot use devm_ managed resources with these GPIO descriptors 369 * since they are associated with the "GPIO extension device" which 370 * does not probe any driver. The device tree parser will however 371 * populate a platform device for it so we can anyway obtain the 372 * GPIO descriptors from the device. 373 */ 374 for (i = 0; i < num_addr; i++) { 375 gpiod = gpiod_get_index(gpio_ext_dev, "addr", i, 376 GPIOD_OUT_LOW); 377 if (IS_ERR(gpiod)) 378 return PTR_ERR(gpiod); 379 gpiod_set_consumer_name(gpiod, "GPIO extension addr"); 380 addr[i] = gpiod; 381 } 382 gpio_ext->addr = addr; 383 gpio_ext->num_addr = num_addr; 384 385 ret = gpiod_count(gpio_ext_dev, "data"); 386 if (ret < 0) { 387 dev_err(dev, 388 "Failed to count GPIOs in DT property data-gpios\n"); 389 return ret; 390 } 391 num_data = ret; 392 data = devm_kcalloc(dev, num_data, sizeof(*data), GFP_KERNEL); 393 if (!data) 394 return -ENOMEM; 395 396 for (i = 0; i < num_data; i++) { 397 gpiod = gpiod_get_index(gpio_ext_dev, "data", i, 398 GPIOD_OUT_LOW); 399 if (IS_ERR(gpiod)) 400 return PTR_ERR(gpiod); 401 gpiod_set_consumer_name(gpiod, "GPIO extension data"); 402 data[i] = gpiod; 403 } 404 gpio_ext->data = data; 405 gpio_ext->num_data = num_data; 406 407 gpiod = gpiod_get(gpio_ext_dev, "enable", GPIOD_OUT_LOW); 408 if (IS_ERR(gpiod)) { 409 dev_err(dev, 410 "Failed to get GPIO from DT property enable-gpio\n"); 411 return PTR_ERR(gpiod); 412 } 413 gpiod_set_consumer_name(gpiod, "GPIO extension enable"); 414 gpio_ext->enable = gpiod; 415 416 return devm_add_action_or_reset(dev, netxbig_gpio_ext_remove, gpio_ext); 417 } 418 419 static int netxbig_leds_get_of_pdata(struct device *dev, 420 struct netxbig_led_platform_data *pdata) 421 { 422 struct device_node *np = dev_of_node(dev); 423 struct device_node *gpio_ext_np; 424 struct platform_device *gpio_ext_pdev; 425 struct device *gpio_ext_dev; 426 struct device_node *child; 427 struct netxbig_gpio_ext *gpio_ext; 428 struct netxbig_led_timer *timers; 429 struct netxbig_led *leds, *led; 430 int num_timers; 431 int num_leds = 0; 432 int ret; 433 int i; 434 435 /* GPIO extension */ 436 gpio_ext_np = of_parse_phandle(np, "gpio-ext", 0); 437 if (!gpio_ext_np) { 438 dev_err(dev, "Failed to get DT handle gpio-ext\n"); 439 return -EINVAL; 440 } 441 gpio_ext_pdev = of_find_device_by_node(gpio_ext_np); 442 if (!gpio_ext_pdev) { 443 dev_err(dev, "Failed to find platform device for gpio-ext\n"); 444 return -ENODEV; 445 } 446 gpio_ext_dev = &gpio_ext_pdev->dev; 447 448 gpio_ext = devm_kzalloc(dev, sizeof(*gpio_ext), GFP_KERNEL); 449 if (!gpio_ext) { 450 of_node_put(gpio_ext_np); 451 return -ENOMEM; 452 } 453 ret = netxbig_gpio_ext_get(dev, gpio_ext_dev, gpio_ext); 454 of_node_put(gpio_ext_np); 455 if (ret) 456 return ret; 457 pdata->gpio_ext = gpio_ext; 458 459 /* Timers (optional) */ 460 ret = of_property_count_u32_elems(np, "timers"); 461 if (ret > 0) { 462 if (ret % 3) 463 return -EINVAL; 464 num_timers = ret / 3; 465 timers = devm_kcalloc(dev, num_timers, sizeof(*timers), 466 GFP_KERNEL); 467 if (!timers) 468 return -ENOMEM; 469 for (i = 0; i < num_timers; i++) { 470 u32 tmp; 471 472 of_property_read_u32_index(np, "timers", 3 * i, 473 &timers[i].mode); 474 if (timers[i].mode >= NETXBIG_LED_MODE_NUM) 475 return -EINVAL; 476 of_property_read_u32_index(np, "timers", 477 3 * i + 1, &tmp); 478 timers[i].delay_on = tmp; 479 of_property_read_u32_index(np, "timers", 480 3 * i + 2, &tmp); 481 timers[i].delay_off = tmp; 482 } 483 pdata->timer = timers; 484 pdata->num_timer = num_timers; 485 } 486 487 /* LEDs */ 488 num_leds = of_get_available_child_count(np); 489 if (!num_leds) { 490 dev_err(dev, "No LED subnodes found in DT\n"); 491 return -ENODEV; 492 } 493 494 leds = devm_kcalloc(dev, num_leds, sizeof(*leds), GFP_KERNEL); 495 if (!leds) 496 return -ENOMEM; 497 498 led = leds; 499 for_each_available_child_of_node(np, child) { 500 const char *string; 501 int *mode_val; 502 int num_modes; 503 504 ret = of_property_read_u32(child, "mode-addr", 505 &led->mode_addr); 506 if (ret) 507 goto err_node_put; 508 509 ret = of_property_read_u32(child, "bright-addr", 510 &led->bright_addr); 511 if (ret) 512 goto err_node_put; 513 514 ret = of_property_read_u32(child, "max-brightness", 515 &led->bright_max); 516 if (ret) 517 goto err_node_put; 518 519 mode_val = 520 devm_kcalloc(dev, 521 NETXBIG_LED_MODE_NUM, sizeof(*mode_val), 522 GFP_KERNEL); 523 if (!mode_val) { 524 ret = -ENOMEM; 525 goto err_node_put; 526 } 527 528 for (i = 0; i < NETXBIG_LED_MODE_NUM; i++) 529 mode_val[i] = NETXBIG_LED_INVALID_MODE; 530 531 ret = of_property_count_u32_elems(child, "mode-val"); 532 if (ret < 0 || ret % 2) { 533 ret = -EINVAL; 534 goto err_node_put; 535 } 536 num_modes = ret / 2; 537 if (num_modes > NETXBIG_LED_MODE_NUM) { 538 ret = -EINVAL; 539 goto err_node_put; 540 } 541 542 for (i = 0; i < num_modes; i++) { 543 int mode; 544 int val; 545 546 of_property_read_u32_index(child, 547 "mode-val", 2 * i, &mode); 548 of_property_read_u32_index(child, 549 "mode-val", 2 * i + 1, &val); 550 if (mode >= NETXBIG_LED_MODE_NUM) { 551 ret = -EINVAL; 552 goto err_node_put; 553 } 554 mode_val[mode] = val; 555 } 556 led->mode_val = mode_val; 557 558 if (!of_property_read_string(child, "label", &string)) 559 led->name = string; 560 else 561 led->name = child->name; 562 563 if (!of_property_read_string(child, 564 "linux,default-trigger", &string)) 565 led->default_trigger = string; 566 567 led++; 568 } 569 570 pdata->leds = leds; 571 pdata->num_leds = num_leds; 572 573 return 0; 574 575 err_node_put: 576 of_node_put(child); 577 return ret; 578 } 579 580 static const struct of_device_id of_netxbig_leds_match[] = { 581 { .compatible = "lacie,netxbig-leds", }, 582 {}, 583 }; 584 MODULE_DEVICE_TABLE(of, of_netxbig_leds_match); 585 586 static int netxbig_led_probe(struct platform_device *pdev) 587 { 588 struct netxbig_led_platform_data *pdata; 589 struct netxbig_led_data *leds_data; 590 int i; 591 int ret; 592 593 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 594 if (!pdata) 595 return -ENOMEM; 596 ret = netxbig_leds_get_of_pdata(&pdev->dev, pdata); 597 if (ret) 598 return ret; 599 600 leds_data = devm_kcalloc(&pdev->dev, 601 pdata->num_leds, sizeof(*leds_data), 602 GFP_KERNEL); 603 if (!leds_data) 604 return -ENOMEM; 605 606 for (i = 0; i < pdata->num_leds; i++) { 607 ret = create_netxbig_led(pdev, pdata, 608 &leds_data[i], &pdata->leds[i]); 609 if (ret < 0) 610 return ret; 611 } 612 613 return 0; 614 } 615 616 static struct platform_driver netxbig_led_driver = { 617 .probe = netxbig_led_probe, 618 .driver = { 619 .name = "leds-netxbig", 620 .of_match_table = of_netxbig_leds_match, 621 }, 622 }; 623 624 module_platform_driver(netxbig_led_driver); 625 626 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>"); 627 MODULE_DESCRIPTION("LED driver for LaCie xBig Network boards"); 628 MODULE_LICENSE("GPL"); 629 MODULE_ALIAS("platform:leds-netxbig"); 630