drivers/leds/leds-gpio.c

   1 /*
   2  * LEDs driver for GPIOs
   3  *
   4  * Copyright (C) 2007 8D Technologies inc.
   5  * Raphael Assenat <raph@8d.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  */
  12 #include <linux/kernel.h>
  13 #include <linux/init.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/leds.h>
  16 #include <linux/workqueue.h>
  17
  18 #include <asm/gpio.h>
  19
  20 struct gpio_led_data {
  21         struct led_classdev cdev;
  22         unsigned gpio;
  23         struct work_struct work;
  24         u8 new_level;
  25         u8 can_sleep;
  26         u8 active_low;
  27 };
  28
  29 static void gpio_led_work(struct work_struct *work)
  30 {
  31         struct gpio_led_data    *led_dat =
  32                 container_of(work, struct gpio_led_data, work);
  33
  34         gpio_set_value_cansleep(led_dat->gpio, led_dat->new_level);
  35 }
  36
  37 static void gpio_led_set(struct led_classdev *led_cdev,
  38         enum led_brightness value)
  39 {
  40         struct gpio_led_data *led_dat =
  41                 container_of(led_cdev, struct gpio_led_data, cdev);
  42         int level;
  43
  44         if (value == LED_OFF)
  45                 level = 0;
  46         else
  47                 level = 1;
  48
  49         if (led_dat->active_low)
  50                 level = !level;
  51
  52         /* setting GPIOs with I2C/etc requires a preemptible task context */
  53         if (led_dat->can_sleep) {
  54                 if (preempt_count()) {
  55                         led_dat->new_level = level;
  56                         schedule_work(&led_dat->work);
  57                 } else
  58                         gpio_set_value_cansleep(led_dat->gpio, level);
  59         } else
  60                 gpio_set_value(led_dat->gpio, level);
  61 }
  62
  63 static int __init gpio_led_probe(struct platform_device *pdev)
  64 {
  65         struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
  66         struct gpio_led *cur_led;
  67         struct gpio_led_data *leds_data, *led_dat;
  68         int i, ret = 0;
  69
  70         if (!pdata)
  71                 return -EBUSY;
  72
  73         leds_data = kzalloc(sizeof(struct gpio_led_data) * pdata->num_leds,
  74                                 GFP_KERNEL);
  75         if (!leds_data)
  76                 return -ENOMEM;
  77
  78         for (i = 0; i < pdata->num_leds; i++) {
  79                 cur_led = &pdata->leds[i];
  80                 led_dat = &leds_data[i];
  81
  82                 led_dat->cdev.name = cur_led->name;
  83                 led_dat->cdev.default_trigger = cur_led->default_trigger;
  84                 led_dat->gpio = cur_led->gpio;
  85                 led_dat->can_sleep = gpio_cansleep(cur_led->gpio);
  86                 led_dat->active_low = cur_led->active_low;
  87                 led_dat->cdev.brightness_set = gpio_led_set;
  88                 led_dat->cdev.brightness = cur_led->active_low ? LED_FULL : LED_OFF;
  89
  90                 ret = gpio_request(led_dat->gpio, led_dat->cdev.name);
  91                 if (ret < 0)
  92                         goto err;
  93
  94                 gpio_direction_output(led_dat->gpio, led_dat->active_low);
  95
  96                 ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
  97                 if (ret < 0) {
  98                         gpio_free(led_dat->gpio);
  99                         goto err;
 100                 }
 101
 102                 INIT_WORK(&led_dat->work, gpio_led_work);
 103         }
 104
 105         platform_set_drvdata(pdev, leds_data);
 106
 107         return 0;
 108
 109 err:
 110         if (i > 0) {
 111                 for (i = i - 1; i >= 0; i--) {
 112                         led_classdev_unregister(&leds_data[i].cdev);
 113                         gpio_free(leds_data[i].gpio);
 114                 }
 115         }
 116
 117         flush_scheduled_work();
 118         kfree(leds_data);
 119
 120         return ret;
 121 }
 122
 123 static int __exit gpio_led_remove(struct platform_device *pdev)
 124 {
 125         int i;
 126         struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
 127         struct gpio_led_data *leds_data;
 128
 129         leds_data = platform_get_drvdata(pdev);
 130
 131         for (i = 0; i < pdata->num_leds; i++) {
 132                 led_classdev_unregister(&leds_data[i].cdev);
 133                 gpio_free(leds_data[i].gpio);
 134         }
 135
 136         kfree(leds_data);
 137
 138         return 0;
 139 }
 140
 141 #ifdef CONFIG_PM
 142 static int gpio_led_suspend(struct platform_device *pdev, pm_message_t state)
 143 {
 144         struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
 145         struct gpio_led_data *leds_data;
 146         int i;
 147
 148         leds_data = platform_get_drvdata(pdev);
 149
 150         for (i = 0; i < pdata->num_leds; i++)
 151                 led_classdev_suspend(&leds_data[i].cdev);
 152
 153         return 0;
 154 }
 155
 156 static int gpio_led_resume(struct platform_device *pdev)
 157 {
 158         struct gpio_led_platform_data *pdata = pdev->dev.platform_data;
 159         struct gpio_led_data *leds_data;
 160         int i;
 161
 162         leds_data = platform_get_drvdata(pdev);
 163
 164         for (i = 0; i < pdata->num_leds; i++)
 165                 led_classdev_resume(&leds_data[i].cdev);
 166
 167         return 0;
 168 }
 169 #else
 170 #define gpio_led_suspend NULL
 171 #define gpio_led_resume NULL
 172 #endif
 173
 174 static struct platform_driver gpio_led_driver = {
 175         .remove         = __exit_p(gpio_led_remove),
 176         .suspend        = gpio_led_suspend,
 177         .resume         = gpio_led_resume,
 178         .driver         = {
 179                 .name   = "leds-gpio",
 180                 .owner  = THIS_MODULE,
 181         },
 182 };
 183
 184 static int __init gpio_led_init(void)
 185 {
 186         return platform_driver_probe(&gpio_led_driver, gpio_led_probe);
 187 }
 188
 189 static void __exit gpio_led_exit(void)
 190 {
 191         platform_driver_unregister(&gpio_led_driver);
 192 }
 193
 194 module_init(gpio_led_init);
 195 module_exit(gpio_led_exit);
 196
 197 MODULE_AUTHOR("Raphael Assenat <raph@8d.com>");
 198 MODULE_DESCRIPTION("GPIO LED driver");
 199 MODULE_LICENSE("GPL");