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