drivers/staging/dream/qdsp5/audio_aac.c

   1 /* arch/arm/mach-msm/qdsp5/audio_aac.c
   2  *
   3  * aac audio decoder device
   4  *
   5  * Copyright (C) 2008 Google, Inc.
   6  * Copyright (C) 2008 HTC Corporation
   7  * Copyright (c) 2008-2009 QUALCOMM USA, INC.
   8  *
   9  * This software is licensed under the terms of the GNU General Public
  10  * License version 2, as published by the Free Software Foundation, and
  11  * may be copied, distributed, and modified under those terms.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/fs.h>
  22 #include <linux/miscdevice.h>
  23 #include <linux/uaccess.h>
  24 #include <linux/kthread.h>
  25 #include <linux/wait.h>
  26 #include <linux/dma-mapping.h>
  27 #include <linux/gfp.h>
  28
  29 #include <linux/delay.h>
  30
  31 #include <asm/atomic.h>
  32 #include <asm/ioctls.h>
  33 #include "audmgr.h"
  34
  35 #include <mach/msm_adsp.h>
  36 #include <mach/msm_audio_aac.h>
  37 #include <mach/qdsp5/qdsp5audppcmdi.h>
  38 #include <mach/qdsp5/qdsp5audppmsg.h>
  39 #include <mach/qdsp5/qdsp5audplaycmdi.h>
  40 #include <mach/qdsp5/qdsp5audplaymsg.h>
  41
  42 /* for queue ids - should be relative to module number*/
  43 #include "adsp.h"
  44
  45 #ifdef DEBUG
  46 #define dprintk(format, arg...) \
  47 printk(KERN_DEBUG format, ## arg)
  48 #else
  49 #define dprintk(format, arg...) do {} while (0)
  50 #endif
  51
  52 #define BUFSZ 32768
  53 #define DMASZ (BUFSZ * 2)
  54
  55 #define AUDPLAY_INVALID_READ_PTR_OFFSET 0xFFFF
  56 #define AUDDEC_DEC_AAC 5
  57
  58 #define PCM_BUFSZ_MIN 9600      /* Hold one stereo AAC frame */
  59 #define PCM_BUF_MAX_COUNT 5     /* DSP only accepts 5 buffers at most
  60                                    but support 2 buffers currently */
  61 #define ROUTING_MODE_FTRT 1
  62 #define ROUTING_MODE_RT 2
  63 /* Decoder status received from AUDPPTASK */
  64 #define  AUDPP_DEC_STATUS_SLEEP 0
  65 #define  AUDPP_DEC_STATUS_INIT  1
  66 #define  AUDPP_DEC_STATUS_CFG   2
  67 #define  AUDPP_DEC_STATUS_PLAY  3
  68
  69 struct buffer {
  70         void *data;
  71         unsigned size;
  72         unsigned used;          /* Input usage actual DSP produced PCM size  */
  73         unsigned addr;
  74 };
  75
  76 struct audio {
  77         struct buffer out[2];
  78
  79         spinlock_t dsp_lock;
  80
  81         uint8_t out_head;
  82         uint8_t out_tail;
  83         uint8_t out_needed;     /* number of buffers the dsp is waiting for */
  84
  85         atomic_t out_bytes;
  86
  87         struct mutex lock;
  88         struct mutex write_lock;
  89         wait_queue_head_t write_wait;
  90
  91         /* Host PCM section */
  92         struct buffer in[PCM_BUF_MAX_COUNT];
  93         struct mutex read_lock;
  94         wait_queue_head_t read_wait;    /* Wait queue for read */
  95         char *read_data;        /* pointer to reader buffer */
  96         dma_addr_t read_phys;   /* physical address of reader buffer */
  97         uint8_t read_next;      /* index to input buffers to be read next */
  98         uint8_t fill_next;      /* index to buffer that DSP should be filling */
  99         uint8_t pcm_buf_count;  /* number of pcm buffer allocated */
 100         /* ---- End of Host PCM section */
 101
 102         struct msm_adsp_module *audplay;
 103
 104         /* configuration to use on next enable */
 105         uint32_t out_sample_rate;
 106         uint32_t out_channel_mode;
 107         struct msm_audio_aac_config aac_config;
 108         struct audmgr audmgr;
 109
 110         /* data allocated for various buffers */
 111         char *data;
 112         dma_addr_t phys;
 113
 114         int rflush; /* Read  flush */
 115         int wflush; /* Write flush */
 116         int opened;
 117         int enabled;
 118         int running;
 119         int stopped;    /* set when stopped, cleared on flush */
 120         int pcm_feedback;
 121         int buf_refresh;
 122
 123         int reserved; /* A byte is being reserved */
 124         char rsv_byte; /* Handle odd length user data */
 125
 126         unsigned volume;
 127
 128         uint16_t dec_id;
 129         uint32_t read_ptr_offset;
 130 };
 131
 132 static int auddec_dsp_config(struct audio *audio, int enable);
 133 static void audpp_cmd_cfg_adec_params(struct audio *audio);
 134 static void audpp_cmd_cfg_routing_mode(struct audio *audio);
 135 static void audplay_send_data(struct audio *audio, unsigned needed);
 136 static void audplay_config_hostpcm(struct audio *audio);
 137 static void audplay_buffer_refresh(struct audio *audio);
 138 static void audio_dsp_event(void *private, unsigned id, uint16_t *msg);
 139
 140 /* must be called with audio->lock held */
 141 static int audio_enable(struct audio *audio)
 142 {
 143         struct audmgr_config cfg;
 144         int rc;
 145
 146         dprintk("audio_enable()\n");
 147
 148         if (audio->enabled)
 149                 return 0;
 150
 151         audio->out_tail = 0;
 152         audio->out_needed = 0;
 153
 154         cfg.tx_rate = RPC_AUD_DEF_SAMPLE_RATE_NONE;
 155         cfg.rx_rate = RPC_AUD_DEF_SAMPLE_RATE_48000;
 156         cfg.def_method = RPC_AUD_DEF_METHOD_PLAYBACK;
 157         cfg.codec = RPC_AUD_DEF_CODEC_AAC;
 158         cfg.snd_method = RPC_SND_METHOD_MIDI;
 159
 160         rc = audmgr_enable(&audio->audmgr, &cfg);
 161         if (rc < 0)
 162                 return rc;
 163
 164         if (msm_adsp_enable(audio->audplay)) {
 165                 pr_err("audio: msm_adsp_enable(audplay) failed\n");
 166                 audmgr_disable(&audio->audmgr);
 167                 return -ENODEV;
 168         }
 169
 170         if (audpp_enable(audio->dec_id, audio_dsp_event, audio)) {
 171                 pr_err("audio: audpp_enable() failed\n");
 172     msm_adsp_disable(audio->audplay);
 173                 audmgr_disable(&audio->audmgr);
 174                 return -ENODEV;
 175         }
 176         audio->enabled = 1;
 177         return 0;
 178 }
 179
 180 /* must be called with audio->lock held */
 181 static int audio_disable(struct audio *audio)
 182 {
 183         dprintk("audio_disable()\n");
 184         if (audio->enabled) {
 185                 audio->enabled = 0;
 186                 auddec_dsp_config(audio, 0);
 187                 wake_up(&audio->write_wait);
 188                 wake_up(&audio->read_wait);
 189                 msm_adsp_disable(audio->audplay);
 190                 audpp_disable(audio->dec_id, audio);
 191                 audmgr_disable(&audio->audmgr);
 192                 audio->out_needed = 0;
 193         }
 194         return 0;
 195 }
 196
 197 /* ------------------- dsp --------------------- */
 198 static void audio_update_pcm_buf_entry(struct audio *audio, uint32_t *payload)
 199 {
 200         uint8_t index;
 201         unsigned long flags;
 202
 203         if (audio->rflush)
 204                 return;
 205
 206         spin_lock_irqsave(&audio->dsp_lock, flags);
 207         for (index = 0; index < payload[1]; index++) {
 208                 if (audio->in[audio->fill_next].addr ==
 209                     payload[2 + index * 2]) {
 210                         dprintk("audio_update_pcm_buf_entry: in[%d] ready\n",
 211                                 audio->fill_next);
 212                         audio->in[audio->fill_next].used =
 213                                 payload[3 + index * 2];
 214                         if ((++audio->fill_next) == audio->pcm_buf_count)
 215                                 audio->fill_next = 0;
 216
 217                 } else {
 218                         pr_err
 219                             ("audio_update_pcm_buf_entry: expected=%x ret=%x\n"
 220                              , audio->in[audio->fill_next].addr,
 221                              payload[1 + index * 2]);
 222                         break;
 223                 }
 224         }
 225         if (audio->in[audio->fill_next].used == 0) {
 226                 audplay_buffer_refresh(audio);
 227         } else {
 228                 dprintk("audio_update_pcm_buf_entry: read cannot keep up\n");
 229                 audio->buf_refresh = 1;
 230         }
 231         wake_up(&audio->read_wait);
 232         spin_unlock_irqrestore(&audio->dsp_lock, flags);
 233
 234 }
 235
 236 static void audplay_dsp_event(void *data, unsigned id, size_t len,
 237                               void (*getevent) (void *ptr, size_t len))
 238 {
 239         struct audio *audio = data;
 240         uint32_t msg[28];
 241         getevent(msg, sizeof(msg));
 242
 243         dprintk("audplay_dsp_event: msg_id=%x\n", id);
 244
 245         switch (id) {
 246         case AUDPLAY_MSG_DEC_NEEDS_DATA:
 247                 audplay_send_data(audio, 1);
 248                 break;
 249
 250         case AUDPLAY_MSG_BUFFER_UPDATE:
 251                 audio_update_pcm_buf_entry(audio, msg);
 252                 break;
 253
 254         default:
 255                 pr_err("unexpected message from decoder \n");
 256         }
 257 }
 258
 259 static void audio_dsp_event(void *private, unsigned id, uint16_t *msg)
 260 {
 261         struct audio *audio = private;
 262
 263         switch (id) {
 264         case AUDPP_MSG_STATUS_MSG:{
 265                         unsigned status = msg[1];
 266
 267                         switch (status) {
 268                         case AUDPP_DEC_STATUS_SLEEP:
 269                                 dprintk("decoder status: sleep \n");
 270                                 break;
 271
 272                         case AUDPP_DEC_STATUS_INIT:
 273                                 dprintk("decoder status: init \n");
 274                                 audpp_cmd_cfg_routing_mode(audio);
 275                                 break;
 276
 277                         case AUDPP_DEC_STATUS_CFG:
 278                                 dprintk("decoder status: cfg \n");
 279                                 break;
 280                         case AUDPP_DEC_STATUS_PLAY:
 281                                 dprintk("decoder status: play \n");
 282                                 if (audio->pcm_feedback) {
 283                                         audplay_config_hostpcm(audio);
 284                                         audplay_buffer_refresh(audio);
 285                                 }
 286                                 break;
 287                         default:
 288                                 pr_err("unknown decoder status \n");
 289                         }
 290                         break;
 291                 }
 292         case AUDPP_MSG_CFG_MSG:
 293                 if (msg[0] == AUDPP_MSG_ENA_ENA) {
 294                         dprintk("audio_dsp_event: CFG_MSG ENABLE\n");
 295                         auddec_dsp_config(audio, 1);
 296                         audio->out_needed = 0;
 297                         audio->running = 1;
 298                         audpp_set_volume_and_pan(audio->dec_id, audio->volume,
 299                                                  0);
 300                         audpp_avsync(audio->dec_id, 22050);
 301                 } else if (msg[0] == AUDPP_MSG_ENA_DIS) {
 302                         dprintk("audio_dsp_event: CFG_MSG DISABLE\n");
 303                         audpp_avsync(audio->dec_id, 0);
 304                         audio->running = 0;
 305                 } else {
 306                         pr_err("audio_dsp_event: CFG_MSG %d?\n", msg[0]);
 307                 }
 308                 break;
 309         case AUDPP_MSG_ROUTING_ACK:
 310                 dprintk("audio_dsp_event: ROUTING_ACK mode=%d\n", msg[1]);
 311                 audpp_cmd_cfg_adec_params(audio);
 312                 break;
 313
 314         case AUDPP_MSG_FLUSH_ACK:
 315                 dprintk("%s: FLUSH_ACK\n", __func__);
 316                 audio->wflush = 0;
 317                 audio->rflush = 0;
 318                 if (audio->pcm_feedback)
 319                         audplay_buffer_refresh(audio);
 320                 break;
 321
 322         default:
 323                 pr_err("audio_dsp_event: UNKNOWN (%d)\n", id);
 324         }
 325
 326 }
 327
 328 struct msm_adsp_ops audplay_adsp_ops_aac = {
 329         .event = audplay_dsp_event,
 330 };
 331
 332 #define audplay_send_queue0(audio, cmd, len) \
 333         msm_adsp_write(audio->audplay, QDSP_uPAudPlay0BitStreamCtrlQueue, \
 334                        cmd, len)
 335
 336 static int auddec_dsp_config(struct audio *audio, int enable)
 337 {
 338         audpp_cmd_cfg_dec_type cmd;
 339
 340         memset(&cmd, 0, sizeof(cmd));
 341         cmd.cmd_id = AUDPP_CMD_CFG_DEC_TYPE;
 342         if (enable)
 343                 cmd.dec0_cfg = AUDPP_CMD_UPDATDE_CFG_DEC |
 344                     AUDPP_CMD_ENA_DEC_V | AUDDEC_DEC_AAC;
 345         else
 346                 cmd.dec0_cfg = AUDPP_CMD_UPDATDE_CFG_DEC | AUDPP_CMD_DIS_DEC_V;
 347
 348         return audpp_send_queue1(&cmd, sizeof(cmd));
 349 }
 350
 351 static void audpp_cmd_cfg_adec_params(struct audio *audio)
 352 {
 353         audpp_cmd_cfg_adec_params_aac cmd;
 354
 355         memset(&cmd, 0, sizeof(cmd));
 356         cmd.common.cmd_id = AUDPP_CMD_CFG_ADEC_PARAMS;
 357         cmd.common.length = AUDPP_CMD_CFG_ADEC_PARAMS_AAC_LEN;
 358         cmd.common.dec_id = audio->dec_id;
 359         cmd.common.input_sampling_frequency = audio->out_sample_rate;
 360         cmd.format = audio->aac_config.format;
 361         cmd.audio_object = audio->aac_config.audio_object;
 362         cmd.ep_config = audio->aac_config.ep_config;
 363         cmd.aac_section_data_resilience_flag =
 364                 audio->aac_config.aac_section_data_resilience_flag;
 365         cmd.aac_scalefactor_data_resilience_flag =
 366                 audio->aac_config.aac_scalefactor_data_resilience_flag;
 367         cmd.aac_spectral_data_resilience_flag =
 368                 audio->aac_config.aac_spectral_data_resilience_flag;
 369         cmd.sbr_on_flag = audio->aac_config.sbr_on_flag;
 370         cmd.sbr_ps_on_flag = audio->aac_config.sbr_ps_on_flag;
 371         cmd.channel_configuration = audio->aac_config.channel_configuration;
 372
 373         audpp_send_queue2(&cmd, sizeof(cmd));
 374 }
 375
 376 static void audpp_cmd_cfg_routing_mode(struct audio *audio)
 377 {
 378         struct audpp_cmd_routing_mode cmd;
 379         dprintk("audpp_cmd_cfg_routing_mode()\n");
 380         memset(&cmd, 0, sizeof(cmd));
 381         cmd.cmd_id = AUDPP_CMD_ROUTING_MODE;
 382         cmd.object_number = audio->dec_id;
 383         if (audio->pcm_feedback)
 384                 cmd.routing_mode = ROUTING_MODE_FTRT;
 385         else
 386                 cmd.routing_mode = ROUTING_MODE_RT;
 387
 388         audpp_send_queue1(&cmd, sizeof(cmd));
 389 }
 390
 391 static int audplay_dsp_send_data_avail(struct audio *audio,
 392                                        unsigned idx, unsigned len)
 393 {
 394         audplay_cmd_bitstream_data_avail cmd;
 395
 396         cmd.cmd_id = AUDPLAY_CMD_BITSTREAM_DATA_AVAIL;
 397         cmd.decoder_id = audio->dec_id;
 398         cmd.buf_ptr = audio->out[idx].addr;
 399         cmd.buf_size = len / 2;
 400         cmd.partition_number = 0;
 401         return audplay_send_queue0(audio, &cmd, sizeof(cmd));
 402 }
 403
 404 static void audplay_buffer_refresh(struct audio *audio)
 405 {
 406         struct audplay_cmd_buffer_refresh refresh_cmd;
 407
 408         refresh_cmd.cmd_id = AUDPLAY_CMD_BUFFER_REFRESH;
 409         refresh_cmd.num_buffers = 1;
 410         refresh_cmd.buf0_address = audio->in[audio->fill_next].addr;
 411         refresh_cmd.buf0_length = audio->in[audio->fill_next].size -
 412                 (audio->in[audio->fill_next].size % 1024); /* AAC frame size */
 413         refresh_cmd.buf_read_count = 0;
 414         dprintk("audplay_buffer_fresh: buf0_addr=%x buf0_len=%d\n",
 415                 refresh_cmd.buf0_address, refresh_cmd.buf0_length);
 416         (void)audplay_send_queue0(audio, &refresh_cmd, sizeof(refresh_cmd));
 417 }
 418
 419 static void audplay_config_hostpcm(struct audio *audio)
 420 {
 421         struct audplay_cmd_hpcm_buf_cfg cfg_cmd;
 422
 423         dprintk("audplay_config_hostpcm()\n");
 424         cfg_cmd.cmd_id = AUDPLAY_CMD_HPCM_BUF_CFG;
 425         cfg_cmd.max_buffers = audio->pcm_buf_count;
 426         cfg_cmd.byte_swap = 0;
 427         cfg_cmd.hostpcm_config = (0x8000) | (0x4000);
 428         cfg_cmd.feedback_frequency = 1;
 429         cfg_cmd.partition_number = 0;
 430         (void)audplay_send_queue0(audio, &cfg_cmd, sizeof(cfg_cmd));
 431
 432 }
 433
 434 static void audplay_send_data(struct audio *audio, unsigned needed)
 435 {
 436         struct buffer *frame;
 437         unsigned long flags;
 438
 439         spin_lock_irqsave(&audio->dsp_lock, flags);
 440         if (!audio->running)
 441                 goto done;
 442
 443         if (needed && !audio->wflush) {
 444                 /* We were called from the callback because the DSP
 445                  * requested more data.  Note that the DSP does want
 446                  * more data, and if a buffer was in-flight, mark it
 447                  * as available (since the DSP must now be done with
 448                  * it).
 449                  */
 450                 audio->out_needed = 1;
 451                 frame = audio->out + audio->out_tail;
 452                 if (frame->used == 0xffffffff) {
 453                         dprintk("frame %d free\n", audio->out_tail);
 454                         frame->used = 0;
 455                         audio->out_tail ^= 1;
 456                         wake_up(&audio->write_wait);
 457                 }
 458         }
 459
 460         if (audio->out_needed) {
 461                 /* If the DSP currently wants data and we have a
 462                  * buffer available, we will send it and reset
 463                  * the needed flag.  We'll mark the buffer as in-flight
 464                  * so that it won't be recycled until the next buffer
 465                  * is requested
 466                  */
 467
 468                 frame = audio->out + audio->out_tail;
 469                 if (frame->used) {
 470                         BUG_ON(frame->used == 0xffffffff);
 471 /*                      printk("frame %d busy\n", audio->out_tail); */
 472                         audplay_dsp_send_data_avail(audio, audio->out_tail,
 473                                                     frame->used);
 474                         frame->used = 0xffffffff;
 475                         audio->out_needed = 0;
 476                 }
 477         }
 478  done:
 479         spin_unlock_irqrestore(&audio->dsp_lock, flags);
 480 }
 481
 482 /* ------------------- device --------------------- */
 483
 484 static void audio_flush(struct audio *audio)
 485 {
 486         audio->out[0].used = 0;
 487         audio->out[1].used = 0;
 488         audio->out_head = 0;
 489         audio->out_tail = 0;
 490         audio->reserved = 0;
 491         audio->out_needed = 0;
 492         atomic_set(&audio->out_bytes, 0);
 493 }
 494
 495 static void audio_flush_pcm_buf(struct audio *audio)
 496 {
 497         uint8_t index;
 498
 499         for (index = 0; index < PCM_BUF_MAX_COUNT; index++)
 500                 audio->in[index].used = 0;
 501         audio->buf_refresh = 0;
 502         audio->read_next = 0;
 503         audio->fill_next = 0;
 504 }
 505
 506 static int audaac_validate_usr_config(struct msm_audio_aac_config *config)
 507 {
 508         int ret_val = -1;
 509
 510         if (config->format != AUDIO_AAC_FORMAT_ADTS &&
 511                 config->format != AUDIO_AAC_FORMAT_RAW &&
 512                 config->format != AUDIO_AAC_FORMAT_PSUEDO_RAW &&
 513                 config->format != AUDIO_AAC_FORMAT_LOAS)
 514                 goto done;
 515
 516         if (config->audio_object != AUDIO_AAC_OBJECT_LC &&
 517                 config->audio_object != AUDIO_AAC_OBJECT_LTP &&
 518                 config->audio_object != AUDIO_AAC_OBJECT_ERLC)
 519                 goto done;
 520
 521         if (config->audio_object == AUDIO_AAC_OBJECT_ERLC) {
 522                 if (config->ep_config > 3)
 523                         goto done;
 524                 if (config->aac_scalefactor_data_resilience_flag !=
 525                         AUDIO_AAC_SCA_DATA_RES_OFF &&
 526                         config->aac_scalefactor_data_resilience_flag !=
 527                         AUDIO_AAC_SCA_DATA_RES_ON)
 528                         goto done;
 529                 if (config->aac_section_data_resilience_flag !=
 530                         AUDIO_AAC_SEC_DATA_RES_OFF &&
 531                         config->aac_section_data_resilience_flag !=
 532                         AUDIO_AAC_SEC_DATA_RES_ON)
 533                         goto done;
 534                 if (config->aac_spectral_data_resilience_flag !=
 535                         AUDIO_AAC_SPEC_DATA_RES_OFF &&
 536                         config->aac_spectral_data_resilience_flag !=
 537                         AUDIO_AAC_SPEC_DATA_RES_ON)
 538                         goto done;
 539         } else {
 540                 config->aac_section_data_resilience_flag =
 541                         AUDIO_AAC_SEC_DATA_RES_OFF;
 542                 config->aac_scalefactor_data_resilience_flag =
 543                         AUDIO_AAC_SCA_DATA_RES_OFF;
 544                 config->aac_spectral_data_resilience_flag =
 545                         AUDIO_AAC_SPEC_DATA_RES_OFF;
 546         }
 547
 548         if (config->sbr_on_flag != AUDIO_AAC_SBR_ON_FLAG_OFF &&
 549                 config->sbr_on_flag != AUDIO_AAC_SBR_ON_FLAG_ON)
 550                 goto done;
 551
 552         if (config->sbr_ps_on_flag != AUDIO_AAC_SBR_PS_ON_FLAG_OFF &&
 553                 config->sbr_ps_on_flag != AUDIO_AAC_SBR_PS_ON_FLAG_ON)
 554                 goto done;
 555
 556         if (config->dual_mono_mode > AUDIO_AAC_DUAL_MONO_PL_SR)
 557                 goto done;
 558
 559         if (config->channel_configuration > 2)
 560                 goto done;
 561
 562         ret_val = 0;
 563  done:
 564         return ret_val;
 565 }
 566
 567 static void audio_ioport_reset(struct audio *audio)
 568 {
 569         /* Make sure read/write thread are free from
 570          * sleep and knowing that system is not able
 571          * to process io request at the moment
 572          */
 573         wake_up(&audio->write_wait);
 574         mutex_lock(&audio->write_lock);
 575         audio_flush(audio);
 576         mutex_unlock(&audio->write_lock);
 577         wake_up(&audio->read_wait);
 578         mutex_lock(&audio->read_lock);
 579         audio_flush_pcm_buf(audio);
 580         mutex_unlock(&audio->read_lock);
 581 }
 582
 583 static long audio_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 584 {
 585         struct audio *audio = file->private_data;
 586         int rc = 0;
 587
 588         dprintk("audio_ioctl() cmd = %d\n", cmd);
 589
 590         if (cmd == AUDIO_GET_STATS) {
 591                 struct msm_audio_stats stats;
 592                 stats.byte_count = audpp_avsync_byte_count(audio->dec_id);
 593                 stats.sample_count = audpp_avsync_sample_count(audio->dec_id);
 594                 if (copy_to_user((void *)arg, &stats, sizeof(stats)))
 595                         return -EFAULT;
 596                 return 0;
 597         }
 598         if (cmd == AUDIO_SET_VOLUME) {
 599                 unsigned long flags;
 600                 spin_lock_irqsave(&audio->dsp_lock, flags);
 601                 audio->volume = arg;
 602                 if (audio->running)
 603                         audpp_set_volume_and_pan(audio->dec_id, arg, 0);
 604                 spin_unlock_irqrestore(&audio->dsp_lock, flags);
 605                 return 0;
 606         }
 607         mutex_lock(&audio->lock);
 608         switch (cmd) {
 609         case AUDIO_START:
 610                 rc = audio_enable(audio);
 611                 break;
 612         case AUDIO_STOP:
 613                 rc = audio_disable(audio);
 614                 audio->stopped = 1;
 615                 audio_ioport_reset(audio);
 616                 audio->stopped = 0;
 617                 break;
 618         case AUDIO_FLUSH:
 619                 dprintk("%s: AUDIO_FLUSH\n", __func__);
 620                 audio->rflush = 1;
 621                 audio->wflush = 1;
 622                 audio_ioport_reset(audio);
 623                 if (audio->running)
 624                         audpp_flush(audio->dec_id);
 625                 else {
 626                         audio->rflush = 0;
 627                         audio->wflush = 0;
 628                 }
 629                 break;
 630
 631         case AUDIO_SET_CONFIG:{
 632                         struct msm_audio_config config;
 633
 634                         if (copy_from_user
 635                             (&config, (void *)arg, sizeof(config))) {
 636                                 rc = -EFAULT;
 637                                 break;
 638                         }
 639
 640                         if (config.channel_count == 1) {
 641                                 config.channel_count =
 642                                     AUDPP_CMD_PCM_INTF_MONO_V;
 643                         } else if (config.channel_count == 2) {
 644                                 config.channel_count =
 645                                     AUDPP_CMD_PCM_INTF_STEREO_V;
 646                         } else {
 647                                 rc = -EINVAL;
 648                                 break;
 649                         }
 650
 651                         audio->out_sample_rate = config.sample_rate;
 652                         audio->out_channel_mode = config.channel_count;
 653                         rc = 0;
 654                         break;
 655                 }
 656         case AUDIO_GET_CONFIG:{
 657                         struct msm_audio_config config;
 658                         config.buffer_size = BUFSZ;
 659                         config.buffer_count = 2;
 660                         config.sample_rate = audio->out_sample_rate;
 661                         if (audio->out_channel_mode ==
 662                             AUDPP_CMD_PCM_INTF_MONO_V) {
 663                                 config.channel_count = 1;
 664                         } else {
 665                                 config.channel_count = 2;
 666                         }
 667                         config.unused[0] = 0;
 668                         config.unused[1] = 0;
 669                         config.unused[2] = 0;
 670                         config.unused[3] = 0;
 671                         if (copy_to_user((void *)arg, &config,
 672                                          sizeof(config)))
 673                                 rc = -EFAULT;
 674                         else
 675                                 rc = 0;
 676
 677                         break;
 678                 }
 679         case AUDIO_GET_AAC_CONFIG:{
 680                         if (copy_to_user((void *)arg, &audio->aac_config,
 681                                 sizeof(audio->aac_config)))
 682                                 rc = -EFAULT;
 683                         else
 684                                 rc = 0;
 685                         break;
 686                 }
 687         case AUDIO_SET_AAC_CONFIG:{
 688                         struct msm_audio_aac_config usr_config;
 689
 690                         if (copy_from_user
 691                                 (&usr_config, (void *)arg,
 692                                         sizeof(usr_config))) {
 693                                 rc = -EFAULT;
 694                                 break;
 695                         }
 696
 697                         if (audaac_validate_usr_config(&usr_config) == 0) {
 698                                 audio->aac_config = usr_config;
 699                                 rc = 0;
 700                         } else
 701                                 rc = -EINVAL;
 702
 703                         break;
 704                 }
 705         case AUDIO_GET_PCM_CONFIG:{
 706                         struct msm_audio_pcm_config config;
 707                         config.pcm_feedback = 0;
 708                         config.buffer_count = PCM_BUF_MAX_COUNT;
 709                         config.buffer_size = PCM_BUFSZ_MIN;
 710                         if (copy_to_user((void *)arg, &config,
 711                                          sizeof(config)))
 712                                 rc = -EFAULT;
 713                         else
 714                                 rc = 0;
 715                         break;
 716                 }
 717         case AUDIO_SET_PCM_CONFIG:{
 718                         struct msm_audio_pcm_config config;
 719                         if (copy_from_user
 720                             (&config, (void *)arg, sizeof(config))) {
 721                                 rc = -EFAULT;
 722                                 break;
 723                         }
 724                         if ((config.buffer_count > PCM_BUF_MAX_COUNT) ||
 725                             (config.buffer_count == 1))
 726                                 config.buffer_count = PCM_BUF_MAX_COUNT;
 727
 728                         if (config.buffer_size < PCM_BUFSZ_MIN)
 729                                 config.buffer_size = PCM_BUFSZ_MIN;
 730
 731                         /* Check if pcm feedback is required */
 732                         if ((config.pcm_feedback) && (!audio->read_data)) {
 733                                 dprintk("ioctl: allocate PCM buffer %d\n",
 734                                         config.buffer_count *
 735                                         config.buffer_size);
 736                                 audio->read_data =
 737                                     dma_alloc_coherent(NULL,
 738                                                        config.buffer_size *
 739                                                        config.buffer_count,
 740                                                        &audio->read_phys,
 741                                                        GFP_KERNEL);
 742                                 if (!audio->read_data) {
 743                                         pr_err("audio_aac: buf alloc fail\n");
 744                                         rc = -1;
 745                                 } else {
 746                                         uint8_t index;
 747                                         uint32_t offset = 0;
 748                                         audio->pcm_feedback = 1;
 749                                         audio->buf_refresh = 0;
 750                                         audio->pcm_buf_count =
 751                                             config.buffer_count;
 752                                         audio->read_next = 0;
 753                                         audio->fill_next = 0;
 754
 755                                         for (index = 0;
 756                                              index < config.buffer_count;
 757                                              index++) {
 758                                                 audio->in[index].data =
 759                                                     audio->read_data + offset;
 760                                                 audio->in[index].addr =
 761                                                     audio->read_phys + offset;
 762                                                 audio->in[index].size =
 763                                                     config.buffer_size;
 764                                                 audio->in[index].used = 0;
 765                                                 offset += config.buffer_size;
 766                                         }
 767                                         rc = 0;
 768                                 }
 769                         } else {
 770                                 rc = 0;
 771                         }
 772                         break;
 773                 }
 774         case AUDIO_PAUSE:
 775                 dprintk("%s: AUDIO_PAUSE %ld\n", __func__, arg);
 776                 rc = audpp_pause(audio->dec_id, (int) arg);
 777                 break;
 778         default:
 779                 rc = -EINVAL;
 780         }
 781         mutex_unlock(&audio->lock);
 782         return rc;
 783 }
 784
 785 static ssize_t audio_read(struct file *file, char __user *buf, size_t count,
 786                           loff_t *pos)
 787 {
 788         struct audio *audio = file->private_data;
 789         const char __user *start = buf;
 790         int rc = 0;
 791
 792         if (!audio->pcm_feedback)
 793                 return 0; /* PCM feedback is not enabled. Nothing to read */
 794
 795         mutex_lock(&audio->read_lock);
 796         dprintk("audio_read() %d \n", count);
 797         while (count > 0) {
 798                 rc = wait_event_interruptible(audio->read_wait,
 799                                               (audio->in[audio->read_next].
 800                                                 used > 0) || (audio->stopped)
 801                                                 || (audio->rflush));
 802
 803                 if (rc < 0)
 804                         break;
 805
 806                 if (audio->stopped || audio->rflush) {
 807                         rc = -EBUSY;
 808                         break;
 809                 }
 810
 811                 if (count < audio->in[audio->read_next].used) {
 812                         /* Read must happen in frame boundary. Since driver
 813                            does not know frame size, read count must be greater
 814                            or equal to size of PCM samples */
 815                         dprintk("audio_read: no partial frame done reading\n");
 816                         break;
 817                 } else {
 818                         dprintk("audio_read: read from in[%d]\n",
 819                                 audio->read_next);
 820                         if (copy_to_user
 821                             (buf, audio->in[audio->read_next].data,
 822                              audio->in[audio->read_next].used)) {
 823                                 pr_err("audio_read: invalid addr %x \n",
 824                                        (unsigned int)buf);
 825                                 rc = -EFAULT;
 826                                 break;
 827                         }
 828                         count -= audio->in[audio->read_next].used;
 829                         buf += audio->in[audio->read_next].used;
 830                         audio->in[audio->read_next].used = 0;
 831                         if ((++audio->read_next) == audio->pcm_buf_count)
 832                                 audio->read_next = 0;
 833                         if (audio->in[audio->read_next].used == 0)
 834                                 break; /* No data ready at this moment
 835                                         * Exit while loop to prevent
 836                                         * output thread sleep too long
 837                                         */
 838                 }
 839         }
 840
 841         /* don't feed output buffer to HW decoder during flushing
 842          * buffer refresh command will be sent once flush completes
 843          * send buf refresh command here can confuse HW decoder
 844          */
 845         if (audio->buf_refresh && !audio->rflush) {
 846                 audio->buf_refresh = 0;
 847                 dprintk("audio_read: kick start pcm feedback again\n");
 848                 audplay_buffer_refresh(audio);
 849         }
 850
 851         mutex_unlock(&audio->read_lock);
 852
 853         if (buf > start)
 854                 rc = buf - start;
 855
 856         dprintk("audio_read: read %d bytes\n", rc);
 857         return rc;
 858 }
 859
 860 static ssize_t audio_write(struct file *file, const char __user *buf,
 861                            size_t count, loff_t *pos)
 862 {
 863         struct audio *audio = file->private_data;
 864         const char __user *start = buf;
 865         struct buffer *frame;
 866         size_t xfer;
 867         char *cpy_ptr;
 868         int rc = 0;
 869         unsigned dsize;
 870
 871         mutex_lock(&audio->write_lock);
 872         while (count > 0) {
 873                 frame = audio->out + audio->out_head;
 874                 cpy_ptr = frame->data;
 875                 dsize = 0;
 876                 rc = wait_event_interruptible(audio->write_wait,
 877                                               (frame->used == 0)
 878                                                 || (audio->stopped)
 879                                                 || (audio->wflush));
 880                 if (rc < 0)
 881                         break;
 882                 if (audio->stopped || audio->wflush) {
 883                         rc = -EBUSY;
 884                         break;
 885                 }
 886
 887                 if (audio->reserved) {
 888                         dprintk("%s: append reserved byte %x\n",
 889                                 __func__, audio->rsv_byte);
 890                         *cpy_ptr = audio->rsv_byte;
 891                         xfer = (count > (frame->size - 1)) ?
 892                                 frame->size - 1 : count;
 893                         cpy_ptr++;
 894                         dsize = 1;
 895                         audio->reserved = 0;
 896                 } else
 897                         xfer = (count > frame->size) ? frame->size : count;
 898
 899                 if (copy_from_user(cpy_ptr, buf, xfer)) {
 900                         rc = -EFAULT;
 901                         break;
 902                 }
 903
 904                 dsize += xfer;
 905                 if (dsize & 1) {
 906                         audio->rsv_byte = ((char *) frame->data)[dsize - 1];
 907                         dprintk("%s: odd length buf reserve last byte %x\n",
 908                                 __func__, audio->rsv_byte);
 909                         audio->reserved = 1;
 910                         dsize--;
 911                 }
 912                 count -= xfer;
 913                 buf += xfer;
 914
 915                 if (dsize > 0) {
 916                         audio->out_head ^= 1;
 917                         frame->used = dsize;
 918                         audplay_send_data(audio, 0);
 919                 }
 920         }
 921         mutex_unlock(&audio->write_lock);
 922         if (buf > start)
 923                 return buf - start;
 924         return rc;
 925 }
 926
 927 static int audio_release(struct inode *inode, struct file *file)
 928 {
 929         struct audio *audio = file->private_data;
 930
 931         dprintk("audio_release()\n");
 932
 933         mutex_lock(&audio->lock);
 934         audio_disable(audio);
 935         audio_flush(audio);
 936         audio_flush_pcm_buf(audio);
 937         msm_adsp_put(audio->audplay);
 938         audio->audplay = NULL;
 939         audio->opened = 0;
 940         audio->reserved = 0;
 941         dma_free_coherent(NULL, DMASZ, audio->data, audio->phys);
 942         audio->data = NULL;
 943         if (audio->read_data != NULL) {
 944                 dma_free_coherent(NULL,
 945                                   audio->in[0].size * audio->pcm_buf_count,
 946                                   audio->read_data, audio->read_phys);
 947                 audio->read_data = NULL;
 948         }
 949         audio->pcm_feedback = 0;
 950         mutex_unlock(&audio->lock);
 951         return 0;
 952 }
 953
 954 static struct audio the_aac_audio;
 955
 956 static int audio_open(struct inode *inode, struct file *file)
 957 {
 958         struct audio *audio = &the_aac_audio;
 959         int rc;
 960
 961         mutex_lock(&audio->lock);
 962
 963         if (audio->opened) {
 964                 pr_err("audio: busy\n");
 965                 rc = -EBUSY;
 966                 goto done;
 967         }
 968
 969         if (!audio->data) {
 970                 audio->data = dma_alloc_coherent(NULL, DMASZ,
 971                                                  &audio->phys, GFP_KERNEL);
 972                 if (!audio->data) {
 973                         pr_err("audio: could not allocate DMA buffers\n");
 974                         rc = -ENOMEM;
 975                         goto done;
 976                 }
 977         }
 978
 979         rc = audmgr_open(&audio->audmgr);
 980         if (rc)
 981                 goto done;
 982
 983         rc = msm_adsp_get("AUDPLAY0TASK", &audio->audplay,
 984                           &audplay_adsp_ops_aac, audio);
 985         if (rc) {
 986                 pr_err("audio: failed to get audplay0 dsp module\n");
 987                 goto done;
 988         }
 989         audio->out_sample_rate = 44100;
 990         audio->out_channel_mode = AUDPP_CMD_PCM_INTF_STEREO_V;
 991         audio->aac_config.format = AUDIO_AAC_FORMAT_ADTS;
 992         audio->aac_config.audio_object = AUDIO_AAC_OBJECT_LC;
 993         audio->aac_config.ep_config = 0;
 994         audio->aac_config.aac_section_data_resilience_flag =
 995                 AUDIO_AAC_SEC_DATA_RES_OFF;
 996         audio->aac_config.aac_scalefactor_data_resilience_flag =
 997                 AUDIO_AAC_SCA_DATA_RES_OFF;
 998         audio->aac_config.aac_spectral_data_resilience_flag =
 999                 AUDIO_AAC_SPEC_DATA_RES_OFF;
1000         audio->aac_config.sbr_on_flag = AUDIO_AAC_SBR_ON_FLAG_ON;
1001         audio->aac_config.sbr_ps_on_flag = AUDIO_AAC_SBR_PS_ON_FLAG_ON;
1002         audio->aac_config.dual_mono_mode = AUDIO_AAC_DUAL_MONO_PL_SR;
1003         audio->aac_config.channel_configuration = 2;
1004         audio->dec_id = 0;
1005
1006         audio->out[0].data = audio->data + 0;
1007         audio->out[0].addr = audio->phys + 0;
1008         audio->out[0].size = BUFSZ;
1009
1010         audio->out[1].data = audio->data + BUFSZ;
1011         audio->out[1].addr = audio->phys + BUFSZ;
1012         audio->out[1].size = BUFSZ;
1013
1014         audio->volume = 0x2000; /* Q13 1.0 */
1015
1016         audio_flush(audio);
1017
1018         file->private_data = audio;
1019         audio->opened = 1;
1020         rc = 0;
1021 done:
1022         mutex_unlock(&audio->lock);
1023         return rc;
1024 }
1025
1026 static struct file_operations audio_aac_fops = {
1027         .owner = THIS_MODULE,
1028         .open = audio_open,
1029         .release = audio_release,
1030         .read = audio_read,
1031         .write = audio_write,
1032         .unlocked_ioctl = audio_ioctl,
1033         .llseek = noop_llseek,
1034 };
1035
1036 struct miscdevice audio_aac_misc = {
1037         .minor = MISC_DYNAMIC_MINOR,
1038         .name = "msm_aac",
1039         .fops = &audio_aac_fops,
1040 };
1041
1042 static int __init audio_init(void)
1043 {
1044         mutex_init(&the_aac_audio.lock);
1045         mutex_init(&the_aac_audio.write_lock);
1046         mutex_init(&the_aac_audio.read_lock);
1047         spin_lock_init(&the_aac_audio.dsp_lock);
1048         init_waitqueue_head(&the_aac_audio.write_wait);
1049         init_waitqueue_head(&the_aac_audio.read_wait);
1050         the_aac_audio.read_data = NULL;
1051         return misc_register(&audio_aac_misc);
1052 }
1053
1054 device_initcall(audio_init);