drivers/leds/leds-regulator.c

   1 /*
   2  * leds-regulator.c - LED class driver for regulator driven LEDs.
   3  *
   4  * Copyright (C) 2009 Antonio Ospite <ospite@studenti.unina.it>
   5  *
   6  * Inspired by leds-wm8350 driver.
   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 version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/err.h>
  16 #include <linux/slab.h>
  17 #include <linux/workqueue.h>
  18 #include <linux/leds.h>
  19 #include <linux/leds-regulator.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/regulator/consumer.h>
  22
  23 #define to_regulator_led(led_cdev) \
  24         container_of(led_cdev, struct regulator_led, cdev)
  25
  26 struct regulator_led {
  27         struct led_classdev cdev;
  28         enum led_brightness value;
  29         int enabled;
  30         struct mutex mutex;
  31         struct work_struct work;
  32
  33         struct regulator *vcc;
  34 };
  35
  36 static inline int led_regulator_get_max_brightness(struct regulator *supply)
  37 {
  38         int ret;
  39         int voltage = regulator_list_voltage(supply, 0);
  40
  41         if (voltage <= 0)
  42                 return 1;
  43
  44         /* even if regulator can't change voltages,
  45          * we still assume it can change status
  46          * and the LED can be turned on and off.
  47          */
  48         ret = regulator_set_voltage(supply, voltage, voltage);
  49         if (ret < 0)
  50                 return 1;
  51
  52         return regulator_count_voltages(supply);
  53 }
  54
  55 static int led_regulator_get_voltage(struct regulator *supply,
  56                 enum led_brightness brightness)
  57 {
  58         if (brightness == 0)
  59                 return -EINVAL;
  60
  61         return regulator_list_voltage(supply, brightness - 1);
  62 }
  63
  64
  65 static void regulator_led_enable(struct regulator_led *led)
  66 {
  67         int ret;
  68
  69         if (led->enabled)
  70                 return;
  71
  72         ret = regulator_enable(led->vcc);
  73         if (ret != 0) {
  74                 dev_err(led->cdev.dev, "Failed to enable vcc: %d\n", ret);
  75                 return;
  76         }
  77
  78         led->enabled = 1;
  79 }
  80
  81 static void regulator_led_disable(struct regulator_led *led)
  82 {
  83         int ret;
  84
  85         if (!led->enabled)
  86                 return;
  87
  88         ret = regulator_disable(led->vcc);
  89         if (ret != 0) {
  90                 dev_err(led->cdev.dev, "Failed to disable vcc: %d\n", ret);
  91                 return;
  92         }
  93
  94         led->enabled = 0;
  95 }
  96
  97 static void regulator_led_set_value(struct regulator_led *led)
  98 {
  99         int voltage;
 100         int ret;
 101
 102         mutex_lock(&led->mutex);
 103
 104         if (led->value == LED_OFF) {
 105                 regulator_led_disable(led);
 106                 goto out;
 107         }
 108
 109         if (led->cdev.max_brightness > 1) {
 110                 voltage = led_regulator_get_voltage(led->vcc, led->value);
 111                 dev_dbg(led->cdev.dev, "brightness: %d voltage: %d\n",
 112                                 led->value, voltage);
 113
 114                 ret = regulator_set_voltage(led->vcc, voltage, voltage);
 115                 if (ret != 0)
 116                         dev_err(led->cdev.dev, "Failed to set voltage %d: %d\n",
 117                                 voltage, ret);
 118         }
 119
 120         regulator_led_enable(led);
 121
 122 out:
 123         mutex_unlock(&led->mutex);
 124 }
 125
 126 static void led_work(struct work_struct *work)
 127 {
 128         struct regulator_led *led;
 129
 130         led = container_of(work, struct regulator_led, work);
 131         regulator_led_set_value(led);
 132 }
 133
 134 static void regulator_led_brightness_set(struct led_classdev *led_cdev,
 135                            enum led_brightness value)
 136 {
 137         struct regulator_led *led = to_regulator_led(led_cdev);
 138
 139         led->value = value;
 140         schedule_work(&led->work);
 141 }
 142
 143 static int __devinit regulator_led_probe(struct platform_device *pdev)
 144 {
 145         struct led_regulator_platform_data *pdata = pdev->dev.platform_data;
 146         struct regulator_led *led;
 147         struct regulator *vcc;
 148         int ret = 0;
 149
 150         if (pdata == NULL) {
 151                 dev_err(&pdev->dev, "no platform data\n");
 152                 return -ENODEV;
 153         }
 154
 155         vcc = regulator_get_exclusive(&pdev->dev, "vled");
 156         if (IS_ERR(vcc)) {
 157                 dev_err(&pdev->dev, "Cannot get vcc for %s\n", pdata->name);
 158                 return PTR_ERR(vcc);
 159         }
 160
 161         led = kzalloc(sizeof(*led), GFP_KERNEL);
 162         if (led == NULL) {
 163                 ret = -ENOMEM;
 164                 goto err_vcc;
 165         }
 166
 167         led->cdev.max_brightness = led_regulator_get_max_brightness(vcc);
 168         if (pdata->brightness > led->cdev.max_brightness) {
 169                 dev_err(&pdev->dev, "Invalid default brightness %d\n",
 170                                 pdata->brightness);
 171                 ret = -EINVAL;
 172                 goto err_led;
 173         }
 174         led->value = pdata->brightness;
 175
 176         led->cdev.brightness_set = regulator_led_brightness_set;
 177         led->cdev.name = pdata->name;
 178         led->cdev.flags |= LED_CORE_SUSPENDRESUME;
 179         led->vcc = vcc;
 180
 181         /* to handle correctly an already enabled regulator */
 182         if (regulator_is_enabled(led->vcc))
 183                 led->enabled = 1;
 184
 185         mutex_init(&led->mutex);
 186         INIT_WORK(&led->work, led_work);
 187
 188         platform_set_drvdata(pdev, led);
 189
 190         ret = led_classdev_register(&pdev->dev, &led->cdev);
 191         if (ret < 0) {
 192                 cancel_work_sync(&led->work);
 193                 goto err_led;
 194         }
 195
 196         /* to expose the default value to userspace */
 197         led->cdev.brightness = led->value;
 198
 199         /* Set the default led status */
 200         regulator_led_set_value(led);
 201
 202         return 0;
 203
 204 err_led:
 205         kfree(led);
 206 err_vcc:
 207         regulator_put(vcc);
 208         return ret;
 209 }
 210
 211 static int __devexit regulator_led_remove(struct platform_device *pdev)
 212 {
 213         struct regulator_led *led = platform_get_drvdata(pdev);
 214
 215         led_classdev_unregister(&led->cdev);
 216         cancel_work_sync(&led->work);
 217         regulator_led_disable(led);
 218         regulator_put(led->vcc);
 219         kfree(led);
 220         return 0;
 221 }
 222
 223 static struct platform_driver regulator_led_driver = {
 224         .driver = {
 225                    .name  = "leds-regulator",
 226                    .owner = THIS_MODULE,
 227                    },
 228         .probe  = regulator_led_probe,
 229         .remove = __devexit_p(regulator_led_remove),
 230 };
 231
 232 static int __init regulator_led_init(void)
 233 {
 234         return platform_driver_register(&regulator_led_driver);
 235 }
 236 module_init(regulator_led_init);
 237
 238 static void __exit regulator_led_exit(void)
 239 {
 240         platform_driver_unregister(&regulator_led_driver);
 241 }
 242 module_exit(regulator_led_exit);
 243
 244 MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
 245 MODULE_DESCRIPTION("Regulator driven LED driver");
 246 MODULE_LICENSE("GPL");
 247 MODULE_ALIAS("platform:leds-regulator");