am_aud_tone_reply.c

Motorola synergy audio component

    }
        while(HAPI_MDI_QUEUE_read1 (DSP_MCU_AUDIO_REPLY, reply_buff))
        {
            UINT8 timestamp = reply_buff[1] >> 8;
#if (AUDIO_RAINBOW == TRUE)
            if ((replies_to_tcmd == TRUE) && (timestamp >= AM_HW_STRING_PRIMITIVE_TIMESTAMP_MAX) &&
                (reply_buff[0] != DSP_MCU_AUDIO_DMP_REQUEST) &&
                (reply_buff[0] != DSP_MCU_AUDIO_DMP_INFO_REQUEST) &&
                (reply_buff[0] != DSP_MCU_AUDIO_DMP_MRAM_REQUEST))
            {
                UINT8 *msg;
                UINT32 msg_len;
                
                msg_len = (UINT32)((reply_buff[1]&0xFF) + 2) << 1; /* get DSP message length in
                                                                      bytes, including header */
                msg = (UINT8*) suCreateMessage(msg_len, CONN_TCMD_API_SW_MDI_AUD_REPLY_ID,
                                               SU_INVALID_HANDLE, NULL);
                memcpy(msg, reply_buff, msg_len);
                CONN_TCMD_send_msg(msg);  
            }
            else
            {              
#endif        
                /* Log each time we read a message */
                am_send_log_data(AUD_MDI_Q_READ, (char *)reply_buff, ((reply_buff[1]&0xFF) + 2) * 2);
                switch(reply_buff[0])
                {
#if (MAKE_FTR_VA == TRUE)
                    case DSP_MCU_VA_RECORD_OFF_CONFIRM:
                        DSP_AUDIO_VA_Record_Off_Confirm();
                        break;
                        
                    case DSP_MCU_VA_PLAYBACK_OFF_CONFIRM:
                        DSP_AUDIO_VA_Playback_Off_Confirm();
                        break;
#endif
                    
#if (MAKE_FTR_VR == TRUE)    
                    case DSP_MCU_VR_STOP_COMPLETE:
                        /* what to do on a stop complete */
                        break;
                        
                    case DSP_MCU_VR_SD_CAPTURE_COMPLETE:
                        {
                            AUDSCM_SDSR_CAPTURE_COMPLETE_IND *  msgptr;
                            if(Audio_Utterance_with_VA())
                            {
                                UINT16 buffer[] = { MCU_DSP_VA_RECORD_OFF,
                                                    (UINT16)MCU_DSP_VA_RECORD_OFF_WORD_LEN};
#if (AUDIO_RAINBOW == TRUE)     
                                EXEC_CLKMGR_request_pcap_aux_clk(EXEC_CLKMGR_CALLERID_AUDIOMGR, NULL);
#endif
                                HAPI_MDI_QUEUE_write(MCU_DSP_AUDIO_COMMAND, buffer, 
                                                     2+ MCU_DSP_VA_RECORD_OFF_WORD_LEN , TRUE);
                                /*Datalog the MDI data */
                                am_send_log_data(AUD_MDI_Q_WRITE_VA_VR, (char *)buffer, 2*(2+MCU_DSP_VA_RECORD_OFF_WORD_LEN));
                            }
                            
                            msgptr =  suCreateMessage((UINT32)sizeof(AUDSCM_SDSR_CAPTURE_COMPLETE_IND), 
                                                      (UINT32)DSP_MCU_VR_SD_CAPTURE_COMPLETE, SU_INVALID_HANDLE, NULL);
                            msgptr->error_code = reply_buff[2];
                            AM_SendMessage((char *)msgptr);
                        }
                        break;
                        
                    case DSP_MCU_VR_SD_TRAIN_COMPLETE:            
                        {
                            AUDSCM_SDSR_TRAIN_COMPLETE_IND  * msgptr = NULL;
                            msgptr =  suCreateMessage((UINT32)sizeof(AUDSCM_SDSR_TRAIN_COMPLETE_IND), 
                                                      (UINT32)DSP_MCU_VR_SD_TRAIN_COMPLETE, SU_INVALID_HANDLE, NULL);           
                            msgptr->warning_code = 0;
                            msgptr->error_code   = reply_buff[2];
                            msgptr->model_id     = reply_buff[3];
                            AM_SendMessage((char *) msgptr);
                        }
                        break;
                        
                    case DSP_MCU_VR_SD_RECOGNIZE_COMPLETE:
                        {
                            AUDSCM_SDSR_COMPLETE_IND * msgptr = NULL;
                            msgptr =  suCreateMessage((UINT32)sizeof(AUDSCM_SDSR_COMPLETE_IND), 
                                                      (UINT32)DSP_MCU_VR_SD_RECOGNIZE_COMPLETE, SU_INVALID_HANDLE, NULL);
                            
                            msgptr->error_code = reply_buff[2];
                            msgptr->header.id = 0;
                            msgptr->header.stamp_n_length = 3;
                            msgptr->word_array[0] = reply_buff[3];
                            msgptr->word_array[1] = reply_buff[4];
                            AM_SendMessage((char *) msgptr);
                        }
                        break;
#endif
                        
                    case DSP_MCU_AUDIO_TONE_COMPLETE:       
                        /* Create the reply message */
                        {
                            AUD_DSP_REPLY_PRIM *dsp_aud_prim = (AUD_DSP_REPLY_PRIM*)suCreateMessage(
                                                                                                    (UINT32)(sizeof(AUD_DSP_REPLY_PRIM)), 
                                                                                                    (UINT32)AUDSCM_TONE_CMPLT1_IND_ID,                                     
                                                                                                    SU_INVALID_HANDLE, NULL);            
                            memcpy(dsp_aud_prim->reply_buff, reply_buff, DSP_MCU_AUDIO_REPLY_WORD_SIZE * 2);
                            AM_SendMessage((char *) dsp_aud_prim);
                        }
                        break;
                        
                    case DSP_MCU_AUDIO_ERROR_REPLY:
                        {
                            AUD_DSP_REPLY_PRIM *dsp_aud_prim = (AUD_DSP_REPLY_PRIM*)suCreateMessage(
                                                                                                    (UINT32)(sizeof(AUD_DSP_REPLY_PRIM)), 
                                                                                                    AUDSCM_DSP_AUDIO_ERROR_REPLY_ID, 
                                                                                                    SU_INVALID_HANDLE, NULL);
                            memcpy(dsp_aud_prim->reply_buff, reply_buff, DSP_MCU_AUDIO_REPLY_WORD_SIZE * 2);
                            AM_SendMessage((char *) dsp_aud_prim);
                        }
                        break;

                    case DSP_MCU_AUDIO_MM_SESSION_START:
                    case DSP_MCU_AUDIO_MM_SESSION_END:
                    case DSP_MCU_AUDIO_MM_TOKEN_INFO:
                    case DSP_MCU_AUDIO_MIDI_EVENT:
#if (MAKE_NEPTUNE_CHIPSET && MAKE_HDW_BB_IC == MAKE_HDW_NEPTUNE_LTS)
                    case DSP_MCU_AUDIO_MM_DECODE_FINISHED:
#endif

#if (AUDIO_RAINBOW == TRUE)
                    case DSP_MCU_AUDIO_MM_DECODE_FINISHED:
                    case DSP_MCU_AUDIO_MM_VIDEO_INFO:
                    case DSP_MCU_AUDIO_MIDI_OFF:
                    case DSP_MCU_AUDIO_DMP_REQUEST:
                    case DSP_MCU_AUDIO_DMP_INFO_REQUEST:
                    case DSP_MCU_AUDIO_DMP_MRAM_REQUEST:
#endif
                        {
                            UINT8 *msg;
                            UINT32 msg_len;
                            
                            msg_len = (UINT32)((reply_buff[1]&0xFF) + 2) << 1; /* get DSP message length in
                                                                                  bytes, including header */
                            msg = (UINT8*) suCreateMessage(msg_len, AM_MDI_Q_EXTERNAL_REPLY_ID,
                                                           SU_INVALID_HANDLE, NULL);
                            memcpy(msg, reply_buff, msg_len);
                            AM_SendMessage((char*)msg);
                        }
                        break;
#if (AUDIO_RAINBOW != TRUE)
                    case DSP_MCU_MIDI_COMPLETE:
                        {
                            MME_FW_MDI_mo_callback(reply_buff, DSP_MCU_MIDI_COMPLETE_WORD_LEN + 2);
                            break;
                        }
                    case DSP_MCU_MIDI_ERROR:
                        {
                            MME_FW_MDI_mo_callback(reply_buff, DSP_MCU_MIDI_ERROR_WORD_LEN + 2);
                            break;
                        }
#endif
#if (AUDIO_RAINBOW == TRUE) 
                    case DSP_MCU_AUDIO_LOW_POWER:
                        {
                            /* Tell pcap aux clkmgr that the pcap aux clock is off */
                            EXEC_CLKMGR_pcap_aux_clk_off();
                            break;
                        }
                    case DSP_MCU_AUDIO_WAKE:
                        {

                            /* Tell pcap aux clkmgr that the pcap aux clock is on */
                            EXEC_CLKMGR_pcap_aux_clk_on(1); /* 1 indicates that this function was called from ISR */
                            break;
                        }
#endif             
                    
#if(MAKE_FTR_FUN_LIGHTS == TRUE)
                   case DSP_MCU_FL_DATA:
                  {
                     MME_FW_MDI_flof_callback(reply_buff, DSP_MCU_FL_DATA_LEN +2);
                     break;
                  }
#endif
                  
#if (MAKE_TTY == TRUE)
                    case DSP_MCU_TTY_DETECT:
                        RTIME_MAINT_set_ext_dev_stat( RTIME_MAINT_DEV_DIG_TTY,
                                                      RTIME_MAINT_DEV_STAT_CONN );
                        break;
#endif  
                    default:
                        break;
            
                }
#if (AUDIO_RAINBOW == TRUE)
            }
#endif
        }/* end the while loop for gsm */

    #endif
}


/* DESCRIPTION:
       This function is provided for ISR to send TTY detect message to AM.
 
   INPUTS:
       None

   OUTPUTS:
       None

   IMPORTANT NOTES:
       None
*/
#if (MAKE_TTY == TRUE)
void aud_dsp_reply_tty()
{
#if (AUDIO_CDMA == TRUE)

    AUD_DSP_REPLY_PRIM temp_dsp_reply_prim;
    AUD_DSP_REPLY_PRIM *temp_dsp_aud_prim = &temp_dsp_reply_prim;
                                     
    UINT8 i;   
  
    for (i = 0; i < DSP_MCU_AUDIO_REPLY_WORD_SIZE; i++)
    {   
        temp_dsp_aud_prim->reply_buff[i] = TD_DSP_AUD_REPLY_BUFF_INVALID;
    }

    L1_MODEM_API_QUEUE_read_tty_detect (DSP_MCU_AUDIO_REPLY, temp_dsp_aud_prim->reply_buff);

    if ( temp_dsp_aud_prim->reply_buff[0] == DSP_MCU_TTY_DETECT )
    { 
        RTIME_MAINT_set_ext_dev_stat( RTIME_MAINT_DEV_DIG_TTY,
                                       RTIME_MAINT_DEV_STAT_CONN ); 
    }               
#endif           
}
#endif