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