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, only the first channel 27 * that is enabled is allowed to change the prescale register. 28 * PWM channels requested afterwards must use a period that results in the same 29 * prescale setting as the one set by the first requested channel. 30 * GPIOs do not count as enabled PWMs as they are not using the prescaler. 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 struct mutex lock; 82 DECLARE_BITMAP(pwms_enabled, PCA9685_MAXCHAN + 1); 83 #if IS_ENABLED(CONFIG_GPIOLIB) 84 struct gpio_chip gpio; 85 DECLARE_BITMAP(pwms_inuse, PCA9685_MAXCHAN + 1); 86 #endif 87 }; 88 89 static inline struct pca9685 *to_pca(struct pwm_chip *chip) 90 { 91 return container_of(chip, struct pca9685, chip); 92 } 93 94 /* This function is supposed to be called with the lock mutex held */ 95 static bool pca9685_prescaler_can_change(struct pca9685 *pca, int channel) 96 { 97 /* No PWM enabled: Change allowed */ 98 if (bitmap_empty(pca->pwms_enabled, PCA9685_MAXCHAN + 1)) 99 return true; 100 /* More than one PWM enabled: Change not allowed */ 101 if (bitmap_weight(pca->pwms_enabled, PCA9685_MAXCHAN + 1) > 1) 102 return false; 103 /* 104 * Only one PWM enabled: Change allowed if the PWM about to 105 * be changed is the one that is already enabled 106 */ 107 return test_bit(channel, pca->pwms_enabled); 108 } 109 110 static int pca9685_read_reg(struct pca9685 *pca, unsigned int reg, unsigned int *val) 111 { 112 struct device *dev = pca->chip.dev; 113 int err; 114 115 err = regmap_read(pca->regmap, reg, val); 116 if (err) 117 dev_err(dev, "regmap_read of register 0x%x failed: %pe\n", reg, ERR_PTR(err)); 118 119 return err; 120 } 121 122 static int pca9685_write_reg(struct pca9685 *pca, unsigned int reg, unsigned int val) 123 { 124 struct device *dev = pca->chip.dev; 125 int err; 126 127 err = regmap_write(pca->regmap, reg, val); 128 if (err) 129 dev_err(dev, "regmap_write to register 0x%x failed: %pe\n", reg, ERR_PTR(err)); 130 131 return err; 132 } 133 134 /* Helper function to set the duty cycle ratio to duty/4096 (e.g. duty=2048 -> 50%) */ 135 static void pca9685_pwm_set_duty(struct pca9685 *pca, int channel, unsigned int duty) 136 { 137 struct pwm_device *pwm = &pca->chip.pwms[channel]; 138 unsigned int on, off; 139 140 if (duty == 0) { 141 /* Set the full OFF bit, which has the highest precedence */ 142 pca9685_write_reg(pca, REG_OFF_H(channel), LED_FULL); 143 return; 144 } else if (duty >= PCA9685_COUNTER_RANGE) { 145 /* Set the full ON bit and clear the full OFF bit */ 146 pca9685_write_reg(pca, REG_ON_H(channel), LED_FULL); 147 pca9685_write_reg(pca, REG_OFF_H(channel), 0); 148 return; 149 } 150 151 152 if (pwm->state.usage_power && channel < PCA9685_MAXCHAN) { 153 /* 154 * If usage_power is set, the pca9685 driver will phase shift 155 * the individual channels relative to their channel number. 156 * This improves EMI because the enabled channels no longer 157 * turn on at the same time, while still maintaining the 158 * configured duty cycle / power output. 159 */ 160 on = channel * PCA9685_COUNTER_RANGE / PCA9685_MAXCHAN; 161 } else 162 on = 0; 163 164 off = (on + duty) % PCA9685_COUNTER_RANGE; 165 166 /* Set ON time (clears full ON bit) */ 167 pca9685_write_reg(pca, REG_ON_L(channel), on & 0xff); 168 pca9685_write_reg(pca, REG_ON_H(channel), (on >> 8) & 0xf); 169 /* Set OFF time (clears full OFF bit) */ 170 pca9685_write_reg(pca, REG_OFF_L(channel), off & 0xff); 171 pca9685_write_reg(pca, REG_OFF_H(channel), (off >> 8) & 0xf); 172 } 173 174 static unsigned int pca9685_pwm_get_duty(struct pca9685 *pca, int channel) 175 { 176 struct pwm_device *pwm = &pca->chip.pwms[channel]; 177 unsigned int off = 0, on = 0, val = 0; 178 179 if (WARN_ON(channel >= PCA9685_MAXCHAN)) { 180 /* HW does not support reading state of "all LEDs" channel */ 181 return 0; 182 } 183 184 pca9685_read_reg(pca, LED_N_OFF_H(channel), &off); 185 if (off & LED_FULL) { 186 /* Full OFF bit is set */ 187 return 0; 188 } 189 190 pca9685_read_reg(pca, LED_N_ON_H(channel), &on); 191 if (on & LED_FULL) { 192 /* Full ON bit is set */ 193 return PCA9685_COUNTER_RANGE; 194 } 195 196 pca9685_read_reg(pca, LED_N_OFF_L(channel), &val); 197 off = ((off & 0xf) << 8) | (val & 0xff); 198 if (!pwm->state.usage_power) 199 return off; 200 201 /* Read ON register to calculate duty cycle of staggered output */ 202 if (pca9685_read_reg(pca, LED_N_ON_L(channel), &val)) { 203 /* Reset val to 0 in case reading LED_N_ON_L failed */ 204 val = 0; 205 } 206 on = ((on & 0xf) << 8) | (val & 0xff); 207 return (off - on) & (PCA9685_COUNTER_RANGE - 1); 208 } 209 210 #if IS_ENABLED(CONFIG_GPIOLIB) 211 static bool pca9685_pwm_test_and_set_inuse(struct pca9685 *pca, int pwm_idx) 212 { 213 bool is_inuse; 214 215 mutex_lock(&pca->lock); 216 if (pwm_idx >= PCA9685_MAXCHAN) { 217 /* 218 * "All LEDs" channel: 219 * pretend already in use if any of the PWMs are requested 220 */ 221 if (!bitmap_empty(pca->pwms_inuse, PCA9685_MAXCHAN)) { 222 is_inuse = true; 223 goto out; 224 } 225 } else { 226 /* 227 * Regular channel: 228 * pretend already in use if the "all LEDs" channel is requested 229 */ 230 if (test_bit(PCA9685_MAXCHAN, pca->pwms_inuse)) { 231 is_inuse = true; 232 goto out; 233 } 234 } 235 is_inuse = test_and_set_bit(pwm_idx, pca->pwms_inuse); 236 out: 237 mutex_unlock(&pca->lock); 238 return is_inuse; 239 } 240 241 static void pca9685_pwm_clear_inuse(struct pca9685 *pca, int pwm_idx) 242 { 243 mutex_lock(&pca->lock); 244 clear_bit(pwm_idx, pca->pwms_inuse); 245 mutex_unlock(&pca->lock); 246 } 247 248 static int pca9685_pwm_gpio_request(struct gpio_chip *gpio, unsigned int offset) 249 { 250 struct pca9685 *pca = gpiochip_get_data(gpio); 251 252 if (pca9685_pwm_test_and_set_inuse(pca, offset)) 253 return -EBUSY; 254 pm_runtime_get_sync(pca->chip.dev); 255 return 0; 256 } 257 258 static int pca9685_pwm_gpio_get(struct gpio_chip *gpio, unsigned int offset) 259 { 260 struct pca9685 *pca = gpiochip_get_data(gpio); 261 262 return pca9685_pwm_get_duty(pca, offset) != 0; 263 } 264 265 static void pca9685_pwm_gpio_set(struct gpio_chip *gpio, unsigned int offset, 266 int value) 267 { 268 struct pca9685 *pca = gpiochip_get_data(gpio); 269 270 pca9685_pwm_set_duty(pca, offset, value ? PCA9685_COUNTER_RANGE : 0); 271 } 272 273 static void pca9685_pwm_gpio_free(struct gpio_chip *gpio, unsigned int offset) 274 { 275 struct pca9685 *pca = gpiochip_get_data(gpio); 276 277 pca9685_pwm_set_duty(pca, offset, 0); 278 pm_runtime_put(pca->chip.dev); 279 pca9685_pwm_clear_inuse(pca, offset); 280 } 281 282 static int pca9685_pwm_gpio_get_direction(struct gpio_chip *chip, 283 unsigned int offset) 284 { 285 /* Always out */ 286 return GPIO_LINE_DIRECTION_OUT; 287 } 288 289 static int pca9685_pwm_gpio_direction_input(struct gpio_chip *gpio, 290 unsigned int offset) 291 { 292 return -EINVAL; 293 } 294 295 static int pca9685_pwm_gpio_direction_output(struct gpio_chip *gpio, 296 unsigned int offset, int value) 297 { 298 pca9685_pwm_gpio_set(gpio, offset, value); 299 300 return 0; 301 } 302 303 /* 304 * The PCA9685 has a bit for turning the PWM output full off or on. Some 305 * boards like Intel Galileo actually uses these as normal GPIOs so we 306 * expose a GPIO chip here which can exclusively take over the underlying 307 * PWM channel. 308 */ 309 static int pca9685_pwm_gpio_probe(struct pca9685 *pca) 310 { 311 struct device *dev = pca->chip.dev; 312 313 pca->gpio.label = dev_name(dev); 314 pca->gpio.parent = dev; 315 pca->gpio.request = pca9685_pwm_gpio_request; 316 pca->gpio.free = pca9685_pwm_gpio_free; 317 pca->gpio.get_direction = pca9685_pwm_gpio_get_direction; 318 pca->gpio.direction_input = pca9685_pwm_gpio_direction_input; 319 pca->gpio.direction_output = pca9685_pwm_gpio_direction_output; 320 pca->gpio.get = pca9685_pwm_gpio_get; 321 pca->gpio.set = pca9685_pwm_gpio_set; 322 pca->gpio.base = -1; 323 pca->gpio.ngpio = PCA9685_MAXCHAN; 324 pca->gpio.can_sleep = true; 325 326 return devm_gpiochip_add_data(dev, &pca->gpio, pca); 327 } 328 #else 329 static inline bool pca9685_pwm_test_and_set_inuse(struct pca9685 *pca, 330 int pwm_idx) 331 { 332 return false; 333 } 334 335 static inline void 336 pca9685_pwm_clear_inuse(struct pca9685 *pca, int pwm_idx) 337 { 338 } 339 340 static inline int pca9685_pwm_gpio_probe(struct pca9685 *pca) 341 { 342 return 0; 343 } 344 #endif 345 346 static void pca9685_set_sleep_mode(struct pca9685 *pca, bool enable) 347 { 348 struct device *dev = pca->chip.dev; 349 int err = regmap_update_bits(pca->regmap, PCA9685_MODE1, 350 MODE1_SLEEP, enable ? MODE1_SLEEP : 0); 351 if (err) { 352 dev_err(dev, "regmap_update_bits of register 0x%x failed: %pe\n", 353 PCA9685_MODE1, ERR_PTR(err)); 354 return; 355 } 356 357 if (!enable) { 358 /* Wait 500us for the oscillator to be back up */ 359 udelay(500); 360 } 361 } 362 363 static int __pca9685_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, 364 const struct pwm_state *state) 365 { 366 struct pca9685 *pca = to_pca(chip); 367 unsigned long long duty, prescale; 368 unsigned int val = 0; 369 370 if (state->polarity != PWM_POLARITY_NORMAL) 371 return -EINVAL; 372 373 prescale = DIV_ROUND_CLOSEST_ULL(PCA9685_OSC_CLOCK_MHZ * state->period, 374 PCA9685_COUNTER_RANGE * 1000) - 1; 375 if (prescale < PCA9685_PRESCALE_MIN || prescale > PCA9685_PRESCALE_MAX) { 376 dev_err(chip->dev, "pwm not changed: period out of bounds!\n"); 377 return -EINVAL; 378 } 379 380 if (!state->enabled) { 381 pca9685_pwm_set_duty(pca, pwm->hwpwm, 0); 382 return 0; 383 } 384 385 pca9685_read_reg(pca, PCA9685_PRESCALE, &val); 386 if (prescale != val) { 387 if (!pca9685_prescaler_can_change(pca, pwm->hwpwm)) { 388 dev_err(chip->dev, 389 "pwm not changed: periods of enabled pwms must match!\n"); 390 return -EBUSY; 391 } 392 393 /* 394 * Putting the chip briefly into SLEEP mode 395 * at this point won't interfere with the 396 * pm_runtime framework, because the pm_runtime 397 * state is guaranteed active here. 398 */ 399 /* Put chip into sleep mode */ 400 pca9685_set_sleep_mode(pca, true); 401 402 /* Change the chip-wide output frequency */ 403 pca9685_write_reg(pca, PCA9685_PRESCALE, prescale); 404 405 /* Wake the chip up */ 406 pca9685_set_sleep_mode(pca, false); 407 } 408 409 duty = PCA9685_COUNTER_RANGE * state->duty_cycle; 410 duty = DIV_ROUND_UP_ULL(duty, state->period); 411 pca9685_pwm_set_duty(pca, pwm->hwpwm, duty); 412 return 0; 413 } 414 415 static int pca9685_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, 416 const struct pwm_state *state) 417 { 418 struct pca9685 *pca = to_pca(chip); 419 int ret; 420 421 mutex_lock(&pca->lock); 422 ret = __pca9685_pwm_apply(chip, pwm, state); 423 if (ret == 0) { 424 if (state->enabled) 425 set_bit(pwm->hwpwm, pca->pwms_enabled); 426 else 427 clear_bit(pwm->hwpwm, pca->pwms_enabled); 428 } 429 mutex_unlock(&pca->lock); 430 431 return ret; 432 } 433 434 static int pca9685_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm, 435 struct pwm_state *state) 436 { 437 struct pca9685 *pca = to_pca(chip); 438 unsigned long long duty; 439 unsigned int val = 0; 440 441 /* Calculate (chip-wide) period from prescale value */ 442 pca9685_read_reg(pca, PCA9685_PRESCALE, &val); 443 /* 444 * PCA9685_OSC_CLOCK_MHZ is 25, i.e. an integer divider of 1000. 445 * The following calculation is therefore only a multiplication 446 * and we are not losing precision. 447 */ 448 state->period = (PCA9685_COUNTER_RANGE * 1000 / PCA9685_OSC_CLOCK_MHZ) * 449 (val + 1); 450 451 /* The (per-channel) polarity is fixed */ 452 state->polarity = PWM_POLARITY_NORMAL; 453 454 if (pwm->hwpwm >= PCA9685_MAXCHAN) { 455 /* 456 * The "all LEDs" channel does not support HW readout 457 * Return 0 and disabled for backwards compatibility 458 */ 459 state->duty_cycle = 0; 460 state->enabled = false; 461 return 0; 462 } 463 464 state->enabled = true; 465 duty = pca9685_pwm_get_duty(pca, pwm->hwpwm); 466 state->duty_cycle = DIV_ROUND_DOWN_ULL(duty * state->period, PCA9685_COUNTER_RANGE); 467 468 return 0; 469 } 470 471 static int pca9685_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm) 472 { 473 struct pca9685 *pca = to_pca(chip); 474 475 if (pca9685_pwm_test_and_set_inuse(pca, pwm->hwpwm)) 476 return -EBUSY; 477 478 if (pwm->hwpwm < PCA9685_MAXCHAN) { 479 /* PWMs - except the "all LEDs" channel - default to enabled */ 480 mutex_lock(&pca->lock); 481 set_bit(pwm->hwpwm, pca->pwms_enabled); 482 mutex_unlock(&pca->lock); 483 } 484 485 pm_runtime_get_sync(chip->dev); 486 487 return 0; 488 } 489 490 static void pca9685_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm) 491 { 492 struct pca9685 *pca = to_pca(chip); 493 494 mutex_lock(&pca->lock); 495 pca9685_pwm_set_duty(pca, pwm->hwpwm, 0); 496 clear_bit(pwm->hwpwm, pca->pwms_enabled); 497 mutex_unlock(&pca->lock); 498 499 pm_runtime_put(chip->dev); 500 pca9685_pwm_clear_inuse(pca, pwm->hwpwm); 501 } 502 503 static const struct pwm_ops pca9685_pwm_ops = { 504 .apply = pca9685_pwm_apply, 505 .get_state = pca9685_pwm_get_state, 506 .request = pca9685_pwm_request, 507 .free = pca9685_pwm_free, 508 .owner = THIS_MODULE, 509 }; 510 511 static const struct regmap_config pca9685_regmap_i2c_config = { 512 .reg_bits = 8, 513 .val_bits = 8, 514 .max_register = PCA9685_NUMREGS, 515 .cache_type = REGCACHE_NONE, 516 }; 517 518 static int pca9685_pwm_probe(struct i2c_client *client) 519 { 520 struct pca9685 *pca; 521 unsigned int reg; 522 int ret; 523 524 pca = devm_kzalloc(&client->dev, sizeof(*pca), GFP_KERNEL); 525 if (!pca) 526 return -ENOMEM; 527 528 pca->regmap = devm_regmap_init_i2c(client, &pca9685_regmap_i2c_config); 529 if (IS_ERR(pca->regmap)) { 530 ret = PTR_ERR(pca->regmap); 531 dev_err(&client->dev, "Failed to initialize register map: %d\n", 532 ret); 533 return ret; 534 } 535 536 i2c_set_clientdata(client, pca); 537 538 mutex_init(&pca->lock); 539 540 ret = pca9685_read_reg(pca, PCA9685_MODE2, ®); 541 if (ret) 542 return ret; 543 544 if (device_property_read_bool(&client->dev, "invert")) 545 reg |= MODE2_INVRT; 546 else 547 reg &= ~MODE2_INVRT; 548 549 if (device_property_read_bool(&client->dev, "open-drain")) 550 reg &= ~MODE2_OUTDRV; 551 else 552 reg |= MODE2_OUTDRV; 553 554 ret = pca9685_write_reg(pca, PCA9685_MODE2, reg); 555 if (ret) 556 return ret; 557 558 /* Disable all LED ALLCALL and SUBx addresses to avoid bus collisions */ 559 pca9685_read_reg(pca, PCA9685_MODE1, ®); 560 reg &= ~(MODE1_ALLCALL | MODE1_SUB1 | MODE1_SUB2 | MODE1_SUB3); 561 pca9685_write_reg(pca, PCA9685_MODE1, reg); 562 563 /* Reset OFF/ON registers to POR default */ 564 pca9685_write_reg(pca, PCA9685_ALL_LED_OFF_L, 0); 565 pca9685_write_reg(pca, PCA9685_ALL_LED_OFF_H, LED_FULL); 566 pca9685_write_reg(pca, PCA9685_ALL_LED_ON_L, 0); 567 pca9685_write_reg(pca, PCA9685_ALL_LED_ON_H, LED_FULL); 568 569 pca->chip.ops = &pca9685_pwm_ops; 570 /* Add an extra channel for ALL_LED */ 571 pca->chip.npwm = PCA9685_MAXCHAN + 1; 572 573 pca->chip.dev = &client->dev; 574 575 ret = pwmchip_add(&pca->chip); 576 if (ret < 0) 577 return ret; 578 579 ret = pca9685_pwm_gpio_probe(pca); 580 if (ret < 0) { 581 pwmchip_remove(&pca->chip); 582 return ret; 583 } 584 585 pm_runtime_enable(&client->dev); 586 587 if (pm_runtime_enabled(&client->dev)) { 588 /* 589 * Although the chip comes out of power-up in the sleep state, 590 * we force it to sleep in case it was woken up before 591 */ 592 pca9685_set_sleep_mode(pca, true); 593 pm_runtime_set_suspended(&client->dev); 594 } else { 595 /* Wake the chip up if runtime PM is disabled */ 596 pca9685_set_sleep_mode(pca, false); 597 } 598 599 return 0; 600 } 601 602 static void pca9685_pwm_remove(struct i2c_client *client) 603 { 604 struct pca9685 *pca = i2c_get_clientdata(client); 605 606 pwmchip_remove(&pca->chip); 607 608 if (!pm_runtime_enabled(&client->dev)) { 609 /* Put chip in sleep state if runtime PM is disabled */ 610 pca9685_set_sleep_mode(pca, true); 611 } 612 613 pm_runtime_disable(&client->dev); 614 } 615 616 static int __maybe_unused pca9685_pwm_runtime_suspend(struct device *dev) 617 { 618 struct i2c_client *client = to_i2c_client(dev); 619 struct pca9685 *pca = i2c_get_clientdata(client); 620 621 pca9685_set_sleep_mode(pca, true); 622 return 0; 623 } 624 625 static int __maybe_unused pca9685_pwm_runtime_resume(struct device *dev) 626 { 627 struct i2c_client *client = to_i2c_client(dev); 628 struct pca9685 *pca = i2c_get_clientdata(client); 629 630 pca9685_set_sleep_mode(pca, false); 631 return 0; 632 } 633 634 static const struct i2c_device_id pca9685_id[] = { 635 { "pca9685", 0 }, 636 { /* sentinel */ }, 637 }; 638 MODULE_DEVICE_TABLE(i2c, pca9685_id); 639 640 #ifdef CONFIG_ACPI 641 static const struct acpi_device_id pca9685_acpi_ids[] = { 642 { "INT3492", 0 }, 643 { /* sentinel */ }, 644 }; 645 MODULE_DEVICE_TABLE(acpi, pca9685_acpi_ids); 646 #endif 647 648 #ifdef CONFIG_OF 649 static const struct of_device_id pca9685_dt_ids[] = { 650 { .compatible = "nxp,pca9685-pwm", }, 651 { /* sentinel */ } 652 }; 653 MODULE_DEVICE_TABLE(of, pca9685_dt_ids); 654 #endif 655 656 static const struct dev_pm_ops pca9685_pwm_pm = { 657 SET_RUNTIME_PM_OPS(pca9685_pwm_runtime_suspend, 658 pca9685_pwm_runtime_resume, NULL) 659 }; 660 661 static struct i2c_driver pca9685_i2c_driver = { 662 .driver = { 663 .name = "pca9685-pwm", 664 .acpi_match_table = ACPI_PTR(pca9685_acpi_ids), 665 .of_match_table = of_match_ptr(pca9685_dt_ids), 666 .pm = &pca9685_pwm_pm, 667 }, 668 .probe = pca9685_pwm_probe, 669 .remove = pca9685_pwm_remove, 670 .id_table = pca9685_id, 671 }; 672 673 module_i2c_driver(pca9685_i2c_driver); 674 675 MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>"); 676 MODULE_DESCRIPTION("PWM driver for PCA9685"); 677 MODULE_LICENSE("GPL"); 678