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