linux/drivers/leds/leds-ns2.c
<<
>>
Prefs
   1/*
   2 * leds-ns2.c - Driver for the Network Space v2 (and parents) dual-GPIO LED
   3 *
   4 * Copyright (C) 2010 LaCie
   5 *
   6 * Author: Simon Guinot <sguinot@lacie.com>
   7 *
   8 * Based on leds-gpio.c by Raphael Assenat <raph@8d.com>
   9 *
  10 * This program is free software; you can redistribute it and/or modify
  11 * it under the terms of the GNU General Public License as published by
  12 * the Free Software Foundation; either version 2 of the License, or
  13 * (at your option) any later version.
  14 *
  15 * This program is distributed in the hope that it will be useful,
  16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 * GNU General Public License for more details.
  19 *
  20 * You should have received a copy of the GNU General Public License
  21 * along with this program; if not, write to the Free Software
  22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23 */
  24
  25#include <linux/kernel.h>
  26#include <linux/platform_device.h>
  27#include <linux/slab.h>
  28#include <linux/gpio.h>
  29#include <linux/leds.h>
  30#include <linux/module.h>
  31#include <linux/platform_data/leds-kirkwood-ns2.h>
  32#include <linux/of.h>
  33#include <linux/of_gpio.h>
  34#include "leds.h"
  35
  36/*
  37 * The Network Space v2 dual-GPIO LED is wired to a CPLD. Three different LED
  38 * modes are available: off, on and SATA activity blinking. The LED modes are
  39 * controlled through two GPIOs (command and slow): each combination of values
  40 * for the command/slow GPIOs corresponds to a LED mode.
  41 */
  42
  43struct ns2_led_data {
  44        struct led_classdev     cdev;
  45        unsigned                cmd;
  46        unsigned                slow;
  47        bool                    can_sleep;
  48        unsigned char           sata; /* True when SATA mode active. */
  49        rwlock_t                rw_lock; /* Lock GPIOs. */
  50        int                     num_modes;
  51        struct ns2_led_modval   *modval;
  52};
  53
  54static int ns2_led_get_mode(struct ns2_led_data *led_dat,
  55                            enum ns2_led_modes *mode)
  56{
  57        int i;
  58        int ret = -EINVAL;
  59        int cmd_level;
  60        int slow_level;
  61
  62        cmd_level = gpio_get_value_cansleep(led_dat->cmd);
  63        slow_level = gpio_get_value_cansleep(led_dat->slow);
  64
  65        for (i = 0; i < led_dat->num_modes; i++) {
  66                if (cmd_level == led_dat->modval[i].cmd_level &&
  67                    slow_level == led_dat->modval[i].slow_level) {
  68                        *mode = led_dat->modval[i].mode;
  69                        ret = 0;
  70                        break;
  71                }
  72        }
  73
  74        return ret;
  75}
  76
  77static void ns2_led_set_mode(struct ns2_led_data *led_dat,
  78                             enum ns2_led_modes mode)
  79{
  80        int i;
  81        bool found = false;
  82        unsigned long flags;
  83
  84        for (i = 0; i < led_dat->num_modes; i++)
  85                if (mode == led_dat->modval[i].mode) {
  86                        found = true;
  87                        break;
  88                }
  89
  90        if (!found)
  91                return;
  92
  93        write_lock_irqsave(&led_dat->rw_lock, flags);
  94
  95        if (!led_dat->can_sleep) {
  96                gpio_set_value(led_dat->cmd,
  97                               led_dat->modval[i].cmd_level);
  98                gpio_set_value(led_dat->slow,
  99                               led_dat->modval[i].slow_level);
 100                goto exit_unlock;
 101        }
 102
 103        gpio_set_value_cansleep(led_dat->cmd, led_dat->modval[i].cmd_level);
 104        gpio_set_value_cansleep(led_dat->slow, led_dat->modval[i].slow_level);
 105
 106exit_unlock:
 107        write_unlock_irqrestore(&led_dat->rw_lock, flags);
 108}
 109
 110static void ns2_led_set(struct led_classdev *led_cdev,
 111                        enum led_brightness value)
 112{
 113        struct ns2_led_data *led_dat =
 114                container_of(led_cdev, struct ns2_led_data, cdev);
 115        enum ns2_led_modes mode;
 116
 117        if (value == LED_OFF)
 118                mode = NS_V2_LED_OFF;
 119        else if (led_dat->sata)
 120                mode = NS_V2_LED_SATA;
 121        else
 122                mode = NS_V2_LED_ON;
 123
 124        ns2_led_set_mode(led_dat, mode);
 125}
 126
 127static int ns2_led_set_blocking(struct led_classdev *led_cdev,
 128                        enum led_brightness value)
 129{
 130        ns2_led_set(led_cdev, value);
 131        return 0;
 132}
 133
 134static ssize_t ns2_led_sata_store(struct device *dev,
 135                                  struct device_attribute *attr,
 136                                  const char *buff, size_t count)
 137{
 138        struct led_classdev *led_cdev = dev_get_drvdata(dev);
 139        struct ns2_led_data *led_dat =
 140                container_of(led_cdev, struct ns2_led_data, cdev);
 141        int ret;
 142        unsigned long enable;
 143
 144        ret = kstrtoul(buff, 10, &enable);
 145        if (ret < 0)
 146                return ret;
 147
 148        enable = !!enable;
 149
 150        if (led_dat->sata == enable)
 151                goto exit;
 152
 153        led_dat->sata = enable;
 154
 155        if (!led_get_brightness(led_cdev))
 156                goto exit;
 157
 158        if (enable)
 159                ns2_led_set_mode(led_dat, NS_V2_LED_SATA);
 160        else
 161                ns2_led_set_mode(led_dat, NS_V2_LED_ON);
 162
 163exit:
 164        return count;
 165}
 166
 167static ssize_t ns2_led_sata_show(struct device *dev,
 168                                 struct device_attribute *attr, char *buf)
 169{
 170        struct led_classdev *led_cdev = dev_get_drvdata(dev);
 171        struct ns2_led_data *led_dat =
 172                container_of(led_cdev, struct ns2_led_data, cdev);
 173
 174        return sprintf(buf, "%d\n", led_dat->sata);
 175}
 176
 177static DEVICE_ATTR(sata, 0644, ns2_led_sata_show, ns2_led_sata_store);
 178
 179static struct attribute *ns2_led_attrs[] = {
 180        &dev_attr_sata.attr,
 181        NULL
 182};
 183ATTRIBUTE_GROUPS(ns2_led);
 184
 185static int
 186create_ns2_led(struct platform_device *pdev, struct ns2_led_data *led_dat,
 187               const struct ns2_led *template)
 188{
 189        int ret;
 190        enum ns2_led_modes mode;
 191
 192        ret = devm_gpio_request_one(&pdev->dev, template->cmd,
 193                        gpio_get_value_cansleep(template->cmd) ?
 194                        GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
 195                        template->name);
 196        if (ret) {
 197                dev_err(&pdev->dev, "%s: failed to setup command GPIO\n",
 198                        template->name);
 199                return ret;
 200        }
 201
 202        ret = devm_gpio_request_one(&pdev->dev, template->slow,
 203                        gpio_get_value_cansleep(template->slow) ?
 204                        GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
 205                        template->name);
 206        if (ret) {
 207                dev_err(&pdev->dev, "%s: failed to setup slow GPIO\n",
 208                        template->name);
 209                return ret;
 210        }
 211
 212        rwlock_init(&led_dat->rw_lock);
 213
 214        led_dat->cdev.name = template->name;
 215        led_dat->cdev.default_trigger = template->default_trigger;
 216        led_dat->cdev.blink_set = NULL;
 217        led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
 218        led_dat->cdev.groups = ns2_led_groups;
 219        led_dat->cmd = template->cmd;
 220        led_dat->slow = template->slow;
 221        led_dat->can_sleep = gpio_cansleep(led_dat->cmd) |
 222                                gpio_cansleep(led_dat->slow);
 223        if (led_dat->can_sleep)
 224                led_dat->cdev.brightness_set_blocking = ns2_led_set_blocking;
 225        else
 226                led_dat->cdev.brightness_set = ns2_led_set;
 227        led_dat->modval = template->modval;
 228        led_dat->num_modes = template->num_modes;
 229
 230        ret = ns2_led_get_mode(led_dat, &mode);
 231        if (ret < 0)
 232                return ret;
 233
 234        /* Set LED initial state. */
 235        led_dat->sata = (mode == NS_V2_LED_SATA) ? 1 : 0;
 236        led_dat->cdev.brightness =
 237                (mode == NS_V2_LED_OFF) ? LED_OFF : LED_FULL;
 238
 239        ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
 240        if (ret < 0)
 241                return ret;
 242
 243        return 0;
 244}
 245
 246static void delete_ns2_led(struct ns2_led_data *led_dat)
 247{
 248        led_classdev_unregister(&led_dat->cdev);
 249}
 250
 251#ifdef CONFIG_OF_GPIO
 252/*
 253 * Translate OpenFirmware node properties into platform_data.
 254 */
 255static int
 256ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata)
 257{
 258        struct device_node *np = dev->of_node;
 259        struct device_node *child;
 260        struct ns2_led *led, *leds;
 261        int num_leds = 0;
 262
 263        num_leds = of_get_child_count(np);
 264        if (!num_leds)
 265                return -ENODEV;
 266
 267        leds = devm_kzalloc(dev, num_leds * sizeof(struct ns2_led),
 268                            GFP_KERNEL);
 269        if (!leds)
 270                return -ENOMEM;
 271
 272        led = leds;
 273        for_each_child_of_node(np, child) {
 274                const char *string;
 275                int ret, i, num_modes;
 276                struct ns2_led_modval *modval;
 277
 278                ret = of_get_named_gpio(child, "cmd-gpio", 0);
 279                if (ret < 0)
 280                        return ret;
 281                led->cmd = ret;
 282                ret = of_get_named_gpio(child, "slow-gpio", 0);
 283                if (ret < 0)
 284                        return ret;
 285                led->slow = ret;
 286                ret = of_property_read_string(child, "label", &string);
 287                led->name = (ret == 0) ? string : child->name;
 288                ret = of_property_read_string(child, "linux,default-trigger",
 289                                              &string);
 290                if (ret == 0)
 291                        led->default_trigger = string;
 292
 293                ret = of_property_count_u32_elems(child, "modes-map");
 294                if (ret < 0 || ret % 3) {
 295                        dev_err(dev,
 296                                "Missing or malformed modes-map property\n");
 297                        return -EINVAL;
 298                }
 299
 300                num_modes = ret / 3;
 301                modval = devm_kzalloc(dev,
 302                                      num_modes * sizeof(struct ns2_led_modval),
 303                                      GFP_KERNEL);
 304                if (!modval)
 305                        return -ENOMEM;
 306
 307                for (i = 0; i < num_modes; i++) {
 308                        of_property_read_u32_index(child,
 309                                                "modes-map", 3 * i,
 310                                                (u32 *) &modval[i].mode);
 311                        of_property_read_u32_index(child,
 312                                                "modes-map", 3 * i + 1,
 313                                                (u32 *) &modval[i].cmd_level);
 314                        of_property_read_u32_index(child,
 315                                                "modes-map", 3 * i + 2,
 316                                                (u32 *) &modval[i].slow_level);
 317                }
 318
 319                led->num_modes = num_modes;
 320                led->modval = modval;
 321
 322                led++;
 323        }
 324
 325        pdata->leds = leds;
 326        pdata->num_leds = num_leds;
 327
 328        return 0;
 329}
 330
 331static const struct of_device_id of_ns2_leds_match[] = {
 332        { .compatible = "lacie,ns2-leds", },
 333        {},
 334};
 335MODULE_DEVICE_TABLE(of, of_ns2_leds_match);
 336#endif /* CONFIG_OF_GPIO */
 337
 338struct ns2_led_priv {
 339        int num_leds;
 340        struct ns2_led_data leds_data[];
 341};
 342
 343static inline int sizeof_ns2_led_priv(int num_leds)
 344{
 345        return sizeof(struct ns2_led_priv) +
 346                      (sizeof(struct ns2_led_data) * num_leds);
 347}
 348
 349static int ns2_led_probe(struct platform_device *pdev)
 350{
 351        struct ns2_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
 352        struct ns2_led_priv *priv;
 353        int i;
 354        int ret;
 355
 356#ifdef CONFIG_OF_GPIO
 357        if (!pdata) {
 358                pdata = devm_kzalloc(&pdev->dev,
 359                                     sizeof(struct ns2_led_platform_data),
 360                                     GFP_KERNEL);
 361                if (!pdata)
 362                        return -ENOMEM;
 363
 364                ret = ns2_leds_get_of_pdata(&pdev->dev, pdata);
 365                if (ret)
 366                        return ret;
 367        }
 368#else
 369        if (!pdata)
 370                return -EINVAL;
 371#endif /* CONFIG_OF_GPIO */
 372
 373        priv = devm_kzalloc(&pdev->dev,
 374                            sizeof_ns2_led_priv(pdata->num_leds), GFP_KERNEL);
 375        if (!priv)
 376                return -ENOMEM;
 377        priv->num_leds = pdata->num_leds;
 378
 379        for (i = 0; i < priv->num_leds; i++) {
 380                ret = create_ns2_led(pdev, &priv->leds_data[i],
 381                                     &pdata->leds[i]);
 382                if (ret < 0) {
 383                        for (i = i - 1; i >= 0; i--)
 384                                delete_ns2_led(&priv->leds_data[i]);
 385                        return ret;
 386                }
 387        }
 388
 389        platform_set_drvdata(pdev, priv);
 390
 391        return 0;
 392}
 393
 394static int ns2_led_remove(struct platform_device *pdev)
 395{
 396        int i;
 397        struct ns2_led_priv *priv;
 398
 399        priv = platform_get_drvdata(pdev);
 400
 401        for (i = 0; i < priv->num_leds; i++)
 402                delete_ns2_led(&priv->leds_data[i]);
 403
 404        return 0;
 405}
 406
 407static struct platform_driver ns2_led_driver = {
 408        .probe          = ns2_led_probe,
 409        .remove         = ns2_led_remove,
 410        .driver         = {
 411                .name           = "leds-ns2",
 412                .of_match_table = of_match_ptr(of_ns2_leds_match),
 413        },
 414};
 415
 416module_platform_driver(ns2_led_driver);
 417
 418MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
 419MODULE_DESCRIPTION("Network Space v2 LED driver");
 420MODULE_LICENSE("GPL");
 421MODULE_ALIAS("platform:leds-ns2");
 422