linux/drivers/leds/leds-regulator.c
<<
>>
Prefs
   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
  26struct 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
  36static 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
  55static 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
  65static 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
  81static 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
  97static 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
 122out:
 123        mutex_unlock(&led->mutex);
 124}
 125
 126static 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
 134static 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
 143static 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 = devm_kzalloc(&pdev->dev, 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_vcc;
 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_vcc;
 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
 204err_vcc:
 205        regulator_put(vcc);
 206        return ret;
 207}
 208
 209static int __devexit regulator_led_remove(struct platform_device *pdev)
 210{
 211        struct regulator_led *led = platform_get_drvdata(pdev);
 212
 213        led_classdev_unregister(&led->cdev);
 214        cancel_work_sync(&led->work);
 215        regulator_led_disable(led);
 216        regulator_put(led->vcc);
 217        return 0;
 218}
 219
 220static struct platform_driver regulator_led_driver = {
 221        .driver = {
 222                   .name  = "leds-regulator",
 223                   .owner = THIS_MODULE,
 224                   },
 225        .probe  = regulator_led_probe,
 226        .remove = __devexit_p(regulator_led_remove),
 227};
 228
 229module_platform_driver(regulator_led_driver);
 230
 231MODULE_AUTHOR("Antonio Ospite <ospite@studenti.unina.it>");
 232MODULE_DESCRIPTION("Regulator driven LED driver");
 233MODULE_LICENSE("GPL");
 234MODULE_ALIAS("platform:leds-regulator");
 235
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.