Skip to content

Commit fd811b6

Browse files
brooniebroonie
committed
spi: Use devm_clk_get_*() helper function to
Merge series from Li Zetao <[email protected]>: Commit 7ef9651 ("clk: Provide new devm_clk helpers for prepared and enabled clocks") provides a new helper function for prepared and enabled clocks when a driver keeps a clock prepared (or enabled) during the whole lifetime of the driver. So where drivers get clocks and enable them immediately, it can be combined into a single function devm_clk_get_*(). Moreover, the unprepare and disable function has been registered to devm_clk_state, and before devm_clk_state is released, the clocks will be unprepareed and disable, so it is unnecessary to unprepare and disable clocks explicitly when remove drivers or in the error handling path.
2 parents fffae3a + d6c612a commit fd811b6

25 files changed

+88
-413
lines changed

‎drivers/spi/spi-ar934x.c

Lines changed: 3 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -168,27 +168,21 @@ static int ar934x_spi_probe(struct platform_device *pdev)
168168
struct ar934x_spi *sp;
169169
void __iomem *base;
170170
struct clk *clk;
171-
int ret;
172171

173172
base = devm_platform_ioremap_resource(pdev, 0);
174173
if (IS_ERR(base))
175174
return PTR_ERR(base);
176175

177-
clk = devm_clk_get(&pdev->dev, NULL);
176+
clk = devm_clk_get_enabled(&pdev->dev, NULL);
178177
if (IS_ERR(clk)) {
179178
dev_err(&pdev->dev, "failed to get clock\n");
180179
return PTR_ERR(clk);
181180
}
182181

183-
ret = clk_prepare_enable(clk);
184-
if (ret)
185-
return ret;
186-
187182
ctlr = devm_spi_alloc_host(&pdev->dev, sizeof(*sp));
188183
if (!ctlr) {
189184
dev_info(&pdev->dev, "failed to allocate spi controller\n");
190-
ret = -ENOMEM;
191-
goto err_clk_disable;
185+
return -ENOMEM;
192186
}
193187

194188
/* disable flash mapping and expose spi controller registers */
@@ -212,25 +206,15 @@ static int ar934x_spi_probe(struct platform_device *pdev)
212206
sp->clk_freq = clk_get_rate(clk);
213207
sp->ctlr = ctlr;
214208

215-
ret = spi_register_controller(ctlr);
216-
if (!ret)
217-
return 0;
218-
219-
err_clk_disable:
220-
clk_disable_unprepare(clk);
221-
return ret;
209+
return spi_register_controller(ctlr);
222210
}
223211

224212
static void ar934x_spi_remove(struct platform_device *pdev)
225213
{
226214
struct spi_controller *ctlr;
227-
struct ar934x_spi *sp;
228215

229216
ctlr = dev_get_drvdata(&pdev->dev);
230-
sp = spi_controller_get_devdata(ctlr);
231-
232217
spi_unregister_controller(ctlr);
233-
clk_disable_unprepare(sp->clk);
234218
}
235219

236220
static struct platform_driver ar934x_spi_driver = {

‎drivers/spi/spi-armada-3700.c

Lines changed: 3 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -865,18 +865,12 @@ static int a3700_spi_probe(struct platform_device *pdev)
865865

866866
init_completion(&spi->done);
867867

868-
spi->clk = devm_clk_get(dev, NULL);
868+
spi->clk = devm_clk_get_prepared(dev, NULL);
869869
if (IS_ERR(spi->clk)) {
870870
dev_err(dev, "could not find clk: %ld\n", PTR_ERR(spi->clk));
871871
goto error;
872872
}
873873

874-
ret = clk_prepare(spi->clk);
875-
if (ret) {
876-
dev_err(dev, "could not prepare clk: %d\n", ret);
877-
goto error;
878-
}
879-
880874
host->max_speed_hz = min_t(unsigned long, A3700_SPI_MAX_SPEED_HZ,
881875
clk_get_rate(spi->clk));
882876
host->min_speed_hz = DIV_ROUND_UP(clk_get_rate(spi->clk),
@@ -888,40 +882,29 @@ static int a3700_spi_probe(struct platform_device *pdev)
888882
dev_name(dev), host);
889883
if (ret) {
890884
dev_err(dev, "could not request IRQ: %d\n", ret);
891-
goto error_clk;
885+
goto error;
892886
}
893887

894888
ret = devm_spi_register_controller(dev, host);
895889
if (ret) {
896890
dev_err(dev, "Failed to register host\n");
897-
goto error_clk;
891+
goto error;
898892
}
899893

900894
return 0;
901895

902-
error_clk:
903-
clk_unprepare(spi->clk);
904896
error:
905897
spi_controller_put(host);
906898
out:
907899
return ret;
908900
}
909901

910-
static void a3700_spi_remove(struct platform_device *pdev)
911-
{
912-
struct spi_controller *host = platform_get_drvdata(pdev);
913-
struct a3700_spi *spi = spi_controller_get_devdata(host);
914-
915-
clk_unprepare(spi->clk);
916-
}
917-
918902
static struct platform_driver a3700_spi_driver = {
919903
.driver = {
920904
.name = DRIVER_NAME,
921905
.of_match_table = of_match_ptr(a3700_spi_dt_ids),
922906
},
923907
.probe = a3700_spi_probe,
924-
.remove_new = a3700_spi_remove,
925908
};
926909

927910
module_platform_driver(a3700_spi_driver);

‎drivers/spi/spi-aspeed-smc.c

Lines changed: 2 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -748,7 +748,7 @@ static int aspeed_spi_probe(struct platform_device *pdev)
748748
aspi->ahb_window_size = resource_size(res);
749749
aspi->ahb_base_phy = res->start;
750750

751-
aspi->clk = devm_clk_get(&pdev->dev, NULL);
751+
aspi->clk = devm_clk_get_enabled(&pdev->dev, NULL);
752752
if (IS_ERR(aspi->clk)) {
753753
dev_err(dev, "missing clock\n");
754754
return PTR_ERR(aspi->clk);
@@ -760,12 +760,6 @@ static int aspeed_spi_probe(struct platform_device *pdev)
760760
return -EINVAL;
761761
}
762762

763-
ret = clk_prepare_enable(aspi->clk);
764-
if (ret) {
765-
dev_err(dev, "can not enable the clock\n");
766-
return ret;
767-
}
768-
769763
/* IRQ is for DMA, which the driver doesn't support yet */
770764

771765
ctlr->mode_bits = SPI_RX_DUAL | SPI_TX_DUAL | data->mode_bits;
@@ -777,14 +771,9 @@ static int aspeed_spi_probe(struct platform_device *pdev)
777771
ctlr->dev.of_node = dev->of_node;
778772

779773
ret = devm_spi_register_controller(dev, ctlr);
780-
if (ret) {
774+
if (ret)
781775
dev_err(&pdev->dev, "spi_register_controller failed\n");
782-
goto disable_clk;
783-
}
784-
return 0;
785776

786-
disable_clk:
787-
clk_disable_unprepare(aspi->clk);
788777
return ret;
789778
}
790779

@@ -793,7 +782,6 @@ static void aspeed_spi_remove(struct platform_device *pdev)
793782
struct aspeed_spi *aspi = platform_get_drvdata(pdev);
794783

795784
aspeed_spi_enable(aspi, false);
796-
clk_disable_unprepare(aspi->clk);
797785
}
798786

799787
/*

‎drivers/spi/spi-ath79.c

Lines changed: 2 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -200,20 +200,16 @@ static int ath79_spi_probe(struct platform_device *pdev)
200200
goto err_put_host;
201201
}
202202

203-
sp->clk = devm_clk_get(&pdev->dev, "ahb");
203+
sp->clk = devm_clk_get_enabled(&pdev->dev, "ahb");
204204
if (IS_ERR(sp->clk)) {
205205
ret = PTR_ERR(sp->clk);
206206
goto err_put_host;
207207
}
208208

209-
ret = clk_prepare_enable(sp->clk);
210-
if (ret)
211-
goto err_put_host;
212-
213209
rate = DIV_ROUND_UP(clk_get_rate(sp->clk), MHZ);
214210
if (!rate) {
215211
ret = -EINVAL;
216-
goto err_clk_disable;
212+
goto err_put_host;
217213
}
218214

219215
sp->rrw_delay = ATH79_SPI_RRW_DELAY_FACTOR / rate;
@@ -229,8 +225,6 @@ static int ath79_spi_probe(struct platform_device *pdev)
229225

230226
err_disable:
231227
ath79_spi_disable(sp);
232-
err_clk_disable:
233-
clk_disable_unprepare(sp->clk);
234228
err_put_host:
235229
spi_controller_put(host);
236230

@@ -243,7 +237,6 @@ static void ath79_spi_remove(struct platform_device *pdev)
243237

244238
spi_bitbang_stop(&sp->bitbang);
245239
ath79_spi_disable(sp);
246-
clk_disable_unprepare(sp->clk);
247240
spi_controller_put(sp->bitbang.master);
248241
}
249242

‎drivers/spi/spi-axi-spi-engine.c

Lines changed: 5 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -485,30 +485,22 @@ static int spi_engine_probe(struct platform_device *pdev)
485485

486486
spin_lock_init(&spi_engine->lock);
487487

488-
spi_engine->clk = devm_clk_get(&pdev->dev, "s_axi_aclk");
488+
spi_engine->clk = devm_clk_get_enabled(&pdev->dev, "s_axi_aclk");
489489
if (IS_ERR(spi_engine->clk)) {
490490
ret = PTR_ERR(spi_engine->clk);
491491
goto err_put_host;
492492
}
493493

494-
spi_engine->ref_clk = devm_clk_get(&pdev->dev, "spi_clk");
494+
spi_engine->ref_clk = devm_clk_get_enabled(&pdev->dev, "spi_clk");
495495
if (IS_ERR(spi_engine->ref_clk)) {
496496
ret = PTR_ERR(spi_engine->ref_clk);
497497
goto err_put_host;
498498
}
499499

500-
ret = clk_prepare_enable(spi_engine->clk);
501-
if (ret)
502-
goto err_put_host;
503-
504-
ret = clk_prepare_enable(spi_engine->ref_clk);
505-
if (ret)
506-
goto err_clk_disable;
507-
508500
spi_engine->base = devm_platform_ioremap_resource(pdev, 0);
509501
if (IS_ERR(spi_engine->base)) {
510502
ret = PTR_ERR(spi_engine->base);
511-
goto err_ref_clk_disable;
503+
goto err_put_host;
512504
}
513505

514506
version = readl(spi_engine->base + SPI_ENGINE_REG_VERSION);
@@ -518,7 +510,7 @@ static int spi_engine_probe(struct platform_device *pdev)
518510
SPI_ENGINE_VERSION_MINOR(version),
519511
SPI_ENGINE_VERSION_PATCH(version));
520512
ret = -ENODEV;
521-
goto err_ref_clk_disable;
513+
goto err_put_host;
522514
}
523515

524516
writel_relaxed(0x00, spi_engine->base + SPI_ENGINE_REG_RESET);
@@ -527,7 +519,7 @@ static int spi_engine_probe(struct platform_device *pdev)
527519

528520
ret = request_irq(irq, spi_engine_irq, 0, pdev->name, host);
529521
if (ret)
530-
goto err_ref_clk_disable;
522+
goto err_put_host;
531523

532524
host->dev.of_node = pdev->dev.of_node;
533525
host->mode_bits = SPI_CPOL | SPI_CPHA | SPI_3WIRE;
@@ -545,10 +537,6 @@ static int spi_engine_probe(struct platform_device *pdev)
545537
return 0;
546538
err_free_irq:
547539
free_irq(irq, host);
548-
err_ref_clk_disable:
549-
clk_disable_unprepare(spi_engine->ref_clk);
550-
err_clk_disable:
551-
clk_disable_unprepare(spi_engine->clk);
552540
err_put_host:
553541
spi_controller_put(host);
554542
return ret;
@@ -569,9 +557,6 @@ static void spi_engine_remove(struct platform_device *pdev)
569557
writel_relaxed(0xff, spi_engine->base + SPI_ENGINE_REG_INT_PENDING);
570558
writel_relaxed(0x00, spi_engine->base + SPI_ENGINE_REG_INT_ENABLE);
571559
writel_relaxed(0x01, spi_engine->base + SPI_ENGINE_REG_RESET);
572-
573-
clk_disable_unprepare(spi_engine->ref_clk);
574-
clk_disable_unprepare(spi_engine->clk);
575560
}
576561

577562
static const struct of_device_id spi_engine_match_table[] = {

‎drivers/spi/spi-bcm2835.c

Lines changed: 2 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1352,7 +1352,7 @@ static int bcm2835_spi_probe(struct platform_device *pdev)
13521352
if (IS_ERR(bs->regs))
13531353
return PTR_ERR(bs->regs);
13541354

1355-
bs->clk = devm_clk_get(&pdev->dev, NULL);
1355+
bs->clk = devm_clk_get_enabled(&pdev->dev, NULL);
13561356
if (IS_ERR(bs->clk))
13571357
return dev_err_probe(&pdev->dev, PTR_ERR(bs->clk),
13581358
"could not get clk\n");
@@ -1363,14 +1363,11 @@ static int bcm2835_spi_probe(struct platform_device *pdev)
13631363
if (bs->irq < 0)
13641364
return bs->irq;
13651365

1366-
err = clk_prepare_enable(bs->clk);
1367-
if (err)
1368-
return err;
13691366
bs->clk_hz = clk_get_rate(bs->clk);
13701367

13711368
err = bcm2835_dma_init(ctlr, &pdev->dev, bs);
13721369
if (err)
1373-
goto out_clk_disable;
1370+
return err;
13741371

13751372
/* initialise the hardware with the default polarities */
13761373
bcm2835_wr(bs, BCM2835_SPI_CS,
@@ -1396,8 +1393,6 @@ static int bcm2835_spi_probe(struct platform_device *pdev)
13961393

13971394
out_dma_release:
13981395
bcm2835_dma_release(ctlr, bs);
1399-
out_clk_disable:
1400-
clk_disable_unprepare(bs->clk);
14011396
return err;
14021397
}
14031398

@@ -1415,8 +1410,6 @@ static void bcm2835_spi_remove(struct platform_device *pdev)
14151410
/* Clear FIFOs, and disable the HW block */
14161411
bcm2835_wr(bs, BCM2835_SPI_CS,
14171412
BCM2835_SPI_CS_CLEAR_RX | BCM2835_SPI_CS_CLEAR_TX);
1418-
1419-
clk_disable_unprepare(bs->clk);
14201413
}
14211414

14221415
static const struct of_device_id bcm2835_spi_match[] = {

‎drivers/spi/spi-bcm2835aux.c

Lines changed: 4 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -512,7 +512,7 @@ static int bcm2835aux_spi_probe(struct platform_device *pdev)
512512
if (IS_ERR(bs->regs))
513513
return PTR_ERR(bs->regs);
514514

515-
bs->clk = devm_clk_get(&pdev->dev, NULL);
515+
bs->clk = devm_clk_get_enabled(&pdev->dev, NULL);
516516
if (IS_ERR(bs->clk)) {
517517
err = PTR_ERR(bs->clk);
518518
dev_err(&pdev->dev, "could not get clk: %d\n", err);
@@ -523,19 +523,11 @@ static int bcm2835aux_spi_probe(struct platform_device *pdev)
523523
if (bs->irq < 0)
524524
return bs->irq;
525525

526-
/* this also enables the HW block */
527-
err = clk_prepare_enable(bs->clk);
528-
if (err) {
529-
dev_err(&pdev->dev, "could not prepare clock: %d\n", err);
530-
return err;
531-
}
532-
533526
/* just checking if the clock returns a sane value */
534527
clk_hz = clk_get_rate(bs->clk);
535528
if (!clk_hz) {
536529
dev_err(&pdev->dev, "clock returns 0 Hz\n");
537-
err = -ENODEV;
538-
goto out_clk_disable;
530+
return -ENODEV;
539531
}
540532

541533
/* reset SPI-HW block */
@@ -547,22 +539,18 @@ static int bcm2835aux_spi_probe(struct platform_device *pdev)
547539
dev_name(&pdev->dev), host);
548540
if (err) {
549541
dev_err(&pdev->dev, "could not request IRQ: %d\n", err);
550-
goto out_clk_disable;
542+
return err;
551543
}
552544

553545
err = spi_register_controller(host);
554546
if (err) {
555547
dev_err(&pdev->dev, "could not register SPI host: %d\n", err);
556-
goto out_clk_disable;
548+
return err;
557549
}
558550

559551
bcm2835aux_debugfs_create(bs, dev_name(&pdev->dev));
560552

561553
return 0;
562-
563-
out_clk_disable:
564-
clk_disable_unprepare(bs->clk);
565-
return err;
566554
}
567555

568556
static void bcm2835aux_spi_remove(struct platform_device *pdev)
@@ -575,9 +563,6 @@ static void bcm2835aux_spi_remove(struct platform_device *pdev)
575563
spi_unregister_controller(host);
576564

577565
bcm2835aux_spi_reset_hw(bs);
578-
579-
/* disable the HW block by releasing the clock */
580-
clk_disable_unprepare(bs->clk);
581566
}
582567

583568
static const struct of_device_id bcm2835aux_spi_match[] = {

0 commit comments

Comments
 (0)