| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * Copyright (C) 2020-21 Intel Corporation. | |
| */ | |
| #include "iosm_ipc_imem.h" | |
| #include "iosm_ipc_task_queue.h" | |
| /* Actual tasklet function, will be called whenever tasklet is scheduled. | |
| * Calls event handler involves callback for each element in the message queue | |
| */ | |
| static void ipc_task_queue_handler(unsigned long data) | |
| { | |
| struct ipc_task_queue *ipc_task = (struct ipc_task_queue *)data; | |
| unsigned int q_rpos = ipc_task->q_rpos; | |
| /* Loop over the input queue contents. */ | |
| while (q_rpos != ipc_task->q_wpos) { | |
| /* Get the current first queue element. */ | |
| struct ipc_task_queue_args *args = &ipc_task->args[q_rpos]; | |
| /* Process the input message. */ | |
| if (args->func) | |
| args->response = args->func(args->ipc_imem, args->arg, | |
| args->msg, args->size); | |
| /* Signal completion for synchronous calls */ | |
| if (args->completion) | |
| complete(args->completion); | |
| /* Free message if copy was allocated. */ | |
| if (args->is_copy) | |
| kfree(args->msg); | |
| /* Set invalid queue element. Technically | |
| * spin_lock_irqsave is not required here as | |
| * the array element has been processed already | |
| * so we can assume that immediately after processing | |
| * ipc_task element, queue will not rotate again to | |
| * ipc_task same element within such short time. | |
| */ | |
| args->completion = NULL; | |
| args->func = NULL; | |
| args->msg = NULL; | |
| args->size = 0; | |
| args->is_copy = false; | |
| /* calculate the new read ptr and update the volatile read | |
| * ptr | |
| */ | |
| q_rpos = (q_rpos + 1) % IPC_THREAD_QUEUE_SIZE; | |
| ipc_task->q_rpos = q_rpos; | |
| } | |
| } | |
| /* Free memory alloc and trigger completions left in the queue during dealloc */ | |
| static void ipc_task_queue_cleanup(struct ipc_task_queue *ipc_task) | |
| { | |
| unsigned int q_rpos = ipc_task->q_rpos; | |
| while (q_rpos != ipc_task->q_wpos) { | |
| struct ipc_task_queue_args *args = &ipc_task->args[q_rpos]; | |
| if (args->completion) | |
| complete(args->completion); | |
| if (args->is_copy) | |
| kfree(args->msg); | |
| q_rpos = (q_rpos + 1) % IPC_THREAD_QUEUE_SIZE; | |
| ipc_task->q_rpos = q_rpos; | |
| } | |
| } | |
| /* Add a message to the queue and trigger the ipc_task. */ | |
| static int | |
| ipc_task_queue_add_task(struct iosm_imem *ipc_imem, | |
| int arg, void *msg, | |
| int (*func)(struct iosm_imem *ipc_imem, int arg, | |
| void *msg, size_t size), | |
| size_t size, bool is_copy, bool wait) | |
| { | |
| struct tasklet_struct *ipc_tasklet = ipc_imem->ipc_task->ipc_tasklet; | |
| struct ipc_task_queue *ipc_task = &ipc_imem->ipc_task->ipc_queue; | |
| struct completion completion; | |
| unsigned int pos, nextpos; | |
| unsigned long flags; | |
| int result = -EIO; | |
| init_completion(&completion); | |
| /* tasklet send may be called from both interrupt or thread | |
| * context, therefore protect queue operation by spinlock | |
| */ | |
| spin_lock_irqsave(&ipc_task->q_lock, flags); | |
| pos = ipc_task->q_wpos; | |
| nextpos = (pos + 1) % IPC_THREAD_QUEUE_SIZE; | |
| /* Get next queue position. */ | |
| if (nextpos != ipc_task->q_rpos) { | |
| /* Get the reference to the queue element and save the passed | |
| * values. | |
| */ | |
| ipc_task->args[pos].arg = arg; | |
| ipc_task->args[pos].msg = msg; | |
| ipc_task->args[pos].func = func; | |
| ipc_task->args[pos].ipc_imem = ipc_imem; | |
| ipc_task->args[pos].size = size; | |
| ipc_task->args[pos].is_copy = is_copy; | |
| ipc_task->args[pos].completion = wait ? &completion : NULL; | |
| ipc_task->args[pos].response = -1; | |
| /* apply write barrier so that ipc_task->q_rpos elements | |
| * are updated before ipc_task->q_wpos is being updated. | |
| */ | |
| smp_wmb(); | |
| /* Update the status of the free queue space. */ | |
| ipc_task->q_wpos = nextpos; | |
| result = 0; | |
| } | |
| spin_unlock_irqrestore(&ipc_task->q_lock, flags); | |
| if (result == 0) { | |
| tasklet_schedule(ipc_tasklet); | |
| if (wait) { | |
| wait_for_completion(&completion); | |
| result = ipc_task->args[pos].response; | |
| } | |
| } else { | |
| dev_err(ipc_imem->ipc_task->dev, "queue is full"); | |
| } | |
| return result; | |
| } | |
| int ipc_task_queue_send_task(struct iosm_imem *imem, | |
| int (*func)(struct iosm_imem *ipc_imem, int arg, | |
| void *msg, size_t size), | |
| int arg, void *msg, size_t size, bool wait) | |
| { | |
| bool is_copy = false; | |
| void *copy = msg; | |
| int ret = -ENOMEM; | |
| if (size > 0) { | |
| copy = kmemdup(msg, size, GFP_ATOMIC); | |
| if (!copy) | |
| goto out; | |
| is_copy = true; | |
| } | |
| ret = ipc_task_queue_add_task(imem, arg, copy, func, | |
| size, is_copy, wait); | |
| if (ret < 0) { | |
| dev_err(imem->ipc_task->dev, | |
| "add task failed for %ps %d, %p, %zu, %d", func, arg, | |
| copy, size, is_copy); | |
| if (is_copy) | |
| kfree(copy); | |
| goto out; | |
| } | |
| ret = 0; | |
| out: | |
| return ret; | |
| } | |
| int ipc_task_init(struct ipc_task *ipc_task) | |
| { | |
| struct ipc_task_queue *ipc_queue = &ipc_task->ipc_queue; | |
| ipc_task->ipc_tasklet = kzalloc_obj(*ipc_task->ipc_tasklet); | |
| if (!ipc_task->ipc_tasklet) | |
| return -ENOMEM; | |
| /* Initialize the spinlock needed to protect the message queue of the | |
| * ipc_task | |
| */ | |
| spin_lock_init(&ipc_queue->q_lock); | |
| tasklet_init(ipc_task->ipc_tasklet, ipc_task_queue_handler, | |
| (unsigned long)ipc_queue); | |
| return 0; | |
| } | |
| void ipc_task_deinit(struct ipc_task *ipc_task) | |
| { | |
| tasklet_kill(ipc_task->ipc_tasklet); | |
| kfree(ipc_task->ipc_tasklet); | |
| /* This will free/complete any outstanding messages, | |
| * without calling the actual handler | |
| */ | |
| ipc_task_queue_cleanup(&ipc_task->ipc_queue); | |
| } |