drivers/leds/leds-netxbig.c

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