ASoC: renesas: rz-ssi: Use temporary variable for struct device

Use a temporary variable for the struct device pointers to avoid
dereferencing.

Reviewed-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Claudiu Beznea <claudiu.beznea.uj@bp.renesas.com>
Link: https://patch.msgid.link/20241210170953.2936724-12-claudiu.beznea.uj@bp.renesas.com
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/sound/soc/renesas/rz-ssi.c b/sound/soc/renesas/rz-ssi.c
index 03d409d3070c9b235e4f3748b5025d79cb824e20..74632e2482f893b1ef34b55ca8e933896bb5005d 100644 (file)
--- a/sound/soc/renesas/rz-ssi.c
+++ b/sound/soc/renesas/rz-ssi.c
@@ -1021,36 +1021,37 @@ static const struct snd_soc_component_driver rz_ssi_soc_component = {
 
 static int rz_ssi_probe(struct platform_device *pdev)
 {
+       struct device *dev = &pdev->dev;
        struct rz_ssi_priv *ssi;
        struct clk *audio_clk;
        struct resource *res;
        int ret;
 
-       ssi = devm_kzalloc(&pdev->dev, sizeof(*ssi), GFP_KERNEL);
+       ssi = devm_kzalloc(dev, sizeof(*ssi), GFP_KERNEL);
        if (!ssi)
                return -ENOMEM;
 
-       ssi->dev = &pdev->dev;
+       ssi->dev = dev;
        ssi->base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
        if (IS_ERR(ssi->base))
                return PTR_ERR(ssi->base);
 
        ssi->phys = res->start;
-       ssi->clk = devm_clk_get(&pdev->dev, "ssi");
+       ssi->clk = devm_clk_get(dev, "ssi");
        if (IS_ERR(ssi->clk))
                return PTR_ERR(ssi->clk);
 
-       ssi->sfr_clk = devm_clk_get(&pdev->dev, "ssi_sfr");
+       ssi->sfr_clk = devm_clk_get(dev, "ssi_sfr");
        if (IS_ERR(ssi->sfr_clk))
                return PTR_ERR(ssi->sfr_clk);
 
-       audio_clk = devm_clk_get(&pdev->dev, "audio_clk1");
+       audio_clk = devm_clk_get(dev, "audio_clk1");
        if (IS_ERR(audio_clk))
                return dev_err_probe(&pdev->dev, PTR_ERR(audio_clk),
                                     "no audio clk1");
 
        ssi->audio_clk_1 = clk_get_rate(audio_clk);
-       audio_clk = devm_clk_get(&pdev->dev, "audio_clk2");
+       audio_clk = devm_clk_get(dev, "audio_clk2");
        if (IS_ERR(audio_clk))
                return dev_err_probe(&pdev->dev, PTR_ERR(audio_clk),
                                     "no audio clk2");
@@ -1063,13 +1064,13 @@ static int rz_ssi_probe(struct platform_device *pdev)
        ssi->audio_mck = ssi->audio_clk_1 ? ssi->audio_clk_1 : ssi->audio_clk_2;
 
        /* Detect DMA support */
-       ret = rz_ssi_dma_request(ssi, &pdev->dev);
+       ret = rz_ssi_dma_request(ssi, dev);
        if (ret < 0) {
-               dev_warn(&pdev->dev, "DMA not available, using PIO\n");
+               dev_warn(dev, "DMA not available, using PIO\n");
                ssi->playback.transfer = rz_ssi_pio_send;
                ssi->capture.transfer = rz_ssi_pio_recv;
        } else {
-               dev_info(&pdev->dev, "DMA enabled");
+               dev_info(dev, "DMA enabled");
                ssi->playback.transfer = rz_ssi_dma_transfer;
                ssi->capture.transfer = rz_ssi_dma_transfer;
        }
@@ -1078,7 +1079,7 @@ static int rz_ssi_probe(struct platform_device *pdev)
        ssi->capture.priv = ssi;
 
        spin_lock_init(&ssi->lock);
-       dev_set_drvdata(&pdev->dev, ssi);
+       dev_set_drvdata(dev, ssi);
 
        /* Error Interrupt */
        ssi->irq_int = platform_get_irq_byname(pdev, "int_req");
@@ -1087,12 +1088,11 @@ static int rz_ssi_probe(struct platform_device *pdev)
                return ssi->irq_int;
        }
 
-       ret = devm_request_irq(&pdev->dev, ssi->irq_int, &rz_ssi_interrupt,
-                              0, dev_name(&pdev->dev), ssi);
+       ret = devm_request_irq(dev, ssi->irq_int, &rz_ssi_interrupt,
+                              0, dev_name(dev), ssi);
        if (ret < 0) {
                rz_ssi_release_dma_channels(ssi);
-               return dev_err_probe(&pdev->dev, ret,
-                                    "irq request error (int_req)\n");
+               return dev_err_probe(dev, ret, "irq request error (int_req)\n");
        }
 
        if (!rz_ssi_is_dma_enabled(ssi)) {
@@ -1104,11 +1104,11 @@ static int rz_ssi_probe(struct platform_device *pdev)
                        if (ssi->irq_rt < 0)
                                return ssi->irq_rt;
 
-                       ret = devm_request_irq(&pdev->dev, ssi->irq_rt,
+                       ret = devm_request_irq(dev, ssi->irq_rt,
                                               &rz_ssi_interrupt, 0,
-                                              dev_name(&pdev->dev), ssi);
+                                              dev_name(dev), ssi);
                        if (ret < 0)
-                               return dev_err_probe(&pdev->dev, ret,
+                               return dev_err_probe(dev, ret,
                                                     "irq request error (dma_rt)\n");
                } else {
                        if (ssi->irq_tx < 0)
@@ -1117,50 +1117,50 @@ static int rz_ssi_probe(struct platform_device *pdev)
                        if (ssi->irq_rx < 0)
                                return ssi->irq_rx;
 
-                       ret = devm_request_irq(&pdev->dev, ssi->irq_tx,
+                       ret = devm_request_irq(dev, ssi->irq_tx,
                                               &rz_ssi_interrupt, 0,
-                                              dev_name(&pdev->dev), ssi);
+                                              dev_name(dev), ssi);
                        if (ret < 0)
-                               return dev_err_probe(&pdev->dev, ret,
+                               return dev_err_probe(dev, ret,
                                                "irq request error (dma_tx)\n");
 
-                       ret = devm_request_irq(&pdev->dev, ssi->irq_rx,
+                       ret = devm_request_irq(dev, ssi->irq_rx,
                                               &rz_ssi_interrupt, 0,
-                                              dev_name(&pdev->dev), ssi);
+                                              dev_name(dev), ssi);
                        if (ret < 0)
-                               return dev_err_probe(&pdev->dev, ret,
+                               return dev_err_probe(dev, ret,
                                                "irq request error (dma_rx)\n");
                }
        }
 
-       ssi->rstc = devm_reset_control_get_exclusive(&pdev->dev, NULL);
+       ssi->rstc = devm_reset_control_get_exclusive(dev, NULL);
        if (IS_ERR(ssi->rstc)) {
                ret = PTR_ERR(ssi->rstc);
                goto err_reset;
        }
 
        reset_control_deassert(ssi->rstc);
-       pm_runtime_enable(&pdev->dev);
-       ret = pm_runtime_resume_and_get(&pdev->dev);
+       pm_runtime_enable(dev);
+       ret = pm_runtime_resume_and_get(dev);
        if (ret < 0) {
-               dev_err(&pdev->dev, "pm_runtime_resume_and_get failed\n");
+               dev_err(dev, "pm_runtime_resume_and_get failed\n");
                goto err_pm;
        }
 
-       ret = devm_snd_soc_register_component(&pdev->dev, &rz_ssi_soc_component,
+       ret = devm_snd_soc_register_component(dev, &rz_ssi_soc_component,
                                              rz_ssi_soc_dai,
                                              ARRAY_SIZE(rz_ssi_soc_dai));
        if (ret < 0) {
-               dev_err(&pdev->dev, "failed to register snd component\n");
+               dev_err(dev, "failed to register snd component\n");
                goto err_snd_soc;
        }
 
        return 0;
 
 err_snd_soc:
-       pm_runtime_put(ssi->dev);
+       pm_runtime_put(dev);
 err_pm:
-       pm_runtime_disable(ssi->dev);
+       pm_runtime_disable(dev);
        reset_control_assert(ssi->rstc);
 err_reset:
        rz_ssi_release_dma_channels(ssi);