drivers/mailbox/mtk-cmdq-mailbox.c

72 	struct cmdq_thread	*thread;
82 	struct cmdq_thread	*thread;
116 static int cmdq_thread_suspend(struct cmdq *cmdq, struct cmdq_thread *thread)
120 	writel(CMDQ_THR_SUSPEND, thread->base + CMDQ_THR_SUSPEND_TASK);
123 	if (!(readl(thread->base + CMDQ_THR_ENABLE_TASK) & CMDQ_THR_ENABLED))
126 	if (readl_poll_timeout_atomic(thread->base + CMDQ_THR_CURR_STATUS,
128 		dev_err(cmdq->mbox.dev, "suspend GCE thread 0x%x failed\n",
129 			(u32)(thread->base - cmdq->base));
136 static void cmdq_thread_resume(struct cmdq_thread *thread)
138 	writel(CMDQ_THR_RESUME, thread->base + CMDQ_THR_SUSPEND_TASK);
155 static int cmdq_thread_reset(struct cmdq *cmdq, struct cmdq_thread *thread)
159 	writel(CMDQ_THR_DO_WARM_RESET, thread->base + CMDQ_THR_WARM_RESET);
160 	if (readl_poll_timeout_atomic(thread->base + CMDQ_THR_WARM_RESET,
163 		dev_err(cmdq->mbox.dev, "reset GCE thread 0x%x failed\n",
164 			(u32)(thread->base - cmdq->base));
171 static void cmdq_thread_disable(struct cmdq *cmdq, struct cmdq_thread *thread)
173 	cmdq_thread_reset(cmdq, thread);
174 	writel(CMDQ_THR_DISABLED, thread->base + CMDQ_THR_ENABLE_TASK);
177 /* notify GCE to re-fetch commands by setting GCE thread PC */
178 static void cmdq_thread_invalidate_fetched_data(struct cmdq_thread *thread)
180 	writel(readl(thread->base + CMDQ_THR_CURR_ADDR),
181 	       thread->base + CMDQ_THR_CURR_ADDR);
187 	struct cmdq_thread *thread = task->thread;
189 			&thread->task_busy_list, typeof(*task), list_entry);
201 	cmdq_thread_invalidate_fetched_data(thread);
204 static bool cmdq_thread_is_in_wfe(struct cmdq_thread *thread)
206 	return readl(thread->base + CMDQ_THR_WAIT_TOKEN) & CMDQ_THR_IS_WAITING;
215 	mbox_chan_received_data(task->thread->chan, &data);
222 	struct cmdq_thread *thread = task->thread;
227 	WARN_ON(cmdq_thread_suspend(cmdq, thread) < 0);
228 	next_task = list_first_entry_or_null(&thread->task_busy_list,
232 		       thread->base + CMDQ_THR_CURR_ADDR);
233 	cmdq_thread_resume(thread);
237 				    struct cmdq_thread *thread)
243 	irq_flag = readl(thread->base + CMDQ_THR_IRQ_STATUS);
244 	writel(~irq_flag, thread->base + CMDQ_THR_IRQ_STATUS);
249 	 * reset / disable this GCE thread, so we need to check the enable
250 	 * bit of this GCE thread.
252 	if (!(readl(thread->base + CMDQ_THR_ENABLE_TASK) & CMDQ_THR_ENABLED))
262 	curr_pa = readl(thread->base + CMDQ_THR_CURR_ADDR) << cmdq->pdata->shift;
264 	list_for_each_entry_safe(task, tmp, &thread->task_busy_list,
283 	if (list_empty(&thread->task_busy_list))
284 		cmdq_thread_disable(cmdq, thread);
298 		struct cmdq_thread *thread = &cmdq->thread[bit];
300 		spin_lock_irqsave(&thread->chan->lock, flags);
301 		cmdq_thread_irq_handler(cmdq, thread);
302 		spin_unlock_irqrestore(&thread->chan->lock, flags);
335 	struct cmdq_thread *thread;
342 		thread = &cmdq->thread[i];
343 		if (!list_empty(&thread->task_busy_list)) {
378 	struct cmdq_thread *thread = (struct cmdq_thread *)chan->con_priv;
400 	task->thread = thread;
403 	if (list_empty(&thread->task_busy_list)) {
405 		 * The thread reset will clear thread related register to 0,
408 		 * thread and make it running.
410 		WARN_ON(cmdq_thread_reset(cmdq, thread) < 0);
413 		       thread->base + CMDQ_THR_CURR_ADDR);
415 		       thread->base + CMDQ_THR_END_ADDR);
417 		writel(thread->priority, thread->base + CMDQ_THR_PRIORITY);
418 		writel(CMDQ_THR_IRQ_EN, thread->base + CMDQ_THR_IRQ_ENABLE);
419 		writel(CMDQ_THR_ENABLED, thread->base + CMDQ_THR_ENABLE_TASK);
421 		WARN_ON(cmdq_thread_suspend(cmdq, thread) < 0);
422 		curr_pa = readl(thread->base + CMDQ_THR_CURR_ADDR) <<
424 		end_pa = readl(thread->base + CMDQ_THR_END_ADDR) <<
431 			       thread->base + CMDQ_THR_CURR_ADDR);
434 			smp_mb(); /* modify jump before enable thread */
437 		       thread->base + CMDQ_THR_END_ADDR);
438 		cmdq_thread_resume(thread);
440 	list_move_tail(&task->list_entry, &thread->task_busy_list);
455 	struct cmdq_thread *thread = (struct cmdq_thread *)chan->con_priv;
462 	spin_lock_irqsave(&thread->chan->lock, flags);
463 	if (list_empty(&thread->task_busy_list))
466 	WARN_ON(cmdq_thread_suspend(cmdq, thread) < 0);
469 	cmdq_thread_irq_handler(cmdq, thread);
470 	if (list_empty(&thread->task_busy_list))
473 	list_for_each_entry_safe(task, tmp, &thread->task_busy_list,
479 	cmdq_thread_disable(cmdq, thread);
483 	 * The thread->task_busy_list empty means thread already disable. The
484 	 * cmdq_mbox_send_data() always reset thread which clear disable and
488 	spin_unlock_irqrestore(&thread->chan->lock, flags);
496 	struct cmdq_thread *thread = (struct cmdq_thread *)chan->con_priv;
508 	spin_lock_irqsave(&thread->chan->lock, flags);
509 	if (list_empty(&thread->task_busy_list))
512 	WARN_ON(cmdq_thread_suspend(cmdq, thread) < 0);
513 	if (!cmdq_thread_is_in_wfe(thread))
516 	list_for_each_entry_safe(task, tmp, &thread->task_busy_list,
520 		mbox_chan_received_data(task->thread->chan, &data);
525 	cmdq_thread_resume(thread);
526 	cmdq_thread_disable(cmdq, thread);
529 	spin_unlock_irqrestore(&thread->chan->lock, flags);
536 	cmdq_thread_resume(thread);
537 	spin_unlock_irqrestore(&thread->chan->lock, flags);
538 	if (readl_poll_timeout_atomic(thread->base + CMDQ_THR_ENABLE_TASK,
540 		dev_err(cmdq->mbox.dev, "Fail to wait GCE thread 0x%x done\n",
541 			(u32)(thread->base - cmdq->base));
561 	struct cmdq_thread *thread;
566 	thread = (struct cmdq_thread *)mbox->chans[ind].con_priv;
567 	thread->priority = sp->args[1];
568 	thread->chan = &mbox->chans[ind];
673 	cmdq->thread = devm_kcalloc(dev, cmdq->pdata->thread_nr,
674 					sizeof(*cmdq->thread), GFP_KERNEL);
675 	if (!cmdq->thread)
679 		cmdq->thread[i].base = cmdq->base + CMDQ_THR_BASE +
681 		INIT_LIST_HEAD(&cmdq->thread[i].task_busy_list);
682 		cmdq->mbox.chans[i].con_priv = (void *)&cmdq->thread[i];