Lines Matching +full:gce +full:- +full:mailbox
1 // SPDX-License-Identifier: GPL-2.0
7 #include <linux/clk-provider.h>
8 #include <linux/dma-mapping.h>
18 #include <linux/mailbox/mtk-cmdq-mailbox.h>
24 #define CMDQ_NUM_CMD(t) (t->cmd_buf_size / CMDQ_INST_SIZE)
73 struct cmdq_pkt *pkt; /* the packet sent from mailbox client */
97 WARN_ON(clk_bulk_enable(cmdq->pdata->gce_num, cmdq->clocks)); in cmdq_sw_ddr_enable()
100 writel(GCE_DDR_EN | GCE_CTRL_BY_SW, cmdq->base + GCE_GCTL_VALUE); in cmdq_sw_ddr_enable()
102 writel(GCE_CTRL_BY_SW, cmdq->base + GCE_GCTL_VALUE); in cmdq_sw_ddr_enable()
104 clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks); in cmdq_sw_ddr_enable()
109 struct cmdq *cmdq = container_of(chan->mbox, struct cmdq, mbox); in cmdq_get_shift_pa()
111 return cmdq->pdata->shift; in cmdq_get_shift_pa()
119 writel(CMDQ_THR_SUSPEND, thread->base + CMDQ_THR_SUSPEND_TASK); in cmdq_thread_suspend()
122 if (!(readl(thread->base + CMDQ_THR_ENABLE_TASK) & CMDQ_THR_ENABLED)) in cmdq_thread_suspend()
125 if (readl_poll_timeout_atomic(thread->base + CMDQ_THR_CURR_STATUS, in cmdq_thread_suspend()
127 dev_err(cmdq->mbox.dev, "suspend GCE thread 0x%x failed\n", in cmdq_thread_suspend()
128 (u32)(thread->base - cmdq->base)); in cmdq_thread_suspend()
129 return -EFAULT; in cmdq_thread_suspend()
137 writel(CMDQ_THR_RESUME, thread->base + CMDQ_THR_SUSPEND_TASK); in cmdq_thread_resume()
145 WARN_ON(clk_bulk_enable(cmdq->pdata->gce_num, cmdq->clocks)); in cmdq_init()
146 if (cmdq->pdata->control_by_sw) in cmdq_init()
148 if (cmdq->pdata->sw_ddr_en) in cmdq_init()
152 writel(gctl_regval, cmdq->base + GCE_GCTL_VALUE); in cmdq_init()
154 writel(CMDQ_THR_ACTIVE_SLOT_CYCLES, cmdq->base + CMDQ_THR_SLOT_CYCLES); in cmdq_init()
156 writel(i, cmdq->base + CMDQ_SYNC_TOKEN_UPDATE); in cmdq_init()
157 clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks); in cmdq_init()
164 writel(CMDQ_THR_DO_WARM_RESET, thread->base + CMDQ_THR_WARM_RESET); in cmdq_thread_reset()
165 if (readl_poll_timeout_atomic(thread->base + CMDQ_THR_WARM_RESET, in cmdq_thread_reset()
168 dev_err(cmdq->mbox.dev, "reset GCE thread 0x%x failed\n", in cmdq_thread_reset()
169 (u32)(thread->base - cmdq->base)); in cmdq_thread_reset()
170 return -EFAULT; in cmdq_thread_reset()
179 writel(CMDQ_THR_DISABLED, thread->base + CMDQ_THR_ENABLE_TASK); in cmdq_thread_disable()
182 /* notify GCE to re-fetch commands by setting GCE thread PC */
185 writel(readl(thread->base + CMDQ_THR_CURR_ADDR), in cmdq_thread_invalidate_fetched_data()
186 thread->base + CMDQ_THR_CURR_ADDR); in cmdq_thread_invalidate_fetched_data()
191 struct device *dev = task->cmdq->mbox.dev; in cmdq_task_insert_into_thread()
192 struct cmdq_thread *thread = task->thread; in cmdq_task_insert_into_thread()
194 &thread->task_busy_list, typeof(*task), list_entry); in cmdq_task_insert_into_thread()
195 u64 *prev_task_base = prev_task->pkt->va_base; in cmdq_task_insert_into_thread()
198 dma_sync_single_for_cpu(dev, prev_task->pa_base, in cmdq_task_insert_into_thread()
199 prev_task->pkt->cmd_buf_size, DMA_TO_DEVICE); in cmdq_task_insert_into_thread()
200 prev_task_base[CMDQ_NUM_CMD(prev_task->pkt) - 1] = in cmdq_task_insert_into_thread()
202 (task->pa_base >> task->cmdq->pdata->shift); in cmdq_task_insert_into_thread()
203 dma_sync_single_for_device(dev, prev_task->pa_base, in cmdq_task_insert_into_thread()
204 prev_task->pkt->cmd_buf_size, DMA_TO_DEVICE); in cmdq_task_insert_into_thread()
211 return readl(thread->base + CMDQ_THR_WAIT_TOKEN) & CMDQ_THR_IS_WAITING; in cmdq_thread_is_in_wfe()
219 data.pkt = task->pkt; in cmdq_task_exec_done()
220 mbox_chan_received_data(task->thread->chan, &data); in cmdq_task_exec_done()
222 list_del(&task->list_entry); in cmdq_task_exec_done()
227 struct cmdq_thread *thread = task->thread; in cmdq_task_handle_error()
229 struct cmdq *cmdq = task->cmdq; in cmdq_task_handle_error()
231 dev_err(cmdq->mbox.dev, "task 0x%p error\n", task); in cmdq_task_handle_error()
233 next_task = list_first_entry_or_null(&thread->task_busy_list, in cmdq_task_handle_error()
236 writel(next_task->pa_base >> cmdq->pdata->shift, in cmdq_task_handle_error()
237 thread->base + CMDQ_THR_CURR_ADDR); in cmdq_task_handle_error()
248 irq_flag = readl(thread->base + CMDQ_THR_IRQ_STATUS); in cmdq_thread_irq_handler()
249 writel(~irq_flag, thread->base + CMDQ_THR_IRQ_STATUS); in cmdq_thread_irq_handler()
254 * reset / disable this GCE thread, so we need to check the enable in cmdq_thread_irq_handler()
255 * bit of this GCE thread. in cmdq_thread_irq_handler()
257 if (!(readl(thread->base + CMDQ_THR_ENABLE_TASK) & CMDQ_THR_ENABLED)) in cmdq_thread_irq_handler()
267 curr_pa = readl(thread->base + CMDQ_THR_CURR_ADDR) << cmdq->pdata->shift; in cmdq_thread_irq_handler()
269 list_for_each_entry_safe(task, tmp, &thread->task_busy_list, in cmdq_thread_irq_handler()
271 task_end_pa = task->pa_base + task->pkt->cmd_buf_size; in cmdq_thread_irq_handler()
272 if (curr_pa >= task->pa_base && curr_pa < task_end_pa) in cmdq_thread_irq_handler()
275 if (!curr_task || curr_pa == task_end_pa - CMDQ_INST_SIZE) { in cmdq_thread_irq_handler()
279 cmdq_task_exec_done(task, -ENOEXEC); in cmdq_thread_irq_handler()
288 if (list_empty(&thread->task_busy_list)) in cmdq_thread_irq_handler()
298 irq_status = readl(cmdq->base + CMDQ_CURR_IRQ_STATUS) & cmdq->irq_mask; in cmdq_irq_handler()
299 if (!(irq_status ^ cmdq->irq_mask)) in cmdq_irq_handler()
302 for_each_clear_bit(bit, &irq_status, cmdq->pdata->thread_nr) { in cmdq_irq_handler()
303 struct cmdq_thread *thread = &cmdq->thread[bit]; in cmdq_irq_handler()
305 spin_lock_irqsave(&thread->chan->lock, flags); in cmdq_irq_handler()
307 spin_unlock_irqrestore(&thread->chan->lock, flags); in cmdq_irq_handler()
310 pm_runtime_mark_last_busy(cmdq->mbox.dev); in cmdq_irq_handler()
319 return clk_bulk_enable(cmdq->pdata->gce_num, cmdq->clocks); in cmdq_runtime_resume()
326 clk_bulk_disable(cmdq->pdata->gce_num, cmdq->clocks); in cmdq_runtime_suspend()
337 cmdq->suspended = true; in cmdq_suspend()
339 for (i = 0; i < cmdq->pdata->thread_nr; i++) { in cmdq_suspend()
340 thread = &cmdq->thread[i]; in cmdq_suspend()
341 if (!list_empty(&thread->task_busy_list)) { in cmdq_suspend()
350 if (cmdq->pdata->sw_ddr_en) in cmdq_suspend()
361 cmdq->suspended = false; in cmdq_resume()
363 if (cmdq->pdata->sw_ddr_en) in cmdq_resume()
373 if (cmdq->pdata->sw_ddr_en) in cmdq_remove()
377 cmdq_runtime_suspend(&pdev->dev); in cmdq_remove()
379 clk_bulk_unprepare(cmdq->pdata->gce_num, cmdq->clocks); in cmdq_remove()
385 struct cmdq_thread *thread = (struct cmdq_thread *)chan->con_priv; in cmdq_mbox_send_data()
386 struct cmdq *cmdq = dev_get_drvdata(chan->mbox->dev); in cmdq_mbox_send_data()
392 WARN_ON(cmdq->suspended); in cmdq_mbox_send_data()
394 ret = pm_runtime_get_sync(cmdq->mbox.dev); in cmdq_mbox_send_data()
400 __pm_runtime_put_autosuspend(cmdq->mbox.dev); in cmdq_mbox_send_data()
401 return -ENOMEM; in cmdq_mbox_send_data()
404 task->cmdq = cmdq; in cmdq_mbox_send_data()
405 INIT_LIST_HEAD(&task->list_entry); in cmdq_mbox_send_data()
406 task->pa_base = pkt->pa_base; in cmdq_mbox_send_data()
407 task->thread = thread; in cmdq_mbox_send_data()
408 task->pkt = pkt; in cmdq_mbox_send_data()
410 if (list_empty(&thread->task_busy_list)) { in cmdq_mbox_send_data()
419 writel(task->pa_base >> cmdq->pdata->shift, in cmdq_mbox_send_data()
420 thread->base + CMDQ_THR_CURR_ADDR); in cmdq_mbox_send_data()
421 writel((task->pa_base + pkt->cmd_buf_size) >> cmdq->pdata->shift, in cmdq_mbox_send_data()
422 thread->base + CMDQ_THR_END_ADDR); in cmdq_mbox_send_data()
424 writel(thread->priority, thread->base + CMDQ_THR_PRIORITY); in cmdq_mbox_send_data()
425 writel(CMDQ_THR_IRQ_EN, thread->base + CMDQ_THR_IRQ_ENABLE); in cmdq_mbox_send_data()
426 writel(CMDQ_THR_ENABLED, thread->base + CMDQ_THR_ENABLE_TASK); in cmdq_mbox_send_data()
429 curr_pa = readl(thread->base + CMDQ_THR_CURR_ADDR) << in cmdq_mbox_send_data()
430 cmdq->pdata->shift; in cmdq_mbox_send_data()
431 end_pa = readl(thread->base + CMDQ_THR_END_ADDR) << in cmdq_mbox_send_data()
432 cmdq->pdata->shift; in cmdq_mbox_send_data()
434 if (curr_pa == end_pa - CMDQ_INST_SIZE || in cmdq_mbox_send_data()
437 writel(task->pa_base >> cmdq->pdata->shift, in cmdq_mbox_send_data()
438 thread->base + CMDQ_THR_CURR_ADDR); in cmdq_mbox_send_data()
443 writel((task->pa_base + pkt->cmd_buf_size) >> cmdq->pdata->shift, in cmdq_mbox_send_data()
444 thread->base + CMDQ_THR_END_ADDR); in cmdq_mbox_send_data()
447 list_move_tail(&task->list_entry, &thread->task_busy_list); in cmdq_mbox_send_data()
449 pm_runtime_mark_last_busy(cmdq->mbox.dev); in cmdq_mbox_send_data()
450 __pm_runtime_put_autosuspend(cmdq->mbox.dev); in cmdq_mbox_send_data()
462 struct cmdq_thread *thread = (struct cmdq_thread *)chan->con_priv; in cmdq_mbox_shutdown()
463 struct cmdq *cmdq = dev_get_drvdata(chan->mbox->dev); in cmdq_mbox_shutdown()
467 WARN_ON(pm_runtime_get_sync(cmdq->mbox.dev) < 0); in cmdq_mbox_shutdown()
469 spin_lock_irqsave(&thread->chan->lock, flags); in cmdq_mbox_shutdown()
470 if (list_empty(&thread->task_busy_list)) in cmdq_mbox_shutdown()
477 if (list_empty(&thread->task_busy_list)) in cmdq_mbox_shutdown()
480 list_for_each_entry_safe(task, tmp, &thread->task_busy_list, in cmdq_mbox_shutdown()
482 cmdq_task_exec_done(task, -ECONNABORTED); in cmdq_mbox_shutdown()
490 * The thread->task_busy_list empty means thread already disable. The in cmdq_mbox_shutdown()
495 spin_unlock_irqrestore(&thread->chan->lock, flags); in cmdq_mbox_shutdown()
497 pm_runtime_mark_last_busy(cmdq->mbox.dev); in cmdq_mbox_shutdown()
498 __pm_runtime_put_autosuspend(cmdq->mbox.dev); in cmdq_mbox_shutdown()
503 struct cmdq_thread *thread = (struct cmdq_thread *)chan->con_priv; in cmdq_mbox_flush()
505 struct cmdq *cmdq = dev_get_drvdata(chan->mbox->dev); in cmdq_mbox_flush()
511 ret = pm_runtime_get_sync(cmdq->mbox.dev); in cmdq_mbox_flush()
515 spin_lock_irqsave(&thread->chan->lock, flags); in cmdq_mbox_flush()
516 if (list_empty(&thread->task_busy_list)) in cmdq_mbox_flush()
523 list_for_each_entry_safe(task, tmp, &thread->task_busy_list, in cmdq_mbox_flush()
525 data.sta = -ECONNABORTED; in cmdq_mbox_flush()
526 data.pkt = task->pkt; in cmdq_mbox_flush()
527 mbox_chan_received_data(task->thread->chan, &data); in cmdq_mbox_flush()
528 list_del(&task->list_entry); in cmdq_mbox_flush()
536 spin_unlock_irqrestore(&thread->chan->lock, flags); in cmdq_mbox_flush()
537 pm_runtime_mark_last_busy(cmdq->mbox.dev); in cmdq_mbox_flush()
538 __pm_runtime_put_autosuspend(cmdq->mbox.dev); in cmdq_mbox_flush()
544 spin_unlock_irqrestore(&thread->chan->lock, flags); in cmdq_mbox_flush()
545 if (readl_poll_timeout_atomic(thread->base + CMDQ_THR_ENABLE_TASK, in cmdq_mbox_flush()
547 dev_err(cmdq->mbox.dev, "Fail to wait GCE thread 0x%x done\n", in cmdq_mbox_flush()
548 (u32)(thread->base - cmdq->base)); in cmdq_mbox_flush()
550 return -EFAULT; in cmdq_mbox_flush()
552 pm_runtime_mark_last_busy(cmdq->mbox.dev); in cmdq_mbox_flush()
553 __pm_runtime_put_autosuspend(cmdq->mbox.dev); in cmdq_mbox_flush()
567 int ind = sp->args[0]; in cmdq_xlate()
570 if (ind >= mbox->num_chans) in cmdq_xlate()
571 return ERR_PTR(-EINVAL); in cmdq_xlate()
573 thread = (struct cmdq_thread *)mbox->chans[ind].con_priv; in cmdq_xlate()
574 thread->priority = sp->args[1]; in cmdq_xlate()
575 thread->chan = &mbox->chans[ind]; in cmdq_xlate()
577 return &mbox->chans[ind]; in cmdq_xlate()
582 static const char * const gce_name = "gce"; in cmdq_get_clocks()
583 struct device_node *node, *parent = dev->of_node->parent; in cmdq_get_clocks()
586 cmdq->clocks = devm_kcalloc(dev, cmdq->pdata->gce_num, in cmdq_get_clocks()
587 sizeof(*cmdq->clocks), GFP_KERNEL); in cmdq_get_clocks()
588 if (!cmdq->clocks) in cmdq_get_clocks()
589 return -ENOMEM; in cmdq_get_clocks()
591 if (cmdq->pdata->gce_num == 1) { in cmdq_get_clocks()
592 clks = &cmdq->clocks[0]; in cmdq_get_clocks()
594 clks->id = gce_name; in cmdq_get_clocks()
595 clks->clk = devm_clk_get(dev, NULL); in cmdq_get_clocks()
596 if (IS_ERR(clks->clk)) in cmdq_get_clocks()
597 return dev_err_probe(dev, PTR_ERR(clks->clk), in cmdq_get_clocks()
598 "failed to get gce clock\n"); in cmdq_get_clocks()
604 * If there is more than one GCE, get the clocks for the others too, in cmdq_get_clocks()
605 * as the clock of the main GCE must be enabled for additional IPs in cmdq_get_clocks()
611 if (alias_id < 0 || alias_id >= cmdq->pdata->gce_num) in cmdq_get_clocks()
614 clks = &cmdq->clocks[alias_id]; in cmdq_get_clocks()
616 clks->id = devm_kasprintf(dev, GFP_KERNEL, "gce%d", alias_id); in cmdq_get_clocks()
617 if (!clks->id) { in cmdq_get_clocks()
619 return -ENOMEM; in cmdq_get_clocks()
622 clks->clk = of_clk_get(node, 0); in cmdq_get_clocks()
623 if (IS_ERR(clks->clk)) { in cmdq_get_clocks()
625 return dev_err_probe(dev, PTR_ERR(clks->clk), in cmdq_get_clocks()
626 "failed to get gce%d clock\n", alias_id); in cmdq_get_clocks()
635 struct device *dev = &pdev->dev; in cmdq_probe()
641 return -ENOMEM; in cmdq_probe()
643 cmdq->base = devm_platform_ioremap_resource(pdev, 0); in cmdq_probe()
644 if (IS_ERR(cmdq->base)) in cmdq_probe()
645 return PTR_ERR(cmdq->base); in cmdq_probe()
647 cmdq->irq = platform_get_irq(pdev, 0); in cmdq_probe()
648 if (cmdq->irq < 0) in cmdq_probe()
649 return cmdq->irq; in cmdq_probe()
651 cmdq->pdata = device_get_match_data(dev); in cmdq_probe()
652 if (!cmdq->pdata) { in cmdq_probe()
654 return -EINVAL; in cmdq_probe()
657 cmdq->irq_mask = GENMASK(cmdq->pdata->thread_nr - 1, 0); in cmdq_probe()
660 dev, cmdq->base, cmdq->irq); in cmdq_probe()
666 cmdq->mbox.dev = dev; in cmdq_probe()
667 cmdq->mbox.chans = devm_kcalloc(dev, cmdq->pdata->thread_nr, in cmdq_probe()
668 sizeof(*cmdq->mbox.chans), GFP_KERNEL); in cmdq_probe()
669 if (!cmdq->mbox.chans) in cmdq_probe()
670 return -ENOMEM; in cmdq_probe()
672 cmdq->mbox.num_chans = cmdq->pdata->thread_nr; in cmdq_probe()
673 cmdq->mbox.ops = &cmdq_mbox_chan_ops; in cmdq_probe()
674 cmdq->mbox.of_xlate = cmdq_xlate; in cmdq_probe()
677 cmdq->mbox.txdone_irq = false; in cmdq_probe()
678 cmdq->mbox.txdone_poll = false; in cmdq_probe()
680 cmdq->thread = devm_kcalloc(dev, cmdq->pdata->thread_nr, in cmdq_probe()
681 sizeof(*cmdq->thread), GFP_KERNEL); in cmdq_probe()
682 if (!cmdq->thread) in cmdq_probe()
683 return -ENOMEM; in cmdq_probe()
685 for (i = 0; i < cmdq->pdata->thread_nr; i++) { in cmdq_probe()
686 cmdq->thread[i].base = cmdq->base + CMDQ_THR_BASE + in cmdq_probe()
688 INIT_LIST_HEAD(&cmdq->thread[i].task_busy_list); in cmdq_probe()
689 cmdq->mbox.chans[i].con_priv = (void *)&cmdq->thread[i]; in cmdq_probe()
694 WARN_ON(clk_bulk_prepare(cmdq->pdata->gce_num, cmdq->clocks)); in cmdq_probe()
698 err = devm_request_irq(dev, cmdq->irq, cmdq_irq_handler, IRQF_SHARED, in cmdq_probe()
719 err = devm_mbox_controller_register(dev, &cmdq->mbox); in cmdq_probe()
721 dev_err(dev, "failed to register mailbox: %d\n", err); in cmdq_probe()
786 {.compatible = "mediatek,mt6779-gce", .data = (void *)&gce_plat_mt6779},
787 {.compatible = "mediatek,mt8173-gce", .data = (void *)&gce_plat_mt8173},
788 {.compatible = "mediatek,mt8183-gce", .data = (void *)&gce_plat_mt8183},
789 {.compatible = "mediatek,mt8186-gce", .data = (void *)&gce_plat_mt8186},
790 {.compatible = "mediatek,mt8188-gce", .data = (void *)&gce_plat_mt8188},
791 {.compatible = "mediatek,mt8192-gce", .data = (void *)&gce_plat_mt8192},
792 {.compatible = "mediatek,mt8195-gce", .data = (void *)&gce_plat_mt8195},
820 MODULE_DESCRIPTION("Mediatek Command Queue(CMDQ) Mailbox driver");