Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
spi: fix controller deregistration (part 2/2)
Johan Hovold <johan@kernel.org> says:
Device managed registration generally only works if all involved
resources are managed as otherwise resources may be disabled or freed
while they are still in use.
This series fixes the SPI controller drivers that get this wrong by
disabling resources such as clocks, DMA and interrupts while the
controller (and its devices) are still registered, which can lead to
issues like system errors due to unclocked accesses, NULL-pointer
dereferences, hangs or just prevent SPI device drivers from doing I/O
during during deregistration (e.g. to power down devices).
I decided to split these fixes in two parts consisting of 20 and 26
patches respectively in order not to spam the lists too much.
I've also prepared a follow-on series to convert the drivers here that
do not yet use device managed controller allocation (which avoids taking
extra references during deregistration).
After that it should be possible to change the SPI API so that it no
longer drops a reference during deregistration without too much effort
(cf. [1]).
Note that this series is based on spi/for-next which specifically has
commit 1f8fd9490e31 ("spi: zynq-qspi: Simplify clock handling with
devm_clk_get_enabled()") (which is not in the for-7.1 branch).
Johan
[1] https://lore.kernel.org/lkml/20260325145319.1132072-1-johan@kernel.org/
+176
-42
+3
-1
drivers/spi/spi-mt65xx.c
+3
-1
drivers/spi/spi-mt65xx.c
···
1325
1325
1326
1326
pm_runtime_enable(dev);
1327
1327
1328
-
ret = devm_spi_register_controller(dev, host);
1328
+
ret = spi_register_controller(host);
1329
1329
if (ret) {
1330
1330
pm_runtime_disable(dev);
1331
1331
return dev_err_probe(dev, ret, "failed to register host\n");
···
1339
1339
struct spi_controller *host = platform_get_drvdata(pdev);
1340
1340
struct mtk_spi *mdata = spi_controller_get_devdata(host);
1341
1341
int ret;
1342
+
1343
+
spi_unregister_controller(host);
1342
1344
1343
1345
cpu_latency_qos_remove_request(&mdata->qos_request);
1344
1346
if (mdata->use_spimem && !completion_done(&mdata->spimem_done))
+3
-1
drivers/spi/spi-mtk-nor.c
+3
-1
drivers/spi/spi-mtk-nor.c
···
913
913
pm_runtime_enable(&pdev->dev);
914
914
pm_runtime_get_noresume(&pdev->dev);
915
915
916
-
ret = devm_spi_register_controller(&pdev->dev, ctlr);
916
+
ret = spi_register_controller(ctlr);
917
917
if (ret < 0)
918
918
goto err_probe;
919
919
···
937
937
{
938
938
struct spi_controller *ctlr = dev_get_drvdata(&pdev->dev);
939
939
struct mtk_nor *sp = spi_controller_get_devdata(ctlr);
940
+
941
+
spi_unregister_controller(ctlr);
940
942
941
943
pm_runtime_disable(&pdev->dev);
942
944
pm_runtime_set_suspended(&pdev->dev);
+7
-1
drivers/spi/spi-mxs.c
+7
-1
drivers/spi/spi-mxs.c
···
619
619
if (ret)
620
620
goto out_pm_runtime_put;
621
621
622
-
ret = devm_spi_register_controller(&pdev->dev, host);
622
+
ret = spi_register_controller(host);
623
623
if (ret) {
624
624
dev_err(&pdev->dev, "Cannot register SPI host, %d\n", ret);
625
625
goto out_pm_runtime_put;
···
650
650
spi = spi_controller_get_devdata(host);
651
651
ssp = &spi->ssp;
652
652
653
+
spi_controller_get(host);
654
+
655
+
spi_unregister_controller(host);
656
+
653
657
pm_runtime_disable(&pdev->dev);
654
658
if (!pm_runtime_status_suspended(&pdev->dev))
655
659
mxs_spi_runtime_suspend(&pdev->dev);
656
660
657
661
dma_release_channel(ssp->dmach);
662
+
663
+
spi_controller_put(host);
658
664
}
659
665
660
666
static struct platform_driver mxs_spi_driver = {
+7
-1
drivers/spi/spi-npcm-pspi.c
+7
-1
drivers/spi/spi-npcm-pspi.c
···
413
413
/* set to default clock rate */
414
414
npcm_pspi_set_baudrate(priv, NPCM_PSPI_DEFAULT_CLK);
415
415
416
-
ret = devm_spi_register_controller(&pdev->dev, host);
416
+
ret = spi_register_controller(host);
417
417
if (ret)
418
418
goto out_disable_clk;
419
419
···
434
434
struct spi_controller *host = platform_get_drvdata(pdev);
435
435
struct npcm_pspi *priv = spi_controller_get_devdata(host);
436
436
437
+
spi_controller_get(host);
438
+
439
+
spi_unregister_controller(host);
440
+
437
441
npcm_pspi_reset_hw(priv);
438
442
clk_disable_unprepare(priv->clk);
443
+
444
+
spi_controller_put(host);
439
445
}
440
446
441
447
static const struct of_device_id npcm_pspi_match[] = {
+7
-1
drivers/spi/spi-omap2-mcspi.c
+7
-1
drivers/spi/spi-omap2-mcspi.c
···
1592
1592
if (status < 0)
1593
1593
goto disable_pm;
1594
1594
1595
-
status = devm_spi_register_controller(&pdev->dev, ctlr);
1595
+
status = spi_register_controller(ctlr);
1596
1596
if (status < 0)
1597
1597
goto disable_pm;
1598
1598
···
1613
1613
struct spi_controller *ctlr = platform_get_drvdata(pdev);
1614
1614
struct omap2_mcspi *mcspi = spi_controller_get_devdata(ctlr);
1615
1615
1616
+
spi_controller_get(ctlr);
1617
+
1618
+
spi_unregister_controller(ctlr);
1619
+
1616
1620
omap2_mcspi_release_dma(ctlr);
1617
1621
1618
1622
pm_runtime_dont_use_autosuspend(mcspi->dev);
1619
1623
pm_runtime_put_sync(mcspi->dev);
1620
1624
pm_runtime_disable(&pdev->dev);
1625
+
1626
+
spi_controller_put(ctlr);
1621
1627
}
1622
1628
1623
1629
/* work with hotplug and coldplug */
+7
-1
drivers/spi/spi-pic32-sqi.c
+7
-1
drivers/spi/spi-pic32-sqi.c
···
642
642
host->prepare_transfer_hardware = pic32_sqi_prepare_hardware;
643
643
host->unprepare_transfer_hardware = pic32_sqi_unprepare_hardware;
644
644
645
-
ret = devm_spi_register_controller(&pdev->dev, host);
645
+
ret = spi_register_controller(host);
646
646
if (ret) {
647
647
dev_err(&host->dev, "failed registering spi host\n");
648
648
free_irq(sqi->irq, sqi);
···
665
665
{
666
666
struct pic32_sqi *sqi = platform_get_drvdata(pdev);
667
667
668
+
spi_controller_get(sqi->host);
669
+
670
+
spi_unregister_controller(sqi->host);
671
+
668
672
/* release resources */
669
673
free_irq(sqi->irq, sqi);
670
674
ring_desc_ring_free(sqi);
675
+
676
+
spi_controller_put(sqi->host);
671
677
}
672
678
673
679
static const struct of_device_id pic32_sqi_of_ids[] = {
+8
-3
drivers/spi/spi-pic32.c
+8
-3
drivers/spi/spi-pic32.c
···
821
821
}
822
822
823
823
/* register host */
824
-
ret = devm_spi_register_controller(&pdev->dev, host);
824
+
ret = spi_register_controller(host);
825
825
if (ret) {
826
826
dev_err(&host->dev, "failed registering spi host\n");
827
827
goto err_bailout;
···
840
840
841
841
static void pic32_spi_remove(struct platform_device *pdev)
842
842
{
843
-
struct pic32_spi *pic32s;
843
+
struct pic32_spi *pic32s = platform_get_drvdata(pdev);
844
844
845
-
pic32s = platform_get_drvdata(pdev);
845
+
spi_controller_get(pic32s->host);
846
+
847
+
spi_unregister_controller(pic32s->host);
848
+
846
849
pic32_spi_disable(pic32s);
847
850
pic32_spi_dma_unprep(pic32s);
851
+
852
+
spi_controller_put(pic32s->host);
848
853
}
849
854
850
855
static const struct of_device_id pic32_spi_of_match[] = {
+7
-1
drivers/spi/spi-pl022.c
+7
-1
drivers/spi/spi-pl022.c
···
1956
1956
1957
1957
/* Register with the SPI framework */
1958
1958
amba_set_drvdata(adev, pl022);
1959
-
status = devm_spi_register_controller(&adev->dev, host);
1959
+
status = spi_register_controller(host);
1960
1960
if (status != 0) {
1961
1961
dev_err_probe(&adev->dev, status,
1962
1962
"problem registering spi host\n");
···
1997
1997
if (!pl022)
1998
1998
return;
1999
1999
2000
+
spi_controller_get(pl022->host);
2001
+
2002
+
spi_unregister_controller(pl022->host);
2003
+
2000
2004
/*
2001
2005
* undo pm_runtime_put() in probe. I assume that we're not
2002
2006
* accessing the primecell here.
···
2012
2008
pl022_dma_remove(pl022);
2013
2009
2014
2010
amba_release_regions(adev);
2011
+
2012
+
spi_controller_put(pl022->host);
2015
2013
}
2016
2014
2017
2015
#ifdef CONFIG_PM_SLEEP
+7
-1
drivers/spi/spi-qup.c
+7
-1
drivers/spi/spi-qup.c
···
1193
1193
pm_runtime_set_active(dev);
1194
1194
pm_runtime_enable(dev);
1195
1195
1196
-
ret = devm_spi_register_controller(dev, host);
1196
+
ret = spi_register_controller(host);
1197
1197
if (ret)
1198
1198
goto disable_pm;
1199
1199
···
1320
1320
struct spi_qup *controller = spi_controller_get_devdata(host);
1321
1321
int ret;
1322
1322
1323
+
spi_controller_get(host);
1324
+
1325
+
spi_unregister_controller(host);
1326
+
1323
1327
ret = pm_runtime_get_sync(&pdev->dev);
1324
1328
1325
1329
if (ret >= 0) {
···
1343
1339
1344
1340
pm_runtime_put_noidle(&pdev->dev);
1345
1341
pm_runtime_disable(&pdev->dev);
1342
+
1343
+
spi_controller_put(host);
1346
1344
}
1347
1345
1348
1346
static const struct of_device_id spi_qup_dt_match[] = {
+8
-2
drivers/spi/spi-rspi.c
+8
-2
drivers/spi/spi-rspi.c
···
1171
1171
{
1172
1172
struct rspi_data *rspi = platform_get_drvdata(pdev);
1173
1173
1174
+
spi_controller_get(rspi->ctlr);
1175
+
1176
+
spi_unregister_controller(rspi->ctlr);
1177
+
1174
1178
rspi_release_dma(rspi->ctlr);
1175
1179
pm_runtime_disable(&pdev->dev);
1180
+
1181
+
spi_controller_put(rspi->ctlr);
1176
1182
}
1177
1183
1178
1184
static const struct spi_ops rspi_ops = {
···
1382
1376
if (ret < 0)
1383
1377
dev_warn(&pdev->dev, "DMA not available, using PIO\n");
1384
1378
1385
-
ret = devm_spi_register_controller(&pdev->dev, ctlr);
1379
+
ret = spi_register_controller(ctlr);
1386
1380
if (ret < 0) {
1387
-
dev_err(&pdev->dev, "devm_spi_register_controller error.\n");
1381
+
dev_err(&pdev->dev, "failed to register controller\n");
1388
1382
goto error3;
1389
1383
}
1390
1384
+3
-1
drivers/spi/spi-s3c64xx.c
+3
-1
drivers/spi/spi-s3c64xx.c
···
1369
1369
S3C64XX_SPI_INT_TX_OVERRUN_EN | S3C64XX_SPI_INT_TX_UNDERRUN_EN,
1370
1370
sdd->regs + S3C64XX_SPI_INT_EN);
1371
1371
1372
-
ret = devm_spi_register_controller(&pdev->dev, host);
1372
+
ret = spi_register_controller(host);
1373
1373
if (ret != 0) {
1374
1374
dev_err(&pdev->dev, "cannot register SPI host: %d\n", ret);
1375
1375
goto err_pm_put;
···
1398
1398
struct s3c64xx_spi_driver_data *sdd = spi_controller_get_devdata(host);
1399
1399
1400
1400
pm_runtime_get_sync(&pdev->dev);
1401
+
1402
+
spi_unregister_controller(host);
1401
1403
1402
1404
writel(0, sdd->regs + S3C64XX_SPI_INT_EN);
1403
1405
+8
-2
drivers/spi/spi-sh-hspi.c
+8
-2
drivers/spi/spi-sh-hspi.c
···
257
257
ctlr->transfer_one_message = hspi_transfer_one_message;
258
258
ctlr->bits_per_word_mask = SPI_BPW_MASK(8);
259
259
260
-
ret = devm_spi_register_controller(&pdev->dev, ctlr);
260
+
ret = spi_register_controller(ctlr);
261
261
if (ret < 0) {
262
-
dev_err(&pdev->dev, "devm_spi_register_controller error.\n");
262
+
dev_err(&pdev->dev, "failed to register controller\n");
263
263
goto error2;
264
264
}
265
265
···
279
279
{
280
280
struct hspi_priv *hspi = platform_get_drvdata(pdev);
281
281
282
+
spi_controller_get(hspi->ctlr);
283
+
284
+
spi_unregister_controller(hspi->ctlr);
285
+
282
286
pm_runtime_disable(&pdev->dev);
283
287
284
288
clk_put(hspi->clk);
289
+
290
+
spi_controller_put(hspi->ctlr);
285
291
}
286
292
287
293
static const struct of_device_id hspi_of_match[] = {
+8
-2
drivers/spi/spi-sh-msiof.c
+8
-2
drivers/spi/spi-sh-msiof.c
···
1289
1289
if (ret < 0)
1290
1290
dev_warn(dev, "DMA not available, using PIO\n");
1291
1291
1292
-
ret = devm_spi_register_controller(dev, ctlr);
1292
+
ret = spi_register_controller(ctlr);
1293
1293
if (ret < 0) {
1294
-
dev_err(dev, "devm_spi_register_controller error.\n");
1294
+
dev_err(dev, "failed to register controller\n");
1295
1295
goto err2;
1296
1296
}
1297
1297
···
1309
1309
{
1310
1310
struct sh_msiof_spi_priv *p = platform_get_drvdata(pdev);
1311
1311
1312
+
spi_controller_get(p->ctlr);
1313
+
1314
+
spi_unregister_controller(p->ctlr);
1315
+
1312
1316
sh_msiof_release_dma(p);
1313
1317
pm_runtime_disable(&pdev->dev);
1318
+
1319
+
spi_controller_put(p->ctlr);
1314
1320
}
1315
1321
1316
1322
static const struct platform_device_id spi_driver_ids[] = {
+7
-1
drivers/spi/spi-sifive.c
+7
-1
drivers/spi/spi-sifive.c
···
392
392
dev_info(&pdev->dev, "mapped; irq=%d, cs=%d\n",
393
393
irq, host->num_chipselect);
394
394
395
-
ret = devm_spi_register_controller(&pdev->dev, host);
395
+
ret = spi_register_controller(host);
396
396
if (ret < 0) {
397
397
dev_err(&pdev->dev, "spi_register_host failed\n");
398
398
goto put_host;
···
411
411
struct spi_controller *host = platform_get_drvdata(pdev);
412
412
struct sifive_spi *spi = spi_controller_get_devdata(host);
413
413
414
+
spi_controller_get(host);
415
+
416
+
spi_unregister_controller(host);
417
+
414
418
/* Disable all the interrupts just in case */
415
419
sifive_spi_write(spi, SIFIVE_SPI_REG_IE, 0);
420
+
421
+
spi_controller_put(host);
416
422
}
417
423
418
424
static int sifive_spi_suspend(struct device *dev)
+9
-1
drivers/spi/spi-slave-mt27xx.c
+9
-1
drivers/spi/spi-slave-mt27xx.c
···
453
453
454
454
pm_runtime_enable(&pdev->dev);
455
455
456
-
ret = devm_spi_register_controller(&pdev->dev, ctlr);
456
+
ret = spi_register_controller(ctlr);
457
457
clk_disable_unprepare(mdata->spi_clk);
458
458
if (ret) {
459
459
dev_err(&pdev->dev,
···
473
473
474
474
static void mtk_spi_slave_remove(struct platform_device *pdev)
475
475
{
476
+
struct spi_controller *ctlr = platform_get_drvdata(pdev);
477
+
478
+
spi_controller_get(ctlr);
479
+
480
+
spi_unregister_controller(ctlr);
481
+
476
482
pm_runtime_disable(&pdev->dev);
483
+
484
+
spi_controller_put(ctlr);
477
485
}
478
486
479
487
#ifdef CONFIG_PM_SLEEP
+6
-2
drivers/spi/spi-sprd.c
+6
-2
drivers/spi/spi-sprd.c
···
977
977
goto err_rpm_put;
978
978
}
979
979
980
-
ret = devm_spi_register_controller(&pdev->dev, sctlr);
980
+
ret = spi_register_controller(sctlr);
981
981
if (ret)
982
982
goto err_rpm_put;
983
983
···
1008
1008
if (ret < 0)
1009
1009
dev_err(ss->dev, "failed to resume SPI controller\n");
1010
1010
1011
-
spi_controller_suspend(sctlr);
1011
+
spi_controller_get(sctlr);
1012
+
1013
+
spi_unregister_controller(sctlr);
1012
1014
1013
1015
if (ret >= 0) {
1014
1016
if (ss->dma.enable)
···
1019
1017
}
1020
1018
pm_runtime_put_noidle(&pdev->dev);
1021
1019
pm_runtime_disable(&pdev->dev);
1020
+
1021
+
spi_controller_put(sctlr);
1022
1022
}
1023
1023
1024
1024
static int __maybe_unused sprd_spi_runtime_suspend(struct device *dev)
+7
-1
drivers/spi/spi-st-ssc4.c
+7
-1
drivers/spi/spi-st-ssc4.c
···
349
349
350
350
platform_set_drvdata(pdev, host);
351
351
352
-
ret = devm_spi_register_controller(&pdev->dev, host);
352
+
ret = spi_register_controller(host);
353
353
if (ret) {
354
354
dev_err(&pdev->dev, "Failed to register host\n");
355
355
goto rpm_disable;
···
371
371
struct spi_controller *host = platform_get_drvdata(pdev);
372
372
struct spi_st *spi_st = spi_controller_get_devdata(host);
373
373
374
+
spi_controller_get(host);
375
+
376
+
spi_unregister_controller(host);
377
+
374
378
pm_runtime_disable(&pdev->dev);
375
379
376
380
clk_disable_unprepare(spi_st->clk);
381
+
382
+
spi_controller_put(host);
377
383
378
384
pinctrl_pm_select_sleep_state(&pdev->dev);
379
385
}
+9
-1
drivers/spi/spi-sun4i.c
+9
-1
drivers/spi/spi-sun4i.c
···
504
504
pm_runtime_enable(&pdev->dev);
505
505
pm_runtime_idle(&pdev->dev);
506
506
507
-
ret = devm_spi_register_controller(&pdev->dev, host);
507
+
ret = spi_register_controller(host);
508
508
if (ret) {
509
509
dev_err(&pdev->dev, "cannot register SPI host\n");
510
510
goto err_pm_disable;
···
522
522
523
523
static void sun4i_spi_remove(struct platform_device *pdev)
524
524
{
525
+
struct spi_controller *host = platform_get_drvdata(pdev);
526
+
527
+
spi_controller_get(host);
528
+
529
+
spi_unregister_controller(host);
530
+
525
531
pm_runtime_force_suspend(&pdev->dev);
532
+
533
+
spi_controller_put(host);
526
534
}
527
535
528
536
static const struct of_device_id sun4i_spi_match[] = {
+7
-1
drivers/spi/spi-sun6i.c
+7
-1
drivers/spi/spi-sun6i.c
···
742
742
pm_runtime_set_active(&pdev->dev);
743
743
pm_runtime_enable(&pdev->dev);
744
744
745
-
ret = devm_spi_register_controller(&pdev->dev, host);
745
+
ret = spi_register_controller(host);
746
746
if (ret) {
747
747
dev_err(&pdev->dev, "cannot register SPI host\n");
748
748
goto err_pm_disable;
···
768
768
{
769
769
struct spi_controller *host = platform_get_drvdata(pdev);
770
770
771
+
spi_controller_get(host);
772
+
773
+
spi_unregister_controller(host);
774
+
771
775
pm_runtime_force_suspend(&pdev->dev);
772
776
773
777
if (host->dma_tx)
774
778
dma_release_channel(host->dma_tx);
775
779
if (host->dma_rx)
776
780
dma_release_channel(host->dma_rx);
781
+
782
+
spi_controller_put(host);
777
783
}
778
784
779
785
static const struct sun6i_spi_cfg sun6i_a31_spi_cfg = {
+7
-1
drivers/spi/spi-synquacer.c
+7
-1
drivers/spi/spi-synquacer.c
···
716
716
pm_runtime_set_active(sspi->dev);
717
717
pm_runtime_enable(sspi->dev);
718
718
719
-
ret = devm_spi_register_controller(sspi->dev, host);
719
+
ret = spi_register_controller(host);
720
720
if (ret)
721
721
goto disable_pm;
722
722
···
737
737
struct spi_controller *host = platform_get_drvdata(pdev);
738
738
struct synquacer_spi *sspi = spi_controller_get_devdata(host);
739
739
740
+
spi_controller_get(host);
741
+
742
+
spi_unregister_controller(host);
743
+
740
744
pm_runtime_disable(sspi->dev);
741
745
742
746
clk_disable_unprepare(sspi->clk);
747
+
748
+
spi_controller_put(host);
743
749
}
744
750
745
751
static int __maybe_unused synquacer_spi_suspend(struct device *dev)
+7
-1
drivers/spi/spi-tegra114.c
+7
-1
drivers/spi/spi-tegra114.c
···
1415
1415
goto exit_pm_disable;
1416
1416
}
1417
1417
1418
-
ret = devm_spi_register_controller(&pdev->dev, host);
1418
+
ret = spi_register_controller(host);
1419
1419
if (ret < 0) {
1420
1420
dev_err(&pdev->dev, "can not register to host err %d\n", ret);
1421
1421
goto exit_free_irq;
···
1441
1441
struct spi_controller *host = platform_get_drvdata(pdev);
1442
1442
struct tegra_spi_data *tspi = spi_controller_get_devdata(host);
1443
1443
1444
+
spi_controller_get(host);
1445
+
1446
+
spi_unregister_controller(host);
1447
+
1444
1448
free_irq(tspi->irq, tspi);
1445
1449
1446
1450
if (tspi->tx_dma_chan)
···
1456
1452
pm_runtime_disable(&pdev->dev);
1457
1453
if (!pm_runtime_status_suspended(&pdev->dev))
1458
1454
tegra_spi_runtime_suspend(&pdev->dev);
1455
+
1456
+
spi_controller_put(host);
1459
1457
}
1460
1458
1461
1459
#ifdef CONFIG_PM_SLEEP
+7
-1
drivers/spi/spi-tegra20-sflash.c
+7
-1
drivers/spi/spi-tegra20-sflash.c
···
505
505
tegra_sflash_writel(tsd, tsd->def_command_reg, SPI_COMMAND);
506
506
pm_runtime_put(&pdev->dev);
507
507
508
-
ret = devm_spi_register_controller(&pdev->dev, host);
508
+
ret = spi_register_controller(host);
509
509
if (ret < 0) {
510
510
dev_err(&pdev->dev, "can not register to host err %d\n", ret);
511
511
goto exit_pm_disable;
···
528
528
struct spi_controller *host = platform_get_drvdata(pdev);
529
529
struct tegra_sflash_data *tsd = spi_controller_get_devdata(host);
530
530
531
+
spi_controller_get(host);
532
+
533
+
spi_unregister_controller(host);
534
+
531
535
free_irq(tsd->irq, tsd);
532
536
533
537
pm_runtime_disable(&pdev->dev);
534
538
if (!pm_runtime_status_suspended(&pdev->dev))
535
539
tegra_sflash_runtime_suspend(&pdev->dev);
540
+
541
+
spi_controller_put(host);
536
542
}
537
543
538
544
#ifdef CONFIG_PM_SLEEP
+6
-8
drivers/spi/spi-ti-qspi.c
+6
-8
drivers/spi/spi-ti-qspi.c
···
888
888
qspi->mmap_enabled = false;
889
889
qspi->current_cs = -1;
890
890
891
-
ret = devm_spi_register_controller(&pdev->dev, host);
891
+
ret = spi_register_controller(host);
892
892
if (!ret)
893
893
return 0;
894
894
···
903
903
static void ti_qspi_remove(struct platform_device *pdev)
904
904
{
905
905
struct ti_qspi *qspi = platform_get_drvdata(pdev);
906
-
int rc;
907
906
908
-
rc = spi_controller_suspend(qspi->host);
909
-
if (rc) {
910
-
dev_alert(&pdev->dev, "spi_controller_suspend() failed (%pe)\n",
911
-
ERR_PTR(rc));
912
-
return;
913
-
}
907
+
spi_controller_get(qspi->host);
908
+
909
+
spi_unregister_controller(qspi->host);
914
910
915
911
pm_runtime_put_sync(&pdev->dev);
916
912
pm_runtime_disable(&pdev->dev);
917
913
918
914
ti_qspi_dma_cleanup(qspi);
915
+
916
+
spi_controller_put(qspi->host);
919
917
}
920
918
921
919
static const struct dev_pm_ops ti_qspi_pm_ops = {
+7
-1
drivers/spi/spi-uniphier.c
+7
-1
drivers/spi/spi-uniphier.c
···
746
746
747
747
host->max_dma_len = min(dma_tx_burst, dma_rx_burst);
748
748
749
-
ret = devm_spi_register_controller(&pdev->dev, host);
749
+
ret = spi_register_controller(host);
750
750
if (ret)
751
751
goto out_release_dma;
752
752
···
771
771
{
772
772
struct spi_controller *host = platform_get_drvdata(pdev);
773
773
774
+
spi_controller_get(host);
775
+
776
+
spi_unregister_controller(host);
777
+
774
778
if (host->dma_tx)
775
779
dma_release_channel(host->dma_tx);
776
780
if (host->dma_rx)
777
781
dma_release_channel(host->dma_rx);
782
+
783
+
spi_controller_put(host);
778
784
}
779
785
780
786
static const struct of_device_id uniphier_spi_match[] = {
+11
-4
drivers/spi/spi-zynq-qspi.c
+11
-4
drivers/spi/spi-zynq-qspi.c
···
643
643
644
644
xqspi = spi_controller_get_devdata(ctlr);
645
645
xqspi->dev = dev;
646
-
platform_set_drvdata(pdev, xqspi);
646
+
platform_set_drvdata(pdev, ctlr);
647
647
xqspi->regs = devm_platform_ioremap_resource(pdev, 0);
648
648
if (IS_ERR(xqspi->regs)) {
649
649
ret = PTR_ERR(xqspi->regs);
···
702
702
/* QSPI controller initializations */
703
703
zynq_qspi_init_hw(xqspi, ctlr->num_chipselect);
704
704
705
-
ret = devm_spi_register_controller(&pdev->dev, ctlr);
705
+
ret = spi_register_controller(ctlr);
706
706
if (ret) {
707
-
dev_err(&pdev->dev, "devm_spi_register_controller failed\n");
707
+
dev_err(&pdev->dev, "failed to register controller\n");
708
708
goto remove_ctlr;
709
709
}
710
710
···
728
728
*/
729
729
static void zynq_qspi_remove(struct platform_device *pdev)
730
730
{
731
-
struct zynq_qspi *xqspi = platform_get_drvdata(pdev);
731
+
struct spi_controller *ctlr = platform_get_drvdata(pdev);
732
+
struct zynq_qspi *xqspi = spi_controller_get_devdata(ctlr);
733
+
734
+
spi_controller_get(ctlr);
735
+
736
+
spi_unregister_controller(ctlr);
732
737
733
738
zynq_qspi_write(xqspi, ZYNQ_QSPI_ENABLE_OFFSET, 0);
739
+
740
+
spi_controller_put(ctlr);
734
741
}
735
742
736
743
static const struct of_device_id zynq_qspi_of_match[] = {
+3
-1
drivers/spi/spi-zynqmp-gqspi.c
+3
-1
drivers/spi/spi-zynqmp-gqspi.c
···
1324
1324
ctlr->dev.of_node = np;
1325
1325
ctlr->auto_runtime_pm = true;
1326
1326
1327
-
ret = devm_spi_register_controller(&pdev->dev, ctlr);
1327
+
ret = spi_register_controller(ctlr);
1328
1328
if (ret) {
1329
1329
dev_err(&pdev->dev, "spi_register_controller failed\n");
1330
1330
goto clk_dis_all;
···
1361
1361
struct zynqmp_qspi *xqspi = platform_get_drvdata(pdev);
1362
1362
1363
1363
pm_runtime_get_sync(&pdev->dev);
1364
+
1365
+
spi_unregister_controller(xqspi->ctlr);
1364
1366
1365
1367
zynqmp_gqspi_write(xqspi, GQSPI_EN_OFST, 0x0);
1366
1368