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 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 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_RW(sata); 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 ret = -ENOMEM; 452 goto put_device; 453 } 454 ret = netxbig_gpio_ext_get(dev, gpio_ext_dev, gpio_ext); 455 of_node_put(gpio_ext_np); 456 if (ret) 457 goto put_device; 458 pdata->gpio_ext = gpio_ext; 459 460 /* Timers (optional) */ 461 ret = of_property_count_u32_elems(np, "timers"); 462 if (ret > 0) { 463 if (ret % 3) { 464 ret = -EINVAL; 465 goto put_device; 466 } 467 468 num_timers = ret / 3; 469 timers = devm_kcalloc(dev, num_timers, sizeof(*timers), 470 GFP_KERNEL); 471 if (!timers) { 472 ret = -ENOMEM; 473 goto put_device; 474 } 475 for (i = 0; i < num_timers; i++) { 476 u32 tmp; 477 478 of_property_read_u32_index(np, "timers", 3 * i, 479 &timers[i].mode); 480 if (timers[i].mode >= NETXBIG_LED_MODE_NUM) { 481 ret = -EINVAL; 482 goto put_device; 483 } 484 of_property_read_u32_index(np, "timers", 485 3 * i + 1, &tmp); 486 timers[i].delay_on = tmp; 487 of_property_read_u32_index(np, "timers", 488 3 * i + 2, &tmp); 489 timers[i].delay_off = tmp; 490 } 491 pdata->timer = timers; 492 pdata->num_timer = num_timers; 493 } 494 495 /* LEDs */ 496 num_leds = of_get_available_child_count(np); 497 if (!num_leds) { 498 dev_err(dev, "No LED subnodes found in DT\n"); 499 ret = -ENODEV; 500 goto put_device; 501 } 502 503 leds = devm_kcalloc(dev, num_leds, sizeof(*leds), GFP_KERNEL); 504 if (!leds) { 505 ret = -ENOMEM; 506 goto put_device; 507 } 508 509 led = leds; 510 for_each_available_child_of_node(np, child) { 511 const char *string; 512 int *mode_val; 513 int num_modes; 514 515 ret = of_property_read_u32(child, "mode-addr", 516 &led->mode_addr); 517 if (ret) 518 goto err_node_put; 519 520 ret = of_property_read_u32(child, "bright-addr", 521 &led->bright_addr); 522 if (ret) 523 goto err_node_put; 524 525 ret = of_property_read_u32(child, "max-brightness", 526 &led->bright_max); 527 if (ret) 528 goto err_node_put; 529 530 mode_val = 531 devm_kcalloc(dev, 532 NETXBIG_LED_MODE_NUM, sizeof(*mode_val), 533 GFP_KERNEL); 534 if (!mode_val) { 535 ret = -ENOMEM; 536 goto err_node_put; 537 } 538 539 for (i = 0; i < NETXBIG_LED_MODE_NUM; i++) 540 mode_val[i] = NETXBIG_LED_INVALID_MODE; 541 542 ret = of_property_count_u32_elems(child, "mode-val"); 543 if (ret < 0 || ret % 2) { 544 ret = -EINVAL; 545 goto err_node_put; 546 } 547 num_modes = ret / 2; 548 if (num_modes > NETXBIG_LED_MODE_NUM) { 549 ret = -EINVAL; 550 goto err_node_put; 551 } 552 553 for (i = 0; i < num_modes; i++) { 554 int mode; 555 int val; 556 557 of_property_read_u32_index(child, 558 "mode-val", 2 * i, &mode); 559 of_property_read_u32_index(child, 560 "mode-val", 2 * i + 1, &val); 561 if (mode >= NETXBIG_LED_MODE_NUM) { 562 ret = -EINVAL; 563 goto err_node_put; 564 } 565 mode_val[mode] = val; 566 } 567 led->mode_val = mode_val; 568 569 if (!of_property_read_string(child, "label", &string)) 570 led->name = string; 571 else 572 led->name = child->name; 573 574 if (!of_property_read_string(child, 575 "linux,default-trigger", &string)) 576 led->default_trigger = string; 577 578 led++; 579 } 580 581 pdata->leds = leds; 582 pdata->num_leds = num_leds; 583 584 return 0; 585 586 err_node_put: 587 of_node_put(child); 588 put_device: 589 put_device(gpio_ext_dev); 590 return ret; 591 } 592 593 static const struct of_device_id of_netxbig_leds_match[] = { 594 { .compatible = "lacie,netxbig-leds", }, 595 {}, 596 }; 597 MODULE_DEVICE_TABLE(of, of_netxbig_leds_match); 598 599 static int netxbig_led_probe(struct platform_device *pdev) 600 { 601 struct netxbig_led_platform_data *pdata; 602 struct netxbig_led_data *leds_data; 603 int i; 604 int ret; 605 606 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 607 if (!pdata) 608 return -ENOMEM; 609 ret = netxbig_leds_get_of_pdata(&pdev->dev, pdata); 610 if (ret) 611 return ret; 612 613 leds_data = devm_kcalloc(&pdev->dev, 614 pdata->num_leds, sizeof(*leds_data), 615 GFP_KERNEL); 616 if (!leds_data) 617 return -ENOMEM; 618 619 for (i = 0; i < pdata->num_leds; i++) { 620 ret = create_netxbig_led(pdev, pdata, 621 &leds_data[i], &pdata->leds[i]); 622 if (ret < 0) 623 return ret; 624 } 625 626 return 0; 627 } 628 629 static struct platform_driver netxbig_led_driver = { 630 .probe = netxbig_led_probe, 631 .driver = { 632 .name = "leds-netxbig", 633 .of_match_table = of_netxbig_leds_match, 634 }, 635 }; 636 637 module_platform_driver(netxbig_led_driver); 638 639 MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>"); 640 MODULE_DESCRIPTION("LED driver for LaCie xBig Network boards"); 641 MODULE_LICENSE("GPL"); 642 MODULE_ALIAS("platform:leds-netxbig"); 643