Message-Id: <CWFMYY5X1YDI.1DFA3SWOTWIKR@fairphone.com>
Date:   Mon, 23 Oct 2023 09:21:58 +0200
From:   "Luca Weiss" <luca.weiss@...rphone.com>
To:     "Anjelique Melendez" <quic_amelende@...cinc.com>, <pavel@....cz>,
        <lee@...nel.org>, <thierry.reding@...il.com>, <robh+dt@...nel.org>,
        <krzysztof.kozlowski+dt@...aro.org>, <conor+dt@...nel.org>,
        <agross@...nel.org>, <andersson@...nel.org>
Cc:     <konrad.dybcio@...aro.org>, <u.kleine-koenig@...gutronix.de>,
        <quic_subbaram@...cinc.com>, <quic_gurus@...cinc.com>,
        <linux-leds@...r.kernel.org>, <devicetree@...r.kernel.org>,
        <linux-kernel@...r.kernel.org>, <linux-arm-msm@...r.kernel.org>,
        <linux-pwm@...r.kernel.org>
Subject: Re: [PATCH v6 4/7] leds: rgb: leds-qcom-lpg: Add support for PPG
 through single SDAM

On Fri Oct 20, 2023 at 8:22 PM CEST, Anjelique Melendez wrote:
> In some PMICs like pmi632, the pattern look up table (LUT) and LPG
> configuration is stored in a single SDAM module instead of LUT
> peripheral. This feature is called PPG. PPG uses Qualcomm Programmable
> Boot Sequencer (PBS) inorder to trigger pattern sequences for PMICs.

As with PATCH 5/7:

Tested-by: Luca Weiss <luca.weiss@...rphone.com>

>
> Signed-off-by: Anjelique Melendez <quic_amelende@...cinc.com>
> ---
>  drivers/leds/rgb/leds-qcom-lpg.c | 264 ++++++++++++++++++++++++++++---
>  1 file changed, 242 insertions(+), 22 deletions(-)
>
> diff --git a/drivers/leds/rgb/leds-qcom-lpg.c b/drivers/leds/rgb/leds-qcom-lpg.c
> index df469aaa7e6e..0c6d0e593c06 100644
> --- a/drivers/leds/rgb/leds-qcom-lpg.c
> +++ b/drivers/leds/rgb/leds-qcom-lpg.c
> @@ -8,11 +8,13 @@
>  #include <linux/bitfield.h>
>  #include <linux/led-class-multicolor.h>
>  #include <linux/module.h>
> +#include <linux/nvmem-consumer.h>
>  #include <linux/of.h>
>  #include <linux/platform_device.h>
>  #include <linux/pwm.h>
>  #include <linux/regmap.h>
>  #include <linux/slab.h>
> +#include <linux/soc/qcom/qcom-pbs.h>
>  
>  #define LPG_SUBTYPE_REG		0x05
>  #define  LPG_SUBTYPE_LPG	0x2
> @@ -39,6 +41,8 @@
>  #define PWM_SEC_ACCESS_REG	0xd0
>  #define PWM_DTEST_REG(x)	(0xe2 + (x) - 1)
>  
> +#define SDAM_REG_PBS_SEQ_EN		0x42
> +
>  #define TRI_LED_SRC_SEL		0x45
>  #define TRI_LED_EN_CTL		0x46
>  #define TRI_LED_ATC_CTL		0x47
> @@ -48,9 +52,25 @@
>  
>  #define LPG_RESOLUTION_9BIT	BIT(9)
>  #define LPG_RESOLUTION_15BIT	BIT(15)
> +#define PPG_MAX_LED_BRIGHTNESS	255
> +
>  #define LPG_MAX_M		7
>  #define LPG_MAX_PREDIV		6
>  
> +#define DEFAULT_TICK_DURATION_US	7800
> +#define RAMP_STEP_DURATION(x)		(((x) * 1000 / DEFAULT_TICK_DURATION_US) & 0xff)
> +
> +/* LPG common config settings for PPG */
> +#define SDAM_REG_RAMP_STEP_DURATION		0x47
> +#define SDAM_LPG_SDAM_LUT_PATTERN_OFFSET	0x80
> +
> +/* LPG per channel config settings for PPG */
> +#define SDAM_LUT_EN_OFFSET			0x0
> +#define SDAM_PATTERN_CONFIG_OFFSET		0x1
> +#define SDAM_END_INDEX_OFFSET			0x3
> +#define SDAM_START_INDEX_OFFSET		0x4
> +#define SDAM_PBS_SCRATCH_LUT_COUNTER_OFFSET	0x6
> +
>  struct lpg_channel;
>  struct lpg_data;
>  
> @@ -64,6 +84,9 @@ struct lpg_data;
>   * @lut_base:	base address of the LUT block (optional)
>   * @lut_size:	number of entries in the LUT block
>   * @lut_bitmap:	allocation bitmap for LUT entries
> + * @pbs_dev:	PBS device
> + * @lpg_chan_sdam:	LPG SDAM peripheral device
> + * @pbs_en_bitmap:	bitmap for tracking PBS triggers
>   * @triled_base: base address of the TRILED block (optional)
>   * @triled_src:	power-source for the TRILED
>   * @triled_has_atc_ctl:	true if there is TRI_LED_ATC_CTL register
> @@ -85,6 +108,10 @@ struct lpg {
>  	u32 lut_size;
>  	unsigned long *lut_bitmap;
>  
> +	struct pbs_dev *pbs_dev;
> +	struct nvmem_device *lpg_chan_sdam;
> +	unsigned long pbs_en_bitmap;
> +
>  	u32 triled_base;
>  	u32 triled_src;
>  	bool triled_has_atc_ctl;
> @@ -101,6 +128,7 @@ struct lpg {
>   * @triled_mask: mask in TRILED to enable this channel
>   * @lut_mask:	mask in LUT to start pattern generator for this channel
>   * @subtype:	PMIC hardware block subtype
> + * @sdam_offset:	channel offset in LPG SDAM
>   * @in_use:	channel is exposed to LED framework
>   * @color:	color of the LED attached to this channel
>   * @dtest_line:	DTEST line for output, or 0 if disabled
> @@ -129,6 +157,7 @@ struct lpg_channel {
>  	unsigned int triled_mask;
>  	unsigned int lut_mask;
>  	unsigned int subtype;
> +	u32 sdam_offset;
>  
>  	bool in_use;
>  
> @@ -178,10 +207,12 @@ struct lpg_led {
>  
>  /**
>   * struct lpg_channel_data - per channel initialization data
> + * @sdam_offset:	Channel offset in LPG SDAM
>   * @base:		base address for PWM channel registers
>   * @triled_mask:	bitmask for controlling this channel in TRILED
>   */
>  struct lpg_channel_data {
> +	unsigned int sdam_offset;
>  	unsigned int base;
>  	u8 triled_mask;
>  };
> @@ -206,6 +237,52 @@ struct lpg_data {
>  	const struct lpg_channel_data *channels;
>  };
>  
> +#define PBS_SW_TRIG_BIT		BIT(0)
> +
> +static int lpg_clear_pbs_trigger(struct lpg *lpg, unsigned int lut_mask)
> +{
> +	u8 val = 0;
> +	int rc;
> +
> +	lpg->pbs_en_bitmap &= (~lut_mask);
> +	if (!lpg->pbs_en_bitmap) {
> +		rc = nvmem_device_write(lpg->lpg_chan_sdam, SDAM_REG_PBS_SEQ_EN, 1, &val);
> +		if (rc < 0)
> +			return rc;
> +	}
> +
> +	return 0;
> +}
> +
> +static int lpg_set_pbs_trigger(struct lpg *lpg, unsigned int lut_mask)
> +{
> +	u8 val = PBS_SW_TRIG_BIT;
> +	int rc;
> +
> +	if (!lpg->pbs_en_bitmap) {
> +		rc = nvmem_device_write(lpg->lpg_chan_sdam, SDAM_REG_PBS_SEQ_EN, 1, &val);
> +		if (rc < 0)
> +			return rc;
> +
> +		rc = qcom_pbs_trigger_event(lpg->pbs_dev, val);
> +		if (rc < 0)
> +			return rc;
> +	}
> +	lpg->pbs_en_bitmap |= lut_mask;
> +
> +	return 0;
> +}
> +
> +static int lpg_sdam_configure_triggers(struct lpg_channel *chan, u8 set_trig)
> +{
> +	u32 addr = SDAM_LUT_EN_OFFSET + chan->sdam_offset;
> +
> +	if (!chan->lpg->lpg_chan_sdam)
> +		return 0;
> +
> +	return nvmem_device_write(chan->lpg->lpg_chan_sdam, addr, 1, &set_trig);
> +}
> +
>  static int triled_set(struct lpg *lpg, unsigned int mask, unsigned int enable)
>  {
>  	/* Skip if we don't have a triled block */
> @@ -216,6 +293,40 @@ static int triled_set(struct lpg *lpg, unsigned int mask, unsigned int enable)
>  				  mask, enable);
>  }
>  
> +static int lpg_lut_store_sdam(struct lpg *lpg, struct led_pattern *pattern,
> +			 size_t len, unsigned int *lo_idx, unsigned int *hi_idx)
> +{
> +	unsigned int idx;
> +	u8 brightness;
> +	int i, rc;
> +	u16 addr;
> +
> +	if (len > lpg->lut_size) {
> +		dev_err(lpg->dev, "Pattern length (%zu) exceeds maximum pattern length (%d)\n",
> +			len, lpg->lut_size);
> +		return -EINVAL;
> +	}
> +
> +	idx = bitmap_find_next_zero_area(lpg->lut_bitmap, lpg->lut_size, 0, len, 0);
> +	if (idx >= lpg->lut_size)
> +		return -ENOSPC;
> +
> +	for (i = 0; i < len; i++) {
> +		brightness = pattern[i].brightness;
> +		addr = SDAM_LPG_SDAM_LUT_PATTERN_OFFSET + i + idx;
> +		rc = nvmem_device_write(lpg->lpg_chan_sdam, addr, 1, &brightness);
> +		if (rc < 0)
> +			return rc;
> +	}
> +
> +	bitmap_set(lpg->lut_bitmap, idx, len);
> +
> +	*lo_idx = idx;
> +	*hi_idx = idx + len - 1;
> +
> +	return 0;
> +}
> +
>  static int lpg_lut_store(struct lpg *lpg, struct led_pattern *pattern,
>  			 size_t len, unsigned int *lo_idx, unsigned int *hi_idx)
>  {
> @@ -256,6 +367,9 @@ static void lpg_lut_free(struct lpg *lpg, unsigned int lo_idx, unsigned int hi_i
>  
>  static int lpg_lut_sync(struct lpg *lpg, unsigned int mask)
>  {
> +	if (!lpg->lut_base)
> +		return 0;
> +
>  	return regmap_write(lpg->map, lpg->lut_base + RAMP_CONTROL_REG, mask);
>  }
>  
> @@ -462,6 +576,28 @@ static void lpg_apply_pwm_value(struct lpg_channel *chan)
>  #define LPG_PATTERN_CONFIG_PAUSE_HI	BIT(1)
>  #define LPG_PATTERN_CONFIG_PAUSE_LO	BIT(0)
>  
> +static void lpg_sdam_apply_lut_control(struct lpg_channel *chan)
> +{
> +	struct nvmem_device *lpg_chan_sdam = chan->lpg->lpg_chan_sdam;
> +	unsigned int lo_idx = chan->pattern_lo_idx;
> +	unsigned int hi_idx = chan->pattern_hi_idx;
> +	u8 val = 0, conf = 0;
> +
> +	if (!chan->ramp_enabled || chan->pattern_lo_idx == chan->pattern_hi_idx)
> +		return;
> +
> +	if (!chan->ramp_oneshot)
> +		conf |= LPG_PATTERN_CONFIG_REPEAT;
> +
> +	nvmem_device_write(lpg_chan_sdam, SDAM_PBS_SCRATCH_LUT_COUNTER_OFFSET + chan->sdam_offset, 1, &val);
> +	nvmem_device_write(lpg_chan_sdam, SDAM_PATTERN_CONFIG_OFFSET + chan->sdam_offset, 1, &conf);
> +	nvmem_device_write(lpg_chan_sdam, SDAM_END_INDEX_OFFSET + chan->sdam_offset, 1, &hi_idx);
> +	nvmem_device_write(lpg_chan_sdam, SDAM_START_INDEX_OFFSET + chan->sdam_offset, 1, &lo_idx);
> +
> +	val = RAMP_STEP_DURATION(chan->ramp_tick_ms);
> +	nvmem_device_write(lpg_chan_sdam, SDAM_REG_RAMP_STEP_DURATION, 1, &val);
> +}
> +
>  static void lpg_apply_lut_control(struct lpg_channel *chan)
>  {
>  	struct lpg *lpg = chan->lpg;
> @@ -597,7 +733,10 @@ static void lpg_apply(struct lpg_channel *chan)
>  	lpg_apply_pwm_value(chan);
>  	lpg_apply_control(chan);
>  	lpg_apply_sync(chan);
> -	lpg_apply_lut_control(chan);
> +	if (chan->lpg->lpg_chan_sdam)
> +		lpg_sdam_apply_lut_control(chan);
> +	else
> +		lpg_apply_lut_control(chan);
>  	lpg_enable_glitch(chan);
>  }
>  
> @@ -622,6 +761,7 @@ static void lpg_brightness_set(struct lpg_led *led, struct led_classdev *cdev,
>  			chan->ramp_enabled = false;
>  		} else if (chan->pattern_lo_idx != chan->pattern_hi_idx) {
>  			lpg_calc_freq(chan, NSEC_PER_MSEC);
> +			lpg_sdam_configure_triggers(chan, 1);
>  
>  			chan->enabled = true;
>  			chan->ramp_enabled = true;
> @@ -649,8 +789,10 @@ static void lpg_brightness_set(struct lpg_led *led, struct led_classdev *cdev,
>  		triled_set(lpg, triled_mask, triled_enabled);
>  
>  	/* Trigger start of ramp generator(s) */
> -	if (lut_mask)
> +	if (lut_mask) {
>  		lpg_lut_sync(lpg, lut_mask);
> +		lpg_set_pbs_trigger(lpg, lut_mask);
> +	}
>  }
>  
>  static int lpg_brightness_single_set(struct led_classdev *cdev,
> @@ -836,18 +978,23 @@ static int lpg_pattern_set(struct lpg_led *led, struct led_pattern *led_pattern,
>  	 * If the specified pattern is a palindrome the ping pong mode is
>  	 * enabled. In this scenario the delta_t of the middle entry (i.e. the
>  	 * last in the programmed pattern) determines the "high pause".
> +	 *
> +	 * SDAM-based devices do not support "ping-pong", "low pause" or "high pause"
>  	 */
>  
>  	/* Detect palindromes and use "ping pong" to reduce LUT usage */
> -	for (i = 0; i < len / 2; i++) {
> -		brightness_a = pattern[i].brightness;
> -		brightness_b = pattern[len - i - 1].brightness;
> -
> -		if (brightness_a != brightness_b) {
> -			ping_pong = false;
> -			break;
> +	if (lpg->lut_base) {
> +		for (i = 0; i < len / 2; i++) {
> +			brightness_a = pattern[i].brightness;
> +			brightness_b = pattern[len - i - 1].brightness;
> +
> +			if (brightness_a != brightness_b) {
> +				ping_pong = false;
> +				break;
> +			}
>  		}
> -	}
> +	} else
> +		ping_pong = false;
>  
>  	/* The pattern length to be written to the LUT */
>  	if (ping_pong)
> @@ -875,12 +1022,26 @@ static int lpg_pattern_set(struct lpg_led *led, struct led_pattern *led_pattern,
>  	if (delta_t >= BIT(9))
>  		goto out_free_pattern;
>  
> -	/* Find "low pause" and "high pause" in the pattern */
> -	lo_pause = pattern[0].delta_t;
> -	hi_pause = pattern[actual_len - 1].delta_t;
> +	/*
> +	 * Find "low pause" and "high pause" in the pattern in the LUT case.
> +	 * SDAM-based devices require equal duration of all steps
> +	 */
> +	if (lpg->lut_base) {
> +		lo_pause = pattern[0].delta_t;
> +		hi_pause = pattern[actual_len - 1].delta_t;
> +	} else {
> +		if (delta_t != pattern[0].delta_t || delta_t != pattern[actual_len - 1].delta_t)
> +			goto out_free_pattern;
> +	}
> +
>  
>  	mutex_lock(&lpg->lock);
> -	ret = lpg_lut_store(lpg, pattern, actual_len, &lo_idx, &hi_idx);
> +
> +	if (lpg->lut_base)
> +		ret = lpg_lut_store(lpg, pattern, actual_len, &lo_idx, &hi_idx);
> +	else
> +		ret = lpg_lut_store_sdam(lpg, pattern, actual_len, &lo_idx, &hi_idx);
> +
>  	if (ret < 0)
>  		goto out_unlock;
>  
> @@ -928,7 +1089,12 @@ static int lpg_pattern_mc_set(struct led_classdev *cdev,
>  {
>  	struct led_classdev_mc *mc = lcdev_to_mccdev(cdev);
>  	struct lpg_led *led = container_of(mc, struct lpg_led, mcdev);
> -	int ret;
> +	unsigned int triled_mask = 0;
> +	int ret, i;
> +
> +	for (i = 0; i < led->num_channels; i++)
> +		triled_mask |= led->channels[i]->triled_mask;
> +	triled_set(led->lpg, triled_mask, 0);
>  
>  	ret = lpg_pattern_set(led, pattern, len, repeat);
>  	if (ret < 0)
> @@ -953,6 +1119,8 @@ static int lpg_pattern_clear(struct lpg_led *led)
>  
>  	for (i = 0; i < led->num_channels; i++) {
>  		chan = led->channels[i];
> +		lpg_sdam_configure_triggers(chan, 0);
> +		lpg_clear_pbs_trigger(chan->lpg, chan->lut_mask);
>  		chan->pattern_lo_idx = 0;
>  		chan->pattern_hi_idx = 0;
>  	}
> @@ -1188,8 +1356,8 @@ static int lpg_add_led(struct lpg *lpg, struct device_node *np)
>  		cdev->brightness_set_blocking = lpg_brightness_mc_set;
>  		cdev->blink_set = lpg_blink_mc_set;
>  
> -		/* Register pattern accessors only if we have a LUT block */
> -		if (lpg->lut_base) {
> +		/* Register pattern accessors if we have a LUT block or when using PPG */
> +		if (lpg->lut_base || lpg->lpg_chan_sdam) {
>  			cdev->pattern_set = lpg_pattern_mc_set;
>  			cdev->pattern_clear = lpg_pattern_mc_clear;
>  		}
> @@ -1202,15 +1370,19 @@ static int lpg_add_led(struct lpg *lpg, struct device_node *np)
>  		cdev->brightness_set_blocking = lpg_brightness_single_set;
>  		cdev->blink_set = lpg_blink_single_set;
>  
> -		/* Register pattern accessors only if we have a LUT block */
> -		if (lpg->lut_base) {
> +		/* Register pattern accessors if we have a LUT block or when using PPG */
> +		if (lpg->lut_base || lpg->lpg_chan_sdam) {
>  			cdev->pattern_set = lpg_pattern_single_set;
>  			cdev->pattern_clear = lpg_pattern_single_clear;
>  		}
>  	}
>  
>  	cdev->default_trigger = of_get_property(np, "linux,default-trigger", NULL);
> -	cdev->max_brightness = LPG_RESOLUTION_9BIT - 1;
> +
> +	if (lpg->lpg_chan_sdam)
> +		cdev->max_brightness = PPG_MAX_LED_BRIGHTNESS;
> +	else
> +		cdev->max_brightness = LPG_RESOLUTION_9BIT - 1;
>  
>  	if (!of_property_read_string(np, "default-state", &state) &&
>  	    !strcmp(state, "on"))
> @@ -1251,6 +1423,7 @@ static int lpg_init_channels(struct lpg *lpg)
>  		chan->base = data->channels[i].base;
>  		chan->triled_mask = data->channels[i].triled_mask;
>  		chan->lut_mask = BIT(i);
> +		chan->sdam_offset = data->channels[i].sdam_offset;
>  
>  		regmap_read(lpg->map, chan->base + LPG_SUBTYPE_REG, &chan->subtype);
>  	}
> @@ -1297,11 +1470,12 @@ static int lpg_init_lut(struct lpg *lpg)
>  {
>  	const struct lpg_data *data = lpg->data;
>  
> -	if (!data->lut_base)
> +	if (!data->lut_size)
>  		return 0;
>  
> -	lpg->lut_base = data->lut_base;
>  	lpg->lut_size = data->lut_size;
> +	if (data->lut_base)
> +		lpg->lut_base = data->lut_base;
>  
>  	lpg->lut_bitmap = devm_bitmap_zalloc(lpg->dev, lpg->lut_size, GFP_KERNEL);
>  	if (!lpg->lut_bitmap)
> @@ -1310,6 +1484,48 @@ static int lpg_init_lut(struct lpg *lpg)
>  	return 0;
>  }
>  
> +static int lpg_init_sdam(struct lpg *lpg)
> +{
> +	int i, sdam_count, rc;
> +	u8 val = 0;
> +
> +	sdam_count = of_property_count_strings(lpg->dev->of_node, "nvmem-names");
> +	if (sdam_count <= 0)
> +		return 0;
> +
> +	/* Get the SDAM device for LPG/LUT config */
> +	lpg->lpg_chan_sdam = devm_nvmem_device_get(lpg->dev, "lpg_chan_sdam");
> +	if (IS_ERR(lpg->lpg_chan_sdam))
> +		return dev_err_probe(lpg->dev, PTR_ERR(lpg->lpg_chan_sdam),
> +				"Failed to get LPG chan SDAM device\n");
> +
> +	lpg->pbs_dev = get_pbs_client_device(lpg->dev);
> +	if (IS_ERR(lpg->pbs_dev))
> +		return dev_err_probe(lpg->dev, PTR_ERR(lpg->pbs_dev),
> +				"Failed to get PBS client device\n");
> +
> +	for (i = 0; i < lpg->num_channels; i++) {
> +		struct lpg_channel *chan = &lpg->channels[i];
> +
> +		if (chan->sdam_offset) {
> +			rc = nvmem_device_write(lpg->lpg_chan_sdam,
> +				SDAM_PBS_SCRATCH_LUT_COUNTER_OFFSET + chan->sdam_offset, 1, &val);
> +			if (rc < 0)
> +				return rc;
> +
> +			rc = lpg_sdam_configure_triggers(chan, 0);
> +			if (rc < 0)
> +				return rc;
> +
> +			rc = lpg_clear_pbs_trigger(chan->lpg, chan->lut_mask);
> +			if (rc < 0)
> +				return rc;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
>  static int lpg_probe(struct platform_device *pdev)
>  {
>  	struct device_node *np;
> @@ -1346,6 +1562,10 @@ static int lpg_probe(struct platform_device *pdev)
>  	if (ret < 0)
>  		return ret;
>  
> +	ret = lpg_init_sdam(lpg);
> +	if (ret < 0)
> +		return ret;
> +
>  	ret = lpg_init_lut(lpg);
>  	if (ret < 0)
>  		return ret;

Powered by blists - more mailing lists