audio-lnx: Rename folders to new flat structure.
Kernel audio drivers can be categorised into below folders.
asoc - ALSA based drivers,
asoc/codecs - codec drivers,
ipc - APR IPC communication drivers,
dsp - DSP low level drivers/Audio ION/ADSP Loader,
dsp/codecs - Native encoders and decoders,
soc - SoC based drivers(pinctrl/regmap/soundwire)
Restructure drivers to above folder format.
Include directories also follow above format.
Change-Id: I8fa0857baaacd47db126fb5c1f1f5ed7e886dbc0
Signed-off-by: Laxminath Kasam <lkasam@codeaurora.org>
diff --git a/ipc/apr_tal_glink.c b/ipc/apr_tal_glink.c
new file mode 100644
index 0000000..f99f9ed
--- /dev/null
+++ b/ipc/apr_tal_glink.c
@@ -0,0 +1,451 @@
+/*
+ * Copyright (c) 2016-2017 The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/uaccess.h>
+#include <linux/spinlock.h>
+#include <linux/mutex.h>
+#include <linux/sched.h>
+#include <linux/wait.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/slab.h>
+#include <linux/debugfs.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/clk.h>
+#include <soc/qcom/glink.h>
+#include <ipc/apr_tal.h>
+
+#define APR_MAXIMUM_NUM_OF_RETRIES 2
+
+struct apr_tx_buf {
+ struct apr_pkt_priv pkt_priv;
+ char buf[APR_MAX_BUF];
+};
+
+struct link_state {
+ uint32_t dest;
+ void *handle;
+ enum glink_link_state link_state;
+ wait_queue_head_t wait;
+};
+
+static struct link_state link_state[APR_DEST_MAX];
+
+static char *svc_names[APR_DEST_MAX][APR_CLIENT_MAX] = {
+ {
+ "apr_audio_svc",
+ "apr_voice_svc",
+ },
+ {
+ "apr_audio_svc",
+ "apr_voice_svc",
+ },
+};
+
+static struct apr_svc_ch_dev
+ apr_svc_ch[APR_DL_MAX][APR_DEST_MAX][APR_CLIENT_MAX];
+
+static struct apr_tx_buf *apr_alloc_buf(int len)
+{
+
+ if (len > APR_MAX_BUF) {
+ pr_err("%s: buf too large [%d]\n", __func__, len);
+ return ERR_PTR(-EINVAL);
+ }
+
+ return kzalloc(sizeof(struct apr_tx_buf), GFP_ATOMIC);
+}
+
+static void apr_free_buf(const void *ptr)
+{
+
+ struct apr_pkt_priv *apr_pkt_priv = (struct apr_pkt_priv *)ptr;
+ struct apr_tx_buf *tx_buf;
+
+ if (!apr_pkt_priv) {
+ pr_err("%s: Invalid apr_pkt_priv\n", __func__);
+ return;
+ }
+
+ if (apr_pkt_priv->pkt_owner == APR_PKT_OWNER_DRIVER) {
+ tx_buf = container_of((void *)apr_pkt_priv,
+ struct apr_tx_buf, pkt_priv);
+ pr_debug("%s: Freeing buffer %pK", __func__, tx_buf);
+ kfree(tx_buf);
+ }
+}
+
+
+static int __apr_tal_write(struct apr_svc_ch_dev *apr_ch, void *data,
+ struct apr_pkt_priv *pkt_priv, int len)
+{
+ int rc = 0;
+ unsigned long flags;
+
+ spin_lock_irqsave(&apr_ch->w_lock, flags);
+ rc = glink_tx(apr_ch->handle, pkt_priv, data, len, GLINK_TX_ATOMIC);
+ spin_unlock_irqrestore(&apr_ch->w_lock, flags);
+
+ if (rc)
+ pr_err("%s: glink_tx failed, rc[%d]\n", __func__, rc);
+ else
+ rc = len;
+
+ return rc;
+}
+
+int apr_tal_write(struct apr_svc_ch_dev *apr_ch, void *data,
+ struct apr_pkt_priv *pkt_priv, int len)
+{
+ int rc = 0, retries = 0;
+ void *pkt_data = NULL;
+ struct apr_tx_buf *tx_buf = NULL;
+ struct apr_pkt_priv *pkt_priv_ptr = pkt_priv;
+
+ if (!apr_ch->handle || !pkt_priv)
+ return -EINVAL;
+
+ if (pkt_priv->pkt_owner == APR_PKT_OWNER_DRIVER) {
+ tx_buf = apr_alloc_buf(len);
+ if (IS_ERR_OR_NULL(tx_buf)) {
+ rc = -EINVAL;
+ goto exit;
+ }
+ memcpy(tx_buf->buf, data, len);
+ memcpy(&tx_buf->pkt_priv, pkt_priv, sizeof(tx_buf->pkt_priv));
+ pkt_priv_ptr = &tx_buf->pkt_priv;
+ pkt_data = tx_buf->buf;
+ } else {
+ pkt_data = data;
+ }
+
+ do {
+ if (rc == -EAGAIN)
+ udelay(50);
+
+ rc = __apr_tal_write(apr_ch, pkt_data, pkt_priv_ptr, len);
+ } while (rc == -EAGAIN && retries++ < APR_MAXIMUM_NUM_OF_RETRIES);
+
+ if (rc < 0) {
+ pr_err("%s: Unable to send the packet, rc:%d\n", __func__, rc);
+ if (pkt_priv->pkt_owner == APR_PKT_OWNER_DRIVER)
+ kfree(tx_buf);
+ }
+exit:
+ return rc;
+}
+
+void apr_tal_notify_rx(void *handle, const void *priv, const void *pkt_priv,
+ const void *ptr, size_t size)
+{
+ struct apr_svc_ch_dev *apr_ch = (struct apr_svc_ch_dev *)priv;
+ unsigned long flags;
+
+ if (!apr_ch || !ptr) {
+ pr_err("%s: Invalid apr_ch or ptr\n", __func__);
+ return;
+ }
+
+ pr_debug("%s: Rx packet received\n", __func__);
+
+ spin_lock_irqsave(&apr_ch->r_lock, flags);
+ if (apr_ch->func)
+ apr_ch->func((void *)ptr, size, (void *)pkt_priv);
+ spin_unlock_irqrestore(&apr_ch->r_lock, flags);
+ glink_rx_done(apr_ch->handle, ptr, true);
+}
+
+static void apr_tal_notify_tx_abort(void *handle, const void *priv,
+ const void *pkt_priv)
+{
+ pr_debug("%s: tx_abort received for pkt_priv:%pK\n",
+ __func__, pkt_priv);
+ apr_free_buf(pkt_priv);
+}
+
+void apr_tal_notify_tx_done(void *handle, const void *priv,
+ const void *pkt_priv, const void *ptr)
+{
+ pr_debug("%s: tx_done received for pkt_priv:%pK\n",
+ __func__, pkt_priv);
+ apr_free_buf(pkt_priv);
+}
+
+bool apr_tal_notify_rx_intent_req(void *handle, const void *priv,
+ size_t req_size)
+{
+ struct apr_svc_ch_dev *apr_ch = (struct apr_svc_ch_dev *)priv;
+
+ if (!apr_ch) {
+ pr_err("%s: Invalid apr_ch\n", __func__);
+ return false;
+ }
+
+ pr_err("%s: No rx intents queued, unable to receive\n", __func__);
+ return false;
+}
+
+static void apr_tal_notify_remote_rx_intent(void *handle, const void *priv,
+ size_t size)
+{
+ struct apr_svc_ch_dev *apr_ch = (struct apr_svc_ch_dev *)priv;
+
+ if (!apr_ch) {
+ pr_err("%s: Invalid apr_ch\n", __func__);
+ return;
+ }
+ /*
+ * This is to make sure that the far end has queued at least one intent
+ * before we attmpt any IPC. A simple bool flag is used here instead of
+ * a counter, as the far end is required to guarantee intent
+ * availability for all use cases once the channel is fully opened.
+ */
+ pr_debug("%s: remote queued an intent\n", __func__);
+ apr_ch->if_remote_intent_ready = true;
+ wake_up(&apr_ch->wait);
+}
+
+void apr_tal_notify_state(void *handle, const void *priv, unsigned int event)
+{
+ struct apr_svc_ch_dev *apr_ch = (struct apr_svc_ch_dev *)priv;
+
+ if (!apr_ch) {
+ pr_err("%s: Invalid apr_ch\n", __func__);
+ return;
+ }
+
+ apr_ch->channel_state = event;
+ pr_info("%s: Channel state[%d]\n", __func__, event);
+
+ if (event == GLINK_CONNECTED)
+ wake_up(&apr_ch->wait);
+}
+
+int apr_tal_rx_intents_config(struct apr_svc_ch_dev *apr_ch,
+ int num_of_intents, uint32_t size)
+{
+ int i;
+ int rc;
+
+ if (!apr_ch || !num_of_intents || !size) {
+ pr_err("%s: Invalid parameter\n", __func__);
+ return -EINVAL;
+ }
+
+ for (i = 0; i < num_of_intents; i++) {
+ rc = glink_queue_rx_intent(apr_ch->handle, apr_ch, size);
+ if (rc) {
+ pr_err("%s: Failed to queue rx intent, iteration[%d]\n",
+ __func__, i);
+ break;
+ }
+ }
+
+ return rc;
+}
+
+struct apr_svc_ch_dev *apr_tal_open(uint32_t clnt, uint32_t dest, uint32_t dl,
+ apr_svc_cb_fn func, void *priv)
+{
+ int rc;
+ struct glink_open_config open_cfg;
+ struct apr_svc_ch_dev *apr_ch;
+
+ if ((clnt >= APR_CLIENT_MAX) || (dest >= APR_DEST_MAX) ||
+ (dl >= APR_DL_MAX)) {
+ pr_err("%s: Invalid params, clnt:%d, dest:%d, dl:%d\n",
+ __func__, clnt, dest, dl);
+ return NULL;
+ }
+
+ apr_ch = &apr_svc_ch[dl][dest][clnt];
+ mutex_lock(&apr_ch->m_lock);
+ if (apr_ch->handle) {
+ pr_err("%s: This channel is already opened\n", __func__);
+ rc = -EBUSY;
+ goto unlock;
+ }
+
+ if (link_state[dest].link_state != GLINK_LINK_STATE_UP) {
+ rc = wait_event_timeout(link_state[dest].wait,
+ link_state[dest].link_state == GLINK_LINK_STATE_UP,
+ msecs_to_jiffies(APR_OPEN_TIMEOUT_MS));
+ if (rc == 0) {
+ pr_err("%s: Open timeout, dest:%d\n", __func__, dest);
+ rc = -ETIMEDOUT;
+ goto unlock;
+ }
+ pr_debug("%s: Wakeup done, dest:%d\n", __func__, dest);
+ }
+
+ memset(&open_cfg, 0, sizeof(struct glink_open_config));
+ open_cfg.options = GLINK_OPT_INITIAL_XPORT;
+ if (dest == APR_DEST_MODEM)
+ open_cfg.edge = "mpss";
+ else
+ open_cfg.edge = "lpass";
+
+ open_cfg.name = svc_names[dest][clnt];
+ open_cfg.notify_rx = apr_tal_notify_rx;
+ open_cfg.notify_tx_done = apr_tal_notify_tx_done;
+ open_cfg.notify_state = apr_tal_notify_state;
+ open_cfg.notify_rx_intent_req = apr_tal_notify_rx_intent_req;
+ open_cfg.notify_remote_rx_intent = apr_tal_notify_remote_rx_intent;
+ open_cfg.notify_tx_abort = apr_tal_notify_tx_abort;
+ open_cfg.priv = apr_ch;
+ open_cfg.transport = "smem";
+
+ apr_ch->channel_state = GLINK_REMOTE_DISCONNECTED;
+ apr_ch->handle = glink_open(&open_cfg);
+ if (IS_ERR_OR_NULL(apr_ch->handle)) {
+ pr_err("%s: glink_open failed %s\n", __func__,
+ svc_names[dest][clnt]);
+ apr_ch->handle = NULL;
+ rc = -EINVAL;
+ goto unlock;
+ }
+
+ rc = wait_event_timeout(apr_ch->wait,
+ (apr_ch->channel_state == GLINK_CONNECTED), 5 * HZ);
+ if (rc == 0) {
+ pr_err("%s: TIMEOUT for OPEN event\n", __func__);
+ rc = -ETIMEDOUT;
+ goto close_link;
+ }
+
+ /*
+ * Remote intent is not required for GLINK <--> SMD IPC, so this is
+ * designed not to fail the open call.
+ */
+ rc = wait_event_timeout(apr_ch->wait,
+ apr_ch->if_remote_intent_ready, 5 * HZ);
+ if (rc == 0)
+ pr_err("%s: TIMEOUT for remote intent readiness\n", __func__);
+
+ rc = apr_tal_rx_intents_config(apr_ch, APR_DEFAULT_NUM_OF_INTENTS,
+ APR_MAX_BUF);
+ if (rc) {
+ pr_err("%s: Unable to queue intents\n", __func__);
+ goto close_link;
+ }
+
+ apr_ch->func = func;
+ apr_ch->priv = priv;
+
+close_link:
+ if (rc) {
+ glink_close(apr_ch->handle);
+ apr_ch->handle = NULL;
+ }
+unlock:
+ mutex_unlock(&apr_ch->m_lock);
+
+ return rc ? NULL : apr_ch;
+}
+
+int apr_tal_close(struct apr_svc_ch_dev *apr_ch)
+{
+ int rc;
+
+ if (!apr_ch || !apr_ch->handle) {
+ rc = -EINVAL;
+ goto exit;
+ }
+
+ mutex_lock(&apr_ch->m_lock);
+ rc = glink_close(apr_ch->handle);
+ apr_ch->handle = NULL;
+ apr_ch->func = NULL;
+ apr_ch->priv = NULL;
+ apr_ch->if_remote_intent_ready = false;
+ mutex_unlock(&apr_ch->m_lock);
+exit:
+ return rc;
+}
+
+static void apr_tal_link_state_cb(struct glink_link_state_cb_info *cb_info,
+ void *priv)
+{
+ uint32_t dest;
+
+ if (!cb_info) {
+ pr_err("%s: Invalid cb_info\n", __func__);
+ return;
+ }
+
+ if (!strcmp(cb_info->edge, "mpss"))
+ dest = APR_DEST_MODEM;
+ else if (!strcmp(cb_info->edge, "lpass"))
+ dest = APR_DEST_QDSP6;
+ else {
+ pr_err("%s:Unknown edge[%s]\n", __func__, cb_info->edge);
+ return;
+ }
+
+ pr_info("%s: edge[%s] link state[%d]\n", __func__, cb_info->edge,
+ cb_info->link_state);
+
+ link_state[dest].link_state = cb_info->link_state;
+ if (link_state[dest].link_state == GLINK_LINK_STATE_UP)
+ wake_up(&link_state[dest].wait);
+}
+
+static struct glink_link_info mpss_link_info = {
+ .transport = "smem",
+ .edge = "mpss",
+ .glink_link_state_notif_cb = apr_tal_link_state_cb,
+};
+
+static struct glink_link_info lpass_link_info = {
+ .transport = "smem",
+ .edge = "lpass",
+ .glink_link_state_notif_cb = apr_tal_link_state_cb,
+};
+
+static int __init apr_tal_init(void)
+{
+ int i, j, k;
+
+ for (i = 0; i < APR_DL_MAX; i++) {
+ for (j = 0; j < APR_DEST_MAX; j++) {
+ for (k = 0; k < APR_CLIENT_MAX; k++) {
+ init_waitqueue_head(&apr_svc_ch[i][j][k].wait);
+ spin_lock_init(&apr_svc_ch[i][j][k].w_lock);
+ spin_lock_init(&apr_svc_ch[i][j][k].r_lock);
+ mutex_init(&apr_svc_ch[i][j][k].m_lock);
+ }
+ }
+ }
+
+ for (i = 0; i < APR_DEST_MAX; i++)
+ init_waitqueue_head(&link_state[i].wait);
+
+ link_state[APR_DEST_MODEM].link_state = GLINK_LINK_STATE_DOWN;
+ link_state[APR_DEST_MODEM].handle =
+ glink_register_link_state_cb(&mpss_link_info, NULL);
+ if (!link_state[APR_DEST_MODEM].handle)
+ pr_err("%s: Unable to register mpss link state\n", __func__);
+
+ link_state[APR_DEST_QDSP6].link_state = GLINK_LINK_STATE_DOWN;
+ link_state[APR_DEST_QDSP6].handle =
+ glink_register_link_state_cb(&lpass_link_info, NULL);
+ if (!link_state[APR_DEST_QDSP6].handle)
+ pr_err("%s: Unable to register lpass link state\n", __func__);
+
+ return 0;
+}
+device_initcall(apr_tal_init);