android/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

audio-kernel: upgrade to ar/spf changes

Browse Source 
Rename casa to ar and gecko to spf in audio-kernel.

Change-Id: Ia37ee0497ce043443ca70131d2739737cb8f0366
Signed-off-by: Phani Kumar Uppalapati <phaniu@codeaurora.org>
This commit is contained in:
Phani Kumar Uppalapati 2020-06-10 00:39:35 -07:00
parent 25f314627d
commit bc326d21fd
13 changed files with 125 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
asoc/msm_common.c
View File

@ -19,7 +19,7 @@
#include <sound/core.h>
#include <sound/soc.h>
#include <asoc/msm-cdc-pinctrl.h>
#include <dsp/gecko-core.h>
#include <dsp/spf-core.h>
#include <dsp/msm_audio_ion.h>
#include <sound/info.h>
@ -133,7 +133,7 @@ static void check_userspace_service_state(struct snd_soc_pcm_runtime *rtd,
__func__);
if (pdata->dsp_sessions_closed == 0) {
/*Issue close all graph cmd to DSP*/
gecko_core_apm_close_all();
spf_core_apm_close_all();
/*unmap all dma mapped buffers*/
msm_audio_ion_crash_handler();
pdata->dsp_sessions_closed = 1;

2
config/konaauto.conf
View File

@ -31,7 +31,7 @@ export CONFIG_SND_SOC_WCD938X=m
export CONFIG_SND_SOC_WCD938X_SLAVE=m
export CONFIG_SND_SOC_KONA=m
export CONFIG_SND_EVENT=m
export CONFIG_GECKO_CORE=m
export CONFIG_SPF_CORE=m
export CONFIG_AUDIO_PRM=m
export CONFIG_AUDIO_PKT_ION=m
export CONFIG_MSM_QDSP6_GPR_RPMSG=m

2
config/konaautoconf.h
View File

@ -35,7 +35,7 @@
#define CONFIG_SND_SOC_WCD938X_SLAVE 1
#define CONFIG_SND_SOC_KONA 1
#define CONFIG_SND_EVENT 1
#define CONFIG_GECKO_CORE 1
#define CONFIG_SPF_CORE 1
#define CONFIG_AUDIO_PRM 1
#define CONFIG_AUDIO_PKT_ION 1
#define CONFIG_MSM_QDSP6_GPR_RPMSG 1

2
config/lahainaauto.conf
View File

@ -32,7 +32,7 @@ export CONFIG_SND_SOC_SWR_DMIC=m
export CONFIG_SND_SOC_LAHAINA=m
export CONFIG_SND_EVENT=m
export CONFIG_SND_SWR_HAPTICS=m
export CONFIG_GECKO_CORE=m
export CONFIG_SPF_CORE=m
export CONFIG_AUDIO_PRM=m
export CONFIG_AUDIO_PKT_ION=m
export CONFIG_MSM_QDSP6_GPR_RPMSG=m

2
config/lahainaautoconf.h
View File

@ -36,7 +36,7 @@
#define CONFIG_SND_SOC_LAHAINA 1
#define CONFIG_SND_EVENT 1
#define CONFIG_SND_SWR_HAPTICS 1
#define CONFIG_GECKO_CORE 1
#define CONFIG_SPF_CORE 1
#define CONFIG_AUDIO_PRM 1
#define CONFIG_AUDIO_PKT_ION 1
#define CONFIG_MSM_QDSP6_GPR_RPMSG 1

10
dsp/Kbuild
View File

@ -137,8 +137,8 @@ ifdef CONFIG_MSM_QDSP6_NOTIFIER
QDSP6_NOTIFIER_OBJS += audio_notifier.o audio_ssr.o
endif
ifdef CONFIG_GECKO_CORE
GECKO_CORE_OBJS += gecko-core.o
ifdef CONFIG_SPF_CORE
SPF_CORE_OBJS += spf-core.o
endif
ifdef CONFIG_AUDIO_PRM
@ -154,7 +154,7 @@ VOICE_MHI += voice_mhi.o
endif
ifdef CONFIG_DIGITAL_CDC_RSC_MGR
GECKO_CORE_OBJS += digital-cdc-rsc-mgr.o
SPF_CORE_OBJS += digital-cdc-rsc-mgr.o
endif
LINUX_INC += -Iinclude/linux
@ -217,8 +217,8 @@ adsp_loader_dlkm-y := $(ADSP_LOADER_OBJS)
obj-$(CONFIG_MSM_QDSP6_PDR) += q6_pdr_dlkm.o
q6_pdr_dlkm-y := $(QDSP6_PDR_OBJS)
obj-$(CONFIG_GECKO_CORE) += gecko_core_dlkm.o
gecko_core_dlkm-y := $(GECKO_CORE_OBJS)
obj-$(CONFIG_SPF_CORE) += spf_core_dlkm.o
spf_core_dlkm-y := $(SPF_CORE_OBJS)
obj-$(CONFIG_MSM_QDSP6_NOTIFIER) += q6_notifier_dlkm.o
q6_notifier_dlkm-y := $(QDSP6_NOTIFIER_OBJS)

4
dsp/adsp-loader.c
View File

@ -10,7 +10,7 @@
#include <linux/string.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <dsp/gecko-core.h>
#include <dsp/spf-core.h>
#include <linux/of_device.h>
#include <linux/sysfs.h>
#include <linux/workqueue.h>
@ -130,7 +130,7 @@ static void adsp_load_fw(struct work_struct *adsp_ldr_work)
load_adsp:
{
adsp_state = gecko_core_is_apm_ready();
adsp_state = spf_core_is_apm_ready();
if (adsp_state == APR_SUBSYS_DOWN) {
priv = platform_get_drvdata(pdev);
if (!priv) {

6
dsp/msm_audio_ion.c
View File

@ -21,7 +21,7 @@
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/device.h>
#ifndef CONFIG_GECKO_CORE
#ifndef CONFIG_SPF_CORE
#include <ipc/apr.h>
#endif
#include <dsp/msm_audio_ion.h>
@ -1030,7 +1030,7 @@ static int msm_audio_ion_probe(struct platform_device *pdev)
bool is_non_hypervisor_en;
struct device *dev = &pdev->dev;
struct of_phandle_args iommuspec;
#ifndef CONFIG_GECKO_CORE
#ifndef CONFIG_SPF_CORE
enum apr_subsys_state q6_state;
#endif
@ -1055,7 +1055,7 @@ static int msm_audio_ion_probe(struct platform_device *pdev)
dev_dbg(dev, "%s: SMMU is Disabled\n", __func__);
goto exit;
}
#ifndef CONFIG_GECKO_CORE
#ifndef CONFIG_SPF_CORE
q6_state = apr_get_q6_state();
if (q6_state == APR_SUBSYS_DOWN) {
dev_info(dev,

198
dsp/gecko-core.c → dsp/spf-core.c
View File

@ -20,18 +20,18 @@
#include <linux/of_platform.h>
#include <linux/jiffies.h>
#include <ipc/gpr-lite.h>
#include <dsp/gecko-core.h>
#include <dsp/spf-core.h>
#include <dsp/digital-cdc-rsc-mgr.h>
#define APM_STATE_READY_TIMEOUT_MS 10000
#define Q6_READY_TIMEOUT_MS 1000
#define APM_CMD_GET_GECKO_STATE 0x01001021
#define APM_CMD_GET_SPF_STATE 0x01001021
#define APM_CMD_CLOSE_ALL 0x01001013
#define APM_CMD_RSP_GET_GECKO_STATE 0x02001007
#define APM_CMD_RSP_GET_SPF_STATE 0x02001007
#define APM_MODULE_INSTANCE_ID 0x00000001
#define GPR_SVC_ADSP_CORE 0x3
struct gecko_core {
struct spf_core {
struct gpr_device *adev;
wait_queue_head_t wait;
struct mutex lock;
@ -39,23 +39,23 @@ struct gecko_core {
int32_t status;
};
struct gecko_core_private {
struct spf_core_private {
struct device *dev;
struct mutex lock;
struct gecko_core *gecko_core_drv;
struct spf_core *spf_core_drv;
bool is_initial_boot;
struct work_struct add_chld_dev_work;
};
static struct gecko_core_private *gecko_core_priv;
static struct spf_core_private *spf_core_priv;
/* used to decode basic responses from Gecko */
struct gecko_cmd_basic_rsp {
struct spf_cmd_basic_rsp {
uint32_t opcode;
int32_t status;
};
struct apm_cmd_rsp_get_gecko_status_t
struct apm_cmd_rsp_get_spf_status_t
{
/* Gecko status
@ -67,11 +67,11 @@ struct apm_cmd_rsp_get_gecko_status_t
};
static int gecko_core_callback(struct gpr_device *adev, void *data)
static int spf_core_callback(struct gpr_device *adev, void *data)
{
struct gecko_core *core = dev_get_drvdata(&adev->dev);
struct apm_cmd_rsp_get_gecko_status_t *gecko_status_rsp;
struct gecko_cmd_basic_rsp *basic_rsp;
struct spf_core *core = dev_get_drvdata(&adev->dev);
struct apm_cmd_rsp_get_spf_status_t *spf_status_rsp;
struct spf_cmd_basic_rsp *basic_rsp;
struct gpr_hdr *hdr = data;
@ -79,7 +79,7 @@ static int gecko_core_callback(struct gpr_device *adev, void *data)
switch (hdr->opcode) {
case GPR_IBASIC_RSP_RESULT:
basic_rsp = GPR_PKT_GET_PAYLOAD(
struct gecko_cmd_basic_rsp,
struct spf_cmd_basic_rsp,
data);
dev_info(&adev->dev ,"%s: op %x status %d", __func__,
basic_rsp->opcode, basic_rsp->status);
@ -91,13 +91,13 @@ static int gecko_core_callback(struct gpr_device *adev, void *data)
}
core->resp_received = true;
break;
case APM_CMD_RSP_GET_GECKO_STATE:
gecko_status_rsp =
case APM_CMD_RSP_GET_SPF_STATE:
spf_status_rsp =
GPR_PKT_GET_PAYLOAD(
struct apm_cmd_rsp_get_gecko_status_t,
struct apm_cmd_rsp_get_spf_status_t,
data);
dev_info(&adev->dev ,"%s: sucess response received",__func__);
core->status = gecko_status_rsp->status;
core->status = spf_status_rsp->status;
core->resp_received = true;
break;
default:
@ -111,7 +111,7 @@ static int gecko_core_callback(struct gpr_device *adev, void *data)
return 0;
}
static bool __gecko_core_is_apm_ready(struct gecko_core *core)
static bool __spf_core_is_apm_ready(struct spf_core *core)
{
struct gpr_device *adev = core->adev;
struct gpr_pkt pkt;
@ -126,9 +126,9 @@ static bool __gecko_core_is_apm_ready(struct gecko_core *core)
pkt.hdr.src_port = GPR_SVC_ADSP_CORE;
pkt.hdr.dst_domain_id = GPR_IDS_DOMAIN_ID_ADSP_V;
pkt.hdr.src_domain_id = GPR_IDS_DOMAIN_ID_APPS_V;
pkt.hdr.opcode = APM_CMD_GET_GECKO_STATE;
pkt.hdr.opcode = APM_CMD_GET_SPF_STATE;
dev_err(gecko_core_priv->dev, "%s: send_command ret\n", __func__);
dev_err(spf_core_priv->dev, "%s: send_command ret\n", __func__);
rc = gpr_send_pkt(adev, &pkt);
if (rc < 0) {
@ -138,12 +138,12 @@ static bool __gecko_core_is_apm_ready(struct gecko_core *core)
rc = wait_event_timeout(core->wait, (core->resp_received),
msecs_to_jiffies(Q6_READY_TIMEOUT_MS));
dev_dbg(gecko_core_priv->dev, "%s: wait event unblocked \n", __func__);
dev_dbg(spf_core_priv->dev, "%s: wait event unblocked \n", __func__);
if (rc > 0 && core->resp_received) {
ret = core->status;
} else {
dev_err(gecko_core_priv->dev, "%s: command timedout, ret\n",
dev_err(spf_core_priv->dev, "%s: command timedout, ret\n",
__func__);
}
done:
@ -152,28 +152,28 @@ done:
}
/**
* gecko_core_is_apm_ready() - Get status of adsp
* spf_core_is_apm_ready() - Get status of adsp
*
* Return: Will return true if apm is ready and false if not.
*/
bool gecko_core_is_apm_ready(void)
bool spf_core_is_apm_ready(void)
{
unsigned long timeout;
bool ret = false;
struct gecko_core *core;
struct spf_core *core;
if (!gecko_core_priv)
if (!spf_core_priv)
return ret;
mutex_lock(&gecko_core_priv->lock);
core = gecko_core_priv->gecko_core_drv;
mutex_lock(&spf_core_priv->lock);
core = spf_core_priv->spf_core_drv;
if (!core)
goto done;
timeout = jiffies + msecs_to_jiffies(APM_STATE_READY_TIMEOUT_MS);
mutex_lock(&core->lock);
for (;;) {
if (__gecko_core_is_apm_ready(core)) {
if (__spf_core_is_apm_ready(core)) {
ret = true;
break;
}
@ -186,30 +186,30 @@ bool gecko_core_is_apm_ready(void)
mutex_unlock(&core->lock);
done:
mutex_unlock(&gecko_core_priv->lock);
mutex_unlock(&spf_core_priv->lock);
return ret;
}
EXPORT_SYMBOL_GPL(gecko_core_is_apm_ready);
EXPORT_SYMBOL_GPL(spf_core_is_apm_ready);
/**
* gecko_core_apm_close_all() - Get status of adsp
* spf_core_apm_close_all() - Get status of adsp
*
* Return: Will be return true if apm is ready and false if not.
*/
void gecko_core_apm_close_all(void)
void spf_core_apm_close_all(void)
{
int rc = 0;
struct gecko_core *core;
struct spf_core *core;
struct gpr_pkt pkt;
struct gpr_device *adev = NULL;
if (!gecko_core_priv)
if (!spf_core_priv)
return;
mutex_lock(&gecko_core_priv->lock);
core = gecko_core_priv->gecko_core_drv;
mutex_lock(&spf_core_priv->lock);
core = spf_core_priv->spf_core_drv;
if (!core) {
mutex_unlock(&gecko_core_priv->lock);
mutex_unlock(&spf_core_priv->lock);
return;
}
@ -229,48 +229,48 @@ void gecko_core_apm_close_all(void)
pkt.hdr.src_domain_id = GPR_IDS_DOMAIN_ID_APPS_V;
pkt.hdr.opcode = APM_CMD_CLOSE_ALL;
dev_info(gecko_core_priv->dev, "%s: send_command \n", __func__);
dev_info(spf_core_priv->dev, "%s: send_command \n", __func__);
rc = gpr_send_pkt(adev, &pkt);
if (rc < 0) {
dev_err(gecko_core_priv->dev, "%s: send_pkt_failed %d\n",
dev_err(spf_core_priv->dev, "%s: send_pkt_failed %d\n",
__func__, rc);
goto done;
}
rc = wait_event_timeout(core->wait, (core->resp_received),
msecs_to_jiffies(Q6_READY_TIMEOUT_MS));
dev_info(gecko_core_priv->dev, "%s: wait event unblocked \n", __func__);
dev_info(spf_core_priv->dev, "%s: wait event unblocked \n", __func__);
if (rc > 0 && core->resp_received) {
if (core->status != 0)
dev_err(gecko_core_priv->dev, "%s, cmd failed status %d",
dev_err(spf_core_priv->dev, "%s, cmd failed status %d",
__func__, core->status);
} else {
dev_err(gecko_core_priv->dev, "%s: command timedout, ret\n",
dev_err(spf_core_priv->dev, "%s: command timedout, ret\n",
__func__);
}
done:
core->resp_received = false;
mutex_unlock(&core->lock);
mutex_unlock(&gecko_core_priv->lock);
mutex_unlock(&spf_core_priv->lock);
return;
}
EXPORT_SYMBOL_GPL(gecko_core_apm_close_all);
EXPORT_SYMBOL_GPL(spf_core_apm_close_all);
static int gecko_core_probe(struct gpr_device *adev)
static int spf_core_probe(struct gpr_device *adev)
{
struct gecko_core *core;
struct spf_core *core;
pr_err("%s",__func__);
if (!gecko_core_priv) {
pr_err("%s: gecko_core platform probe not yet done\n", __func__);
if (!spf_core_priv) {
pr_err("%s: spf_core platform probe not yet done\n", __func__);
return -EPROBE_DEFER;
}
mutex_lock(&gecko_core_priv->lock);
mutex_lock(&spf_core_priv->lock);
core = kzalloc(sizeof(*core), GFP_KERNEL);
if (!core) {
mutex_unlock(&gecko_core_priv->lock);
mutex_unlock(&spf_core_priv->lock);
return -ENOMEM;
}
@ -279,90 +279,90 @@ static int gecko_core_probe(struct gpr_device *adev)
mutex_init(&core->lock);
core->adev = adev;
init_waitqueue_head(&core->wait);
gecko_core_priv->gecko_core_drv = core;
if (gecko_core_priv->is_initial_boot)
schedule_work(&gecko_core_priv->add_chld_dev_work);
mutex_unlock(&gecko_core_priv->lock);
spf_core_priv->spf_core_drv = core;
if (spf_core_priv->is_initial_boot)
schedule_work(&spf_core_priv->add_chld_dev_work);
mutex_unlock(&spf_core_priv->lock);
return 0;
}
static int gecko_core_exit(struct gpr_device *adev)
static int spf_core_exit(struct gpr_device *adev)
{
struct gecko_core *core = dev_get_drvdata(&adev->dev);
if (!gecko_core_priv) {
pr_err("%s: gecko_core platform probe not yet done\n", __func__);
struct spf_core *core = dev_get_drvdata(&adev->dev);
if (!spf_core_priv) {
pr_err("%s: spf_core platform probe not yet done\n", __func__);
return -1;
}
mutex_lock(&gecko_core_priv->lock);
gecko_core_priv->gecko_core_drv = NULL;
mutex_lock(&spf_core_priv->lock);
spf_core_priv->spf_core_drv = NULL;
kfree(core);
mutex_unlock(&gecko_core_priv->lock);
mutex_unlock(&spf_core_priv->lock);
return 0;
}
static const struct of_device_id gecko_core_device_id[] = {
{ .compatible = "qcom,gecko_core" },
static const struct of_device_id spf_core_device_id[] = {
{ .compatible = "qcom,spf_core" },
{},
};
MODULE_DEVICE_TABLE(of, gecko_core_device_id);
MODULE_DEVICE_TABLE(of, spf_core_device_id);
static struct gpr_driver qcom_gecko_core_driver = {
.probe = gecko_core_probe,
.remove = gecko_core_exit,
.callback = gecko_core_callback,
static struct gpr_driver qcom_spf_core_driver = {
.probe = spf_core_probe,
.remove = spf_core_exit,
.callback = spf_core_callback,
.driver = {
.name = "qcom-gecko_core",
.of_match_table = of_match_ptr(gecko_core_device_id),
.name = "qcom-spf_core",
.of_match_table = of_match_ptr(spf_core_device_id),
},
};
static void gecko_core_add_child_devices(struct work_struct *work)
static void spf_core_add_child_devices(struct work_struct *work)
{
int ret;
pr_err("%s:enumarate machine driver\n", __func__);
if(gecko_core_is_apm_ready()) {
dev_err(gecko_core_priv->dev, "%s: apm is up\n",
if(spf_core_is_apm_ready()) {
dev_err(spf_core_priv->dev, "%s: apm is up\n",
__func__);
} else {
dev_err(gecko_core_priv->dev, "%s: apm is not up\n",
dev_err(spf_core_priv->dev, "%s: apm is not up\n",
__func__);
return;
}
ret = of_platform_populate(gecko_core_priv->dev->of_node,
NULL, NULL, gecko_core_priv->dev);
ret = of_platform_populate(spf_core_priv->dev->of_node,
NULL, NULL, spf_core_priv->dev);
if (ret)
dev_err(gecko_core_priv->dev, "%s: failed to add child nodes, ret=%d\n",
dev_err(spf_core_priv->dev, "%s: failed to add child nodes, ret=%d\n",
__func__, ret);
gecko_core_priv->is_initial_boot = false;
spf_core_priv->is_initial_boot = false;
}
static int gecko_core_platform_driver_probe(struct platform_device *pdev)
static int spf_core_platform_driver_probe(struct platform_device *pdev)
{
int ret = 0;
pr_err("%s",__func__);
gecko_core_priv = devm_kzalloc(&pdev->dev, sizeof(struct gecko_core_private), GFP_KERNEL);
if (!gecko_core_priv)
spf_core_priv = devm_kzalloc(&pdev->dev, sizeof(struct spf_core_private), GFP_KERNEL);
if (!spf_core_priv)
return -ENOMEM;
gecko_core_priv->dev = &pdev->dev;
spf_core_priv->dev = &pdev->dev;
mutex_init(&gecko_core_priv->lock);
mutex_init(&spf_core_priv->lock);
INIT_WORK(&gecko_core_priv->add_chld_dev_work, gecko_core_add_child_devices);
INIT_WORK(&spf_core_priv->add_chld_dev_work, spf_core_add_child_devices);
ret = gpr_driver_register(&qcom_gecko_core_driver);
ret = gpr_driver_register(&qcom_spf_core_driver);
if (ret) {
pr_err("%s: gpr driver register failed = %d\n",
__func__, ret);
ret = 0;
}
gecko_core_priv->is_initial_boot = true;
spf_core_priv->is_initial_boot = true;
#if 0
ret = snd_event_client_register(&pdev->dev, &gpr_ssr_ops, NULL);
@ -377,31 +377,31 @@ static int gecko_core_platform_driver_probe(struct platform_device *pdev)
return ret;
}
static int gecko_core_platform_driver_remove(struct platform_device *pdev)
static int spf_core_platform_driver_remove(struct platform_device *pdev)
{
//snd_event_client_deregister(&pdev->dev);
gpr_driver_unregister(&qcom_gecko_core_driver);
gecko_core_priv = NULL;
gpr_driver_unregister(&qcom_spf_core_driver);
spf_core_priv = NULL;
digital_cdc_rsc_mgr_exit();
return 0;
}
static const struct of_device_id gecko_core_of_match[] = {
{ .compatible = "qcom,gecko-core-platform", },
static const struct of_device_id spf_core_of_match[] = {
{ .compatible = "qcom,spf-core-platform", },
{},
};
static struct platform_driver gecko_core_driver = {
.probe = gecko_core_platform_driver_probe,
.remove = gecko_core_platform_driver_remove,
static struct platform_driver spf_core_driver = {
.probe = spf_core_platform_driver_probe,
.remove = spf_core_platform_driver_remove,
.driver = {
.name = "gecko-core-platform",
.name = "spf-core-platform",
.owner = THIS_MODULE,
.of_match_table = gecko_core_of_match,
.of_match_table = spf_core_of_match,
}
};
module_platform_driver(gecko_core_driver);
module_platform_driver(spf_core_driver);
MODULE_DESCRIPTION("q6 core");
MODULE_LICENSE("GPL v2");

6
dsp/voice_mhi.c
View File

@ -14,7 +14,7 @@
#include <linux/mutex.h>
#include "voice_mhi.h"
#include <dsp/msm_audio_ion.h>
#include <dsp/gecko-core.h>
#include <dsp/spf-core.h>
#include <dsp/audio_prm.h>
#include <ipc/gpr-lite.h>
@ -388,7 +388,7 @@ static void voice_mhi_map_pcie_and_send(struct work_struct *work)
voice_mhi_lcl.dev_info.iova_pcie.base = iova;
mutex_unlock(&voice_mhi_lcl.mutex);
if (gecko_core_is_apm_ready()) {
if (spf_core_is_apm_ready()) {
voice_mhi_set_mailbox_memory_config();
voice_mhi_start();
}
@ -413,7 +413,7 @@ static void voice_mhi_gpr_send(struct work_struct *work)
if (VOICE_MHI_STATE_CHECK(voice_mhi_lcl.voice_mhi_state,
VOICE_MHI_SDX_UP)) {
mutex_unlock(&voice_mhi_lcl.mutex);
if (gecko_core_is_apm_ready()) {
if (spf_core_is_apm_ready()) {
voice_mhi_set_mailbox_memory_config();
voice_mhi_start();
return;

8
include/dsp/gecko-core.h → include/dsp/spf-core.h
View File

@ -10,11 +10,11 @@
* GNU General Public License for more details.
*/
#ifndef __GECKO_CORE_H__
#define __GECKO_CORE_H__
#ifndef __SPF_CORE_H__
#define __SPF_CORE_H__
#include <ipc/gpr-lite.h>
bool gecko_core_is_apm_ready(void);
void gecko_core_apm_close_all(void);
bool spf_core_is_apm_ready(void);
void spf_core_apm_close_all(void);
#endif

2
include/ipc/gpr-lite.h
View File

@ -149,7 +149,7 @@ struct gpr_q6 {
GPR_PKT_VER)
/**********************************************************************/
/** GECKO GUID definitions ***/
/** SPF GUID definitions ***/
/**********************************************************************/
/* An empty macro to mark non-GUIDs so that GUID script doesn't mistake
the ID for a GUID */

4
ipc/audio-pkt.c
View File

@ -27,7 +27,7 @@
#include <linux/uaccess.h>
#include <linux/termios.h>
#include <ipc/gpr-lite.h>
#include <dsp/gecko-core.h>
#include <dsp/spf-core.h>
#include <dsp/msm_audio_ion.h>
/* Define IPC Logging Macros */
@ -193,7 +193,7 @@ int audio_pkt_release(struct inode *inode, struct file *file)
spin_unlock_irqrestore(&audpkt_dev->queue_lock, flags);
file->private_data = NULL;
gecko_core_apm_close_all();
spf_core_apm_close_all();
msm_audio_ion_crash_handler();
return 0;