linux/drivers/leds/leds-adp5520.c
<<
>>
Prefs
   1/*
   2 * LEDs driver for Analog Devices ADP5520/ADP5501 MFD PMICs
   3 *
   4 * Copyright 2009 Analog Devices Inc.
   5 *
   6 * Loosely derived from leds-da903x:
   7 * Copyright (C) 2008 Compulab, Ltd.
   8 *      Mike Rapoport <mike@compulab.co.il>
   9 *
  10 * Copyright (C) 2006-2008 Marvell International Ltd.
  11 *      Eric Miao <eric.miao@marvell.com>
  12 *
  13 * Licensed under the GPL-2 or later.
  14 */
  15
  16#include <linux/module.h>
  17#include <linux/kernel.h>
  18#include <linux/init.h>
  19#include <linux/platform_device.h>
  20#include <linux/leds.h>
  21#include <linux/workqueue.h>
  22#include <linux/mfd/adp5520.h>
  23#include <linux/slab.h>
  24
  25struct adp5520_led {
  26        struct led_classdev     cdev;
  27        struct work_struct      work;
  28        struct device           *master;
  29        enum led_brightness     new_brightness;
  30        int                     id;
  31        int                     flags;
  32};
  33
  34static void adp5520_led_work(struct work_struct *work)
  35{
  36        struct adp5520_led *led = container_of(work, struct adp5520_led, work);
  37        adp5520_write(led->master, ADP5520_LED1_CURRENT + led->id - 1,
  38                         led->new_brightness >> 2);
  39}
  40
  41static void adp5520_led_set(struct led_classdev *led_cdev,
  42                           enum led_brightness value)
  43{
  44        struct adp5520_led *led;
  45
  46        led = container_of(led_cdev, struct adp5520_led, cdev);
  47        led->new_brightness = value;
  48        schedule_work(&led->work);
  49}
  50
  51static int adp5520_led_setup(struct adp5520_led *led)
  52{
  53        struct device *dev = led->master;
  54        int flags = led->flags;
  55        int ret = 0;
  56
  57        switch (led->id) {
  58        case FLAG_ID_ADP5520_LED1_ADP5501_LED0:
  59                ret |= adp5520_set_bits(dev, ADP5520_LED_TIME,
  60                                        (flags >> ADP5520_FLAG_OFFT_SHIFT) &
  61                                        ADP5520_FLAG_OFFT_MASK);
  62                ret |= adp5520_set_bits(dev, ADP5520_LED_CONTROL,
  63                                        ADP5520_LED1_EN);
  64                break;
  65        case FLAG_ID_ADP5520_LED2_ADP5501_LED1:
  66                ret |= adp5520_set_bits(dev,  ADP5520_LED_TIME,
  67                                        ((flags >> ADP5520_FLAG_OFFT_SHIFT) &
  68                                        ADP5520_FLAG_OFFT_MASK) << 2);
  69                ret |= adp5520_clr_bits(dev, ADP5520_LED_CONTROL,
  70                                         ADP5520_R3_MODE);
  71                ret |= adp5520_set_bits(dev, ADP5520_LED_CONTROL,
  72                                        ADP5520_LED2_EN);
  73                break;
  74        case FLAG_ID_ADP5520_LED3_ADP5501_LED2:
  75                ret |= adp5520_set_bits(dev,  ADP5520_LED_TIME,
  76                                        ((flags >> ADP5520_FLAG_OFFT_SHIFT) &
  77                                        ADP5520_FLAG_OFFT_MASK) << 4);
  78                ret |= adp5520_clr_bits(dev, ADP5520_LED_CONTROL,
  79                                        ADP5520_C3_MODE);
  80                ret |= adp5520_set_bits(dev, ADP5520_LED_CONTROL,
  81                                        ADP5520_LED3_EN);
  82                break;
  83        }
  84
  85        return ret;
  86}
  87
  88static int adp5520_led_prepare(struct platform_device *pdev)
  89{
  90        struct adp5520_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
  91        struct device *dev = pdev->dev.parent;
  92        int ret = 0;
  93
  94        ret |= adp5520_write(dev, ADP5520_LED1_CURRENT, 0);
  95        ret |= adp5520_write(dev, ADP5520_LED2_CURRENT, 0);
  96        ret |= adp5520_write(dev, ADP5520_LED3_CURRENT, 0);
  97        ret |= adp5520_write(dev, ADP5520_LED_TIME, pdata->led_on_time << 6);
  98        ret |= adp5520_write(dev, ADP5520_LED_FADE, FADE_VAL(pdata->fade_in,
  99                 pdata->fade_out));
 100
 101        return ret;
 102}
 103
 104static int adp5520_led_probe(struct platform_device *pdev)
 105{
 106        struct adp5520_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
 107        struct adp5520_led *led, *led_dat;
 108        struct led_info *cur_led;
 109        int ret, i;
 110
 111        if (pdata == NULL) {
 112                dev_err(&pdev->dev, "missing platform data\n");
 113                return -ENODEV;
 114        }
 115
 116        if (pdata->num_leds > ADP5520_01_MAXLEDS) {
 117                dev_err(&pdev->dev, "can't handle more than %d LEDS\n",
 118                                 ADP5520_01_MAXLEDS);
 119                return -EFAULT;
 120        }
 121
 122        led = devm_kzalloc(&pdev->dev, sizeof(*led) * pdata->num_leds,
 123                                GFP_KERNEL);
 124        if (led == NULL) {
 125                dev_err(&pdev->dev, "failed to alloc memory\n");
 126                return -ENOMEM;
 127        }
 128
 129        ret = adp5520_led_prepare(pdev);
 130
 131        if (ret) {
 132                dev_err(&pdev->dev, "failed to write\n");
 133                return ret;
 134        }
 135
 136        for (i = 0; i < pdata->num_leds; ++i) {
 137                cur_led = &pdata->leds[i];
 138                led_dat = &led[i];
 139
 140                led_dat->cdev.name = cur_led->name;
 141                led_dat->cdev.default_trigger = cur_led->default_trigger;
 142                led_dat->cdev.brightness_set = adp5520_led_set;
 143                led_dat->cdev.brightness = LED_OFF;
 144
 145                if (cur_led->flags & ADP5520_FLAG_LED_MASK)
 146                        led_dat->flags = cur_led->flags;
 147                else
 148                        led_dat->flags = i + 1;
 149
 150                led_dat->id = led_dat->flags & ADP5520_FLAG_LED_MASK;
 151
 152                led_dat->master = pdev->dev.parent;
 153                led_dat->new_brightness = LED_OFF;
 154
 155                INIT_WORK(&led_dat->work, adp5520_led_work);
 156
 157                ret = led_classdev_register(led_dat->master, &led_dat->cdev);
 158                if (ret) {
 159                        dev_err(&pdev->dev, "failed to register LED %d\n",
 160                                led_dat->id);
 161                        goto err;
 162                }
 163
 164                ret = adp5520_led_setup(led_dat);
 165                if (ret) {
 166                        dev_err(&pdev->dev, "failed to write\n");
 167                        i++;
 168                        goto err;
 169                }
 170        }
 171
 172        platform_set_drvdata(pdev, led);
 173        return 0;
 174
 175err:
 176        if (i > 0) {
 177                for (i = i - 1; i >= 0; i--) {
 178                        led_classdev_unregister(&led[i].cdev);
 179                        cancel_work_sync(&led[i].work);
 180                }
 181        }
 182
 183        return ret;
 184}
 185
 186static int adp5520_led_remove(struct platform_device *pdev)
 187{
 188        struct adp5520_leds_platform_data *pdata = dev_get_platdata(&pdev->dev);
 189        struct adp5520_led *led;
 190        int i;
 191
 192        led = platform_get_drvdata(pdev);
 193
 194        adp5520_clr_bits(led->master, ADP5520_LED_CONTROL,
 195                 ADP5520_LED1_EN | ADP5520_LED2_EN | ADP5520_LED3_EN);
 196
 197        for (i = 0; i < pdata->num_leds; i++) {
 198                led_classdev_unregister(&led[i].cdev);
 199                cancel_work_sync(&led[i].work);
 200        }
 201
 202        return 0;
 203}
 204
 205static struct platform_driver adp5520_led_driver = {
 206        .driver = {
 207                .name   = "adp5520-led",
 208                .owner  = THIS_MODULE,
 209        },
 210        .probe          = adp5520_led_probe,
 211        .remove         = adp5520_led_remove,
 212};
 213
 214module_platform_driver(adp5520_led_driver);
 215
 216MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 217MODULE_DESCRIPTION("LEDS ADP5520(01) Driver");
 218MODULE_LICENSE("GPL");
 219MODULE_ALIAS("platform:adp5520-led");
 220
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.