From: "Uwe Kleine-König" <ukleinek@kernel.org>
To: Taniya Das <taniya.das@oss.qualcomm.com>
Cc: Rob Herring <robh@kernel.org>,
Krzysztof Kozlowski <krzk+dt@kernel.org>,
Conor Dooley <conor+dt@kernel.org>,
Bjorn Andersson <andersson@kernel.org>,
Konrad Dybcio <konradybcio@kernel.org>,
Abel Vesa <abelvesa@kernel.org>,
Ajit Pandey <ajit.pandey@oss.qualcomm.com>,
Imran Shaik <imran.shaik@oss.qualcomm.com>,
Jagadeesh Kona <jagadeesh.kona@oss.qualcomm.com>,
linux-arm-msm@vger.kernel.org, linux-pwm@vger.kernel.org,
devicetree@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: Re: [PATCH 2/3] pwm: qcom: add Shikra PWM controller support
Date: Tue, 17 Nov 2026 15:44:00 +0100 [thread overview]
Message-ID: <avxh7fQliDF_wCms@monoceros> (raw)
In-Reply-To: <20261116-pwm_qcom_shikra-v1-2-67ee4553adc5@oss.qualcomm.com>
[-- Attachment #1: Type: text/plain, Size: 24303 bytes --]
On Mon, Nov 16, 2026 at 12:29:49PM +0530, Taniya Das wrote:
> Add support for the Pulse Width Modulation (PWM) controller on Qualcomm
> Shikra SoCs.
>
> The controller has a shared output-enable register and up to ten frame
> blocks with independent configuration registers. Model each available
> frame from its DT child node, and retain the shared AHB and PWM core
> clocks while an output is active.
>
> Signed-off-by: Taniya Das <taniya.das@oss.qualcomm.com>
> ---
> drivers/pwm/Kconfig | 13 +
> drivers/pwm/Makefile | 1 +
> drivers/pwm/pwm-qcom.c | 685 +++++++++++++++++++++++++++++++++++++++++++++++++
> 3 files changed, 699 insertions(+)
>
> diff --git a/drivers/pwm/Kconfig b/drivers/pwm/Kconfig
> index aacd800687e7c98b2272ddb01447356349425032..ae229e922521e97d88610887da5ccb0f7433fbd3 100644
> --- a/drivers/pwm/Kconfig
> +++ b/drivers/pwm/Kconfig
> @@ -566,6 +566,19 @@ config PWM_PXA
> To compile this driver as a module, choose M here: the module
> will be called pwm-pxa.
>
> +config PWM_QCOM
> + tristate "Qualcomm PWM support"
> + depends on ARCH_QCOM || COMPILE_TEST
> + depends on COMMON_CLK && HAS_IOMEM && OF
> + select REGMAP_MMIO
> + help
> + PWM framework driver for the PWM block found on Qualcomm SoCs,
> + which supports multiple PWM frames. Each frame can be
> + configured independently of the others.
> +
> + To compile this driver as a module, choose M here: the module will
> + be called pwm-qcom.
> +
> config PWM_RASPBERRYPI_POE
> tristate "Raspberry Pi Firmware PoE Hat PWM support"
> # Make sure not 'y' when RASPBERRYPI_FIRMWARE is 'm'. This can only
> diff --git a/drivers/pwm/Makefile b/drivers/pwm/Makefile
> index 7e2c34cc4f6a955b04edcdd08721264d0d477f2e..a7e0095b573448cb643b19f4da2e6f02ada4bc39 100644
> --- a/drivers/pwm/Makefile
> +++ b/drivers/pwm/Makefile
> @@ -50,6 +50,7 @@ obj-$(CONFIG_PWM_NTXEC) += pwm-ntxec.o
> obj-$(CONFIG_PWM_OMAP_DMTIMER) += pwm-omap-dmtimer.o
> obj-$(CONFIG_PWM_PCA9685) += pwm-pca9685.o
> obj-$(CONFIG_PWM_PXA) += pwm-pxa.o
> +obj-$(CONFIG_PWM_QCOM) += pwm-qcom.o
> obj-$(CONFIG_PWM_RASPBERRYPI_POE) += pwm-raspberrypi-poe.o
> obj-$(CONFIG_PWM_RENESAS_RCAR) += pwm-rcar.o
> obj-$(CONFIG_PWM_RENESAS_RZG2L_GPT) += pwm-rzg2l-gpt.o
> diff --git a/drivers/pwm/pwm-qcom.c b/drivers/pwm/pwm-qcom.c
> new file mode 100644
> index 0000000000000000000000000000000000000000..9b15cdcaa5c76a3f2a9d7871b4e12d52cf89610a
> --- /dev/null
> +++ b/drivers/pwm/pwm-qcom.c
> @@ -0,0 +1,685 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
> + *
> + */
Please describe the general hardware properties in a "Limitations"
paragraph. Look at other drivers for the format and what to mention
there.
> +
> +#include <linux/bitops.h>
> +#include <linux/clk.h>
> +#include <linux/math64.h>
> +#include <linux/mod_devicetable.h>
Don't include <linux/mod_devicetable.h>. <linux/platform_device.h>
already gives you of_device_id, so just drop it.
> +#include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/of.h>
> +#include <linux/of_address.h>
> +#include <linux/platform_device.h>
> +#include <linux/pwm.h>
> +#include <linux/regmap.h>
> +
> +/* Offsets */
> +#define PWM_TOPCTL0 0x0
> +
> +/* offsets per frame */
> +#define PWM_CTL0 0x0
> +#define PWM_CTL1 0x4
> +#define PWM_CTL2 0x8
> +#define PWM_CYC_CFG 0xc
> +#define PWM_UPDATE 0x10
> +#define PWM_RESET 0x18
> +
> +#define PWM_FRAME_POLARITY_BIT BIT(0)
> +#define PWM_FRAME_ROLLOVER_CNT_BIT BIT(4)
> +#define PWM_FRAME_RESET_BIT BIT(0)
Please add a proper prefix to these defintions. "PWM_UPDATE" sounds much
more generic than it is.
Also ideally the bit defintions start with the register name.
> +/* All per-frame 16-bit value fields (CYC_CFG, CTL1, CTL2). */
> +#define PWM_FRAME_VAL_MASK GENMASK(15, 0)
> +
> +/*
> + * struct qcom_pwm_priv_data - per-compatible hardware description
> + * @max_channels: number of frames supported by this hardware variant.
> + * @pwm_reset_support: whether PWM_RESET is implemented, allowing the period
> + * to be changed after it has already been set once.
> + * @pwm_cnt_rollover: whether PWM_FRAME_ROLLOVER_CNT_BIT is implemented,
> + * needed so period changes don't get stuck waiting on the counter.
> + */
> +struct qcom_pwm_priv_data {
> + unsigned int max_channels;
> + bool pwm_reset_support;
> + bool pwm_cnt_rollover;
> +};
> +
> +/*
> + * struct qcom_pwm_frames - Information regarding per PWM frame
> + * @frame_id: Id number associated with each frame.
> + * @polarity: Current polarity of the particular frame.
> + * @regmap: regmap covering this frame's own register block. Each frame now
> + * owns its own "reg" range in DT, so registers are accessed at their
> + * plain offsets within this regmap instead of as an offset into a
> + * shared parent regmap.
> + * @current_period_ns: Current period of the particular frame.
> + * @current_duty_ns: Current duty cycle of the particular frame.
> + * @current_freq: Current frequency of frame.
> + * @freq_set: This bool flag is responsible for setting period once per frame.
> + * @frame_lock: mutex lock per frame.
> + * @cnt_rollover_en: This bool flag is used to set rollover bit per frame.
> + */
> +struct qcom_pwm_frames {
> + u32 frame_id;
> + u32 polarity;
> + struct regmap *regmap;
> + u64 current_period_ns;
> + u64 current_duty_ns;
> + unsigned long current_freq;
> + bool is_enabled;
> + bool freq_set;
> + struct mutex frame_lock; /* PWM per frame lock */
> + bool cnt_rollover_en;
Only a single space between type name and member name.
> +};
> +
> +/*
> + * struct qcom_pwm_chip - Information regarding per PWM block
> + * @regmap: regmap of the shared PWM_TOPCTL0 enable register.
> + * @frames: structure for all frames of each PWM block.
> + * @priv_data: per-compatible hardware description.
> + * @ahb: AHB clock providing access to the PWM block.
> + * @core: shared clock providing the PWM frame rate.
> + * @lock: mutex lock per chip (enable/disable path).
> + * @num_frames: number of frames in each PWM block.
> + */
> +struct qcom_pwm_chip {
> + struct regmap *regmap;
> + struct qcom_pwm_frames *frames;
> + const struct qcom_pwm_priv_data *priv_data;
> + struct clk *ahb;
> + struct clk *core;
> + /* This lock to be used for Enable/Disable as it is per PWM channel */
> + struct mutex lock;
> + u32 num_frames;
> +};
> +
> +static inline struct qcom_pwm_chip *to_qcom_pwm_chip(struct pwm_chip *chip)
If you rename that to qcome_pwm_from_chip it also has the common
function prefix.
> +{
> + return pwmchip_get_drvdata(chip);
> +}
> +
> +static int qcom_pwm_clks_enable(struct qcom_pwm_chip *chip)
> +{
> + int ret;
> +
> + ret = clk_prepare_enable(chip->ahb);
> + if (ret)
> + return ret;
> +
> + ret = clk_prepare_enable(chip->core);
> + if (ret)
> + clk_disable_unprepare(chip->ahb);
> +
> + return ret;
> +}
> +
> +static void qcom_pwm_clks_disable(struct qcom_pwm_chip *chip)
> +{
> + clk_disable_unprepare(chip->core);
> + clk_disable_unprepare(chip->ahb);
> +}
> +
> +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_get_state(struct pwm_chip *pwm_chip, struct pwm_device *pwm,
> + struct pwm_state *state)
> +{
> + struct qcom_pwm_chip *chip = to_qcom_pwm_chip(pwm_chip);
> + struct qcom_pwm_frames *frame = &chip->frames[pwm->hwpwm];
> + unsigned long rate;
> + u32 topctl, ctl0, ctl1, cyc_cfg, cycles;
> + int ret;
> +
> + if (!frame->regmap)
> + return -ENODEV;
> +
> + /* Both clocks are needed for register access. */
> + ret = qcom_pwm_clks_enable(chip);
> + if (ret)
> + return ret;
> +
> + rate = clk_get_rate(chip->core);
> + if (!rate) {
> + ret = -EINVAL;
> + goto err_clks;
> + }
> +
> + mutex_lock(&frame->frame_lock);
> +
> + ret = regmap_read(chip->regmap, PWM_TOPCTL0, &topctl);
> + if (ret)
> + goto out;
> +
> + ret = regmap_read(frame->regmap, PWM_CTL0, &ctl0);
> + if (ret)
> + goto out;
> +
> + ret = regmap_read(frame->regmap, PWM_CTL1, &ctl1);
> + if (ret)
> + goto out;
> +
> + ret = regmap_read(frame->regmap, PWM_CYC_CFG, &cyc_cfg);
> + if (ret)
> + goto out;
> +
> + cycles = (cyc_cfg & PWM_FRAME_VAL_MASK) + 1;
> + state->enabled = !!(topctl & BIT(frame->frame_id));
> + state->polarity = (ctl0 & PWM_FRAME_POLARITY_BIT) ?
> + PWM_POLARITY_INVERSED : PWM_POLARITY_NORMAL;
> + /*
> + * Round up so re-applying the returned state reproduces the same
> + * register values, since qcom_pwm_config() rounds the period and duty
> + * cycle down.
> + */
> + state->period = DIV_ROUND_UP_ULL((u64)cycles * NSEC_PER_SEC, rate);
> + state->duty_cycle = DIV_ROUND_UP_ULL((u64)(ctl1 & PWM_FRAME_VAL_MASK) *
> + NSEC_PER_SEC, rate);
> +out:
> + mutex_unlock(&frame->frame_lock);
> +err_clks:
> + qcom_pwm_clks_disable(chip);
> +
> + return ret;
> +}
> +
> +static int qcom_pwm_config(struct qcom_pwm_chip *chip,
> + u32 hw_idx, u64 duty_ns, u64 period_ns, int polarity)
> +{
> + struct regmap *frame_regmap = chip->frames[hw_idx].regmap;
> + u64 ctl1, duty_percent;
> + unsigned long rate;
> + u64 current_period = period_ns;
> + bool clks_enabled = false;
> + int ret;
> + u32 cyc_cfg;
> +
> + mutex_lock(&chip->frames[hw_idx].frame_lock);
> +
> + if (!chip->frames[hw_idx].is_enabled) {
> + ret = qcom_pwm_clks_enable(chip);
> + if (ret)
> + goto err_unlock;
> + clks_enabled = true;
> + }
> +
> + rate = clk_get_rate(chip->core);
> + if (!rate) {
> + ret = -EINVAL;
> + goto out;
> + }
> +
> + /*
> + * Set the counter rollover enable bit, so that counter doesn't get stuck
> + * in period change configuration.
> + */
> + if (chip->priv_data->pwm_cnt_rollover && !chip->frames[hw_idx].cnt_rollover_en) {
> + ret = regmap_update_bits(frame_regmap, PWM_CTL0,
> + PWM_FRAME_ROLLOVER_CNT_BIT,
> + PWM_FRAME_ROLLOVER_CNT_BIT);
> + if (ret)
> + goto out;
> +
> + chip->frames[hw_idx].cnt_rollover_en = true;
> + }
> +
> + 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;
> + }
> + }
> +
> + 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);
> + 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;
> + }
> +
> + ret = regmap_update_bits(frame_regmap, PWM_CTL2, PWM_FRAME_VAL_MASK, 0);
> + if (ret)
> + goto out;
> +
> + ret = regmap_update_bits(frame_regmap, PWM_CTL1, PWM_FRAME_VAL_MASK, ctl1);
> + if (ret)
> + goto out;
> +
> + ret = regmap_update_bits(frame_regmap, PWM_UPDATE, BIT(0), 1);
> + if (ret)
> + goto out;
> +
> + chip->frames[hw_idx].current_duty_ns = duty_ns;
> +out:
> + if (clks_enabled)
> + qcom_pwm_clks_disable(chip);
> +err_unlock:
> + mutex_unlock(&chip->frames[hw_idx].frame_lock);
> +
> + return ret;
> +}
> +
> +static int qcom_pwm_enable(struct qcom_pwm_chip *chip,
> + struct pwm_device *pwm)
> +{
> + struct device *dev = regmap_get_device(chip->regmap);
> + int ret;
> + u32 val, hw_idx = pwm->hwpwm;
> +
> + ret = qcom_pwm_clks_enable(chip);
> + if (ret)
> + return ret;
> +
> + mutex_lock(&chip->lock);
> +
> + dev_dbg(dev, "enable: hw_idx=%u frame_id=%u\n",
> + hw_idx, chip->frames[hw_idx].frame_id);
> +
> + val = BIT(chip->frames[hw_idx].frame_id);
> + ret = regmap_update_bits(chip->regmap, PWM_TOPCTL0, val, val);
> + if (!ret)
> + chip->frames[hw_idx].is_enabled = true;
> +
> + mutex_unlock(&chip->lock);
> +
> + if (ret)
> + goto err_clks;
> +
> + return 0;
> +
> +err_clks:
> + qcom_pwm_clks_disable(chip);
> + return ret;
> +}
> +
> +static int qcom_pwm_disable(struct qcom_pwm_chip *chip,
> + struct pwm_device *pwm)
> +{
> + struct device *dev = regmap_get_device(chip->regmap);
> + u32 val, hw_idx = pwm->hwpwm;
> + int ret;
> +
> + mutex_lock(&chip->lock);
> +
> + dev_dbg(dev, "disable: hw_idx=%u\n", hw_idx);
> +
> + val = BIT(chip->frames[hw_idx].frame_id);
> + ret = regmap_update_bits(chip->regmap, PWM_TOPCTL0, val, 0);
> + if (!ret)
> + chip->frames[hw_idx].is_enabled = false;
> +
> + mutex_unlock(&chip->lock);
> +
> + if (ret)
> + return ret;
> +
> + qcom_pwm_clks_disable(chip);
> +
> + return 0;
> +}
> +
> +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);
Don't call PWM functions from callbacks. pwm_get_state() doesn't take
the chip lock, but that's an implementation detail that you shouldn't
rely on.
> +
> + if (state->period &&
> + (state->period != curr_state.period ||
> + state->duty_cycle != curr_state.duty_cycle ||
> + state->polarity != curr_state.polarity)) {
Don't do these checks, the PWM core already handles stuff like that.
> + 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;
> + }
> + }
> +
> + 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;
> +}
> +
> +static int qcom_pwm_request(struct pwm_chip *pwm_chip, struct pwm_device *pwm)
> +{
> + struct qcom_pwm_chip *chip = to_qcom_pwm_chip(pwm_chip);
> +
> + if (!chip->frames[pwm->hwpwm].regmap)
> + return -ENODEV;
> +
> + return 0;
> +}
> +
> +/*
> + * Reset the software state and the frame's own registers (the same
> + * PWM_CTL0/PWM_CTL1/PWM_CYC_CFG registers qcom_pwm_get_state() reads back)
> + * to their power-on defaults, and disable an active PWM frame.
> + */
> +static void qcom_pwm_free(struct pwm_chip *pwm_chip, struct pwm_device *pwm)
> +{
> + struct qcom_pwm_chip *chip = to_qcom_pwm_chip(pwm_chip);
The variable name "chip" is reserved for variables of type pwm_chip. So
please use "chip" instead of "pwm_chip" and something else for the
struct qcom_pwm_chip variables.
> + struct qcom_pwm_frames *frame = &chip->frames[pwm->hwpwm];
> + bool enabled;
> + int ret;
> +
> + mutex_lock(&chip->lock);
> + enabled = frame->is_enabled;
> + mutex_unlock(&chip->lock);
> +
> + if (enabled) {
> + ret = qcom_pwm_disable(chip, pwm);
> + if (ret) {
> + dev_err(pwmchip_parent(pwm_chip),
> + "failed to disable PWM on free\n");
> + return;
> + }
> + }
> +
> + ret = qcom_pwm_clks_enable(chip);
> + if (ret) {
> + dev_err(pwmchip_parent(pwm_chip),
> + "failed to enable clocks on free\n");
> + return;
> + }
> +
> + mutex_lock(&frame->frame_lock);
> +
> + ret = regmap_update_bits(frame->regmap, PWM_CTL0,
> + PWM_FRAME_POLARITY_BIT | PWM_FRAME_ROLLOVER_CNT_BIT, 0);
> + if (ret)
> + goto out;
> +
> + ret = regmap_update_bits(frame->regmap, PWM_CTL1, PWM_FRAME_VAL_MASK, 0);
> + if (ret)
> + goto out;
> +
> + ret = regmap_update_bits(frame->regmap, PWM_CTL2, PWM_FRAME_VAL_MASK, 0);
> + if (ret)
> + goto out;
> +
> + ret = regmap_update_bits(frame->regmap, PWM_CYC_CFG, PWM_FRAME_VAL_MASK, 0);
> + if (ret)
> + goto out;
> +
> + ret = regmap_update_bits(frame->regmap, PWM_UPDATE, BIT(0), 1);
> + if (ret)
> + goto out;
> +
> + 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;
> + }
> +
> + frame->freq_set = false;
> + frame->current_period_ns = 0;
> + frame->current_duty_ns = 0;
> + frame->current_freq = 0;
> + frame->polarity = 0;
> + frame->cnt_rollover_en = false;
> +out:
> + mutex_unlock(&frame->frame_lock);
> + qcom_pwm_clks_disable(chip);
> +
> + if (ret)
> + dev_err(pwmchip_parent(pwm_chip),
> + "failed to reset PWM registers on free\n");
> +}
> +
> +static const struct pwm_ops qcom_pwm_ops = {
> + .request = qcom_pwm_request,
> + .apply = qcom_pwm_apply,
> + .free = qcom_pwm_free,
> + .get_state = qcom_pwm_get_state,
I don't accept new drivers with .apply() and .get_state(). Please use
the waveform callbacks instead.
> +};
> +
> +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);
> + if (IS_ERR(chip->regmap))
> + return dev_err_probe(dev, PTR_ERR(chip->regmap),
> + "failed to initialise regmap\n");
> +
> + chip->ahb = devm_clk_get(dev, "ahb");
> + if (IS_ERR(chip->ahb))
> + return dev_err_probe(dev, PTR_ERR(chip->ahb),
> + "failed to get ahb clock\n");
> +
> + chip->core = devm_clk_get(dev, "core");
> + if (IS_ERR(chip->core))
> + return dev_err_probe(dev, PTR_ERR(chip->core),
> + "failed to get core clock\n");
> +
> + chip->frames = devm_kcalloc(dev, chip->num_frames,
> + sizeof(*chip->frames), GFP_KERNEL);
I think devm_kzalloc_objs is the right function to use here.
> + if (!chip->frames)
> + return -ENOMEM;
> +
> + for_each_available_child_of_node(np, frame_node) {
> + u32 n;
> + struct resource res;
> +
> + if (of_property_read_u32(frame_node, "qcom,frame-index", &n)) {
> + of_node_put(frame_node);
If you use for_each_available_child_of_node_scoped you don't need to
care about the of_node_put() calls for earch error path.
> + return dev_err_probe(dev, -EINVAL,
> + "missing qcom,frame-index property in DT node\n");
> + }
> +
> + if (n >= chip->priv_data->max_channels) {
> + of_node_put(frame_node);
> + return dev_err_probe(dev, -EINVAL,
> + "invalid qcom,frame-index %u\n", n);
> + }
> +
> + if (test_and_set_bit(n, &frame_ids)) {
> + of_node_put(frame_node);
> + return dev_err_probe(dev, -EINVAL,
> + "duplicate qcom,frame-index %u\n", n);
> + }
> +
> + chip->frames[n].frame_id = n;
> +
> + ret = of_address_to_resource(frame_node, 0, &res);
> + if (ret) {
> + of_node_put(frame_node);
> + return dev_err_probe(dev, ret,
> + "failed to get frame-%u resource\n", n);
> + }
> +
> + base = devm_ioremap_resource(dev, &res);
> + if (IS_ERR(base)) {
> + of_node_put(frame_node);
> + return PTR_ERR(base);
> + }
> +
> + chip->frames[n].regmap =
> + devm_regmap_init_mmio(dev, base, &pwm_regmap_config);
> + if (IS_ERR(chip->frames[n].regmap)) {
> + of_node_put(frame_node);
> + return dev_err_probe(dev, PTR_ERR(chip->frames[n].regmap),
> + "failed to initialise frame regmap\n");
> + }
> +
> + mutex_init(&chip->frames[n].frame_lock);
> + }
> +
> + /* The hardware requires all PWM outputs to be disabled at probe. */
> + ret = qcom_pwm_clks_enable(chip);
> + if (ret)
> + return ret;
> +
> + ret = regmap_update_bits(chip->regmap, PWM_TOPCTL0,
> + GENMASK(chip->priv_data->max_channels - 1, 0), 0);
> +
> + qcom_pwm_clks_disable(chip);
> +
> + return ret;
> +}
> +
> +static const struct qcom_pwm_priv_data shikra_pwm_data = {
> + .max_channels = 10,
> +};
As long as there is only a single variant, just hardcode the info here.
> +static const struct of_device_id qcom_pwm_of_match[] = {
> + { .compatible = "qcom,shikra-pwm", .data = &shikra_pwm_data },
> + { },
Drop the trailing comma after the list terminator.
> +};
> +MODULE_DEVICE_TABLE(of, qcom_pwm_of_match);
> +
> +static int qcom_pwm_probe(struct platform_device *pdev)
> +{
> + struct pwm_chip *pwm_chip;
> + struct qcom_pwm_chip *chip;
> + const struct qcom_pwm_priv_data *priv;
> + struct device_node *np = pdev->dev.of_node;
> + u32 child_count;
> + int rc;
> +
> + priv = of_device_get_match_data(&pdev->dev);
> + if (!priv)
> + return -EINVAL;
> +
> + /* At least one available frame resource must be described. */
> + child_count = of_get_available_child_count(np);
> + if (!child_count)
> + return dev_err_probe(&pdev->dev, -EINVAL,
> + "at least one PWM frame must be described\n");
Error messages start with a capital letter.
> + pwm_chip = devm_pwmchip_alloc(&pdev->dev, priv->max_channels, sizeof(*chip));
> + if (IS_ERR(pwm_chip))
> + return PTR_ERR(pwm_chip);
> +
> + chip = to_qcom_pwm_chip(pwm_chip);
> + chip->priv_data = priv;
Single space before = please
> + chip->num_frames = priv->max_channels;
> + mutex_init(&chip->lock);
> +
> + pwm_chip->ops = &qcom_pwm_ops;
> +
> + rc = qcom_pwm_parse_dt(pdev, pwm_chip, chip);
> + if (rc)
> + return rc;
> +
> + rc = devm_pwmchip_add(&pdev->dev, pwm_chip);
> + if (rc)
> + return rc;
> +
> + return 0;
> +}
> +
> +static struct platform_driver qcom_pwm_driver = {
> + .driver = {
> + .name = "qcom-pwm",
> + .of_match_table = qcom_pwm_of_match,
> + },
> + .probe = qcom_pwm_probe,
Please use a single space before =.
> +};
> +
> +module_platform_driver(qcom_pwm_driver);
> +
> +MODULE_DESCRIPTION("Qualcomm PWM driver");
> +MODULE_LICENSE("GPL");
Best regards
Uwe
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]
next prev parent reply other threads:[~2026-11-17 14:44 UTC|newest]
Thread overview: 6+ 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 10:05 ` Krzysztof Kozlowski
2026-11-16 6:59 ` [PATCH 2/3] pwm: qcom: add Shikra PWM controller support Taniya Das
2026-11-17 14:44 ` Uwe Kleine-König [this message]
2026-11-16 6:59 ` [PATCH 3/3] arm64: dts: qcom: add Shikra PWM controller Taniya Das
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=avxh7fQliDF_wCms@monoceros \
--to=ukleinek@kernel.org \
--cc=abelvesa@kernel.org \
--cc=ajit.pandey@oss.qualcomm.com \
--cc=andersson@kernel.org \
--cc=conor+dt@kernel.org \
--cc=devicetree@vger.kernel.org \
--cc=imran.shaik@oss.qualcomm.com \
--cc=jagadeesh.kona@oss.qualcomm.com \
--cc=konradybcio@kernel.org \
--cc=krzk+dt@kernel.org \
--cc=linux-arm-msm@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-pwm@vger.kernel.org \
--cc=robh@kernel.org \
--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
all inboxes | Powered by JetHome®