tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge tag 'dmaengine-fix-5.19' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/dmaengine

Pull dmaengine fixes from Vinod Koul:
"One core fix for DMA_INTERRUPT and rest driver fixes.

Core:

- Revert verification of DMA_INTERRUPT capability as that was
incorrect

Bunch of driver fixes for:

- ti: refcount and put_device leak

- qcom_bam: runtime pm overflow

- idxd: force wq context cleanup and call idxd_enable_system_pasid()
on success

- dw-axi-dmac: RMW on channel suspend register

- imx-sdma: restart cyclic channel when enabled

- at_xdma: error handling for at_xdmac_alloc_desc

- pl330: lockdep warning

- lgm: error handling path in probe

- allwinner: Fix min/max typo in binding"

* tag 'dmaengine-fix-5.19' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/dmaengine:
dt-bindings: dma: allwinner,sun50i-a64-dma: Fix min/max typo
dmaengine: lgm: Fix an error handling path in intel_ldma_probe()
dmaengine: pl330: Fix lockdep warning about non-static key
dmaengine: idxd: Only call idxd_enable_system_pasid() if succeeded in enabling SVA feature
dmaengine: at_xdma: handle errors of at_xdmac_alloc_desc() correctly
dmaengine: imx-sdma: only restart cyclic channel when enabled
dmaengine: dw-axi-dmac: Fix RMW on channel suspend register
dmaengine: idxd: force wq context cleanup on device disable path
dmaengine: qcom: bam_dma: fix runtime PM underflow
dmaengine: imx-sdma: Allow imx8m for imx7 FW revs
dmaengine: Revert "dmaengine: add verification of DMA_INTERRUPT capability for dmatest"
dmaengine: ti: Add missing put_device in ti_dra7_xbar_route_allocate
dmaengine: ti: Fix refcount leak in ti_dra7_xbar_route_allocate

Linus Torvalds 952c53cd 5867f3b8

+43 -56
+1 -1
Documentation/devicetree/bindings/dma/allwinner,sun50i-a64-dma.yaml
··· 67 67 then: 68 68 properties: 69 69 clocks: 70 - maxItems: 2 70 + minItems: 2 71 71 72 72 required: 73 73 - clock-names
+5
drivers/dma/at_xdmac.c
··· 1900 1900 for (i = 0; i < init_nr_desc_per_channel; i++) { 1901 1901 desc = at_xdmac_alloc_desc(chan, GFP_KERNEL); 1902 1902 if (!desc) { 1903 + if (i == 0) { 1904 + dev_warn(chan2dev(chan), 1905 + "can't allocate any descriptors\n"); 1906 + return -EIO; 1907 + } 1903 1908 dev_warn(chan2dev(chan), 1904 1909 "only %d descriptors have been allocated\n", i); 1905 1910 break;
+3 -10
drivers/dma/dmatest.c
··· 675 675 /* 676 676 * src and dst buffers are freed by ourselves below 677 677 */ 678 - if (params->polled) { 678 + if (params->polled) 679 679 flags = DMA_CTRL_ACK; 680 - } else { 681 - if (dma_has_cap(DMA_INTERRUPT, dev->cap_mask)) { 682 - flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT; 683 - } else { 684 - pr_err("Channel does not support interrupt!\n"); 685 - goto err_pq_array; 686 - } 687 - } 680 + else 681 + flags = DMA_CTRL_ACK | DMA_PREP_INTERRUPT; 688 682 689 683 ktime = ktime_get(); 690 684 while (!(kthread_should_stop() || ··· 906 912 runtime = ktime_to_us(ktime); 907 913 908 914 ret = 0; 909 - err_pq_array: 910 915 kfree(dma_pq); 911 916 err_srcs_array: 912 917 kfree(srcs);
+5 -3
drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c
··· 1164 1164 BIT(chan->id) << DMAC_CHAN_SUSP_WE_SHIFT; 1165 1165 axi_dma_iowrite32(chan->chip, DMAC_CHEN, val); 1166 1166 } else { 1167 - val = BIT(chan->id) << DMAC_CHAN_SUSP2_SHIFT | 1168 - BIT(chan->id) << DMAC_CHAN_SUSP2_WE_SHIFT; 1167 + val = axi_dma_ioread32(chan->chip, DMAC_CHSUSPREG); 1168 + val |= BIT(chan->id) << DMAC_CHAN_SUSP2_SHIFT | 1169 + BIT(chan->id) << DMAC_CHAN_SUSP2_WE_SHIFT; 1169 1170 axi_dma_iowrite32(chan->chip, DMAC_CHSUSPREG, val); 1170 1171 } 1171 1172 ··· 1191 1190 { 1192 1191 u32 val; 1193 1192 1194 - val = axi_dma_ioread32(chan->chip, DMAC_CHEN); 1195 1193 if (chan->chip->dw->hdata->reg_map_8_channels) { 1194 + val = axi_dma_ioread32(chan->chip, DMAC_CHEN); 1196 1195 val &= ~(BIT(chan->id) << DMAC_CHAN_SUSP_SHIFT); 1197 1196 val |= (BIT(chan->id) << DMAC_CHAN_SUSP_WE_SHIFT); 1198 1197 axi_dma_iowrite32(chan->chip, DMAC_CHEN, val); 1199 1198 } else { 1199 + val = axi_dma_ioread32(chan->chip, DMAC_CHSUSPREG); 1200 1200 val &= ~(BIT(chan->id) << DMAC_CHAN_SUSP2_SHIFT); 1201 1201 val |= (BIT(chan->id) << DMAC_CHAN_SUSP2_WE_SHIFT); 1202 1202 axi_dma_iowrite32(chan->chip, DMAC_CHSUSPREG, val);
+1 -4
drivers/dma/idxd/device.c
··· 716 716 struct idxd_wq *wq = idxd->wqs[i]; 717 717 718 718 mutex_lock(&wq->wq_lock); 719 - if (wq->state == IDXD_WQ_ENABLED) { 720 - idxd_wq_disable_cleanup(wq); 721 - wq->state = IDXD_WQ_DISABLED; 722 - } 719 + idxd_wq_disable_cleanup(wq); 723 720 idxd_wq_device_reset_cleanup(wq); 724 721 mutex_unlock(&wq->wq_lock); 725 722 }
+7 -6
drivers/dma/idxd/init.c
··· 512 512 dev_dbg(dev, "IDXD reset complete\n"); 513 513 514 514 if (IS_ENABLED(CONFIG_INTEL_IDXD_SVM) && sva) { 515 - if (iommu_dev_enable_feature(dev, IOMMU_DEV_FEAT_SVA)) 515 + if (iommu_dev_enable_feature(dev, IOMMU_DEV_FEAT_SVA)) { 516 516 dev_warn(dev, "Unable to turn on user SVA feature.\n"); 517 - else 517 + } else { 518 518 set_bit(IDXD_FLAG_USER_PASID_ENABLED, &idxd->flags); 519 519 520 - if (idxd_enable_system_pasid(idxd)) 521 - dev_warn(dev, "No in-kernel DMA with PASID.\n"); 522 - else 523 - set_bit(IDXD_FLAG_PASID_ENABLED, &idxd->flags); 520 + if (idxd_enable_system_pasid(idxd)) 521 + dev_warn(dev, "No in-kernel DMA with PASID.\n"); 522 + else 523 + set_bit(IDXD_FLAG_PASID_ENABLED, &idxd->flags); 524 + } 524 525 } else if (!sva) { 525 526 dev_warn(dev, "User forced SVA off via module param.\n"); 526 527 }
+2 -2
drivers/dma/imx-sdma.c
··· 891 891 * SDMA stops cyclic channel when DMA request triggers a channel and no SDMA 892 892 * owned buffer is available (i.e. BD_DONE was set too late). 893 893 */ 894 - if (!is_sdma_channel_enabled(sdmac->sdma, sdmac->channel)) { 894 + if (sdmac->desc && !is_sdma_channel_enabled(sdmac->sdma, sdmac->channel)) { 895 895 dev_warn(sdmac->sdma->dev, "restart cyclic channel %d\n", sdmac->channel); 896 896 sdma_enable_channel(sdmac->sdma, sdmac->channel); 897 897 } ··· 2346 2346 #if IS_ENABLED(CONFIG_SOC_IMX6Q) 2347 2347 MODULE_FIRMWARE("imx/sdma/sdma-imx6q.bin"); 2348 2348 #endif 2349 - #if IS_ENABLED(CONFIG_SOC_IMX7D) 2349 + #if IS_ENABLED(CONFIG_SOC_IMX7D) || IS_ENABLED(CONFIG_SOC_IMX8M) 2350 2350 MODULE_FIRMWARE("imx/sdma/sdma-imx7d.bin"); 2351 2351 #endif 2352 2352 MODULE_LICENSE("GPL");
+2 -1
drivers/dma/lgm/lgm-dma.c
··· 1593 1593 d->core_clk = devm_clk_get_optional(dev, NULL); 1594 1594 if (IS_ERR(d->core_clk)) 1595 1595 return PTR_ERR(d->core_clk); 1596 - clk_prepare_enable(d->core_clk); 1597 1596 1598 1597 d->rst = devm_reset_control_get_optional(dev, NULL); 1599 1598 if (IS_ERR(d->rst)) 1600 1599 return PTR_ERR(d->rst); 1600 + 1601 + clk_prepare_enable(d->core_clk); 1601 1602 reset_control_deassert(d->rst); 1602 1603 1603 1604 ret = devm_add_action_or_reset(dev, ldma_clk_disable, d);
+1 -1
drivers/dma/pl330.c
··· 2589 2589 2590 2590 /* If the DMAC pool is empty, alloc new */ 2591 2591 if (!desc) { 2592 - DEFINE_SPINLOCK(lock); 2592 + static DEFINE_SPINLOCK(lock); 2593 2593 LIST_HEAD(pool); 2594 2594 2595 2595 if (!add_desc(&pool, &lock, GFP_ATOMIC, 1))
+11 -28
drivers/dma/qcom/bam_dma.c
··· 558 558 return 0; 559 559 } 560 560 561 - static int bam_pm_runtime_get_sync(struct device *dev) 562 - { 563 - if (pm_runtime_enabled(dev)) 564 - return pm_runtime_get_sync(dev); 565 - 566 - return 0; 567 - } 568 - 569 561 /** 570 562 * bam_free_chan - Frees dma resources associated with specific channel 571 563 * @chan: specified channel ··· 573 581 unsigned long flags; 574 582 int ret; 575 583 576 - ret = bam_pm_runtime_get_sync(bdev->dev); 584 + ret = pm_runtime_get_sync(bdev->dev); 577 585 if (ret < 0) 578 586 return; 579 587 ··· 776 784 unsigned long flag; 777 785 int ret; 778 786 779 - ret = bam_pm_runtime_get_sync(bdev->dev); 787 + ret = pm_runtime_get_sync(bdev->dev); 780 788 if (ret < 0) 781 789 return ret; 782 790 ··· 802 810 unsigned long flag; 803 811 int ret; 804 812 805 - ret = bam_pm_runtime_get_sync(bdev->dev); 813 + ret = pm_runtime_get_sync(bdev->dev); 806 814 if (ret < 0) 807 815 return ret; 808 816 ··· 911 919 if (srcs & P_IRQ) 912 920 tasklet_schedule(&bdev->task); 913 921 914 - ret = bam_pm_runtime_get_sync(bdev->dev); 922 + ret = pm_runtime_get_sync(bdev->dev); 915 923 if (ret < 0) 916 924 return IRQ_NONE; 917 925 ··· 1029 1037 if (!vd) 1030 1038 return; 1031 1039 1032 - ret = bam_pm_runtime_get_sync(bdev->dev); 1040 + ret = pm_runtime_get_sync(bdev->dev); 1033 1041 if (ret < 0) 1034 1042 return; 1035 1043 ··· 1366 1374 if (ret) 1367 1375 goto err_unregister_dma; 1368 1376 1369 - if (!bdev->bamclk) { 1370 - pm_runtime_disable(&pdev->dev); 1371 - return 0; 1372 - } 1373 - 1374 1377 pm_runtime_irq_safe(&pdev->dev); 1375 1378 pm_runtime_set_autosuspend_delay(&pdev->dev, BAM_DMA_AUTOSUSPEND_DELAY); 1376 1379 pm_runtime_use_autosuspend(&pdev->dev); ··· 1449 1462 { 1450 1463 struct bam_device *bdev = dev_get_drvdata(dev); 1451 1464 1452 - if (bdev->bamclk) { 1453 - pm_runtime_force_suspend(dev); 1454 - clk_unprepare(bdev->bamclk); 1455 - } 1465 + pm_runtime_force_suspend(dev); 1466 + clk_unprepare(bdev->bamclk); 1456 1467 1457 1468 return 0; 1458 1469 } ··· 1460 1475 struct bam_device *bdev = dev_get_drvdata(dev); 1461 1476 int ret; 1462 1477 1463 - if (bdev->bamclk) { 1464 - ret = clk_prepare(bdev->bamclk); 1465 - if (ret) 1466 - return ret; 1478 + ret = clk_prepare(bdev->bamclk); 1479 + if (ret) 1480 + return ret; 1467 1481 1468 - pm_runtime_force_resume(dev); 1469 - } 1482 + pm_runtime_force_resume(dev); 1470 1483 1471 1484 return 0; 1472 1485 }
+5
drivers/dma/ti/dma-crossbar.c
··· 245 245 if (dma_spec->args[0] >= xbar->xbar_requests) { 246 246 dev_err(&pdev->dev, "Invalid XBAR request number: %d\n", 247 247 dma_spec->args[0]); 248 + put_device(&pdev->dev); 248 249 return ERR_PTR(-EINVAL); 249 250 } 250 251 ··· 253 252 dma_spec->np = of_parse_phandle(ofdma->of_node, "dma-masters", 0); 254 253 if (!dma_spec->np) { 255 254 dev_err(&pdev->dev, "Can't get DMA master\n"); 255 + put_device(&pdev->dev); 256 256 return ERR_PTR(-EINVAL); 257 257 } 258 258 259 259 map = kzalloc(sizeof(*map), GFP_KERNEL); 260 260 if (!map) { 261 261 of_node_put(dma_spec->np); 262 + put_device(&pdev->dev); 262 263 return ERR_PTR(-ENOMEM); 263 264 } 264 265 ··· 271 268 mutex_unlock(&xbar->mutex); 272 269 dev_err(&pdev->dev, "Run out of free DMA requests\n"); 273 270 kfree(map); 271 + of_node_put(dma_spec->np); 272 + put_device(&pdev->dev); 274 273 return ERR_PTR(-ENOMEM); 275 274 } 276 275 set_bit(map->xbar_out, xbar->dma_inuse);