From: sashiko-bot@kernel.org
To: "Taniya Das" <taniya.das@oss.qualcomm.com>
Cc: devicetree@vger.kernel.org, robh@kernel.org, conor+dt@kernel.org
Subject: Re: [PATCH 2/3] pwm: qcom: add Shikra PWM controller support
Date: Mon, 16 Nov 2026 07:29:14 +0000 [thread overview]
Message-ID: <sashiko-outbox-216428@kernel.org> (raw)
In-Reply-To: <20261116-pwm_qcom_shikra-v1-2-67ee4553adc5@oss.qualcomm.com>
Thank you for your contribution! Sashiko AI review found 7 potential
issues to consider:
- [High] pwm: qcom: division by zero in qcom_pwm_config() when cycles >
rate
- [High] pwm: qcom: broken duty-cycle math and -ERANGE check in
qcom_pwm_config()
- [High] pwm: qcom: qcom_pwm_apply() runs qcom_pwm_config() when
!state->enabled
- [Medium] pwm: qcom: unrounded current_period_ns check in
qcom_pwm_config() fails
- [Medium] pwm: qcom: desynchronized software state in qcom_pwm_apply()
and config
- [Medium] pwm: qcom: partial state mutation before validation in
qcom_pwm_config()
- [Low] pwm: qcom: unnamed regmap_config collision in
qcom_pwm_parse_dt()
--
commit 06e62578a3838a59f7adc59ac3054518eb4e4082
Author: Taniya Das <taniya.das@oss.qualcomm.com>
pwm: qcom: add Shikra PWM controller support
This commit adds a PWM controller driver for Qualcomm Shikra SoCs, modeling
up to ten independent PWM frames from DT child nodes with a shared
output-enable register and shared AHB and core clocks.
> diff --git a/drivers/pwm/pwm-qcom.c b/drivers/pwm/pwm-qcom.c
> new file mode 100644
> index 0000000000000..9b15cdcaa5c76
> --- /dev/null
> +++ b/drivers/pwm/pwm-qcom.c
[ ... ]
> +static int qcom_pwm_calc_frequency(struct qcom_pwm_chip *chip,
> + u64 period_ns, unsigned long rate, u32 hw_idx)
> +{
> + struct regmap *frame_regmap = chip->frames[hw_idx].regmap;
> + u64 cycles;
> + int ret;
> +
> + /*
> + * PWM client can set the period only once if the HW version does
> + * not support reset functionality.
> + */
> + if (chip->frames[hw_idx].freq_set && !chip->priv_data->pwm_reset_support)
> + return 0;
> +
> + /*
> + * Number of core-clock cycles in one PWM period. Round down so the
> + * implemented period never exceeds the requested one, as the PWM API
> + * requires. PWM_CYC_CFG holds (cycles - 1) in its low 16 bits, so
> + * cycles is bounded to [2, 65536], i.e. an output frequency from
> + * rate / 2 down to rate / 65536.
> + */
> + cycles = mul_u64_u64_div_u64(period_ns, rate, NSEC_PER_SEC);
> + if (cycles < 2 || cycles > 65536) {
> + dev_dbg(regmap_get_device(frame_regmap),
> + "period %llu ns out of range for rate %lu Hz\n",
> + period_ns, rate);
> + return -ERANGE;
> + }
> +
> + ret = regmap_update_bits(frame_regmap, PWM_CYC_CFG,
> + PWM_FRAME_VAL_MASK, cycles - 1);
> + if (ret)
> + return ret;
> +
> + chip->frames[hw_idx].current_freq = div64_ul(rate, cycles);
> + chip->frames[hw_idx].freq_set = true;
> + chip->frames[hw_idx].current_period_ns = period_ns;
> +
> + return 0;
> +}
[ ... ]
> +static int qcom_pwm_config(struct qcom_pwm_chip *chip,
> + u32 hw_idx, u64 duty_ns, u64 period_ns, int polarity)
> +{
[ ... ]
> + if (chip->frames[hw_idx].freq_set &&
> + chip->frames[hw_idx].current_period_ns != period_ns) {
> + if (chip->priv_data->pwm_reset_support) {
> + ret = regmap_update_bits(frame_regmap, PWM_RESET,
> + PWM_FRAME_RESET_BIT,
> + PWM_FRAME_RESET_BIT);
> + if (ret)
> + goto out;
> + } else {
> + ret = -EINVAL;
> + goto out;
> + }
> + }
[Severity: Medium]
Does comparing against the unrounded current_period_ns cause re-applying the
state returned by qcom_pwm_get_state() to fail with -EINVAL on
qcom,shikra-pwm?
qcom_pwm_calc_frequency() rounds cycles down and stores the caller's
unrounded period_ns in current_period_ns, whereas qcom_pwm_get_state()
returns the hardware period rounded up from cycles. Because shikra_pwm_data
leaves pwm_reset_support false, re-applying the state read back from
qcom_pwm_get_state() (for example in pwm_apply_debug() or a consumer
read-modify-write update) sees period_ns != current_period_ns and returns
-EINVAL even though both periods map to the same cycle count.
> +
> + ret = qcom_pwm_calc_frequency(chip, current_period, rate, hw_idx);
> + if (ret)
> + goto out;
> +
> + if (chip->frames[hw_idx].polarity != polarity) {
> + ret = regmap_update_bits(frame_regmap, PWM_CTL0,
> + PWM_FRAME_POLARITY_BIT, polarity);
> + if (ret)
> + goto out;
> +
> + chip->frames[hw_idx].polarity = polarity;
> + }
> +
> + ctl1 = DIV_ROUND_CLOSEST(rate, chip->frames[hw_idx].current_freq);
[Severity: High]
Can this divide by zero when cycles > rate?
When the core clock is divided below 65536 Hz (down to 37.5 kHz on Shikra)
and a valid period longer than one second is requested (rate < cycles <=
65536), div64_ul(rate, cycles) in qcom_pwm_calc_frequency() truncates
current_freq to 0, and DIV_ROUND_CLOSEST(rate, current_freq) divides by zero.
Even when cycles <= rate, round-tripping through an integer current_freq
loses cycle-count precision compared to using cycles directly.
> + duty_percent = mul_u64_add_u64_div_u64(duty_ns, 100, current_period / 2, current_period);
> + ctl1 = mul_u64_add_u64_div_u64(ctl1, duty_percent, 50, 100);
> +
> + ret = regmap_read(frame_regmap, PWM_CYC_CFG, &cyc_cfg);
> + if (ret)
> + goto out;
> +
> + if ((ctl1 > cyc_cfg || ctl1 == 0) && duty_ns != 0) {
> + dev_err(regmap_get_device(frame_regmap),
> + "duty cycle out of valid range\n");
> + ret = -ERANGE;
> + goto out;
> + }
[Severity: High]
Does this calculation reject valid 100% and < 0.5% duty cycles with -ERANGE
and quantize PWM_CTL1 to integer percentages?
PWM_CYC_CFG stores cycles - 1, so when duty_ns == period_ns (or >= 99.5% of
period_ns), duty_percent rounds to 100 and ctl1 becomes cycles (cyc_cfg + 1),
tripping ctl1 > cyc_cfg. When 0 < duty_ns < 0.5% of period_ns, duty_percent
rounds to 0 and ctl1 == 0 with duty_ns != 0 also returns -ERANGE instead of
programming the cycle count or rounding down to 0. Quantizing through a
rounded 0..100 percentage also discards the 16-bit counter resolution of
PWM_CTL1 and rounds duty_cycle up, contrary to the PWM framework contract and
the comment in qcom_pwm_get_state().
[Severity: Medium]
If the ctl1 range check above fails, does qcom_pwm_config() leave hardware
registers and per-frame state partially updated?
qcom_pwm_calc_frequency() has already written PWM_CYC_CFG and set
freq_set = true and current_period_ns, and the polarity block has already
updated PWM_CTL0 and frame->polarity, while __pwm_apply() leaves pwm->state
unchanged on error. On qcom,shikra-pwm (!pwm_reset_support), an initial
apply that fails the ctl1 check leaves freq_set true for the failed period,
causing subsequent apply calls with any other period to fail with -EINVAL.
[ ... ]
> +static int qcom_pwm_apply(struct pwm_chip *pwm_chip, struct pwm_device *pwm,
> + const struct pwm_state *state)
> +{
> + struct qcom_pwm_chip *chip = to_qcom_pwm_chip(pwm_chip);
> + struct pwm_state curr_state;
> + u32 hw_idx = pwm->hwpwm;
> + int ret;
> +
> + pwm_get_state(pwm, &curr_state);
> +
> + if (state->period &&
> + (state->period != curr_state.period ||
> + state->duty_cycle != curr_state.duty_cycle ||
> + state->polarity != curr_state.polarity)) {
> + ret = qcom_pwm_config(chip, hw_idx, state->duty_cycle,
> + state->period, state->polarity);
> + if (ret) {
> + dev_err(pwmchip_parent(pwm_chip),
> + "failed to update PWM configuration\n");
> + return ret;
> + }
> + }
[Severity: High]
Should qcom_pwm_apply() skip qcom_pwm_config() when !state->enabled?
When disabling an active PWM, running qcom_pwm_config() first can fail (for
example with -EINVAL if state->period changed on Shikra, or -ERANGE) and
return before qcom_pwm_disable() is reached, leaving the output active and
its ahb and core clocks enabled. When a channel is exported via sysfs while
disabled, qcom_pwm_get_state() initializes pwm->state.period from the reset
default PWM_CYC_CFG == 0 (1 clock cycle), so writing duty_cycle or polarity
before period calls qcom_pwm_config() with a 1-cycle period and fails with
-ERANGE, while writing period while disabled sets freq_set = true and locks
the period before the channel is ever enabled.
> +
> + if (state->enabled != curr_state.enabled) {
> + if (state->enabled)
> + return qcom_pwm_enable(chip, pwm);
> +
> + ret = qcom_pwm_disable(chip, pwm);
> + if (ret)
> + return ret;
> + }
> +
> + return 0;
> +}
[Severity: Medium]
Can comparing against curr_state (pwm->state) and frame->polarity skip
necessary hardware updates or disable clocks twice?
When a channel is first requested, pwm_device_request() populates pwm->state
from qcom_pwm_get_state() while frame->freq_set remains false; if a consumer
then enables the channel with those same period, duty_cycle, and polarity
values, qcom_pwm_apply() sees no change from curr_state, skips
qcom_pwm_config(), and enables an unconfigured frame. Similarly,
frame->polarity is initialized to 0 rather than read from PWM_CTL0, so
qcom_pwm_config() will not clear PWM_FRAME_POLARITY_BIT if it was set prior
to probe and PWM_POLARITY_NORMAL is requested.
[ ... ]
> +static const struct regmap_config pwm_regmap_config = {
> + .reg_bits = 32,
> + .reg_stride = 4,
> + .val_bits = 32,
> + .fast_io = true,
> +};
> +
> +static int qcom_pwm_parse_dt(struct platform_device *pdev,
> + struct pwm_chip *pwm_chip,
> + struct qcom_pwm_chip *chip)
> +{
> + struct device *dev = pwmchip_parent(pwm_chip);
> + struct device_node *np = pdev->dev.of_node;
> + struct device_node *frame_node;
> + void __iomem *base;
> + unsigned long frame_ids = 0;
> + int ret;
> +
> + base = devm_platform_ioremap_resource(pdev, 0);
> + if (IS_ERR(base))
> + return PTR_ERR(base);
> +
> + chip->regmap = devm_regmap_init_mmio(dev, base, &pwm_regmap_config);
[ ... ]
> + chip->frames[n].regmap =
> + devm_regmap_init_mmio(dev, base, &pwm_regmap_config);
[Severity: Low]
Does registering chip->regmap and every chip->frames[n].regmap on the same
device with an unnamed pwm_regmap_config collide in regmap debugfs?
Because pwm_regmap_config.name is NULL, regmap_debugfs_init() uses
dev_name(dev) for all of them under /sys/kernel/debug/regmap/, causing every
per-frame regmap to fail debugfs directory creation with -EEXIST during
probe.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261116-pwm_qcom_shikra-v1-0-67ee4553adc5@oss.qualcomm.com?part=2
next prev parent reply other threads:[~2026-11-16 7:29 UTC|newest]
Thread overview: 7+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-16 6:59 [PATCH 0/3] pwm: qcom: add Shikra PWM controller Taniya Das
2026-11-16 6:59 ` [PATCH 1/3] dt-bindings: " Taniya Das
2026-11-16 7:22 ` sashiko-bot
2026-11-16 6:59 ` [PATCH 2/3] pwm: qcom: add Shikra PWM controller support Taniya Das
2026-11-16 7:29 ` sashiko-bot [this message]
2026-11-16 6:59 ` [PATCH 3/3] arm64: dts: qcom: add Shikra PWM controller Taniya Das
2026-11-16 7:32 ` sashiko-bot
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-216428@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=conor+dt@kernel.org \
--cc=devicetree@vger.kernel.org \
--cc=robh@kernel.org \
--cc=sashiko-reviews@lists.linux.dev \
--cc=taniya.das@oss.qualcomm.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox