dma/qcom/bam_dma.c

350 	struct bam_device *bdev;
405  * @bdev: bam device
409 static inline void __iomem *bam_addr(struct bam_device *bdev, u32 pipe,
412 	const struct reg_offset_data r = bdev->layout[reg];
414 	return bdev->regs + r.base_offset +
417 		r.ee_mult * bdev->ee;
422  * @bdev: bam device
424 static void bam_reset(struct bam_device *bdev)
430 	val = readl_relaxed(bam_addr(bdev, 0, BAM_CTRL));
432 	writel_relaxed(val, bam_addr(bdev, 0, BAM_CTRL));
434 	writel_relaxed(val, bam_addr(bdev, 0, BAM_CTRL));
441 	writel_relaxed(val, bam_addr(bdev, 0, BAM_CTRL));
445 			bam_addr(bdev, 0, BAM_DESC_CNT_TRSHLD));
448 	writel_relaxed(BAM_CNFG_BITS_DEFAULT, bam_addr(bdev, 0, BAM_CNFG_BITS));
452 			bam_addr(bdev, 0, BAM_IRQ_EN));
455 	writel_relaxed(BAM_IRQ_MSK, bam_addr(bdev, 0, BAM_IRQ_SRCS_MSK_EE));
466 	struct bam_device *bdev = bchan->bdev;
471 	writel_relaxed(1, bam_addr(bdev, bchan->id, BAM_P_RST));
472 	writel_relaxed(0, bam_addr(bdev, bchan->id, BAM_P_RST));
491 	struct bam_device *bdev = bchan->bdev;
502 			bam_addr(bdev, bchan->id, BAM_P_DESC_FIFO_ADDR));
504 			bam_addr(bdev, bchan->id, BAM_P_FIFO_SIZES));
508 			bam_addr(bdev, bchan->id, BAM_P_IRQ_EN));
511 	val = readl_relaxed(bam_addr(bdev, 0, BAM_IRQ_SRCS_MSK_EE));
513 	writel_relaxed(val, bam_addr(bdev, 0, BAM_IRQ_SRCS_MSK_EE));
523 	writel_relaxed(val, bam_addr(bdev, bchan->id, BAM_P_CTRL));
541 	struct bam_device *bdev = bchan->bdev;
547 	bchan->fifo_virt = dma_alloc_wc(bdev->dev, BAM_DESC_FIFO_SIZE,
551 		dev_err(bdev->dev, "Failed to allocate desc fifo\n");
555 	if (bdev->active_channels++ == 0 && bdev->powered_remotely)
556 		bam_reset(bdev);
571 	struct bam_device *bdev = bchan->bdev;
576 	ret = pm_runtime_get_sync(bdev->dev);
583 		dev_err(bchan->bdev->dev, "Cannot free busy channel\n");
591 	dma_free_wc(bdev->dev, BAM_DESC_FIFO_SIZE, bchan->fifo_virt,
596 	val = readl_relaxed(bam_addr(bdev, 0, BAM_IRQ_SRCS_MSK_EE));
598 	writel_relaxed(val, bam_addr(bdev, 0, BAM_IRQ_SRCS_MSK_EE));
601 	writel_relaxed(0, bam_addr(bdev, bchan->id, BAM_P_IRQ_EN));
603 	if (--bdev->active_channels == 0 && bdev->powered_remotely) {
605 		val = readl_relaxed(bam_addr(bdev, 0, BAM_CTRL));
607 		writel_relaxed(val, bam_addr(bdev, 0, BAM_CTRL));
611 	pm_runtime_mark_last_busy(bdev->dev);
612 	pm_runtime_put_autosuspend(bdev->dev);
653 	struct bam_device *bdev = bchan->bdev;
662 		dev_err(bdev->dev, "invalid dma direction\n");
775 	struct bam_device *bdev = bchan->bdev;
779 	ret = pm_runtime_get_sync(bdev->dev);
784 	writel_relaxed(1, bam_addr(bdev, bchan->id, BAM_P_HALT));
787 	pm_runtime_mark_last_busy(bdev->dev);
788 	pm_runtime_put_autosuspend(bdev->dev);
801 	struct bam_device *bdev = bchan->bdev;
805 	ret = pm_runtime_get_sync(bdev->dev);
810 	writel_relaxed(0, bam_addr(bdev, bchan->id, BAM_P_HALT));
813 	pm_runtime_mark_last_busy(bdev->dev);
814 	pm_runtime_put_autosuspend(bdev->dev);
821  * @bdev: bam controller
826 static u32 process_channel_irqs(struct bam_device *bdev)
832 	srcs = readl_relaxed(bam_addr(bdev, 0, BAM_IRQ_SRCS_EE));
838 	for (i = 0; i < bdev->num_channels; i++) {
839 		struct bam_chan *bchan = &bdev->channels[i];
845 		pipe_stts = readl_relaxed(bam_addr(bdev, i, BAM_P_IRQ_STTS));
847 		writel_relaxed(pipe_stts, bam_addr(bdev, i, BAM_P_IRQ_CLR));
851 		offset = readl_relaxed(bam_addr(bdev, i, BAM_P_SW_OFSTS)) &
904 	struct bam_device *bdev = data;
908 	srcs |= process_channel_irqs(bdev);
912 		tasklet_schedule(&bdev->task);
914 	ret = pm_runtime_get_sync(bdev->dev);
919 		clr_mask = readl_relaxed(bam_addr(bdev, 0, BAM_IRQ_STTS));
927 		writel_relaxed(clr_mask, bam_addr(bdev, 0, BAM_IRQ_CLR));
930 	pm_runtime_mark_last_busy(bdev->dev);
931 	pm_runtime_put_autosuspend(bdev->dev);
995 	struct bam_device *bdev = bchan->bdev;
998 	if (!bdev->controlled_remotely) {
1005 			       bam_addr(bdev, 0, BAM_DESC_CNT_TRSHLD));
1018 	struct bam_device *bdev = bchan->bdev;
1032 	ret = pm_runtime_get_sync(bdev->dev);
1103 			bam_addr(bdev, bchan->id, BAM_P_EVNT_REG));
1105 	pm_runtime_mark_last_busy(bdev->dev);
1106 	pm_runtime_put_autosuspend(bdev->dev);
1117 	struct bam_device *bdev = from_tasklet(bdev, t, task);
1123 	for (i = 0; i < bdev->num_channels; i++) {
1124 		bchan = &bdev->channels[i];
1170 	struct bam_device *bdev = container_of(of->of_dma_data,
1178 	if (request >= bdev->num_channels)
1181 	return dma_get_slave_channel(&(bdev->channels[request].vc.chan));
1186  * @bdev: bam device
1190 static int bam_init(struct bam_device *bdev)
1195 	if (!bdev->num_ees) {
1196 		val = readl_relaxed(bam_addr(bdev, 0, BAM_REVISION));
1197 		bdev->num_ees = (val >> NUM_EES_SHIFT) & NUM_EES_MASK;
1201 	if (bdev->ee >= bdev->num_ees)
1204 	if (!bdev->num_channels) {
1205 		val = readl_relaxed(bam_addr(bdev, 0, BAM_NUM_PIPES));
1206 		bdev->num_channels = val & BAM_NUM_PIPES_MASK;
1210 	if (!bdev->controlled_remotely && !bdev->powered_remotely)
1211 		bam_reset(bdev);
1216 static void bam_channel_init(struct bam_device *bdev, struct bam_chan *bchan,
1220 	bchan->bdev = bdev;
1222 	vchan_init(&bchan->vc, &bdev->common);
1238 	struct bam_device *bdev;
1242 	bdev = devm_kzalloc(&pdev->dev, sizeof(*bdev), GFP_KERNEL);
1243 	if (!bdev)
1246 	bdev->dev = &pdev->dev;
1254 	bdev->layout = match->data;
1256 	bdev->regs = devm_platform_ioremap_resource(pdev, 0);
1257 	if (IS_ERR(bdev->regs))
1258 		return PTR_ERR(bdev->regs);
1260 	bdev->irq = platform_get_irq(pdev, 0);
1261 	if (bdev->irq < 0)
1262 		return bdev->irq;
1264 	ret = of_property_read_u32(pdev->dev.of_node, "qcom,ee", &bdev->ee);
1266 		dev_err(bdev->dev, "Execution environment unspecified\n");
1270 	bdev->controlled_remotely = of_property_read_bool(pdev->dev.of_node,
1272 	bdev->powered_remotely = of_property_read_bool(pdev->dev.of_node,
1275 	if (bdev->controlled_remotely || bdev->powered_remotely)
1276 		bdev->bamclk = devm_clk_get_optional(bdev->dev, "bam_clk");
1278 		bdev->bamclk = devm_clk_get(bdev->dev, "bam_clk");
1280 	if (IS_ERR(bdev->bamclk))
1281 		return PTR_ERR(bdev->bamclk);
1283 	if (!bdev->bamclk) {
1285 					   &bdev->num_channels);
1287 			dev_err(bdev->dev, "num-channels unspecified in dt\n");
1290 					   &bdev->num_ees);
1292 			dev_err(bdev->dev, "num-ees unspecified in dt\n");
1295 	ret = clk_prepare_enable(bdev->bamclk);
1297 		dev_err(bdev->dev, "failed to prepare/enable clock\n");
1301 	ret = bam_init(bdev);
1305 	tasklet_setup(&bdev->task, dma_tasklet);
1307 	bdev->channels = devm_kcalloc(bdev->dev, bdev->num_channels,
1308 				sizeof(*bdev->channels), GFP_KERNEL);
1310 	if (!bdev->channels) {
1316 	INIT_LIST_HEAD(&bdev->common.channels);
1318 	for (i = 0; i < bdev->num_channels; i++)
1319 		bam_channel_init(bdev, &bdev->channels[i], i);
1321 	ret = devm_request_irq(bdev->dev, bdev->irq, bam_dma_irq,
1322 			IRQF_TRIGGER_HIGH, "bam_dma", bdev);
1327 	bdev->common.dev = bdev->dev;
1328 	ret = dma_set_max_seg_size(bdev->common.dev, BAM_FIFO_SIZE);
1330 		dev_err(bdev->dev, "cannot set maximum segment size\n");
1334 	platform_set_drvdata(pdev, bdev);
1337 	dma_cap_zero(bdev->common.cap_mask);
1338 	dma_cap_set(DMA_SLAVE, bdev->common.cap_mask);
1341 	bdev->common.directions = BIT(DMA_DEV_TO_MEM) | BIT(DMA_MEM_TO_DEV);
1342 	bdev->common.residue_granularity = DMA_RESIDUE_GRANULARITY_SEGMENT;
1343 	bdev->common.src_addr_widths = DMA_SLAVE_BUSWIDTH_4_BYTES;
1344 	bdev->common.dst_addr_widths = DMA_SLAVE_BUSWIDTH_4_BYTES;
1345 	bdev->common.device_alloc_chan_resources = bam_alloc_chan;
1346 	bdev->common.device_free_chan_resources = bam_free_chan;
1347 	bdev->common.device_prep_slave_sg = bam_prep_slave_sg;
1348 	bdev->common.device_config = bam_slave_config;
1349 	bdev->common.device_pause = bam_pause;
1350 	bdev->common.device_resume = bam_resume;
1351 	bdev->common.device_terminate_all = bam_dma_terminate_all;
1352 	bdev->common.device_issue_pending = bam_issue_pending;
1353 	bdev->common.device_tx_status = bam_tx_status;
1354 	bdev->common.dev = bdev->dev;
1356 	ret = dma_async_device_register(&bdev->common);
1358 		dev_err(bdev->dev, "failed to register dma async device\n");
1363 					&bdev->common);
1377 	dma_async_device_unregister(&bdev->common);
1379 	for (i = 0; i < bdev->num_channels; i++)
1380 		tasklet_kill(&bdev->channels[i].vc.task);
1382 	tasklet_kill(&bdev->task);
1384 	clk_disable_unprepare(bdev->bamclk);
1391 	struct bam_device *bdev = platform_get_drvdata(pdev);
1397 	dma_async_device_unregister(&bdev->common);
1400 	writel_relaxed(0, bam_addr(bdev, 0,  BAM_IRQ_SRCS_MSK_EE));
1402 	devm_free_irq(bdev->dev, bdev->irq, bdev);
1404 	for (i = 0; i < bdev->num_channels; i++) {
1405 		bam_dma_terminate_all(&bdev->channels[i].vc.chan);
1406 		tasklet_kill(&bdev->channels[i].vc.task);
1408 		if (!bdev->channels[i].fifo_virt)
1411 		dma_free_wc(bdev->dev, BAM_DESC_FIFO_SIZE,
1412 			    bdev->channels[i].fifo_virt,
1413 			    bdev->channels[i].fifo_phys);
1416 	tasklet_kill(&bdev->task);
1418 	clk_disable_unprepare(bdev->bamclk);
1423 	struct bam_device *bdev = dev_get_drvdata(dev);
1425 	clk_disable(bdev->bamclk);
1432 	struct bam_device *bdev = dev_get_drvdata(dev);
1435 	ret = clk_enable(bdev->bamclk);
1446 	struct bam_device *bdev = dev_get_drvdata(dev);
1449 	clk_unprepare(bdev->bamclk);
1456 	struct bam_device *bdev = dev_get_drvdata(dev);
1459 	ret = clk_prepare(bdev->bamclk);