| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <20201119100005.GA703@workstation.tuxnet>
Date: Thu, 19 Nov 2020 11:00:05 +0100
From: Clemens Gruber <clemens.gruber@...ruber.com>
To: Sven Van Asbroeck <thesven73@...il.com>
Cc: linux-pwm@...r.kernel.org,
Thierry Reding <thierry.reding@...il.com>,
Uwe Kleine-König
<u.kleine-koenig@...gutronix.de>, Lee Jones <lee.jones@...aro.org>,
Linux Kernel Mailing List <linux-kernel@...r.kernel.org>,
Mika Westerberg <mika.westerberg@...ux.intel.com>,
David Jander <david@...tonic.nl>
Subject: Re: [PATCH 1/3] pwm: pca9685: Switch to atomic API
Hi Sven,
thank you for your fast response and helpful feedback! I'll answer below.
On Wed, Nov 18, 2020 at 07:18:04PM -0500, Sven Van Asbroeck wrote:
> Hi Clemens, thank you so much for this contribution.
> I no longer have access to this chip, so I cannot test
> the changes.
>
> Some friendly/constructive feedback below.
>
> On Wed, Nov 18, 2020 at 12:44 PM Clemens Gruber
> <clemens.gruber@...ruber.com> wrote:
> >
> > This switch to the atomic API goes hand in hand with a few fixes to
> > previously experienced issues:
> > - The duty cycle is no longer lost after disable/enable (previously the
> > OFF registers were cleared in disable and the user was required to
> > call config to restore the duty cycle settings)
> > - The prescale register is now read out. If one sets a period resulting
> > in the same prescale register value, the sleep and write to the
> > register is skipped
> >
> > The hardware readout may return slightly different values than those
> > that were set in apply due to the limited range of possible prescale and
> > counter register values. If one channel is reconfigured with new duty
> > cycle and period, the others will keep the same relative duty cycle to
> > period ratio as they had before, even though the per-chip / global
> > frequency changed. (The PCA9685 has only one prescaler!)
> >
> > Note that although the datasheet mentions 200 Hz as default frequency
> > when using the internal 25 MHz oscillator, the calculated period from
> > the default prescaler register setting of 30 is 5079040ns.
> >
> > Signed-off-by: Clemens Gruber <clemens.gruber@...ruber.com>
> > ---
> > drivers/pwm/pwm-pca9685.c | 233 ++++++++++++++++++++------------------
> > 1 file changed, 124 insertions(+), 109 deletions(-)
> >
> > diff --git a/drivers/pwm/pwm-pca9685.c b/drivers/pwm/pwm-pca9685.c
> > index 4a55dc18656c..20f1314e6754 100644
> > --- a/drivers/pwm/pwm-pca9685.c
> > +++ b/drivers/pwm/pwm-pca9685.c
> > @@ -51,7 +51,6 @@
> > #define PCA9685_PRESCALE_MAX 0xFF /* => min. frequency of 24 Hz */
> >
> > #define PCA9685_COUNTER_RANGE 4096
> > -#define PCA9685_DEFAULT_PERIOD 5000000 /* Default period_ns = 1/200 Hz */
> > #define PCA9685_OSC_CLOCK_MHZ 25 /* Internal oscillator with 25 MHz */
> >
> > #define PCA9685_NUMREGS 0xFF
> > @@ -74,7 +73,7 @@
> > struct pca9685 {
> > struct pwm_chip chip;
> > struct regmap *regmap;
> > - int period_ns;
> > + int prescale;
>
> You've decided to cache the prescale register...
>
> > #if IS_ENABLED(CONFIG_GPIOLIB)
> > struct mutex lock;
> > struct gpio_chip gpio;
> > @@ -246,18 +245,117 @@ static void pca9685_set_sleep_mode(struct pca9685 *pca, bool enable)
> > }
> > }
> >
> > -static int pca9685_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
> > - int duty_ns, int period_ns)
> > +static void pca9685_pwm_full_off(struct pwm_chip *chip,
> > + struct pwm_device *pwm)
> > +{
> > + struct pca9685 *pca = to_pca(chip);
> > + int reg;
> > +
> > + /*
> > + * Set the full OFF bit to cause the PWM channel to be always off.
> > + * The full OFF bit has precedence over the other register values.
> > + */
> > +
> > + if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > + reg = PCA9685_ALL_LED_OFF_H;
> > + else
> > + reg = LED_N_OFF_H(pwm->hwpwm);
> > +
> > + regmap_write(pca->regmap, reg, LED_FULL);
> > +}
> > +
> > +static void pca9685_pwm_full_on(struct pwm_chip *chip,
> > + struct pwm_device *pwm)
> > +{
> > + struct pca9685 *pca = to_pca(chip);
> > + int reg;
> > +
> > + /*
> > + * Clear the OFF registers (including the full OFF bit) and set
> > + * the full ON bit to cause the PWM channel to be always on.
> > + */
> > +
> > + if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > + reg = PCA9685_ALL_LED_OFF_L;
> > + else
> > + reg = LED_N_OFF_L(pwm->hwpwm);
> > +
> > + regmap_write(pca->regmap, reg, 0x0);
> > +
> > + if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > + reg = PCA9685_ALL_LED_OFF_H;
> > + else
> > + reg = LED_N_OFF_H(pwm->hwpwm);
> > +
> > + regmap_write(pca->regmap, reg, 0x0);
> > +
> > + if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > + reg = PCA9685_ALL_LED_ON_H;
> > + else
> > + reg = LED_N_ON_H(pwm->hwpwm);
> > +
> > + regmap_write(pca->regmap, reg, LED_FULL);
> > +}
> > +
> > +static int pca9685_pwm_read_global_period(struct pca9685 *pca)
>
> but in this function, you don't seem to use the cached prescale
> value, but read it out again instead?
Good point.
I wanted .get_state to read out the actual HW state but the cached
prescale register should always be identical to that, so it should be OK
to use it here.
> > +{
> > + unsigned int prescale = 0;
> > +
> > + regmap_read(pca->regmap, PCA9685_PRESCALE, &prescale);
> > +
> > + if (prescale < PCA9685_PRESCALE_MIN || prescale > PCA9685_PRESCALE_MAX)
> > + return 0;
> > +
> > + return (PCA9685_COUNTER_RANGE * 1000 / PCA9685_OSC_CLOCK_MHZ) *
> > + (prescale + 1);
> > +}
> > +
> > +static void pca9685_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
> > + struct pwm_state *state)
> > +{
> > + struct pca9685 *pca = to_pca(chip);
> > + unsigned int val, duty;
> > + int reg;
> > +
> > + /* Read out (chip-wide) period */
> > + state->period = pca9685_pwm_read_global_period(pca);
> > +
> > + /* The (per-channel) polarity is fixed */
> > + state->polarity = PWM_POLARITY_NORMAL;
> > +
> > + /* Read out current duty cycle and enabled state */
> > + reg = pwm->hwpwm >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_OFF_H :
> > + LED_N_OFF_H(pwm->hwpwm);
> > + regmap_read(pca->regmap, reg, &val);
> > + duty = (val & 0xf) << 8;
> > +
> > + state->enabled = !(val & LED_FULL);
> > +
> > + reg = pwm->hwpwm >= PCA9685_MAXCHAN ? PCA9685_ALL_LED_OFF_L :
> > + LED_N_OFF_L(pwm->hwpwm);
> > + regmap_read(pca->regmap, reg, &val);
> > + duty |= (val & 0xff);
> > +
> > + if (duty < PCA9685_COUNTER_RANGE) {
> > + duty *= state->period;
> > + state->duty_cycle = duty / (PCA9685_COUNTER_RANGE - 1);
> > + } else
> > + state->duty_cycle = 0;
> > +}
> > +
> > +static int pca9685_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
> > + const struct pwm_state *state)
> > {
> > struct pca9685 *pca = to_pca(chip);
> > - unsigned long long duty;
> > + unsigned long long duty, prescale;
> > unsigned int reg;
> > - int prescale;
> >
> > - if (period_ns != pca->period_ns) {
> > - prescale = DIV_ROUND_CLOSEST(PCA9685_OSC_CLOCK_MHZ * period_ns,
> > - PCA9685_COUNTER_RANGE * 1000) - 1;
> > + if (state->polarity != PWM_POLARITY_NORMAL)
> > + return -EOPNOTSUPP;
> >
> > + prescale = DIV_ROUND_CLOSEST_ULL(PCA9685_OSC_CLOCK_MHZ * state->period,
> > + PCA9685_COUNTER_RANGE * 1000) - 1;
> > + if (prescale != pca->prescale) {
>
> Use of cached prescale here, all good.
>
> > if (prescale >= PCA9685_PRESCALE_MIN &&
> > prescale <= PCA9685_PRESCALE_MAX) {
> > /*
> > @@ -270,12 +368,13 @@ static int pca9685_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
> > pca9685_set_sleep_mode(pca, true);
> >
> > /* Change the chip-wide output frequency */
> > - regmap_write(pca->regmap, PCA9685_PRESCALE, prescale);
> > + regmap_write(pca->regmap, PCA9685_PRESCALE,
> > + (int)prescale);
> >
> > /* Wake the chip up */
> > pca9685_set_sleep_mode(pca, false);
> >
> > - pca->period_ns = period_ns;
> > + pca->prescale = (int)prescale;
> > } else {
> > dev_err(chip->dev,
> > "prescaler not set: period out of bounds!\n");
> > @@ -283,46 +382,18 @@ static int pca9685_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
> > }
> > }
> >
> > - if (duty_ns < 1) {
> > - if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > - reg = PCA9685_ALL_LED_OFF_H;
> > - else
> > - reg = LED_N_OFF_H(pwm->hwpwm);
> > -
> > - regmap_write(pca->regmap, reg, LED_FULL);
> > -
> > + if (!state->enabled || state->duty_cycle < 1) {
> > + pca9685_pwm_full_off(chip, pwm);
> > return 0;
> > }
> >
> > - if (duty_ns == period_ns) {
> > - /* Clear both OFF registers */
> > - if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > - reg = PCA9685_ALL_LED_OFF_L;
> > - else
> > - reg = LED_N_OFF_L(pwm->hwpwm);
> > -
> > - regmap_write(pca->regmap, reg, 0x0);
> > -
> > - if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > - reg = PCA9685_ALL_LED_OFF_H;
> > - else
> > - reg = LED_N_OFF_H(pwm->hwpwm);
> > -
> > - regmap_write(pca->regmap, reg, 0x0);
> > -
> > - /* Set the full ON bit */
> > - if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > - reg = PCA9685_ALL_LED_ON_H;
> > - else
> > - reg = LED_N_ON_H(pwm->hwpwm);
> > -
> > - regmap_write(pca->regmap, reg, LED_FULL);
> > -
> > + if (state->duty_cycle == state->period) {
> > + pca9685_pwm_full_on(chip, pwm);
> > return 0;
> > }
> >
> > - duty = PCA9685_COUNTER_RANGE * (unsigned long long)duty_ns;
> > - duty = DIV_ROUND_UP_ULL(duty, period_ns);
> > + duty = (PCA9685_COUNTER_RANGE - 1) * state->duty_cycle;
> > + duty = DIV_ROUND_UP_ULL(duty, state->period);
> >
> > if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > reg = PCA9685_ALL_LED_OFF_L;
> > @@ -349,64 +420,6 @@ static int pca9685_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
> > return 0;
> > }
> >
> > -static int pca9685_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
> > -{
> > - struct pca9685 *pca = to_pca(chip);
> > - unsigned int reg;
> > -
> > - /*
> > - * The PWM subsystem does not support a pre-delay.
> > - * So, set the ON-timeout to 0
> > - */
> > - if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > - reg = PCA9685_ALL_LED_ON_L;
> > - else
> > - reg = LED_N_ON_L(pwm->hwpwm);
> > -
> > - regmap_write(pca->regmap, reg, 0);
> > -
> > - if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > - reg = PCA9685_ALL_LED_ON_H;
> > - else
> > - reg = LED_N_ON_H(pwm->hwpwm);
> > -
> > - regmap_write(pca->regmap, reg, 0);
> > -
> > - /*
> > - * Clear the full-off bit.
> > - * It has precedence over the others and must be off.
> > - */
> > - if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > - reg = PCA9685_ALL_LED_OFF_H;
> > - else
> > - reg = LED_N_OFF_H(pwm->hwpwm);
> > -
> > - regmap_update_bits(pca->regmap, reg, LED_FULL, 0x0);
> > -
> > - return 0;
> > -}
> > -
> > -static void pca9685_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
> > -{
> > - struct pca9685 *pca = to_pca(chip);
> > - unsigned int reg;
> > -
> > - if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > - reg = PCA9685_ALL_LED_OFF_H;
> > - else
> > - reg = LED_N_OFF_H(pwm->hwpwm);
> > -
> > - regmap_write(pca->regmap, reg, LED_FULL);
> > -
> > - /* Clear the LED_OFF counter. */
> > - if (pwm->hwpwm >= PCA9685_MAXCHAN)
> > - reg = PCA9685_ALL_LED_OFF_L;
> > - else
> > - reg = LED_N_OFF_L(pwm->hwpwm);
> > -
> > - regmap_write(pca->regmap, reg, 0x0);
> > -}
> > -
> > static int pca9685_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
> > {
> > struct pca9685 *pca = to_pca(chip);
> > @@ -422,15 +435,14 @@ static void pca9685_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
> > {
> > struct pca9685 *pca = to_pca(chip);
> >
> > - pca9685_pwm_disable(chip, pwm);
> > + pca9685_pwm_full_off(chip, pwm);
> > pm_runtime_put(chip->dev);
> > pca9685_pwm_clear_inuse(pca, pwm->hwpwm);
> > }
> >
> > static const struct pwm_ops pca9685_pwm_ops = {
> > - .enable = pca9685_pwm_enable,
> > - .disable = pca9685_pwm_disable,
> > - .config = pca9685_pwm_config,
> > + .get_state = pca9685_pwm_get_state,
> > + .apply = pca9685_pwm_apply,
> > .request = pca9685_pwm_request,
> > .free = pca9685_pwm_free,
> > .owner = THIS_MODULE,
> > @@ -448,7 +460,7 @@ static int pca9685_pwm_probe(struct i2c_client *client,
> > {
> > struct pca9685 *pca;
> > unsigned int reg;
> > - int ret;
> > + int prescale = 0, ret;
> >
> > pca = devm_kzalloc(&client->dev, sizeof(*pca), GFP_KERNEL);
> > if (!pca)
> > @@ -461,10 +473,13 @@ static int pca9685_pwm_probe(struct i2c_client *client,
> > ret);
> > return ret;
> > }
> > - pca->period_ns = PCA9685_DEFAULT_PERIOD;
> >
> > i2c_set_clientdata(client, pca);
> >
> > + regmap_read(pca->regmap, PCA9685_PRESCALE, &prescale);
> > + if (prescale < PCA9685_PRESCALE_MIN || prescale > PCA9685_PRESCALE_MAX)
> > + pca->prescale = prescale;
>
> I'm not sure this will cache the prescale value correctly,
> the logic seems inverted
You are right, that's a mistake.
> You appear to mix cached and uncached uses of prescale,
> is there a need for this? If not, perhaps pick one and use
> it consistently?
Yes, sticking to the cached value is probably the way to go.
> Perhaps you can define a is_prescale_valid() helper,
> which is easier to read.
> And it can be easily negated:
> if (!is_prescale_valid(prescale))
> without getting confused between </>. <=/>=, and ||/&&.
Good idea!
> Also, if the prescale register contains an invalid value
> during probe(), e.g. 0x00 or 0x01, would it make sense
> to explicitly overwrite it with a valid setting?
As long as it is overwritten with a correct setting when the PWM is used
for the first time, it should be OK?
Thanks,
Clemens
Powered by blists - more mailing lists