640 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * leds-netxbig.c - Driver for the 2Big and 5Big Network series LEDs4 *5 * Copyright (C) 2010 LaCie6 *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 20struct 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 28enum 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_NUM38 39struct netxbig_led_timer {40 unsigned long delay_on;41 unsigned long delay_off;42 enum netxbig_led_mode mode;43};44 45struct 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 54struct 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 66static DEFINE_SPINLOCK(gpio_ext_lock);67 68static 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 76static 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 84static 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 91static 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 107struct 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 120static 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 138static 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 168static 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 the197 * SATA LEDs. So, change the brightness setting for a single198 * 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 207static 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 else238 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 252exit_unlock:253 spin_unlock_irq(&led_dat->lock);254 255 return ret;256}257 258static 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 268static DEVICE_ATTR_RW(sata);269 270static struct attribute *netxbig_led_attrs[] = {271 &dev_attr_sata.attr,272 NULL273};274ATTRIBUTE_GROUPS(netxbig_led);275 276static 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 registers289 * 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 during295 * 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 through308 * 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 data318 * @data: managed resource data to clean up319 *320 * Since we pick GPIO descriptors from another device than the device our321 * driver is probing to, we need to register a specific callback to free322 * these up using managed resources.323 */324static 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 data338 * @dev: main LED device339 * @gpio_ext_dev: the GPIO extension device340 * @gpio_ext: the data structure holding the GPIO extension data341 *342 * This function walks the subdevice that only contain GPIO line343 * handles in the device tree and obtains the GPIO descriptors from that344 * device.345 */346static 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 descriptors369 * since they are associated with the "GPIO extension device" which370 * does not probe any driver. The device tree parser will however371 * populate a platform device for it so we can anyway obtain the372 * 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 419static 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 netxbig_gpio_ext *gpio_ext;427 struct netxbig_led_timer *timers;428 struct netxbig_led *leds, *led;429 int num_timers;430 int num_leds = 0;431 int ret;432 int i;433 434 /* GPIO extension */435 gpio_ext_np = of_parse_phandle(np, "gpio-ext", 0);436 if (!gpio_ext_np) {437 dev_err(dev, "Failed to get DT handle gpio-ext\n");438 return -EINVAL;439 }440 gpio_ext_pdev = of_find_device_by_node(gpio_ext_np);441 if (!gpio_ext_pdev) {442 dev_err(dev, "Failed to find platform device for gpio-ext\n");443 return -ENODEV;444 }445 gpio_ext_dev = &gpio_ext_pdev->dev;446 447 gpio_ext = devm_kzalloc(dev, sizeof(*gpio_ext), GFP_KERNEL);448 if (!gpio_ext) {449 of_node_put(gpio_ext_np);450 ret = -ENOMEM;451 goto put_device;452 }453 ret = netxbig_gpio_ext_get(dev, gpio_ext_dev, gpio_ext);454 of_node_put(gpio_ext_np);455 if (ret)456 goto put_device;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 ret = -EINVAL;464 goto put_device;465 }466 467 num_timers = ret / 3;468 timers = devm_kcalloc(dev, num_timers, sizeof(*timers),469 GFP_KERNEL);470 if (!timers) {471 ret = -ENOMEM;472 goto put_device;473 }474 for (i = 0; i < num_timers; i++) {475 u32 tmp;476 477 of_property_read_u32_index(np, "timers", 3 * i,478 &timers[i].mode);479 if (timers[i].mode >= NETXBIG_LED_MODE_NUM) {480 ret = -EINVAL;481 goto put_device;482 }483 of_property_read_u32_index(np, "timers",484 3 * i + 1, &tmp);485 timers[i].delay_on = tmp;486 of_property_read_u32_index(np, "timers",487 3 * i + 2, &tmp);488 timers[i].delay_off = tmp;489 }490 pdata->timer = timers;491 pdata->num_timer = num_timers;492 }493 494 /* LEDs */495 num_leds = of_get_available_child_count(np);496 if (!num_leds) {497 dev_err(dev, "No LED subnodes found in DT\n");498 ret = -ENODEV;499 goto put_device;500 }501 502 leds = devm_kcalloc(dev, num_leds, sizeof(*leds), GFP_KERNEL);503 if (!leds) {504 ret = -ENOMEM;505 goto put_device;506 }507 508 led = leds;509 for_each_available_child_of_node_scoped(np, child) {510 const char *string;511 int *mode_val;512 int num_modes;513 514 ret = of_property_read_u32(child, "mode-addr",515 &led->mode_addr);516 if (ret)517 goto put_device;518 519 ret = of_property_read_u32(child, "bright-addr",520 &led->bright_addr);521 if (ret)522 goto put_device;523 524 ret = of_property_read_u32(child, "max-brightness",525 &led->bright_max);526 if (ret)527 goto put_device;528 529 mode_val =530 devm_kcalloc(dev,531 NETXBIG_LED_MODE_NUM, sizeof(*mode_val),532 GFP_KERNEL);533 if (!mode_val) {534 ret = -ENOMEM;535 goto put_device;536 }537 538 for (i = 0; i < NETXBIG_LED_MODE_NUM; i++)539 mode_val[i] = NETXBIG_LED_INVALID_MODE;540 541 ret = of_property_count_u32_elems(child, "mode-val");542 if (ret < 0 || ret % 2) {543 ret = -EINVAL;544 goto put_device;545 }546 num_modes = ret / 2;547 if (num_modes > NETXBIG_LED_MODE_NUM) {548 ret = -EINVAL;549 goto put_device;550 }551 552 for (i = 0; i < num_modes; i++) {553 int mode;554 int val;555 556 of_property_read_u32_index(child,557 "mode-val", 2 * i, &mode);558 of_property_read_u32_index(child,559 "mode-val", 2 * i + 1, &val);560 if (mode >= NETXBIG_LED_MODE_NUM) {561 ret = -EINVAL;562 goto put_device;563 }564 mode_val[mode] = val;565 }566 led->mode_val = mode_val;567 568 if (!of_property_read_string(child, "label", &string))569 led->name = string;570 else571 led->name = child->name;572 573 if (!of_property_read_string(child,574 "linux,default-trigger", &string))575 led->default_trigger = string;576 577 led++;578 }579 580 pdata->leds = leds;581 pdata->num_leds = num_leds;582 583 return 0;584 585put_device:586 put_device(gpio_ext_dev);587 return ret;588}589 590static const struct of_device_id of_netxbig_leds_match[] = {591 { .compatible = "lacie,netxbig-leds", },592 {},593};594MODULE_DEVICE_TABLE(of, of_netxbig_leds_match);595 596static int netxbig_led_probe(struct platform_device *pdev)597{598 struct netxbig_led_platform_data *pdata;599 struct netxbig_led_data *leds_data;600 int i;601 int ret;602 603 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);604 if (!pdata)605 return -ENOMEM;606 ret = netxbig_leds_get_of_pdata(&pdev->dev, pdata);607 if (ret)608 return ret;609 610 leds_data = devm_kcalloc(&pdev->dev,611 pdata->num_leds, sizeof(*leds_data),612 GFP_KERNEL);613 if (!leds_data)614 return -ENOMEM;615 616 for (i = 0; i < pdata->num_leds; i++) {617 ret = create_netxbig_led(pdev, pdata,618 &leds_data[i], &pdata->leds[i]);619 if (ret < 0)620 return ret;621 }622 623 return 0;624}625 626static struct platform_driver netxbig_led_driver = {627 .probe = netxbig_led_probe,628 .driver = {629 .name = "leds-netxbig",630 .of_match_table = of_netxbig_leds_match,631 },632};633 634module_platform_driver(netxbig_led_driver);635 636MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");637MODULE_DESCRIPTION("LED driver for LaCie xBig Network boards");638MODULE_LICENSE("GPL");639MODULE_ALIAS("platform:leds-netxbig");640