自学教程：C++ EXT_ASSERT函数代码示例

/* send ilm to UART owner */void USB2UART_Sendilm(msg_type msgid){    ilm_struct *USB2UART_ilm;    void *port_ptr = NULL;    if (USB2UARTPort.ownerid == MOD_DRV_HISR)        return;    switch(msgid)    {    case MSG_ID_UART_READY_TO_READ_IND:    {        uart_ready_to_read_ind_struct *tmp;        tmp = (uart_ready_to_read_ind_struct *)              construct_local_para(sizeof(uart_ready_to_read_ind_struct),TD_UL);        tmp->port = USB2UARTPort.port_no;        port_ptr = tmp;    }    break;    case MSG_ID_UART_READY_TO_WRITE_IND:    {        uart_ready_to_write_ind_struct *tmp;        tmp = (uart_ready_to_write_ind_struct *)              construct_local_para(sizeof(uart_ready_to_write_ind_struct),TD_UL);        tmp->port = USB2UARTPort.port_no;        port_ptr = tmp;    }    break;    case MSG_ID_UART_ESCAPE_DETECTED_IND:    {        uart_escape_detected_ind_struct *tmp;        tmp = (uart_escape_detected_ind_struct *)              construct_local_para(sizeof(uart_escape_detected_ind_struct),TD_UL);        tmp->port = USB2UARTPort.port_no;        port_ptr = tmp;    }    break;    default:        EXT_ASSERT(0, msgid, 0, 0);        break;    }    if (USB2UARTPort.ownerid == MOD_DRV_HISR)        EXT_ASSERT(0, USB2UARTPort.ownerid, 0, 0);    DRV_BuildPrimitive(USB2UART_ilm, MOD_DRV_HISR,                       USB2UARTPort.ownerid, msgid, port_ptr);    msg_send_ext_queue(USB2UART_ilm);}

/************************************************************	Bulk EP OUT handle functions (clear rx fifo data, read them out and drop)*************************************************************/void USB_Acm_Rx_ClrFifo(void){	kal_uint32        nCount;#ifdef USB_20_ENABLE	kal_uint32	max_bulk_pkt_size;	kal_uint8         data[USB_EP_BULK_MAXP_HS];#else	kal_uint8         data[USB_EP_BULK_MAXP];#endif		/* check if data received */	nCount = USB_EP_Rx_Pkt_Len(g_UsbACM.rxpipe->byEP);#ifdef USB_20_ENABLE		if(USB_Is_High_Speed() == KAL_TRUE)		max_bulk_pkt_size = USB_EP_BULK_MAXP_HS;	else		max_bulk_pkt_size = USB_EP_BULK_MAXP_FS;	#ifdef  __PRODUCTION_RELEASE__		if(nCount > max_bulk_pkt_size)	{		nCount = max_bulk_pkt_size;	}	#else	EXT_ASSERT((nCount <= max_bulk_pkt_size), nCount, max_bulk_pkt_size, 0);	#endif#else  /* USB_20_ENABLE */	#ifdef  __PRODUCTION_RELEASE__		if(nCount > USB_EP_BULK_MAXP)	{		nCount = USB_EP_BULK_MAXP;	}	#else	EXT_ASSERT((nCount <= USB_EP_BULK_MAXP), nCount, USB_EP_BULK_MAXP, 0);	#endif#endif  /* USB_20_ENABLE */	if(nCount>0)	{		/* get the data from fifo */		USB_EPFIFORead(g_UsbACM.rxpipe->byEP, nCount, data);		/* Clear RxPktRdy */		USB_EP_Bulk_Rx_Ready(g_UsbACM.rxpipe->byEP);	}}

/*! * @function        [static] cccitty_check_ul_gpd_list_sequence * @brief           Traverse the input GPD list and check sequence in the CCCI header  * * @param first_gpd [IN] pointer to the first GPD in the GPD chain * @param last_gpd  [IN] pointer to the last GPD in the GPD chain * * @return          kal_uint32 return the gpd number in between first_gpd and last_gpd */static kal_uint32 cccitty_check_ul_gpd_list_sequence(qbm_gpd* first_gpd, qbm_gpd* last_gpd){    qbm_gpd *curr_gpd;    qbm_gpd *next_gpd;    kal_uint32 num_gpd;    CCCI_BUFF_T *pdata;    EXT_ASSERT((first_gpd && last_gpd),(kal_uint32)first_gpd, (kal_uint32)last_gpd,0);    curr_gpd = first_gpd;    do {        next_gpd = QBM_DES_GET_NEXT(curr_gpd);        pdata = CCCIDEV_GET_QBM_DATAPTR(curr_gpd);        ccci_debug_check_seq(pdata);        num_gpd ++;        if ( curr_gpd == last_gpd )        {            break;        }                curr_gpd = next_gpd;    } while ( curr_gpd != NULL );    return num_gpd;    }

/* clear tx buffer */static void USB2UART_ClrTxBuffer(UART_PORT port, module_type ownerid){    kal_uint32 savedMask;#ifndef  __PRODUCTION_RELEASE__    if(ownerid != USB2UARTPort.ownerid)    {        EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);    }#endif    drv_trace0(TRACE_FUNC, USBACM_CLEAR_TX_BUF);//	kal_prompt_trace(MOD_USB, "clrTx/n");    /* stop dma channel if current status is CDC ACM*/    if ( (gUsbDevice.device_type == USB_CDC_ACM) && (USB2UARTPort.initialized == KAL_TRUE)            &&(gUsbDevice.nDevState==DEVSTATE_CONFIG))    {        USB_Stop_DMA_Channel(g_UsbACM.txpipe->byEP, USB_TX_EP_TYPE);    }    savedMask = SaveAndSetIRQMask();    USB2UARTPort.Tx_Buffer.Write = 0;    USB2UARTPort.Tx_Buffer.Read = 0;    g_UsbACM.send_Txilm = KAL_TRUE;    RestoreIRQMask(savedMask);    drv_trace1(TRACE_FUNC, USBACM_CLEAR_TX_BUF_READY_TO_READ_FLAG, ownerid);//	kal_prompt_trace(MOD_USB, "clr RDY W %d", ownerid);}

DCL_STATUS DclSerialPort_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data){ 	DCL_DEV Device ;	SIO_TYPE_T type;	if(handle == STATUS_INVALID_DEVICE) 		return STATUS_FAIL; 				 if (!DCL_UART_IS_HANDLE_MAGIC(handle))   {      ASSERT(0);      return STATUS_INVALID_DCL_HANDLE;   } 					 Device = DCL_UART_GET_DEV(handle);  if(Device > UART_DEV_CNT)// if((Device<0)||(Device > UART_DEV_CNT)) remove for build warning,beasese this  enum can't < 0		return  STATUS_FAIL;   type = SIO_DEV_Drv_Index[Device]; // if the uart driver not init, here will issue assert if(type == DCL_UART_TYPE) 	{ 	if(SIO_Dev_Driver[type] != Uart_Drv_Handler.SeriportHandlerCb)//maybe bootup trace 	     EXT_ASSERT(0, (kal_uint32)type, (kal_uint32)Device,  (kal_uint32)handle);//please check weather called UART_Boot_Trace_Release(0),when bootup init 			}		  return  SIO_Dev_Driver[type](Device, cmd, data);	}

void VideoCommClrAllQ(VIDEO_COMM_STATE_T *prCommState){    kal_uint32 u4SavedMask;    kal_uint32 i = 0;    u4SavedMask = SaveAndSetIRQMask();    if (prCommState->u4EntryCount != 0)    {        EXT_ASSERT(0, prCommState->u4EntryCount, 0, 0);    }    prCommState->rCmdQ.u4WriteIdx = 0;    prCommState->rCmdQ.u4ReadIdx = 0;    for (;i < VIDEO_PORT_MAX_NUM; i++)    {        prCommState->rInputBuffQ[i].u4WriteIdx = 0;        prCommState->rInputBuffQ[i].u4ReadIdx = 0;        prCommState->rInputBuffQ[i].u4UsedNum= 0;        prCommState->rOutputBuffQ[i].u4WriteIdx = 0;        prCommState->rOutputBuffQ[i].u4ReadIdx = 0;        prCommState->rOutputBuffQ[i].u4UsedNum= 0;    }    RestoreIRQMask(u4SavedMask);}

/************************************************************************** FUNCTION*  INT_FIQ_Lisr** DESCRIPTION*   This function implement FIQ handler** CALLS** CALL BY** PARAMETERS** RETURNS**************************************************************************/void INT_FIQ_Lisr(void){   kal_uint8  FIQ_Enter=1;      if (KAL_FALSE == SLA_IsLmuLogging())   {      LMU_Write_ISR_CSM(0xaaaa0fff);   }   if (SA_LoggingIndex != 0)   {      SLA_LoggingLISR(0xaaaa0fff);   }     FIQErrInfo.fiqSelect = FIQ_isValid();     FIQErrInfo.irqReturnAddr = processing_irqlr;     FIQErrInfo.fiqReturnAddr = processing_fiqlr;   if (KAL_FALSE == SLA_IsLmuLogging())   {      LMU_Write_ISR_END_CSM(0xaaaaaaaa);   }   if (SA_LoggingIndex != 0)   {      SLA_LoggingLISR(0xaaaaaaaa);   }        EXT_ASSERT(FIQ_Enter==0, FIQErrInfo.fiqSelect, FIQErrInfo.fiqReturnAddr, FIQErrInfo.irqReturnAddr);}

/*     Update the buffer information after transmit done    Note that "USB2Uart_WriteLength" will be reset to 0.    This function and "USB2UART_Check_Transmit_Data" function must be pair.*/static void USB2UART_Update_Transmit_Data(void){	/* update buffer information */	if (USB2Uart_MemType == USBTRX_MEM_ISR)	{		USB2UARTPort.Tx_Buffer_ISR.Read += USB2Uart_WriteLength;		ASSERT(USB2UARTPort.Tx_Buffer_ISR.Read <= USB2UARTPort.Tx_Buffer_ISR.Length);		if (USB2UARTPort.Tx_Buffer_ISR.Read == USB2UARTPort.Tx_Buffer_ISR.Length)			USB2UARTPort.Tx_Buffer_ISR.Read = 0;	}	else if (USB2Uart_MemType == USBTRX_MEM_TASK)	{		USB2UARTPort.Tx_Buffer.Read += USB2Uart_WriteLength;		ASSERT(USB2UARTPort.Tx_Buffer.Read <= USB2UARTPort.Tx_Buffer.Length);		if (USB2UARTPort.Tx_Buffer.Read == USB2UARTPort.Tx_Buffer.Length)			USB2UARTPort.Tx_Buffer.Read = 0;	}	else	{		EXT_ASSERT(0, USB2Uart_MemType, 0, 0); 	}	/* reset to 0*/	USB2Uart_WriteLength = 0;}

/*! * @function        cccitty_ccci_dl_cb * @brief           Downlink done handler, called while Tx done callback in HIF *                  Context: HIF context e.x. MOD_SIODCORE *                  Reference cdcacm_ttyhdr_cmd_put_bytes_ior /ccmni_ipc_dl *                  Process: <1> drop the ior if TTYCore doesn't request callback, tty_need_tx_done_cb == DCL_FALSE *                           <2> callback p_cccitty->dcl_txdone * * @param channel    [IN] ccci_channel id * @param io_request [IN] pointer to uplink io request  * * @return          void * */void cccitty_ccci_dl_cb(CCCI_CHANNEL_T channel, ccci_io_request_t* io_request){    cccitty_inst_t      *p_cccitty = cccitty_get_instance();    cccitty_dev_t       *p_cccidev;    cccitty_device_id   dev_id = cccitty_get_dl_devid(channel);    if(CCCI_TTY_DEV_CNT == dev_id){        /* cannot find dev_id for channel, please check g_cccitty_ccci_ch_mappping */        return;    }        if(NULL == io_request){        cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_DL_TXDONE_NULL_IOR, dev_id, channel);        return;    }//    dev_id = cccitty_get_dl_devid(channel);    /* ASSERT if invalid channel number is received */    EXT_ASSERT(dev_id < CCCI_TTY_DEV_CNT, channel, 0, 0);    p_cccidev = cccitty_get_dev_instance(dev_id);    if(DCL_TRUE == p_cccidev->tty_need_tx_done_cb){        /* TTYCore/User requests Tx done callback */        //cccitty_trace(CCCI_TTY_TRACE, CCCI_TTY_MOD_UL, CCCI_TTY_TR_DL_TXDONE_CB, dev_id, channel);        p_cccitty->dcl_txdone(p_cccidev->tty_handler, MOD_CCCITTY, io_request);    }else{        //cccitty_trace(CCCI_TTY_TRACE, CCCI_TTY_MOD_UL, CCCI_TTY_TR_DL_TXDONE_CB_DIS, dev_id, channel);        ccci_dest_ior(io_request);    }    return;}

kal_int32 init_gt818_download_module( kal_uint16 cur_ver, kal_uint8 *firmware_ptr ){    kal_int32 ret = 0;    outbuf = (kal_uint8 *)get_ctrl_buffer( MAX_BUFFER_LEN );    inbuf  = (kal_uint8 *)get_ctrl_buffer( MAX_BUFFER_LEN );    dbgbuf = (kal_char *)get_ctrl_buffer( MAX_BUFFER_LEN );            if ( ( outbuf == NULL ) ||         ( inbuf == NULL ) ||         ( dbgbuf == NULL ) )    {        EXT_ASSERT(0, (kal_uint32)outbuf, (kal_uint32)inbuf, (kal_uint32)dbgbuf);        return 0;    }    CTP_DWN_DEBUG_LINE_TRACE();     //rst_handle = DclGPIO_Open(DCL_GPIO, GPIO_CTP_SHUTDN_PIN);    //int_handle = DclGPIO_Open(DCL_GPIO, GPIO_CTP_INT_PIN);    int_handle = DclGPIO_Open(DCL_GPIO, gpio_ctp_eint_pin);    rst_handle = DclGPIO_Open(DCL_GPIO, gpio_ctp_reset_pin);    DclGPIO_Control(rst_handle, GPIO_CMD_SET_MODE_0, NULL);    DclGPIO_Control(int_handle, GPIO_CMD_SET_MODE_0, NULL);    DclGPIO_Control(int_handle, GPIO_CMD_SET_DIR_OUT, NULL);    ret = gt818_downloader_probe( cur_ver, firmware_ptr );    //DclGPIO_Control(int_handle, GPIO_CMD_SET_DIR_IN, NULL);    //DclGPIO_Control(int_handle, GPIO_CMD_SET_MODE_1, NULL);    DclGPIO_Control(int_handle, GPIO_CMD_WRITE_HIGH, NULL);    DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);    kal_sleep_task(5);    DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_LOW, NULL);    kal_sleep_task(5);    DclGPIO_Control(rst_handle, GPIO_CMD_WRITE_HIGH, NULL);    kal_sleep_task(120);    free_ctrl_buffer( outbuf );    free_ctrl_buffer( inbuf );    free_ctrl_buffer( dbgbuf );    if ( downloader_errno )        EXT_ASSERT( 0, downloader_errno, 0, 0 );    return ret;}

/*! * @function        [static] cccitty_process_dl_gpd_list * @brief           Traverse the input GPD list and insert the CCCI header on the first BD->data  * * @param pDevice   [IN] pointer to the CCCI_TTY device * @param first_gpd [IN] pointer to the first GPD in the GPD chain * @param last_gpd  [IN] pointer to the last GPD in the GPD chain * * @return          kal_uint32 return the gpd number in between first_gpd and last_gpd */static kal_uint32 cccitty_process_dl_gpd_list(cccitty_dev_t* pDevice, qbm_gpd* first_gpd, qbm_gpd* last_gpd){  /*process_tx_gpd_list*/    qbm_gpd*            current_gpd = NULL;    kal_uint32          pkt_cnt   = 0;    kal_uint32          byte_cnt  = 0;    kal_uint32          ccci_h_size;    CCCI_BUFF_T         *p_ccci_head;    kal_int32           addseqrtn;        //ASSERT(first_gpd && last_gpd);    EXT_ASSERT((first_gpd && last_gpd), pDevice->dev_id, (kal_uint32)first_gpd, (kal_uint32)last_gpd);      current_gpd = first_gpd;    ccci_h_size = sizeof(CCCI_BUFF_T);    ASSERT(ccci_h_size > 0);    do {        //4 <1> append CCCI header CCCI_BUFF_T#ifdef __CCCI_N_USE_TGPD_EXT__         /*move data buffer pointer forward for ccci header, increase the gpd, bd length*/        CCCITTY_PUSH_QBM_DATAHEAD(current_gpd, ccci_h_size);        p_ccci_head   = (CCCI_BUFF_T *)CCCITTY_GET_QBM_DATAPTR(current_gpd);        CCCI_STREAM_SET_LEN(p_ccci_head, CCCITTY_GET_QBM_DATALEN(current_gpd));#else        /* Store the DL CCCI header in the GPD extention part */        QBM_DES_SET_EXTLEN(current_gpd, ccci_h_size);        p_ccci_head = (CCCI_BUFF_T *)QBM_DES_GET_EXT(current_gpd);        CCCI_STREAM_SET_LEN(p_ccci_head, CCCITTY_GET_QBM_DATALEN(current_gpd)+ccci_h_size);#endif        /*Construct the CCCI header*/        CCCI_SET_CH_NO(p_ccci_head, pDevice->ccci_ch.cccitty_ch_dl);        /*Add CCCI sequence number*/        addseqrtn = ccci_debug_add_seq(p_ccci_head, CCCI_DEBUG_ASSERT_BIT);        if(addseqrtn != CCCI_SUCCESS)         {            cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_DL, CCCI_TTY_ADD_DL_SEQ_FAIL, addseqrtn, pDevice->ccci_ch.cccitty_ch_dl);        }#if CCCITTY_DATA_TRACE_DUMP_ENABLE        if(pDevice->ccci_ch.cccitty_ch_dl != CCCI_MD_LOG_RX){            cccitty_dump_data(CCCITTY_GET_QBM_DATAPTR(current_gpd), CCCITTY_DUMP_SIZE);        }#endif        QBM_CACHE_FLUSH(p_ccci_head, sizeof(CCCI_BUFF_T));                pkt_cnt++;        byte_cnt += QBM_DES_GET_DATALEN(current_gpd);        if ( current_gpd == last_gpd )        {            break;        }        current_gpd = QBM_DES_GET_NEXT(current_gpd);    } while ( current_gpd != NULL );    return pkt_cnt;}

void USB_Ms_Change_Register_DiskDriver(kal_uint8 disk_index, USB_DiskDriver_STRUCT *disk_api){	/* disk index can not exceed max LUN */	if(disk_index >= USBMS_MAX_DISK[CURRENT_DRV])		EXT_ASSERT(0, (kal_uint32)disk_index, (kal_uint32)USBMS_MAX_DISK[CURRENT_DRV], 0);	USBMS_DISKDRV_API[CURRENT_DRV][disk_index] = disk_api;}

void tst_catcher_force_me_to_assert(void) {  //When you see this assertion failure, it means someone pressed "ASSERT" button from Catcher or issued assert tcl command.  //In general, users do it to preserve the scene of phone "hang" issue.  //Please communicate with issue submitters before reaching Catcher owners.  kal_bool CATCHER_FORCE_ME_TO_ASSERT = KAL_FALSE;  EXT_ASSERT(CATCHER_FORCE_ME_TO_ASSERT, 0, 0, 0);}

static void mdci_dsplogging_d2m_cb(MDCI_BUFF_T *bufp){	if((bufp->reserved>1)||(log_mdci_hdlr == NULL))		EXT_ASSERT(0, (kal_uint32)bufp->reserved, (kal_uint32)log_mdci_hdlr, 0);	log_mdci_hdlr(((MDCI_STREAM_T *)(bufp))->addr, ((MDCI_STREAM_T *)(bufp))->len, bufp->reserved);}

kal_uint8 USB_Ms_Set_Current_Driver(kal_uint32 drv){	if( (drv == LOGIC_DRIVE_MS)||(drv == LOGIC_DRIVE_CDROM))		CURRENT_DRV = drv;	else			EXT_ASSERT(0, drv, 0, 0);			return (USBMS_MAX_DISK[CURRENT_DRV]-1);}

static void USB2UART_SetFlowCtrl(UART_PORT port, kal_bool XON, module_type ownerid){#ifndef  __PRODUCTION_RELEASE__    if(ownerid != USB2UARTPort.ownerid)    {        EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);    }#endif}

static void USB2UART_CtrlDTR (UART_PORT port, IO_level SDTR, module_type ownerid){#ifndef  __PRODUCTION_RELEASE__    if(ownerid != USB2UARTPort.ownerid)    {        EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);    }#endif}

static void USB2UART_SetAutoBaud_Div(UART_PORT port, module_type ownerid){#ifndef  __PRODUCTION_RELEASE__    if(ownerid != USB2UARTPort.ownerid)    {        EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);    }#endif}

static void USB2UART_Purge(UART_PORT port, UART_buffer dir, module_type ownerid){#ifndef  __PRODUCTION_RELEASE__    if(ownerid != USB2UARTPort.ownerid)    {        EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);    }#endif}

kal_uint8 USB_Ms_Register_DiskDriver(USB_DiskDriver_STRUCT *disk_api){	USBMS_DISKDRV_API[CURRENT_DRV][USBMS_MAX_DISK[CURRENT_DRV]] = disk_api;	USBMS_MAX_DISK[CURRENT_DRV]++;		if(USBMS_MAX_DISK[CURRENT_DRV]>=MAX_DISK_DRVER)		EXT_ASSERT(0, (kal_uint32)USBMS_MAX_DISK[CURRENT_DRV], MAX_DISK_DRVER, 0);	return (USBMS_MAX_DISK[CURRENT_DRV]-1);}

static void USB2UART_Register_RX_Callback(UART_PORT port, module_type ownerid, UART_RX_FUNC func){#ifndef  __PRODUCTION_RELEASE__    if(ownerid != USB2UARTPort.ownerid)    {        EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);    }#endif    USB2UARTPort.rx_cb = func;}

/***************************************************************************** * FUNCTION *  jma_audio_recorder_timer_expired * DESCRIPTION *  This function handles if audio recorder timer is expired * PARAMETERS *  mma_type            [IN] *  java_recorder       [IN] *  int reocrder(?) * RETURNS *  void *****************************************************************************/void jma_audio_recorder_timer_expired(kal_int32 vm_id){    /*----------------------------------------------------------------*/    /* Local Variables                                                */    /*----------------------------------------------------------------*/    kal_uint32 record_size = 0;    kal_int32 ticks = kal_milli_secs_to_ticks(200); /* 200 ms */    FS_HANDLE file_handle;    kal_int32 result;    /*----------------------------------------------------------------*/    /* Code Body                                                      */    /*----------------------------------------------------------------*/    kal_trace(TRACE_GROUP_4, FUNC_J2ME_JMA_AUDIO_RECORDER_TIMER_EXPIRED, vm_id, audio_recorder[vm_id].id, audio_recorder[vm_id].state);    JMA_CS_ENTER(vm_id, JMA_VOID);    if (audio_recorder[vm_id].state != JAVA_MEDIA_STATE_RECORDING)    {        JMA_CS_LEAVE(JMA_VOID);    }    EXT_ASSERT(audio_recorder[vm_id].state == JAVA_MEDIA_STATE_RECORDING, 0, 0, 0);    /* Get file size */    file_handle = FS_Open(audio_recorder[vm_id].filename, FS_READ_ONLY | FS_OPEN_SHARED);    if (file_handle <= 0)    {        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_MARKER_FAIL);        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, file_handle);        JMA_CS_LEAVE(JMA_VOID);    }    result = FS_GetFileSize(file_handle, &record_size);    result = FS_Close(file_handle);    if(1 == result)    {        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, record_size+1);    }    kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_D, record_size);    /* Reach record size limit */    if (record_size >= audio_recorder[vm_id].record_size_limit)    {        /* State will be changed */        jma_mvm_audio_recorder_commit(vm_id, audio_recorder[vm_id].id);        jvm_post_mma_event(MMA_EVENT_RECORD_STOPPED,                           audio_recorder[vm_id].id, audio_recorder[vm_id].current_time);    }    else /* re-start timer */    {        kal_trace(TRACE_GROUP_4, INFO_J2ME_MMA_STACK_START_TIMER);        stack_start_timer(&java_media_timer, JAVA_MEDIA_TIMER_AUDIO_RECORDER + vm_id, ticks);    }    JMA_CS_LEAVE(JMA_VOID);}

static void USB2UART_SetDCBConfig(UART_PORT port, UARTDCBStruct *UART_Config, module_type ownerid){#ifndef  __PRODUCTION_RELEASE__    if(ownerid != USB2UARTPort.ownerid)    {        EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);    }#endif    kal_mem_cpy(&USB2UARTPort.DCB, UART_Config, sizeof(UARTDCBStruct));}

kal_uint8 USB_Ms_Get_Max_LUN(void){	//disk number 0 means no disk register for mass storage function		if(USBMS_MAX_DISK[CURRENT_DRV]==0)	{		#ifdef __USB_MODEM_CARD_SUPPORT__		return	USBMS_INVALID_MAX_LUN;		#else		EXT_ASSERT(0, (kal_uint32)USBMS_MAX_DISK[CURRENT_DRV], 0, 0);		#endif	}			return (USBMS_MAX_DISK[CURRENT_DRV]-1);}

void UPLL_Enable(UPLL_OWNER owner){#if  (defined(DRV_UPLL_V1)||defined(DRV_UPLL_V2)||defined(DRV_UPLL_V3)||defined(DRV_UPLL_V4)||defined(DRV_UPLL_V5)||defined(DRV_UPLL_V6)||defined(DRV_UPLL_V7)||defined(DRV_UPLL_V8) || defined(DRV_USB_UPLL_MT50_SERIES))	kal_uint32 savedMask;	if(owner >= UPLL_OWNER_MAX)		EXT_ASSERT(0, (kal_uint32)owner, g_upll_owner, 0);	savedMask = SaveAndSetIRQMask();   	if(g_upll_owner == 0)	{#if defined(DRV_UPLL_V1)		USB_DRV_SetBits(DRVPDN_CON0_CLR , DRVPDN_CON0_UPLL);#elif defined(DRV_UPLL_V2)		/* hardware issue */		USB_PDNDisable(USB_PDN_OWNER_UPLL);		USB_DRV_SetBits(DRVPDN_CON0_CLR , DRVPDN_CON0_UPLL);#elif defined(DRV_UPLL_V3)		/* select UPLL clock source from PLL */		USB_DRV_SetBits(PLL , 0x0040);#elif defined(DRV_UPLL_V4)		USB_DRV_ClearBits(DRVPDN_CON0 , DRVPDN_CON0_PLL2);		/* disable USB clock from external clock */		USB_DRV_ClearBits(CLK_CON , 0x4000);		USB_DRV_SetBits(PLLSEL , 0x0008);#elif defined(DRV_UPLL_V5)		USB_DRV_SetBits(PLL , 0x0040);#elif defined(DRV_UPLL_V6)		USB_DRV_SetBits(PDN_CON , 0x0010);#elif defined(DRV_UPLL_V7)		USB_DRV_SetBits(UPLL_CON1, 0x0002);#elif defined(DRV_UPLL_V8)		USB_DRV_SetBits(GPLL_CON0, 0x0080);#elif defined(DRV_USB_UPLL_MT50_SERIES)	if (SW_SEC_0 == INT_SW_SecVersion()) 	{		PDN_CLR(PDN_USB_48M);	}#endif	}	g_upll_owner |= 1<<(kal_uint32)owner;	RestoreIRQMask(savedMask);#endif}

void h264_intmem_init(void *start_ptr,kal_uint32 length){    kal_uint8 *p_video_addr = (kal_uint8*)start_ptr;    kal_uint32 video_length = length;    if(INT_QueryIsCachedRAM(start_ptr, length))    {        EXT_ASSERT(0, (kal_uint32)start_ptr, length, 0);		    } 	     ASSERT( (((kal_uint32)p_video_addr&0x03)==0)&&(rH264WorkMem.int_ram_init==KAL_FALSE) );    rH264WorkMem.int_ram_start_ptr = (kal_uint32 *)p_video_addr;    rH264WorkMem.int_ram_total_length = video_length;    rH264WorkMem.int_ram_index = 0;    rH264WorkMem.int_ram_init = KAL_TRUE;}

void tst_catcher_database_unmatch_assert(kal_uint32 expected_len, kal_uint32 len_sent_from_catcher, kal_uint32 type ) {  //When you see this assertion failure, it means tst received a filter settings cmd and the content doesn't match what it expected.  // The common possible reason is that you use the wrong Catcher database.  // Or, you may add some module id or sap id without codegen and remaking tst lib again.  // If not, please contact cgen owners for help.    //type:   // 1: TST_SET_PRIM_MOD_FILTER (Module filters)  // 2: TST_SET_PRIM_SAP_FILTER (Sap filter)  // 3: TST_SET_PS_TRC_FILTER (PS Trace group filters)  kal_bool WRONG_DATABASE_SELECTED_IN_CATCHER = KAL_FALSE;  EXT_ASSERT(WRONG_DATABASE_SELECTED_IN_CATCHER,              expected_len,             len_sent_from_catcher, type);}

void usbc_reinit_class(void){    kal_uint32   idx;    usbc_class_reinit_func_t  class_reinit;    for (idx = 0; idx < USB_CLASS_NUM; idx++) {        class_reinit = _get_class_reinit_func(idx);        if (class_reinit) {            usbc_trace_info(USBCORE_ALL_NODE_CHECKIN_REINIT_CLASS_START, idx);            class_reinit(KAL_FALSE);            usbc_trace_info(USBCORE_ALL_NODE_CHECKIN_REINIT_CLASS_END, idx);        } else {            EXT_ASSERT(KAL_FALSE, 2, 0, 0);        }    }}

/* close  USB2UART port */static void USB2UART_close(UART_PORT port, module_type ownerid){#ifndef __USB_ENABLE__    ASSERT(0);#endif#ifndef  __PRODUCTION_RELEASE__    if(ownerid != USB2UARTPort.ownerid)    {        EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0);    }#endif    if(INT_Exception_Enter != 0)    {        drv_trace1(TRACE_FUNC, USBACM_CLOSE, ownerid);//	kal_prompt_trace(MOD_USB, "USB Close %d", ownerid);    }    g_UsbACM.send_Txilm = KAL_FALSE;    g_UsbACM.config_send_Txilm = KAL_FALSE;    USB2UARTPort.initialized = KAL_FALSE;    USB2UARTPort.ownerid = MOD_DRV_HISR;    g_UsbACM.threshold_enable = KAL_FALSE;    if ((gUsbDevice.device_type == USB_CDC_ACM)&&(gUsbDevice.nDevState==DEVSTATE_CONFIG))    {        /* disable endpoint interrupt */        USB_TxEPDis(g_UsbACM.txpipe->byEP, KAL_TRUE);        USB_RxEPDis(g_UsbACM.rxpipe->byEP, KAL_FALSE);    }    Buf_init(&(USB2UARTPort.Rx_Buffer),(kal_uint8 *)(USB2UARTPort.RingBuffers.rx_buffer),             g_UsbACM.acm_param->rx_ringbuff_size);    Buf_init(&(USB2UARTPort.Tx_Buffer),(kal_uint8 *)(USB2UARTPort.RingBuffers.tx_buffer),             g_UsbACM.acm_param->tx_ringbuff_size);    Buf_init(&(USB2UARTPort.Tx_Buffer_ISR),(kal_uint8 *)(USB2UARTPort.RingBuffers.txISR_buffer),             g_UsbACM.acm_param->txisr_ringbuff_size);    if(g_UsbACM.ring_buffer_timer_counting == KAL_TRUE)    {        GPTI_StopItem(g_UsbACM.ring_buffer_handle);        g_UsbACM.ring_buffer_timer_counting = KAL_FALSE;    }    USB2UART_ConfigEscape(port, 0xff, 0, MOD_DRV_HISR);}