2019-06-02 22:44:50 -07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2013-05-30 00:50:12 -07:00
|
|
|
/*
|
|
|
|
* Driver for PCA9685 16-channel 12-bit PWM LED controller
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013 Steffen Trumtrar <s.trumtrar@pengutronix.de>
|
pwm-pca9685: Support changing the output frequency
Previously, period_ns and duty_ns were only used to determine the
ratio of ON and OFF time, the default frequency of 200 Hz was never
changed.
The PCA9685 however is capable of changing the PWM output frequency,
which is expected when changing the period.
This patch configures the prescaler accordingly, using the formula
and notes provided in the PCA9685 datasheet.
Bounds checking for the minimum and maximum frequencies, last updated
in revision v.4 of said datasheet, is also added.
The prescaler is only touched if the period changed, because we have to
put the chip into sleep mode to unlock the prescale register.
If it is changed, the PWM output frequency changes for all outputs,
because there is one prescaler per chip. This is documented in the
PCA9685 datasheet and in the comments.
If the duty cycle is not changed at the same time as the period, then
we restart the PWM output using the duty cycle to period ratio from
before the period change.
When using LEDs for example, previously set brightness levels stay the
same when the frequency changes.
Cc: Thierry Reding <thierry.reding@gmail.com>
Cc: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Signed-off-by: Clemens Gruber <clemens.gruber@pqgruber.com>
Signed-off-by: Thierry Reding <thierry.reding@gmail.com>
2015-07-23 08:19:02 -07:00
|
|
|
* Copyright (C) 2015 Clemens Gruber <clemens.gruber@pqgruber.com>
|
2013-05-30 00:50:12 -07:00
|
|
|
*
|
|
|
|
* based on the pwm-twl-led.c driver
|
|
|
|
*/
|
|
|
|
|
2015-10-07 03:18:49 -07:00
|
|
|
#include <linux/acpi.h>
|
2016-09-20 07:40:56 -07:00
|
|
|
#include <linux/gpio/driver.h>
|
2013-05-30 00:50:12 -07:00
|
|
|
#include <linux/i2c.h>
|
|
|
|
#include <linux/module.h>
|
2016-09-20 07:40:56 -07:00
|
|
|
#include <linux/mutex.h>
|
2013-05-30 00:50:12 -07:00
|
|
|
#include <linux/platform_device.h>
|
2015-10-07 03:18:49 -07:00
|
|
|
#include <linux/property.h>
|
2013-05-30 00:50:12 -07:00
|
|
|
#include <linux/pwm.h>
|
|
|
|
#include <linux/regmap.h>
|
|
|
|
#include <linux/slab.h>
|
pwm-pca9685: Support changing the output frequency
Previously, period_ns and duty_ns were only used to determine the
ratio of ON and OFF time, the default frequency of 200 Hz was never
changed.
The PCA9685 however is capable of changing the PWM output frequency,
which is expected when changing the period.
This patch configures the prescaler accordingly, using the formula
and notes provided in the PCA9685 datasheet.
Bounds checking for the minimum and maximum frequencies, last updated
in revision v.4 of said datasheet, is also added.
The prescaler is only touched if the period changed, because we have to
put the chip into sleep mode to unlock the prescale register.
If it is changed, the PWM output frequency changes for all outputs,
because there is one prescaler per chip. This is documented in the
PCA9685 datasheet and in the comments.
If the duty cycle is not changed at the same time as the period, then
we restart the PWM output using the duty cycle to period ratio from
before the period change.
When using LEDs for example, previously set brightness levels stay the
same when the frequency changes.
Cc: Thierry Reding <thierry.reding@gmail.com>
Cc: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Signed-off-by: Clemens Gruber <clemens.gruber@pqgruber.com>
Signed-off-by: Thierry Reding <thierry.reding@gmail.com>
2015-07-23 08:19:02 -07:00
|
|
|
#include <linux/delay.h>
|
2017-04-13 05:58:11 -07:00
|
|
|
#include <linux/pm_runtime.h>
|
2020-04-01 10:01:06 -07:00
|
|
|
#include <linux/bitmap.h>
|
pwm-pca9685: Support changing the output frequency
Previously, period_ns and duty_ns were only used to determine the
ratio of ON and OFF time, the default frequency of 200 Hz was never
changed.
The PCA9685 however is capable of changing the PWM output frequency,
which is expected when changing the period.
This patch configures the prescaler accordingly, using the formula
and notes provided in the PCA9685 datasheet.
Bounds checking for the minimum and maximum frequencies, last updated
in revision v.4 of said datasheet, is also added.
The prescaler is only touched if the period changed, because we have to
put the chip into sleep mode to unlock the prescale register.
If it is changed, the PWM output frequency changes for all outputs,
because there is one prescaler per chip. This is documented in the
PCA9685 datasheet and in the comments.
If the duty cycle is not changed at the same time as the period, then
we restart the PWM output using the duty cycle to period ratio from
before the period change.
When using LEDs for example, previously set brightness levels stay the
same when the frequency changes.
Cc: Thierry Reding <thierry.reding@gmail.com>
Cc: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Signed-off-by: Clemens Gruber <clemens.gruber@pqgruber.com>
Signed-off-by: Thierry Reding <thierry.reding@gmail.com>
2015-07-23 08:19:02 -07:00
|
|
|
|
|
|
|
/*
|
2021-05-07 06:18:44 -07:00
|
|
|
* Because the PCA9685 has only one prescaler per chip, only the first channel
|
|
|
|
* that is enabled is allowed to change the prescale register.
|
|
|
|
* PWM channels requested afterwards must use a period that results in the same
|
|
|
|
* prescale setting as the one set by the first requested channel.
|
|
|
|
* GPIOs do not count as enabled PWMs as they are not using the prescaler.
|
pwm-pca9685: Support changing the output frequency
Previously, period_ns and duty_ns were only used to determine the
ratio of ON and OFF time, the default frequency of 200 Hz was never
changed.
The PCA9685 however is capable of changing the PWM output frequency,
which is expected when changing the period.
This patch configures the prescaler accordingly, using the formula
and notes provided in the PCA9685 datasheet.
Bounds checking for the minimum and maximum frequencies, last updated
in revision v.4 of said datasheet, is also added.
The prescaler is only touched if the period changed, because we have to
put the chip into sleep mode to unlock the prescale register.
If it is changed, the PWM output frequency changes for all outputs,
because there is one prescaler per chip. This is documented in the
PCA9685 datasheet and in the comments.
If the duty cycle is not changed at the same time as the period, then
we restart the PWM output using the duty cycle to period ratio from
before the period change.
When using LEDs for example, previously set brightness levels stay the
same when the frequency changes.
Cc: Thierry Reding <thierry.reding@gmail.com>
Cc: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Signed-off-by: Clemens Gruber <clemens.gruber@pqgruber.com>
Signed-off-by: Thierry Reding <thierry.reding@gmail.com>
2015-07-23 08:19:02 -07:00
|
|
|
*/
|
2013-05-30 00:50:12 -07:00
|
|
|
|
|
|
|
#define PCA9685_MODE1 0x00
|
|
|
|
#define PCA9685_MODE2 0x01
|
|
|
|
#define PCA9685_SUBADDR1 0x02
|
|
|
|
#define PCA9685_SUBADDR2 0x03
|
|
|
|
#define PCA9685_SUBADDR3 0x04
|
|
|
|
#define PCA9685_ALLCALLADDR 0x05
|
|
|
|
#define PCA9685_LEDX_ON_L 0x06
|
|
|
|
#define PCA9685_LEDX_ON_H 0x07
|
|
|
|
#define PCA9685_LEDX_OFF_L 0x08
|
|
|
|
#define PCA9685_LEDX_OFF_H 0x09
|
|
|
|
|
|
|
|
#define PCA9685_ALL_LED_ON_L 0xFA
|
|
|
|
#define PCA9685_ALL_LED_ON_H 0xFB
|
|
|
|
#define PCA9685_ALL_LED_OFF_L 0xFC
|
|
|
|
#define PCA9685_ALL_LED_OFF_H 0xFD
|
|
|
|
#define PCA9685_PRESCALE 0xFE
|
|
|
|
|
pwm-pca9685: Support changing the output frequency
Previously, period_ns and duty_ns were only used to determine the
ratio of ON and OFF time, the default frequency of 200 Hz was never
changed.
The PCA9685 however is capable of changing the PWM output frequency,
which is expected when changing the period.
This patch configures the prescaler accordingly, using the formula
and notes provided in the PCA9685 datasheet.
Bounds checking for the minimum and maximum frequencies, last updated
in revision v.4 of said datasheet, is also added.
The prescaler is only touched if the period changed, because we have to
put the chip into sleep mode to unlock the prescale register.
If it is changed, the PWM output frequency changes for all outputs,
because there is one prescaler per chip. This is documented in the
PCA9685 datasheet and in the comments.
If the duty cycle is not changed at the same time as the period, then
we restart the PWM output using the duty cycle to period ratio from
before the period change.
When using LEDs for example, previously set brightness levels stay the
same when the frequency changes.
Cc: Thierry Reding <thierry.reding@gmail.com>
Cc: Steffen Trumtrar <s.trumtrar@pengutronix.de>
Signed-off-by: Clemens Gruber <clemens.gruber@pqgruber.com>
Signed-off-by: Thierry Reding <thierry.reding@gmail.com>
2015-07-23 08:19:02 -07:00
|
|
|
#define PCA9685_PRESCALE_MIN 0x03 /* => max. frequency of 1526 Hz */
|
|
|
|
#define PCA9685_PRESCALE_MAX 0xFF /* => min. frequency of 24 Hz */
|
|
|
|
|
|
|
|
#define PCA9685_COUNTER_RANGE 4096
|
|
|
|
#define PCA9685_OSC_CLOCK_MHZ 25 /* Internal oscillator with 25 MHz */
|
|
|
|
|
2013-05-30 00:50:12 -07:00
|
|
|
#define PCA9685_NUMREGS 0xFF
|
|
|
|
#define PCA9685_MAXCHAN 0x10
|
|
|
|
|
2020-08-28 05:14:14 -07:00
|
|
|
#define LED_FULL BIT(4)
|
2020-08-28 05:14:15 -07:00
|
|
|
#define MODE1_ALLCALL BIT(0)
|
|
|
|
#define MODE1_SUB3 BIT(1)
|
|
|
|
#define MODE1_SUB2 BIT(2)
|
|
|
|
#define MODE1_SUB1 BIT(3)
|
2020-08-28 05:14:14 -07:00
|
|
|
#define MODE1_SLEEP BIT(4)
|
|
|
|
#define MODE2_INVRT BIT(4)
|
|
|
|
#define MODE2_OUTDRV BIT(2)
|
2013-05-30 00:50:12 -07:00
|
|
|
|
|
|
|
#define LED_N_ON_H(N) (PCA9685_LEDX_ON_H + (4 * (N)))
|
|
|
|
#define LED_N_ON_L(N) (PCA9685_LEDX_ON_L + (4 * (N)))
|
|
|
|
#define LED_N_OFF_H(N) (PCA9685_LEDX_OFF_H + (4 * (N)))
|
|
|
|
#define LED_N_OFF_L(N) (PCA9685_LEDX_OFF_L + (4 * (N)))
|
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
#define REG_ON_H(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_ON_H : LED_N_ON_H((C)))
|
|
|
|
#define REG_ON_L(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_ON_L : LED_N_ON_L((C)))
|
|
|
|
#define REG_OFF_H(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_OFF_H : LED_N_OFF_H((C)))
|
|
|
|
#define REG_OFF_L(C) ((C) >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_OFF_L : LED_N_OFF_L((C)))
|
|
|
|
|
2013-05-30 00:50:12 -07:00
|
|
|
struct pca9685 {
|
|
|
|
struct regmap *regmap;
|
2016-09-20 07:40:56 -07:00
|
|
|
struct mutex lock;
|
2021-05-07 06:18:44 -07:00
|
|
|
DECLARE_BITMAP(pwms_enabled, PCA9685_MAXCHAN + 1);
|
|
|
|
#if IS_ENABLED(CONFIG_GPIOLIB)
|
2016-09-20 07:40:56 -07:00
|
|
|
struct gpio_chip gpio;
|
2020-04-01 10:01:06 -07:00
|
|
|
DECLARE_BITMAP(pwms_inuse, PCA9685_MAXCHAN + 1);
|
2016-09-20 07:40:56 -07:00
|
|
|
#endif
|
2013-05-30 00:50:12 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline struct pca9685 *to_pca(struct pwm_chip *chip)
|
|
|
|
{
|
2024-02-14 02:32:10 -07:00
|
|
|
return pwmchip_get_drvdata(chip);
|
2013-05-30 00:50:12 -07:00
|
|
|
}
|
|
|
|
|
2021-05-07 06:18:44 -07:00
|
|
|
/* This function is supposed to be called with the lock mutex held */
|
|
|
|
static bool pca9685_prescaler_can_change(struct pca9685 *pca, int channel)
|
|
|
|
{
|
|
|
|
/* No PWM enabled: Change allowed */
|
|
|
|
if (bitmap_empty(pca->pwms_enabled, PCA9685_MAXCHAN + 1))
|
|
|
|
return true;
|
|
|
|
/* More than one PWM enabled: Change not allowed */
|
|
|
|
if (bitmap_weight(pca->pwms_enabled, PCA9685_MAXCHAN + 1) > 1)
|
|
|
|
return false;
|
|
|
|
/*
|
|
|
|
* Only one PWM enabled: Change allowed if the PWM about to
|
|
|
|
* be changed is the one that is already enabled
|
|
|
|
*/
|
|
|
|
return test_bit(channel, pca->pwms_enabled);
|
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
static int pca9685_read_reg(struct pwm_chip *chip, unsigned int reg, unsigned int *val)
|
2021-05-07 06:18:45 -07:00
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pca9685 *pca = to_pca(chip);
|
2024-02-14 02:32:09 -07:00
|
|
|
struct device *dev = pwmchip_parent(chip);
|
2021-05-07 06:18:45 -07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = regmap_read(pca->regmap, reg, val);
|
|
|
|
if (err)
|
|
|
|
dev_err(dev, "regmap_read of register 0x%x failed: %pe\n", reg, ERR_PTR(err));
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
static int pca9685_write_reg(struct pwm_chip *chip, unsigned int reg, unsigned int val)
|
2021-05-07 06:18:45 -07:00
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pca9685 *pca = to_pca(chip);
|
2024-02-14 02:32:09 -07:00
|
|
|
struct device *dev = pwmchip_parent(chip);
|
2021-05-07 06:18:45 -07:00
|
|
|
int err;
|
|
|
|
|
|
|
|
err = regmap_write(pca->regmap, reg, val);
|
|
|
|
if (err)
|
|
|
|
dev_err(dev, "regmap_write to register 0x%x failed: %pe\n", reg, ERR_PTR(err));
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
/* Helper function to set the duty cycle ratio to duty/4096 (e.g. duty=2048 -> 50%) */
|
2024-02-14 02:32:08 -07:00
|
|
|
static void pca9685_pwm_set_duty(struct pwm_chip *chip, int channel, unsigned int duty)
|
2021-04-15 05:14:48 -07:00
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_device *pwm = &chip->pwms[channel];
|
2021-05-07 06:18:43 -07:00
|
|
|
unsigned int on, off;
|
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
if (duty == 0) {
|
|
|
|
/* Set the full OFF bit, which has the highest precedence */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_write_reg(chip, REG_OFF_H(channel), LED_FULL);
|
2021-05-07 06:18:43 -07:00
|
|
|
return;
|
2021-04-15 05:14:48 -07:00
|
|
|
} else if (duty >= PCA9685_COUNTER_RANGE) {
|
|
|
|
/* Set the full ON bit and clear the full OFF bit */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_write_reg(chip, REG_ON_H(channel), LED_FULL);
|
|
|
|
pca9685_write_reg(chip, REG_OFF_H(channel), 0);
|
2021-05-07 06:18:43 -07:00
|
|
|
return;
|
2021-04-15 05:14:48 -07:00
|
|
|
}
|
2021-05-07 06:18:43 -07:00
|
|
|
|
|
|
|
|
|
|
|
if (pwm->state.usage_power && channel < PCA9685_MAXCHAN) {
|
|
|
|
/*
|
|
|
|
* If usage_power is set, the pca9685 driver will phase shift
|
|
|
|
* the individual channels relative to their channel number.
|
|
|
|
* This improves EMI because the enabled channels no longer
|
|
|
|
* turn on at the same time, while still maintaining the
|
|
|
|
* configured duty cycle / power output.
|
|
|
|
*/
|
|
|
|
on = channel * PCA9685_COUNTER_RANGE / PCA9685_MAXCHAN;
|
|
|
|
} else
|
|
|
|
on = 0;
|
|
|
|
|
|
|
|
off = (on + duty) % PCA9685_COUNTER_RANGE;
|
|
|
|
|
|
|
|
/* Set ON time (clears full ON bit) */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_write_reg(chip, REG_ON_L(channel), on & 0xff);
|
|
|
|
pca9685_write_reg(chip, REG_ON_H(channel), (on >> 8) & 0xf);
|
2021-05-07 06:18:43 -07:00
|
|
|
/* Set OFF time (clears full OFF bit) */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_write_reg(chip, REG_OFF_L(channel), off & 0xff);
|
|
|
|
pca9685_write_reg(chip, REG_OFF_H(channel), (off >> 8) & 0xf);
|
2021-04-15 05:14:48 -07:00
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
static unsigned int pca9685_pwm_get_duty(struct pwm_chip *chip, int channel)
|
2021-04-15 05:14:48 -07:00
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_device *pwm = &chip->pwms[channel];
|
2021-05-07 06:18:43 -07:00
|
|
|
unsigned int off = 0, on = 0, val = 0;
|
2021-04-15 05:14:48 -07:00
|
|
|
|
|
|
|
if (WARN_ON(channel >= PCA9685_MAXCHAN)) {
|
|
|
|
/* HW does not support reading state of "all LEDs" channel */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_read_reg(chip, LED_N_OFF_H(channel), &off);
|
2021-05-07 06:18:43 -07:00
|
|
|
if (off & LED_FULL) {
|
2021-04-15 05:14:48 -07:00
|
|
|
/* Full OFF bit is set */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_read_reg(chip, LED_N_ON_H(channel), &on);
|
2021-05-07 06:18:43 -07:00
|
|
|
if (on & LED_FULL) {
|
2021-04-15 05:14:48 -07:00
|
|
|
/* Full ON bit is set */
|
|
|
|
return PCA9685_COUNTER_RANGE;
|
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_read_reg(chip, LED_N_OFF_L(channel), &val);
|
2021-05-07 06:18:43 -07:00
|
|
|
off = ((off & 0xf) << 8) | (val & 0xff);
|
|
|
|
if (!pwm->state.usage_power)
|
|
|
|
return off;
|
|
|
|
|
|
|
|
/* Read ON register to calculate duty cycle of staggered output */
|
2024-02-14 02:32:08 -07:00
|
|
|
if (pca9685_read_reg(chip, LED_N_ON_L(channel), &val)) {
|
2021-05-07 06:18:43 -07:00
|
|
|
/* Reset val to 0 in case reading LED_N_ON_L failed */
|
2021-04-15 05:14:48 -07:00
|
|
|
val = 0;
|
|
|
|
}
|
2021-05-07 06:18:43 -07:00
|
|
|
on = ((on & 0xf) << 8) | (val & 0xff);
|
|
|
|
return (off - on) & (PCA9685_COUNTER_RANGE - 1);
|
2021-04-15 05:14:48 -07:00
|
|
|
}
|
|
|
|
|
2016-09-20 07:40:56 -07:00
|
|
|
#if IS_ENABLED(CONFIG_GPIOLIB)
|
2020-04-01 10:01:06 -07:00
|
|
|
static bool pca9685_pwm_test_and_set_inuse(struct pca9685 *pca, int pwm_idx)
|
2016-09-20 07:40:56 -07:00
|
|
|
{
|
2020-04-01 10:01:06 -07:00
|
|
|
bool is_inuse;
|
2016-09-20 07:40:56 -07:00
|
|
|
|
|
|
|
mutex_lock(&pca->lock);
|
2020-04-01 10:01:06 -07:00
|
|
|
if (pwm_idx >= PCA9685_MAXCHAN) {
|
|
|
|
/*
|
2020-08-28 05:14:13 -07:00
|
|
|
* "All LEDs" channel:
|
2020-04-01 10:01:06 -07:00
|
|
|
* pretend already in use if any of the PWMs are requested
|
|
|
|
*/
|
|
|
|
if (!bitmap_empty(pca->pwms_inuse, PCA9685_MAXCHAN)) {
|
|
|
|
is_inuse = true;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/*
|
2020-08-28 05:14:13 -07:00
|
|
|
* Regular channel:
|
2020-04-01 10:01:06 -07:00
|
|
|
* pretend already in use if the "all LEDs" channel is requested
|
|
|
|
*/
|
|
|
|
if (test_bit(PCA9685_MAXCHAN, pca->pwms_inuse)) {
|
|
|
|
is_inuse = true;
|
|
|
|
goto out;
|
|
|
|
}
|
2016-09-20 07:40:56 -07:00
|
|
|
}
|
2020-04-01 10:01:06 -07:00
|
|
|
is_inuse = test_and_set_bit(pwm_idx, pca->pwms_inuse);
|
|
|
|
out:
|
2016-09-20 07:40:56 -07:00
|
|
|
mutex_unlock(&pca->lock);
|
2020-04-01 10:01:06 -07:00
|
|
|
return is_inuse;
|
2016-09-20 07:40:56 -07:00
|
|
|
}
|
|
|
|
|
2020-04-01 10:01:06 -07:00
|
|
|
static void pca9685_pwm_clear_inuse(struct pca9685 *pca, int pwm_idx)
|
2016-09-20 07:40:56 -07:00
|
|
|
{
|
|
|
|
mutex_lock(&pca->lock);
|
2020-04-01 10:01:06 -07:00
|
|
|
clear_bit(pwm_idx, pca->pwms_inuse);
|
|
|
|
mutex_unlock(&pca->lock);
|
|
|
|
}
|
2016-09-20 07:40:56 -07:00
|
|
|
|
2020-04-01 10:01:06 -07:00
|
|
|
static int pca9685_pwm_gpio_request(struct gpio_chip *gpio, unsigned int offset)
|
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_chip *chip = gpiochip_get_data(gpio);
|
|
|
|
struct pca9685 *pca = to_pca(chip);
|
2016-09-20 07:40:56 -07:00
|
|
|
|
2020-04-01 10:01:06 -07:00
|
|
|
if (pca9685_pwm_test_and_set_inuse(pca, offset))
|
|
|
|
return -EBUSY;
|
2024-02-14 02:32:09 -07:00
|
|
|
pm_runtime_get_sync(pwmchip_parent(chip));
|
2020-04-01 10:01:06 -07:00
|
|
|
return 0;
|
2016-09-20 07:40:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int pca9685_pwm_gpio_get(struct gpio_chip *gpio, unsigned int offset)
|
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_chip *chip = gpiochip_get_data(gpio);
|
2016-09-20 07:40:56 -07:00
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
return pca9685_pwm_get_duty(chip, offset) != 0;
|
2016-09-20 07:40:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void pca9685_pwm_gpio_set(struct gpio_chip *gpio, unsigned int offset,
|
|
|
|
int value)
|
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_chip *chip = gpiochip_get_data(gpio);
|
2016-09-20 07:40:56 -07:00
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_pwm_set_duty(chip, offset, value ? PCA9685_COUNTER_RANGE : 0);
|
2016-09-20 07:40:56 -07:00
|
|
|
}
|
|
|
|
|
2017-04-13 05:58:11 -07:00
|
|
|
static void pca9685_pwm_gpio_free(struct gpio_chip *gpio, unsigned int offset)
|
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_chip *chip = gpiochip_get_data(gpio);
|
|
|
|
struct pca9685 *pca = to_pca(chip);
|
2017-04-13 05:58:11 -07:00
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_pwm_set_duty(chip, offset, 0);
|
2024-02-14 02:32:09 -07:00
|
|
|
pm_runtime_put(pwmchip_parent(chip));
|
2020-04-01 10:01:06 -07:00
|
|
|
pca9685_pwm_clear_inuse(pca, offset);
|
2017-04-13 05:58:11 -07:00
|
|
|
}
|
|
|
|
|
2016-09-20 07:40:56 -07:00
|
|
|
static int pca9685_pwm_gpio_get_direction(struct gpio_chip *chip,
|
|
|
|
unsigned int offset)
|
|
|
|
{
|
|
|
|
/* Always out */
|
2020-03-11 08:52:20 -07:00
|
|
|
return GPIO_LINE_DIRECTION_OUT;
|
2016-09-20 07:40:56 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int pca9685_pwm_gpio_direction_input(struct gpio_chip *gpio,
|
|
|
|
unsigned int offset)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pca9685_pwm_gpio_direction_output(struct gpio_chip *gpio,
|
|
|
|
unsigned int offset, int value)
|
|
|
|
{
|
|
|
|
pca9685_pwm_gpio_set(gpio, offset, value);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The PCA9685 has a bit for turning the PWM output full off or on. Some
|
|
|
|
* boards like Intel Galileo actually uses these as normal GPIOs so we
|
|
|
|
* expose a GPIO chip here which can exclusively take over the underlying
|
|
|
|
* PWM channel.
|
|
|
|
*/
|
2024-02-14 02:32:08 -07:00
|
|
|
static int pca9685_pwm_gpio_probe(struct pwm_chip *chip)
|
2016-09-20 07:40:56 -07:00
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pca9685 *pca = to_pca(chip);
|
2024-02-14 02:32:09 -07:00
|
|
|
struct device *dev = pwmchip_parent(chip);
|
2016-09-20 07:40:56 -07:00
|
|
|
|
|
|
|
pca->gpio.label = dev_name(dev);
|
|
|
|
pca->gpio.parent = dev;
|
|
|
|
pca->gpio.request = pca9685_pwm_gpio_request;
|
|
|
|
pca->gpio.free = pca9685_pwm_gpio_free;
|
|
|
|
pca->gpio.get_direction = pca9685_pwm_gpio_get_direction;
|
|
|
|
pca->gpio.direction_input = pca9685_pwm_gpio_direction_input;
|
|
|
|
pca->gpio.direction_output = pca9685_pwm_gpio_direction_output;
|
|
|
|
pca->gpio.get = pca9685_pwm_gpio_get;
|
|
|
|
pca->gpio.set = pca9685_pwm_gpio_set;
|
|
|
|
pca->gpio.base = -1;
|
|
|
|
pca->gpio.ngpio = PCA9685_MAXCHAN;
|
|
|
|
pca->gpio.can_sleep = true;
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
return devm_gpiochip_add_data(dev, &pca->gpio, chip);
|
2016-09-20 07:40:56 -07:00
|
|
|
}
|
|
|
|
#else
|
2020-04-01 10:01:06 -07:00
|
|
|
static inline bool pca9685_pwm_test_and_set_inuse(struct pca9685 *pca,
|
|
|
|
int pwm_idx)
|
2016-09-20 07:40:56 -07:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-04-01 10:01:06 -07:00
|
|
|
static inline void
|
|
|
|
pca9685_pwm_clear_inuse(struct pca9685 *pca, int pwm_idx)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
static inline int pca9685_pwm_gpio_probe(struct pwm_chip *chip)
|
2016-09-20 07:40:56 -07:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
static void pca9685_set_sleep_mode(struct pwm_chip *chip, bool enable)
|
2017-04-13 05:58:11 -07:00
|
|
|
{
|
2024-02-14 02:32:09 -07:00
|
|
|
struct device *dev = pwmchip_parent(chip);
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pca9685 *pca = to_pca(chip);
|
2021-05-07 06:18:45 -07:00
|
|
|
int err = regmap_update_bits(pca->regmap, PCA9685_MODE1,
|
|
|
|
MODE1_SLEEP, enable ? MODE1_SLEEP : 0);
|
|
|
|
if (err) {
|
|
|
|
dev_err(dev, "regmap_update_bits of register 0x%x failed: %pe\n",
|
|
|
|
PCA9685_MODE1, ERR_PTR(err));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-04-21 06:19:02 -07:00
|
|
|
if (!enable) {
|
2017-04-13 05:58:11 -07:00
|
|
|
/* Wait 500us for the oscillator to be back up */
|
|
|
|
udelay(500);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-05-07 06:18:44 -07:00
|
|
|
static int __pca9685_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
|
|
|
|
const struct pwm_state *state)
|
2013-05-30 00:50:12 -07:00
|
|
|
{
|
|
|
|
struct pca9685 *pca = to_pca(chip);
|
2021-04-15 05:14:48 -07:00
|
|
|
unsigned long long duty, prescale;
|
|
|
|
unsigned int val = 0;
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
if (state->polarity != PWM_POLARITY_NORMAL)
|
|
|
|
return -EINVAL;
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
prescale = DIV_ROUND_CLOSEST_ULL(PCA9685_OSC_CLOCK_MHZ * state->period,
|
|
|
|
PCA9685_COUNTER_RANGE * 1000) - 1;
|
|
|
|
if (prescale < PCA9685_PRESCALE_MIN || prescale > PCA9685_PRESCALE_MAX) {
|
2024-02-14 02:32:09 -07:00
|
|
|
dev_err(pwmchip_parent(chip), "pwm not changed: period out of bounds!\n");
|
2021-04-15 05:14:48 -07:00
|
|
|
return -EINVAL;
|
2013-05-30 00:50:12 -07:00
|
|
|
}
|
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
if (!state->enabled) {
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_pwm_set_duty(chip, pwm->hwpwm, 0);
|
2013-05-30 00:50:12 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_read_reg(chip, PCA9685_PRESCALE, &val);
|
2021-04-15 05:14:48 -07:00
|
|
|
if (prescale != val) {
|
2021-05-07 06:18:44 -07:00
|
|
|
if (!pca9685_prescaler_can_change(pca, pwm->hwpwm)) {
|
2024-02-14 02:32:09 -07:00
|
|
|
dev_err(pwmchip_parent(chip),
|
2021-05-07 06:18:44 -07:00
|
|
|
"pwm not changed: periods of enabled pwms must match!\n");
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
/*
|
|
|
|
* Putting the chip briefly into SLEEP mode
|
|
|
|
* at this point won't interfere with the
|
|
|
|
* pm_runtime framework, because the pm_runtime
|
|
|
|
* state is guaranteed active here.
|
|
|
|
*/
|
|
|
|
/* Put chip into sleep mode */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_set_sleep_mode(chip, true);
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
/* Change the chip-wide output frequency */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_write_reg(chip, PCA9685_PRESCALE, prescale);
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
/* Wake the chip up */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_set_sleep_mode(chip, false);
|
2021-04-15 05:14:48 -07:00
|
|
|
}
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2021-04-15 05:14:48 -07:00
|
|
|
duty = PCA9685_COUNTER_RANGE * state->duty_cycle;
|
|
|
|
duty = DIV_ROUND_UP_ULL(duty, state->period);
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_pwm_set_duty(chip, pwm->hwpwm, duty);
|
2013-05-30 00:50:12 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-05-07 06:18:44 -07:00
|
|
|
static int pca9685_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
|
|
|
|
const struct pwm_state *state)
|
|
|
|
{
|
|
|
|
struct pca9685 *pca = to_pca(chip);
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&pca->lock);
|
|
|
|
ret = __pca9685_pwm_apply(chip, pwm, state);
|
|
|
|
if (ret == 0) {
|
|
|
|
if (state->enabled)
|
|
|
|
set_bit(pwm->hwpwm, pca->pwms_enabled);
|
|
|
|
else
|
|
|
|
clear_bit(pwm->hwpwm, pca->pwms_enabled);
|
|
|
|
}
|
|
|
|
mutex_unlock(&pca->lock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-12-02 11:35:26 -07:00
|
|
|
static int pca9685_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
|
|
|
|
struct pwm_state *state)
|
2021-04-15 05:14:49 -07:00
|
|
|
{
|
|
|
|
unsigned long long duty;
|
|
|
|
unsigned int val = 0;
|
|
|
|
|
|
|
|
/* Calculate (chip-wide) period from prescale value */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_read_reg(chip, PCA9685_PRESCALE, &val);
|
2021-04-15 05:14:49 -07:00
|
|
|
/*
|
|
|
|
* PCA9685_OSC_CLOCK_MHZ is 25, i.e. an integer divider of 1000.
|
|
|
|
* The following calculation is therefore only a multiplication
|
|
|
|
* and we are not losing precision.
|
|
|
|
*/
|
|
|
|
state->period = (PCA9685_COUNTER_RANGE * 1000 / PCA9685_OSC_CLOCK_MHZ) *
|
|
|
|
(val + 1);
|
|
|
|
|
|
|
|
/* The (per-channel) polarity is fixed */
|
|
|
|
state->polarity = PWM_POLARITY_NORMAL;
|
|
|
|
|
|
|
|
if (pwm->hwpwm >= PCA9685_MAXCHAN) {
|
|
|
|
/*
|
|
|
|
* The "all LEDs" channel does not support HW readout
|
|
|
|
* Return 0 and disabled for backwards compatibility
|
|
|
|
*/
|
|
|
|
state->duty_cycle = 0;
|
|
|
|
state->enabled = false;
|
2022-12-02 11:35:26 -07:00
|
|
|
return 0;
|
2021-04-15 05:14:49 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
state->enabled = true;
|
2024-02-14 02:32:08 -07:00
|
|
|
duty = pca9685_pwm_get_duty(chip, pwm->hwpwm);
|
2021-04-15 05:14:49 -07:00
|
|
|
state->duty_cycle = DIV_ROUND_DOWN_ULL(duty * state->period, PCA9685_COUNTER_RANGE);
|
2022-12-02 11:35:26 -07:00
|
|
|
|
|
|
|
return 0;
|
2021-04-15 05:14:49 -07:00
|
|
|
}
|
|
|
|
|
2013-05-30 00:50:12 -07:00
|
|
|
static int pca9685_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
|
|
|
|
{
|
|
|
|
struct pca9685 *pca = to_pca(chip);
|
|
|
|
|
2020-04-01 10:01:06 -07:00
|
|
|
if (pca9685_pwm_test_and_set_inuse(pca, pwm->hwpwm))
|
2016-09-20 07:40:56 -07:00
|
|
|
return -EBUSY;
|
2021-05-07 06:18:44 -07:00
|
|
|
|
|
|
|
if (pwm->hwpwm < PCA9685_MAXCHAN) {
|
|
|
|
/* PWMs - except the "all LEDs" channel - default to enabled */
|
|
|
|
mutex_lock(&pca->lock);
|
|
|
|
set_bit(pwm->hwpwm, pca->pwms_enabled);
|
|
|
|
mutex_unlock(&pca->lock);
|
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:09 -07:00
|
|
|
pm_runtime_get_sync(pwmchip_parent(chip));
|
2013-05-30 00:50:12 -07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pca9685_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
|
|
|
|
{
|
2020-04-01 10:01:06 -07:00
|
|
|
struct pca9685 *pca = to_pca(chip);
|
|
|
|
|
2021-05-07 06:18:44 -07:00
|
|
|
mutex_lock(&pca->lock);
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_pwm_set_duty(chip, pwm->hwpwm, 0);
|
2021-05-07 06:18:44 -07:00
|
|
|
clear_bit(pwm->hwpwm, pca->pwms_enabled);
|
|
|
|
mutex_unlock(&pca->lock);
|
|
|
|
|
2024-02-14 02:32:09 -07:00
|
|
|
pm_runtime_put(pwmchip_parent(chip));
|
2020-04-01 10:01:06 -07:00
|
|
|
pca9685_pwm_clear_inuse(pca, pwm->hwpwm);
|
2013-05-30 00:50:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct pwm_ops pca9685_pwm_ops = {
|
2021-04-15 05:14:48 -07:00
|
|
|
.apply = pca9685_pwm_apply,
|
2021-04-15 05:14:49 -07:00
|
|
|
.get_state = pca9685_pwm_get_state,
|
2013-05-30 00:50:12 -07:00
|
|
|
.request = pca9685_pwm_request,
|
|
|
|
.free = pca9685_pwm_free,
|
|
|
|
};
|
|
|
|
|
2015-02-24 02:40:24 -07:00
|
|
|
static const struct regmap_config pca9685_regmap_i2c_config = {
|
2013-05-30 00:50:12 -07:00
|
|
|
.reg_bits = 8,
|
|
|
|
.val_bits = 8,
|
|
|
|
.max_register = PCA9685_NUMREGS,
|
|
|
|
.cache_type = REGCACHE_NONE,
|
|
|
|
};
|
|
|
|
|
2022-12-02 11:35:38 -07:00
|
|
|
static int pca9685_pwm_probe(struct i2c_client *client)
|
2013-05-30 00:50:12 -07:00
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_chip *chip;
|
2013-05-30 00:50:12 -07:00
|
|
|
struct pca9685 *pca;
|
2020-08-28 05:14:15 -07:00
|
|
|
unsigned int reg;
|
2013-05-30 00:50:12 -07:00
|
|
|
int ret;
|
|
|
|
|
2024-02-14 02:32:10 -07:00
|
|
|
/* Add an extra channel for ALL_LED */
|
|
|
|
chip = devm_pwmchip_alloc(&client->dev, PCA9685_MAXCHAN + 1, sizeof(*pca));
|
|
|
|
if (IS_ERR(chip))
|
|
|
|
return PTR_ERR(chip);
|
|
|
|
pca = to_pca(chip);
|
2013-05-30 00:50:12 -07:00
|
|
|
|
|
|
|
pca->regmap = devm_regmap_init_i2c(client, &pca9685_regmap_i2c_config);
|
|
|
|
if (IS_ERR(pca->regmap)) {
|
|
|
|
ret = PTR_ERR(pca->regmap);
|
|
|
|
dev_err(&client->dev, "Failed to initialize register map: %d\n",
|
|
|
|
ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
i2c_set_clientdata(client, chip);
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2021-05-07 06:18:44 -07:00
|
|
|
mutex_init(&pca->lock);
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
ret = pca9685_read_reg(chip, PCA9685_MODE2, ®);
|
2021-05-07 06:18:45 -07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2015-10-07 03:18:49 -07:00
|
|
|
if (device_property_read_bool(&client->dev, "invert"))
|
2020-08-28 05:14:15 -07:00
|
|
|
reg |= MODE2_INVRT;
|
2013-05-30 00:50:12 -07:00
|
|
|
else
|
2020-08-28 05:14:15 -07:00
|
|
|
reg &= ~MODE2_INVRT;
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2015-10-07 03:18:49 -07:00
|
|
|
if (device_property_read_bool(&client->dev, "open-drain"))
|
2020-08-28 05:14:15 -07:00
|
|
|
reg &= ~MODE2_OUTDRV;
|
2013-05-30 00:50:12 -07:00
|
|
|
else
|
2020-08-28 05:14:15 -07:00
|
|
|
reg |= MODE2_OUTDRV;
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
ret = pca9685_write_reg(chip, PCA9685_MODE2, reg);
|
2021-05-07 06:18:45 -07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2020-08-28 05:14:15 -07:00
|
|
|
/* Disable all LED ALLCALL and SUBx addresses to avoid bus collisions */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_read_reg(chip, PCA9685_MODE1, ®);
|
2020-08-28 05:14:15 -07:00
|
|
|
reg &= ~(MODE1_ALLCALL | MODE1_SUB1 | MODE1_SUB2 | MODE1_SUB3);
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_write_reg(chip, PCA9685_MODE1, reg);
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2021-05-07 06:18:43 -07:00
|
|
|
/* Reset OFF/ON registers to POR default */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_write_reg(chip, PCA9685_ALL_LED_OFF_L, 0);
|
|
|
|
pca9685_write_reg(chip, PCA9685_ALL_LED_OFF_H, LED_FULL);
|
|
|
|
pca9685_write_reg(chip, PCA9685_ALL_LED_ON_L, 0);
|
|
|
|
pca9685_write_reg(chip, PCA9685_ALL_LED_ON_H, LED_FULL);
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
chip->ops = &pca9685_pwm_ops;
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
ret = pwmchip_add(chip);
|
2016-09-20 07:40:56 -07:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
ret = pca9685_pwm_gpio_probe(chip);
|
2017-04-13 05:58:11 -07:00
|
|
|
if (ret < 0) {
|
2024-02-14 02:32:08 -07:00
|
|
|
pwmchip_remove(chip);
|
2017-04-13 05:58:11 -07:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
pm_runtime_enable(&client->dev);
|
2016-09-20 07:40:56 -07:00
|
|
|
|
2021-04-15 05:14:50 -07:00
|
|
|
if (pm_runtime_enabled(&client->dev)) {
|
|
|
|
/*
|
|
|
|
* Although the chip comes out of power-up in the sleep state,
|
|
|
|
* we force it to sleep in case it was woken up before
|
|
|
|
*/
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_set_sleep_mode(chip, true);
|
2021-04-15 05:14:50 -07:00
|
|
|
pm_runtime_set_suspended(&client->dev);
|
|
|
|
} else {
|
|
|
|
/* Wake the chip up if runtime PM is disabled */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_set_sleep_mode(chip, false);
|
2021-04-15 05:14:50 -07:00
|
|
|
}
|
|
|
|
|
2017-04-13 05:58:11 -07:00
|
|
|
return 0;
|
2013-05-30 00:50:12 -07:00
|
|
|
}
|
|
|
|
|
2022-08-15 01:02:30 -07:00
|
|
|
static void pca9685_pwm_remove(struct i2c_client *client)
|
2013-05-30 00:50:12 -07:00
|
|
|
{
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_chip *chip = i2c_get_clientdata(client);
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
pwmchip_remove(chip);
|
2021-04-15 05:14:50 -07:00
|
|
|
|
|
|
|
if (!pm_runtime_enabled(&client->dev)) {
|
|
|
|
/* Put chip in sleep state if runtime PM is disabled */
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_set_sleep_mode(chip, true);
|
2021-04-15 05:14:50 -07:00
|
|
|
}
|
|
|
|
|
2017-04-13 05:58:11 -07:00
|
|
|
pm_runtime_disable(&client->dev);
|
|
|
|
}
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2020-03-11 08:43:49 -07:00
|
|
|
static int __maybe_unused pca9685_pwm_runtime_suspend(struct device *dev)
|
2017-04-13 05:58:11 -07:00
|
|
|
{
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_chip *chip = i2c_get_clientdata(client);
|
2017-04-13 05:58:11 -07:00
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_set_sleep_mode(chip, true);
|
2017-04-13 05:58:11 -07:00
|
|
|
return 0;
|
2013-05-30 00:50:12 -07:00
|
|
|
}
|
|
|
|
|
2020-03-11 08:43:49 -07:00
|
|
|
static int __maybe_unused pca9685_pwm_runtime_resume(struct device *dev)
|
2017-04-13 05:58:11 -07:00
|
|
|
{
|
|
|
|
struct i2c_client *client = to_i2c_client(dev);
|
2024-02-14 02:32:08 -07:00
|
|
|
struct pwm_chip *chip = i2c_get_clientdata(client);
|
2017-04-13 05:58:11 -07:00
|
|
|
|
2024-02-14 02:32:08 -07:00
|
|
|
pca9685_set_sleep_mode(chip, false);
|
2017-04-13 05:58:11 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-30 00:50:12 -07:00
|
|
|
static const struct i2c_device_id pca9685_id[] = {
|
2024-05-08 06:06:18 -07:00
|
|
|
{ "pca9685" },
|
|
|
|
{ /* sentinel */ }
|
2013-05-30 00:50:12 -07:00
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(i2c, pca9685_id);
|
|
|
|
|
2015-10-07 03:18:49 -07:00
|
|
|
#ifdef CONFIG_ACPI
|
|
|
|
static const struct acpi_device_id pca9685_acpi_ids[] = {
|
|
|
|
{ "INT3492", 0 },
|
|
|
|
{ /* sentinel */ },
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(acpi, pca9685_acpi_ids);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_OF
|
2013-05-30 00:50:12 -07:00
|
|
|
static const struct of_device_id pca9685_dt_ids[] = {
|
|
|
|
{ .compatible = "nxp,pca9685-pwm", },
|
|
|
|
{ /* sentinel */ }
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, pca9685_dt_ids);
|
2015-10-07 03:18:49 -07:00
|
|
|
#endif
|
2013-05-30 00:50:12 -07:00
|
|
|
|
2017-04-13 05:58:11 -07:00
|
|
|
static const struct dev_pm_ops pca9685_pwm_pm = {
|
|
|
|
SET_RUNTIME_PM_OPS(pca9685_pwm_runtime_suspend,
|
|
|
|
pca9685_pwm_runtime_resume, NULL)
|
|
|
|
};
|
|
|
|
|
2013-05-30 00:50:12 -07:00
|
|
|
static struct i2c_driver pca9685_i2c_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "pca9685-pwm",
|
2015-10-07 03:18:49 -07:00
|
|
|
.acpi_match_table = ACPI_PTR(pca9685_acpi_ids),
|
|
|
|
.of_match_table = of_match_ptr(pca9685_dt_ids),
|
2017-04-13 05:58:11 -07:00
|
|
|
.pm = &pca9685_pwm_pm,
|
2013-05-30 00:50:12 -07:00
|
|
|
},
|
2023-05-25 14:13:05 -07:00
|
|
|
.probe = pca9685_pwm_probe,
|
2013-05-30 00:50:12 -07:00
|
|
|
.remove = pca9685_pwm_remove,
|
|
|
|
.id_table = pca9685_id,
|
|
|
|
};
|
|
|
|
|
|
|
|
module_i2c_driver(pca9685_i2c_driver);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>");
|
|
|
|
MODULE_DESCRIPTION("PWM driver for PCA9685");
|
|
|
|
MODULE_LICENSE("GPL");
|