redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

MLK-17747: dsp: use the name of dsp instead of hifi 

In order to avoid the name problem going forward with
integration with Qcom, Qcom has their own dsp and hifi
is competitor, so the hifi name should not be used in
our code.

So use the name of dsp instead of hifi to fix this
problem.

Signed-off-by: Weiguang Kong <weiguang.kong@nxp.com>
5.4-rM2-2.2.x-imx-squashed
Weiguang Kong 2018-04-18 23:36:37 +08:00 committed by Dong Aisheng
parent 7d17cbca37
commit 6b7b1ae0ec
8 changed files with 303 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Documentation/devicetree/bindings/sound/fsl,hifi4.txt → Documentation/devicetree/bindings/sound/fsl,dsp.txt
View File

@ -1,16 +1,16 @@
NXP HIFI4 DSP (HIFI4) NXP DSP
The IP is from Cadence. The IP is from Cadence.
Required properties: Required properties:
- compatible : Contains "fsl,imx8qxp-hifi4". - compatible : Contains "fsl,imx8qxp-dsp".
- reg : Offset and length of the register set for the device. - reg : Offset and length of the register set for the device.
Example: Example:
hifi4: hifi4@596e8000 { dsp: dsp@596e8000 {
compatible = "fsl,imx8qxp-hifi4"; compatible = "fsl,imx8qxp-dsp";
reg = <0x0 0x596e8000 0x0 0x88000>; reg = <0x0 0x596e8000 0x0 0x88000>;
status = "okay"; status = "okay";
}; };

43
include/uapi/linux/mxc_hifi4.h → include/uapi/linux/mxc_dsp.h
View File

@ -4,26 +4,27 @@
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met: * modification, are permitted provided that the following conditions are met:
* *
* 1. Redistributions of source code must retain the above copyright notice, this * 1. Redistributions of source code must retain the above copyright notice,
* list of conditions and the following disclaimer. * this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice, * 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation * this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution. * and/or other materials provided with the distribution.
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __MXC_HIFI4_UAPI_H__ #ifndef __MXC_DSP_UAPI_H__
#define __MXC_HIFI4_UAPI_H__ #define __MXC_DSP_UAPI_H__
#define DSP_IOC_MAGIC 'H' #define DSP_IOC_MAGIC 'H'
#define DSP_CLIENT_REGISTER _IOW(DSP_IOC_MAGIC, 0, unsigned int) #define DSP_CLIENT_REGISTER _IOW(DSP_IOC_MAGIC, 0, unsigned int)
@ -42,7 +43,7 @@
#define CODEC_SBC_ENC 8 #define CODEC_SBC_ENC 8
#define CODEC_DEMO_DEC 9 #define CODEC_DEMO_DEC 9
enum HIFI_ERROR_TYPE { enum DSP_ERROR_TYPE {
XA_SUCCESS = 0, XA_SUCCESS = 0,
XA_ERROR_STREAM, XA_ERROR_STREAM,
@ -59,7 +60,7 @@ enum HIFI_ERROR_TYPE {
}; };
/* Parameter type to Set /Get */ /* Parameter type to Set /Get */
enum HIFI_ParaType { enum DSP_ParaType {
/* Set parmameters */ /* Set parmameters */
/* common */ /* common */
XA_SAMPLERATE = 0, XA_SAMPLERATE = 0,
@ -108,8 +109,8 @@ enum HIFI_ParaType {
}; };
#define HIFI_STREAM_DABPLUS_BASE 0x30 #define XA_STREAM_DABPLUS_BASE 0x30
enum HIFI_StreamType { enum DSP_StreamType {
/* AAC/AACPLUS file format */ /* AAC/AACPLUS file format */
XA_STREAM_UNKNOWN = 0, XA_STREAM_UNKNOWN = 0,
XA_STREAM_ADTS, XA_STREAM_ADTS,
@ -121,7 +122,7 @@ enum HIFI_StreamType {
XA_STREAM_LOAS, XA_STREAM_LOAS,
/* DABPLUS file format */ /* DABPLUS file format */
XA_STREAM_DABPLUS_RAW_SIDEINFO = HIFI_STREAM_DABPLUS_BASE, XA_STREAM_DABPLUS_RAW_SIDEINFO = XA_STREAM_DABPLUS_BASE,
XA_STREAM_DABPLUS, XA_STREAM_DABPLUS,
/* BSAC file raw format */ /* BSAC file raw format */
@ -130,7 +131,7 @@ enum HIFI_StreamType {
}; };
/* sbc_enc-specific channel modes */ /* sbc_enc-specific channel modes */
enum HIFI_SbcEncChmode { enum DSP_SbcEncChmode {
XA_CHMODE_MONO = 0, XA_CHMODE_MONO = 0,
XA_CHMODE_DUAL = 1, XA_CHMODE_DUAL = 1,
XA_CHMODE_STEREO = 2, XA_CHMODE_STEREO = 2,
@ -142,4 +143,4 @@ struct shmem_info {
unsigned int size; unsigned int size;
}; };
#endif/* __MXC_HIFI4_UAPI_H__ */ #endif/* __MXC_DSP_UAPI_H__ */

4
sound/soc/fsl/Kconfig
View File

@ -74,8 +74,8 @@ config SND_SOC_FSL_MICFIL
Say Y if you want to add Pulse Density Modulation microphone Say Y if you want to add Pulse Density Modulation microphone
interface (MICFIL) support for NXP. interface (MICFIL) support for NXP.
config SND_SOC_FSL_HIFI4 config SND_SOC_FSL_DSP
tristate "hifi 4 module support" tristate "dsp module support"
help help
Say Y if you want to add hifi 4 support for the Freescale CPUs. Say Y if you want to add hifi 4 support for the Freescale CPUs.
which is a DSP core for audio processing. which is a DSP core for audio processing.

4
sound/soc/fsl/Makefile
View File

@ -15,7 +15,7 @@ obj-$(CONFIG_SND_SOC_P1022_RDK) += snd-soc-p1022-rdk.o
snd-soc-fsl-audmix-objs := fsl_audmix.o snd-soc-fsl-audmix-objs := fsl_audmix.o
snd-soc-fsl-asoc-card-objs := fsl-asoc-card.o snd-soc-fsl-asoc-card-objs := fsl-asoc-card.o
snd-soc-fsl-asrc-objs := fsl_asrc.o fsl_asrc_dma.o snd-soc-fsl-asrc-objs := fsl_asrc.o fsl_asrc_dma.o
snd-soc-fsl-hifi4-objs := fsl_hifi4.o fsl_hifi4_proxy.o snd-soc-fsl-dsp-objs := fsl_dsp.o fsl_dsp_proxy.o
snd-soc-fsl-sai-objs := fsl_sai.o snd-soc-fsl-sai-objs := fsl_sai.o
snd-soc-fsl-ssi-y := fsl_ssi.o snd-soc-fsl-ssi-y := fsl_ssi.o
snd-soc-fsl-ssi-$(CONFIG_DEBUG_FS) += fsl_ssi_dbg.o snd-soc-fsl-ssi-$(CONFIG_DEBUG_FS) += fsl_ssi_dbg.o
@ -28,7 +28,7 @@ snd-soc-fsl-dma-objs := fsl_dma.o
obj-$(CONFIG_SND_SOC_FSL_AUDMIX) += snd-soc-fsl-audmix.o obj-$(CONFIG_SND_SOC_FSL_AUDMIX) += snd-soc-fsl-audmix.o
obj-$(CONFIG_SND_SOC_FSL_ASOC_CARD) += snd-soc-fsl-asoc-card.o obj-$(CONFIG_SND_SOC_FSL_ASOC_CARD) += snd-soc-fsl-asoc-card.o
obj-$(CONFIG_SND_SOC_FSL_ASRC) += snd-soc-fsl-asrc.o obj-$(CONFIG_SND_SOC_FSL_ASRC) += snd-soc-fsl-asrc.o
obj-$(CONFIG_SND_SOC_FSL_HIFI4) += snd-soc-fsl-hifi4.o obj-$(CONFIG_SND_SOC_FSL_DSP) += snd-soc-fsl-dsp.o
obj-$(CONFIG_SND_SOC_FSL_SAI) += snd-soc-fsl-sai.o obj-$(CONFIG_SND_SOC_FSL_SAI) += snd-soc-fsl-sai.o
obj-$(CONFIG_SND_SOC_FSL_SSI) += snd-soc-fsl-ssi.o obj-$(CONFIG_SND_SOC_FSL_SSI) += snd-soc-fsl-ssi.o
obj-$(CONFIG_SND_SOC_FSL_SPDIF) += snd-soc-fsl-spdif.o obj-$(CONFIG_SND_SOC_FSL_SPDIF) += snd-soc-fsl-spdif.o

404
sound/soc/fsl/fsl_hifi4.c → sound/soc/fsl/fsl_dsp.c
View File

@ -1,5 +1,5 @@
/* /*
* Freescale HIFI 4 driver * Freescale DSP driver
* *
* Copyright (c) 2012-2013 by Tensilica Inc. ALL RIGHTS RESERVED. * Copyright (c) 2012-2013 by Tensilica Inc. ALL RIGHTS RESERVED.
* Copyright 2018 NXP * Copyright 2018 NXP
@ -58,20 +58,20 @@
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
#include <linux/compat.h> #include <linux/compat.h>
#endif #endif
#include <uapi/linux/mxc_hifi4.h> #include <uapi/linux/mxc_dsp.h>
#include <linux/firmware/imx/types.h> #include <linux/firmware/imx/types.h>
#include <linux/firmware/imx/svc/misc.h> #include <linux/firmware/imx/svc/misc.h>
#include <dt-bindings/firmware/imx/rsrc.h> #include <dt-bindings/firmware/imx/rsrc.h>
#include "fsl_hifi4.h" #include "fsl_dsp.h"
/* ...allocate new client */ /* ...allocate new client */
static inline struct xf_client *xf_client_alloc(struct fsl_hifi4 *hifi4_priv) static inline struct xf_client *xf_client_alloc(struct fsl_dsp *dsp_priv)
{ {
struct xf_client *client; struct xf_client *client;
u32 id; u32 id;
id = hifi4_priv->xf_client_map[0].next; id = dsp_priv->xf_client_map[0].next;
/* ...try to allocate a client handle */ /* ...try to allocate a client handle */
if (id != 0) { if (id != 0) {
@ -81,11 +81,11 @@ static inline struct xf_client *xf_client_alloc(struct fsl_hifi4 *hifi4_priv)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
/* ...advance the head of free clients */ /* ...advance the head of free clients */
hifi4_priv->xf_client_map[0].next = dsp_priv->xf_client_map[0].next =
hifi4_priv->xf_client_map[id].next; dsp_priv->xf_client_map[id].next;
/* ...put associate client id with given object */ /* ...put associate client id with given object */
hifi4_priv->xf_client_map[id].client = client; dsp_priv->xf_client_map[id].client = client;
/* ...mark client is not yet bound to proxy */ /* ...mark client is not yet bound to proxy */
client->proxy = NULL; client->proxy = NULL;
@ -104,25 +104,25 @@ static inline struct xf_client *xf_client_alloc(struct fsl_hifi4 *hifi4_priv)
static inline void xf_client_free(struct xf_client *client) static inline void xf_client_free(struct xf_client *client)
{ {
int id = client->id; int id = client->id;
struct fsl_hifi4 *hifi4_priv = (struct fsl_hifi4 *)client->global; struct fsl_dsp *dsp_priv = (struct fsl_dsp *)client->global;
/* ...put proxy client id into free clients list */ /* ...put proxy client id into free clients list */
hifi4_priv->xf_client_map[id].next = hifi4_priv->xf_client_map[0].next; dsp_priv->xf_client_map[id].next = dsp_priv->xf_client_map[0].next;
hifi4_priv->xf_client_map[0].next = id; dsp_priv->xf_client_map[0].next = id;
/* ...destroy client data */ /* ...destroy client data */
kfree(client); kfree(client);
} }
/* ...lookup client basing on id */ /* ...lookup client basing on id */
struct xf_client *xf_client_lookup(struct fsl_hifi4 *hifi4_priv, u32 id) struct xf_client *xf_client_lookup(struct fsl_dsp *dsp_priv, u32 id)
{ {
if ((id >= XF_CFG_MAX_IPC_CLIENTS) || if ((id >= XF_CFG_MAX_IPC_CLIENTS) ||
(hifi4_priv->xf_client_map[id].next < XF_CFG_MAX_IPC_CLIENTS) (dsp_priv->xf_client_map[id].next < XF_CFG_MAX_IPC_CLIENTS)
) )
return NULL; return NULL;
else else
return hifi4_priv->xf_client_map[id].client; return dsp_priv->xf_client_map[id].client;
} }
/* ...helper function for retrieving the client handle */ /* ...helper function for retrieving the client handle */
@ -144,11 +144,11 @@ static inline struct xf_client *xf_get_client(struct file *file)
static int fsl_dsp_client_register(struct xf_client *client) static int fsl_dsp_client_register(struct xf_client *client)
{ {
struct fsl_hifi4 *hifi4_priv; struct fsl_dsp *dsp_priv;
struct device *dev; struct device *dev;
hifi4_priv = (struct fsl_hifi4 *)client->global; dsp_priv = (struct fsl_dsp *)client->global;
dev = hifi4_priv->dev; dev = dsp_priv->dev;
/* ...make sure client is not registered yet */ /* ...make sure client is not registered yet */
if (client->proxy != NULL) { if (client->proxy != NULL) {
@ -157,7 +157,7 @@ static int fsl_dsp_client_register(struct xf_client *client)
} }
/* ...complete association (no communication with remote proxy here) */ /* ...complete association (no communication with remote proxy here) */
client->proxy = &hifi4_priv->proxy; client->proxy = &dsp_priv->proxy;
pr_debug("client-%x registered within proxy", client->id); pr_debug("client-%x registered within proxy", client->id);
@ -186,8 +186,8 @@ static int fsl_dsp_client_unregister(struct xf_client *client)
static int fsl_dsp_ipc_msg_to_dsp(struct xf_client *client, static int fsl_dsp_ipc_msg_to_dsp(struct xf_client *client,
void __user *user) void __user *user)
{ {
struct fsl_hifi4 *hifi4_priv = (struct fsl_hifi4 *)client->global; struct fsl_dsp *dsp_priv = (struct fsl_dsp *)client->global;
struct device *dev = hifi4_priv->dev; struct device *dev = dsp_priv->dev;
struct xf_proxy_message msg; struct xf_proxy_message msg;
void *buffer; void *buffer;
unsigned long ret = 0; unsigned long ret = 0;
@ -199,14 +199,14 @@ static int fsl_dsp_ipc_msg_to_dsp(struct xf_client *client,
} }
/* ...make sure message pointer is sane */ /* ...make sure message pointer is sane */
buffer = xf_proxy_a2b(&hifi4_priv->proxy, msg.address); buffer = xf_proxy_a2b(&dsp_priv->proxy, msg.address);
if (buffer == (void *)-1) if (buffer == (void *)-1)
return -EFAULT; return -EFAULT;
/* ...put current proxy client into message session id */ /* ...put current proxy client into message session id */
msg.session_id = XF_MSG_AP_FROM_USER(msg.session_id, client->id); msg.session_id = XF_MSG_AP_FROM_USER(msg.session_id, client->id);
xf_cmd_send(&hifi4_priv->proxy, xf_cmd_send(&dsp_priv->proxy,
msg.session_id, msg.session_id,
msg.opcode, msg.opcode,
buffer, buffer,
@ -218,13 +218,13 @@ static int fsl_dsp_ipc_msg_to_dsp(struct xf_client *client,
static int fsl_dsp_ipc_msg_from_dsp(struct xf_client *client, static int fsl_dsp_ipc_msg_from_dsp(struct xf_client *client,
void __user *user) void __user *user)
{ {
struct fsl_hifi4 *hifi4_priv = (struct fsl_hifi4 *)client->global; struct fsl_dsp *dsp_priv = (struct fsl_dsp *)client->global;
struct device *dev = hifi4_priv->dev; struct device *dev = dsp_priv->dev;
struct xf_message *m; struct xf_message *m;
struct xf_proxy_message msg; struct xf_proxy_message msg;
unsigned long ret = 0; unsigned long ret = 0;
m = xf_cmd_recv(&hifi4_priv->proxy, &client->wait, &client->queue, 0); m = xf_cmd_recv(&dsp_priv->proxy, &client->wait, &client->queue, 0);
if (IS_ERR(m)) { if (IS_ERR(m)) {
dev_err(dev, "receiving failed: %d", (int)PTR_ERR(m)); dev_err(dev, "receiving failed: %d", (int)PTR_ERR(m));
return PTR_ERR(m); return PTR_ERR(m);
@ -238,12 +238,12 @@ static int fsl_dsp_ipc_msg_from_dsp(struct xf_client *client,
msg.session_id = XF_MSG_AP_TO_USER(m->id); msg.session_id = XF_MSG_AP_TO_USER(m->id);
msg.opcode = m->opcode; msg.opcode = m->opcode;
msg.length = m->length; msg.length = m->length;
msg.address = xf_proxy_b2a(&hifi4_priv->proxy, m->buffer); msg.address = xf_proxy_b2a(&dsp_priv->proxy, m->buffer);
msg.ret = m->ret; msg.ret = m->ret;
/* ...return the message back to a pool and release lock */ /* ...return the message back to a pool and release lock */
xf_msg_free(&hifi4_priv->proxy, m); xf_msg_free(&dsp_priv->proxy, m);
xf_unlock(&hifi4_priv->proxy.lock); xf_unlock(&dsp_priv->proxy.lock);
ret = copy_to_user(user, &msg, sizeof(struct xf_proxy_message)); ret = copy_to_user(user, &msg, sizeof(struct xf_proxy_message));
if (ret) { if (ret) {
@ -257,13 +257,13 @@ static int fsl_dsp_ipc_msg_from_dsp(struct xf_client *client,
static int fsl_dsp_get_shmem_info(struct xf_client *client, static int fsl_dsp_get_shmem_info(struct xf_client *client,
void __user *user) void __user *user)
{ {
struct fsl_hifi4 *hifi4_priv = (struct fsl_hifi4 *)client->global; struct fsl_dsp *dsp_priv = (struct fsl_dsp *)client->global;
struct device *dev = hifi4_priv->dev; struct device *dev = dsp_priv->dev;
struct shmem_info mem_info; struct shmem_info mem_info;
unsigned long ret = 0; unsigned long ret = 0;
mem_info.phys_addr = hifi4_priv->scratch_buf_phys; mem_info.phys_addr = dsp_priv->scratch_buf_phys;
mem_info.size = hifi4_priv->scratch_buf_size; mem_info.size = dsp_priv->scratch_buf_size;
ret = copy_to_user(user, &mem_info, sizeof(struct shmem_info)); ret = copy_to_user(user, &mem_info, sizeof(struct shmem_info));
if (ret) { if (ret) {
@ -274,16 +274,16 @@ static int fsl_dsp_get_shmem_info(struct xf_client *client,
return ret; return ret;
} }
static struct miscdevice hifi4_miscdev = { static struct miscdevice dsp_miscdev = {
.name = "mxc_hifi4", .name = "mxc_hifi4",
.minor = MISC_DYNAMIC_MINOR, .minor = MISC_DYNAMIC_MINOR,
}; };
static long fsl_hifi4_ioctl(struct file *file, unsigned int cmd, static long fsl_dsp_ioctl(struct file *file, unsigned int cmd,
unsigned long arg) unsigned long arg)
{ {
struct xf_client *client; struct xf_client *client;
struct fsl_hifi4 *hifi4_priv; struct fsl_dsp *dsp_priv;
struct xf_proxy *proxy; struct xf_proxy *proxy;
struct device *dev; struct device *dev;
void __user *user; void __user *user;
@ -294,16 +294,16 @@ static long fsl_hifi4_ioctl(struct file *file, unsigned int cmd,
if (IS_ERR(client)) if (IS_ERR(client))
return PTR_ERR(client); return PTR_ERR(client);
hifi4_priv = (struct fsl_hifi4 *)client->global; dsp_priv = (struct fsl_dsp *)client->global;
proxy = &hifi4_priv->proxy; proxy = &dsp_priv->proxy;
dev = hifi4_priv->dev; dev = dsp_priv->dev;
user = (void __user *)arg; user = (void __user *)arg;
mutex_lock(&hifi4_priv->hifi4_mutex); mutex_lock(&dsp_priv->dsp_mutex);
if (!proxy->is_ready) { if (!proxy->is_ready) {
mutex_unlock(&hifi4_priv->hifi4_mutex); mutex_unlock(&dsp_priv->dsp_mutex);
dev_err(dev, "hifi firmware is not ready\n"); dev_err(dev, "dsp firmware is not ready\n");
return -EFAULT; return -EFAULT;
} }
@ -327,29 +327,29 @@ static long fsl_hifi4_ioctl(struct file *file, unsigned int cmd,
break; break;
} }
mutex_unlock(&hifi4_priv->hifi4_mutex); mutex_unlock(&dsp_priv->dsp_mutex);
return ret; return ret;
} }
void resource_release(struct fsl_hifi4 *hifi4_priv) void resource_release(struct fsl_dsp *dsp_priv)
{ {
int i; int i;
/* ...initialize client association map */ /* ...initialize client association map */
for (i = 0; i < XF_CFG_MAX_IPC_CLIENTS - 1; i++) for (i = 0; i < XF_CFG_MAX_IPC_CLIENTS - 1; i++)
hifi4_priv->xf_client_map[i].next = i + 1; dsp_priv->xf_client_map[i].next = i + 1;
/* ...set list terminator */ /* ...set list terminator */
hifi4_priv->xf_client_map[i].next = 0; dsp_priv->xf_client_map[i].next = 0;
/* ...set pointer to shared memory */ /* ...set pointer to shared memory */
xf_proxy_init(&hifi4_priv->proxy); xf_proxy_init(&dsp_priv->proxy);
} }
static int fsl_hifi4_open(struct inode *inode, struct file *file) static int fsl_dsp_open(struct inode *inode, struct file *file)
{ {
struct fsl_hifi4 *hifi4_priv = dev_get_drvdata(hifi4_miscdev.parent); struct fsl_dsp *dsp_priv = dev_get_drvdata(dsp_miscdev.parent);
struct device *dev = hifi4_priv->dev; struct device *dev = dsp_priv->dev;
struct xf_client *client; struct xf_client *client;
int ret = 0; int ret = 0;
@ -358,7 +358,7 @@ static int fsl_hifi4_open(struct inode *inode, struct file *file)
return -EINVAL; return -EINVAL;
/* ...allocate new proxy client object */ /* ...allocate new proxy client object */
client = xf_client_alloc(hifi4_priv); client = xf_client_alloc(dsp_priv);
if (IS_ERR(client)) if (IS_ERR(client))
return PTR_ERR(client); return PTR_ERR(client);
@ -374,23 +374,23 @@ static int fsl_hifi4_open(struct inode *inode, struct file *file)
/* ...reset mappings counter */ /* ...reset mappings counter */
atomic_set(&client->vm_use, 0); atomic_set(&client->vm_use, 0);
client->global = (void *)hifi4_priv; client->global = (void *)dsp_priv;
file->private_data = (void *)client; file->private_data = (void *)client;
pm_runtime_get_sync(dev); pm_runtime_get_sync(dev);
mutex_lock(&hifi4_priv->hifi4_mutex); mutex_lock(&dsp_priv->dsp_mutex);
/* increase reference counter when opening device */ /* increase reference counter when opening device */
atomic_long_inc(&hifi4_priv->refcnt); atomic_long_inc(&dsp_priv->refcnt);
mutex_unlock(&hifi4_priv->hifi4_mutex); mutex_unlock(&dsp_priv->dsp_mutex);
return ret; return ret;
} }
static int fsl_hifi4_close(struct inode *inode, struct file *file) static int fsl_dsp_close(struct inode *inode, struct file *file)
{ {
struct fsl_hifi4 *hifi4_priv; struct fsl_dsp *dsp_priv;
struct device *dev; struct device *dev;
struct xf_proxy *proxy; struct xf_proxy *proxy;
struct xf_client *client; struct xf_client *client;
@ -409,26 +409,26 @@ static int fsl_hifi4_close(struct inode *inode, struct file *file)
xf_client_free(client); xf_client_free(client);
} }
hifi4_priv = (struct fsl_hifi4 *)client->global; dsp_priv = (struct fsl_dsp *)client->global;
dev = hifi4_priv->dev; dev = dsp_priv->dev;
pm_runtime_put_sync(dev); pm_runtime_put_sync(dev);
mutex_lock(&hifi4_priv->hifi4_mutex); mutex_lock(&dsp_priv->dsp_mutex);
/* decrease reference counter when closing device */ /* decrease reference counter when closing device */
atomic_long_dec(&hifi4_priv->refcnt); atomic_long_dec(&dsp_priv->refcnt);
/* If device is free, reinitialize the resource of /* If device is free, reinitialize the resource of
* hifi4 driver and framework * dsp driver and framework
*/ */
if (atomic_long_read(&hifi4_priv->refcnt) <= 0) if (atomic_long_read(&dsp_priv->refcnt) <= 0)
resource_release(hifi4_priv); resource_release(dsp_priv);
mutex_unlock(&hifi4_priv->hifi4_mutex); mutex_unlock(&dsp_priv->dsp_mutex);
return 0; return 0;
} }
/* ...wait until data is available in the response queue */ /* ...wait until data is available in the response queue */
static unsigned int fsl_hifi4_poll(struct file *file, poll_table *wait) static unsigned int fsl_dsp_poll(struct file *file, poll_table *wait)
{ {
struct xf_proxy *proxy; struct xf_proxy *proxy;
struct xf_client *client; struct xf_client *client;
@ -458,7 +458,7 @@ static unsigned int fsl_hifi4_poll(struct file *file, poll_table *wait)
******************************************************************************/ ******************************************************************************/
/* ...add reference to shared buffer */ /* ...add reference to shared buffer */
static void hifi4_mmap_open(struct vm_area_struct *vma) static void dsp_mmap_open(struct vm_area_struct *vma)
{ {
struct xf_client *client = vma->vm_private_data; struct xf_client *client = vma->vm_private_data;
@ -469,7 +469,7 @@ static void hifi4_mmap_open(struct vm_area_struct *vma)
} }
/* ...close reference to shared buffer */ /* ...close reference to shared buffer */
static void hifi4_mmap_close(struct vm_area_struct *vma) static void dsp_mmap_close(struct vm_area_struct *vma)
{ {
struct xf_client *client = vma->vm_private_data; struct xf_client *client = vma->vm_private_data;
@ -480,20 +480,20 @@ static void hifi4_mmap_close(struct vm_area_struct *vma)
} }
/* ...memory map operations */ /* ...memory map operations */
static const struct vm_operations_struct hifi4_mmap_ops = { static const struct vm_operations_struct dsp_mmap_ops = {
.open = hifi4_mmap_open, .open = dsp_mmap_open,
.close = hifi4_mmap_close, .close = dsp_mmap_close,
}; };
/* ...shared memory mapping */ /* ...shared memory mapping */
static int fsl_hifi4_mmap(struct file *file, struct vm_area_struct *vma) static int fsl_dsp_mmap(struct file *file, struct vm_area_struct *vma)
{ {
struct xf_proxy *proxy; struct xf_proxy *proxy;
struct xf_client *client; struct xf_client *client;
unsigned long size; unsigned long size;
unsigned long pfn; unsigned long pfn;
int r; int r;
struct fsl_hifi4 *hifi4_priv; struct fsl_dsp *dsp_priv;
/* ...basic sanity checks */ /* ...basic sanity checks */
client = xf_get_client(file); client = xf_get_client(file);
@ -515,7 +515,7 @@ static int fsl_hifi4_mmap(struct file *file, struct vm_area_struct *vma)
return -EPERM; return -EPERM;
/* ...set memory map operations */ /* ...set memory map operations */
vma->vm_ops = &hifi4_mmap_ops; vma->vm_ops = &dsp_mmap_ops;
/* ...assign private data */ /* ...assign private data */
client->vm_start = vma->vm_start; client->vm_start = vma->vm_start;
@ -524,9 +524,9 @@ static int fsl_hifi4_mmap(struct file *file, struct vm_area_struct *vma)
vma->vm_private_data = client; vma->vm_private_data = client;
/* ...set page number of shared memory */ /* ...set page number of shared memory */
hifi4_priv = (struct fsl_hifi4 *)client->global; dsp_priv = (struct fsl_dsp *)client->global;
pfn = hifi4_priv->scratch_buf_phys >> PAGE_SHIFT; pfn = dsp_priv->scratch_buf_phys >> PAGE_SHIFT;
size = hifi4_priv->scratch_buf_size; size = dsp_priv->scratch_buf_size;
/* ...remap shared memory to user-space */ /* ...remap shared memory to user-space */
vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
@ -540,7 +540,7 @@ static int fsl_hifi4_mmap(struct file *file, struct vm_area_struct *vma)
return 0; return 0;
} }
void *memset_hifi(void *dest, int c, size_t count) void *memset_dsp(void *dest, int c, size_t count)
{ {
uint *dl = (uint *)dest; uint *dl = (uint *)dest;
void *dl_1, *dl_2; void *dl_1, *dl_2;
@ -586,7 +586,7 @@ void *memset_hifi(void *dest, int c, size_t count)
return dest; return dest;
} }
void *memcpy_hifi(void *dest, const void *src, size_t count) void *memcpy_dsp(void *dest, const void *src, size_t count)
{ {
unsigned int *dl = (unsigned int *)dest, *sl = (unsigned int *)src; unsigned int *dl = (unsigned int *)dest, *sl = (unsigned int *)src;
size_t n = round_up(count, 4) / 4; size_t n = round_up(count, 4) / 4;
@ -607,10 +607,10 @@ void *memcpy_hifi(void *dest, const void *src, size_t count)
return dest; return dest;
} }
static void hifi4_load_firmware(const struct firmware *fw, void *context) static void dsp_load_firmware(const struct firmware *fw, void *context)
{ {
struct fsl_hifi4 *hifi4_priv = context; struct fsl_dsp *dsp_priv = context;
struct device *dev = hifi4_priv->dev; struct device *dev = dsp_priv->dev;
Elf32_Ehdr *ehdr; /* Elf header structure pointer */ Elf32_Ehdr *ehdr; /* Elf header structure pointer */
Elf32_Shdr *shdr; /* Section header structure pointer */ Elf32_Shdr *shdr; /* Section header structure pointer */
Elf32_Addr sh_addr; Elf32_Addr sh_addr;
@ -654,8 +654,8 @@ static void hifi4_load_firmware(const struct firmware *fw, void *context)
sh_addr = shdr->sh_addr; sh_addr = shdr->sh_addr;
if (shdr->sh_type == SHT_NOBITS) { if (shdr->sh_type == SHT_NOBITS) {
memset_hifi((void *)(hifi4_priv->sdram_vir_addr + memset_dsp((void *)(dsp_priv->sdram_vir_addr +
(sh_addr - hifi4_priv->sdram_phys_addr)), (sh_addr - dsp_priv->sdram_phys_addr)),
0, 0,
shdr->sh_size); shdr->sh_size);
} else { } else {
@ -665,13 +665,13 @@ static void hifi4_load_firmware(const struct firmware *fw, void *context)
(!strcmp(&strtab[shdr->sh_name], ".data")) || (!strcmp(&strtab[shdr->sh_name], ".data")) ||
(!strcmp(&strtab[shdr->sh_name], ".bss")) (!strcmp(&strtab[shdr->sh_name], ".bss"))
) { ) {
memcpy_hifi((void *)(hifi4_priv->sdram_vir_addr memcpy_dsp((void *)(dsp_priv->sdram_vir_addr
+ (sh_addr - hifi4_priv->sdram_phys_addr)), + (sh_addr - dsp_priv->sdram_phys_addr)),
(const void *)image, (const void *)image,
shdr->sh_size); shdr->sh_size);
} else { } else {
memcpy_hifi((void *)(hifi4_priv->regs + memcpy_dsp((void *)(dsp_priv->regs +
(sh_addr - hifi4_priv->paddr)), (sh_addr - dsp_priv->paddr)),
(const void *)image, (const void *)image,
shdr->sh_size); shdr->sh_size);
} }
@ -679,73 +679,73 @@ static void hifi4_load_firmware(const struct firmware *fw, void *context)
} }
/* start the core */ /* start the core */
imx_sc_pm_cpu_start(hifi4_priv->hifi_ipcHandle, imx_sc_pm_cpu_start(dsp_priv->dsp_ipcHandle,
IMX_SC_R_DSP, true, hifi4_priv->iram); IMX_SC_R_DSP, true, dsp_priv->iram);
} }
/* Initialization of the MU code. */ /* Initialization of the MU code. */
int hifi4_mu_init(struct fsl_hifi4 *hifi4_priv) int dsp_mu_init(struct fsl_dsp *dsp_priv)
{ {
struct device *dev = hifi4_priv->dev; struct device *dev = dsp_priv->dev;
struct device_node *np; struct device_node *np;
unsigned int hifi_mu_id; unsigned int dsp_mu_id;
u32 irq; u32 irq;
int ret = 0; int ret = 0;
/* /*
* Get the address of MU to be used for communication with the hifi * Get the address of MU to be used for communication with the dsp
*/ */
np = of_find_compatible_node(NULL, NULL, "fsl,imx8-mu-hifi"); np = of_find_compatible_node(NULL, NULL, "fsl,imx8-mu-dsp");
if (!np) { if (!np) {
dev_err(dev, "Cannot find MU entry in device tree\n"); dev_err(dev, "Cannot find MU entry in device tree\n");
return -EINVAL; return -EINVAL;
} }
hifi4_priv->mu_base_virtaddr = of_iomap(np, 0); dsp_priv->mu_base_virtaddr = of_iomap(np, 0);
WARN_ON(!hifi4_priv->mu_base_virtaddr); WARN_ON(!dsp_priv->mu_base_virtaddr);
ret = of_property_read_u32_index(np, ret = of_property_read_u32_index(np,
"fsl,hifi_ap_mu_id", 0, &hifi_mu_id); "fsl,dsp_ap_mu_id", 0, &dsp_mu_id);
if (ret) { if (ret) {
dev_err(dev, "Cannot get mu_id %d\n", ret); dev_err(dev, "Cannot get mu_id %d\n", ret);
return -EINVAL; return -EINVAL;
} }
hifi4_priv->hifi_mu_id = hifi_mu_id; dsp_priv->dsp_mu_id = dsp_mu_id;
irq = of_irq_get(np, 0); irq = of_irq_get(np, 0);
ret = devm_request_irq(hifi4_priv->dev, irq, fsl_hifi4_mu_isr, ret = devm_request_irq(dsp_priv->dev, irq, fsl_dsp_mu_isr,
IRQF_EARLY_RESUME, "hifi4_mu_isr", &hifi4_priv->proxy); IRQF_EARLY_RESUME, "dsp_mu_isr", &dsp_priv->proxy);
if (ret) { if (ret) {
dev_err(dev, "request_irq failed %d, err = %d\n", irq, ret); dev_err(dev, "request_irq failed %d, err = %d\n", irq, ret);
return -EINVAL; return -EINVAL;
} }
if (!hifi4_priv->hifi_mu_init) { if (!dsp_priv->dsp_mu_init) {
MU_Init(hifi4_priv->mu_base_virtaddr); MU_Init(dsp_priv->mu_base_virtaddr);
MU_EnableRxFullInt(hifi4_priv->mu_base_virtaddr, 0); MU_EnableRxFullInt(dsp_priv->mu_base_virtaddr, 0);
hifi4_priv->hifi_mu_init = 1; dsp_priv->dsp_mu_init = 1;
} }
return ret; return ret;
} }
static const struct file_operations hifi4_fops = { static const struct file_operations dsp_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.unlocked_ioctl = fsl_hifi4_ioctl, .unlocked_ioctl = fsl_dsp_ioctl,
#ifdef CONFIG_COMPAT #ifdef CONFIG_COMPAT
.compat_ioctl = fsl_hifi4_ioctl, .compat_ioctl = fsl_dsp_ioctl,
#endif #endif
.open = fsl_hifi4_open, .open = fsl_dsp_open,
.poll = fsl_hifi4_poll, .poll = fsl_dsp_poll,
.mmap = fsl_hifi4_mmap, .mmap = fsl_dsp_mmap,
.release = fsl_hifi4_close, .release = fsl_dsp_close,
}; };
static int fsl_hifi4_probe(struct platform_device *pdev) static int fsl_dsp_probe(struct platform_device *pdev)
{ {
struct device_node *np = pdev->dev.of_node; struct device_node *np = pdev->dev.of_node;
struct fsl_hifi4 *hifi4_priv; struct fsl_dsp *dsp_priv;
const char *fw_name; const char *fw_name;
struct resource *res; struct resource *res;
void __iomem *regs; void __iomem *regs;
@ -754,11 +754,11 @@ static int fsl_hifi4_probe(struct platform_device *pdev)
int size, offset, i; int size, offset, i;
int ret; int ret;
hifi4_priv = devm_kzalloc(&pdev->dev, sizeof(*hifi4_priv), GFP_KERNEL); dsp_priv = devm_kzalloc(&pdev->dev, sizeof(*dsp_priv), GFP_KERNEL);
if (!hifi4_priv) if (!dsp_priv)
return -ENOMEM; return -ENOMEM;
hifi4_priv->dev = &pdev->dev; dsp_priv->dev = &pdev->dev;
/* Get the addresses and IRQ */ /* Get the addresses and IRQ */
res = platform_get_resource(pdev, IORESOURCE_MEM, 0); res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@ -766,76 +766,76 @@ static int fsl_hifi4_probe(struct platform_device *pdev)
if (IS_ERR(regs)) if (IS_ERR(regs))
return PTR_ERR(regs); return PTR_ERR(regs);
hifi4_priv->paddr = res->start; dsp_priv->paddr = res->start;
hifi4_priv->regs = regs; dsp_priv->regs = regs;
hifi4_priv->dram0 = hifi4_priv->paddr + DRAM0_OFFSET; dsp_priv->dram0 = dsp_priv->paddr + DRAM0_OFFSET;
hifi4_priv->dram1 = hifi4_priv->paddr + DRAM1_OFFSET; dsp_priv->dram1 = dsp_priv->paddr + DRAM1_OFFSET;
hifi4_priv->iram = hifi4_priv->paddr + IRAM_OFFSET; dsp_priv->iram = dsp_priv->paddr + IRAM_OFFSET;
hifi4_priv->sram = hifi4_priv->paddr + SYSRAM_OFFSET; dsp_priv->sram = dsp_priv->paddr + SYSRAM_OFFSET;
ret = imx_scu_get_handle(&hifi4_priv->hifi_ipcHandle); ret = imx_scu_get_handle(&dsp_priv->dsp_ipcHandle);
if (ret) { if (ret) {
dev_err(&pdev->dev, "Cannot get scu handle %d\n", ret); dev_err(&pdev->dev, "Cannot get scu handle %d\n", ret);
return ret; return ret;
}; };
ret = imx_sc_misc_set_control(hifi4_priv->hifi_ipcHandle, IMX_SC_R_DSP, ret = imx_sc_misc_set_control(dsp_priv->dsp_ipcHandle, IMX_SC_R_DSP,
IMX_SC_C_OFS_SEL, 1); IMX_SC_C_OFS_SEL, 1);
if (ret) { if (ret) {
dev_err(&pdev->dev, "Error system address offset source select\n"); dev_err(&pdev->dev, "Error system address offset source select\n");
return -EIO; return -EIO;
} }
ret = imx_sc_misc_set_control(hifi4_priv->hifi_ipcHandle, IMX_SC_R_DSP, ret = imx_sc_misc_set_control(dsp_priv->dsp_ipcHandle, IMX_SC_R_DSP,
IMX_SC_C_OFS_AUDIO, 0x80); IMX_SC_C_OFS_AUDIO, 0x80);
if (ret) { if (ret) {
dev_err(&pdev->dev, "Error system address offset of AUDIO\n"); dev_err(&pdev->dev, "Error system address offset of AUDIO\n");
return -EIO; return -EIO;
} }
ret = imx_sc_misc_set_control(hifi4_priv->hifi_ipcHandle, IMX_SC_R_DSP, ret = imx_sc_misc_set_control(dsp_priv->dsp_ipcHandle, IMX_SC_R_DSP,
IMX_SC_C_OFS_PERIPH, 0x5A); IMX_SC_C_OFS_PERIPH, 0x5A);
if (ret) { if (ret) {
dev_err(&pdev->dev, "Error system address offset of PERIPH\n"); dev_err(&pdev->dev, "Error system address offset of PERIPH\n");
return -EIO; return -EIO;
} }
ret = imx_sc_misc_set_control(hifi4_priv->hifi_ipcHandle, IMX_SC_R_DSP, ret = imx_sc_misc_set_control(dsp_priv->dsp_ipcHandle, IMX_SC_R_DSP,
IMX_SC_C_OFS_IRQ, 0x51); IMX_SC_C_OFS_IRQ, 0x51);
if (ret) { if (ret) {
dev_err(&pdev->dev, "Error system address offset of IRQ\n"); dev_err(&pdev->dev, "Error system address offset of IRQ\n");
return -EIO; return -EIO;
} }
ret = hifi4_mu_init(hifi4_priv); ret = dsp_mu_init(dsp_priv);
if (ret) if (ret)
return ret; return ret;
ret = of_property_read_string(np, "fsl,hifi4-firmware", &fw_name); ret = of_property_read_string(np, "fsl,dsp-firmware", &fw_name);
hifi4_priv->fw_name = fw_name; dsp_priv->fw_name = fw_name;
platform_set_drvdata(pdev, hifi4_priv); platform_set_drvdata(pdev, dsp_priv);
pm_runtime_enable(&pdev->dev); pm_runtime_enable(&pdev->dev);
hifi4_miscdev.fops = &hifi4_fops, dsp_miscdev.fops = &dsp_fops,
hifi4_miscdev.parent = &pdev->dev, dsp_miscdev.parent = &pdev->dev,
ret = misc_register(&hifi4_miscdev); ret = misc_register(&dsp_miscdev);
if (ret) { if (ret) {
dev_err(&pdev->dev, "failed to register misc device %d\n", ret); dev_err(&pdev->dev, "failed to register misc device %d\n", ret);
return ret; return ret;
} }
hifi4_priv->sdram_phys_addr = SDRAM_BASE_ADDR; dsp_priv->sdram_phys_addr = SDRAM_BASE_ADDR;
hifi4_priv->sdram_vir_addr = ioremap_wc(hifi4_priv->sdram_phys_addr, dsp_priv->sdram_vir_addr = ioremap_wc(dsp_priv->sdram_phys_addr,
SDRAM_BASE_SIZE); SDRAM_BASE_SIZE);
if (!hifi4_priv->sdram_vir_addr) { if (!dsp_priv->sdram_vir_addr) {
dev_err(&pdev->dev, "failed to remap sdram space for hifi4 firmware\n"); dev_err(&pdev->dev, "failed to remap sdram space for dsp firmware\n");
return -ENXIO; return -ENXIO;
} }
memset_io(hifi4_priv->sdram_vir_addr, 0, SDRAM_BASE_SIZE); memset_io(dsp_priv->sdram_vir_addr, 0, SDRAM_BASE_SIZE);
size = MSG_BUF_SIZE + HIFI_CONFIG_SIZE; size = MSG_BUF_SIZE + DSP_CONFIG_SIZE;
buf_virt = dma_alloc_coherent(&pdev->dev, size, &buf_phys, GFP_KERNEL); buf_virt = dma_alloc_coherent(&pdev->dev, size, &buf_phys, GFP_KERNEL);
if (!buf_virt) { if (!buf_virt) {
@ -844,69 +844,69 @@ static int fsl_hifi4_probe(struct platform_device *pdev)
} }
/* msg ring buffer memory */ /* msg ring buffer memory */
hifi4_priv->msg_buf_virt = buf_virt; dsp_priv->msg_buf_virt = buf_virt;
hifi4_priv->msg_buf_phys = buf_phys; dsp_priv->msg_buf_phys = buf_phys;
hifi4_priv->msg_buf_size = MSG_BUF_SIZE; dsp_priv->msg_buf_size = MSG_BUF_SIZE;
offset = MSG_BUF_SIZE; offset = MSG_BUF_SIZE;
/* keep dsp framework's global data when suspend/resume */ /* keep dsp framework's global data when suspend/resume */
hifi4_priv->hifi_config_virt = buf_virt + offset; dsp_priv->dsp_config_virt = buf_virt + offset;
hifi4_priv->hifi_config_phys = buf_phys + offset; dsp_priv->dsp_config_phys = buf_phys + offset;
hifi4_priv->hifi_config_size = HIFI_CONFIG_SIZE; dsp_priv->dsp_config_size = DSP_CONFIG_SIZE;
/* scratch memory for dsp framework */ /* scratch memory for dsp framework */
hifi4_priv->scratch_buf_virt = hifi4_priv->sdram_vir_addr + dsp_priv->scratch_buf_virt = dsp_priv->sdram_vir_addr +
SDRAM_CODEC_LIB_OFFSET; SDRAM_CODEC_LIB_OFFSET;
hifi4_priv->scratch_buf_phys = hifi4_priv->sdram_phys_addr + dsp_priv->scratch_buf_phys = dsp_priv->sdram_phys_addr +
SDRAM_CODEC_LIB_OFFSET; SDRAM_CODEC_LIB_OFFSET;
hifi4_priv->scratch_buf_size = SDRAM_BASE_SIZE - SDRAM_CODEC_LIB_OFFSET; dsp_priv->scratch_buf_size = SDRAM_BASE_SIZE - SDRAM_CODEC_LIB_OFFSET;
/* initialize the reference counter for hifi4_priv /* initialize the reference counter for dsp_priv
* structure * structure
*/ */
atomic_long_set(&hifi4_priv->refcnt, 0); atomic_long_set(&dsp_priv->refcnt, 0);
/* ...initialize client association map */ /* ...initialize client association map */
for (i = 0; i < XF_CFG_MAX_IPC_CLIENTS - 1; i++) for (i = 0; i < XF_CFG_MAX_IPC_CLIENTS - 1; i++)
hifi4_priv->xf_client_map[i].next = i + 1; dsp_priv->xf_client_map[i].next = i + 1;
/* ...set list terminator */ /* ...set list terminator */
hifi4_priv->xf_client_map[i].next = 0; dsp_priv->xf_client_map[i].next = 0;
/* ...set pointer to shared memory */ /* ...set pointer to shared memory */
xf_proxy_init(&hifi4_priv->proxy); xf_proxy_init(&dsp_priv->proxy);
/* ...initialize mutex */ /* ...initialize mutex */
mutex_init(&hifi4_priv->hifi4_mutex); mutex_init(&dsp_priv->dsp_mutex);
return 0; return 0;
} }
static int fsl_hifi4_remove(struct platform_device *pdev) static int fsl_dsp_remove(struct platform_device *pdev)
{ {
struct fsl_hifi4 *hifi4_priv = platform_get_drvdata(pdev); struct fsl_dsp *dsp_priv = platform_get_drvdata(pdev);
int size; int size;
misc_deregister(&hifi4_miscdev); misc_deregister(&dsp_miscdev);
size = MSG_BUF_SIZE + HIFI_CONFIG_SIZE; size = MSG_BUF_SIZE + DSP_CONFIG_SIZE;
dma_free_coherent(&pdev->dev, size, hifi4_priv->msg_buf_virt, dma_free_coherent(&pdev->dev, size, dsp_priv->msg_buf_virt,
hifi4_priv->msg_buf_phys); dsp_priv->msg_buf_phys);
if (hifi4_priv->sdram_vir_addr) if (dsp_priv->sdram_vir_addr)
iounmap(hifi4_priv->sdram_vir_addr); iounmap(dsp_priv->sdram_vir_addr);
return 0; return 0;
} }
#ifdef CONFIG_PM #ifdef CONFIG_PM
static int fsl_hifi4_runtime_resume(struct device *dev) static int fsl_dsp_runtime_resume(struct device *dev)
{ {
struct fsl_hifi4 *hifi4_priv = dev_get_drvdata(dev); struct fsl_dsp *dsp_priv = dev_get_drvdata(dev);
struct xf_proxy *proxy = &hifi4_priv->proxy; struct xf_proxy *proxy = &dsp_priv->proxy;
int ret; int ret;
if (sc_pm_set_resource_power_mode(hifi4_priv->hifi_ipcHandle, if (sc_pm_set_resource_power_mode(dsp_priv->dsp_ipcHandle,
SC_R_DSP_RAM, SC_PM_PW_MODE_ON) != SC_ERR_NONE) { SC_R_DSP_RAM, SC_PM_PW_MODE_ON) != SC_ERR_NONE) {
dev_err(dev, "Error power on HIFI RAM\n"); dev_err(dev, "Error power on DSP RAM\n");
return -EIO; return -EIO;
} }
@ -914,9 +914,9 @@ static int fsl_hifi4_runtime_resume(struct device *dev)
init_completion(&proxy->cmd_complete); init_completion(&proxy->cmd_complete);
ret = request_firmware_nowait(THIS_MODULE, ret = request_firmware_nowait(THIS_MODULE,
FW_ACTION_HOTPLUG, hifi4_priv->fw_name, FW_ACTION_HOTPLUG, dsp_priv->fw_name,
dev, dev,
GFP_KERNEL, hifi4_priv, hifi4_load_firmware); GFP_KERNEL, dsp_priv, dsp_load_firmware);
if (ret) { if (ret) {
dev_err(dev, "failed to load firmware\n"); dev_err(dev, "failed to load firmware\n");
@ -924,23 +924,23 @@ static int fsl_hifi4_runtime_resume(struct device *dev)
} }
ret = icm_ack_wait(proxy, 0); ret = icm_ack_wait(proxy, 0);
if (ret) { if (ret)
return ret; return ret;
}
dev_info(dev, "hifi driver registered\n"); dev_info(dev, "dsp driver registered\n");
} }
return 0; return 0;
} }
static int fsl_hifi4_runtime_suspend(struct device *dev) static int fsl_dsp_runtime_suspend(struct device *dev)
{ {
struct fsl_hifi4 *hifi4_priv = dev_get_drvdata(dev); struct fsl_dsp *dsp_priv = dev_get_drvdata(dev);
struct xf_proxy *proxy = &hifi4_priv->proxy; struct xf_proxy *proxy = &dsp_priv->proxy;
if (sc_pm_set_resource_power_mode(hifi4_priv->hifi_ipcHandle, if (sc_pm_set_resource_power_mode(dsp_priv->dsp_ipcHandle,
SC_R_DSP_RAM, SC_PM_PW_MODE_OFF) != SC_ERR_NONE) { SC_R_DSP_RAM, SC_PM_PW_MODE_OFF) != SC_ERR_NONE) {
dev_err(dev, "Error power off HIFI RAM\n"); dev_err(dev, "Error power off DSP RAM\n");
return -EIO; return -EIO;
} }
proxy->is_ready = 0; proxy->is_ready = 0;
@ -950,16 +950,16 @@ static int fsl_hifi4_runtime_suspend(struct device *dev)
#ifdef CONFIG_PM_SLEEP #ifdef CONFIG_PM_SLEEP
static int fsl_hifi4_suspend(struct device *dev) static int fsl_dsp_suspend(struct device *dev)
{ {
struct fsl_hifi4 *hifi4_priv = dev_get_drvdata(dev); struct fsl_dsp *dsp_priv = dev_get_drvdata(dev);
struct xf_proxy *proxy = &hifi4_priv->proxy; struct xf_proxy *proxy = &dsp_priv->proxy;
int ret = 0; int ret = 0;
if (proxy->is_ready) { if (proxy->is_ready) {
ret = xf_cmd_send_suspend(proxy); ret = xf_cmd_send_suspend(proxy);
if (ret) { if (ret) {
dev_err(dev, "hifi4 suspend fail\n"); dev_err(dev, "dsp suspend fail\n");
return ret; return ret;
} }
} }
@ -969,10 +969,10 @@ static int fsl_hifi4_suspend(struct device *dev)
return ret; return ret;
} }
static int fsl_hifi4_resume(struct device *dev) static int fsl_dsp_resume(struct device *dev)
{ {
struct fsl_hifi4 *hifi4_priv = dev_get_drvdata(dev); struct fsl_dsp *dsp_priv = dev_get_drvdata(dev);
struct xf_proxy *proxy = &hifi4_priv->proxy; struct xf_proxy *proxy = &dsp_priv->proxy;
int ret = 0; int ret = 0;
ret = pm_runtime_force_resume(dev); ret = pm_runtime_force_resume(dev);
@ -982,7 +982,7 @@ static int fsl_hifi4_resume(struct device *dev)
if (proxy->is_ready) { if (proxy->is_ready) {
ret = xf_cmd_send_resume(proxy); ret = xf_cmd_send_resume(proxy);
if (ret) { if (ret) {
dev_err(dev, "hifi4 resume fail\n"); dev_err(dev, "dsp resume fail\n");
return ret; return ret;
} }
} }
@ -991,29 +991,29 @@ static int fsl_hifi4_resume(struct device *dev)
} }
#endif /* CONFIG_PM_SLEEP */ #endif /* CONFIG_PM_SLEEP */
static const struct dev_pm_ops fsl_hifi4_pm = { static const struct dev_pm_ops fsl_dsp_pm = {
SET_RUNTIME_PM_OPS(fsl_hifi4_runtime_suspend, SET_RUNTIME_PM_OPS(fsl_dsp_runtime_suspend,
fsl_hifi4_runtime_resume, NULL) fsl_dsp_runtime_resume, NULL)
SET_SYSTEM_SLEEP_PM_OPS(fsl_hifi4_suspend, fsl_hifi4_resume) SET_SYSTEM_SLEEP_PM_OPS(fsl_dsp_suspend, fsl_dsp_resume)
}; };
static const struct of_device_id fsl_hifi4_ids[] = { static const struct of_device_id fsl_dsp_ids[] = {
{ .compatible = "fsl,imx8qxp-hifi4", }, { .compatible = "fsl,imx8qxp-dsp", },
{} {}
}; };
MODULE_DEVICE_TABLE(of, fsl_hifi4_ids); MODULE_DEVICE_TABLE(of, fsl_dsp_ids);
static struct platform_driver fsl_hifi4_driver = { static struct platform_driver fsl_dsp_driver = {
.probe = fsl_hifi4_probe, .probe = fsl_dsp_probe,
.remove = fsl_hifi4_remove, .remove = fsl_dsp_remove,
.driver = { .driver = {
.name = "fsl-hifi4", .name = "fsl-dsp",
.of_match_table = fsl_hifi4_ids, .of_match_table = fsl_dsp_ids,
.pm = &fsl_hifi4_pm, .pm = &fsl_dsp_pm,
}, },
}; };
module_platform_driver(fsl_hifi4_driver); module_platform_driver(fsl_dsp_driver);
MODULE_DESCRIPTION("Freescale HIFI 4 driver"); MODULE_DESCRIPTION("Freescale DSP driver");
MODULE_ALIAS("platform:fsl-hifi4"); MODULE_ALIAS("platform:fsl-dsp");
MODULE_LICENSE("Dual BSD/GPL"); MODULE_LICENSE("Dual BSD/GPL");

34
sound/soc/fsl/fsl_hifi4.h → sound/soc/fsl/fsl_dsp.h
View File

@ -1,5 +1,5 @@
/* /*
* Freescale HIFI 4 driver * Freescale DSP driver
* *
* Copyright 2018 NXP * Copyright 2018 NXP
* *
@ -8,8 +8,8 @@
* kind, whether express or implied. * kind, whether express or implied.
*/ */
#include <uapi/linux/mxc_hifi4.h> #include <uapi/linux/mxc_dsp.h>
#include "fsl_hifi4_proxy.h" #include "fsl_dsp_proxy.h"
typedef void (*memcpy_func) (void *dest, const void *src, size_t n); typedef void (*memcpy_func) (void *dest, const void *src, size_t n);
@ -51,14 +51,14 @@ union xf_client_link {
struct xf_client *client; struct xf_client *client;
}; };
struct fsl_hifi4 { struct fsl_dsp {
struct device *dev; struct device *dev;
const char *fw_name; const char *fw_name;
void __iomem *regs; void __iomem *regs;
void __iomem *mu_base_virtaddr; void __iomem *mu_base_virtaddr;
struct imx_sc_ipc *hifi_ipcHandle; struct imx_sc_ipc *dsp_ipcHandle;
unsigned int hifi_mu_id; unsigned int dsp_mu_id;
int hifi_mu_init; int dsp_mu_init;
atomic_long_t refcnt; atomic_long_t refcnt;
unsigned long paddr; unsigned long paddr;
unsigned long dram0; unsigned long dram0;
@ -73,15 +73,15 @@ struct fsl_hifi4 {
void *scratch_buf_virt; void *scratch_buf_virt;
dma_addr_t scratch_buf_phys; dma_addr_t scratch_buf_phys;
int scratch_buf_size; int scratch_buf_size;
void *hifi_config_virt; void *dsp_config_virt;
dma_addr_t hifi_config_phys; dma_addr_t dsp_config_phys;
int hifi_config_size; int dsp_config_size;
/* ...proxy data structures */ /* ...proxy data structures */
struct xf_proxy proxy; struct xf_proxy proxy;
/* ...mutex lock */ /* ...mutex lock */
struct mutex hifi4_mutex; struct mutex dsp_mutex;
/* ...global clients pool (item[0] serves as list terminator) */ /* ...global clients pool (item[0] serves as list terminator) */
union xf_client_link xf_client_map[XF_CFG_MAX_IPC_CLIENTS]; union xf_client_link xf_client_map[XF_CFG_MAX_IPC_CLIENTS];
@ -105,7 +105,7 @@ struct fsl_hifi4 {
#define MSG_BUF_SIZE 8192 #define MSG_BUF_SIZE 8192
#define INPUT_BUF_SIZE 4096 #define INPUT_BUF_SIZE 4096
#define OUTPUT_BUF_SIZE 16384 #define OUTPUT_BUF_SIZE 16384
#define HIFI_CONFIG_SIZE 4096 #define DSP_CONFIG_SIZE 4096
/*external buffer /*external buffer
* ---------------------------------------------------------------------- * ----------------------------------------------------------------------
@ -113,13 +113,13 @@ struct fsl_hifi4 {
* ----------------------------------------------------------------------- * -----------------------------------------------------------------------
* | scratch buffer for malloc | 0xffffff | For MEM_scratch_malloc() * | scratch buffer for malloc | 0xffffff | For MEM_scratch_malloc()
* ------------------------------------------------------------------------ * ------------------------------------------------------------------------
* | global structure | 4096 | For store hifi config structure * | global structure | 4096 | For store dsp config structure
* ------------------------------------------------------------------------ * ------------------------------------------------------------------------
*/ */
#define MEMORY_REMAP_OFFSET 0x39000000 #define MEMORY_REMAP_OFFSET 0x39000000
/* reserved memory for hifi4 firmware and core libs to /* reserved memory for dsp firmware and core libs to
* save their instruction/data section in SDRAM, the physical * save their instruction/data section in SDRAM, the physical
* address range is 0x8e000000 ~ 0x8fffffff (32M bytes). * address range is 0x8e000000 ~ 0x8fffffff (32M bytes).
*/ */
@ -133,6 +133,6 @@ struct fsl_hifi4 {
#define SC_C_OFS_PERIPH 41 #define SC_C_OFS_PERIPH 41
#define SC_C_OFS_IRQ 42 #define SC_C_OFS_IRQ 42
void *memcpy_hifi(void *dest, const void *src, size_t count); void *memcpy_dsp(void *dest, const void *src, size_t count);
void *memset_hifi(void *dest, int c, size_t count); void *memset_dsp(void *dest, int c, size_t count);
struct xf_client *xf_client_lookup(struct fsl_hifi4 *hifi4_priv, u32 id); struct xf_client *xf_client_lookup(struct fsl_dsp *dsp_priv, u32 id);

93
sound/soc/fsl/fsl_hifi4_proxy.c → sound/soc/fsl/fsl_dsp_proxy.c
View File

@ -9,7 +9,7 @@
* *
******************************************************************************/ ******************************************************************************/
/******************************************************************************* /*******************************************************************************
* fsl_hifi4_proxy.c * fsl_dsp_proxy.c
* *
* DSP proxy driver * DSP proxy driver
* *
@ -17,9 +17,8 @@
* and dsp framework * and dsp framework
******************************************************************************/ ******************************************************************************/
#include <soc/imx8/sc/ipc.h> #include "fsl_dsp_proxy.h"
#include "fsl_hifi4_proxy.h" #include "fsl_dsp.h"
#include "fsl_hifi4.h"
/* ...initialize message queue */ /* ...initialize message queue */
@ -154,41 +153,41 @@ struct xf_message *xf_msg_received(struct xf_proxy *proxy,
*/ */
u32 icm_intr_send(struct xf_proxy *proxy, u32 msg) u32 icm_intr_send(struct xf_proxy *proxy, u32 msg)
{ {
struct fsl_hifi4 *hifi4_priv = container_of(proxy, struct fsl_dsp *dsp_priv = container_of(proxy,
struct fsl_hifi4, proxy); struct fsl_dsp, proxy);
MU_SendMessage(hifi4_priv->mu_base_virtaddr, 0, msg); MU_SendMessage(dsp_priv->mu_base_virtaddr, 0, msg);
return 0; return 0;
} }
int icm_intr_extended_send(struct xf_proxy *proxy, int icm_intr_extended_send(struct xf_proxy *proxy,
u32 msg, u32 msg,
struct hifi4_ext_msg *ext_msg) struct dsp_ext_msg *ext_msg)
{ {
struct fsl_hifi4 *hifi4_priv = container_of(proxy, struct fsl_dsp *dsp_priv = container_of(proxy,
struct fsl_hifi4, proxy); struct fsl_dsp, proxy);
struct device *dev = hifi4_priv->dev; struct device *dev = dsp_priv->dev;
union icm_header_t msghdr; union icm_header_t msghdr;
msghdr.allbits = msg; msghdr.allbits = msg;
if (msghdr.size != 8) if (msghdr.size != 8)
dev_err(dev, "too much ext msg\n"); dev_err(dev, "too much ext msg\n");
MU_SendMessage(hifi4_priv->mu_base_virtaddr, 1, ext_msg->phys); MU_SendMessage(dsp_priv->mu_base_virtaddr, 1, ext_msg->phys);
MU_SendMessage(hifi4_priv->mu_base_virtaddr, 2, ext_msg->size); MU_SendMessage(dsp_priv->mu_base_virtaddr, 2, ext_msg->size);
MU_SendMessage(hifi4_priv->mu_base_virtaddr, 0, msg); MU_SendMessage(dsp_priv->mu_base_virtaddr, 0, msg);
return 0; return 0;
} }
int send_dpu_ext_msg_addr(struct xf_proxy *proxy) int send_dpu_ext_msg_addr(struct xf_proxy *proxy)
{ {
struct fsl_hifi4 *hifi4_priv = container_of(proxy, struct fsl_dsp *dsp_priv = container_of(proxy,
struct fsl_hifi4, proxy); struct fsl_dsp, proxy);
union icm_header_t msghdr; union icm_header_t msghdr;
struct hifi4_ext_msg ext_msg; struct dsp_ext_msg ext_msg;
struct hifi4_mem_msg *dpu_ext_msg = struct dsp_mem_msg *dpu_ext_msg =
(struct hifi4_mem_msg *)((unsigned char *)hifi4_priv->msg_buf_virt (struct dsp_mem_msg *)((unsigned char *)dsp_priv->msg_buf_virt
+ (MSG_BUF_SIZE / 2)); + (MSG_BUF_SIZE / 2));
int ret_val = 0; int ret_val = 0;
@ -197,15 +196,15 @@ int send_dpu_ext_msg_addr(struct xf_proxy *proxy)
msghdr.intr = 1; msghdr.intr = 1;
msghdr.msg = ICM_CORE_INIT; msghdr.msg = ICM_CORE_INIT;
msghdr.size = 8; msghdr.size = 8;
ext_msg.phys = hifi4_priv->msg_buf_phys + (MSG_BUF_SIZE / 2); ext_msg.phys = dsp_priv->msg_buf_phys + (MSG_BUF_SIZE / 2);
ext_msg.size = sizeof(struct hifi4_mem_msg); ext_msg.size = sizeof(struct dsp_mem_msg);
dpu_ext_msg->ext_msg_phys = hifi4_priv->msg_buf_phys; dpu_ext_msg->ext_msg_phys = dsp_priv->msg_buf_phys;
dpu_ext_msg->ext_msg_size = MSG_BUF_SIZE; dpu_ext_msg->ext_msg_size = MSG_BUF_SIZE;
dpu_ext_msg->scratch_phys = hifi4_priv->scratch_buf_phys; dpu_ext_msg->scratch_phys = dsp_priv->scratch_buf_phys;
dpu_ext_msg->scratch_size = hifi4_priv->scratch_buf_size; dpu_ext_msg->scratch_size = dsp_priv->scratch_buf_size;
dpu_ext_msg->hifi_config_phys = hifi4_priv->hifi_config_phys; dpu_ext_msg->dsp_config_phys = dsp_priv->dsp_config_phys;
dpu_ext_msg->hifi_config_size = hifi4_priv->hifi_config_size; dpu_ext_msg->dsp_config_size = dsp_priv->dsp_config_size;
icm_intr_extended_send(proxy, msghdr.allbits, &ext_msg); icm_intr_extended_send(proxy, msghdr.allbits, &ext_msg);
@ -214,9 +213,9 @@ int send_dpu_ext_msg_addr(struct xf_proxy *proxy)
long icm_ack_wait(struct xf_proxy *proxy, u32 msg) long icm_ack_wait(struct xf_proxy *proxy, u32 msg)
{ {
struct fsl_hifi4 *hifi4_priv = container_of(proxy, struct fsl_dsp *dsp_priv = container_of(proxy,
struct fsl_hifi4, proxy); struct fsl_dsp, proxy);
struct device *dev = hifi4_priv->dev; struct device *dev = dsp_priv->dev;
union icm_header_t msghdr; union icm_header_t msghdr;
int err; int err;
@ -234,16 +233,16 @@ long icm_ack_wait(struct xf_proxy *proxy, u32 msg)
return 0; return 0;
} }
irqreturn_t fsl_hifi4_mu_isr(int irq, void *dev_id) irqreturn_t fsl_dsp_mu_isr(int irq, void *dev_id)
{ {
struct xf_proxy *proxy = dev_id; struct xf_proxy *proxy = dev_id;
struct fsl_hifi4 *hifi4_priv = container_of(proxy, struct fsl_dsp *dsp_priv = container_of(proxy,
struct fsl_hifi4, proxy); struct fsl_dsp, proxy);
struct device *dev = hifi4_priv->dev; struct device *dev = dsp_priv->dev;
union icm_header_t msghdr; union icm_header_t msghdr;
u32 reg; u32 reg;
MU_ReceiveMsg(hifi4_priv->mu_base_virtaddr, 0, &reg); MU_ReceiveMsg(dsp_priv->mu_base_virtaddr, 0, &reg);
msghdr = (union icm_header_t)reg; msghdr = (union icm_header_t)reg;
if (msghdr.intr == 1) { if (msghdr.intr == 1) {
@ -287,14 +286,14 @@ irqreturn_t fsl_hifi4_mu_isr(int irq, void *dev_id)
/* ...shared memory translation - kernel virtual address to shared address */ /* ...shared memory translation - kernel virtual address to shared address */
u32 xf_proxy_b2a(struct xf_proxy *proxy, void *b) u32 xf_proxy_b2a(struct xf_proxy *proxy, void *b)
{ {
struct fsl_hifi4 *hifi4_priv = container_of(proxy, struct fsl_dsp *dsp_priv = container_of(proxy,
struct fsl_hifi4, proxy); struct fsl_dsp, proxy);
if (b == NULL) if (b == NULL)
return XF_PROXY_NULL; return XF_PROXY_NULL;
else if ((u32)(b - hifi4_priv->scratch_buf_virt) < else if ((u32)(b - dsp_priv->scratch_buf_virt) <
SDRAM_SCRATCH_BUF_SIZE) SDRAM_SCRATCH_BUF_SIZE)
return (u32)(b - hifi4_priv->scratch_buf_virt); return (u32)(b - dsp_priv->scratch_buf_virt);
else else
return XF_PROXY_BADADDR; return XF_PROXY_BADADDR;
} }
@ -302,11 +301,11 @@ u32 xf_proxy_b2a(struct xf_proxy *proxy, void *b)
/* ...shared memory translation - shared address to kernel virtual address */ /* ...shared memory translation - shared address to kernel virtual address */
void *xf_proxy_a2b(struct xf_proxy *proxy, u32 address) void *xf_proxy_a2b(struct xf_proxy *proxy, u32 address)
{ {
struct fsl_hifi4 *hifi4_priv = container_of(proxy, struct fsl_dsp *dsp_priv = container_of(proxy,
struct fsl_hifi4, proxy); struct fsl_dsp, proxy);
if (address < SDRAM_SCRATCH_BUF_SIZE) if (address < SDRAM_SCRATCH_BUF_SIZE)
return hifi4_priv->scratch_buf_virt + address; return dsp_priv->scratch_buf_virt + address;
else if (address == XF_PROXY_NULL) else if (address == XF_PROXY_NULL)
return NULL; return NULL;
else else
@ -316,8 +315,8 @@ void *xf_proxy_a2b(struct xf_proxy *proxy, u32 address)
/* ...process association between response received and intended client */ /* ...process association between response received and intended client */
static void xf_cmap(struct xf_proxy *proxy, struct xf_message *m) static void xf_cmap(struct xf_proxy *proxy, struct xf_message *m)
{ {
struct fsl_hifi4 *hifi4_priv = container_of(proxy, struct fsl_dsp *dsp_priv = container_of(proxy,
struct fsl_hifi4, proxy); struct fsl_dsp, proxy);
u32 id = XF_AP_IPC_CLIENT(m->id); u32 id = XF_AP_IPC_CLIENT(m->id);
struct xf_client *client; struct xf_client *client;
@ -330,7 +329,7 @@ static void xf_cmap(struct xf_proxy *proxy, struct xf_message *m)
} }
/* ...make sure the client ID is sane */ /* ...make sure the client ID is sane */
client = xf_client_lookup(hifi4_priv, id); client = xf_client_lookup(dsp_priv, id);
if (!client) { if (!client) {
pr_err("rsp[id:%08x]: client lookup failed", m->id); pr_err("rsp[id:%08x]: client lookup failed", m->id);
xf_msg_free(proxy, m); xf_msg_free(proxy, m);
@ -471,8 +470,8 @@ void xf_proxy_process(struct work_struct *w)
/* ...initialize shared memory interface */ /* ...initialize shared memory interface */
int xf_proxy_init(struct xf_proxy *proxy) int xf_proxy_init(struct xf_proxy *proxy)
{ {
struct fsl_hifi4 *hifi4_priv = container_of(proxy, struct fsl_dsp *dsp_priv = container_of(proxy,
struct fsl_hifi4, proxy); struct fsl_dsp, proxy);
struct xf_message *m; struct xf_message *m;
int i; int i;
@ -501,7 +500,7 @@ int xf_proxy_init(struct xf_proxy *proxy)
INIT_WORK(&proxy->work, xf_proxy_process); INIT_WORK(&proxy->work, xf_proxy_process);
/* ...set pointer to shared memory */ /* ...set pointer to shared memory */
proxy->ipc.shmem = (struct xf_shmem_data *)hifi4_priv->msg_buf_virt; proxy->ipc.shmem = (struct xf_shmem_data *)dsp_priv->msg_buf_virt;
/* ...initialize shared memory interface */ /* ...initialize shared memory interface */
XF_PROXY_WRITE(proxy, cmd_read_idx, 0); XF_PROXY_WRITE(proxy, cmd_read_idx, 0);

16
sound/soc/fsl/fsl_hifi4_proxy.h → sound/soc/fsl/fsl_dsp_proxy.h
View File

@ -9,13 +9,13 @@
* *
************************************************************/ ************************************************************/
/************************************************************ /************************************************************
* fsl_hifi4_proxy.h * fsl_dsp_proxy.h
* *
* Proxy commmand/response messages * Proxy commmand/response messages
************************************************************/ ************************************************************/
#ifndef __FSL_HIFI4_PROXY_H #ifndef __FSL_DSP_PROXY_H
#define __FSL_HIFI4_PROXY_H #define __FSL_DSP_PROXY_H
#include <linux/wait.h> #include <linux/wait.h>
#include <linux/device.h> #include <linux/device.h>
@ -329,18 +329,18 @@ union icm_header_t {
u32 allbits; u32 allbits;
}; };
struct hifi4_ext_msg { struct dsp_ext_msg {
u32 phys; u32 phys;
u32 size; u32 size;
}; };
struct hifi4_mem_msg { struct dsp_mem_msg {
u32 ext_msg_phys; u32 ext_msg_phys;
u32 ext_msg_size; u32 ext_msg_size;
u32 scratch_phys; u32 scratch_phys;
u32 scratch_size; u32 scratch_size;
u32 hifi_config_phys; u32 dsp_config_phys;
u32 hifi_config_size; u32 dsp_config_size;
}; };
static inline void xf_lock_init(spinlock_t *lock) static inline void xf_lock_init(spinlock_t *lock)
@ -375,7 +375,7 @@ struct xf_message *xf_cmd_recv(struct xf_proxy *proxy,
int wait); int wait);
/* ...mu interrupt handle */ /* ...mu interrupt handle */
irqreturn_t fsl_hifi4_mu_isr(int irq, void *dev_id); irqreturn_t fsl_dsp_mu_isr(int irq, void *dev_id);
/* ...initialize client pending message queue */ /* ...initialize client pending message queue */
void xf_msg_queue_init(struct xf_msg_queue *queue); void xf_msg_queue_init(struct xf_msg_queue *queue);