| /* Copyright (c) 2010-2013, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| */ |
| |
| #include <linux/module.h> |
| #include <linux/fs.h> |
| #include <linux/miscdevice.h> |
| #include <linux/uaccess.h> |
| #include <linux/sched.h> |
| #include <linux/wait.h> |
| #include <linux/dma-mapping.h> |
| #include <linux/slab.h> |
| #include <linux/atomic.h> |
| #include <asm/ioctls.h> |
| #include "audio_utils.h" |
| |
| static int audio_in_pause(struct q6audio_in *audio) |
| { |
| int rc; |
| |
| rc = q6asm_cmd(audio->ac, CMD_PAUSE); |
| if (rc < 0) |
| pr_err("%s:session id %d: pause cmd failed rc=%d\n", __func__, |
| audio->ac->session, rc); |
| |
| return rc; |
| } |
| |
| static int audio_in_flush(struct q6audio_in *audio) |
| { |
| int rc; |
| |
| pr_debug("%s:session id %d: flush\n", __func__, audio->ac->session); |
| /* Flush if session running */ |
| if (audio->enabled) { |
| /* Implicitly issue a pause to the encoder before flushing */ |
| rc = audio_in_pause(audio); |
| if (rc < 0) { |
| pr_err("%s:session id %d: pause cmd failed rc=%d\n", |
| __func__, audio->ac->session, rc); |
| return rc; |
| } |
| |
| rc = q6asm_cmd(audio->ac, CMD_FLUSH); |
| if (rc < 0) { |
| pr_err("%s:session id %d: flush cmd failed rc=%d\n", |
| __func__, audio->ac->session, rc); |
| return rc; |
| } |
| /* 2nd arg: 0 -> run immediately |
| 3rd arg: 0 -> msw_ts, 4th arg: 0 ->lsw_ts */ |
| q6asm_run(audio->ac, 0x00, 0x00, 0x00); |
| pr_debug("Rerun the session\n"); |
| } |
| audio->rflush = 1; |
| audio->wflush = 1; |
| memset(audio->out_frame_info, 0, sizeof(audio->out_frame_info)); |
| wake_up(&audio->read_wait); |
| /* get read_lock to ensure no more waiting read thread */ |
| mutex_lock(&audio->read_lock); |
| audio->rflush = 0; |
| mutex_unlock(&audio->read_lock); |
| wake_up(&audio->write_wait); |
| /* get write_lock to ensure no more waiting write thread */ |
| mutex_lock(&audio->write_lock); |
| audio->wflush = 0; |
| mutex_unlock(&audio->write_lock); |
| pr_debug("%s:session id %d: in_bytes %d\n", __func__, |
| audio->ac->session, atomic_read(&audio->in_bytes)); |
| pr_debug("%s:session id %d: in_samples %d\n", __func__, |
| audio->ac->session, atomic_read(&audio->in_samples)); |
| atomic_set(&audio->in_bytes, 0); |
| atomic_set(&audio->in_samples, 0); |
| atomic_set(&audio->out_count, 0); |
| return 0; |
| } |
| |
| /* must be called with audio->lock held */ |
| int audio_in_enable(struct q6audio_in *audio) |
| { |
| if (audio->enabled) |
| return 0; |
| |
| /* 2nd arg: 0 -> run immediately |
| 3rd arg: 0 -> msw_ts, 4th arg: 0 ->lsw_ts */ |
| return q6asm_run(audio->ac, 0x00, 0x00, 0x00); |
| } |
| |
| /* must be called with audio->lock held */ |
| int audio_in_disable(struct q6audio_in *audio) |
| { |
| int rc = 0; |
| if (!audio->stopped) { |
| audio->enabled = 0; |
| audio->opened = 0; |
| pr_debug("%s:session id %d: inbytes[%d] insamples[%d]\n", |
| __func__, audio->ac->session, |
| atomic_read(&audio->in_bytes), |
| atomic_read(&audio->in_samples)); |
| |
| rc = q6asm_cmd(audio->ac, CMD_CLOSE); |
| if (rc < 0) |
| pr_err("%s:session id %d: Failed to close the session rc=%d\n", |
| __func__, audio->ac->session, |
| rc); |
| audio->stopped = 1; |
| memset(audio->out_frame_info, 0, |
| sizeof(audio->out_frame_info)); |
| wake_up(&audio->read_wait); |
| wake_up(&audio->write_wait); |
| } |
| pr_debug("%s:session id %d: enabled[%d]\n", __func__, |
| audio->ac->session, audio->enabled); |
| return rc; |
| } |
| |
| int audio_in_buf_alloc(struct q6audio_in *audio) |
| { |
| int rc = 0; |
| |
| switch (audio->buf_alloc) { |
| case NO_BUF_ALLOC: |
| if (audio->feedback == NON_TUNNEL_MODE) { |
| rc = q6asm_audio_client_buf_alloc(IN, |
| audio->ac, |
| ALIGN_BUF_SIZE(audio->pcm_cfg.buffer_size), |
| audio->pcm_cfg.buffer_count); |
| if (rc < 0) { |
| pr_err("%s:session id %d: Buffer Alloc failed\n", |
| __func__, |
| audio->ac->session); |
| rc = -ENOMEM; |
| break; |
| } |
| audio->buf_alloc |= BUF_ALLOC_IN; |
| } |
| rc = q6asm_audio_client_buf_alloc(OUT, audio->ac, |
| ALIGN_BUF_SIZE(audio->str_cfg.buffer_size), |
| audio->str_cfg.buffer_count); |
| if (rc < 0) { |
| pr_err("%s:session id %d: Buffer Alloc failed rc=%d\n", |
| __func__, audio->ac->session, rc); |
| rc = -ENOMEM; |
| break; |
| } |
| audio->buf_alloc |= BUF_ALLOC_OUT; |
| break; |
| case BUF_ALLOC_IN: |
| rc = q6asm_audio_client_buf_alloc(OUT, audio->ac, |
| ALIGN_BUF_SIZE(audio->str_cfg.buffer_size), |
| audio->str_cfg.buffer_count); |
| if (rc < 0) { |
| pr_err("%s:session id %d: Buffer Alloc failed rc=%d\n", |
| __func__, audio->ac->session, rc); |
| rc = -ENOMEM; |
| break; |
| } |
| audio->buf_alloc |= BUF_ALLOC_OUT; |
| break; |
| case BUF_ALLOC_OUT: |
| if (audio->feedback == NON_TUNNEL_MODE) { |
| rc = q6asm_audio_client_buf_alloc(IN, audio->ac, |
| ALIGN_BUF_SIZE(audio->pcm_cfg.buffer_size), |
| audio->pcm_cfg.buffer_count); |
| if (rc < 0) { |
| pr_err("%s:session id %d: Buffer Alloc failed\n", |
| __func__, |
| audio->ac->session); |
| rc = -ENOMEM; |
| break; |
| } |
| audio->buf_alloc |= BUF_ALLOC_IN; |
| } |
| break; |
| default: |
| pr_debug("%s:session id %d: buf[%d]\n", __func__, |
| audio->ac->session, audio->buf_alloc); |
| } |
| |
| return rc; |
| } |
| /* ------------------- device --------------------- */ |
| long audio_in_ioctl(struct file *file, |
| unsigned int cmd, unsigned long arg) |
| { |
| struct q6audio_in *audio = file->private_data; |
| int rc = 0; |
| |
| if (cmd == AUDIO_GET_STATS) { |
| struct msm_audio_stats stats; |
| memset(&stats, 0, sizeof(stats)); |
| stats.byte_count = atomic_read(&audio->in_bytes); |
| stats.sample_count = atomic_read(&audio->in_samples); |
| if (copy_to_user((void *) arg, &stats, sizeof(stats))) |
| return -EFAULT; |
| return rc; |
| } |
| |
| mutex_lock(&audio->lock); |
| switch (cmd) { |
| case AUDIO_FLUSH: { |
| /* Make sure we're stopped and we wake any threads |
| * that might be blocked holding the read_lock. |
| * While audio->stopped read threads will always |
| * exit immediately. |
| */ |
| rc = audio_in_flush(audio); |
| if (rc < 0) |
| pr_err("%s:session id %d: Flush Fail rc=%d\n", |
| __func__, audio->ac->session, rc); |
| else { /* Register back the flushed read buffer with DSP */ |
| int cnt = 0; |
| while (cnt++ < audio->str_cfg.buffer_count) |
| q6asm_read(audio->ac); /* Push buffer to DSP */ |
| pr_debug("register the read buffer\n"); |
| } |
| break; |
| } |
| case AUDIO_PAUSE: { |
| pr_debug("%s:session id %d: AUDIO_PAUSE\n", __func__, |
| audio->ac->session); |
| if (audio->enabled) |
| audio_in_pause(audio); |
| break; |
| } |
| case AUDIO_GET_STREAM_CONFIG: { |
| struct msm_audio_stream_config cfg; |
| memset(&cfg, 0, sizeof(cfg)); |
| cfg.buffer_size = audio->str_cfg.buffer_size; |
| cfg.buffer_count = audio->str_cfg.buffer_count; |
| if (copy_to_user((void *)arg, &cfg, sizeof(cfg))) |
| rc = -EFAULT; |
| pr_debug("%s:session id %d: AUDIO_GET_STREAM_CONFIG %d %d\n", |
| __func__, audio->ac->session, cfg.buffer_size, |
| cfg.buffer_count); |
| break; |
| } |
| case AUDIO_SET_STREAM_CONFIG: { |
| struct msm_audio_stream_config cfg; |
| if (copy_from_user(&cfg, (void *)arg, sizeof(cfg))) { |
| rc = -EFAULT; |
| break; |
| } |
| /* Minimum single frame size, |
| but with in maximum frames number */ |
| if ((cfg.buffer_size < (audio->min_frame_size+ \ |
| sizeof(struct meta_out_dsp))) || |
| (cfg.buffer_count < FRAME_NUM)) { |
| rc = -EINVAL; |
| break; |
| } |
| audio->str_cfg.buffer_size = cfg.buffer_size; |
| audio->str_cfg.buffer_count = cfg.buffer_count; |
| if(audio->opened){ |
| rc = q6asm_audio_client_buf_alloc(OUT,audio->ac, |
| ALIGN_BUF_SIZE(audio->str_cfg.buffer_size), |
| audio->str_cfg.buffer_count); |
| if (rc < 0) { |
| pr_err("%s: session id %d: Buffer Alloc failed rc=%d\n", |
| __func__, audio->ac->session, rc); |
| rc = -ENOMEM; |
| break; |
| } |
| } |
| audio->buf_alloc |= BUF_ALLOC_OUT; |
| rc = 0; |
| pr_debug("%s:session id %d: AUDIO_SET_STREAM_CONFIG %d %d\n", |
| __func__, audio->ac->session, |
| audio->str_cfg.buffer_size, |
| audio->str_cfg.buffer_count); |
| break; |
| } |
| case AUDIO_GET_SESSION_ID: { |
| if (copy_to_user((void *) arg, &audio->ac->session, |
| sizeof(unsigned short))) { |
| rc = -EFAULT; |
| } |
| break; |
| } |
| case AUDIO_SET_BUF_CFG: { |
| struct msm_audio_buf_cfg cfg; |
| if (copy_from_user(&cfg, (void *)arg, sizeof(cfg))) { |
| rc = -EFAULT; |
| break; |
| } |
| if ((audio->feedback == NON_TUNNEL_MODE) && |
| !cfg.meta_info_enable) { |
| rc = -EFAULT; |
| break; |
| } |
| |
| /* Restrict the num of frames per buf to coincide with |
| * default buf size */ |
| if (cfg.frames_per_buf > audio->max_frames_per_buf) { |
| rc = -EFAULT; |
| break; |
| } |
| audio->buf_cfg.meta_info_enable = cfg.meta_info_enable; |
| audio->buf_cfg.frames_per_buf = cfg.frames_per_buf; |
| pr_debug("%s:session id %d: Set-buf-cfg: meta[%d] framesperbuf[%d]\n", |
| __func__, |
| audio->ac->session, cfg.meta_info_enable, |
| cfg.frames_per_buf); |
| break; |
| } |
| case AUDIO_GET_BUF_CFG: { |
| pr_debug("%s:session id %d: Get-buf-cfg: meta[%d] framesperbuf[%d]\n", |
| __func__, |
| audio->ac->session, audio->buf_cfg.meta_info_enable, |
| audio->buf_cfg.frames_per_buf); |
| |
| if (copy_to_user((void *)arg, &audio->buf_cfg, |
| sizeof(struct msm_audio_buf_cfg))) |
| rc = -EFAULT; |
| break; |
| } |
| case AUDIO_GET_CONFIG: { |
| if (copy_to_user((void *)arg, &audio->pcm_cfg, |
| sizeof(struct msm_audio_config))) |
| rc = -EFAULT; |
| break; |
| |
| } |
| case AUDIO_SET_CONFIG: { |
| struct msm_audio_config cfg; |
| if (copy_from_user(&cfg, (void *)arg, sizeof(cfg))) { |
| rc = -EFAULT; |
| break; |
| } |
| if (audio->feedback != NON_TUNNEL_MODE) { |
| pr_err("%s:session id %d: Not sufficient permission to change the record mode\n", |
| __func__, |
| audio->ac->session); |
| rc = -EACCES; |
| break; |
| } |
| if ((cfg.buffer_count > PCM_BUF_COUNT) || |
| (cfg.buffer_count == 1)) |
| cfg.buffer_count = PCM_BUF_COUNT; |
| |
| audio->pcm_cfg.buffer_count = cfg.buffer_count; |
| audio->pcm_cfg.buffer_size = cfg.buffer_size; |
| audio->pcm_cfg.channel_count = cfg.channel_count; |
| audio->pcm_cfg.sample_rate = cfg.sample_rate; |
| if(audio->opened && audio->feedback == NON_TUNNEL_MODE){ |
| rc = q6asm_audio_client_buf_alloc(IN, audio->ac, |
| ALIGN_BUF_SIZE(audio->pcm_cfg.buffer_size), |
| audio->pcm_cfg.buffer_count); |
| if(rc < 0){ |
| pr_err("%s:session id %d: Buffer Alloc failed\n", |
| __func__,audio->ac->session); |
| rc = -ENOMEM; |
| break; |
| } |
| } |
| audio->buf_alloc |= BUF_ALLOC_IN; |
| rc = 0; |
| pr_debug("%s:session id %d: AUDIO_SET_CONFIG %d %d\n", __func__, |
| audio->ac->session, audio->pcm_cfg.buffer_count, |
| audio->pcm_cfg.buffer_size); |
| break; |
| } |
| default: |
| /* call codec specific ioctl */ |
| rc = audio->enc_ioctl(file, cmd, arg); |
| } |
| mutex_unlock(&audio->lock); |
| return rc; |
| } |
| |
| ssize_t audio_in_read(struct file *file, |
| char __user *buf, |
| size_t count, loff_t *pos) |
| { |
| struct q6audio_in *audio = file->private_data; |
| const char __user *start = buf; |
| unsigned char *data; |
| uint32_t offset = 0; |
| uint32_t size = 0; |
| int rc = 0; |
| uint32_t idx; |
| struct meta_out_dsp meta; |
| uint32_t bytes_to_copy = 0; |
| uint32_t mfield_size = (audio->buf_cfg.meta_info_enable == 0) ? 0 : |
| (sizeof(unsigned char) + |
| (sizeof(struct meta_out_dsp)*(audio->buf_cfg.frames_per_buf))); |
| memset(&meta, 0, sizeof(meta)); |
| pr_debug("%s:session id %d: read - %d\n", __func__, audio->ac->session, |
| count); |
| if (!audio->enabled) |
| return -EFAULT; |
| mutex_lock(&audio->read_lock); |
| while (count > 0) { |
| rc = wait_event_interruptible( |
| audio->read_wait, |
| ((atomic_read(&audio->out_count) > 0) || |
| (audio->stopped) || |
| audio->rflush || audio->eos_rsp || |
| audio->event_abort)); |
| |
| if (audio->event_abort) { |
| rc = -EIO; |
| break; |
| } |
| |
| |
| if (rc < 0) |
| break; |
| |
| if ((audio->stopped && !(atomic_read(&audio->out_count))) || |
| audio->rflush) { |
| pr_debug("%s:session id %d: driver in stop state or flush,No more buf to read", |
| __func__, |
| audio->ac->session); |
| rc = 0;/* End of File */ |
| break; |
| } |
| if (!(atomic_read(&audio->out_count)) && |
| (audio->eos_rsp == 1) && |
| (count >= (sizeof(unsigned char) + |
| sizeof(struct meta_out_dsp)))) { |
| unsigned char num_of_frames; |
| pr_info("%s:session id %d: eos %d at output\n", |
| __func__, audio->ac->session, audio->eos_rsp); |
| if (buf != start) |
| break; |
| num_of_frames = 0xFF; |
| if (copy_to_user(buf, &num_of_frames, |
| sizeof(unsigned char))) { |
| rc = -EFAULT; |
| break; |
| } |
| buf += sizeof(unsigned char); |
| meta.frame_size = 0xFFFF; |
| meta.encoded_pcm_samples = 0xFFFF; |
| meta.msw_ts = 0x00; |
| meta.lsw_ts = 0x00; |
| meta.nflags = AUD_EOS_SET; |
| audio->eos_rsp = 0; |
| if (copy_to_user(buf, &meta, sizeof(meta))) { |
| rc = -EFAULT; |
| break; |
| } |
| buf += sizeof(meta); |
| break; |
| } |
| data = (unsigned char *)q6asm_is_cpu_buf_avail(OUT, audio->ac, |
| &size, &idx); |
| if ((count >= (size + mfield_size)) && data) { |
| if (audio->buf_cfg.meta_info_enable) { |
| if (copy_to_user(buf, |
| &audio->out_frame_info[idx][0], |
| sizeof(unsigned char))) { |
| rc = -EFAULT; |
| break; |
| } |
| bytes_to_copy = |
| (size + audio->out_frame_info[idx][1]); |
| /* Number of frames information copied */ |
| buf += sizeof(unsigned char); |
| count -= sizeof(unsigned char); |
| } else { |
| offset = audio->out_frame_info[idx][1]; |
| bytes_to_copy = size; |
| } |
| |
| pr_debug("%s:session id %d: offset=%d nr of frames= %d\n", |
| __func__, audio->ac->session, |
| audio->out_frame_info[idx][1], |
| audio->out_frame_info[idx][0]); |
| |
| if (copy_to_user(buf, &data[offset], bytes_to_copy)) { |
| rc = -EFAULT; |
| break; |
| } |
| count -= bytes_to_copy; |
| buf += bytes_to_copy; |
| } else { |
| pr_err("%s:session id %d: short read data[%p] bytesavail[%d]bytesrequest[%d]\n", |
| __func__, |
| audio->ac->session, |
| data, size, count); |
| } |
| atomic_dec(&audio->out_count); |
| q6asm_read(audio->ac); |
| break; |
| } |
| mutex_unlock(&audio->read_lock); |
| |
| pr_debug("%s:session id %d: read: %d bytes\n", __func__, |
| audio->ac->session, (buf-start)); |
| if (buf > start) |
| return buf - start; |
| return rc; |
| } |
| |
| static int extract_meta_info(char *buf, unsigned long *msw_ts, |
| unsigned long *lsw_ts, unsigned int *flags) |
| { |
| struct meta_in *meta = (struct meta_in *)buf; |
| *msw_ts = meta->ntimestamp.highpart; |
| *lsw_ts = meta->ntimestamp.lowpart; |
| *flags = meta->nflags; |
| return 0; |
| } |
| |
| ssize_t audio_in_write(struct file *file, |
| const char __user *buf, |
| size_t count, loff_t *pos) |
| { |
| struct q6audio_in *audio = file->private_data; |
| const char __user *start = buf; |
| size_t xfer = 0; |
| char *cpy_ptr; |
| int rc = 0; |
| unsigned char *data; |
| uint32_t size = 0; |
| uint32_t idx = 0; |
| uint32_t nflags = 0; |
| unsigned long msw_ts = 0; |
| unsigned long lsw_ts = 0; |
| uint32_t mfield_size = (audio->buf_cfg.meta_info_enable == 0) ? 0 : |
| sizeof(struct meta_in); |
| |
| pr_debug("%s:session id %d: to write[%d]\n", __func__, |
| audio->ac->session, count); |
| if (!audio->enabled) |
| return -EFAULT; |
| mutex_lock(&audio->write_lock); |
| |
| while (count > 0) { |
| rc = wait_event_interruptible(audio->write_wait, |
| ((atomic_read(&audio->in_count) > 0) || |
| (audio->stopped) || |
| (audio->wflush) || (audio->event_abort))); |
| |
| if (audio->event_abort) { |
| rc = -EIO; |
| break; |
| } |
| |
| if (rc < 0) |
| break; |
| if (audio->stopped || audio->wflush) { |
| pr_debug("%s: session id %d: stop or flush\n", __func__, |
| audio->ac->session); |
| rc = -EBUSY; |
| break; |
| } |
| /* if no PCM data, might have only eos buffer |
| such case do not hold cpu buffer */ |
| if ((buf == start) && (count == mfield_size)) { |
| char eos_buf[sizeof(struct meta_in)]; |
| /* Processing begining of user buffer */ |
| if (copy_from_user(eos_buf, buf, mfield_size)) { |
| rc = -EFAULT; |
| break; |
| } |
| /* Check if EOS flag is set and buffer has |
| * contains just meta field |
| */ |
| extract_meta_info(eos_buf, &msw_ts, &lsw_ts, |
| &nflags); |
| buf += mfield_size; |
| /* send the EOS and return */ |
| pr_debug("%s:session id %d: send EOS 0x%8x\n", |
| __func__, |
| audio->ac->session, nflags); |
| break; |
| } |
| data = (unsigned char *)q6asm_is_cpu_buf_avail(IN, audio->ac, |
| &size, &idx); |
| if (!data) { |
| pr_debug("%s:session id %d: No buf available\n", |
| __func__, audio->ac->session); |
| continue; |
| } |
| cpy_ptr = data; |
| if (audio->buf_cfg.meta_info_enable) { |
| if (buf == start) { |
| /* Processing beginning of user buffer */ |
| if (copy_from_user(cpy_ptr, buf, mfield_size)) { |
| rc = -EFAULT; |
| break; |
| } |
| /* Check if EOS flag is set and buffer has |
| * contains just meta field |
| */ |
| extract_meta_info(cpy_ptr, &msw_ts, &lsw_ts, |
| &nflags); |
| buf += mfield_size; |
| count -= mfield_size; |
| } else { |
| pr_debug("%s:session id %d: continuous buffer\n", |
| __func__, audio->ac->session); |
| } |
| } |
| xfer = (count > (audio->pcm_cfg.buffer_size)) ? |
| (audio->pcm_cfg.buffer_size) : count; |
| |
| if (copy_from_user(cpy_ptr, buf, xfer)) { |
| rc = -EFAULT; |
| break; |
| } |
| rc = q6asm_write(audio->ac, xfer, msw_ts, lsw_ts, 0x00); |
| if (rc < 0) { |
| rc = -EFAULT; |
| break; |
| } |
| atomic_dec(&audio->in_count); |
| count -= xfer; |
| buf += xfer; |
| } |
| mutex_unlock(&audio->write_lock); |
| pr_debug("%s:session id %d: eos_condition 0x%8x buf[0x%x] start[0x%x]\n", |
| __func__, audio->ac->session, |
| nflags, (int) buf, (int) start); |
| if (nflags & AUD_EOS_SET) { |
| rc = q6asm_cmd(audio->ac, CMD_EOS); |
| pr_info("%s:session id %d: eos %d at input\n", __func__, |
| audio->ac->session, audio->eos_rsp); |
| } |
| pr_debug("%s:session id %d: Written %d Avail Buf[%d]", __func__, |
| audio->ac->session, (buf - start - mfield_size), |
| atomic_read(&audio->in_count)); |
| if (!rc) { |
| if (buf > start) |
| return buf - start; |
| } |
| return rc; |
| } |
| |
| int audio_in_release(struct inode *inode, struct file *file) |
| { |
| struct q6audio_in *audio = file->private_data; |
| pr_info("%s: session id %d\n", __func__, audio->ac->session); |
| mutex_lock(&audio->lock); |
| audio_in_disable(audio); |
| q6asm_audio_client_free(audio->ac); |
| mutex_unlock(&audio->lock); |
| kfree(audio->enc_cfg); |
| kfree(audio->codec_cfg); |
| kfree(audio); |
| return 0; |
| } |
| |