1095 lines
31 KiB
C
Executable file
1095 lines
31 KiB
C
Executable file
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (c) 2019 MediaTek Inc.
|
|
* Author: Michael Hsiao <michael.hsiao@mediatek.com>
|
|
*/
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* Filename:
|
|
* ---------
|
|
* mt_soc_offloadv2.c
|
|
*
|
|
* Project:
|
|
* --------
|
|
* Audio Driver Kernel Function
|
|
*
|
|
* Description:
|
|
* ------------
|
|
* Audio offloadv2 playback
|
|
*
|
|
* Author:
|
|
* -------
|
|
* HY Chang
|
|
*
|
|
*------------------------------------------------------------------------------
|
|
*
|
|
*
|
|
*****************************************************/
|
|
#include "mtk-auddrv-offloadcommon.h"
|
|
#include <linux/compat.h>
|
|
|
|
/* wake lock relate*/
|
|
#include <linux/device.h>
|
|
#include <linux/pm_wakeup.h>
|
|
|
|
#include "mtk-dsp-common_define.h"
|
|
#include "adsp_feature_define.h"
|
|
#include "adsp_helper.h"
|
|
|
|
#include <audio_task_manager.h>
|
|
#include <audio_ipi_dma.h>
|
|
|
|
//#define DEBUG_VERBOSE
|
|
|
|
/**************************************************
|
|
* Variable Definition
|
|
**************************************************/
|
|
|
|
#define USE_PERIODS_MAX 8192
|
|
#define OFFLOAD_SIZE_BYTES (USE_PERIODS_MAX << 9) /* 4M */
|
|
#define FILL_BUFFERING (USE_PERIODS_MAX << 3) /* 64K */
|
|
#define RESERVE_DRAMPLAYBACKSIZE (USE_PERIODS_MAX << 2) /* 32 K*/
|
|
#define ID AUDIO_TASK_OFFLOAD_ID
|
|
#define GENPOOL_ID AUDIO_DSP_AFE_SHARE_MEM_ID
|
|
|
|
#define aud_wake_lock_init(dev, name) wakeup_source_register(dev, name)
|
|
#define aud_wake_lock_destroy(ws) wakeup_source_destroy(ws)
|
|
#define aud_wake_lock(ws) __pm_stay_awake(ws)
|
|
#define aud_wake_unlock(ws) __pm_relax(ws)
|
|
|
|
enum {
|
|
TASK_SCENE_OFFLOAD_MP3,
|
|
TASK_SCENE_OFFLOAD_AAC
|
|
};
|
|
|
|
typedef uint8_t task_offload_scene_t;
|
|
|
|
static task_offload_scene_t OFFLOAD_TYPE = TASK_SCENE_OFFLOAD_MP3;
|
|
|
|
static struct afe_offload_service_t afe_offload_service = {
|
|
.write_blocked = false,
|
|
.enable = false,
|
|
.drain = false,
|
|
.tswait = false,
|
|
.needdata = false,
|
|
.decode_error = false,
|
|
.volume = 0x10000,
|
|
.scene = TASK_SCENE_PLAYBACK_MP3,
|
|
};
|
|
|
|
static struct afe_offload_param_t afe_offload_block = {
|
|
.state = OFFLOAD_STATE_INIT,
|
|
.samplerate = 0,
|
|
.transferred = 0,
|
|
.copied_total = 0,
|
|
.write_blocked_idx = 0,
|
|
.wakelock = false,
|
|
.drain_state = AUDIO_DRAIN_NONE,
|
|
};
|
|
|
|
static struct afe_offload_codec_t afe_offload_codec_info = {
|
|
.codec_samplerate = 0,
|
|
.codec_bitrate = 0,
|
|
.target_samplerate = 0,
|
|
};
|
|
|
|
static struct snd_compr_stream *offload_stream;
|
|
|
|
static struct device *offload_dev;
|
|
|
|
|
|
static bool offload_playback_pause;
|
|
static bool offload_playback_resume;
|
|
#define use_wake_lock
|
|
static unsigned long ringbuf_writebk;
|
|
static unsigned long long ringbufbridge_writebk;
|
|
|
|
#ifdef use_wake_lock
|
|
static DEFINE_SPINLOCK(offload_lock);
|
|
struct wakeup_source* Offload_suspend_lock;
|
|
#endif
|
|
static struct mtk_base_dsp *dsp;
|
|
static unsigned int offload_buffer_size;
|
|
|
|
/*
|
|
* Function Declaration
|
|
*/
|
|
static void offloadservice_ipicmd_received(struct ipi_msg_t *ipi_msg);
|
|
static void offloadservice_task_unloaded_handling(void);
|
|
static bool offloadservice_tswait(unsigned int id);
|
|
static int offloadservice_copydatatoram(void __user *buf, size_t count);
|
|
#ifdef use_wake_lock
|
|
static void mtk_compr_offload_int_wakelock(bool enable);
|
|
#endif
|
|
|
|
/*
|
|
* Function Implementation
|
|
*/
|
|
|
|
|
|
static void offloadservice_setwriteblocked(bool flag)
|
|
{
|
|
afe_offload_service.write_blocked = flag;
|
|
}
|
|
|
|
static void offloadservice_releasewriteblocked(void)
|
|
{
|
|
offload_stream->runtime->state = SNDRV_PCM_STATE_RUNNING;
|
|
wake_up(&offload_stream->runtime->sleep);
|
|
}
|
|
|
|
static int offloadservice_setvolume(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
afe_offload_service.volume =
|
|
(unsigned int)ucontrol->value.integer.value[0];
|
|
mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_MSG_ONLY,
|
|
AUDIO_IPI_MSG_BYPASS_ACK,
|
|
OFFLOAD_VOLUME, afe_offload_service.volume,
|
|
afe_offload_service.volume, NULL);
|
|
return 0;
|
|
}
|
|
|
|
static int offloadservice_getvolume(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
ucontrol->value.integer.value[0] = afe_offload_service.volume;
|
|
return 0;
|
|
}
|
|
|
|
static int offloadservice_setformat(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
OFFLOAD_TYPE = (task_offload_scene_t)ucontrol->value.integer.value[0];
|
|
pr_debug("%s OFFLOAD_TYPE = %d\n", __func__, OFFLOAD_TYPE);
|
|
return 0;
|
|
}
|
|
|
|
static int offloadservice_getformat(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
ucontrol->value.integer.value[0] = 0;
|
|
if (afe_offload_service.decode_error == true) {
|
|
pr_info("offloadgetformat decode_error\n");
|
|
ucontrol->value.integer.value[0] = 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int offloadservice_setbuffersize(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
offload_buffer_size = (unsigned int)ucontrol->value.integer.value[0];
|
|
pr_info("%s offload_buffer_size = %d\n", __func__, offload_buffer_size);
|
|
return 0;
|
|
}
|
|
|
|
static int offloadservice_getbuffersize(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
ucontrol->value.integer.value[0] = offload_buffer_size;
|
|
return 0;
|
|
}
|
|
|
|
static int offloadservice_settargetrate(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
afe_offload_codec_info.target_samplerate = (unsigned int)ucontrol->value.integer.value[0];
|
|
pr_debug("%s target_samplerate = %d\n", __func__, afe_offload_codec_info.target_samplerate);
|
|
return 0;
|
|
}
|
|
|
|
static int offloadservice_gettargetrate(struct snd_kcontrol *kcontrol,
|
|
struct snd_ctl_elem_value *ucontrol)
|
|
{
|
|
ucontrol->value.integer.value[0] = afe_offload_codec_info.target_samplerate;
|
|
return 0;
|
|
}
|
|
|
|
|
|
static const struct snd_kcontrol_new Audio_snd_dloffload_controls[] = {
|
|
SOC_SINGLE_EXT("offload digital volume", SND_SOC_NOPM, 0, 0x1000000, 0,
|
|
offloadservice_getvolume, offloadservice_setvolume),
|
|
SOC_SINGLE_EXT("offload set format", SND_SOC_NOPM, 0,
|
|
TASK_SCENE_PLAYBACK_MP3, 0,
|
|
offloadservice_getformat, offloadservice_setformat),
|
|
SOC_SINGLE_EXT("offload_buffer_size", SND_SOC_NOPM, 0, 0x400000, 0,
|
|
offloadservice_getbuffersize, offloadservice_setbuffersize),
|
|
SOC_SINGLE_EXT("offload_target_rate", SND_SOC_NOPM, 0, 0x100000, 0,
|
|
offloadservice_gettargetrate, offloadservice_settargetrate),
|
|
};
|
|
|
|
|
|
/*
|
|
* O F F L O A D V 1 D R I V E R O P E R A T I O N S
|
|
*/
|
|
#ifdef use_wake_lock
|
|
static void mtk_compr_offload_int_wakelock(bool enable)
|
|
{
|
|
spin_lock(&offload_lock);
|
|
if (enable ^ afe_offload_block.wakelock) {
|
|
if (enable)
|
|
aud_wake_lock(Offload_suspend_lock);
|
|
else
|
|
aud_wake_unlock(Offload_suspend_lock);
|
|
afe_offload_block.wakelock = enable;
|
|
}
|
|
spin_unlock(&offload_lock);
|
|
}
|
|
#endif
|
|
|
|
static int mtk_compr_offload_draindone(void)
|
|
{
|
|
if (afe_offload_block.state == OFFLOAD_STATE_DRAIN) {
|
|
pr_info("%s\n", __func__);
|
|
/* gapless mode clear vars */
|
|
afe_offload_block.write_blocked_idx = 0;
|
|
afe_offload_block.drain_state = AUDIO_DRAIN_ALL;
|
|
/* for gapless */
|
|
offloadservice_setwriteblocked(false);
|
|
offloadservice_releasewriteblocked();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int mtk_compr_offload_copy(struct snd_compr_stream *stream, char __user *buf,
|
|
size_t count)
|
|
{
|
|
int ret = 0;
|
|
|
|
#ifdef use_wake_lock
|
|
mtk_compr_offload_int_wakelock(true);
|
|
#endif
|
|
ret = offloadservice_copydatatoram(buf, count);
|
|
if (afe_offload_service.decode_error == true)
|
|
ret = -1;
|
|
return ret;
|
|
}
|
|
|
|
static int mtk_compr_offload_drain(struct snd_compr_stream *stream)
|
|
{
|
|
struct RingBuf *ringbuf = &(dsp->dsp_mem[ID].ring_buf);
|
|
struct ringbuf_bridge *buf_bridge =
|
|
&(dsp->dsp_mem[ID].adsp_buf.aud_buffer.buf_bridge);
|
|
|
|
int silence_length = 0;
|
|
int ret;
|
|
void *ipi_audio_buf; /* dsp <-> audio data struct */
|
|
struct audio_dsp_dram *dsp_dram;
|
|
|
|
dsp_dram = &dsp->dsp_mem[ID].msg_atod_share_buf;
|
|
if (afe_offload_block.state != OFFLOAD_STATE_DRAIN) {
|
|
if ((afe_offload_block.state != OFFLOAD_STATE_RUNNING) &&
|
|
(afe_offload_block.transferred < 8 * USE_PERIODS_MAX)) {
|
|
/* send audio_hw_buffer to SCP side, get writeIndx*/
|
|
ipi_audio_buf = (void *)dsp_dram->va_addr;
|
|
memcpy((void *)ipi_audio_buf,
|
|
(void *)&dsp->dsp_mem[ID].adsp_buf,
|
|
sizeof(struct audio_hw_buffer));
|
|
ret = mtk_scp_ipi_send(
|
|
get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_PAYLOAD,
|
|
AUDIO_IPI_MSG_BYPASS_ACK,
|
|
AUDIO_DSP_TASK_DLCOPY,
|
|
sizeof(dsp->dsp_mem[ID].msg_atod_share_buf.phy_addr),
|
|
0,
|
|
(char *)
|
|
&dsp->dsp_mem[ID].msg_atod_share_buf.phy_addr);
|
|
pr_debug("%s(),MSG_DECODER_START, Update the final data, TRANSFERRED %lld\n",
|
|
__func__, afe_offload_block.transferred);
|
|
}
|
|
|
|
silence_length = 0;
|
|
RingBuf_update_writeptr(ringbuf, silence_length);
|
|
RingBuf_Bridge_update_writeptr(buf_bridge, silence_length);
|
|
ringbuf_writebk = (unsigned long)ringbuf->pWrite;
|
|
ringbufbridge_writebk = buf_bridge->pWrite;
|
|
afe_offload_service.needdata = false;
|
|
|
|
pr_info("%s, OFFLOAD_DRAIN", __func__);
|
|
ret = mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_PAYLOAD,
|
|
AUDIO_IPI_MSG_NEED_ACK,
|
|
OFFLOAD_DRAIN,
|
|
sizeof(buf_bridge->pWrite),
|
|
0,
|
|
(void *)&buf_bridge->pWrite);
|
|
afe_offload_block.state = OFFLOAD_STATE_DRAIN;
|
|
afe_offload_block.drain_state = AUDIO_DRAIN_EARLY_NOTIFY;
|
|
}
|
|
#ifdef use_wake_lock
|
|
mtk_compr_offload_int_wakelock(false);
|
|
#endif
|
|
pr_info("%s-", __func__);
|
|
//return -1; /* make compress driver drain failed if use write_wait */
|
|
return 0;
|
|
|
|
}
|
|
|
|
static int mtk_compr_offload_open(struct snd_compr_stream *stream)
|
|
{
|
|
int ret = 0;
|
|
#ifdef use_wake_lock
|
|
mtk_compr_offload_int_wakelock(true);
|
|
#endif
|
|
|
|
mtk_scp_ipi_send(TASK_SCENE_PLAYBACK_MP3,
|
|
AUDIO_IPI_MSG_ONLY,
|
|
AUDIO_IPI_MSG_NEED_ACK,
|
|
AUDIO_DSP_TASK_OPEN,
|
|
0,
|
|
0,
|
|
NULL);
|
|
offload_stream = stream;
|
|
|
|
if (dsp == NULL) {
|
|
dsp = (struct mtk_base_dsp *)get_dsp_base();
|
|
pr_debug("get_dsp_base again\n");
|
|
}
|
|
|
|
if (offload_buffer_size < 262144) { // 256K
|
|
pr_debug("%s err offload_buffer_size = %u\n", __func__, offload_buffer_size);
|
|
return -1;
|
|
}
|
|
|
|
dsp->dsp_mem[ID].gen_pool_buffer =
|
|
mtk_get_adsp_dram_gen_pool(GENPOOL_ID);
|
|
if (dsp->dsp_mem[ID].gen_pool_buffer != NULL) {
|
|
pr_debug("gen_pool_avail = %zu poolsize = %zu\n",
|
|
gen_pool_avail(
|
|
dsp->dsp_mem[ID].gen_pool_buffer),
|
|
gen_pool_size(
|
|
dsp->dsp_mem[ID].gen_pool_buffer));
|
|
|
|
/* allocate ring buffer wioth share memory*/
|
|
ret = mtk_adsp_genpool_allocate_sharemem_ring(
|
|
&dsp->dsp_mem[ID],
|
|
offload_buffer_size,
|
|
ID);
|
|
pr_debug("%s() allocate offload bufsize = %u\n", __func__, offload_buffer_size);
|
|
|
|
if (ret < 0) {
|
|
pr_debug("%s err\n", __func__);
|
|
return -1;
|
|
}
|
|
pr_debug("gen_pool_avail = %zu poolsize = %zu\n",
|
|
gen_pool_avail(
|
|
dsp->dsp_mem[ID].gen_pool_buffer),
|
|
gen_pool_size(
|
|
dsp->dsp_mem[ID].gen_pool_buffer));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_afe_dloffload_component_probe(struct snd_soc_component *component)
|
|
{
|
|
snd_soc_add_component_controls(component, Audio_snd_dloffload_controls,
|
|
ARRAY_SIZE(Audio_snd_dloffload_controls));
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_free(struct snd_compr_stream *stream)
|
|
{
|
|
pr_debug("%s()\n", __func__);
|
|
offloadservice_setwriteblocked(false);
|
|
if (dsp)
|
|
mtk_adsp_genpool_free_sharemem_ring(&dsp->dsp_mem[ID], ID);
|
|
afe_offload_block.state = OFFLOAD_STATE_INIT;
|
|
#ifdef use_wake_lock
|
|
mtk_compr_offload_int_wakelock(false);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_set_params(struct snd_compr_stream *stream,
|
|
struct snd_compr_params *params)
|
|
{
|
|
struct snd_codec codec;
|
|
struct audio_hw_buffer *audio_hwbuf;
|
|
struct mtk_base_dsp_mem *audio_dsp_mem;
|
|
void *ipi_audio_buf; /* dsp <-> audio data struct*/
|
|
int ret = 0;
|
|
|
|
audio_task_register_callback(
|
|
TASK_SCENE_PLAYBACK_MP3,
|
|
offloadservice_ipicmd_received,
|
|
offloadservice_task_unloaded_handling);
|
|
|
|
codec = params->codec;
|
|
afe_offload_block.samplerate = codec.sample_rate;
|
|
|
|
if (!dsp) {
|
|
pr_debug("dsp is null\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
//set shared Dram meme
|
|
audio_hwbuf = &dsp->dsp_mem[ID].adsp_buf;
|
|
audio_dsp_mem = &dsp->dsp_mem[ID];
|
|
dump_audio_dsp_dram(&dsp->dsp_mem[ID].dsp_ring_share_buf);
|
|
//set codec info
|
|
afe_offload_codec_info.codec_samplerate = codec.sample_rate;
|
|
afe_offload_codec_info.codec_bitrate = codec.bit_rate;
|
|
audio_hwbuf->aud_buffer.buffer_attr.channel = codec.ch_out;
|
|
audio_hwbuf->aud_buffer.buffer_attr.format = codec.format;
|
|
audio_hwbuf->aud_buffer.buffer_attr.rate = afe_offload_codec_info.target_samplerate;
|
|
//
|
|
ret = set_audiobuffer_hw(&dsp->dsp_mem[ID].adsp_buf,
|
|
BUFFER_TYPE_SHARE_MEM);
|
|
if (ret < 0)
|
|
goto ERROR;
|
|
ret = set_audiobuffer_memorytype(&dsp->dsp_mem[ID].adsp_buf,
|
|
MEMORY_AUDIO_DRAM);
|
|
if (ret < 0)
|
|
goto ERROR;
|
|
|
|
/* send codec info to SCP side */
|
|
mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_MSG_ONLY,
|
|
AUDIO_IPI_MSG_BYPASS_ACK,
|
|
OFFLOAD_CODEC_INFO,
|
|
afe_offload_codec_info.codec_bitrate,
|
|
afe_offload_codec_info.codec_samplerate
|
|
, NULL);
|
|
|
|
/* send audio_hw_buffer to SCP side */
|
|
ipi_audio_buf =
|
|
(void *)dsp->dsp_mem[ID].msg_atod_share_buf.va_addr;
|
|
pr_debug("%s offload ipi_audio_buf = %p\n", __func__, ipi_audio_buf);
|
|
memcpy((void *)ipi_audio_buf,
|
|
(void *)&dsp->dsp_mem[ID].adsp_buf,
|
|
sizeof(struct audio_hw_buffer));
|
|
|
|
dump_audio_hwbuffer(ipi_audio_buf);
|
|
dump_rbuf_s(__func__, &dsp->dsp_mem[ID].ring_buf);
|
|
|
|
/* send to task with hw_param information , buffer and pcm attribute */
|
|
mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_PAYLOAD,
|
|
AUDIO_IPI_MSG_NEED_ACK, AUDIO_DSP_TASK_HWPARAM,
|
|
sizeof(dsp->dsp_mem[ID].msg_atod_share_buf.phy_addr),
|
|
0,
|
|
(char *)
|
|
&dsp->dsp_mem[ID].msg_atod_share_buf.phy_addr);
|
|
|
|
pr_debug("%s AUDIO_DSP_TASK_HWPARAM Done\n", __func__);
|
|
mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_MSG_ONLY,
|
|
AUDIO_IPI_MSG_NEED_ACK,
|
|
OFFLOAD_SCENE, OFFLOAD_TYPE, OFFLOAD_TYPE, NULL);
|
|
pr_debug("%s OFFLOAD_SCENE Done\n", __func__);
|
|
return ret;
|
|
|
|
ERROR:
|
|
pr_debug("%s err\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
static int mtk_compr_offload_get_params(struct snd_compr_stream *stream,
|
|
struct snd_codec *params)
|
|
{
|
|
pr_debug("%s\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_get_caps(struct snd_compr_stream *stream,
|
|
struct snd_compr_caps *caps)
|
|
{
|
|
pr_debug("%s\n", __func__);
|
|
caps->num_codecs = 2;
|
|
caps->codecs[0] = SND_AUDIOCODEC_PCM;
|
|
caps->codecs[1] = SND_AUDIOCODEC_MP3;
|
|
caps->min_fragment_size = 8192;
|
|
caps->max_fragment_size = 0x7FFFFFFF;
|
|
caps->min_fragments = 2;
|
|
caps->max_fragments = 1875;
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_get_codec_caps(struct snd_compr_stream *stream,
|
|
struct snd_compr_codec_caps *codec)
|
|
{
|
|
pr_debug("%s()\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_set_metadata(struct snd_compr_stream *stream,
|
|
struct snd_compr_metadata *metadata)
|
|
{
|
|
pr_debug("%s()\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_get_metadata(struct snd_compr_stream *stream,
|
|
struct snd_compr_metadata *metadata)
|
|
{
|
|
pr_debug("%s()\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_mmap(struct snd_compr_stream *stream,
|
|
struct vm_area_struct *vma)
|
|
{
|
|
pr_debug("%s()\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static void mtk_dsp_mp3_dl_handler(struct mtk_base_dsp *dsp,
|
|
struct ipi_msg_t *ipi_msg, int id)
|
|
{
|
|
/* get dsp_mem */
|
|
struct mtk_base_dsp_mem *dsp_mem = &dsp->dsp_mem[id];
|
|
struct RingBuf *ringbuf = &(dsp->dsp_mem[ID].ring_buf);
|
|
struct ringbuf_bridge *buf_bridge =
|
|
&(dsp->dsp_mem[ID].adsp_buf.aud_buffer.buf_bridge);
|
|
char *readidx = NULL;
|
|
|
|
#ifdef DEBUG_VERBOSE
|
|
dump_rbuf_s(__func__, &dsp->dsp_mem[id].ring_buf);
|
|
pr_debug("%s msg_id = %u param1 = %u param2 = %u", __func__,
|
|
ipi_msg->msg_id, ipi_msg->param1, ipi_msg->param2);
|
|
#endif
|
|
if (ipi_msg->data_type == AUDIO_IPI_PAYLOAD) {
|
|
memcpy((void *)&dsp_mem->adsp_buf,
|
|
(void *)dsp_mem->msg_dtoa_share_buf.vir_addr,
|
|
sizeof(struct audio_hw_buffer));
|
|
ringbuf->pWrite = (char *)ringbuf_writebk;
|
|
buf_bridge->pWrite = ringbufbridge_writebk;
|
|
readidx = ringbuf->pBufBase +
|
|
(buf_bridge->pRead - buf_bridge->pBufBase);
|
|
if (readidx != ringbuf->pRead) {
|
|
sync_ringbuf_readidx(
|
|
&dsp_mem->ring_buf,
|
|
&dsp_mem->adsp_buf.aud_buffer.buf_bridge);
|
|
pr_debug("%s update read ptr!", __func__);
|
|
}
|
|
}
|
|
#ifdef DEBUG_VERBOSE
|
|
dump_rbuf_s(__func__, &dsp->dsp_mem[id].ring_buf);
|
|
#endif
|
|
}
|
|
|
|
static void offloadservice_ipicmd_received(struct ipi_msg_t *ipi_msg)
|
|
{
|
|
struct mtk_base_dsp *dsp =
|
|
(struct mtk_base_dsp *)get_ipi_recv_private();
|
|
int id = 0;
|
|
|
|
if (ipi_msg == NULL) {
|
|
pr_info("%s ipi_msg == NULL\n", __func__);
|
|
return;
|
|
}
|
|
|
|
if (dsp == NULL) {
|
|
pr_debug("%s dsp == NULL\n", __func__);
|
|
return;
|
|
}
|
|
|
|
id = get_dspdaiid_by_dspscene(ipi_msg->task_scene);
|
|
if (id < 0)
|
|
return;
|
|
|
|
switch (ipi_msg->msg_id) {
|
|
case AUDIO_DSP_TASK_IRQDL:
|
|
mtk_dsp_mp3_dl_handler(dsp, ipi_msg, id);
|
|
offloadservice_setwriteblocked(false);
|
|
offloadservice_releasewriteblocked();
|
|
afe_offload_service.needdata = true;
|
|
break;
|
|
case OFFLOAD_PCMCONSUMED:
|
|
afe_offload_block.copied_total = ipi_msg->param1;
|
|
afe_offload_block.time_pcm = ktime_get();
|
|
afe_offload_block.time_pcm_delay_ms = ipi_msg->param2;
|
|
mutex_lock(&afe_offload_service.ts_lock);
|
|
afe_offload_service.tswait = false;
|
|
wake_up_interruptible(&afe_offload_service.ts_wq);
|
|
mutex_unlock(&afe_offload_service.ts_lock);
|
|
break;
|
|
case OFFLOAD_DRAINDONE:
|
|
pr_info("%s mtk_compr_offload_draindone\n", __func__);
|
|
afe_offload_block.drain_state = AUDIO_DRAIN_ALL;
|
|
mtk_compr_offload_draindone();
|
|
break;
|
|
case OFFLOAD_DECODE_ERROR:
|
|
afe_offload_service.decode_error = true;
|
|
pr_info("%s decode_error\n", __func__);
|
|
break;
|
|
case OFFLOAD_CODEC_INFO:
|
|
if (ipi_msg->param1) {
|
|
afe_offload_codec_info.codec_bitrate = ipi_msg->param1;
|
|
pr_info("%s update bir_rate[%u]\n", __func__, ipi_msg->param1);
|
|
}
|
|
if (ipi_msg->param2) {
|
|
afe_offload_codec_info.codec_samplerate = ipi_msg->param2;
|
|
pr_info("%s sample_rate[%u]\n", __func__, ipi_msg->param2);
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
#ifdef DEBUG_VERBOSE
|
|
pr_debug("%s msg_id:%d\n", __func__, ipi_msg->msg_id);
|
|
#endif
|
|
}
|
|
|
|
|
|
static void offloadservice_task_unloaded_handling(void)
|
|
{
|
|
pr_debug("%s()\n", __func__);
|
|
}
|
|
|
|
static bool offloadservice_tswait(unsigned int id)
|
|
{
|
|
int retval;
|
|
|
|
retval = wait_event_interruptible_timeout(
|
|
afe_offload_service.ts_wq,
|
|
!afe_offload_service.tswait,
|
|
msecs_to_jiffies(OFFLOAD_IPIMSG_TIMEOUT));
|
|
if (!retval)
|
|
pr_info("%s time out\n", __func__);
|
|
|
|
return retval;
|
|
}
|
|
|
|
static int offloadservice_copydatatoram(void __user *buf, size_t count)
|
|
{
|
|
void *ipi_audio_buf; /* dsp <-> audio data struct */
|
|
int copy_size, availsize, ret = 0;
|
|
static unsigned int u4round = 1;
|
|
int transferred = 0;
|
|
struct RingBuf *ringbuf = &(dsp->dsp_mem[ID].ring_buf);
|
|
struct ringbuf_bridge *buf_bridge =
|
|
&(dsp->dsp_mem[ID].adsp_buf.aud_buffer.buf_bridge);
|
|
struct audio_dsp_dram *dsp_dram;
|
|
|
|
dsp_dram = &dsp->dsp_mem[ID].msg_atod_share_buf;
|
|
copy_size = count;
|
|
availsize = RingBuf_getFreeSpace(ringbuf);
|
|
#ifdef DEBUG_VERBOSE
|
|
pr_debug(
|
|
"%s copy_size = %d availsize = %d\n",
|
|
__func__, copy_size,
|
|
RingBuf_getFreeSpace(ringbuf));
|
|
|
|
dump_rbuf_s(__func__, &dsp->dsp_mem[ID].ring_buf);
|
|
#endif
|
|
|
|
if (availsize >= copy_size) {
|
|
RingBuf_copyFromUserLinear(ringbuf, buf, copy_size);
|
|
RingBuf_Bridge_update_writeptr(buf_bridge, copy_size);
|
|
afe_offload_block.transferred += count;
|
|
ringbuf_writebk = (unsigned long)ringbuf->pWrite;
|
|
ringbufbridge_writebk = buf_bridge->pWrite;
|
|
} else {
|
|
//Liang: checked below, should not happened
|
|
pr_debug("%s fail copy_size = %d availsize = %d\n", __func__,
|
|
copy_size, RingBuf_getFreeSpace(ringbuf));
|
|
goto Error;
|
|
}
|
|
//check for next time writable
|
|
if (count >= RingBuf_getFreeSpace(ringbuf)) {
|
|
offloadservice_setwriteblocked(true);
|
|
afe_offload_block.write_blocked_idx =
|
|
buf_bridge->pWrite;
|
|
afe_offload_service.needdata = false;
|
|
u4round = 1;
|
|
mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_PAYLOAD,
|
|
AUDIO_IPI_MSG_BYPASS_ACK,
|
|
OFFLOAD_SETWRITEBLOCK,
|
|
sizeof(afe_offload_block.write_blocked_idx),
|
|
0,
|
|
(void *)&afe_offload_block.write_blocked_idx);
|
|
#ifdef use_wake_lock
|
|
mtk_compr_offload_int_wakelock(false);
|
|
#endif
|
|
pr_debug("%s buffer full , WIdx=%lld\n",
|
|
__func__, buf_bridge->pWrite);
|
|
|
|
}
|
|
|
|
#ifdef DEBUG_VERBOSE
|
|
dump_rbuf_s(__func__, &dsp->dsp_mem[ID].ring_buf);
|
|
Ringbuf_Check(&dsp->dsp_mem[ID].ring_buf);
|
|
Ringbuf_Bridge_Check(
|
|
&dsp->dsp_mem[ID].adsp_buf.aud_buffer.buf_bridge);
|
|
#endif
|
|
|
|
if (afe_offload_service.needdata) {
|
|
transferred = RingBuf_getDataCount(ringbuf);
|
|
if (transferred >=
|
|
(32 * USE_PERIODS_MAX) * u4round) {
|
|
/* notify writeIDX to SCP each 256K*/
|
|
mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_PAYLOAD,
|
|
AUDIO_IPI_MSG_BYPASS_ACK,
|
|
OFFLOAD_WRITEIDX,
|
|
sizeof(buf_bridge->pWrite),
|
|
0,
|
|
(void *)&buf_bridge->pWrite);
|
|
u4round++;
|
|
}
|
|
}
|
|
if ((afe_offload_block.state != OFFLOAD_STATE_RUNNING) &&
|
|
((afe_offload_block.transferred >= 8 * USE_PERIODS_MAX) ||
|
|
(afe_offload_block.transferred < 8 * USE_PERIODS_MAX &&
|
|
afe_offload_block.state == OFFLOAD_STATE_DRAIN))) {
|
|
/* send audio_hw_buffer to SCP side, get writeIndx*/
|
|
ipi_audio_buf = (void *)dsp_dram->va_addr;
|
|
memcpy((void *)ipi_audio_buf,
|
|
(void *)&dsp->dsp_mem[ID].adsp_buf,
|
|
sizeof(struct audio_hw_buffer));
|
|
ret = mtk_scp_ipi_send(
|
|
get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_PAYLOAD,
|
|
AUDIO_IPI_MSG_BYPASS_ACK,
|
|
AUDIO_DSP_TASK_DLCOPY,
|
|
sizeof(dsp->dsp_mem[ID].msg_atod_share_buf.phy_addr),
|
|
0,
|
|
(char *)
|
|
&dsp->dsp_mem[ID].msg_atod_share_buf.phy_addr);
|
|
#ifdef DEBUG_VERBOSE
|
|
pr_debug("%s copy_size = %d availsize = %d\n",
|
|
__func__, copy_size,
|
|
RingBuf_getFreeSpace(ringbuf));
|
|
#endif
|
|
pr_debug("%s(),MSG_DECODER_START, TRANSFERRED %lld\n",
|
|
__func__,
|
|
afe_offload_block.transferred);
|
|
afe_offload_block.state = OFFLOAD_STATE_RUNNING;
|
|
u4round = 1;
|
|
}
|
|
return count;
|
|
Error:
|
|
pr_debug("%s copy failed\n", __func__);
|
|
return -1;
|
|
}
|
|
|
|
static int mtk_compr_send_query_tstamp(void)
|
|
{
|
|
mutex_lock(&afe_offload_service.ts_lock);
|
|
if (!afe_offload_service.tswait && !offload_playback_pause) {
|
|
mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_MSG_ONLY, AUDIO_IPI_MSG_BYPASS_ACK,
|
|
OFFLOAD_TSTAMP, 0, 0, NULL);
|
|
afe_offload_service.tswait = true;
|
|
}
|
|
mutex_unlock(&afe_offload_service.ts_lock);
|
|
return 0;
|
|
}
|
|
static int mtk_compr_offload_pointer(struct snd_compr_stream *stream,
|
|
struct snd_compr_tstamp *tstamp)
|
|
{
|
|
int ret = 0;
|
|
u64 pcm_compensate = 0;
|
|
|
|
mtk_compr_send_query_tstamp();
|
|
|
|
if (afe_offload_block.state == OFFLOAD_STATE_INIT ||
|
|
afe_offload_block.state == OFFLOAD_STATE_IDLE ||
|
|
afe_offload_block.state == OFFLOAD_STATE_PREPARE) {
|
|
tstamp->copied_total = 0;
|
|
tstamp->sampling_rate = afe_offload_block.samplerate;
|
|
tstamp->pcm_io_frames = 0;
|
|
return 0;
|
|
}
|
|
|
|
if (afe_offload_block.state == OFFLOAD_STATE_RUNNING)
|
|
offloadservice_tswait(OFFLOAD_PCMCONSUMED);
|
|
|
|
if (!afe_offload_service.needdata) {
|
|
tstamp->copied_total =
|
|
afe_offload_block.transferred;
|
|
} else {
|
|
tstamp->copied_total =
|
|
afe_offload_block.copied_total;
|
|
}
|
|
if (afe_offload_service.write_blocked ||
|
|
afe_offload_block.state == OFFLOAD_STATE_DRAIN) /* Dram full */
|
|
tstamp->copied_total =
|
|
afe_offload_block.transferred - (8 * USE_PERIODS_MAX);
|
|
if (offload_playback_pause) {
|
|
tstamp->copied_total =
|
|
afe_offload_block.transferred;
|
|
}
|
|
if (afe_offload_block.samplerate != afe_offload_codec_info.codec_samplerate)
|
|
tstamp->sampling_rate = afe_offload_codec_info.codec_samplerate;
|
|
else
|
|
tstamp->sampling_rate = afe_offload_block.samplerate;
|
|
// check for if pcm_delay should < 100ms
|
|
if (afe_offload_block.state == OFFLOAD_STATE_DRAIN ||
|
|
afe_offload_block.state == OFFLOAD_STATE_RUNNING) {
|
|
if ((afe_offload_block.time_pcm_delay_ms > 0) &&
|
|
(afe_offload_block.time_pcm_delay_ms < 100) &&
|
|
(afe_offload_block.copied_total > 0)) {
|
|
pcm_compensate = afe_offload_block.samplerate *
|
|
afe_offload_block.time_pcm_delay_ms / 1000;
|
|
}
|
|
}
|
|
tstamp->pcm_io_frames = (afe_offload_block.copied_total >> 2)
|
|
+ pcm_compensate; /* DSP return 16bit data */
|
|
tstamp->pcm_io_frames = tstamp->pcm_io_frames&0Xffffff80;
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/*
|
|
*=======================================================================
|
|
*-----------------------------------------------------------------------
|
|
*|| O F F L O A D TRIGGER O P E R A T I O N S
|
|
*-----------------------------------------------------------------------
|
|
*=======================================================================
|
|
*/
|
|
static int mtk_compr_offload_start(struct snd_compr_stream *stream)
|
|
{
|
|
int ret = 0;
|
|
afe_offload_block.state = OFFLOAD_STATE_PREPARE;
|
|
offload_playback_pause = false;
|
|
afe_offload_block.drain_state = AUDIO_DRAIN_NONE;
|
|
memset(&afe_offload_block.time_pcm, 0, sizeof(ktime_t));
|
|
ret = mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID), AUDIO_IPI_MSG_ONLY,
|
|
AUDIO_IPI_MSG_DIRECT_SEND, AUDIO_DSP_TASK_START,
|
|
1, 0, NULL);
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_resume(struct snd_compr_stream *stream)
|
|
{
|
|
int ret = 0;
|
|
|
|
if ((afe_offload_block.transferred >= 8 * USE_PERIODS_MAX) ||
|
|
(afe_offload_block.transferred < 8 * USE_PERIODS_MAX &&
|
|
((afe_offload_block.drain_state == AUDIO_DRAIN_EARLY_NOTIFY) ||
|
|
(afe_offload_block.state == OFFLOAD_STATE_DRAIN)))) {
|
|
ret = mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_MSG_ONLY,
|
|
AUDIO_IPI_MSG_NEED_ACK,
|
|
OFFLOAD_RESUME,
|
|
1, 0, NULL);
|
|
|
|
if (afe_offload_block.drain_state != AUDIO_DRAIN_EARLY_NOTIFY)
|
|
afe_offload_block.state = OFFLOAD_STATE_RUNNING;
|
|
}
|
|
offloadservice_releasewriteblocked();
|
|
offload_playback_pause = false;
|
|
offload_playback_resume = true;
|
|
memset(&afe_offload_block.time_pcm, 0, sizeof(ktime_t));
|
|
mtk_compr_send_query_tstamp();
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_pause(struct snd_compr_stream *stream)
|
|
{
|
|
int ret = 0;
|
|
|
|
offloadservice_releasewriteblocked();
|
|
#ifdef use_wake_lock
|
|
mtk_compr_offload_int_wakelock(false);
|
|
#endif
|
|
if ((afe_offload_block.transferred >= 8 * USE_PERIODS_MAX) ||
|
|
(afe_offload_block.transferred < 8 * USE_PERIODS_MAX &&
|
|
((afe_offload_block.drain_state == AUDIO_DRAIN_EARLY_NOTIFY) ||
|
|
(afe_offload_block.state == OFFLOAD_STATE_DRAIN)))) {
|
|
ret = mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_MSG_ONLY,
|
|
AUDIO_IPI_MSG_NEED_ACK,
|
|
OFFLOAD_PAUSE,
|
|
1, 0, NULL);
|
|
pr_debug("%s > transferred\n", __func__);
|
|
}
|
|
offload_playback_pause = true;
|
|
offload_playback_resume = false;
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_deinit_offload_service(struct afe_offload_service_t *service)
|
|
{
|
|
if (!service)
|
|
return -1;
|
|
service->write_blocked = false;
|
|
service->enable = false;
|
|
service->drain = false;
|
|
service->tswait = false;
|
|
service->needdata = false;
|
|
service->decode_error = false;
|
|
service->pcmdump = false;
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_compr_offload_stop(struct snd_compr_stream *stream)
|
|
{
|
|
int ret = 0;
|
|
|
|
afe_offload_block.state = OFFLOAD_STATE_IDLE;
|
|
//SetOffloadEnableFlag(false);
|
|
/* stop hw */
|
|
mtk_scp_ipi_send(get_dspscene_by_dspdaiid(ID),
|
|
AUDIO_IPI_MSG_ONLY,
|
|
AUDIO_IPI_MSG_NEED_ACK,
|
|
AUDIO_DSP_TASK_STOP, 1,
|
|
0, NULL);
|
|
afe_offload_block.transferred = 0;
|
|
afe_offload_block.copied_total = 0;
|
|
afe_offload_block.write_blocked_idx = 0;
|
|
afe_offload_block.drain_state = AUDIO_DRAIN_NONE;
|
|
mtk_compr_deinit_offload_service(&afe_offload_service);
|
|
offloadservice_setwriteblocked(false);
|
|
offloadservice_releasewriteblocked();
|
|
clear_audiobuffer_hw(&dsp->dsp_mem[ID].adsp_buf);
|
|
RingBuf_Reset(&dsp->dsp_mem[ID].ring_buf);
|
|
|
|
#ifdef use_wake_lock
|
|
mtk_compr_offload_int_wakelock(false);
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* mtk_compr_offload_trigger
|
|
****************************************************************************/
|
|
static int mtk_compr_offload_trigger(struct snd_compr_stream *stream, int cmd)
|
|
{
|
|
pr_debug("%s cmd:%x\n", __func__, cmd);
|
|
switch (cmd) {
|
|
case SNDRV_PCM_TRIGGER_START:
|
|
return mtk_compr_offload_start(stream);
|
|
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
|
|
case SNDRV_PCM_TRIGGER_RESUME:
|
|
return mtk_compr_offload_resume(stream);
|
|
case SNDRV_PCM_TRIGGER_STOP:
|
|
return mtk_compr_offload_stop(stream);
|
|
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
|
|
case SNDRV_PCM_TRIGGER_SUSPEND:
|
|
return mtk_compr_offload_pause(stream);
|
|
case SND_COMPR_TRIGGER_DRAIN:
|
|
return mtk_compr_offload_drain(stream);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int mtk_asoc_dloffload_new(struct snd_soc_pcm_runtime *rtd)
|
|
{
|
|
pr_debug("%s\n", __func__);
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_dloffload_remove(struct platform_device *pdev)
|
|
{
|
|
pr_debug("%s\n", __func__);
|
|
snd_soc_unregister_component(&pdev->dev);
|
|
return 0;
|
|
}
|
|
|
|
static struct snd_compr_ops mtk_offload_compr_ops = {
|
|
.open = mtk_compr_offload_open,
|
|
.free = mtk_compr_offload_free,
|
|
.set_params = mtk_compr_offload_set_params,
|
|
.get_params = mtk_compr_offload_get_params,
|
|
.set_metadata = mtk_compr_offload_set_metadata,
|
|
.get_metadata = mtk_compr_offload_get_metadata,
|
|
.trigger = mtk_compr_offload_trigger,
|
|
.pointer = mtk_compr_offload_pointer,
|
|
.copy = mtk_compr_offload_copy,
|
|
.mmap = mtk_compr_offload_mmap,
|
|
.ack = NULL,
|
|
.get_caps = mtk_compr_offload_get_caps,
|
|
.get_codec_caps = mtk_compr_offload_get_codec_caps,
|
|
};
|
|
|
|
static struct snd_soc_component_driver mtk_dloffload_soc_component = {
|
|
.name = AFE_PCM_NAME,
|
|
.compr_ops = &mtk_offload_compr_ops,
|
|
.pcm_new = mtk_asoc_dloffload_new,
|
|
.probe = mtk_afe_dloffload_component_probe,
|
|
};
|
|
|
|
static int mtk_offload_init(void)
|
|
{
|
|
mutex_init(&afe_offload_service.ts_lock);
|
|
init_waitqueue_head(&afe_offload_service.ts_wq);
|
|
return 0;
|
|
}
|
|
|
|
static int mtk_dloffload_probe(struct platform_device *pdev)
|
|
{
|
|
if (pdev->dev.of_node)
|
|
dev_set_name(&pdev->dev, "%s", "mt_soc_offload_common");
|
|
pdev->name = pdev->dev.kobj.name;
|
|
|
|
pr_info("%s: dev name %s\n", __func__, dev_name(&pdev->dev));
|
|
|
|
offload_dev = &pdev->dev;
|
|
mtk_offload_init();
|
|
return snd_soc_register_component(offload_dev,
|
|
&mtk_dloffload_soc_component,
|
|
NULL,
|
|
0);
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
static const struct of_device_id mt_soc_offload_common_of_ids[] = {
|
|
{ .compatible = "mediatek,mt_soc_offload_common", },
|
|
{}
|
|
};
|
|
#endif
|
|
|
|
|
|
static struct platform_driver mtk_offloadplayback_driver = {
|
|
.driver = {
|
|
.name = "mt_soc_offload_common",
|
|
.owner = THIS_MODULE,
|
|
#ifdef CONFIG_OF
|
|
.of_match_table = mt_soc_offload_common_of_ids,
|
|
#endif
|
|
},
|
|
.probe = mtk_dloffload_probe,
|
|
.remove = mtk_dloffload_remove,
|
|
};
|
|
|
|
#ifndef CONFIG_OF
|
|
static struct platform_device *soc_mtkdloffload_dev;
|
|
#endif
|
|
static int __init mtk_offloadplayback_soc_platform_init(void)
|
|
{
|
|
int ret;
|
|
|
|
pr_debug("%s\n", __func__);
|
|
#ifndef CONFIG_OF
|
|
soc_mtkdloffload_dev =
|
|
platform_device_alloc("mt_soc_offload_common", -1);
|
|
if (!soc_mtkdloffload_dev)
|
|
return -ENOMEM;
|
|
ret = platform_device_add(soc_mtkdloffload_dev);
|
|
if (ret != 0) {
|
|
platform_device_put(soc_mtkdloffload_dev);
|
|
return ret;
|
|
}
|
|
#endif
|
|
ret = platform_driver_register(&mtk_offloadplayback_driver);
|
|
#ifdef use_wake_lock
|
|
Offload_suspend_lock = aud_wake_lock_init(NULL, "Offload wakelock");
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
module_init(mtk_offloadplayback_soc_platform_init);
|
|
|
|
static void __exit mtk_offloadplayback_soc_platform_exit(void)
|
|
{
|
|
pr_debug("%s\n", __func__);
|
|
platform_driver_unregister(&mtk_offloadplayback_driver);
|
|
#ifdef use_wake_lock
|
|
aud_wake_lock_destroy(Offload_suspend_lock);
|
|
#endif
|
|
}
|
|
|
|
module_exit(mtk_offloadplayback_soc_platform_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("MediaTek Offload Driver");
|