/* sound/soc/msm/msm-pcm.c * * Copyright (C) 2008 Google, Inc. * Copyright (C) 2008 HTC Corporation * Copyright (c) 2008-2009, 2012 The Linux Foundation. All rights reserved. * * This software is licensed under the terms of the GNU General Public * License version 2, as published by the Free Software Foundation, and * may be copied, distributed, and modified under those terms. * * 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. * You should have received a copy of the GNU General Public License * along with this program; if not, you can find it at http://www.fsf.org. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include "msm-pcm.h" #define MAX_DATA_SIZE 496 #define AUDPP_ALSA_DECODER (-1) #define DB_TABLE_INDEX (50) #define audio_send_queue_recbs(prtd, cmd, len) \ msm_adsp_write(prtd->audrec, QDSP_uPAudRecBitStreamQueue, cmd, len) #define audio_send_queue_rec(prtd, cmd, len) \ msm_adsp_write(prtd->audrec, QDSP_uPAudRecCmdQueue, cmd, len) int intcnt; struct audio_frame { uint16_t count_low; uint16_t count_high; uint16_t bytes; uint16_t unknown; unsigned char samples[]; } __attribute__ ((packed)); /* Table contains dB to raw value mapping */ static const unsigned decoder_db_table[] = { 31 , /* -50 dB */ 35 , 39 , 44 , 50 , 56 , 63 , 70 , 79 , 89 , 99 , 112 , 125 , 141 , 158 , 177 , 199 , 223 , 251 , 281 , 316 , 354 , 398 , 446 , 501 , 562 , 630 , 707 , 794 , 891 , 999 , 1122 , 1258 , 1412 , 1584 , 1778 , 1995 , 2238 , 2511 , 2818 , 3162 , 3548 , 3981 , 4466 , 5011 , 5623 , 6309 , 7079 , 7943 , 8912 , 10000 , 11220 , 12589 , 14125 , 15848 , 17782 , 19952 , 22387 , 25118 , 28183 , 31622 , 35481 , 39810 , 44668 , 50118 , 56234 , 63095 , 70794 , 79432 , 89125 , 100000 , 112201 , 125892 , 141253 , 158489 , 177827 , 199526 , 223872 , 251188 , 281838 , 316227 , 354813 , 398107 , 446683 , 501187 , 562341 , 630957 , 707945 , 794328 , 891250 , 1000000 , 1122018 , 1258925 , 1412537 , 1584893 , 1778279 , 1995262 , 2238721 , 2511886 , 2818382 , 3162277 , 3548133 /* 51 dB */ }; static unsigned compute_db_raw(int db) { unsigned reg_val = 0; /* Computed result for correspondent db */ /* Check if the given db is out of range */ if (db <= MIN_DB) return 0; else if (db > MAX_DB) db = MAX_DB; /* If db is too high then set to max */ reg_val = decoder_db_table[DB_TABLE_INDEX+db]; return reg_val; } int msm_audio_volume_update(unsigned id, int volume, int pan) { unsigned vol_raw; vol_raw = compute_db_raw(volume); printk(KERN_INFO "volume: %8x vol_raw: %8x \n", volume, vol_raw); return audpp_set_volume_and_pan(id, vol_raw, pan); } EXPORT_SYMBOL(msm_audio_volume_update); void alsa_dsp_event(void *data, unsigned id, uint16_t *msg) { struct msm_audio *prtd = data; struct buffer *frame; unsigned long flag; switch (id) { case AUDPP_MSG_STATUS_MSG: break; case AUDPP_MSG_SPA_BANDS: break; case AUDPP_MSG_HOST_PCM_INTF_MSG:{ unsigned id = msg[2]; unsigned idx = msg[3] - 1; if (id != AUDPP_MSG_HOSTPCM_ID_ARM_RX) { printk(KERN_ERR "bogus id\n"); break; } if (idx > 1) { printk(KERN_ERR "bogus buffer idx\n"); break; } /* Update with actual sent buffer size */ if (prtd->out[idx].used != BUF_INVALID_LEN) prtd->pcm_irq_pos += prtd->out[idx].used; if (prtd->pcm_irq_pos > prtd->pcm_size) prtd->pcm_irq_pos = prtd->pcm_count; if (prtd->ops->playback) prtd->ops->playback(prtd); if (prtd->mmap_flag) break; spin_lock_irqsave(&the_locks.write_dsp_lock, flag); if (prtd->running) { prtd->out[idx].used = 0; frame = prtd->out + prtd->out_tail; if (frame->used) { alsa_dsp_send_buffer(prtd, prtd->out_tail, frame->used); prtd->out_tail ^= 1; } else { prtd->out_needed++; } wake_up(&the_locks.write_wait); } spin_unlock_irqrestore(&the_locks.write_dsp_lock, flag); break; } case AUDPP_MSG_PCMDMAMISSED: pr_info("alsa_dsp_event: PCMDMAMISSED %d\n", msg[0]); prtd->eos_ack = 1; wake_up(&the_locks.eos_wait); break; case AUDPP_MSG_CFG_MSG: if (msg[0] == AUDPP_MSG_ENA_ENA) { prtd->out_needed = 0; prtd->running = 1; audio_dsp_out_enable(prtd, 1); } else if (msg[0] == AUDPP_MSG_ENA_DIS) { prtd->running = 0; } else { printk(KERN_ERR "alsa_dsp_event:CFG_MSG=%d\n", msg[0]); } break; case EVENT_MSG_ID: printk(KERN_INFO"alsa_dsp_event: arm9 event\n"); break; default: printk(KERN_ERR "alsa_dsp_event: UNKNOWN (%d)\n", id); } } void alsa_audpre_dsp_event(void *data, unsigned id, size_t len, void (*getevent) (void *ptr, size_t len)) { uint16_t msg[MAX_DATA_SIZE/2]; if (len > MAX_DATA_SIZE) { printk(KERN_ERR"audpre: event too large(%d bytes)\n", len); return; } getevent(msg, len); switch (id) { case AUDPREPROC_MSG_CMD_CFG_DONE_MSG: break; case AUDPREPROC_MSG_ERROR_MSG_ID: printk(KERN_ERR "audpre: err_index %d\n", msg[0]); break; case EVENT_MSG_ID: printk(KERN_INFO"audpre: arm9 event\n"); break; default: printk(KERN_ERR "audpre: unknown event %d\n", id); } } void audrec_dsp_event(void *data, unsigned id, size_t len, void (*getevent) (void *ptr, size_t len)) { struct msm_audio *prtd = data; unsigned long flag; uint16_t msg[MAX_DATA_SIZE/2]; if (len > MAX_DATA_SIZE) { printk(KERN_ERR"audrec: event/msg too large(%d bytes)\n", len); return; } getevent(msg, len); switch (id) { case AUDREC_MSG_CMD_CFG_DONE_MSG: if (msg[0] & AUDREC_MSG_CFG_DONE_TYPE_0_UPDATE) { if (msg[0] & AUDREC_MSG_CFG_DONE_TYPE_0_ENA) audrec_encoder_config(prtd); else prtd->running = 0; } break; case AUDREC_MSG_CMD_AREC_PARAM_CFG_DONE_MSG:{ prtd->running = 1; break; } case AUDREC_MSG_FATAL_ERR_MSG: printk(KERN_ERR "audrec: ERROR %x\n", msg[0]); break; case AUDREC_MSG_PACKET_READY_MSG: alsa_get_dsp_frames(prtd); ++intcnt; if (prtd->channel_mode == 1) { spin_lock_irqsave(&the_locks.read_dsp_lock, flag); prtd->pcm_irq_pos += prtd->pcm_count; if (prtd->pcm_irq_pos >= prtd->pcm_size) prtd->pcm_irq_pos = 0; spin_unlock_irqrestore(&the_locks.read_dsp_lock, flag); if (prtd->ops->capture) prtd->ops->capture(prtd); } else if ((prtd->channel_mode == 0) && (intcnt % 2 == 0)) { spin_lock_irqsave(&the_locks.read_dsp_lock, flag); prtd->pcm_irq_pos += prtd->pcm_count; if (prtd->pcm_irq_pos >= prtd->pcm_size) prtd->pcm_irq_pos = 0; spin_unlock_irqrestore(&the_locks.read_dsp_lock, flag); if (prtd->ops->capture) prtd->ops->capture(prtd); } break; case EVENT_MSG_ID: printk(KERN_INFO"audrec: arm9 event\n"); break; default: printk(KERN_ERR "audrec: unknown event %d\n", id); } } struct msm_adsp_ops aud_pre_adsp_ops = { .event = alsa_audpre_dsp_event, }; struct msm_adsp_ops aud_rec_adsp_ops = { .event = audrec_dsp_event, }; int alsa_adsp_configure(struct msm_audio *prtd) { int ret, i; if (prtd->dir == SNDRV_PCM_STREAM_PLAYBACK) { prtd->data = prtd->playback_substream->dma_buffer.area; prtd->phys = prtd->playback_substream->dma_buffer.addr; } if (prtd->dir == SNDRV_PCM_STREAM_CAPTURE) { prtd->data = prtd->capture_substream->dma_buffer.area; prtd->phys = prtd->capture_substream->dma_buffer.addr; } if (!prtd->data) { ret = -ENOMEM; goto err1; } ret = audmgr_open(&prtd->audmgr); if (ret) goto err2; if (prtd->dir == SNDRV_PCM_STREAM_PLAYBACK) { prtd->out_buffer_size = PLAYBACK_DMASZ; prtd->out_sample_rate = 44100; prtd->out_channel_mode = AUDPP_CMD_PCM_INTF_STEREO_V; prtd->out_weight = 100; prtd->out[0].data = prtd->data + 0; prtd->out[0].addr = prtd->phys + 0; prtd->out[0].size = BUFSZ; prtd->out[1].data = prtd->data + BUFSZ; prtd->out[1].addr = prtd->phys + BUFSZ; prtd->out[1].size = BUFSZ; } if (prtd->dir == SNDRV_PCM_STREAM_CAPTURE) { prtd->samp_rate = RPC_AUD_DEF_SAMPLE_RATE_44100; prtd->samp_rate_index = AUDREC_CMD_SAMP_RATE_INDX_44100; prtd->channel_mode = AUDREC_CMD_STEREO_MODE_STEREO; prtd->buffer_size = STEREO_DATA_SIZE; prtd->type = AUDREC_CMD_TYPE_0_INDEX_WAV; prtd->tx_agc_cfg.cmd_id = AUDPREPROC_CMD_CFG_AGC_PARAMS; prtd->ns_cfg.cmd_id = AUDPREPROC_CMD_CFG_NS_PARAMS; prtd->iir_cfg.cmd_id = AUDPREPROC_CMD_CFG_IIR_TUNING_FILTER_PARAMS; ret = msm_adsp_get("AUDPREPROCTASK", &prtd->audpre, &aud_pre_adsp_ops, prtd); if (ret) goto err3; ret = msm_adsp_get("AUDRECTASK", &prtd->audrec, &aud_rec_adsp_ops, prtd); if (ret) { msm_adsp_put(prtd->audpre); goto err3; } prtd->dsp_cnt = 0; prtd->in_head = 0; prtd->in_tail = 0; prtd->in_count = 0; for (i = 0; i < FRAME_NUM; i++) { prtd->in[i].size = 0; prtd->in[i].read = 0; } } return 0; err3: audmgr_close(&prtd->audmgr); err2: prtd->data = NULL; err1: return ret; } EXPORT_SYMBOL(alsa_adsp_configure); int alsa_audio_configure(struct msm_audio *prtd) { struct audmgr_config cfg; int rc; if (prtd->enabled) return 0; /* refuse to start if we're not ready with first buffer */ if (!prtd->out[0].used) return -EIO; cfg.tx_rate = 0; cfg.rx_rate = RPC_AUD_DEF_SAMPLE_RATE_48000; cfg.def_method = RPC_AUD_DEF_METHOD_HOST_PCM; cfg.codec = RPC_AUD_DEF_CODEC_PCM; cfg.snd_method = RPC_SND_METHOD_MIDI; rc = audmgr_enable(&prtd->audmgr, &cfg); if (rc < 0) return rc; if (audpp_enable(AUDPP_ALSA_DECODER, alsa_dsp_event, prtd)) { printk(KERN_ERR "audio: audpp_enable() failed\n"); audmgr_disable(&prtd->audmgr); return -ENODEV; } prtd->enabled = 1; return 0; } EXPORT_SYMBOL(alsa_audio_configure); ssize_t alsa_send_buffer(struct msm_audio *prtd, const char __user *buf, size_t count, loff_t *pos) { unsigned long flag; const char __user *start = buf; struct buffer *frame; size_t xfer; int rc = 0; mutex_lock(&the_locks.write_lock); while (count > 0) { frame = prtd->out + prtd->out_head; rc = wait_event_interruptible(the_locks.write_wait, (frame->used == 0) || (prtd->stopped)); if (rc < 0) break; if (prtd->stopped) { rc = -EBUSY; break; } xfer = count > frame->size ? frame->size : count; if (copy_from_user(frame->data, buf, xfer)) { rc = -EFAULT; break; } frame->used = xfer; prtd->out_head ^= 1; count -= xfer; buf += xfer; spin_lock_irqsave(&the_locks.write_dsp_lock, flag); frame = prtd->out + prtd->out_tail; if (frame->used && prtd->out_needed) { alsa_dsp_send_buffer(prtd, prtd->out_tail, frame->used); prtd->out_tail ^= 1; prtd->out_needed--; } spin_unlock_irqrestore(&the_locks.write_dsp_lock, flag); } mutex_unlock(&the_locks.write_lock); if (buf > start) return buf - start; return rc; } EXPORT_SYMBOL(alsa_send_buffer); int alsa_audio_disable(struct msm_audio *prtd) { if (prtd->enabled) { mutex_lock(&the_locks.lock); prtd->enabled = 0; audio_dsp_out_enable(prtd, 0); wake_up(&the_locks.write_wait); audpp_disable(AUDPP_ALSA_DECODER, prtd); audmgr_disable(&prtd->audmgr); prtd->out_needed = 0; mutex_unlock(&the_locks.lock); } return 0; } EXPORT_SYMBOL(alsa_audio_disable); int alsa_audrec_disable(struct msm_audio *prtd) { if (prtd->enabled) { mutex_lock(&the_locks.lock); prtd->enabled = 0; alsa_rec_dsp_enable(prtd, 0); wake_up(&the_locks.read_wait); msm_adsp_disable(prtd->audpre); msm_adsp_disable(prtd->audrec); audmgr_disable(&prtd->audmgr); prtd->out_needed = 0; prtd->opened = 0; mutex_unlock(&the_locks.lock); } return 0; } EXPORT_SYMBOL(alsa_audrec_disable); static int audio_dsp_read_buffer(struct msm_audio *prtd, uint32_t read_cnt) { audrec_cmd_packet_ext_ptr cmd; memset(&cmd, 0, sizeof(cmd)); cmd.cmd_id = AUDREC_CMD_PACKET_EXT_PTR; /* Both WAV and AAC use AUDREC_CMD_TYPE_0 */ cmd.type = AUDREC_CMD_TYPE_0; cmd.curr_rec_count_msw = read_cnt >> 16; cmd.curr_rec_count_lsw = read_cnt; return audio_send_queue_recbs(prtd, &cmd, sizeof(cmd)); } int audrec_encoder_config(struct msm_audio *prtd) { audrec_cmd_arec0param_cfg cmd; uint16_t *data = (void *)prtd->data; unsigned n; memset(&cmd, 0, sizeof(cmd)); cmd.cmd_id = AUDREC_CMD_AREC0PARAM_CFG; cmd.ptr_to_extpkt_buffer_msw = prtd->phys >> 16; cmd.ptr_to_extpkt_buffer_lsw = prtd->phys; cmd.buf_len = FRAME_NUM; /* Both WAV and AAC use 8 frames */ cmd.samp_rate_index = prtd->samp_rate_index; /* 0 for mono, 1 for stereo */ cmd.stereo_mode = prtd->channel_mode; cmd.rec_quality = 0x1C00; /* prepare buffer pointers: * Mono: 1024 samples + 4 halfword header * Stereo: 2048 samples + 4 halfword header */ for (n = 0; n < FRAME_NUM; n++) { prtd->in[n].data = data + 4; data += (4 + (prtd->channel_mode ? 2048 : 1024)); } return audio_send_queue_rec(prtd, &cmd, sizeof(cmd)); } int audio_dsp_out_enable(struct msm_audio *prtd, int yes) { audpp_cmd_pcm_intf cmd; memset(&cmd, 0, sizeof(cmd)); cmd.cmd_id = AUDPP_CMD_PCM_INTF_2; cmd.object_num = AUDPP_CMD_PCM_INTF_OBJECT_NUM; cmd.config = AUDPP_CMD_PCM_INTF_CONFIG_CMD_V; cmd.intf_type = AUDPP_CMD_PCM_INTF_RX_ENA_ARMTODSP_V; if (yes) { cmd.write_buf1LSW = prtd->out[0].addr; cmd.write_buf1MSW = prtd->out[0].addr >> 16; cmd.write_buf1_len = 0; cmd.write_buf2LSW = prtd->out[1].addr; cmd.write_buf2MSW = prtd->out[1].addr >> 16; cmd.write_buf2_len = prtd->out[1].used; cmd.arm_to_rx_flag = AUDPP_CMD_PCM_INTF_ENA_V; cmd.weight_decoder_to_rx = prtd->out_weight; cmd.weight_arm_to_rx = 1; cmd.partition_number_arm_to_dsp = 0; cmd.sample_rate = prtd->out_sample_rate; cmd.channel_mode = prtd->out_channel_mode; } return audpp_send_queue2(&cmd, sizeof(cmd)); } int alsa_buffer_read(struct msm_audio *prtd, void __user *buf, size_t count, loff_t *pos) { unsigned long flag; void *data; uint32_t index; uint32_t size; int rc = 0; mutex_lock(&the_locks.read_lock); while (count > 0) { rc = wait_event_interruptible(the_locks.read_wait, (prtd->in_count > 0) || prtd->stopped); if (rc < 0) break; if (prtd->stopped) { rc = -EBUSY; break; } index = prtd->in_tail; data = (uint8_t *) prtd->in[index].data; size = prtd->in[index].size; if (count >= size) { if (copy_to_user(buf, data, size)) { rc = -EFAULT; break; } spin_lock_irqsave(&the_locks.read_dsp_lock, flag); if (index != prtd->in_tail) { /* overrun: data is invalid, we need to retry */ spin_unlock_irqrestore(&the_locks.read_dsp_lock, flag); continue; } prtd->in[index].size = 0; prtd->in_tail = (prtd->in_tail + 1) & (FRAME_NUM - 1); prtd->in_count--; spin_unlock_irqrestore(&the_locks.read_dsp_lock, flag); count -= size; buf += size; } else { break; } } mutex_unlock(&the_locks.read_lock); return rc; } EXPORT_SYMBOL(alsa_buffer_read); int alsa_dsp_send_buffer(struct msm_audio *prtd, unsigned idx, unsigned len) { audpp_cmd_pcm_intf_send_buffer cmd; cmd.cmd_id = AUDPP_CMD_PCM_INTF_2; cmd.host_pcm_object = AUDPP_CMD_PCM_INTF_OBJECT_NUM; cmd.config = AUDPP_CMD_PCM_INTF_BUFFER_CMD_V; cmd.intf_type = AUDPP_CMD_PCM_INTF_RX_ENA_ARMTODSP_V; cmd.dsp_to_arm_buf_id = 0; cmd.arm_to_dsp_buf_id = idx + 1; cmd.arm_to_dsp_buf_len = len; return audpp_send_queue2(&cmd, sizeof(cmd)); } int alsa_rec_dsp_enable(struct msm_audio *prtd, int enable) { audrec_cmd_cfg cmd; memset(&cmd, 0, sizeof(cmd)); cmd.cmd_id = AUDREC_CMD_CFG; cmd.type_0 = enable ? AUDREC_CMD_TYPE_0_ENA : AUDREC_CMD_TYPE_0_DIS; cmd.type_0 |= (AUDREC_CMD_TYPE_0_UPDATE | prtd->type); cmd.type_1 = 0; return audio_send_queue_rec(prtd, &cmd, sizeof(cmd)); } EXPORT_SYMBOL(alsa_rec_dsp_enable); void alsa_get_dsp_frames(struct msm_audio *prtd) { struct audio_frame *frame; uint32_t index = 0; unsigned long flag; if (prtd->type == AUDREC_CMD_TYPE_0_INDEX_WAV) { index = prtd->in_head; frame = (void *)(((char *)prtd->in[index].data) - sizeof(*frame)); spin_lock_irqsave(&the_locks.read_dsp_lock, flag); prtd->in[index].size = frame->bytes; prtd->in_head = (prtd->in_head + 1) & (FRAME_NUM - 1); /* If overflow, move the tail index foward. */ if (prtd->in_head == prtd->in_tail) prtd->in_tail = (prtd->in_tail + 1) & (FRAME_NUM - 1); else prtd->in_count++; audio_dsp_read_buffer(prtd, prtd->dsp_cnt++); spin_unlock_irqrestore(&the_locks.read_dsp_lock, flag); wake_up(&the_locks.read_wait); } else { /* TODO AAC not supported yet. */ } } EXPORT_SYMBOL(alsa_get_dsp_frames);