drivers/leds/leds-twl4030-pwm.c

   1 /*
   2  * TWL4030 PWM controlled LED driver (LEDA, LEDB, PWM0, PWM1)
   3  *
   4  * Author: Gražvydas Ignotas <notasas@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/workqueue.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/leds.h>
  17 #include <linux/leds_pwm.h>
  18 #include <linux/i2c/twl.h>
  19 #include <linux/slab.h>
  20
  21 #define TWL_INTBR_GPBR1         0x0c
  22 #define TWL_INTBR_PMBR1         0x0d
  23
  24 #define TWL4030_PWMx_PWMxON     0x00
  25 #define TWL4030_PWMx_PWMxOFF    0x01
  26 #define TWL4030_LED_LEDEN       0x00
  27
  28 #define GPBR1_PWM0_CLK_ENABLE   BIT(0)
  29 #define GPBR1_PWM1_CLK_ENABLE   BIT(1)
  30 #define GPBR1_PWM0_ENABLE       BIT(2)
  31 #define GPBR1_PWM1_ENABLE       BIT(3)
  32
  33 /* LEDEN bits */
  34 #define LEDEN_LEDAON            BIT(0)
  35 #define LEDEN_LEDBON            BIT(1)
  36 #define LEDEN_LEDAPWM           BIT(4)
  37 #define LEDEN_LEDBPWM           BIT(5)
  38
  39 enum twl4030_led {
  40         TWL4030_LEDA = 0,
  41         TWL4030_LEDB,
  42         TWL4030_PWM0,
  43         TWL4030_PWM1,
  44 };
  45
  46 struct twl4030_pwmled {
  47         struct led_classdev cdev;
  48         void (*enable)(enum twl4030_led led, bool enable);
  49         enum led_brightness new_brightness;
  50         enum led_brightness old_brightness;
  51         enum twl4030_led id;
  52         int module;
  53         struct work_struct work;
  54 };
  55
  56 static int twl4030_clear_set(u8 mod_no, u8 clear, u8 set, u8 reg)
  57 {
  58         u8 val = 0;
  59         int ret;
  60
  61         ret = twl_i2c_read_u8(mod_no, &val, reg);
  62         if (ret)
  63                 return ret;
  64
  65         val &= ~clear;
  66         val |= set;
  67
  68         return twl_i2c_write_u8(mod_no, val, reg);
  69 }
  70
  71 static void twl4030_enable_ledab(enum twl4030_led led, bool enable)
  72 {
  73         u8 bits;
  74
  75         if (led == TWL4030_LEDA)
  76                 bits = LEDEN_LEDAON | LEDEN_LEDAPWM;
  77         else
  78                 bits = LEDEN_LEDBON | LEDEN_LEDBPWM;
  79
  80         if (enable)
  81                 twl4030_clear_set(TWL4030_MODULE_LED, 0, bits, TWL4030_LED_LEDEN);
  82         else
  83                 twl4030_clear_set(TWL4030_MODULE_LED, bits, 0, TWL4030_LED_LEDEN);
  84 }
  85
  86 static void twl4030_enable_pwm01(enum twl4030_led led, bool enable)
  87 {
  88         u8 r, enbit, clkbit;
  89
  90         if (led == TWL4030_PWM0) {
  91                 enbit = GPBR1_PWM0_ENABLE;
  92                 clkbit = GPBR1_PWM0_CLK_ENABLE;
  93         } else {
  94                 enbit = GPBR1_PWM1_ENABLE;
  95                 clkbit = GPBR1_PWM1_CLK_ENABLE;
  96         }
  97
  98         twl_i2c_read_u8(TWL4030_MODULE_INTBR, &r, TWL_INTBR_GPBR1);
  99
 100         if (enable) {
 101                 /* first enable clock, then PWM out */
 102                 r &= ~enbit;
 103                 r |= clkbit;
 104                 twl_i2c_write_u8(TWL4030_MODULE_INTBR, r, TWL_INTBR_GPBR1);
 105                 r |= enbit;
 106         } else {
 107                 /* first disable PWM output, then clock */
 108                 r &= ~enbit;
 109                 twl_i2c_write_u8(TWL4030_MODULE_INTBR, r, TWL_INTBR_GPBR1);
 110                 r &= ~clkbit;
 111         }
 112
 113         twl_i2c_write_u8(TWL4030_MODULE_INTBR, r, TWL_INTBR_GPBR1);
 114 }
 115
 116 static void twl4030_pwmled_work(struct work_struct *work)
 117 {
 118         struct twl4030_pwmled *led;
 119         int val;
 120
 121         led = container_of(work, struct twl4030_pwmled, work);
 122
 123         if (led->new_brightness == LED_OFF) {
 124                 if (led->old_brightness != LED_OFF)
 125                         led->enable(led->id, 0);
 126                 goto out;
 127         }
 128
 129         val = led->new_brightness * 0x7f / LED_FULL;
 130         /* avoid 0: on = off = 0 means full brightness */
 131         if (val == 0)
 132                 val = 1;
 133
 134         twl_i2c_write_u8(led->module, val, TWL4030_PWMx_PWMxOFF);
 135
 136         if (led->old_brightness == LED_OFF)
 137                 led->enable(led->id, 1);
 138
 139 out:
 140         led->old_brightness = led->new_brightness;
 141 }
 142
 143 static void twl4030_pwmled_brightness(struct led_classdev *cdev,
 144                 enum led_brightness b)
 145 {
 146         struct twl4030_pwmled *led;
 147
 148         led = container_of(cdev, struct twl4030_pwmled, cdev);
 149         led->new_brightness = b;
 150         schedule_work(&led->work);
 151 }
 152
 153 static int __devinit twl4030_pwmled_probe(struct platform_device *pdev)
 154 {
 155         const struct led_pwm_platform_data *pdata = pdev->dev.platform_data;
 156         struct twl4030_pwmled *led, *leds;
 157         int ret;
 158         int i;
 159
 160         pdata = pdev->dev.platform_data;
 161         if (!pdata || pdata->num_leds < 1 || pdata->num_leds > 4)
 162                 return -ENODEV;
 163
 164         leds = kcalloc(pdata->num_leds, sizeof(*leds), GFP_KERNEL);
 165         if (!leds)
 166                 return -ENOMEM;
 167
 168         for (i = 0; i < pdata->num_leds; i++) {
 169                 led = &leds[i];
 170                 led->cdev.name = pdata->leds[i].name;
 171                 led->cdev.brightness = LED_OFF;
 172                 led->cdev.brightness_set = twl4030_pwmled_brightness;
 173                 led->cdev.default_trigger = pdata->leds[i].default_trigger;
 174                 led->id = pdata->leds[i].pwm_id;
 175                 led->old_brightness = -1; /* unknown */
 176
 177                 switch (pdata->leds[i].pwm_id) {
 178                 case TWL4030_LEDA:
 179                         led->module = TWL4030_MODULE_PWMA;
 180                         led->enable = twl4030_enable_ledab;
 181                         break;
 182                 case TWL4030_LEDB:
 183                         led->module = TWL4030_MODULE_PWMB;
 184                         led->enable = twl4030_enable_ledab;
 185                         break;
 186                 case TWL4030_PWM0:
 187                         led->module = TWL4030_MODULE_PWM0;
 188                         led->enable = twl4030_enable_pwm01;
 189                         /* enable PWM0 in pin mux */
 190                         twl4030_clear_set(TWL4030_MODULE_INTBR,
 191                                 0x0c, 0x04, TWL_INTBR_PMBR1);
 192                         break;
 193                 case TWL4030_PWM1:
 194                         led->module = TWL4030_MODULE_PWM1;
 195                         led->enable = twl4030_enable_pwm01;
 196                         twl4030_clear_set(TWL4030_MODULE_INTBR,
 197                                 0, 0x30, TWL_INTBR_PMBR1);
 198                         break;
 199                 default:
 200                         dev_err(&pdev->dev, "invalid pwm_id: %d\n",
 201                                 pdata->leds->pwm_id);
 202                         ret = -ENODEV;
 203                         goto err;
 204                 }
 205                 INIT_WORK(&led->work, twl4030_pwmled_work);
 206
 207                 twl_i2c_write_u8(led->module, 0, TWL4030_PWMx_PWMxON);
 208
 209                 /* Hand it over to the LED framework */
 210                 ret = led_classdev_register(&pdev->dev, &led->cdev);
 211                 if (ret < 0)
 212                         goto err;
 213         }
 214
 215         platform_set_drvdata(pdev, leds);
 216         return 0;
 217
 218 err:
 219         for (--i; i >= 0; i--)
 220                 led_classdev_unregister(&leds[i].cdev);
 221         kfree(leds);
 222
 223         return ret;
 224 }
 225
 226 static int __devexit twl4030_pwmled_remove(struct platform_device *pdev)
 227 {
 228         const struct led_pwm_platform_data *pdata = pdev->dev.platform_data;
 229         struct twl4030_pwmled *leds;
 230         int i;
 231
 232         leds = platform_get_drvdata(pdev);
 233
 234         for (i = 0; i < pdata->num_leds; i++) {
 235                 led_classdev_unregister(&leds[i].cdev);
 236                 cancel_work_sync(&leds[i].work);
 237         }
 238
 239         kfree(leds);
 240         platform_set_drvdata(pdev, NULL);
 241         return 0;
 242 }
 243
 244 static struct platform_driver twl4030_pwmled_driver = {
 245         .driver = {
 246                 .name   = "leds-twl4030-pwm",
 247                 .owner  = THIS_MODULE,
 248         },
 249         .probe  = twl4030_pwmled_probe,
 250         .remove = __devexit_p(twl4030_pwmled_remove),
 251 };
 252
 253 static int __init twl4030_pwm_init(void)
 254 {
 255         return platform_driver_register(&twl4030_pwmled_driver);
 256 }
 257 module_init(twl4030_pwm_init);
 258
 259 static void __exit twl4030_pwm_exit(void)
 260 {
 261         platform_driver_unregister(&twl4030_pwmled_driver);
 262 }
 263 module_exit(twl4030_pwm_exit);
 264
 265 MODULE_AUTHOR("Gražvydas Ignotas");
 266 MODULE_DESCRIPTION("Driver for TWL4030 PWM controlled LEDs");
 267 MODULE_LICENSE("GPL");
 268 MODULE_ALIAS("platform:leds-twl4030-pwm");