forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
294 lines
6.5 KiB
294 lines
6.5 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* Intel SST generic IPC Support |
|
* |
|
* Copyright (C) 2015, Intel Corporation. All rights reserved. |
|
*/ |
|
|
|
#include <linux/types.h> |
|
#include <linux/kernel.h> |
|
#include <linux/list.h> |
|
#include <linux/wait.h> |
|
#include <linux/module.h> |
|
#include <linux/spinlock.h> |
|
#include <linux/device.h> |
|
#include <linux/slab.h> |
|
#include <linux/workqueue.h> |
|
#include <linux/sched.h> |
|
#include <linux/delay.h> |
|
#include <linux/platform_device.h> |
|
#include <sound/asound.h> |
|
|
|
#include "sst-dsp.h" |
|
#include "sst-dsp-priv.h" |
|
#include "sst-ipc.h" |
|
|
|
/* IPC message timeout (msecs) */ |
|
#define IPC_TIMEOUT_MSECS 300 |
|
|
|
#define IPC_EMPTY_LIST_SIZE 8 |
|
|
|
/* locks held by caller */ |
|
static struct ipc_message *msg_get_empty(struct sst_generic_ipc *ipc) |
|
{ |
|
struct ipc_message *msg = NULL; |
|
|
|
if (!list_empty(&ipc->empty_list)) { |
|
msg = list_first_entry(&ipc->empty_list, struct ipc_message, |
|
list); |
|
list_del(&msg->list); |
|
} |
|
|
|
return msg; |
|
} |
|
|
|
static int tx_wait_done(struct sst_generic_ipc *ipc, |
|
struct ipc_message *msg, struct sst_ipc_message *reply) |
|
{ |
|
unsigned long flags; |
|
int ret; |
|
|
|
/* wait for DSP completion (in all cases atm inc pending) */ |
|
ret = wait_event_timeout(msg->waitq, msg->complete, |
|
msecs_to_jiffies(IPC_TIMEOUT_MSECS)); |
|
|
|
spin_lock_irqsave(&ipc->dsp->spinlock, flags); |
|
if (ret == 0) { |
|
if (ipc->ops.shim_dbg != NULL) |
|
ipc->ops.shim_dbg(ipc, "message timeout"); |
|
|
|
list_del(&msg->list); |
|
ret = -ETIMEDOUT; |
|
} else { |
|
|
|
/* copy the data returned from DSP */ |
|
if (reply) { |
|
reply->header = msg->rx.header; |
|
if (reply->data) |
|
memcpy(reply->data, msg->rx.data, msg->rx.size); |
|
} |
|
ret = msg->errno; |
|
} |
|
|
|
list_add_tail(&msg->list, &ipc->empty_list); |
|
spin_unlock_irqrestore(&ipc->dsp->spinlock, flags); |
|
return ret; |
|
} |
|
|
|
static int ipc_tx_message(struct sst_generic_ipc *ipc, |
|
struct sst_ipc_message request, |
|
struct sst_ipc_message *reply, int wait) |
|
{ |
|
struct ipc_message *msg; |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&ipc->dsp->spinlock, flags); |
|
|
|
msg = msg_get_empty(ipc); |
|
if (msg == NULL) { |
|
spin_unlock_irqrestore(&ipc->dsp->spinlock, flags); |
|
return -EBUSY; |
|
} |
|
|
|
msg->tx.header = request.header; |
|
msg->tx.size = request.size; |
|
msg->rx.header = 0; |
|
msg->rx.size = reply ? reply->size : 0; |
|
msg->wait = wait; |
|
msg->errno = 0; |
|
msg->pending = false; |
|
msg->complete = false; |
|
|
|
if ((request.size) && (ipc->ops.tx_data_copy != NULL)) |
|
ipc->ops.tx_data_copy(msg, request.data, request.size); |
|
|
|
list_add_tail(&msg->list, &ipc->tx_list); |
|
schedule_work(&ipc->kwork); |
|
spin_unlock_irqrestore(&ipc->dsp->spinlock, flags); |
|
|
|
if (wait) |
|
return tx_wait_done(ipc, msg, reply); |
|
else |
|
return 0; |
|
} |
|
|
|
static int msg_empty_list_init(struct sst_generic_ipc *ipc) |
|
{ |
|
int i; |
|
|
|
ipc->msg = kcalloc(IPC_EMPTY_LIST_SIZE, sizeof(struct ipc_message), |
|
GFP_KERNEL); |
|
if (ipc->msg == NULL) |
|
return -ENOMEM; |
|
|
|
for (i = 0; i < IPC_EMPTY_LIST_SIZE; i++) { |
|
ipc->msg[i].tx.data = kzalloc(ipc->tx_data_max_size, GFP_KERNEL); |
|
if (ipc->msg[i].tx.data == NULL) |
|
goto free_mem; |
|
|
|
ipc->msg[i].rx.data = kzalloc(ipc->rx_data_max_size, GFP_KERNEL); |
|
if (ipc->msg[i].rx.data == NULL) { |
|
kfree(ipc->msg[i].tx.data); |
|
goto free_mem; |
|
} |
|
|
|
init_waitqueue_head(&ipc->msg[i].waitq); |
|
list_add(&ipc->msg[i].list, &ipc->empty_list); |
|
} |
|
|
|
return 0; |
|
|
|
free_mem: |
|
while (i > 0) { |
|
kfree(ipc->msg[i-1].tx.data); |
|
kfree(ipc->msg[i-1].rx.data); |
|
--i; |
|
} |
|
kfree(ipc->msg); |
|
|
|
return -ENOMEM; |
|
} |
|
|
|
static void ipc_tx_msgs(struct work_struct *work) |
|
{ |
|
struct sst_generic_ipc *ipc = |
|
container_of(work, struct sst_generic_ipc, kwork); |
|
struct ipc_message *msg; |
|
|
|
spin_lock_irq(&ipc->dsp->spinlock); |
|
|
|
while (!list_empty(&ipc->tx_list) && !ipc->pending) { |
|
/* if the DSP is busy, we will TX messages after IRQ. |
|
* also postpone if we are in the middle of processing |
|
* completion irq |
|
*/ |
|
if (ipc->ops.is_dsp_busy && ipc->ops.is_dsp_busy(ipc->dsp)) { |
|
dev_dbg(ipc->dev, "ipc_tx_msgs dsp busy\n"); |
|
break; |
|
} |
|
|
|
msg = list_first_entry(&ipc->tx_list, struct ipc_message, list); |
|
list_move(&msg->list, &ipc->rx_list); |
|
|
|
if (ipc->ops.tx_msg != NULL) |
|
ipc->ops.tx_msg(ipc, msg); |
|
} |
|
|
|
spin_unlock_irq(&ipc->dsp->spinlock); |
|
} |
|
|
|
int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc, |
|
struct sst_ipc_message request, struct sst_ipc_message *reply) |
|
{ |
|
int ret; |
|
|
|
/* |
|
* DSP maybe in lower power active state, so |
|
* check if the DSP supports DSP lp On method |
|
* if so invoke that before sending IPC |
|
*/ |
|
if (ipc->ops.check_dsp_lp_on) |
|
if (ipc->ops.check_dsp_lp_on(ipc->dsp, true)) |
|
return -EIO; |
|
|
|
ret = ipc_tx_message(ipc, request, reply, 1); |
|
|
|
if (ipc->ops.check_dsp_lp_on) |
|
if (ipc->ops.check_dsp_lp_on(ipc->dsp, false)) |
|
return -EIO; |
|
|
|
return ret; |
|
} |
|
EXPORT_SYMBOL_GPL(sst_ipc_tx_message_wait); |
|
|
|
int sst_ipc_tx_message_nowait(struct sst_generic_ipc *ipc, |
|
struct sst_ipc_message request) |
|
{ |
|
return ipc_tx_message(ipc, request, NULL, 0); |
|
} |
|
EXPORT_SYMBOL_GPL(sst_ipc_tx_message_nowait); |
|
|
|
int sst_ipc_tx_message_nopm(struct sst_generic_ipc *ipc, |
|
struct sst_ipc_message request, struct sst_ipc_message *reply) |
|
{ |
|
return ipc_tx_message(ipc, request, reply, 1); |
|
} |
|
EXPORT_SYMBOL_GPL(sst_ipc_tx_message_nopm); |
|
|
|
struct ipc_message *sst_ipc_reply_find_msg(struct sst_generic_ipc *ipc, |
|
u64 header) |
|
{ |
|
struct ipc_message *msg; |
|
u64 mask; |
|
|
|
if (ipc->ops.reply_msg_match != NULL) |
|
header = ipc->ops.reply_msg_match(header, &mask); |
|
else |
|
mask = (u64)-1; |
|
|
|
if (list_empty(&ipc->rx_list)) { |
|
dev_err(ipc->dev, "error: rx list empty but received 0x%llx\n", |
|
header); |
|
return NULL; |
|
} |
|
|
|
list_for_each_entry(msg, &ipc->rx_list, list) { |
|
if ((msg->tx.header & mask) == header) |
|
return msg; |
|
} |
|
|
|
return NULL; |
|
} |
|
EXPORT_SYMBOL_GPL(sst_ipc_reply_find_msg); |
|
|
|
/* locks held by caller */ |
|
void sst_ipc_tx_msg_reply_complete(struct sst_generic_ipc *ipc, |
|
struct ipc_message *msg) |
|
{ |
|
msg->complete = true; |
|
|
|
if (!msg->wait) |
|
list_add_tail(&msg->list, &ipc->empty_list); |
|
else |
|
wake_up(&msg->waitq); |
|
} |
|
EXPORT_SYMBOL_GPL(sst_ipc_tx_msg_reply_complete); |
|
|
|
int sst_ipc_init(struct sst_generic_ipc *ipc) |
|
{ |
|
int ret; |
|
|
|
INIT_LIST_HEAD(&ipc->tx_list); |
|
INIT_LIST_HEAD(&ipc->rx_list); |
|
INIT_LIST_HEAD(&ipc->empty_list); |
|
init_waitqueue_head(&ipc->wait_txq); |
|
|
|
ret = msg_empty_list_init(ipc); |
|
if (ret < 0) |
|
return -ENOMEM; |
|
|
|
INIT_WORK(&ipc->kwork, ipc_tx_msgs); |
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(sst_ipc_init); |
|
|
|
void sst_ipc_fini(struct sst_generic_ipc *ipc) |
|
{ |
|
int i; |
|
|
|
cancel_work_sync(&ipc->kwork); |
|
|
|
if (ipc->msg) { |
|
for (i = 0; i < IPC_EMPTY_LIST_SIZE; i++) { |
|
kfree(ipc->msg[i].tx.data); |
|
kfree(ipc->msg[i].rx.data); |
|
} |
|
kfree(ipc->msg); |
|
} |
|
} |
|
EXPORT_SYMBOL_GPL(sst_ipc_fini); |
|
|
|
/* Module information */ |
|
MODULE_AUTHOR("Jin Yao"); |
|
MODULE_DESCRIPTION("Intel SST IPC generic"); |
|
MODULE_LICENSE("GPL v2");
|
|
|