From: Srinivas Kandagatla srinivas.kandagatla@linaro.org

This patch adds support to q6 AFE (Audio Front End) module on Q6DSP.

AFE module sits right at the other end of cpu where the codec/audio devices are connected.

AFE provides abstraced interfaces to both hardware and virtual devices. Each AFE tx/rx port can be configured to connect to one of the hardware devices like codec, hdmi, slimbus, i2s and so on. AFE services include starting, stopping, and if needed, any configurations of the ports.

Signed-off-by: Srinivas Kandagatla srinivas.kandagatla@linaro.org --- .../devicetree/bindings/sound/qcom,q6afe.txt | 15 + include/dt-bindings/sound/qcom,afe.h | 8 + sound/soc/qcom/Kconfig | 13 + sound/soc/qcom/Makefile | 3 + sound/soc/qcom/qdsp6v2/Makefile | 1 + sound/soc/qcom/qdsp6v2/common.h | 225 ++++++++++ sound/soc/qcom/qdsp6v2/q6afe-v2.h | 62 +++ sound/soc/qcom/qdsp6v2/q6afe.c | 499 +++++++++++++++++++++ 8 files changed, 826 insertions(+) create mode 100644 Documentation/devicetree/bindings/sound/qcom,q6afe.txt create mode 100644 include/dt-bindings/sound/qcom,afe.h create mode 100644 sound/soc/qcom/qdsp6v2/Makefile create mode 100644 sound/soc/qcom/qdsp6v2/common.h create mode 100644 sound/soc/qcom/qdsp6v2/q6afe-v2.h create mode 100644 sound/soc/qcom/qdsp6v2/q6afe.c

diff --git a/Documentation/devicetree/bindings/sound/qcom,q6afe.txt b/Documentation/devicetree/bindings/sound/qcom,q6afe.txt new file mode 100644 index 0000000..0ae5771 --- /dev/null +++ b/Documentation/devicetree/bindings/sound/qcom,q6afe.txt @@ -0,0 +1,15 @@ +Qualcomm Q6AFE (Q6 Audio FrontEnd) binding + +This bindings describe the Qualcomm Q6 AFE module on QDSP, +which is used by audio drivers. + +- compatible: + + Usage: required + Value type: <stringlist> + Definition: must be "qcom,q6afe-v<VERSION-NUMBER>" example: "qcom,q6asm-v2" + += EXAMPLE + q6afe { + compatible = "qcom,q6afe-v2"; + }; diff --git a/include/dt-bindings/sound/qcom,afe.h b/include/dt-bindings/sound/qcom,afe.h new file mode 100644 index 0000000..2e58cde --- /dev/null +++ b/include/dt-bindings/sound/qcom,afe.h @@ -0,0 +1,8 @@ +#ifndef __DT_AFE_H__ +#define __DT_AFE_H__ + +/* Audio Front End (AFE) Ports */ +#define AFE_PORT_HDMI_RX 8 +#define AFE_PORT_MAX 9 + +#endif diff --git a/sound/soc/qcom/Kconfig b/sound/soc/qcom/Kconfig index 8ec9a07..dad3fa1 100644 --- a/sound/soc/qcom/Kconfig +++ b/sound/soc/qcom/Kconfig @@ -43,3 +43,16 @@ config SND_SOC_APQ8016_SBC Support for Qualcomm Technologies LPASS audio block in APQ8016 SOC-based systems. Say Y if you want to use audio devices on MI2S. + +config SND_SOC_QDSP6V2_AFE + tristate + default n + +config SND_SOC_QDSP6V2 + tristate "SoC ALSA audio driver for QDSP6V2" + select SND_SOC_QDSP6V2_AFE + help + To add support for MSM QDSP6V2 Soc Audio. + This will enable sound soc platform specific + audio drivers. This includes q6asm, q6adm, + q6afe interfaces to DSP using apr. diff --git a/sound/soc/qcom/Makefile b/sound/soc/qcom/Makefile index 79e5c50..a51bf0a 100644 --- a/sound/soc/qcom/Makefile +++ b/sound/soc/qcom/Makefile @@ -15,3 +15,6 @@ snd-soc-apq8016-sbc-objs := apq8016_sbc.o

obj-$(CONFIG_SND_SOC_STORM) += snd-soc-storm.o obj-$(CONFIG_SND_SOC_APQ8016_SBC) += snd-soc-apq8016-sbc.o + +#DSP lib +obj-$(CONFIG_SND_SOC_QDSP6V2) += qdsp6v2/ diff --git a/sound/soc/qcom/qdsp6v2/Makefile b/sound/soc/qcom/qdsp6v2/Makefile new file mode 100644 index 0000000..8069891 --- /dev/null +++ b/sound/soc/qcom/qdsp6v2/Makefile @@ -0,0 +1 @@ +obj-$(CONFIG_SND_SOC_QDSP6V2_AFE) += q6afe.o diff --git a/sound/soc/qcom/qdsp6v2/common.h b/sound/soc/qcom/qdsp6v2/common.h new file mode 100644 index 0000000..cbd6e00 --- /dev/null +++ b/sound/soc/qcom/qdsp6v2/common.h @@ -0,0 +1,225 @@ +/* + * Copyright (c) 2015-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. + */ +#ifndef __Q6DSP_COMMON_H__ +#define __Q6DSP_COMMON_H__ + +/* ERROR CODES */ +/* Success. The operation completed with no errors. */ +#define ADSP_EOK 0x00000000 +/* General failure. */ +#define ADSP_EFAILED 0x00000001 +/* Bad operation parameter. */ +#define ADSP_EBADPARAM 0x00000002 +/* Unsupported routine or operation. */ +#define ADSP_EUNSUPPORTED 0x00000003 +/* Unsupported version. */ +#define ADSP_EVERSION 0x00000004 +/* Unexpected problem encountered. */ +#define ADSP_EUNEXPECTED 0x00000005 +/* Unhandled problem occurred. */ +#define ADSP_EPANIC 0x00000006 +/* Unable to allocate resource. */ +#define ADSP_ENORESOURCE 0x00000007 +/* Invalid handle. */ +#define ADSP_EHANDLE 0x00000008 +/* Operation is already processed. */ +#define ADSP_EALREADY 0x00000009 +/* Operation is not ready to be processed. */ +#define ADSP_ENOTREADY 0x0000000A +/* Operation is pending completion. */ +#define ADSP_EPENDING 0x0000000B +/* Operation could not be accepted or processed. */ +#define ADSP_EBUSY 0x0000000C +/* Operation aborted due to an error. */ +#define ADSP_EABORTED 0x0000000D +/* Operation preempted by a higher priority. */ +#define ADSP_EPREEMPTED 0x0000000E +/* Operation requests intervention to complete. */ +#define ADSP_ECONTINUE 0x0000000F +/* Operation requests immediate intervention to complete. */ +#define ADSP_EIMMEDIATE 0x00000010 +/* Operation is not implemented. */ +#define ADSP_ENOTIMPL 0x00000011 +/* Operation needs more data or resources. */ +#define ADSP_ENEEDMORE 0x00000012 +/* Operation does not have memory. */ +#define ADSP_ENOMEMORY 0x00000014 +/* Item does not exist. */ +#define ADSP_ENOTEXIST 0x00000015 +/* Max count for adsp error code sent to HLOS*/ +#define ADSP_ERR_MAX (ADSP_ENOTEXIST + 1) +/* Operation is finished. */ +#define ADSP_ETERMINATED 0x00011174 + +/* ERROR STRING */ +/* Success. The operation completed with no errors. */ +#define ADSP_EOK_STR "ADSP_EOK" +/* General failure. */ +#define ADSP_EFAILED_STR "ADSP_EFAILED" +/* Bad operation parameter. */ +#define ADSP_EBADPARAM_STR "ADSP_EBADPARAM" +/* Unsupported routine or operation. */ +#define ADSP_EUNSUPPORTED_STR "ADSP_EUNSUPPORTED" +/* Unsupported version. */ +#define ADSP_EVERSION_STR "ADSP_EVERSION" +/* Unexpected problem encountered. */ +#define ADSP_EUNEXPECTED_STR "ADSP_EUNEXPECTED" +/* Unhandled problem occurred. */ +#define ADSP_EPANIC_STR "ADSP_EPANIC" +/* Unable to allocate resource. */ +#define ADSP_ENORESOURCE_STR "ADSP_ENORESOURCE" +/* Invalid handle. */ +#define ADSP_EHANDLE_STR "ADSP_EHANDLE" +/* Operation is already processed. */ +#define ADSP_EALREADY_STR "ADSP_EALREADY" +/* Operation is not ready to be processed. */ +#define ADSP_ENOTREADY_STR "ADSP_ENOTREADY" +/* Operation is pending completion. */ +#define ADSP_EPENDING_STR "ADSP_EPENDING" +/* Operation could not be accepted or processed. */ +#define ADSP_EBUSY_STR "ADSP_EBUSY" +/* Operation aborted due to an error. */ +#define ADSP_EABORTED_STR "ADSP_EABORTED" +/* Operation preempted by a higher priority. */ +#define ADSP_EPREEMPTED_STR "ADSP_EPREEMPTED" +/* Operation requests intervention to complete. */ +#define ADSP_ECONTINUE_STR "ADSP_ECONTINUE" +/* Operation requests immediate intervention to complete. */ +#define ADSP_EIMMEDIATE_STR "ADSP_EIMMEDIATE" +/* Operation is not implemented. */ +#define ADSP_ENOTIMPL_STR "ADSP_ENOTIMPL" +/* Operation needs more data or resources. */ +#define ADSP_ENEEDMORE_STR "ADSP_ENEEDMORE" +/* Operation does not have memory. */ +#define ADSP_ENOMEMORY_STR "ADSP_ENOMEMORY" +/* Item does not exist. */ +#define ADSP_ENOTEXIST_STR "ADSP_ENOTEXIST" +/* Unexpected error code. */ +#define ADSP_ERR_MAX_STR "ADSP_ERR_MAX" + +#define PCM_FORMAT_MAX_NUM_CHANNEL 8 +#define PCM_CHANNEL_NULL 0 + +#define PCM_CHANNEL_FL 1 /* Front left channel. */ +#define PCM_CHANNEL_FR 2 /* Front right channel. */ +#define PCM_CHANNEL_FC 3 /* Front center channel. */ +#define PCM_CHANNEL_LS 4 /* Left surround channel. */ +#define PCM_CHANNEL_RS 5 /* Right surround channel. */ +#define PCM_CHANNEL_LFE 6 /* Low frequency effect channel. */ +#define PCM_CHANNEL_CS 7 /* Center surround channel; Rear center ch */ +#define PCM_CHANNEL_LB 8 /* Left back channel; Rear left channel. */ +#define PCM_CHANNEL_RB 9 /* Right back channel; Rear right channel. */ +#define PCM_CHANNELS 10 /* Top surround channel. */ + +static inline int q6dsp_map_channels(u8 *ch_map, int ch) +{ + memset(ch_map, 0, PCM_FORMAT_MAX_NUM_CHANNEL); + + if (ch == 1) { + ch_map[0] = PCM_CHANNEL_FC; + } else if (ch == 2) { + ch_map[0] = PCM_CHANNEL_FL; + ch_map[1] = PCM_CHANNEL_FR; + } else if (ch == 3) { + ch_map[0] = PCM_CHANNEL_FL; + ch_map[1] = PCM_CHANNEL_FR; + ch_map[2] = PCM_CHANNEL_FC; + } else if (ch == 4) { + ch_map[0] = PCM_CHANNEL_FL; + ch_map[1] = PCM_CHANNEL_FR; + ch_map[2] = PCM_CHANNEL_LS; + ch_map[3] = PCM_CHANNEL_RS; + } else if (ch == 5) { + ch_map[0] = PCM_CHANNEL_FL; + ch_map[1] = PCM_CHANNEL_FR; + ch_map[2] = PCM_CHANNEL_FC; + ch_map[3] = PCM_CHANNEL_LS; + ch_map[4] = PCM_CHANNEL_RS; + } else if (ch == 6) { + ch_map[0] = PCM_CHANNEL_FL; + ch_map[1] = PCM_CHANNEL_FR; + ch_map[2] = PCM_CHANNEL_LFE; + ch_map[3] = PCM_CHANNEL_FC; + ch_map[4] = PCM_CHANNEL_LS; + ch_map[5] = PCM_CHANNEL_RS; + } else if (ch == 8) { + ch_map[0] = PCM_CHANNEL_FL; + ch_map[1] = PCM_CHANNEL_FR; + ch_map[2] = PCM_CHANNEL_LFE; + ch_map[3] = PCM_CHANNEL_FC; + ch_map[4] = PCM_CHANNEL_LS; + ch_map[5] = PCM_CHANNEL_RS; + ch_map[6] = PCM_CHANNEL_LB; + ch_map[7] = PCM_CHANNEL_RB; + } else { + return -EINVAL; + } + + return 0; +} + +enum { + LEGACY_PCM_MODE = 0, + LOW_LATENCY_PCM_MODE, + ULTRA_LOW_LATENCY_PCM_MODE, + ULL_POST_PROCESSING_PCM_MODE, +}; + +struct adsp_err_code { + int lnx_err_code; + char *adsp_err_str; +}; + +static struct adsp_err_code adsp_err_code_info[ADSP_ERR_MAX+1] = { + { 0, ADSP_EOK_STR}, + { -ENOTRECOVERABLE, ADSP_EFAILED_STR}, + { -EINVAL, ADSP_EBADPARAM_STR}, + { -ENOSYS, ADSP_EUNSUPPORTED_STR}, + { -ENOPROTOOPT, ADSP_EVERSION_STR}, + { -ENOTRECOVERABLE, ADSP_EUNEXPECTED_STR}, + { -ENOTRECOVERABLE, ADSP_EPANIC_STR}, + { -ENOSPC, ADSP_ENORESOURCE_STR}, + { -EBADR, ADSP_EHANDLE_STR}, + { -EALREADY, ADSP_EALREADY_STR}, + { -EPERM, ADSP_ENOTREADY_STR}, + { -EINPROGRESS, ADSP_EPENDING_STR}, + { -EBUSY, ADSP_EBUSY_STR}, + { -ECANCELED, ADSP_EABORTED_STR}, + { -EAGAIN, ADSP_EPREEMPTED_STR}, + { -EAGAIN, ADSP_ECONTINUE_STR}, + { -EAGAIN, ADSP_EIMMEDIATE_STR}, + { -EAGAIN, ADSP_ENOTIMPL_STR}, + { -ENODATA, ADSP_ENEEDMORE_STR}, + { -EADV, ADSP_ERR_MAX_STR}, + { -ENOMEM, ADSP_ENOMEMORY_STR}, + { -ENODEV, ADSP_ENOTEXIST_STR}, + { -EADV, ADSP_ERR_MAX_STR}, +}; + +static inline int adsp_err_get_lnx_err_code(u32 adsp_error) +{ + if (adsp_error > ADSP_ERR_MAX) + return adsp_err_code_info[ADSP_ERR_MAX].lnx_err_code; + else + return adsp_err_code_info[adsp_error].lnx_err_code; +} + +static inline char *adsp_err_get_err_str(u32 adsp_error) +{ + if (adsp_error > ADSP_ERR_MAX) + return adsp_err_code_info[ADSP_ERR_MAX].adsp_err_str; + else + return adsp_err_code_info[adsp_error].adsp_err_str; +} + +#endif /* __Q6DSP_COMMON_H__ */ diff --git a/sound/soc/qcom/qdsp6v2/q6afe-v2.h b/sound/soc/qcom/qdsp6v2/q6afe-v2.h new file mode 100644 index 0000000..bb73709 --- /dev/null +++ b/sound/soc/qcom/qdsp6v2/q6afe-v2.h @@ -0,0 +1,62 @@ +#ifndef __Q6AFE_V2_H__ +#define __Q6AFE_V2_H__ +#include <dt-bindings/sound/qcom,afe.h> +#define MSM_AFE_PORT_TYPE_RX 0 +#define MSM_AFE_PORT_TYPE_TX 1 +#define AFE_MAX_PORTS AFE_PORT_MAX + +struct q6afe_hdmi_cfg { + u16 datatype; + u16 channel_allocation; + u32 sample_rate; + u16 bit_width; +}; + +struct q6afe_port; + +#if IS_ENABLED(CONFIG_SND_SOC_QDSP6V2_AFE) + +struct q6afe_port *q6afe_port_get(struct device *dev, const char *name); +int q6afe_get_port_index(struct q6afe_port *p); +int q6afe_port_stop(struct q6afe_port *port); +int q6afe_port_put(struct q6afe_port *port); +int q6afe_get_port_id(int index); +int q6afe_hdmi_port_start(struct q6afe_port *port, + struct q6afe_hdmi_cfg *cfg); + +#else + +static inline int q6afe_get_port_id(int index) +{ + return -ENOSYS; +} + +static inline int q6afe_get_port_index(struct q6afe_port *p) +{ + return -ENOSYS; +} +static inline struct q6afe_port *q6afe_port_get(struct device *dev, + const char *name) +{ + return ERR_PTR(-ENOSYS); +} + +static inline int q6afe_hdmi_port_start(struct q6afe_port *port, + struct q6afe_hdmi_cfg *cfg) +{ + return -ENOSYS; +} + +static inline int q6afe_port_stop(struct q6afe_port *port) +{ + return -ENOSYS; +} + +static inline int q6afe_port_put(struct q6afe_port *port) +{ + return -ENOSYS; +} + +#endif + +#endif /* __Q6AFE_V2_H__ */ diff --git a/sound/soc/qcom/qdsp6v2/q6afe.c b/sound/soc/qcom/qdsp6v2/q6afe.c new file mode 100644 index 0000000..ebb9f54 --- /dev/null +++ b/sound/soc/qcom/qdsp6v2/q6afe.c @@ -0,0 +1,499 @@ +/* Copyright (c) 2012-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/slab.h> +#include <linux/of.h> +#include <linux/kernel.h> +#include <linux/uaccess.h> +#include <linux/wait.h> +#include <linux/jiffies.h> +#include <linux/sched.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <dt-bindings/sound/qcom,afe.h> +#include <linux/delay.h> +#include <linux/soc/qcom/apr.h> +#include "common.h" +#include "q6afe-v2.h" + +/* AFE Cmds */ +#define AFE_PORT_CMD_DEVICE_START 0x000100E5 +#define AFE_PORT_CMD_DEVICE_STOP 0x000100E6 +#define AFE_PORT_CMD_SET_PARAM_V2 0x000100EF +#define AFE_PORT_CMDRSP_GET_PARAM_V2 0x00010106 +#define AFE_PARAM_ID_HDMI_CONFIG 0x00010210 +#define AFE_MODULE_AUDIO_DEV_INTERFACE 0x0001020C + +/* Port IDs */ +#define AFE_API_VERSION_HDMI_CONFIG 0x1 +#define AFE_PORT_ID_MULTICHAN_HDMI_RX 0x100E +#define TIMEOUT_MS 1000 +#define AFE_CMD_RESP_AVAIL 0 +#define AFE_CMD_RESP_NONE 1 + +struct q6afe_port { + wait_queue_head_t wait; + int token; + int id; + int cfg_type; + union { + struct q6afev2 *v2; + } afe; + struct list_head node; +}; + +struct q6afev2 { + void *apr; + struct device *dev; + int state; + int status; + + struct mutex afe_cmd_lock; + struct list_head port_list; + struct mutex port_list_lock; + struct list_head node; +}; + +struct afe_port_cmd_device_start { + struct apr_hdr hdr; + u16 port_id; + u16 reserved; +} __packed; + +struct afe_port_cmd_device_stop { + struct apr_hdr hdr; + u16 port_id; + u16 reserved; +/* Reserved for 32-bit alignment. This field must be set to 0.*/ +} __packed; + +struct afe_port_param_data_v2 { + u32 module_id; + u32 param_id; + u16 param_size; + u16 reserved; +} __packed; + +struct afe_port_cmd_set_param_v2 { + u16 port_id; + u16 payload_size; + u32 payload_address_lsw; + u32 payload_address_msw; + u32 mem_map_handle; +} __packed; + +struct afe_param_id_hdmi_multi_chan_audio_cfg { + u32 hdmi_cfg_minor_version; + u16 datatype; + u16 channel_allocation; + u32 sample_rate; + u16 bit_width; + u16 reserved; +} __packed; + +union afe_port_config { + struct afe_param_id_hdmi_multi_chan_audio_cfg hdmi_multi_ch; +} __packed; + +struct afe_audioif_config_command { + struct apr_hdr hdr; + struct afe_port_cmd_set_param_v2 param; + struct afe_port_param_data_v2 pdata; + union afe_port_config port; +} __packed; + +struct afe_port_map { + int port_id; + int token; + int is_rx; +}; + +struct q6afev2 *__afe; +/* Port map of index vs real hw port ids */ +static struct afe_port_map port_maps[AFE_PORT_MAX] = { + [AFE_PORT_HDMI_RX] = { AFE_PORT_ID_MULTICHAN_HDMI_RX, + AFE_PORT_HDMI_RX, 1}, +}; + +static struct q6afev2 *of_parse_q6afe_port(struct device *dev, const char *name, + int *id) +{ + struct of_phandle_args args; + int ret; + + ret = of_parse_phandle_with_fixed_args(dev->of_node, name, 1, 0, &args); + if (ret < 0) { + dev_err(dev, "Failed to parse qcom,afe-port\n"); + return NULL; + } + + *id = args.args[0]; + + if (__afe && __afe->dev->of_node == args.np) + return __afe; + + return NULL; +} + +static struct q6afe_port *afe_find_port(struct q6afev2 *afe, int token) +{ + struct q6afe_port *p; + + list_for_each_entry(p, &afe->port_list, node) + if (p->token == token) + return p; + + return NULL; +} + +static int32_t afe_callback(struct apr_client_data *data, void *priv) +{ + struct q6afev2 *afe = priv; + struct q6afe_port *port; + + if (!data) { + dev_err(afe->dev, "%s: Invalid param data\n", __func__); + return -EINVAL; + } + + if (data->payload_size) { + uint32_t *payload = data->payload; + + if (data->opcode == APR_BASIC_RSP_RESULT) { + if (payload[1] != 0) { + afe->status = payload[1]; + dev_err(afe->dev, + "cmd = 0x%x returned error = 0x%x\n", + payload[0], payload[1]); + } + switch (payload[0]) { + case AFE_PORT_CMD_SET_PARAM_V2: + case AFE_PORT_CMD_DEVICE_STOP: + case AFE_PORT_CMD_DEVICE_START: + afe->state = AFE_CMD_RESP_AVAIL; + port = afe_find_port(afe, data->token); + if (port) + wake_up(&port->wait); + + break; + default: + dev_err(afe->dev, "Unknown cmd 0x%x\n", + payload[0]); + break; + } + } + } + return 0; +} + +int q6afe_get_port_id(int index) +{ + if (index < 0 || index > AFE_PORT_MAX) { + pr_err("%s: AFE port index[%d] invalid!\n", __func__, index); + return -EINVAL; + } + + return port_maps[index].port_id; +} +EXPORT_SYMBOL_GPL(q6afe_get_port_id); + +static int afe_apr_send_pkt(struct q6afev2 *afe, void *data, + wait_queue_head_t *wait) +{ + int ret; + + if (wait) + afe->state = AFE_CMD_RESP_NONE; + + afe->status = 0; + ret = apr_send_pkt(afe->apr, data); + if (ret > 0) { + if (wait) { + ret = wait_event_timeout(*wait, + (afe->state == + AFE_CMD_RESP_AVAIL), + msecs_to_jiffies(TIMEOUT_MS)); + if (!ret) { + ret = -ETIMEDOUT; + } else if (afe->status > 0) { + dev_err(afe->dev, "DSP returned error[%s]\n", + adsp_err_get_err_str(afe->status)); + ret = adsp_err_get_lnx_err_code(afe->status); + } else { + ret = 0; + } + } else { + ret = 0; + } + } else if (ret == 0) { + dev_err(afe->dev, "packet not transmitted\n"); + ret = -EINVAL; + } + + return ret; +} + +static int afe_send_cmd_port_start(struct q6afe_port *port) +{ + u16 port_id = port->id; + struct afe_port_cmd_device_start start; + struct q6afev2 *afe = port->afe.v2; + int ret, index; + + index = port->token; + start.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD, + APR_HDR_LEN(APR_HDR_SIZE), + APR_PKT_VER); + start.hdr.pkt_size = sizeof(start); + start.hdr.src_port = 0; + start.hdr.dest_port = 0; + start.hdr.token = index; + start.hdr.opcode = AFE_PORT_CMD_DEVICE_START; + start.port_id = port_id; + + ret = afe_apr_send_pkt(afe, &start, &port->wait); + if (ret) + dev_err(afe->dev, "AFE enable for port 0x%x failed %d\n", + port_id, ret); + + return ret; +} + +static int afe_port_start(struct q6afe_port *port, + union afe_port_config *afe_config) +{ + struct afe_audioif_config_command config; + struct q6afev2 *afe = port->afe.v2; + int ret = 0; + int port_id = port->id; + int cfg_type; + int index = 0; + + if (!afe_config) { + dev_err(afe->dev, "Error, no configuration data\n"); + ret = -EINVAL; + return ret; + } + + index = port->token; + + mutex_lock(&afe->afe_cmd_lock); + /* Also send the topology id here: */ + config.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD, + APR_HDR_LEN(APR_HDR_SIZE), + APR_PKT_VER); + config.hdr.pkt_size = sizeof(config); + config.hdr.src_port = 0; + config.hdr.dest_port = 0; + config.hdr.token = index; + + cfg_type = port->cfg_type; + config.hdr.opcode = AFE_PORT_CMD_SET_PARAM_V2; + config.param.port_id = port_id; + config.param.payload_size = sizeof(config) - sizeof(struct apr_hdr) - + sizeof(config.param); + config.param.payload_address_lsw = 0x00; + config.param.payload_address_msw = 0x00; + config.param.mem_map_handle = 0x00; + config.pdata.module_id = AFE_MODULE_AUDIO_DEV_INTERFACE; + config.pdata.param_id = cfg_type; + config.pdata.param_size = sizeof(config.port); + + config.port = *afe_config; + + ret = afe_apr_send_pkt(afe, &config, &port->wait); + if (ret) { + dev_err(afe->dev, "AFE enable for port 0x%x failed %d\n", + port_id, ret); + goto fail_cmd; + } + + ret = afe_send_cmd_port_start(port); + +fail_cmd: + mutex_unlock(&afe->afe_cmd_lock); + return ret; +} + +int q6afe_get_port_index(struct q6afe_port *p) +{ + return p->token; +} + +int q6afe_port_stop(struct q6afe_port *port) +{ + int port_id = port->id; + struct afe_port_cmd_device_stop stop; + struct q6afev2 *afe = port->afe.v2; + int ret = 0; + int index = 0; + + port_id = port->id; + index = port->token; + if (index < 0 || index > AFE_PORT_MAX) { + dev_err(afe->dev, "AFE port index[%d] invalid!\n", index); + return -EINVAL; + } + + stop.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD, + APR_HDR_LEN(APR_HDR_SIZE), + APR_PKT_VER); + stop.hdr.pkt_size = sizeof(stop); + stop.hdr.src_port = 0; + stop.hdr.dest_port = 0; + stop.hdr.token = index; + stop.hdr.opcode = AFE_PORT_CMD_DEVICE_STOP; + stop.port_id = port_id; + stop.reserved = 0; + + ret = afe_apr_send_pkt(afe, &stop, &port->wait); + if (ret) + dev_err(afe->dev, "AFE close failed %d\n", ret); + + return ret; +} +EXPORT_SYMBOL_GPL(q6afe_port_stop); + +int q6afe_hdmi_port_start(struct q6afe_port *port, struct q6afe_hdmi_cfg *cfg) +{ + union afe_port_config port_cfg; + + port_cfg.hdmi_multi_ch.hdmi_cfg_minor_version = + AFE_API_VERSION_HDMI_CONFIG; + port_cfg.hdmi_multi_ch.datatype = cfg->datatype; + port_cfg.hdmi_multi_ch.channel_allocation = cfg->channel_allocation; + port_cfg.hdmi_multi_ch.sample_rate = cfg->sample_rate; + port_cfg.hdmi_multi_ch.bit_width = cfg->bit_width; + + return afe_port_start(port, &port_cfg); +} +EXPORT_SYMBOL_GPL(q6afe_hdmi_port_start); + +struct q6afe_port *q6afe_port_get(struct device *dev, const char *name) +{ + int port_id, index = 0; + struct q6afev2 *afe = of_parse_q6afe_port(dev, name, &index); + struct q6afe_port *port; + int token; + int cfg_type; + + if (!afe) { + dev_err(dev, "Unable to find instance of afe service\n"); + return ERR_PTR(-ENOENT); + } + + token = index; + if (token < 0 || token > AFE_PORT_MAX) { + dev_err(dev, "AFE port token[%d] invalid!\n", token); + return ERR_PTR(-EINVAL); + } + + port_id = port_maps[index].port_id; + + port = devm_kzalloc(dev, sizeof(*port), GFP_KERNEL); + if (!port) + return ERR_PTR(-ENOMEM); + + init_waitqueue_head(&port->wait); + + port->token = token; + port->id = port_id; + + port->afe.v2 = afe; + switch (port_id) { + case AFE_PORT_ID_MULTICHAN_HDMI_RX: + cfg_type = AFE_PARAM_ID_HDMI_CONFIG; + break; + default: + dev_err(dev, "Invalid port id 0x%x\n", port_id); + return ERR_PTR(-EINVAL); + } + + port->cfg_type = cfg_type; + + mutex_lock(&afe->port_list_lock); + list_add_tail(&port->node, &afe->port_list); + mutex_unlock(&afe->port_list_lock); + + return port; + +} +EXPORT_SYMBOL_GPL(q6afe_port_get); + +int q6afe_port_put(struct q6afe_port *port) +{ + struct q6afev2 *afe = port->afe.v2; + + mutex_lock(&afe->port_list_lock); + list_del(&port->node); + mutex_unlock(&afe->port_list_lock); + + return 0; +} +EXPORT_SYMBOL_GPL(q6afe_port_put); + +static int q6afev2_probe(struct platform_device *pdev) +{ + int ret; + struct device *dev = &pdev->dev; + + __afe = kzalloc(sizeof(*__afe), GFP_KERNEL); + if (!__afe) + return -ENOMEM; + + __afe->apr = apr_register(dev, "ADSP", "AFE", + afe_callback, 0xFFFFFFFF, __afe); + if (__afe->apr == NULL) { + dev_err(dev, "Unable to register AFE\n"); + ret = -ENODEV; + } + + mutex_init(&__afe->afe_cmd_lock); + __afe->dev = dev; + INIT_LIST_HEAD(&__afe->port_list); + mutex_init(&__afe->port_list_lock); + + platform_set_drvdata(pdev, __afe); + return 0; +} + +static int q6afev2_remove(struct platform_device *pdev) +{ + int rval; + + rval = apr_deregister(__afe->apr); + if (rval < 0) + return rval; + + kfree(__afe); + __afe = NULL; + + return 0; +} + +static const struct of_device_id qcom_q6afe_match[] = { + {.compatible = "qcom,q6afe-v2",}, + {} +}; + +static struct platform_driver qcom_q6afe_driver = { + .probe = q6afev2_probe, + .remove = q6afev2_remove, + .driver = { + .name = "qcom-q6afe-v2", + .of_match_table = qcom_q6afe_match, + }, +}; + +module_platform_driver(qcom_q6afe_driver); +MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org"); +MODULE_DESCRIPTION("q6 Audio Front End driver"); +MODULE_LICENSE("GPL v2");

From: Srinivas Kandagatla srinivas.kandagatla@linaro.org

This patch adds basic support to Q6 ASM (Audio Strem Manager) module on Q6DSP. ASM supports up to 8 concurrent streams. each stream can be setup as playback/capture. ASM provides top control functions like Pause/flush/resume for playback and record. ASM can Create/destroy encoder, decoder and also provides POPP dynamic services.

This patch adds support to basic features to allow hdmi playback.

Signed-off-by: Srinivas Kandagatla srinivas.kandagatla@linaro.org --- .../devicetree/bindings/sound/qcom,q6asm.txt | 15 + include/dt-bindings/sound/qcom,asm.h | 13 + sound/soc/qcom/Kconfig | 6 + sound/soc/qcom/qdsp6v2/Makefile | 1 + sound/soc/qcom/qdsp6v2/q6asm-v2.h | 176 ++++ sound/soc/qcom/qdsp6v2/q6asm.c | 1008 ++++++++++++++++++++ 6 files changed, 1219 insertions(+) create mode 100644 Documentation/devicetree/bindings/sound/qcom,q6asm.txt create mode 100644 include/dt-bindings/sound/qcom,asm.h create mode 100644 sound/soc/qcom/qdsp6v2/q6asm-v2.h create mode 100644 sound/soc/qcom/qdsp6v2/q6asm.c

diff --git a/Documentation/devicetree/bindings/sound/qcom,q6asm.txt b/Documentation/devicetree/bindings/sound/qcom,q6asm.txt new file mode 100644 index 0000000..a658ba6 --- /dev/null +++ b/Documentation/devicetree/bindings/sound/qcom,q6asm.txt @@ -0,0 +1,15 @@ +Qualcomm Q6ASM (Q6 Audio Stream Manager) binding + +This bindings describe the Qualcomm Q6 ASM module on QDSP, +which is used by audio drivers. + +- compatible: + + Usage: required + Value type: <stringlist> + Definition: must be "qcom,q6asm-v<VERSION-NUMBER>" example: "qcom,q6asm-v2" + += EXAMPLE + q6asm { + compatible = "qcom,q6asm-v2"; + }; diff --git a/include/dt-bindings/sound/qcom,asm.h b/include/dt-bindings/sound/qcom,asm.h new file mode 100644 index 0000000..0f93349 --- /dev/null +++ b/include/dt-bindings/sound/qcom,asm.h @@ -0,0 +1,13 @@ +#ifndef __DT_ASM_H__ +#define __DT_ASM_H__ + +#define MSM_FRONTEND_DAI_MULTIMEDIA1 0 +#define MSM_FRONTEND_DAI_MULTIMEDIA2 1 +#define MSM_FRONTEND_DAI_MULTIMEDIA3 2 +#define MSM_FRONTEND_DAI_MULTIMEDIA4 3 +#define MSM_FRONTEND_DAI_MULTIMEDIA5 4 +#define MSM_FRONTEND_DAI_MULTIMEDIA6 5 +#define MSM_FRONTEND_DAI_MULTIMEDIA7 6 +#define MSM_FRONTEND_DAI_MULTIMEDIA8 7 + +#endif diff --git a/sound/soc/qcom/Kconfig b/sound/soc/qcom/Kconfig index 72f6fa4..bd49813 100644 --- a/sound/soc/qcom/Kconfig +++ b/sound/soc/qcom/Kconfig @@ -52,10 +52,16 @@ config SND_SOC_QDSP6V2_ADM tristate default n

+config SND_SOC_QDSP6V2_ASM + tristate + default n + + config SND_SOC_QDSP6V2 tristate "SoC ALSA audio driver for QDSP6V2" select SND_SOC_QDSP6V2_AFE select SND_SOC_QDSP6V2_ADM + select SND_SOC_QDSP6V2_ASM help To add support for MSM QDSP6V2 Soc Audio. This will enable sound soc platform specific diff --git a/sound/soc/qcom/qdsp6v2/Makefile b/sound/soc/qcom/qdsp6v2/Makefile index a2b8b0b..00b0549 100644 --- a/sound/soc/qcom/qdsp6v2/Makefile +++ b/sound/soc/qcom/qdsp6v2/Makefile @@ -1,2 +1,3 @@ obj-$(CONFIG_SND_SOC_QDSP6V2_AFE) += q6afe.o obj-$(CONFIG_SND_SOC_QDSP6V2_ADM) += q6adm.o +obj-$(CONFIG_SND_SOC_QDSP6V2_ASM) += q6asm.o diff --git a/sound/soc/qcom/qdsp6v2/q6asm-v2.h b/sound/soc/qcom/qdsp6v2/q6asm-v2.h new file mode 100644 index 0000000..6a6afcd --- /dev/null +++ b/sound/soc/qcom/qdsp6v2/q6asm-v2.h @@ -0,0 +1,176 @@ +/* Copyright (c) 2012-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. + */ +#ifndef __Q6_ASM_V2_H__ +#define __Q6_ASM_V2_H__ + +#include <linux/soc/qcom/apr.h> +#include <linux/list.h> + +/* ASM client callback events */ +#define CMD_PAUSE 0x0001 +#define ASM_CLIENT_EVENT_CMD_PAUSE_DONE 0x1001 +#define CMD_FLUSH 0x0002 +#define ASM_CLIENT_EVENT_CMD_FLUSH_DONE 0x1002 +#define CMD_EOS 0x0003 +#define ASM_CLIENT_EVENT_CMD_EOS_DONE 0x1003 +#define CMD_CLOSE 0x0004 +#define ASM_CLIENT_EVENT_CMD_CLOSE_DONE 0x1004 +#define CMD_OUT_FLUSH 0x0005 +#define ASM_CLIENT_EVENT_CMD_OUT_FLUSH_DONE 0x1005 +#define CMD_SUSPEND 0x0006 +#define ASM_CLIENT_EVENT_CMD_SUSPEND_DONE 0x1006 +#define ASM_CLIENT_EVENT_CMD_RUN_DONE 0x1008 +#define ASM_CLIENT_EVENT_DATA_WRITE_DONE 0x1009 + +#define MAX_SESSIONS 16 +#define NO_TIMESTAMP 0xFF00 +#define FORMAT_LINEAR_PCM 0x0000 + +struct audio_client; +struct audio_buffer; +struct audio_port_data { + struct audio_buffer *buf; + uint32_t max_buf_cnt; + uint32_t dsp_buf; + uint32_t cpu_buf; + uint32_t mem_map_handle; +}; + +typedef void (*app_cb) (uint32_t opcode, uint32_t token, + uint32_t *payload, void *priv); +struct audio_client { + int session; + app_cb cb; + int cmd_state; + void *priv; + uint32_t io_mode; + uint64_t time_stamp; + struct apr_svc *apr; + struct mutex cmd_lock; + /* idx:1 out port, 0: in port */ + struct audio_port_data port[2]; + wait_queue_head_t cmd_wait; + int perf_mode; + int stream_id; + struct device *dev; +}; +#if IS_ENABLED(CONFIG_SND_SOC_QDSP6V2_ASM) +struct q6asm *q6asm_get(struct device *dev); +void q6asm_put(struct q6asm *a); +struct audio_client *q6asm_audio_client_alloc(struct q6asm *a, + struct device *dev, + app_cb cb, void *priv); +void q6asm_audio_client_free(struct audio_client *ac); +int q6asm_write_nolock(struct audio_client *ac, uint32_t len, uint32_t msw_ts, + uint32_t lsw_ts, uint32_t flags); +int q6asm_open_write(struct audio_client *ac, uint32_t format, + uint16_t bits_per_sample); +int q6asm_media_format_block_multi_ch_pcm(struct audio_client *ac, + uint32_t rate, uint32_t channels, + bool use_default_chmap, + char *channel_map, + uint16_t bits_per_sample); +int q6asm_run(struct audio_client *ac, uint32_t flags, uint32_t msw_ts, + uint32_t lsw_ts); +int q6asm_run_nowait(struct audio_client *ac, uint32_t flags, uint32_t msw_ts, + uint32_t lsw_ts); +int q6asm_cmd(struct audio_client *ac, int cmd); +int q6asm_cmd_nowait(struct audio_client *ac, int cmd); +int q6asm_map_memory_regions(unsigned int dir, + struct audio_client *ac, + void *data, + dma_addr_t phys, + unsigned int bufsz, unsigned int bufcnt); +int q6asm_unmap_memory_regions(unsigned int dir, struct audio_client *ac); +#else + +static inline struct q6asm *q6asm_get(struct device *dev) +{ + return PTR_ERR(-ENOSYS); +} + +static inline void q6asm_put(struct q6asm *a) +{ +} + +static inline struct audio_client *q6asm_audio_client_alloc(struct q6asm *a, + struct device *dev, + app_cb cb, + void *priv) +{ + return PTR_ERR(-ENOSYS); +} + +static inline void q6asm_audio_client_free(struct audio_client *ac) +{ +} + +static inline int q6asm_write_nolock(struct audio_client *ac, uint32_t len, + uint32_t msw_ts, uint32_t lsw_ts, + uint32_t flags) +{ + return -ENOSYS; +} +static inline int q6asm_open_write(struct audio_client *ac, uint32_t format, + uint16_t bits_per_sample) +{ + return -ENOSYS; +} +static inline int q6asm_media_format_block_multi_ch_pcm(struct audio_client *a, + uint32_t r, uint32_t c, + bool use_default_chmap, + char *channel_map, + uint16_t bps) +{ + return -ENOSYS; +} + +static inline int q6asm_run(struct audio_client *ac, uint32_t flags, + uint32_t msw_ts, uint32_t lsw_ts) +{ + return -ENOSYS; +} + +static inline int q6asm_run_nowait(struct audio_client *ac, + uint32_t flags, uint32_t msw_ts, + uint32_t lsw_ts); +{ + return -ENOSYS; +} + +static inline int q6asm_cmd(struct audio_client *ac, int cmd) +{ + return -ENOSYS; +} + +static inline int q6asm_cmd_nowait(struct audio_client *ac, int cmd) +{ + return -ENOSYS; +} + +static inline int q6asm_map_memory_regions(unsigned int dir + struct audio_client *ac, + void *data, + dma_addr_t phys, + unsigned int bufsz, + unsigned int bufcnt) +{ + return -ENOSYS; +} + +static inline int q6asm_unmap_memory_regions(unsigned int dir, + struct audio_client *ac) +{ + return -ENOSYS; +} +#endif +#endif /* __Q6_ASM_H__ */ diff --git a/sound/soc/qcom/qdsp6v2/q6asm.c b/sound/soc/qcom/qdsp6v2/q6asm.c new file mode 100644 index 0000000..330f3b3 --- /dev/null +++ b/sound/soc/qcom/qdsp6v2/q6asm.c @@ -0,0 +1,1008 @@ +/* Copyright (c) 2012-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/mutex.h> +#include <linux/wait.h> +#include <linux/sched.h> +#include <linux/module.h> +#include <linux/platform_device.h> +#include <linux/delay.h> +#include <uapi/sound/asound.h> +#include <linux/slab.h> +#include <linux/mm.h> +#include "q6asm-v2.h" +#include "common.h" + +#define ASM_STREAM_CMD_CLOSE 0x00010BCD +#define ASM_STREAM_CMD_FLUSH 0x00010BCE +#define ASM_SESSION_CMD_PAUSE 0x00010BD3 +#define ASM_DATA_CMD_EOS 0x00010BDB +#define DEFAULT_POPP_TOPOLOGY 0x00010BE4 +#define ASM_STREAM_CMD_FLUSH_READBUFS 0x00010C09 +#define ASM_CMD_SHARED_MEM_MAP_REGIONS 0x00010D92 +#define ASM_CMDRSP_SHARED_MEM_MAP_REGIONS 0x00010D93 +#define ASM_CMD_SHARED_MEM_UNMAP_REGIONS 0x00010D94 +#define ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2 0x00010D98 +#define ASM_DATA_EVENT_WRITE_DONE_V2 0x00010D99 +#define ASM_SESSION_CMD_RUN_V2 0x00010DAA +#define ASM_MEDIA_FMT_MULTI_CHANNEL_PCM_V2 0x00010DA5 +#define ASM_DATA_CMD_WRITE_V2 0x00010DAB +#define ASM_SESSION_CMD_SUSPEND 0x00010DEC +#define ASM_STREAM_CMD_OPEN_WRITE_V3 0x00010DB3 + +#define ASM_LEGACY_STREAM_SESSION 0 +#define ASM_END_POINT_DEVICE_MATRIX 0 +#define DEFAULT_APP_TYPE 0 +#define TUN_WRITE_IO_MODE 0x0008 /* tunnel read write mode */ +#define TUN_READ_IO_MODE 0x0004 /* tunnel read write mode */ +#define SYNC_IO_MODE 0x0001 +#define ASYNC_IO_MODE 0x0002 +#define SESSION_MAX MAX_SESSIONS +#define ASM_SHIFT_GAPLESS_MODE_FLAG 31 +#define ADSP_MEMORY_MAP_SHMEM8_4K_POOL 3 + +struct avs_cmd_shared_mem_map_regions { + struct apr_hdr hdr; + u16 mem_pool_id; + u16 num_regions; + u32 property_flag; +} __packed; + +struct avs_shared_map_region_payload { + u32 shm_addr_lsw; + u32 shm_addr_msw; + u32 mem_size_bytes; +} __packed; + +struct avs_cmd_shared_mem_unmap_regions { + struct apr_hdr hdr; + u32 mem_map_handle; +} __packed; + +struct asm_data_cmd_media_fmt_update_v2 { + u32 fmt_blk_size; +} __packed; + +struct asm_multi_channel_pcm_fmt_blk_v2 { + struct apr_hdr hdr; + struct asm_data_cmd_media_fmt_update_v2 fmt_blk; + u16 num_channels; + u16 bits_per_sample; + u32 sample_rate; + u16 is_signed; + u16 reserved; + u8 channel_mapping[8]; +} __packed; + +struct asm_data_cmd_write_v2 { + struct apr_hdr hdr; + u32 buf_addr_lsw; + u32 buf_addr_msw; + u32 mem_map_handle; + u32 buf_size; + u32 seq_id; + u32 timestamp_lsw; + u32 timestamp_msw; + u32 flags; +} __packed; + +struct asm_stream_cmd_open_write_v3 { + struct apr_hdr hdr; + uint32_t mode_flags; + uint16_t sink_endpointype; + uint16_t bits_per_sample; + uint32_t postprocopo_id; + uint32_t dec_fmt_id; +} __packed; + +struct asm_session_cmd_run_v2 { + struct apr_hdr hdr; + u32 flags; + u32 time_lsw; + u32 time_msw; +} __packed; + +struct audio_buffer { + dma_addr_t phys; + void *data; + uint32_t used; + uint32_t size; /* size of buffer */ +}; + +struct q6asm { + struct apr_svc *mmap_apr; + int mem_state; + struct device *dev; + wait_queue_head_t mem_wait; + struct mutex session_lock; + struct audio_client *session[SESSION_MAX + 1]; +}; + +struct q6asm *__q6asm; + +static int q6asm_session_alloc(struct audio_client *ac) +{ + int n = -EINVAL; + + mutex_lock(&__q6asm->session_lock); + for (n = 1; n <= SESSION_MAX; n++) { + if (!__q6asm->session[n]) { + __q6asm->session[n] = ac; + break; + } + } + mutex_unlock(&__q6asm->session_lock); + + return n; +} + +static bool q6asm_is_valid_audio_client(struct audio_client *ac) +{ + int n; + + for (n = 1; n <= SESSION_MAX; n++) { + if (__q6asm->session[n] == ac) + return 1; + } + + return 0; +} + +static void q6asm_session_free(struct audio_client *ac) +{ + mutex_lock(&__q6asm->session_lock); + __q6asm->session[ac->session] = 0; + ac->session = 0; + ac->perf_mode = LEGACY_PCM_MODE; + mutex_unlock(&__q6asm->session_lock); +} + +static inline void q6asm_add_mmaphdr(struct audio_client *ac, + struct apr_hdr *hdr, u32 pkt_size, + bool cmd_flg, u32 token) +{ + hdr->hdr_field = APR_SEQ_CMD_HDR_FIELD; + hdr->src_port = 0; + hdr->dest_port = 0; + hdr->pkt_size = pkt_size; + if (cmd_flg) + hdr->token = token; +} + +static inline void q6asm_add_hdr(struct audio_client *ac, struct apr_hdr *hdr, + uint32_t pkt_size, bool cmd_flg, + uint32_t stream_id) +{ + hdr->hdr_field = APR_SEQ_CMD_HDR_FIELD; + hdr->src_svc = ((struct apr_svc *)ac->apr)->id; + hdr->src_domain = APR_DOMAIN_APPS; + hdr->dest_svc = APR_SVC_ASM; + hdr->dest_domain = APR_DOMAIN_ADSP; + hdr->src_port = ((ac->session << 8) & 0xFF00) | (stream_id); + hdr->dest_port = ((ac->session << 8) & 0xFF00) | (stream_id); + hdr->pkt_size = pkt_size; + if (cmd_flg) + hdr->token = ac->session; +} + +static int __q6asm_memory_unmap(struct audio_client *ac, + phys_addr_t buf_add, int dir) +{ + struct avs_cmd_shared_mem_unmap_regions mem_unmap; + int rc; + + q6asm_add_mmaphdr(ac, &mem_unmap.hdr, sizeof(mem_unmap), true, + ((ac->session << 8) | dir)); + __q6asm->mem_state = -1; + + mem_unmap.hdr.opcode = ASM_CMD_SHARED_MEM_UNMAP_REGIONS; + mem_unmap.mem_map_handle = ac->port[dir].mem_map_handle; + + if (mem_unmap.mem_map_handle == 0) { + dev_err(ac->dev, "invalid mem handle\n"); + return -EINVAL; + } + + rc = apr_send_pkt(__q6asm->mmap_apr, (uint32_t *) &mem_unmap); + if (rc < 0) + return rc; + + rc = wait_event_timeout(__q6asm->mem_wait, (__q6asm->mem_state >= 0), + 5 * HZ); + if (!rc) { + dev_err(ac->dev, "CMD timeout for memory_unmap 0x%x\n", + mem_unmap.mem_map_handle); + return -ETIMEDOUT; + } else if (__q6asm->mem_state > 0) { + return adsp_err_get_lnx_err_code(__q6asm->mem_state); + } + ac->port[dir].mem_map_handle = 0; + + return 0; +} + +int q6asm_unmap_memory_regions(unsigned int dir, struct audio_client *ac) +{ + struct audio_port_data *port; + int cnt = 0; + int rc = 0; + + mutex_lock(&ac->cmd_lock); + port = &ac->port[dir]; + if (!port->buf) { + mutex_unlock(&ac->cmd_lock); + return 0; + } + + cnt = port->max_buf_cnt - 1; + if (cnt >= 0) { + rc = __q6asm_memory_unmap(ac, port->buf[dir].phys, dir); + if (rc < 0) { + dev_err(ac->dev, "%s: Memory_unmap_regions failed %d\n", + __func__, rc); + mutex_unlock(&ac->cmd_lock); + return rc; + } + } + + port->max_buf_cnt = 0; + kfree(port->buf); + port->buf = NULL; + mutex_unlock(&ac->cmd_lock); + + return 0; +} +EXPORT_SYMBOL_GPL(q6asm_unmap_memory_regions); + +static int __q6asm_memory_map_regions(struct audio_client *ac, int dir, + uint32_t period_sz, uint32_t periods, + bool is_contiguous) +{ + struct avs_cmd_shared_mem_map_regions *mmap_regions = NULL; + struct avs_shared_map_region_payload *mregions = NULL; + struct audio_port_data *port = NULL; + struct audio_buffer *ab = NULL; + void *mmap_region_cmd = NULL; + void *payload = NULL; + int rc = 0; + int i = 0; + int cmd_size = 0; + uint32_t num_regions; + uint32_t buf_sz; + + num_regions = is_contiguous ? 1 : periods; + buf_sz = is_contiguous ? (period_sz * periods) : period_sz; + buf_sz = PAGE_ALIGN(buf_sz); + + cmd_size = sizeof(*mmap_regions) + (sizeof(*mregions) * num_regions); + + mmap_region_cmd = kzalloc(cmd_size, GFP_KERNEL); + if (!mmap_region_cmd) + return -ENOMEM; + + mmap_regions = (struct avs_cmd_shared_mem_map_regions *)mmap_region_cmd; + q6asm_add_mmaphdr(ac, &mmap_regions->hdr, cmd_size, true, + ((ac->session << 8) | dir)); + __q6asm->mem_state = -1; + + mmap_regions->hdr.opcode = ASM_CMD_SHARED_MEM_MAP_REGIONS; + mmap_regions->mem_pool_id = ADSP_MEMORY_MAP_SHMEM8_4K_POOL; + mmap_regions->num_regions = num_regions; + mmap_regions->property_flag = 0x00; + + payload = ((u8 *) mmap_region_cmd + + sizeof(struct avs_cmd_shared_mem_map_regions)); + + mregions = (struct avs_shared_map_region_payload *)payload; + + ac->port[dir].mem_map_handle = 0; + port = &ac->port[dir]; + + for (i = 0; i < num_regions; i++) { + ab = &port->buf[i]; + mregions->shm_addr_lsw = lower_32_bits(ab->phys); + mregions->shm_addr_msw = upper_32_bits(ab->phys); + mregions->mem_size_bytes = buf_sz; + ++mregions; + } + + rc = apr_send_pkt(__q6asm->mmap_apr, (uint32_t *) mmap_region_cmd); + if (rc < 0) + goto fail_cmd; + + rc = wait_event_timeout(__q6asm->mem_wait, (__q6asm->mem_state >= 0), + 5 * HZ); + if (!rc) { + dev_err(ac->dev, "timeout. waited for memory_map\n"); + rc = -ETIMEDOUT; + goto fail_cmd; + } + + if (__q6asm->mem_state > 0) { + rc = adsp_err_get_lnx_err_code(__q6asm->mem_state); + goto fail_cmd; + } + rc = 0; +fail_cmd: + kfree(mmap_region_cmd); + return rc; +} + +int q6asm_map_memory_regions(unsigned int dir, struct audio_client *ac, + void *data, dma_addr_t phys, + unsigned int period_sz, unsigned int periods) +{ + struct audio_buffer *buf; + int cnt; + int rc; + + if (ac->port[dir].buf) { + dev_err(ac->dev, "Buffer already allocated\n"); + return 0; + } + + mutex_lock(&ac->cmd_lock); + + buf = kzalloc(((sizeof(struct audio_buffer)) * periods), GFP_KERNEL); + if (!buf) { + mutex_unlock(&ac->cmd_lock); + return -ENOMEM; + } + + + ac->port[dir].buf = buf; + + buf[0].data = data; + buf[0].phys = phys; + buf[0].used = dir ^ 1; + buf[0].size = period_sz; + cnt = 1; + while (cnt < periods) { + if (period_sz > 0) { + buf[cnt].data = buf[0].data + (cnt * period_sz); + buf[cnt].phys = buf[0].phys + (cnt * period_sz); + buf[cnt].used = dir ^ 1; + buf[cnt].size = period_sz; + } + cnt++; + } + + ac->port[dir].max_buf_cnt = periods; + mutex_unlock(&ac->cmd_lock); + + rc = __q6asm_memory_map_regions(ac, dir, period_sz, periods, 1); + if (rc < 0) { + dev_err(ac->dev, + "CMD Memory_map_regions failed %d for size %d\n", rc, + period_sz); + + + ac->port[dir].max_buf_cnt = 0; + kfree(buf); + ac->port[dir].buf = NULL; + + return rc; + } + + return 0; +} +EXPORT_SYMBOL_GPL(q6asm_map_memory_regions); + +void q6asm_audio_client_free(struct audio_client *ac) +{ + apr_deregister(ac->apr); + q6asm_session_free(ac); + kfree(ac); +} +EXPORT_SYMBOL_GPL(q6asm_audio_client_free); + +static struct audio_client *q6asm_get_audio_client(int session_id) +{ + if ((session_id <= 0) || (session_id > SESSION_MAX)) { + pr_err("%s: invalid session: %d\n", __func__, session_id); + goto err; + } + + if (!__q6asm->session[session_id]) { + pr_err("%s: session not active: %d\n", __func__, session_id); + goto err; + } + return __q6asm->session[session_id]; +err: + return NULL; +} + +static int32_t q6asm_srvc_callback(struct apr_client_data *data, void *priv) +{ + struct audio_client *ac = NULL; + struct audio_port_data *port; + uint32_t sid = 0; + uint32_t dir = 0; + uint32_t *payload; + + if (!data) { + pr_err("%s: Invalid CB\n", __func__); + return 0; + } + + payload = data->payload; + sid = (data->token >> 8) & 0x0F; + ac = q6asm_get_audio_client(sid); + if (!ac) { + pr_debug("%s: session[%d] already freed\n", __func__, sid); + return 0; + } + + if (data->opcode == APR_BASIC_RSP_RESULT) { + switch (payload[0]) { + case ASM_CMD_SHARED_MEM_MAP_REGIONS: + case ASM_CMD_SHARED_MEM_UNMAP_REGIONS: + if (payload[1] != 0) { + dev_err(ac->dev, + "cmd = 0x%x returned error = 0x%x sid:%d\n", + payload[0], payload[1], sid); + __q6asm->mem_state = payload[1]; + } else { + __q6asm->mem_state = 0; + } + + wake_up(&__q6asm->mem_wait); + dev_vdbg(ac->dev, "%s: Payload = [0x%x] status[0x%x]\n", + __func__, payload[0], payload[1]); + break; + default: + pr_debug("%s: command[0x%x] not expecting rsp\n", + __func__, payload[0]); + break; + } + return 0; + } + + dir = (data->token & 0x0F); + port = &ac->port[dir]; + + switch (data->opcode) { + case ASM_CMDRSP_SHARED_MEM_MAP_REGIONS:{ + __q6asm->mem_state = 0; + ac->port[dir].mem_map_handle = payload[0]; + wake_up(&__q6asm->mem_wait); + break; + } + case ASM_CMD_SHARED_MEM_UNMAP_REGIONS:{ + __q6asm->mem_state = 0; + ac->port[dir].mem_map_handle = 0; + wake_up(&__q6asm->mem_wait); + + break; + } + default: + pr_debug("%s: command[0x%x]success [0x%x]\n", + __func__, payload[0], payload[1]); + } + if (ac->cb) + ac->cb(data->opcode, data->token, data->payload, ac->priv); + return 0; +} + +static int32_t q6asm_callback(struct apr_client_data *data, void *priv) +{ + struct audio_client *ac = (struct audio_client *)priv; + uint32_t token; + uint32_t *payload; + uint32_t wakeup_flag = 1; + uint32_t client_event = 0; + + if (data == NULL) + return -EINVAL; + + if (!q6asm_is_valid_audio_client(ac)) + return -EINVAL; + + payload = data->payload; + if (data->opcode == APR_BASIC_RSP_RESULT) { + token = data->token; + switch (payload[0]) { + case ASM_SESSION_CMD_PAUSE: + client_event = ASM_CLIENT_EVENT_CMD_PAUSE_DONE; + break; + case ASM_SESSION_CMD_SUSPEND: + client_event = ASM_CLIENT_EVENT_CMD_SUSPEND_DONE; + break; + case ASM_DATA_CMD_EOS: + client_event = ASM_CLIENT_EVENT_CMD_EOS_DONE; + break; + case ASM_STREAM_CMD_CLOSE: + client_event = ASM_CLIENT_EVENT_CMD_CLOSE_DONE; + break; + case ASM_STREAM_CMD_FLUSH: + client_event = ASM_CLIENT_EVENT_CMD_FLUSH_DONE; + break; + case ASM_SESSION_CMD_RUN_V2: + client_event = ASM_CLIENT_EVENT_CMD_RUN_DONE; + break; + + case ASM_STREAM_CMD_FLUSH_READBUFS: + if (token != ac->session) { + dev_err(ac->dev, "session invalid\n"); + return -EINVAL; + } + case ASM_STREAM_CMD_OPEN_WRITE_V3: + case ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2: + if (payload[1] != 0) { + dev_err(ac->dev, + "cmd = 0x%x returned error = 0x%x\n", + payload[0], payload[1]); + if (wakeup_flag) { + ac->cmd_state = payload[1]; + wake_up(&ac->cmd_wait); + } + return 0; + } + if (ac->cmd_state && wakeup_flag) { + ac->cmd_state = 0; + wake_up(&ac->cmd_wait); + } + if (ac->cb) + ac->cb(data->opcode, data->token, + (uint32_t *) data->payload, ac->priv); + break; + default: + dev_err(ac->dev, "command[0x%x] not expecting rsp\n", + payload[0]); + break; + } + + if (ac->cb) + ac->cb(client_event, data->token, + data->payload, ac->priv); + + return 0; + } + + switch (data->opcode) { + case ASM_DATA_EVENT_WRITE_DONE_V2:{ + struct audio_port_data *port = + &ac->port[SNDRV_PCM_STREAM_PLAYBACK]; + + client_event = ASM_CLIENT_EVENT_DATA_WRITE_DONE; + + if (ac->io_mode & SYNC_IO_MODE) { + dma_addr_t phys = port->buf[data->token].phys; + + if (lower_32_bits(phys) != payload[0] || + upper_32_bits(phys) != payload[1]) { + dev_err(ac->dev, "Expected addr %pa\n", + &port->buf[data->token].phys); + return -EINVAL; + } + token = data->token; + port->buf[token].used = 1; + } + break; + } + } + if (ac->cb) + ac->cb(client_event, data->token, data->payload, ac->priv); + + return 0; +} + +struct audio_client *q6asm_audio_client_alloc(struct q6asm *a, + struct device *dev, + app_cb cb, void *priv) +{ + struct audio_client *ac; + int n; + + ac = kzalloc(sizeof(struct audio_client), GFP_KERNEL); + if (!ac) + return NULL; + + n = q6asm_session_alloc(ac); + if (n <= 0) { + dev_err(dev, "ASM Session alloc fail n=%d\n", n); + goto fail_session; + } + + ac->session = n; + ac->cb = cb; + ac->dev = dev; + ac->priv = priv; + ac->io_mode = SYNC_IO_MODE; + ac->perf_mode = LEGACY_PCM_MODE; + /* DSP expects stream id from 1 */ + ac->stream_id = 1; + ac->apr = apr_register(dev, "ADSP", "ASM", q6asm_callback, + ((ac->session) << 8 | 0x0001), ac); + + if (ac->apr == NULL) { + dev_err(dev, "Registration with APR failed\n"); + goto fail_apr1; + } + + /* Common mmap APR service */ + if (!a->mmap_apr) { + a->mmap_apr = apr_register(a->dev, "ADSP", "ASM", + q6asm_srvc_callback, + 0x0FFFFFFFF, NULL); + if (a->mmap_apr == NULL) { + pr_err("Unable to register q6asm mmap service\n"); + goto fail_mmap; + } + } + + init_waitqueue_head(&ac->cmd_wait); + mutex_init(&ac->cmd_lock); + ac->cmd_state = 0; + + pr_debug("%s: session[%d]\n", __func__, ac->session); + + return ac; +fail_mmap: + apr_deregister(ac->apr); +fail_apr1: + q6asm_session_free(ac); +fail_session: + kfree(ac); + return NULL; +} +EXPORT_SYMBOL_GPL(q6asm_audio_client_alloc); + +static int __q6asm_open_write(struct audio_client *ac, uint32_t format, + uint16_t bits_per_sample, uint32_t stream_id, + bool is_gapless_mode) +{ + struct asm_stream_cmd_open_write_v3 open; + int rc; + + q6asm_add_hdr(ac, &open.hdr, sizeof(open), true, stream_id); + ac->cmd_state = -1; + dev_vdbg(ac->dev, "%s: token = 0x%x, stream_id %d, session 0x%x\n", + __func__, open.hdr.token, stream_id, ac->session); + open.hdr.opcode = ASM_STREAM_CMD_OPEN_WRITE_V3; + open.mode_flags = 0x00; + open.mode_flags |= ASM_LEGACY_STREAM_SESSION; + if (is_gapless_mode) + open.mode_flags |= 1 << ASM_SHIFT_GAPLESS_MODE_FLAG; + + /* source endpoint : matrix */ + open.sink_endpointype = ASM_END_POINT_DEVICE_MATRIX; + open.bits_per_sample = bits_per_sample; + open.postprocopo_id = DEFAULT_POPP_TOPOLOGY; + + switch (format) { + case FORMAT_LINEAR_PCM: + open.dec_fmt_id = ASM_MEDIA_FMT_MULTI_CHANNEL_PCM_V2; + break; + default: + dev_err(ac->dev, "Invalid format 0x%x\n", format); + return -EINVAL; + } + rc = apr_send_pkt(ac->apr, (uint32_t *) &open); + if (rc < 0) + return rc; + + rc = wait_event_timeout(ac->cmd_wait, (ac->cmd_state >= 0), 5 * HZ); + if (!rc) { + dev_err(ac->dev, "timeout on open write\n"); + return -ETIMEDOUT; + } + + if (ac->cmd_state > 0) + return adsp_err_get_lnx_err_code(ac->cmd_state); + + ac->io_mode |= TUN_WRITE_IO_MODE; + + return 0; +} + +int q6asm_open_write(struct audio_client *ac, uint32_t format, + uint16_t bits_per_sample) +{ + return __q6asm_open_write(ac, format, bits_per_sample, + ac->stream_id, false); +} +EXPORT_SYMBOL_GPL(q6asm_open_write); + +static int __q6asm_run(struct audio_client *ac, uint32_t flags, + uint32_t msw_ts, uint32_t lsw_ts, bool wait) +{ + struct asm_session_cmd_run_v2 run; + int rc; + + q6asm_add_hdr(ac, &run.hdr, sizeof(run), true, ac->stream_id); + ac->cmd_state = -1; + + run.hdr.opcode = ASM_SESSION_CMD_RUN_V2; + run.flags = flags; + run.time_lsw = lsw_ts; + run.time_msw = msw_ts; + + rc = apr_send_pkt(ac->apr, (uint32_t *) &run); + if (rc < 0) + return rc; + + if (wait) { + rc = wait_event_timeout(ac->cmd_wait, (ac->cmd_state >= 0), + 5 * HZ); + if (!rc) { + dev_err(ac->dev, "timeout on run cmd\n"); + return -ETIMEDOUT; + } + if (ac->cmd_state > 0) + return adsp_err_get_lnx_err_code(ac->cmd_state); + } + + return 0; +} + +int q6asm_run(struct audio_client *ac, uint32_t flags, + uint32_t msw_ts, uint32_t lsw_ts) +{ + return __q6asm_run(ac, flags, msw_ts, lsw_ts, true); +} +EXPORT_SYMBOL_GPL(q6asm_run); + +int q6asm_run_nowait(struct audio_client *ac, uint32_t flags, + uint32_t msw_ts, uint32_t lsw_ts) +{ + return __q6asm_run(ac, flags, msw_ts, lsw_ts, false); +} +EXPORT_SYMBOL_GPL(q6asm_run_nowait); + +int q6asm_media_format_block_multi_ch_pcm(struct audio_client *ac, + uint32_t rate, uint32_t channels, + bool use_default_chmap, + char *channel_map, + uint16_t bits_per_sample) +{ + struct asm_multi_channel_pcm_fmt_blk_v2 fmt; + u8 *channel_mapping; + int rc = 0; + + q6asm_add_hdr(ac, &fmt.hdr, sizeof(fmt), true, ac->stream_id); + ac->cmd_state = -1; + + fmt.hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2; + fmt.fmt_blk.fmt_blk_size = sizeof(fmt) - sizeof(fmt.hdr) - + sizeof(fmt.fmt_blk); + fmt.num_channels = channels; + fmt.bits_per_sample = bits_per_sample; + fmt.sample_rate = rate; + fmt.is_signed = 1; + + channel_mapping = fmt.channel_mapping; + + if (use_default_chmap) { + if (q6dsp_map_channels(channel_mapping, channels)) { + dev_err(ac->dev, " map channels failed %d\n", channels); + return -EINVAL; + } + } else { + memcpy(channel_mapping, channel_map, + PCM_FORMAT_MAX_NUM_CHANNEL); + } + + rc = apr_send_pkt(ac->apr, (uint32_t *) &fmt); + if (rc < 0) + goto fail_cmd; + + rc = wait_event_timeout(ac->cmd_wait, (ac->cmd_state >= 0), 5 * HZ); + if (!rc) { + dev_err(ac->dev, "timeout on format update\n"); + return -ETIMEDOUT; + } + if (ac->cmd_state > 0) + return adsp_err_get_lnx_err_code(ac->cmd_state); + + return 0; +fail_cmd: + return rc; +} +EXPORT_SYMBOL_GPL(q6asm_media_format_block_multi_ch_pcm); + +int q6asm_write_nolock(struct audio_client *ac, uint32_t len, uint32_t msw_ts, + uint32_t lsw_ts, uint32_t flags) +{ + struct asm_data_cmd_write_v2 write; + struct audio_port_data *port; + struct audio_buffer *ab; + int dsp_buf = 0; + int rc = 0; + + if (ac->io_mode & SYNC_IO_MODE) { + port = &ac->port[SNDRV_PCM_STREAM_PLAYBACK]; + q6asm_add_hdr(ac, &write.hdr, sizeof(write), false, + ac->stream_id); + + dsp_buf = port->dsp_buf; + ab = &port->buf[dsp_buf]; + + write.hdr.token = port->dsp_buf; + write.hdr.opcode = ASM_DATA_CMD_WRITE_V2; + write.buf_addr_lsw = lower_32_bits(ab->phys); + write.buf_addr_msw = upper_32_bits(ab->phys); + write.buf_size = len; + write.seq_id = port->dsp_buf; + write.timestamp_lsw = lsw_ts; + write.timestamp_msw = msw_ts; + write.mem_map_handle = + ac->port[SNDRV_PCM_STREAM_PLAYBACK].mem_map_handle; + + if (flags == NO_TIMESTAMP) + write.flags = (flags & 0x800000FF); + else + write.flags = (0x80000000 | flags); + + port->dsp_buf++; + + if (port->dsp_buf >= port->max_buf_cnt) + port->dsp_buf = 0; + + rc = apr_send_pkt(ac->apr, (uint32_t *) &write); + if (rc < 0) + return rc; + } + + return 0; +} +EXPORT_SYMBOL_GPL(q6asm_write_nolock); + +static void q6asm_reset_buf_state(struct audio_client *ac) +{ + int cnt = 0; + int loopcnt = 0; + int used; + struct audio_port_data *port = NULL; + + if (ac->io_mode & SYNC_IO_MODE) { + used = (ac->io_mode & TUN_WRITE_IO_MODE ? 1 : 0); + mutex_lock(&ac->cmd_lock); + for (loopcnt = 0; loopcnt <= SNDRV_PCM_STREAM_CAPTURE; + loopcnt++) { + port = &ac->port[loopcnt]; + cnt = port->max_buf_cnt - 1; + port->dsp_buf = 0; + port->cpu_buf = 0; + while (cnt >= 0) { + if (!port->buf) + continue; + port->buf[cnt].used = used; + cnt--; + } + } + mutex_unlock(&ac->cmd_lock); + } +} + +static int __q6asm_cmd(struct audio_client *ac, int cmd, bool wait) +{ + int stream_id = ac->stream_id; + struct apr_hdr hdr; + int rc; + + q6asm_add_hdr(ac, &hdr, sizeof(hdr), true, stream_id); + ac->cmd_state = -1; + switch (cmd) { + case CMD_PAUSE: + hdr.opcode = ASM_SESSION_CMD_PAUSE; + break; + case CMD_SUSPEND: + hdr.opcode = ASM_SESSION_CMD_SUSPEND; + break; + case CMD_FLUSH: + hdr.opcode = ASM_STREAM_CMD_FLUSH; + break; + case CMD_OUT_FLUSH: + hdr.opcode = ASM_STREAM_CMD_FLUSH_READBUFS; + break; + case CMD_EOS: + hdr.opcode = ASM_DATA_CMD_EOS; + ac->cmd_state = 0; + break; + case CMD_CLOSE: + hdr.opcode = ASM_STREAM_CMD_CLOSE; + break; + default: + return -EINVAL; + } + + rc = apr_send_pkt(ac->apr, (uint32_t *) &hdr); + if (rc < 0) + return rc; + + if (!wait) + return 0; + + rc = wait_event_timeout(ac->cmd_wait, (ac->cmd_state >= 0), 5 * HZ); + if (!rc) { + dev_err(ac->dev, "timeout response for opcode[0x%x]\n", + hdr.opcode); + return -ETIMEDOUT; + } + if (ac->cmd_state > 0) + return adsp_err_get_lnx_err_code(ac->cmd_state); + + if (cmd == CMD_FLUSH) + q6asm_reset_buf_state(ac); + + return 0; +} + +int q6asm_cmd(struct audio_client *ac, int cmd) +{ + return __q6asm_cmd(ac, cmd, true); +} +EXPORT_SYMBOL_GPL(q6asm_cmd); + +int q6asm_cmd_nowait(struct audio_client *ac, int cmd) +{ + return __q6asm_cmd(ac, cmd, false); +} +EXPORT_SYMBOL_GPL(q6asm_cmd_nowait); + +struct q6asm *q6asm_get(struct device *dev) +{ + if (!__q6asm) + return ERR_PTR(-EPROBE_DEFER); + + return __q6asm; +} +EXPORT_SYMBOL_GPL(q6asm_get); + +void q6asm_put(struct q6asm *a) +{ +} +EXPORT_SYMBOL_GPL(q6asm_put); + +static int q6asm_probe(struct platform_device *pdev) +{ + __q6asm = kzalloc(sizeof(*__q6asm), GFP_KERNEL); + if (!__q6asm) + return -ENOMEM; + + __q6asm->dev = &pdev->dev; + __q6asm->mem_state = 0; + init_waitqueue_head(&__q6asm->mem_wait); + mutex_init(&__q6asm->session_lock); + + return 0; +} + +static int q6asm_remove(struct platform_device *pdev) +{ + if (__q6asm->mmap_apr) + return apr_deregister(__q6asm->mmap_apr); + + kfree(__q6asm); + __q6asm = NULL; + + return 0; +} + +static const struct of_device_id qcom_q6asm_match[] = { + {.compatible = "qcom,q6asm-v2",}, + {} +}; + +static struct platform_driver qcom_q6asm_driver = { + .probe = q6asm_probe, + .remove = q6asm_remove, + .driver = { + .name = "qcom-q6asm", + .of_match_table = qcom_q6asm_match, + }, +}; + +module_platform_driver(qcom_q6asm_driver); +MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org"); +MODULE_DESCRIPTION("q6 Audio Stream Manager driver"); +MODULE_LICENSE("GPL v2");

From: Srinivas Kandagatla srinivas.kandagatla@linaro.org

This patch adds support to HDMI backend dai driver.

Signed-off-by: Srinivas Kandagatla srinivas.kandagatla@linaro.org --- .../devicetree/bindings/sound/qcom,q6hdmi.txt | 27 +++ sound/soc/qcom/Kconfig | 4 + sound/soc/qcom/qdsp6v2/Makefile | 1 + sound/soc/qcom/qdsp6v2/q6hdmi.c | 258 +++++++++++++++++++++ 4 files changed, 290 insertions(+) create mode 100644 Documentation/devicetree/bindings/sound/qcom,q6hdmi.txt create mode 100644 sound/soc/qcom/qdsp6v2/q6hdmi.c

diff --git a/Documentation/devicetree/bindings/sound/qcom,q6hdmi.txt b/Documentation/devicetree/bindings/sound/qcom,q6hdmi.txt new file mode 100644 index 0000000..a38f58a --- /dev/null +++ b/Documentation/devicetree/bindings/sound/qcom,q6hdmi.txt @@ -0,0 +1,27 @@ +Qualcomm Q6 HDMI DAI binding + +This bindings describe the Qualcomm Q6 HDMI dai. + +- compatible: + + Usage: required + Value type: <stringlist> + Definition: must be "qcom,q6hdmi-v<VERSION-NUMBER>" + example: "qcom,q6hdmi-v2" +- qcom,afe-port: + Usage: required + Value type: <prop-encoded-array> + Definition: handle to AFE port + +#sound-dai-cells: + Usage: required + Value type: <integer> + Definition: Must be equal to 0 + + += EXAMPLE + q6hdmi { + compatible = "qcom,q6hdmi-v2"; + qcom,afe-port = <&afe AFE_PORT_HDMI_RX>; + #sound-dai-cells = <0>; + }; diff --git a/sound/soc/qcom/Kconfig b/sound/soc/qcom/Kconfig index 9a5b3f0..5035d37 100644 --- a/sound/soc/qcom/Kconfig +++ b/sound/soc/qcom/Kconfig @@ -60,6 +60,9 @@ config SND_SOC_QDSP6V2_ROUTING tristate default n

+config SND_SOC_QDSP6V2_HDMI + tristate + default n

config SND_SOC_QDSP6V2 tristate "SoC ALSA audio driver for QDSP6V2" @@ -67,6 +70,7 @@ config SND_SOC_QDSP6V2 select SND_SOC_QDSP6V2_ADM select SND_SOC_QDSP6V2_ASM select SND_SOC_QDSP6V2_ROUTING + select SND_SOC_QDSP6V2_HDMI help To add support for MSM QDSP6V2 Soc Audio. This will enable sound soc platform specific diff --git a/sound/soc/qcom/qdsp6v2/Makefile b/sound/soc/qcom/qdsp6v2/Makefile index 81d2341..4cab915 100644 --- a/sound/soc/qcom/qdsp6v2/Makefile +++ b/sound/soc/qcom/qdsp6v2/Makefile @@ -2,3 +2,4 @@ obj-$(CONFIG_SND_SOC_QDSP6V2_AFE) += q6afe.o obj-$(CONFIG_SND_SOC_QDSP6V2_ADM) += q6adm.o obj-$(CONFIG_SND_SOC_QDSP6V2_ASM) += q6asm.o obj-$(CONFIG_SND_SOC_QDSP6V2_ROUTING) += q6routing.o +obj-$(CONFIG_SND_SOC_QDSP6V2_HDMI) += q6hdmi.o diff --git a/sound/soc/qcom/qdsp6v2/q6hdmi.c b/sound/soc/qcom/qdsp6v2/q6hdmi.c new file mode 100644 index 0000000..020a377 --- /dev/null +++ b/sound/soc/qcom/qdsp6v2/q6hdmi.c @@ -0,0 +1,258 @@ +/* Copyright (c) 2012-2015, 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/err.h> +#include <linux/init.h> +#include <linux/module.h> +#include <linux/device.h> +#include <linux/platform_device.h> +#include <linux/slab.h> +#include <sound/pcm.h> +#include <sound/soc.h> +#include <sound/pcm_params.h> +#include <dt-bindings/sound/qcom,afe.h> +#include "q6afe-v2.h" + +struct q6hdmi_dai_data { + struct q6afe_port *port; + struct q6afe_hdmi_cfg port_config; + bool is_port_started; +}; + +static int q6hdmi_format_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct q6hdmi_dai_data *dai_data = kcontrol->private_data; + int value = ucontrol->value.integer.value[0]; + + dai_data->port_config.datatype = value; + + return 0; +} + +static int q6hdmi_format_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + + struct q6hdmi_dai_data *dai_data = kcontrol->private_data; + + ucontrol->value.integer.value[0] = + dai_data->port_config.datatype; + + return 0; +} + +static const char * const hdmi_format[] = { + "LPCM", + "Compr" +}; + +static const struct soc_enum hdmi_config_enum[] = { + SOC_ENUM_SINGLE_EXT(2, hdmi_format), +}; + +static const struct snd_kcontrol_new hdmi_config_controls[] = { + SOC_ENUM_EXT("HDMI RX Format", hdmi_config_enum[0], + q6hdmi_format_get, + q6hdmi_format_put), +}; + +static int q6hdmi_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + struct q6hdmi_dai_data *dai_data = dev_get_drvdata(dai->dev); + int channels = params_channels(params); + + dai_data->port_config.sample_rate = params_rate(params); + switch (params_format(params)) { + case SNDRV_PCM_FORMAT_S16_LE: + dai_data->port_config.bit_width = 16; + break; + case SNDRV_PCM_FORMAT_S24_LE: + dai_data->port_config.bit_width = 24; + break; + } + + /*refer to HDMI spec CEA-861-E: Table 28 Audio InfoFrame Data Byte 4*/ + switch (channels) { + case 2: + dai_data->port_config.channel_allocation = 0; + break; + case 3: + dai_data->port_config.channel_allocation = 0x02; + break; + case 4: + dai_data->port_config.channel_allocation = 0x06; + break; + case 5: + dai_data->port_config.channel_allocation = 0x0A; + break; + case 6: + dai_data->port_config.channel_allocation = 0x0B; + break; + case 7: + dai_data->port_config.channel_allocation = 0x12; + break; + case 8: + dai_data->port_config.channel_allocation = 0x13; + break; + default: + dev_err(dai->dev, "invalid Channels = %u\n", channels); + return -EINVAL; + } + + return 0; +} + +static int q6hdmi_startup(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + struct q6hdmi_dai_data *dai_data = dev_get_drvdata(dai->dev); + + dai_data->is_port_started = false; + + return 0; +} + +static void q6hdmi_shutdown(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + struct q6hdmi_dai_data *dai_data = dev_get_drvdata(dai->dev); + int rc; + + rc = q6afe_port_stop(dai_data->port); + if (rc < 0) + dev_err(dai->dev, "fail to close AFE port\n"); + + dai_data->is_port_started = false; + +} + +static int q6hdmi_prepare(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + struct q6hdmi_dai_data *dai_data = dev_get_drvdata(dai->dev); + int rc; + + + if (dai_data->is_port_started) { + /* stop the port and restart with new port config */ + rc = q6afe_port_stop(dai_data->port); /* can block */ + if (rc < 0) { + dev_err(dai->dev, "fail to close AFE port\n"); + return rc; + } + } + + rc = q6afe_hdmi_port_start(dai_data->port, &dai_data->port_config); + if (rc < 0) { + dev_err(dai->dev, "fail to open AFE port %x\n", dai->id); + return rc; + } + + dai_data->is_port_started = true; + + return 0; +} + +static const struct snd_soc_dapm_route hdmi_dapm_routes[] = { + {"HDMI Playback", NULL, "HDMI"}, +}; + +static struct snd_soc_dai_ops q6hdmi_ops = { + .prepare = q6hdmi_prepare, + .hw_params = q6hdmi_hw_params, + .shutdown = q6hdmi_shutdown, + .startup = q6hdmi_startup, +}; + +static struct snd_soc_dai_driver q6hdmi_hdmi_rx_dai = { + .playback = { + .stream_name = "HDMI Playback", + .rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | + SNDRV_PCM_RATE_192000, + .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE, + .channels_min = 2, + .channels_max = 8, + .rate_max = 192000, + .rate_min = 48000, + }, + .ops = &q6hdmi_ops, + .name = "HDMI", +}; + +static const struct snd_soc_dapm_widget hdmi_dapm_widgets[] = { + SND_SOC_DAPM_AIF_OUT("HDMI", "HDMI Playback", 0, 0, 0, 0), + SND_SOC_DAPM_OUTPUT("HDMI-RX"), +}; + +static const struct snd_soc_component_driver msm_dai_hdmi_q6_component = { + .name = "msm-dai-q6-hdmi", + .dapm_widgets = hdmi_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(hdmi_dapm_widgets), + .controls = hdmi_config_controls, + .num_controls = ARRAY_SIZE(hdmi_config_controls), + .dapm_routes = hdmi_dapm_routes, + .num_dapm_routes = ARRAY_SIZE(hdmi_dapm_routes), +}; + +static int q6hdmi_dev_probe(struct platform_device *pdev) +{ + struct q6hdmi_dai_data *dai_data; + int rc = 0; + struct q6afe_port *port; + + dai_data = devm_kzalloc(&pdev->dev, sizeof(*dai_data), GFP_KERNEL); + if (!dai_data) + rc = -ENOMEM; + + port = q6afe_port_get(&pdev->dev, "qcom,afe-port"); + if (IS_ERR(port)) { + dev_err(&pdev->dev, "Unable to get afe port\n"); + return -EPROBE_DEFER; + } + dai_data->port = port; + q6hdmi_hdmi_rx_dai.id = q6afe_get_port_index(port); + dev_set_drvdata(&pdev->dev, dai_data); + + return snd_soc_register_component(&pdev->dev, + &msm_dai_hdmi_q6_component, + &q6hdmi_hdmi_rx_dai, 1); +} + +static int q6hdmi_dev_remove(struct platform_device *pdev) +{ + struct q6hdmi_dai_data *dai_data = dev_get_drvdata(&pdev->dev); + + q6afe_port_put(dai_data->port); + snd_soc_unregister_component(&pdev->dev); + + return 0; +} + +static const struct of_device_id q6hdmi_dt_match[] = { + {.compatible = "qcom,q6hdmi-v2"}, + {} +}; +MODULE_DEVICE_TABLE(of, q6hdmi_dt_match); + +static struct platform_driver q6hdmi_driver = { + .probe = q6hdmi_dev_probe, + .remove = q6hdmi_dev_remove, + .driver = { + .name = "q6-hdmi", + .owner = THIS_MODULE, + .of_match_table = q6hdmi_dt_match, + }, +}; + +module_platform_driver(q6hdmi_driver);

From: Srinivas Kandagatla srinivas.kandagatla@linaro.org

uThis patch adds support to DB820c machine driver.

Signed-off-by: Srinivas Kandagatla srinivas.kandagatla@linaro.org --- .../devicetree/bindings/sound/qcom,apq8096.txt | 85 ++++++++++ sound/soc/qcom/Kconfig | 9 +- sound/soc/qcom/Makefile | 2 + sound/soc/qcom/apq8096.c | 174 +++++++++++++++++++++ 4 files changed, 269 insertions(+), 1 deletion(-) create mode 100644 Documentation/devicetree/bindings/sound/qcom,apq8096.txt create mode 100644 sound/soc/qcom/apq8096.c

diff --git a/Documentation/devicetree/bindings/sound/qcom,apq8096.txt b/Documentation/devicetree/bindings/sound/qcom,apq8096.txt new file mode 100644 index 0000000..cf6a15b --- /dev/null +++ b/Documentation/devicetree/bindings/sound/qcom,apq8096.txt @@ -0,0 +1,85 @@ +* Qualcomm Technologies APQ8096 ASoC sound card driver + +This binding describes the APQ8096 sound card, which uses qdsp for audio. + +- compatible: + Usage: required + Value type: <stringlist> + Definition: must be "qcom,apq8096-sndcard" + += FRONTEND and BACKEND dailinks +Each subnode of sndcard represents either frontend or backend dailink, +and subnodes of each backend/frontend dailinks would be +cpu/codec/platform dais. + +- fe: + Usage: required + Value type: <subnode> + Definition: FrontEnd CPU dailink sub-node + +- be: + Usage: required + Value type: <subnode> + Definition: BackEnd dailink sub-node + +- link-name: + Usage: required + Value type: <string>msm_dai_q6_hdmi + Definition: User friendly name for dai link + +- is-fe: + Usage: optional + Value type: <bool> + Definition: present if the dailink is frontend + + += CPU, PLATFORM, CODEC dais subnodes +- cpu: + Usage: required + Value type: <subnode> + Definition: cpu dai sub-node + +- codec: + Usage: required + Value type: <subnode> + Definition: codec dai sub-node + +- platform: + Usage: opional + Value type: <subnode> + Definition: platform dai sub-node + +- sound-dai: + Usage: required + Value type: <phandle> + Definition: phandle/s and port of CPU/CODEC/PLATFORM dais + +Example: + sound { + compatible = "qcom,snd-apq8096"; + qcom,model = "DB820c"; + + fe@1 { + is-fe; + link-name = "MultiMedia1 PCM"; + cpu { + sound-dai = <&pcm MSM_FRONTEND_DAI_MULTIMEDIA1>; + }; + platform { + sound-dai = <&pcm MSM_FRONTEND_DAI_MULTIMEDIA1>; + }; + }; + + be@1 { + link-name = "HDMI"; + cpu { + sound-dai = <&hdmi_dai>; + }; + platform { + sound-dai = <&routing>; + }; + codec { + sound-dai = <&hdmi>; + }; + }; + }; diff --git a/sound/soc/qcom/Kconfig b/sound/soc/qcom/Kconfig index a2aa480..c190d11 100644 --- a/sound/soc/qcom/Kconfig +++ b/sound/soc/qcom/Kconfig @@ -68,7 +68,6 @@ config SND_SOC_QDSP6V2_PCM tristate default n

- config SND_SOC_QDSP6V2 tristate "SoC ALSA audio driver for QDSP6V2" select SND_SOC_QDSP6V2_AFE @@ -82,3 +81,11 @@ config SND_SOC_QDSP6V2 This will enable sound soc platform specific audio drivers. This includes q6asm, q6adm, q6afe interfaces to DSP using apr. + +config SND_SOC_MSM8996 + tristate "SoC Machine driver for MSM8996 and APQ8096 boards" + select SND_SOC_QDSP6V2 + default n + help + To add support for SoC audio on MSM8996 and APQ8096 boards + diff --git a/sound/soc/qcom/Makefile b/sound/soc/qcom/Makefile index a51bf0a..f3889c4 100644 --- a/sound/soc/qcom/Makefile +++ b/sound/soc/qcom/Makefile @@ -12,9 +12,11 @@ obj-$(CONFIG_SND_SOC_LPASS_APQ8016) += snd-soc-lpass-apq8016.o # Machine snd-soc-storm-objs := storm.o snd-soc-apq8016-sbc-objs := apq8016_sbc.o +snd-soc-msm8996-objs := apq8096.o

obj-$(CONFIG_SND_SOC_STORM) += snd-soc-storm.o obj-$(CONFIG_SND_SOC_APQ8016_SBC) += snd-soc-apq8016-sbc.o +obj-$(CONFIG_SND_SOC_MSM8996) += snd-soc-msm8996.o

#DSP lib obj-$(CONFIG_SND_SOC_QDSP6V2) += qdsp6v2/ diff --git a/sound/soc/qcom/apq8096.c b/sound/soc/qcom/apq8096.c new file mode 100644 index 0000000..de62613 --- /dev/null +++ b/sound/soc/qcom/apq8096.c @@ -0,0 +1,174 @@ +/* + * Copyright (c) 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/clk.h> +#include <linux/platform_device.h> +#include <linux/module.h> +#include <linux/of_device.h> +#include <sound/soc.h> +#include <sound/soc-dapm.h> +#include <sound/pcm.h> +#include <dt-bindings/sound/qcom,afe.h> +#include <dt-bindings/sound/qcom,asm.h> + +int msm8996_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, + struct snd_pcm_hw_params *params) +{ + struct snd_interval *rate = hw_param_interval(params, + SNDRV_PCM_HW_PARAM_RATE); + struct snd_interval *channels = hw_param_interval(params, + SNDRV_PCM_HW_PARAM_CHANNELS); + + rate->min = rate->max = 48000; + channels->min = channels->max = 2; + + return 0; +} + +static int apq8096_sbc_parse_of(struct snd_soc_card *card) +{ + struct device *dev = card->dev; + struct snd_soc_dai_link *link; + struct device_node *np, *codec, *platform, *cpu, *node = dev->of_node; + int ret, num_links; + bool is_fe; + + ret = snd_soc_of_parse_card_name(card, "qcom,model"); + if (ret) { + dev_err(dev, "Error parsing card name: %d\n", ret); + return ret; + } + + num_links = of_get_child_count(node); + + /* Allocate the private data and the DAI link array */ + card->dai_link = devm_kzalloc(dev, sizeof(*link) * num_links, + GFP_KERNEL); + if (!card->dai_link) + return -ENOMEM; + + card->num_links = num_links; + + link = &card->dai_link[0]; + + for_each_child_of_node(node, np) { + is_fe = false; + if (of_property_read_bool(np, "is-fe")) + is_fe = true; + + if (is_fe) { + /* BE is dummy */ + link->codec_of_node = NULL; + link->codec_dai_name = "snd-soc-dummy-dai"; + link->codec_name = "snd-soc-dummy"; + + /* FE settings */ + link->dynamic = 1; + link->dpcm_playback = 1; + + } else { + link->no_pcm = 1; + link->dpcm_playback = 1; + link->be_hw_params_fixup = msm8996_be_hw_params_fixup; + } + + cpu = of_get_child_by_name(np, "cpu"); + platform = of_get_child_by_name(np, "platform"); + codec = of_get_child_by_name(np, "codec"); + + if (!cpu) { + dev_err(dev, "Can't find cpu DT node\n"); + return -EINVAL; + } + + link->cpu_of_node = of_parse_phandle(cpu, "sound-dai", 0); + if (!link->cpu_of_node) { + dev_err(card->dev, "error getting cpu phandle\n"); + return -EINVAL; + } + + link->platform_of_node = of_parse_phandle(platform, + "sound-dai", 0); + if (!link->platform_of_node) { + dev_err(card->dev, "error getting platform phandle\n"); + return -EINVAL; + } + + ret = snd_soc_of_get_dai_name(cpu, &link->cpu_dai_name); + if (ret) { + dev_err(card->dev, "error getting cpu dai name\n"); + return ret; + } + + if (codec) { + ret = snd_soc_of_get_dai_link_codecs(dev, codec, link); + + if (ret < 0) { + dev_err(card->dev, "error getting codec dai name\n"); + return ret; + } + } + + ret = of_property_read_string(np, "link-name", &link->name); + if (ret) { + dev_err(card->dev, "error getting codec dai_link name\n"); + return ret; + } + + link->stream_name = link->name; + link++; + } + + return 0; +} + +static int msm_snd_apq8096_probe(struct platform_device *pdev) +{ + int ret; + struct snd_soc_card *card; + + card = devm_kzalloc(&pdev->dev, sizeof(*card), GFP_KERNEL); + if (!card) + return -ENOMEM; + + card->dev = &pdev->dev; + ret = apq8096_sbc_parse_of(card); + if (ret) { + dev_err(&pdev->dev, "Error parsing OF data\n"); + return ret; + } + + ret = devm_snd_soc_register_card(&pdev->dev, card); + if (ret) + dev_err(&pdev->dev, "sound card register faile (%d)!\n", ret); + + return ret; +} + +static const struct of_device_id msm_snd_apq8096_dt_match[] = { + {.compatible = "qcom,apq8096-sndcard"}, + {} +}; + +static struct platform_driver msm_snd_apq8096_driver = { + .probe = msm_snd_apq8096_probe, + .driver = { + .name = "msm-snd-apq8096", + .owner = THIS_MODULE, + .of_match_table = msm_snd_apq8096_dt_match, + }, +}; +module_platform_driver(msm_snd_apq8096_driver); +MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org"); +MODULE_DESCRIPTION("APQ8096 ASoC Machine Driver"); +MODULE_LICENSE("GPL v2");