All of lore.kernel.org
 help / color / mirror / Atom feed
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 --]

  parent reply	other threads:[~2026-11-17 14:44 UTC|newest]

Thread overview: 9+ 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 10:05   ` Krzysztof Kozlowski
2026-11-16  6:59 ` [PATCH 2/3] pwm: qcom: add Shikra PWM controller support Taniya Das
2026-11-16  7:29   ` sashiko-bot
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
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=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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.