mfd: stm32-timers: Use dma_request_chan() instead dma_request_slave_channel()

Message ID 20191217105240.25648-1-peter.ujfalusi@ti.com
State New
Headers show
Series
  • mfd: stm32-timers: Use dma_request_chan() instead dma_request_slave_channel()
Related show

Commit Message

Peter Ujfalusi Dec. 17, 2019, 10:52 a.m.
dma_request_slave_channel() is a wrapper on top of dma_request_chan()
eating up the error code.

By using dma_request_chan() directly the driver can support deferred
probing against DMA.

Signed-off-by: Peter Ujfalusi <peter.ujfalusi@ti.com>

---
 drivers/mfd/stm32-timers.c | 31 ++++++++++++++++++++++---------
 1 file changed, 22 insertions(+), 9 deletions(-)

-- 
Peter

Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki.
Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki

Comments

Fabrice Gasnier Dec. 20, 2019, 8:54 a.m. | #1
On 12/17/19 11:52 AM, Peter Ujfalusi wrote:
> dma_request_slave_channel() is a wrapper on top of dma_request_chan()

> eating up the error code.

> 

> By using dma_request_chan() directly the driver can support deferred

> probing against DMA.

> 

> Signed-off-by: Peter Ujfalusi <peter.ujfalusi@ti.com>

> ---

>  drivers/mfd/stm32-timers.c | 31 ++++++++++++++++++++++---------

>  1 file changed, 22 insertions(+), 9 deletions(-)

> 

> diff --git a/drivers/mfd/stm32-timers.c b/drivers/mfd/stm32-timers.c

> index efcd4b980c94..34747e8a4a40 100644

> --- a/drivers/mfd/stm32-timers.c

> +++ b/drivers/mfd/stm32-timers.c

> @@ -167,10 +167,11 @@ static void stm32_timers_get_arr_size(struct stm32_timers *ddata)

>  	regmap_write(ddata->regmap, TIM_ARR, 0x0);

>  }

>  

> -static void stm32_timers_dma_probe(struct device *dev,

> +static int stm32_timers_dma_probe(struct device *dev,

>  				   struct stm32_timers *ddata)

>  {

>  	int i;

> +	int ret = 0;

>  	char name[4];

>  

>  	init_completion(&ddata->dma.completion);

> @@ -179,14 +180,22 @@ static void stm32_timers_dma_probe(struct device *dev,

>  	/* Optional DMA support: get valid DMA channel(s) or NULL */

>  	for (i = STM32_TIMERS_DMA_CH1; i <= STM32_TIMERS_DMA_CH4; i++) {

>  		snprintf(name, ARRAY_SIZE(name), "ch%1d", i + 1);

> -		ddata->dma.chans[i] = dma_request_slave_channel(dev, name);

> +		ddata->dma.chans[i] = dma_request_chan(dev, name);

>  	}

> -	ddata->dma.chans[STM32_TIMERS_DMA_UP] =

> -		dma_request_slave_channel(dev, "up");

> -	ddata->dma.chans[STM32_TIMERS_DMA_TRIG] =

> -		dma_request_slave_channel(dev, "trig");

> -	ddata->dma.chans[STM32_TIMERS_DMA_COM] =

> -		dma_request_slave_channel(dev, "com");

> +	ddata->dma.chans[STM32_TIMERS_DMA_UP] = dma_request_chan(dev, "up");

> +	ddata->dma.chans[STM32_TIMERS_DMA_TRIG] = dma_request_chan(dev, "trig");

> +	ddata->dma.chans[STM32_TIMERS_DMA_COM] = dma_request_chan(dev, "com");

> +

> +	for (i = STM32_TIMERS_DMA_CH1; i < STM32_TIMERS_MAX_DMAS; i++) {

> +		if (IS_ERR(ddata->dma.chans[i])) {

> +			if (PTR_ERR(ddata->dma.chans[i]) == -EPROBE_DEFER)> +				ret = -EPROBE_DEFER;


Hi Peter,

Thanks for the patch,

As the DMA is optional, I'd rather prefer to check explicitly there's no
device, and return any other error case, basically:

			if (PTR_ERR(ddata->dma.chans[i]) != -ENODEV)
				return PTR_ERR(ddata->dma.chans[i]);

> +

> +			ddata->dma.chans[i] = NULL;

> +		}

> +	}

> +

> +	return ret;


With that, return 0 here.

>  }

>  

>  static void stm32_timers_dma_remove(struct device *dev,

> @@ -230,7 +239,11 @@ static int stm32_timers_probe(struct platform_device *pdev)

>  

>  	stm32_timers_get_arr_size(ddata);

>  

> -	stm32_timers_dma_probe(dev, ddata);

> +	ret = stm32_timers_dma_probe(dev, ddata);

> +	if (ret) {

> +		stm32_timers_dma_remove(dev, ddata);


With that, stm32_timers_dma_remove() likely need to be updated:

-		if (ddata->dma.chans[i])
+		if (!IS_ERR_OR_NULL(ddata->dma.chans[i]))
			dma_release_channel(ddata->dma.chans[i]);

Best regards,
Fabrice

> +		return ret;

> +	}

>  

>  	platform_set_drvdata(pdev, ddata);

>  

>
Peter Ujfalusi Dec. 20, 2019, 11:36 a.m. | #2
Hi Fabrice,

On 20/12/2019 10.54, Fabrice Gasnier wrote:
> On 12/17/19 11:52 AM, Peter Ujfalusi wrote:

>> dma_request_slave_channel() is a wrapper on top of dma_request_chan()

>> eating up the error code.

>>

>> By using dma_request_chan() directly the driver can support deferred

>> probing against DMA.

>>

>> Signed-off-by: Peter Ujfalusi <peter.ujfalusi@ti.com>

>> ---

>>  drivers/mfd/stm32-timers.c | 31 ++++++++++++++++++++++---------

>>  1 file changed, 22 insertions(+), 9 deletions(-)

>>

>> diff --git a/drivers/mfd/stm32-timers.c b/drivers/mfd/stm32-timers.c

>> index efcd4b980c94..34747e8a4a40 100644

>> --- a/drivers/mfd/stm32-timers.c

>> +++ b/drivers/mfd/stm32-timers.c

>> @@ -167,10 +167,11 @@ static void stm32_timers_get_arr_size(struct stm32_timers *ddata)

>>  	regmap_write(ddata->regmap, TIM_ARR, 0x0);

>>  }

>>  

>> -static void stm32_timers_dma_probe(struct device *dev,

>> +static int stm32_timers_dma_probe(struct device *dev,

>>  				   struct stm32_timers *ddata)

>>  {

>>  	int i;

>> +	int ret = 0;

>>  	char name[4];

>>  

>>  	init_completion(&ddata->dma.completion);

>> @@ -179,14 +180,22 @@ static void stm32_timers_dma_probe(struct device *dev,

>>  	/* Optional DMA support: get valid DMA channel(s) or NULL */

>>  	for (i = STM32_TIMERS_DMA_CH1; i <= STM32_TIMERS_DMA_CH4; i++) {

>>  		snprintf(name, ARRAY_SIZE(name), "ch%1d", i + 1);

>> -		ddata->dma.chans[i] = dma_request_slave_channel(dev, name);

>> +		ddata->dma.chans[i] = dma_request_chan(dev, name);

>>  	}

>> -	ddata->dma.chans[STM32_TIMERS_DMA_UP] =

>> -		dma_request_slave_channel(dev, "up");

>> -	ddata->dma.chans[STM32_TIMERS_DMA_TRIG] =

>> -		dma_request_slave_channel(dev, "trig");

>> -	ddata->dma.chans[STM32_TIMERS_DMA_COM] =

>> -		dma_request_slave_channel(dev, "com");

>> +	ddata->dma.chans[STM32_TIMERS_DMA_UP] = dma_request_chan(dev, "up");

>> +	ddata->dma.chans[STM32_TIMERS_DMA_TRIG] = dma_request_chan(dev, "trig");

>> +	ddata->dma.chans[STM32_TIMERS_DMA_COM] = dma_request_chan(dev, "com");

>> +

>> +	for (i = STM32_TIMERS_DMA_CH1; i < STM32_TIMERS_MAX_DMAS; i++) {

>> +		if (IS_ERR(ddata->dma.chans[i])) {

>> +			if (PTR_ERR(ddata->dma.chans[i]) == -EPROBE_DEFER)> +				ret = -EPROBE_DEFER;

> 

> Hi Peter,

> 

> Thanks for the patch,

> 

> As the DMA is optional, I'd rather prefer to check explicitly there's no

> device, and return any other error case, basically:

> 

> 			if (PTR_ERR(ddata->dma.chans[i]) != -ENODEV)

> 				return PTR_ERR(ddata->dma.chans[i]);


My intention was to specifically pick and handle EPROBE_DEFER while not
changing how the driver handles other errors, whether it because there
is no DMA channel specified or there is a failure to get the channel.

But if you prefer to ignore only ENODEV and report other errors then I
can send v2.
It could expose otherwise ignored configuration error (from DT?) and the
change in the driver will be blamed for the regression.

Would it make sense to add the change you suggested as an iteration on
top of this patch?

> 

>> +

>> +			ddata->dma.chans[i] = NULL;

>> +		}

>> +	}

>> +

>> +	return ret;

> 

> With that, return 0 here.

> 

>>  }

>>  

>>  static void stm32_timers_dma_remove(struct device *dev,

>> @@ -230,7 +239,11 @@ static int stm32_timers_probe(struct platform_device *pdev)

>>  

>>  	stm32_timers_get_arr_size(ddata);

>>  

>> -	stm32_timers_dma_probe(dev, ddata);

>> +	ret = stm32_timers_dma_probe(dev, ddata);

>> +	if (ret) {

>> +		stm32_timers_dma_remove(dev, ddata);

> 

> With that, stm32_timers_dma_remove() likely need to be updated:

> 

> -		if (ddata->dma.chans[i])

> +		if (!IS_ERR_OR_NULL(ddata->dma.chans[i]))

> 			dma_release_channel(ddata->dma.chans[i]);

> 

> Best regards,

> Fabrice

> 

>> +		return ret;

>> +	}

>>  

>>  	platform_set_drvdata(pdev, ddata);

>>  

>>


Kind regards,
- P├ęter

Texas Instruments Finland Oy, Porkkalankatu 22, 00180 Helsinki.
Y-tunnus/Business ID: 0615521-4. Kotipaikka/Domicile: Helsinki

Patch

diff --git a/drivers/mfd/stm32-timers.c b/drivers/mfd/stm32-timers.c
index efcd4b980c94..34747e8a4a40 100644
--- a/drivers/mfd/stm32-timers.c
+++ b/drivers/mfd/stm32-timers.c
@@ -167,10 +167,11 @@  static void stm32_timers_get_arr_size(struct stm32_timers *ddata)
 	regmap_write(ddata->regmap, TIM_ARR, 0x0);
 }
 
-static void stm32_timers_dma_probe(struct device *dev,
+static int stm32_timers_dma_probe(struct device *dev,
 				   struct stm32_timers *ddata)
 {
 	int i;
+	int ret = 0;
 	char name[4];
 
 	init_completion(&ddata->dma.completion);
@@ -179,14 +180,22 @@  static void stm32_timers_dma_probe(struct device *dev,
 	/* Optional DMA support: get valid DMA channel(s) or NULL */
 	for (i = STM32_TIMERS_DMA_CH1; i <= STM32_TIMERS_DMA_CH4; i++) {
 		snprintf(name, ARRAY_SIZE(name), "ch%1d", i + 1);
-		ddata->dma.chans[i] = dma_request_slave_channel(dev, name);
+		ddata->dma.chans[i] = dma_request_chan(dev, name);
 	}
-	ddata->dma.chans[STM32_TIMERS_DMA_UP] =
-		dma_request_slave_channel(dev, "up");
-	ddata->dma.chans[STM32_TIMERS_DMA_TRIG] =
-		dma_request_slave_channel(dev, "trig");
-	ddata->dma.chans[STM32_TIMERS_DMA_COM] =
-		dma_request_slave_channel(dev, "com");
+	ddata->dma.chans[STM32_TIMERS_DMA_UP] = dma_request_chan(dev, "up");
+	ddata->dma.chans[STM32_TIMERS_DMA_TRIG] = dma_request_chan(dev, "trig");
+	ddata->dma.chans[STM32_TIMERS_DMA_COM] = dma_request_chan(dev, "com");
+
+	for (i = STM32_TIMERS_DMA_CH1; i < STM32_TIMERS_MAX_DMAS; i++) {
+		if (IS_ERR(ddata->dma.chans[i])) {
+			if (PTR_ERR(ddata->dma.chans[i]) == -EPROBE_DEFER)
+				ret = -EPROBE_DEFER;
+
+			ddata->dma.chans[i] = NULL;
+		}
+	}
+
+	return ret;
 }
 
 static void stm32_timers_dma_remove(struct device *dev,
@@ -230,7 +239,11 @@  static int stm32_timers_probe(struct platform_device *pdev)
 
 	stm32_timers_get_arr_size(ddata);
 
-	stm32_timers_dma_probe(dev, ddata);
+	ret = stm32_timers_dma_probe(dev, ddata);
+	if (ret) {
+		stm32_timers_dma_remove(dev, ddata);
+		return ret;
+	}
 
 	platform_set_drvdata(pdev, ddata);