xref: /linux/drivers/pwm/pwm-pca9685.c (revision d0e99511834b6828c960e978d9a8cb6e5731250d)
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, &reg);
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, &reg);
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_new = 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