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"); 349