1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for PCA9685 16-channel 12-bit PWM LED controller 4 * 5 * Copyright (C) 2013 Steffen Trumtrar <s.trumtrar@pengutronix.de> 6 * Copyright (C) 2015 Clemens Gruber <clemens.gruber@pqgruber.com> 7 * 8 * based on the pwm-twl-led.c driver 9 */ 10 11 #include <linux/acpi.h> 12 #include <linux/gpio/driver.h> 13 #include <linux/i2c.h> 14 #include <linux/module.h> 15 #include <linux/mutex.h> 16 #include <linux/platform_device.h> 17 #include <linux/property.h> 18 #include <linux/pwm.h> 19 #include <linux/regmap.h> 20 #include <linux/slab.h> 21 #include <linux/delay.h> 22 #include <linux/pm_runtime.h> 23 #include <linux/bitmap.h> 24 25 /* 26 * Because the PCA9685 has only one prescaler per chip, changing the period of 27 * one channel affects the period of all 16 PWM outputs! 28 * However, the ratio between each configured duty cycle and the chip-wide 29 * period remains constant, because the OFF time is set in proportion to the 30 * counter range. 31 */ 32 33 #define PCA9685_MODE1 0x00 34 #define PCA9685_MODE2 0x01 35 #define PCA9685_SUBADDR1 0x02 36 #define PCA9685_SUBADDR2 0x03 37 #define PCA9685_SUBADDR3 0x04 38 #define PCA9685_ALLCALLADDR 0x05 39 #define PCA9685_LEDX_ON_L 0x06 40 #define PCA9685_LEDX_ON_H 0x07 41 #define PCA9685_LEDX_OFF_L 0x08 42 #define PCA9685_LEDX_OFF_H 0x09 43 44 #define PCA9685_ALL_LED_ON_L 0xFA 45 #define PCA9685_ALL_LED_ON_H 0xFB 46 #define PCA9685_ALL_LED_OFF_L 0xFC 47 #define PCA9685_ALL_LED_OFF_H 0xFD 48 #define PCA9685_PRESCALE 0xFE 49 50 #define PCA9685_PRESCALE_MIN 0x03 /* => max. frequency of 1526 Hz */ 51 #define PCA9685_PRESCALE_MAX 0xFF /* => min. frequency of 24 Hz */ 52 53 #define PCA9685_COUNTER_RANGE 4096 54 #define PCA9685_OSC_CLOCK_MHZ 25 /* Internal oscillator with 25 MHz */ 55 56 #define PCA9685_NUMREGS 0xFF 57 #define PCA9685_MAXCHAN 0x10 58 59 #define LED_FULL BIT(4) 60 #define MODE1_ALLCALL BIT(0) 61 #define MODE1_SUB3 BIT(1) 62 #define MODE1_SUB2 BIT(2) 63 #define MODE1_SUB1 BIT(3) 64 #define MODE1_SLEEP BIT(4) 65 #define MODE2_INVRT BIT(4) 66 #define MODE2_OUTDRV BIT(2) 67 68 #define LED_N_ON_H(N) (PCA9685_LEDX_ON_H + (4 * (N))) 69 #define LED_N_ON_L(N) (PCA9685_LEDX_ON_L + (4 * (N))) 70 #define LED_N_OFF_H(N) (PCA9685_LEDX_OFF_H + (4 * (N))) 71 #define LED_N_OFF_L(N) (PCA9685_LEDX_OFF_L + (4 * (N))) 72 73 #define REG_ON_H(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_ON_H : LED_N_ON_H((C))) 74 #define REG_ON_L(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_ON_L : LED_N_ON_L((C))) 75 #define REG_OFF_H(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_OFF_H : LED_N_OFF_H((C))) 76 #define REG_OFF_L(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_OFF_L : LED_N_OFF_L((C))) 77 78 struct pca9685 { 79 struct pwm_chip chip; 80 struct regmap *regmap; 81 #if IS_ENABLED(CONFIG_GPIOLIB) 82 struct mutex lock; 83 struct gpio_chip gpio; 84 DECLARE_BITMAP(pwms_inuse, PCA9685_MAXCHAN + 1); 85 #endif 86 }; 87 88 static inline struct pca9685 *to_pca(struct pwm_chip *chip) 89 { 90 return container_of(chip, struct pca9685, chip); 91 } 92 93 /* Helper function to set the duty cycle ratio to duty/4096 (e.g. duty=2048 -> 50%) */ 94 static void pca9685_pwm_set_duty(struct pca9685 *pca, int channel, unsigned int duty) 95 { 96 if (duty == 0) { 97 /* Set the full OFF bit, which has the highest precedence */ 98 regmap_write(pca->regmap, REG_OFF_H(channel), LED_FULL); 99 } else if (duty >= PCA9685_COUNTER_RANGE) { 100 /* Set the full ON bit and clear the full OFF bit */ 101 regmap_write(pca->regmap, REG_ON_H(channel), LED_FULL); 102 regmap_write(pca->regmap, REG_OFF_H(channel), 0); 103 } else { 104 /* Set OFF time (clears the full OFF bit) */ 105 regmap_write(pca->regmap, REG_OFF_L(channel), duty & 0xff); 106 regmap_write(pca->regmap, REG_OFF_H(channel), (duty >> 8) & 0xf); 107 /* Clear the full ON bit */ 108 regmap_write(pca->regmap, REG_ON_H(channel), 0); 109 } 110 } 111 112 static unsigned int pca9685_pwm_get_duty(struct pca9685 *pca, int channel) 113 { 114 unsigned int off_h = 0, val = 0; 115 116 if (WARN_ON(channel >= PCA9685_MAXCHAN)) { 117 /* HW does not support reading state of "all LEDs" channel */ 118 return 0; 119 } 120 121 regmap_read(pca->regmap, LED_N_OFF_H(channel), &off_h); 122 if (off_h & LED_FULL) { 123 /* Full OFF bit is set */ 124 return 0; 125 } 126 127 regmap_read(pca->regmap, LED_N_ON_H(channel), &val); 128 if (val & LED_FULL) { 129 /* Full ON bit is set */ 130 return PCA9685_COUNTER_RANGE; 131 } 132 133 if (regmap_read(pca->regmap, LED_N_OFF_L(channel), &val)) { 134 /* Reset val to 0 in case reading LED_N_OFF_L failed */ 135 val = 0; 136 } 137 return ((off_h & 0xf) << 8) | (val & 0xff); 138 } 139 140 #if IS_ENABLED(CONFIG_GPIOLIB) 141 static bool pca9685_pwm_test_and_set_inuse(struct pca9685 *pca, int pwm_idx) 142 { 143 bool is_inuse; 144 145 mutex_lock(&pca->lock); 146 if (pwm_idx >= PCA9685_MAXCHAN) { 147 /* 148 * "All LEDs" channel: 149 * pretend already in use if any of the PWMs are requested 150 */ 151 if (!bitmap_empty(pca->pwms_inuse, PCA9685_MAXCHAN)) { 152 is_inuse = true; 153 goto out; 154 } 155 } else { 156 /* 157 * Regular channel: 158 * pretend already in use if the "all LEDs" channel is requested 159 */ 160 if (test_bit(PCA9685_MAXCHAN, pca->pwms_inuse)) { 161 is_inuse = true; 162 goto out; 163 } 164 } 165 is_inuse = test_and_set_bit(pwm_idx, pca->pwms_inuse); 166 out: 167 mutex_unlock(&pca->lock); 168 return is_inuse; 169 } 170 171 static void pca9685_pwm_clear_inuse(struct pca9685 *pca, int pwm_idx) 172 { 173 mutex_lock(&pca->lock); 174 clear_bit(pwm_idx, pca->pwms_inuse); 175 mutex_unlock(&pca->lock); 176 } 177 178 static int pca9685_pwm_gpio_request(struct gpio_chip *gpio, unsigned int offset) 179 { 180 struct pca9685 *pca = gpiochip_get_data(gpio); 181 182 if (pca9685_pwm_test_and_set_inuse(pca, offset)) 183 return -EBUSY; 184 pm_runtime_get_sync(pca->chip.dev); 185 return 0; 186 } 187 188 static int pca9685_pwm_gpio_get(struct gpio_chip *gpio, unsigned int offset) 189 { 190 struct pca9685 *pca = gpiochip_get_data(gpio); 191 192 return pca9685_pwm_get_duty(pca, offset) != 0; 193 } 194 195 static void pca9685_pwm_gpio_set(struct gpio_chip *gpio, unsigned int offset, 196 int value) 197 { 198 struct pca9685 *pca = gpiochip_get_data(gpio); 199 200 pca9685_pwm_set_duty(pca, offset, value ? PCA9685_COUNTER_RANGE : 0); 201 } 202 203 static void pca9685_pwm_gpio_free(struct gpio_chip *gpio, unsigned int offset) 204 { 205 struct pca9685 *pca = gpiochip_get_data(gpio); 206 207 pca9685_pwm_set_duty(pca, offset, 0); 208 pm_runtime_put(pca->chip.dev); 209 pca9685_pwm_clear_inuse(pca, offset); 210 } 211 212 static int pca9685_pwm_gpio_get_direction(struct gpio_chip *chip, 213 unsigned int offset) 214 { 215 /* Always out */ 216 return GPIO_LINE_DIRECTION_OUT; 217 } 218 219 static int pca9685_pwm_gpio_direction_input(struct gpio_chip *gpio, 220 unsigned int offset) 221 { 222 return -EINVAL; 223 } 224 225 static int pca9685_pwm_gpio_direction_output(struct gpio_chip *gpio, 226 unsigned int offset, int value) 227 { 228 pca9685_pwm_gpio_set(gpio, offset, value); 229 230 return 0; 231 } 232 233 /* 234 * The PCA9685 has a bit for turning the PWM output full off or on. Some 235 * boards like Intel Galileo actually uses these as normal GPIOs so we 236 * expose a GPIO chip here which can exclusively take over the underlying 237 * PWM channel. 238 */ 239 static int pca9685_pwm_gpio_probe(struct pca9685 *pca) 240 { 241 struct device *dev = pca->chip.dev; 242 243 mutex_init(&pca->lock); 244 245 pca->gpio.label = dev_name(dev); 246 pca->gpio.parent = dev; 247 pca->gpio.request = pca9685_pwm_gpio_request; 248 pca->gpio.free = pca9685_pwm_gpio_free; 249 pca->gpio.get_direction = pca9685_pwm_gpio_get_direction; 250 pca->gpio.direction_input = pca9685_pwm_gpio_direction_input; 251 pca->gpio.direction_output = pca9685_pwm_gpio_direction_output; 252 pca->gpio.get = pca9685_pwm_gpio_get; 253 pca->gpio.set = pca9685_pwm_gpio_set; 254 pca->gpio.base = -1; 255 pca->gpio.ngpio = PCA9685_MAXCHAN; 256 pca->gpio.can_sleep = true; 257 258 return devm_gpiochip_add_data(dev, &pca->gpio, pca); 259 } 260 #else 261 static inline bool pca9685_pwm_test_and_set_inuse(struct pca9685 *pca, 262 int pwm_idx) 263 { 264 return false; 265 } 266 267 static inline void 268 pca9685_pwm_clear_inuse(struct pca9685 *pca, int pwm_idx) 269 { 270 } 271 272 static inline int pca9685_pwm_gpio_probe(struct pca9685 *pca) 273 { 274 return 0; 275 } 276 #endif 277 278 static void pca9685_set_sleep_mode(struct pca9685 *pca, bool enable) 279 { 280 regmap_update_bits(pca->regmap, PCA9685_MODE1, 281 MODE1_SLEEP, enable ? MODE1_SLEEP : 0); 282 if (!enable) { 283 /* Wait 500us for the oscillator to be back up */ 284 udelay(500); 285 } 286 } 287 288 static int pca9685_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, 289 const struct pwm_state *state) 290 { 291 struct pca9685 *pca = to_pca(chip); 292 unsigned long long duty, prescale; 293 unsigned int val = 0; 294 295 if (state->polarity != PWM_POLARITY_NORMAL) 296 return -EINVAL; 297 298 prescale = DIV_ROUND_CLOSEST_ULL(PCA9685_OSC_CLOCK_MHZ * state->period, 299 PCA9685_COUNTER_RANGE * 1000) - 1; 300 if (prescale < PCA9685_PRESCALE_MIN || prescale > PCA9685_PRESCALE_MAX) { 301 dev_err(chip->dev, "pwm not changed: period out of bounds!\n"); 302 return -EINVAL; 303 } 304 305 if (!state->enabled) { 306 pca9685_pwm_set_duty(pca, pwm->hwpwm, 0); 307 return 0; 308 } 309 310 regmap_read(pca->regmap, PCA9685_PRESCALE, &val); 311 if (prescale != val) { 312 /* 313 * Putting the chip briefly into SLEEP mode 314 * at this point won't interfere with the 315 * pm_runtime framework, because the pm_runtime 316 * state is guaranteed active here. 317 */ 318 /* Put chip into sleep mode */ 319 pca9685_set_sleep_mode(pca, true); 320 321 /* Change the chip-wide output frequency */ 322 regmap_write(pca->regmap, PCA9685_PRESCALE, prescale); 323 324 /* Wake the chip up */ 325 pca9685_set_sleep_mode(pca, false); 326 } 327 328 duty = PCA9685_COUNTER_RANGE * state->duty_cycle; 329 duty = DIV_ROUND_UP_ULL(duty, state->period); 330 pca9685_pwm_set_duty(pca, pwm->hwpwm, duty); 331 return 0; 332 } 333 334 static void pca9685_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm, 335 struct pwm_state *state) 336 { 337 struct pca9685 *pca = to_pca(chip); 338 unsigned long long duty; 339 unsigned int val = 0; 340 341 /* Calculate (chip-wide) period from prescale value */ 342 regmap_read(pca->regmap, PCA9685_PRESCALE, &val); 343 /* 344 * PCA9685_OSC_CLOCK_MHZ is 25, i.e. an integer divider of 1000. 345 * The following calculation is therefore only a multiplication 346 * and we are not losing precision. 347 */ 348 state->period = (PCA9685_COUNTER_RANGE * 1000 / PCA9685_OSC_CLOCK_MHZ) * 349 (val + 1); 350 351 /* The (per-channel) polarity is fixed */ 352 state->polarity = PWM_POLARITY_NORMAL; 353 354 if (pwm->hwpwm >= PCA9685_MAXCHAN) { 355 /* 356 * The "all LEDs" channel does not support HW readout 357 * Return 0 and disabled for backwards compatibility 358 */ 359 state->duty_cycle = 0; 360 state->enabled = false; 361 return; 362 } 363 364 state->enabled = true; 365 duty = pca9685_pwm_get_duty(pca, pwm->hwpwm); 366 state->duty_cycle = DIV_ROUND_DOWN_ULL(duty * state->period, PCA9685_COUNTER_RANGE); 367 } 368 369 static int pca9685_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm) 370 { 371 struct pca9685 *pca = to_pca(chip); 372 373 if (pca9685_pwm_test_and_set_inuse(pca, pwm->hwpwm)) 374 return -EBUSY; 375 pm_runtime_get_sync(chip->dev); 376 377 return 0; 378 } 379 380 static void pca9685_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm) 381 { 382 struct pca9685 *pca = to_pca(chip); 383 384 pca9685_pwm_set_duty(pca, pwm->hwpwm, 0); 385 pm_runtime_put(chip->dev); 386 pca9685_pwm_clear_inuse(pca, pwm->hwpwm); 387 } 388 389 static const struct pwm_ops pca9685_pwm_ops = { 390 .apply = pca9685_pwm_apply, 391 .get_state = pca9685_pwm_get_state, 392 .request = pca9685_pwm_request, 393 .free = pca9685_pwm_free, 394 .owner = THIS_MODULE, 395 }; 396 397 static const struct regmap_config pca9685_regmap_i2c_config = { 398 .reg_bits = 8, 399 .val_bits = 8, 400 .max_register = PCA9685_NUMREGS, 401 .cache_type = REGCACHE_NONE, 402 }; 403 404 static int pca9685_pwm_probe(struct i2c_client *client, 405 const struct i2c_device_id *id) 406 { 407 struct pca9685 *pca; 408 unsigned int reg; 409 int ret; 410 411 pca = devm_kzalloc(&client->dev, sizeof(*pca), GFP_KERNEL); 412 if (!pca) 413 return -ENOMEM; 414 415 pca->regmap = devm_regmap_init_i2c(client, &pca9685_regmap_i2c_config); 416 if (IS_ERR(pca->regmap)) { 417 ret = PTR_ERR(pca->regmap); 418 dev_err(&client->dev, "Failed to initialize register map: %d\n", 419 ret); 420 return ret; 421 } 422 423 i2c_set_clientdata(client, pca); 424 425 regmap_read(pca->regmap, PCA9685_MODE2, ®); 426 427 if (device_property_read_bool(&client->dev, "invert")) 428 reg |= MODE2_INVRT; 429 else 430 reg &= ~MODE2_INVRT; 431 432 if (device_property_read_bool(&client->dev, "open-drain")) 433 reg &= ~MODE2_OUTDRV; 434 else 435 reg |= MODE2_OUTDRV; 436 437 regmap_write(pca->regmap, PCA9685_MODE2, reg); 438 439 /* Disable all LED ALLCALL and SUBx addresses to avoid bus collisions */ 440 regmap_read(pca->regmap, PCA9685_MODE1, ®); 441 reg &= ~(MODE1_ALLCALL | MODE1_SUB1 | MODE1_SUB2 | MODE1_SUB3); 442 regmap_write(pca->regmap, PCA9685_MODE1, reg); 443 444 /* Reset OFF registers to POR default */ 445 regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_L, LED_FULL); 446 regmap_write(pca->regmap, PCA9685_ALL_LED_OFF_H, LED_FULL); 447 448 pca->chip.ops = &pca9685_pwm_ops; 449 /* Add an extra channel for ALL_LED */ 450 pca->chip.npwm = PCA9685_MAXCHAN + 1; 451 452 pca->chip.dev = &client->dev; 453 454 ret = pwmchip_add(&pca->chip); 455 if (ret < 0) 456 return ret; 457 458 ret = pca9685_pwm_gpio_probe(pca); 459 if (ret < 0) { 460 pwmchip_remove(&pca->chip); 461 return ret; 462 } 463 464 pm_runtime_enable(&client->dev); 465 466 if (pm_runtime_enabled(&client->dev)) { 467 /* 468 * Although the chip comes out of power-up in the sleep state, 469 * we force it to sleep in case it was woken up before 470 */ 471 pca9685_set_sleep_mode(pca, true); 472 pm_runtime_set_suspended(&client->dev); 473 } else { 474 /* Wake the chip up if runtime PM is disabled */ 475 pca9685_set_sleep_mode(pca, false); 476 } 477 478 return 0; 479 } 480 481 static int pca9685_pwm_remove(struct i2c_client *client) 482 { 483 struct pca9685 *pca = i2c_get_clientdata(client); 484 int ret; 485 486 ret = pwmchip_remove(&pca->chip); 487 if (ret) 488 return ret; 489 490 if (!pm_runtime_enabled(&client->dev)) { 491 /* Put chip in sleep state if runtime PM is disabled */ 492 pca9685_set_sleep_mode(pca, true); 493 } 494 495 pm_runtime_disable(&client->dev); 496 497 return 0; 498 } 499 500 static int __maybe_unused pca9685_pwm_runtime_suspend(struct device *dev) 501 { 502 struct i2c_client *client = to_i2c_client(dev); 503 struct pca9685 *pca = i2c_get_clientdata(client); 504 505 pca9685_set_sleep_mode(pca, true); 506 return 0; 507 } 508 509 static int __maybe_unused pca9685_pwm_runtime_resume(struct device *dev) 510 { 511 struct i2c_client *client = to_i2c_client(dev); 512 struct pca9685 *pca = i2c_get_clientdata(client); 513 514 pca9685_set_sleep_mode(pca, false); 515 return 0; 516 } 517 518 static const struct i2c_device_id pca9685_id[] = { 519 { "pca9685", 0 }, 520 { /* sentinel */ }, 521 }; 522 MODULE_DEVICE_TABLE(i2c, pca9685_id); 523 524 #ifdef CONFIG_ACPI 525 static const struct acpi_device_id pca9685_acpi_ids[] = { 526 { "INT3492", 0 }, 527 { /* sentinel */ }, 528 }; 529 MODULE_DEVICE_TABLE(acpi, pca9685_acpi_ids); 530 #endif 531 532 #ifdef CONFIG_OF 533 static const struct of_device_id pca9685_dt_ids[] = { 534 { .compatible = "nxp,pca9685-pwm", }, 535 { /* sentinel */ } 536 }; 537 MODULE_DEVICE_TABLE(of, pca9685_dt_ids); 538 #endif 539 540 static const struct dev_pm_ops pca9685_pwm_pm = { 541 SET_RUNTIME_PM_OPS(pca9685_pwm_runtime_suspend, 542 pca9685_pwm_runtime_resume, NULL) 543 }; 544 545 static struct i2c_driver pca9685_i2c_driver = { 546 .driver = { 547 .name = "pca9685-pwm", 548 .acpi_match_table = ACPI_PTR(pca9685_acpi_ids), 549 .of_match_table = of_match_ptr(pca9685_dt_ids), 550 .pm = &pca9685_pwm_pm, 551 }, 552 .probe = pca9685_pwm_probe, 553 .remove = pca9685_pwm_remove, 554 .id_table = pca9685_id, 555 }; 556 557 module_i2c_driver(pca9685_i2c_driver); 558 559 MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>"); 560 MODULE_DESCRIPTION("PWM driver for PCA9685"); 561 MODULE_LICENSE("GPL"); 562