drivers/pwm/pwm-twl-led.c

   1 /*
   2  * Driver for TWL4030/6030 Pulse Width Modulator used as LED driver
   3  *
   4  * Copyright (C) 2012 Texas Instruments
   5  * Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
   6  *
   7  * This driver is a complete rewrite of the former pwm-twl6030.c authorded by:
   8  * Hemanth V <hemanthv@ti.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU General Public License version 2 as published by
  12  * the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful, but WITHOUT
  15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17  * more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along with
  20  * this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/of.h>
  25 #include <linux/platform_device.h>
  26 #include <linux/pwm.h>
  27 #include <linux/i2c/twl.h>
  28 #include <linux/slab.h>
  29
  30 /*
  31  * This driver handles the PWM driven LED terminals of TWL4030 and TWL6030.
  32  * To generate the signal on TWL4030:
  33  *  - LEDA uses PWMA
  34  *  - LEDB uses PWMB
  35  * TWL6030 has one LED pin with dedicated LEDPWM
  36  */
  37
  38 #define TWL4030_LED_MAX         0x7f
  39 #define TWL6030_LED_MAX         0xff
  40
  41 /* Registers, bits and macro for TWL4030 */
  42 #define TWL4030_LEDEN_REG       0x00
  43 #define TWL4030_PWMA_REG        0x01
  44
  45 #define TWL4030_LEDXON          (1 << 0)
  46 #define TWL4030_LEDXPWM         (1 << 4)
  47 #define TWL4030_LED_PINS        (TWL4030_LEDXON | TWL4030_LEDXPWM)
  48 #define TWL4030_LED_TOGGLE(led, x)      ((x) << (led))
  49
  50 /* Register, bits and macro for TWL6030 */
  51 #define TWL6030_LED_PWM_CTRL1   0xf4
  52 #define TWL6030_LED_PWM_CTRL2   0xf5
  53
  54 #define TWL6040_LED_MODE_HW     0x00
  55 #define TWL6040_LED_MODE_ON     0x01
  56 #define TWL6040_LED_MODE_OFF    0x02
  57 #define TWL6040_LED_MODE_MASK   0x03
  58
  59 struct twl_pwmled_chip {
  60         struct pwm_chip chip;
  61         struct mutex mutex;
  62 };
  63
  64 static inline struct twl_pwmled_chip *to_twl(struct pwm_chip *chip)
  65 {
  66         return container_of(chip, struct twl_pwmled_chip, chip);
  67 }
  68
  69 static int twl4030_pwmled_config(struct pwm_chip *chip, struct pwm_device *pwm,
  70                               int duty_ns, int period_ns)
  71 {
  72         int duty_cycle = DIV_ROUND_UP(duty_ns * TWL4030_LED_MAX, period_ns) + 1;
  73         u8 pwm_config[2] = { 1, 0 };
  74         int base, ret;
  75
  76         /*
  77          * To configure the duty period:
  78          * On-cycle is set to 1 (the minimum allowed value)
  79          * The off time of 0 is not configurable, so the mapping is:
  80          * 0 -> off cycle = 2,
  81          * 1 -> off cycle = 2,
  82          * 2 -> off cycle = 3,
  83          * 126 - > off cycle 127,
  84          * 127 - > off cycle 1
  85          * When on cycle == off cycle the PWM will be always on
  86          */
  87         if (duty_cycle == 1)
  88                 duty_cycle = 2;
  89         else if (duty_cycle > TWL4030_LED_MAX)
  90                 duty_cycle = 1;
  91
  92         base = pwm->hwpwm * 2 + TWL4030_PWMA_REG;
  93
  94         pwm_config[1] = duty_cycle;
  95
  96         ret = twl_i2c_write(TWL4030_MODULE_LED, pwm_config, base, 2);
  97         if (ret < 0)
  98                 dev_err(chip->dev, "%s: Failed to configure PWM\n", pwm->label);
  99
 100         return ret;
 101 }
 102
 103 static int twl4030_pwmled_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 104 {
 105         struct twl_pwmled_chip *twl = to_twl(chip);
 106         int ret;
 107         u8 val;
 108
 109         mutex_lock(&twl->mutex);
 110         ret = twl_i2c_read_u8(TWL4030_MODULE_LED, &val, TWL4030_LEDEN_REG);
 111         if (ret < 0) {
 112                 dev_err(chip->dev, "%s: Failed to read LEDEN\n", pwm->label);
 113                 goto out;
 114         }
 115
 116         val |= TWL4030_LED_TOGGLE(pwm->hwpwm, TWL4030_LED_PINS);
 117
 118         ret = twl_i2c_write_u8(TWL4030_MODULE_LED, val, TWL4030_LEDEN_REG);
 119         if (ret < 0)
 120                 dev_err(chip->dev, "%s: Failed to enable PWM\n", pwm->label);
 121
 122 out:
 123         mutex_unlock(&twl->mutex);
 124         return ret;
 125 }
 126
 127 static void twl4030_pwmled_disable(struct pwm_chip *chip,
 128                                    struct pwm_device *pwm)
 129 {
 130         struct twl_pwmled_chip *twl = to_twl(chip);
 131         int ret;
 132         u8 val;
 133
 134         mutex_lock(&twl->mutex);
 135         ret = twl_i2c_read_u8(TWL4030_MODULE_LED, &val, TWL4030_LEDEN_REG);
 136         if (ret < 0) {
 137                 dev_err(chip->dev, "%s: Failed to read LEDEN\n", pwm->label);
 138                 goto out;
 139         }
 140
 141         val &= ~TWL4030_LED_TOGGLE(pwm->hwpwm, TWL4030_LED_PINS);
 142
 143         ret = twl_i2c_write_u8(TWL4030_MODULE_LED, val, TWL4030_LEDEN_REG);
 144         if (ret < 0)
 145                 dev_err(chip->dev, "%s: Failed to disable PWM\n", pwm->label);
 146
 147 out:
 148         mutex_unlock(&twl->mutex);
 149 }
 150
 151 static int twl6030_pwmled_config(struct pwm_chip *chip, struct pwm_device *pwm,
 152                               int duty_ns, int period_ns)
 153 {
 154         int duty_cycle = (duty_ns * TWL6030_LED_MAX) / period_ns;
 155         u8 on_time;
 156         int ret;
 157
 158         on_time = duty_cycle & 0xff;
 159
 160         ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, on_time,
 161                                TWL6030_LED_PWM_CTRL1);
 162         if (ret < 0)
 163                 dev_err(chip->dev, "%s: Failed to configure PWM\n", pwm->label);
 164
 165         return ret;
 166 }
 167
 168 static int twl6030_pwmled_enable(struct pwm_chip *chip, struct pwm_device *pwm)
 169 {
 170         struct twl_pwmled_chip *twl = to_twl(chip);
 171         int ret;
 172         u8 val;
 173
 174         mutex_lock(&twl->mutex);
 175         ret = twl_i2c_read_u8(TWL6030_MODULE_ID1, &val, TWL6030_LED_PWM_CTRL2);
 176         if (ret < 0) {
 177                 dev_err(chip->dev, "%s: Failed to read PWM_CTRL2\n",
 178                         pwm->label);
 179                 goto out;
 180         }
 181
 182         val &= ~TWL6040_LED_MODE_MASK;
 183         val |= TWL6040_LED_MODE_ON;
 184
 185         ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, val, TWL6030_LED_PWM_CTRL2);
 186         if (ret < 0)
 187                 dev_err(chip->dev, "%s: Failed to enable PWM\n", pwm->label);
 188
 189 out:
 190         mutex_unlock(&twl->mutex);
 191         return ret;
 192 }
 193
 194 static void twl6030_pwmled_disable(struct pwm_chip *chip,
 195                                    struct pwm_device *pwm)
 196 {
 197         struct twl_pwmled_chip *twl = to_twl(chip);
 198         int ret;
 199         u8 val;
 200
 201         mutex_lock(&twl->mutex);
 202         ret = twl_i2c_read_u8(TWL6030_MODULE_ID1, &val, TWL6030_LED_PWM_CTRL2);
 203         if (ret < 0) {
 204                 dev_err(chip->dev, "%s: Failed to read PWM_CTRL2\n",
 205                         pwm->label);
 206                 goto out;
 207         }
 208
 209         val &= ~TWL6040_LED_MODE_MASK;
 210         val |= TWL6040_LED_MODE_OFF;
 211
 212         ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, val, TWL6030_LED_PWM_CTRL2);
 213         if (ret < 0)
 214                 dev_err(chip->dev, "%s: Failed to disable PWM\n", pwm->label);
 215
 216 out:
 217         mutex_unlock(&twl->mutex);
 218 }
 219
 220 static int twl6030_pwmled_request(struct pwm_chip *chip, struct pwm_device *pwm)
 221 {
 222         struct twl_pwmled_chip *twl = to_twl(chip);
 223         int ret;
 224         u8 val;
 225
 226         mutex_lock(&twl->mutex);
 227         ret = twl_i2c_read_u8(TWL6030_MODULE_ID1, &val, TWL6030_LED_PWM_CTRL2);
 228         if (ret < 0) {
 229                 dev_err(chip->dev, "%s: Failed to read PWM_CTRL2\n",
 230                         pwm->label);
 231                 goto out;
 232         }
 233
 234         val &= ~TWL6040_LED_MODE_MASK;
 235         val |= TWL6040_LED_MODE_OFF;
 236
 237         ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, val, TWL6030_LED_PWM_CTRL2);
 238         if (ret < 0)
 239                 dev_err(chip->dev, "%s: Failed to request PWM\n", pwm->label);
 240
 241 out:
 242         mutex_unlock(&twl->mutex);
 243         return ret;
 244 }
 245
 246 static void twl6030_pwmled_free(struct pwm_chip *chip, struct pwm_device *pwm)
 247 {
 248         struct twl_pwmled_chip *twl = to_twl(chip);
 249         int ret;
 250         u8 val;
 251
 252         mutex_lock(&twl->mutex);
 253         ret = twl_i2c_read_u8(TWL6030_MODULE_ID1, &val, TWL6030_LED_PWM_CTRL2);
 254         if (ret < 0) {
 255                 dev_err(chip->dev, "%s: Failed to read PWM_CTRL2\n",
 256                         pwm->label);
 257                 goto out;
 258         }
 259
 260         val &= ~TWL6040_LED_MODE_MASK;
 261         val |= TWL6040_LED_MODE_HW;
 262
 263         ret = twl_i2c_write_u8(TWL6030_MODULE_ID1, val, TWL6030_LED_PWM_CTRL2);
 264         if (ret < 0)
 265                 dev_err(chip->dev, "%s: Failed to free PWM\n", pwm->label);
 266
 267 out:
 268         mutex_unlock(&twl->mutex);
 269 }
 270
 271 static const struct pwm_ops twl4030_pwmled_ops = {
 272         .enable = twl4030_pwmled_enable,
 273         .disable = twl4030_pwmled_disable,
 274         .config = twl4030_pwmled_config,
 275         .owner = THIS_MODULE,
 276 };
 277
 278 static const struct pwm_ops twl6030_pwmled_ops = {
 279         .enable = twl6030_pwmled_enable,
 280         .disable = twl6030_pwmled_disable,
 281         .config = twl6030_pwmled_config,
 282         .request = twl6030_pwmled_request,
 283         .free = twl6030_pwmled_free,
 284         .owner = THIS_MODULE,
 285 };
 286
 287 static int twl_pwmled_probe(struct platform_device *pdev)
 288 {
 289         struct twl_pwmled_chip *twl;
 290         int ret;
 291
 292         twl = devm_kzalloc(&pdev->dev, sizeof(*twl), GFP_KERNEL);
 293         if (!twl)
 294                 return -ENOMEM;
 295
 296         if (twl_class_is_4030()) {
 297                 twl->chip.ops = &twl4030_pwmled_ops;
 298                 twl->chip.npwm = 2;
 299         } else {
 300                 twl->chip.ops = &twl6030_pwmled_ops;
 301                 twl->chip.npwm = 1;
 302         }
 303
 304         twl->chip.dev = &pdev->dev;
 305         twl->chip.base = -1;
 306         twl->chip.can_sleep = true;
 307
 308         mutex_init(&twl->mutex);
 309
 310         ret = pwmchip_add(&twl->chip);
 311         if (ret < 0)
 312                 return ret;
 313
 314         platform_set_drvdata(pdev, twl);
 315
 316         return 0;
 317 }
 318
 319 static int twl_pwmled_remove(struct platform_device *pdev)
 320 {
 321         struct twl_pwmled_chip *twl = platform_get_drvdata(pdev);
 322
 323         return pwmchip_remove(&twl->chip);
 324 }
 325
 326 #ifdef CONFIG_OF
 327 static const struct of_device_id twl_pwmled_of_match[] = {
 328         { .compatible = "ti,twl4030-pwmled" },
 329         { .compatible = "ti,twl6030-pwmled" },
 330         { },
 331 };
 332 MODULE_DEVICE_TABLE(of, twl_pwmled_of_match);
 333 #endif
 334
 335 static struct platform_driver twl_pwmled_driver = {
 336         .driver = {
 337                 .name = "twl-pwmled",
 338                 .of_match_table = of_match_ptr(twl_pwmled_of_match),
 339         },
 340         .probe = twl_pwmled_probe,
 341         .remove = twl_pwmled_remove,
 342 };
 343 module_platform_driver(twl_pwmled_driver);
 344
 345 MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@ti.com>");
 346 MODULE_DESCRIPTION("PWM driver for TWL4030 and TWL6030 LED outputs");
 347 MODULE_ALIAS("platform:twl-pwmled");
 348 MODULE_LICENSE("GPL");