kal_bool USB_Ms_Read_Write(USB_MS_DIRECTION direct, kal_uint8 LUN, void *data, kal_uint32 LBA, kal_uint16 sec_len) { kal_bool ret; kal_uint32 time; kal_uint32 performance; USB_Ms_Check_CURRENT_DRV(LUN); if (USBMS_DISKDRV_LBA_INFO[LUN].LastBA == 0) { USBMS_DISKDRV_API[CURRENT_DRV][LUN]->usbms_read_capacity( &USBMS_DISKDRV_LBA_INFO[LUN].LastBA, &USBMS_DISKDRV_LBA_INFO[LUN].BlkLen); } if ( (LBA+sec_len-1) > USBMS_DISKDRV_LBA_INFO[LUN].LastBA) return KAL_FALSE; time = drv_get_current_time(); if (direct == USB_MS_WRITE) ret = USBMS_DISKDRV_API[CURRENT_DRV][LUN]->usbms_write(data, LBA, sec_len); else ret = USBMS_DISKDRV_API[CURRENT_DRV][LUN]->usbms_read(data, LBA, sec_len); time = drv_get_current_time()-time; if(time > 0) { performance = sec_len*32*1024/2/time; if (direct == USB_MS_WRITE) drv_trace1(TRACE_FUNC, (kal_uint32)USBMS_WRITE_PERFORMANCE, performance); else drv_trace1(TRACE_FUNC, (kal_uint32)USBMS_READ_PERFORMANCE, performance); } return ret; }
/** * ROTDMA warm reset function. * * @param none. * * @return. */ void rotdma0_warm_reset(void) { kal_uint32 irq_flag; kal_uint32 cfg; // First backup control register due to control register would be clear after warm reset irq_flag = REG_IMGDMA_ROT_DMA_IRQ_FLAG & 0xFFFF0000; cfg = REG_IMGDMA_ROT_DMA_CFG; IMGDMA_ROTDMA_WARM_RESET(); { kal_bool rst_done; kal_uint32 last_time = drv_get_current_time(); // Check if rotdma reset busy, if busy over 2 tick, assert... according to Andy, < 4us (200 cycle @52Mhz) do { rst_done = IMGDMA_ROTDMA_IS_WARM_RESET_FINISH(); } while ((KAL_FALSE == rst_done) && (2 >= drv_get_duration_tick(last_time, drv_get_current_time()))); } // Restore control register REG_IMGDMA_ROT_DMA_IRQ_FLAG = irq_flag; REG_IMGDMA_ROT_DMA_CFG = cfg; }
void adc_delay_us(kal_uint32 us) { kal_uint32 tmp; kal_uint32 tick_count; tick_count = us>>5; // The unit is 32us //tick_count = us/32; // The unit is 32us tmp = drv_get_current_time(); while (drv_get_duration_tick(tmp, drv_get_current_time()) < tick_count) { ; } }
/* determine what buffer has data to send and call DMA setup function*/ void USB2UART_DMATransmit(kal_uint8 ep_num, kal_bool b_force_isr_buffer) { kal_uint32 addr; kal_uint32 length=0; // kal_uint32 savedMask; // savedMask = SaveAndSetIRQMask(); if(b_force_isr_buffer == KAL_TRUE) { length = USB2UART_Check_Transmit_Data(&addr, KAL_FALSE); } else { length = USB2UART_Check_Transmit_Data(&addr, g_UsbACM.threshold_enable); } // RestoreIRQMask(savedMask); if (length) { USB_Dbg_Trace(USB_ACM_DMA_SETUP, drv_get_current_time(), length, USB2Uart_MemType); /* dma running state is cleared by USB2UART_Tx_DMA_Callback */ // USB_DMA_Setup(ep_num, USB_TX_EP_TYPE, addr, length, USB2UART_Tx_DMA_Callback, KAL_TRUE); USB_DMA_Setup(ep_num, USB_TX_EP_TYPE, USB_ENDPT_BULK, addr, length, USB2UART_Tx_DMA_Callback, KAL_FALSE, KAL_TRUE, USB_DMA1_TYPE); } else { g_UsbACM.setup_dma = KAL_FALSE; } }
MM_ERROR_CODE_ENUM HdrCtrl (PP_SCENARIO_ENUM ScenarioId, PP_SCENARIO_CTRL_ENUM CtrlCode, void *pParaIn, void *pParaOut, kal_uint16 ParaOutLen) { kal_uint32 i, StartTime, TotalTime=0; UTL_SWITCH_CACHE_STRUCT MemSwitch; if(PP_CTRL_CODE_STOP == CtrlCode) { PP_SET_EVENT(PP_EVENT_HDR_STOP_CNF); } else if(PP_CTRL_CODE_START == CtrlCode) { StartTime = drv_get_current_time(); gHdrProcPara.MaxProcTime = HDR_PROCESS_MAX_TIME; MemSwitch.pMemAddr= (kal_uint32*)&(gHdrProcPara.SrcImgAddr); MemSwitch.Size = gHdrProcPara.SrcImgSize; MemSwitch.CacheableFlag=KAL_TRUE; UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL); MemSwitch.pMemAddr= (kal_uint32*)&(gHdrProcPara.WorkingBufAddr); MemSwitch.Size = SwHdrGetUseWorkingBufferSize(); MemSwitch.CacheableFlag=KAL_TRUE; UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL); for(i=0;i<HDR_PROCESS_MAX_COUNT;i++) { /* HDR process */ SwHdrCoreProc(&gHdrProcPara, &gHdrProcResult, ParaOutLen); /* Evaluated process time */ TotalTime = drv_get_duration_ms(StartTime); if((HDR_PROCESS_MAX_TIME<=TotalTime)||(HDR_STATE_READY==gHdrProcResult.HdrState)) { break; } else { gHdrProcPara.MaxProcTime = HDR_PROCESS_MAX_TIME - TotalTime; } } if(gHdrProcResult.HdrState == HDR_STATE_READY) { MemSwitch.pMemAddr= (kal_uint32*)&gHdrProcResult.ImgBufferAddr; MemSwitch.Size = (gHdrProcResult.ImgWidth*gHdrProcResult.ImgHeight*3)/2;//gHdrProcPara.SrcImgSize; MemSwitch.CacheableFlag=KAL_FALSE; UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL); MemSwitch.pMemAddr= (kal_uint32*)&(gHdrProcPara.WorkingBufAddr); MemSwitch.Size = SwHdrGetUseWorkingBufferSize(); MemSwitch.CacheableFlag=KAL_FALSE; UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL); pfPpHdrCb(PP_CBID_HDR_RESULT, &gHdrProcResult, sizeof(HDR_RESULT_STRUCT)); } } return MM_ERROR_NONE; } /* SwHdrControl() */
void MT6302_spiPowerCtrl(kal_bool on) { kal_uint32 i; if(0 == MT6302_getSPIInterface()) { if(31 < MT6302_LCD_pdnHandle) ASSERT(0); if (KAL_FALSE == on) lcd_clk_disable(MT6302_LCD_pdnHandle); else if(KAL_TRUE == on){ lcd_clk_enable(MT6302_LCD_pdnHandle); if(DRVPDN_CON1_LCD & DRV_Reg(DRVPDN_CON1)) ASSERT(0); i = 1000; while(i) i--; } else ASSERT(0); } else if(1 == MT6302_getSPIInterface()) { /*we don't know should we do power control before want to write SPI in GPIO implementation*/ } else{ IMPLEMENTING_ASSERT; } drv_trace8(TRACE_GROUP_4, SIM_GEMINI_GEN1, FILE_MT6302_SPI, __LINE__, on, DRV_Reg(DRVPDN_CON1), MT6302_getSPIInterface(), MT6302_LCD_pdnHandle, drv_get_current_time(), 0 ); }
kal_uint32 drv_get_duration_ms(kal_uint32 previous_time) { kal_uint32 result; kal_uint32 current_time; current_time = drv_get_current_time(); result = drv_get_duration_tick(previous_time, current_time); result*=1000; result/=32768; return result; }
kal_uint32 drv_get_duration_ms(kal_uint32 previous_time) { kal_uint32 result; kal_uint32 current_time; kal_uint64 temp_value; current_time = drv_get_current_time(); result = drv_get_duration_tick(previous_time, current_time); /* X ms = result x 1000/32K = (result x 125)>>12 */ temp_value = (kal_uint64)(((kal_uint64) result)*125); result = (kal_uint32)(temp_value>>12); return result; }
void idp_add_traced_end(IdpTracedAPI const api, kal_int32 const idx) { if ((idx < 0) || (idx >= IDP_TRACED_BUFFER_SIZE)) { ASSERT(0); } if (g_idp_traced[idx].m_api != api) { ASSERT(0); } g_idp_traced[idx].m_done = KAL_TRUE; g_idp_traced[idx].m_done_time_drv = drv_get_current_time(); }
kal_int32 idp_add_traced_lisr(IdpTracedAPI const api) { kal_uint32 savedMask; kal_uint32 register my_idx; savedMask = SaveAndSetIRQMask(); my_idx = g_idp_traced_curr_idx; ++g_idp_traced_curr_idx; g_idp_traced_curr_idx &= (IDP_TRACED_BUFFER_SIZE - 1); RestoreIRQMask(savedMask); g_idp_traced[my_idx].m_api = api; g_idp_traced[my_idx].m_start_time_drv = drv_get_current_time(); return my_idx; }
void DRV_HISR(void) { kal_uint16 index; kal_uint32 savedMask; #if defined(_MAUI_SOFTWARE_LA_) /* under construction !*/ #endif if (drv_hisr_status != 0) { for(index = 0;index<MAX_DRV_HISR_DEVICE;index++) { if (drv_hisr_status & (1 << index)) { savedMask = SaveAndSetIRQMask(); #if defined(_MAUI_SOFTWARE_LA_) /* under construction !*/ /* under construction !*/ #endif DRV_CURRENT_HISR = index; #if ( defined(MT6218B) || defined(MT6205B) ) drv_hisr_dbg_trace(index, 0xffff); #else /*! (MT6218B, MT6205B)*/ drv_hisr_dbg_trace(index, drv_get_current_time()); #endif /*(MT6218B, MT6205B)*/ ASSERT(DRV_HISR_TABLE[index].hisr_count!=0); DRV_HISR_TABLE[index].hisr_count--; if (DRV_HISR_TABLE[index].hisr_count == 0) drv_hisr_status &= ~((1 << index)); RestoreIRQMask(savedMask); DRV_HISR_TABLE[index].hisr_func(); DRV_CURRENT_HISR = DRV_UNKNOWN_HISR_ID; } } } }
static void USB_Stdcmd(Usb_Ep0_Status *pep0state, Usb_Command *pcmd) { kal_bool bError = KAL_FALSE; switch (pcmd->bRequest) { case USB_SET_ADDRESS: USB_Dbg_Trace(USB_EP0_SET_ADDRESS, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = USB_Cmd_SetAddress(pep0state, pcmd); break; case USB_GET_DESCRIPTOR: USB_Dbg_Trace(USB_EP0_GET_DESCRIPTOR, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = USB_Cmd_GetDescriptor(pep0state, pcmd); break; case USB_SET_CONFIGURATION: USB_Dbg_Trace(USB_EP0_SET_CONFIGURATION, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = USB_Cmd_SetConfiguration(pep0state, pcmd); break; case USB_SET_INTERFACE: USB_Dbg_Trace(USB_EP0_SET_INTERFACE, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = USB_Cmd_SetInterface(pep0state, pcmd); break; case USB_GET_CONFIGURATION: USB_Dbg_Trace(USB_EP0_GET_CONFIGURATION, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = USB_Cmd_GetConfiguration(pep0state, pcmd); break; case USB_GET_INTERFACE: USB_Dbg_Trace(USB_EP0_GET_INTERFACE, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = USB_Cmd_GetInterface(pep0state, pcmd); break; case USB_SET_FEATURE: USB_Dbg_Trace(USB_EP0_SET_FEATURE, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = USB_Cmd_SetFeature(pcmd, KAL_TRUE); break; case USB_CLEAR_FEATURE: USB_Dbg_Trace(USB_EP0_CLEAR_FEATURE, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = USB_Cmd_SetFeature(pcmd, KAL_FALSE); break; case USB_GET_STATUS: USB_Dbg_Trace(USB_EP0_GET_STATUS, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = USB_Cmd_GetStatus(pep0state, pcmd); break; /* Stall the command if an unrecognized request is received */ case USB_SYNCH_FRAME: /*Only support for Isoc traffic*/ case USB_SET_DESCRIPTOR: default: USB_Dbg_Trace(USB_EP0_CMD_ERROR, drv_get_current_time(), (kal_uint32)pcmd->wValue, (kal_uint32)pcmd->wIndex); bError = KAL_TRUE; // ASSERT(0); break; } if (gUsbDevice.ep0_state == USB_EP0_IDLE) /* no data to transmit */ { gUsbDevice.ep0_state = USB_EP0_RX_STATUS; USB_Update_EP0_State(USB_EP0_DRV_STATE_READ_END, bError, KAL_TRUE); /* if((gUsbDevice.ep0_class_cmd_handler.b_enable == KAL_TRUE) && (gUsbDevice.ep0_class_cmd_handler.cmd == pcmd->bRequest) ) { gUsbDevice.ep0_class_cmd_handler.ep0_cmd_hdlr(pcmd); } */ } else { USB_Update_EP0_State(USB_EP0_DRV_STATE_READ_END, bError, KAL_FALSE); } }
/*put bytes to tx buffer, return value is the actually put out bytes*/ static kal_uint16 USB2UART_PutBytes(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length, module_type ownerid) { kal_uint16 real_count; // kal_uint16 index; kal_uint32 savedMask; kal_uint8 ep_num = 0; kal_bool setup_dma = KAL_FALSE; kal_int32 remain; BUFFER_INFO *tx_info = &(USB2UARTPort.Tx_Buffer); if(ownerid != USB2UARTPort.ownerid) { #ifdef __PRODUCTION_RELEASE__ return 0; #else /* __PRODUCTION_RELEASE__ */ EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0); #endif } /* return directly if not match condition */ if ( (gUsbDevice.device_type != USB_CDC_ACM) || (USB2UARTPort.initialized == KAL_FALSE) || (gUsbDevice.nDevState!=DEVSTATE_CONFIG)) { if(((gUsbDevice.device_type == USB_CDC_ACM)||(gUsbDevice.usb_comport_boot == KAL_TRUE)) && (USB2UARTPort.initialized == KAL_TRUE)&&(gUsbDevice.nDevState != DEVSTATE_CONFIG)) { g_UsbACM.config_send_Txilm = KAL_TRUE; /* for PC set config later then can issue the first message */ } return 0; } /* The same issue as USB2UART_GetBytes() The area to determine send_Txilm must also contain in critical section. Otherwise if DMA callback activated before send_Txilm setting as true, this message will be lost */ savedMask = SaveAndSetIRQMask(); Buf_GetRoomLeft(tx_info, real_count); /* determine real sent data count */ if (real_count > length) { real_count = length; } else { g_UsbACM.send_Txilm = KAL_TRUE; /*After this time put bytes, buffer will be full */ g_UsbACM.config_send_Txilm = KAL_TRUE; /* if be reseted, then it can issue the message waited for*/ } RestoreIRQMask(savedMask); if(g_UsbACM.send_Txilm == KAL_TRUE) { if(ownerid != MOD_TST_READER) { drv_trace1(TRACE_FUNC, USBACM_PUT_BYTES_BUF_FULL, ownerid); // kal_prompt_trace(MOD_USB, "RDY W %d", ownerid); } } if(real_count != 0) { remain = (BWrite(tx_info) + real_count) - BLength(tx_info); if(remain < 0) { /* dest, src, len */ kal_mem_cpy(BuffWrite(tx_info), buffaddr, real_count); BWrite(tx_info) += real_count; } else { kal_mem_cpy(BuffWrite(tx_info), buffaddr, real_count-remain); kal_mem_cpy(BStartAddr(tx_info), (kal_uint8 *)(buffaddr+real_count-remain), remain); BWrite(tx_info) = remain; } } /* push data from caller buffer to ring buffer */ /* for (index = 0; index < real_count; index++) { Buf_Push(&(USB2UARTPort.Tx_Buffer), *(buffaddr+index)); } */ savedMask = SaveAndSetIRQMask(); /* in case usb is plugged out just before this critical section */ if(gUsbDevice.device_type == USB_CDC_ACM) { // if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE) if(g_UsbACM.setup_dma == KAL_FALSE) { g_UsbACM.setup_dma = KAL_TRUE; setup_dma = KAL_TRUE; ep_num = g_UsbACM.txpipe->byEP; } } RestoreIRQMask(savedMask); if(setup_dma == KAL_TRUE) { USB_Dbg_Trace(USB_ACM_DMA_SETUP_1, drv_get_current_time(), ep_num, 0); USB2UART_DMATransmit(ep_num, KAL_FALSE); } #ifndef __PRODUCTION_RELEASE__ if(ownerid != USB2UARTPort.ownerid) { EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0); } if(ownerid != MOD_TST_READER) { drv_trace1(TRACE_FUNC, USBACM_PUT_BYTES, real_count); // kal_prompt_trace(MOD_USB, "Put %d", real_count); } #endif return real_count; }
static void USB2UART_CtrlDCD(UART_PORT port, IO_level SDCD, module_type ownerid) { kal_uint32 savedMask; kal_bool b_set_intr; kal_uint8 ep_num = 0; #ifdef USB_20_ENABLE kal_uint32 max_intr_pkt_size; #endif #ifndef __PRODUCTION_RELEASE__ USB_Dbg_Trace(USB_ACM_SEND_INTERRUPT, drv_get_current_time(), g_UsbACM.intr_state, 0); if(ownerid != USB2UARTPort.ownerid) { EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0); } #endif savedMask = SaveAndSetIRQMask(); if((g_UsbACM.intr_state == ACM_INTR_IDLE)&&(gUsbDevice.is_configured_now == KAL_TRUE)) { b_set_intr = KAL_TRUE; g_UsbACM.is_intr_pending_pkt = KAL_FALSE; ep_num = g_UsbACM.intrpipe->byEP; } else { b_set_intr = KAL_FALSE; g_UsbACM.is_intr_pending_pkt = KAL_TRUE; } if(SDCD == io_high) g_UsbACM.intr_pkt.Data = SERIAL_STATE_BRXCARRIER; else if (SDCD == io_low) g_UsbACM.intr_pkt.Data = 0x00; else ASSERT(0); RestoreIRQMask(savedMask); if(b_set_intr == KAL_TRUE) { #ifdef USB_20_ENABLE if(USB_Is_High_Speed() == KAL_TRUE) max_intr_pkt_size = USB_EP_INTR_MAXP_HS; else max_intr_pkt_size = USB_EP_INTR_MAXP_FS; if(max_intr_pkt_size > sizeof(UsbAcm_Intr_Pkt)) #else if(USB_EP_INTR_MAXP > sizeof(UsbAcm_Intr_Pkt)) #endif { g_UsbACM.intr_state = ACM_INTR_SEND_LAST_PKT; #ifndef __PRODUCTION_RELEASE__ /* send only one short packet */ USB_Dbg_Trace(USB_ACM_SEND_INTERRUPT2, drv_get_current_time(), g_UsbACM.intr_state, 0); drv_trace1(TRACE_FUNC, USBACM_INTR, g_UsbACM.intr_pkt.Data); // kal_prompt_trace(MOD_USB, "ACM INTR %d", g_UsbACM.intr_pkt.Data); #endif USB_EPFIFOWrite(ep_num, sizeof(UsbAcm_Intr_Pkt), (kal_uint8 *)&g_UsbACM.intr_pkt); USB_EP_Bulk_Tx_Ready(ep_num); } else { g_UsbACM.intr_state = ACM_INTR_SEND_ONE_PKT; #ifndef __PRODUCTION_RELEASE__ /* send one max packet */ USB_Dbg_Trace(USB_ACM_SEND_INTERRUPT1, drv_get_current_time(), g_UsbACM.intr_state, 0); drv_trace1(TRACE_FUNC, USBACM_INTR, g_UsbACM.intr_pkt.Data); // kal_prompt_trace(MOD_USB, "ACM INTR %d", g_UsbACM.intr_pkt.Data); #endif #ifdef USB_20_ENABLE USB_EPFIFOWrite(ep_num, max_intr_pkt_size, (kal_uint8 *)&g_UsbACM.intr_pkt); #else USB_EPFIFOWrite(ep_num, USB_EP_INTR_MAXP, (kal_uint8 *)&g_UsbACM.intr_pkt); #endif USB_EP_Bulk_Tx_Ready(ep_num); } } }
/* put bytes to ISR tx buffer, handle the special character in this function(add escape character) return value is the actually put out bytes*/ static kal_uint16 USB2UART_SendISRData(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length, kal_uint8 mode, kal_uint8 escape_char, module_type ownerid) { kal_int16 real_count, index; kal_uint8 data; kal_uint32 savedMask; kal_uint8 ep_num = 0; kal_bool setup_dma = KAL_FALSE; BUFFER_INFO *tx_isr_info = &(USB2UARTPort.Tx_Buffer_ISR); if(ownerid != USB2UARTPort.ownerid) { #ifdef __PRODUCTION_RELEASE__ return 0; #else EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0); #endif } if ( (gUsbDevice.device_type != USB_CDC_ACM) || (USB2UARTPort.initialized == KAL_FALSE) || (gUsbDevice.nDevState!=DEVSTATE_CONFIG)) return 0; if (mode == 0) { real_count = USB2UART_PutISRBytes(port, buffaddr, length, ownerid); } else { savedMask = SaveAndSetIRQMask(); Buf_GetRoomLeft(tx_isr_info, real_count); RestoreIRQMask(savedMask); /* determine real sent data count */ if (real_count > length) real_count = length; for (index = 0; index < real_count; index++) { kal_uint16 roomleft; savedMask = SaveAndSetIRQMask(); Buf_GetRoomLeft(tx_isr_info, roomleft); RestoreIRQMask(savedMask); data = *(buffaddr + index); /* if the character is special character, translate it. PC has the ability to distinguish it*/ if (data == USB2UARTPort.DCB.xonChar) { if ( roomleft >= 2 ) { Buf_Push(tx_isr_info, escape_char); Buf_Push(tx_isr_info, 0x01); } else { break; } } else if (data == USB2UARTPort.DCB.xoffChar) { if ( roomleft >= 2 ) { Buf_Push(tx_isr_info, escape_char); Buf_Push(tx_isr_info, 0x02); } else { break; } } else if (data == escape_char) { if ( roomleft >= 2 ) { Buf_Push(tx_isr_info, escape_char); Buf_Push(tx_isr_info, 0x03); } else { break; } } else { if (roomleft) { Buf_Push(tx_isr_info, data); } else { break; } } } real_count = index; savedMask = SaveAndSetIRQMask(); /* in case usb is plugged out just before this critical section */ if(gUsbDevice.device_type == USB_CDC_ACM) { // if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE) if(g_UsbACM.setup_dma == KAL_FALSE) { g_UsbACM.setup_dma = KAL_TRUE; setup_dma = KAL_TRUE; ep_num = g_UsbACM.txpipe->byEP; } } RestoreIRQMask(savedMask); if(setup_dma == KAL_TRUE) { USB_Dbg_Trace(USB_ACM_DMA_SETUP_3, drv_get_current_time(), ep_num, 0); USB2UART_DMATransmit(ep_num, KAL_FALSE); } } #ifndef __PRODUCTION_RELEASE__ if(ownerid != USB2UARTPort.ownerid) { EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0); } #endif if(ownerid != MOD_TST_READER) { drv_trace1(TRACE_FUNC, USBACM_SEND_ISR_DATA, real_count); // kal_prompt_trace(MOD_USB, "SendISR %d", real_count); } return real_count; }
/* put bytes to ISR tx buffer, return value is the actually put out bytes */ static kal_uint16 USB2UART_PutISRBytes(UART_PORT port, kal_uint8 *buffaddr, kal_uint16 length, module_type ownerid) { kal_uint16 real_count; // kal_uint16 index; kal_uint32 savedMask; kal_uint8 ep_num = 0; kal_bool setup_dma = KAL_FALSE; kal_int32 remain; BUFFER_INFO *tx_isr_info = &(USB2UARTPort.Tx_Buffer_ISR); if(ownerid != USB2UARTPort.ownerid) { #ifdef __PRODUCTION_RELEASE__ return 0; #else /* __PRODUCTION_RELEASE__ */ EXT_ASSERT( 0, (kal_uint32) ownerid, USB2UARTPort.ownerid, 0); #endif } if ( (gUsbDevice.device_type != USB_CDC_ACM) || (USB2UARTPort.initialized == KAL_FALSE) || (gUsbDevice.nDevState!=DEVSTATE_CONFIG)) return 0; savedMask = SaveAndSetIRQMask(); Buf_GetRoomLeft(tx_isr_info, real_count); RestoreIRQMask(savedMask); /* determine real sent data count */ if (real_count > length) real_count = length; if(real_count != 0) { remain = (BWrite(tx_isr_info) + real_count) - BLength(tx_isr_info); if(remain < 0) { /* dest, src, len */ kal_mem_cpy(BuffWrite(tx_isr_info), buffaddr, real_count); BWrite(tx_isr_info) += real_count; } else { kal_mem_cpy(BuffWrite(tx_isr_info), buffaddr, real_count-remain); kal_mem_cpy(BStartAddr(tx_isr_info), (kal_uint8 *)(buffaddr+real_count-remain), remain); BWrite(tx_isr_info) = remain; } } /* push data from caller buffer to ring buffer */ /* for (index = 0; index < real_count; index++) { Buf_Push(tx_isr_info, *(buffaddr+index)); } */ savedMask = SaveAndSetIRQMask(); /* in case usb is plugged out just before this critical section */ if(gUsbDevice.device_type == USB_CDC_ACM) { // if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE) if(g_UsbACM.setup_dma == KAL_FALSE) { g_UsbACM.setup_dma = KAL_TRUE; setup_dma = KAL_TRUE; ep_num = g_UsbACM.txpipe->byEP; } } RestoreIRQMask(savedMask); if(setup_dma == KAL_TRUE) { USB_Dbg_Trace(USB_ACM_DMA_SETUP_2, drv_get_current_time(), ep_num, 0); USB2UART_DMATransmit(ep_num, KAL_FALSE); } #ifndef __PRODUCTION_RELEASE__ if(ownerid != USB2UARTPort.ownerid) { EXT_ASSERT( 0, (kal_uint32) ownerid, (kal_uint32)USB2UARTPort.ownerid, 0); } #endif if(ownerid != MOD_TST_READER) { drv_trace1(TRACE_FUNC, USBACM_PUT_ISR_BYTES, real_count); // kal_prompt_trace(MOD_USB, "PutISR %d", real_count); } return real_count; }
usim_status_enum L1sim_Reset_All(sim_power_enum ExpectVolt, sim_power_enum *ResultVolt, kal_bool warm, SIM_ICC_APPLICATION application) { sim_ctrlDriver *simDriver; usim_status_enum status; kal_uint32 simInterface; #ifdef __SIM_HOT_SWAP_SUPPORT__ kal_int32 ipcStatus; #if defined (__MD1__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__) kal_uint8 *query, querystring[25] = "MD1_SIM1_HOT_PLUG_EINT"; #elif defined (__MD2__) kal_uint8 *query, querystring[25] = "MD2_SIM1_HOT_PLUG_EINT"; #else kal_uint8 *query, querystring[20] = "SIM1_HOT_PLUG_EINT"; #endif SIM_ICC_HOT_PLUG iccHotPlug = {KAL_FALSE, KAL_FALSE, KAL_FALSE, 0, 0, 0, 0, 0, 0, NULL, NULL}; query = &querystring[0]; #endif #ifdef SIM_4_CARD_SMT_TEST SIM_ICC_APPLICATION anotherApplication; kal_uint32 anotherSimInterface; sim_power_enum anotherResultVolt; sim_ctrlDriver *anotherSimDriver; usim_status_enum anotherStatus; #endif sim_HW_cb *hw_cb; simInterface = sim_get_logicalNum_from_app(application); hw_cb = (sim_HW_cb *)(hwCbArray[simInterface]); #ifdef SIM_4_CARD_SMT_TEST if(SIM_ICC_APPLICATION_PHONE1 == application) anotherApplication = SIM_ICC_APPLICATION_PHONE3; else if(SIM_ICC_APPLICATION_PHONE2 == application) anotherApplication = SIM_ICC_APPLICATION_PHONE4; else ASSERT(0); anotherSimInterface = sim_get_logicalNum_from_app(anotherApplication); #endif if(DRV_SIM_MAX_LOGICAL_INTERFACE <= simInterface) ASSERT(0); #ifdef SIM_4_CARD_SMT_TEST if(DRV_SIM_MAX_LOGICAL_INTERFACE <= anotherSimInterface) ASSERT(0); #endif if(KAL_TRUE == sim_physicalSlotChanged){ #if !defined( __MAUI_BASIC__) tst_sys_trace("[SIM]:sim interface inversed!!"); #else dbg_print("[SIM]:sim interface inversed!!"); #endif simInterface = 1-simInterface; application = 1-application; // need to switch to get correct hwcb and SIMIF number } if(0x0 == ResultVolt) ASSERT(0); #if defined (LPWR_SLIM) L1SM_SleepDisable(hw_cb->smHandler); //lock sleep mode #endif #ifdef __CUSTOMER_HW_VERIFICATION__ simInterface = 0; /*find out the hooked function table*/ simDriver = sim_driverTable[simInterface]; ASSERT(0 != simDriver); sim_MT6302_addMsg(SIM_MT6302_ACTION_RESET, simInterface, 0, 0); status = simDriver->reset(ExpectVolt, ResultVolt, warm, (sim_HW_cb *)(hwCbArray[simInterface])); sim_MT6302_addMsg(SIM_MT6302_ACTION_EOC, simInterface, drv_get_current_time(), 0); simDriver->EOC((sim_HW_cb *)(hwCbArray[simInterface])); simInterface = 1; /*find out the hooked function table*/ simDriver = sim_driverTable[simInterface]; ASSERT(0 != simDriver); sim_MT6302_addMsg(SIM_MT6302_ACTION_RESET, simInterface, 0, 0); /*when we release single SIM MMI, we only release SIM1 MMI, cusrtomer won't get SIM2 MMI, SIM1 is what MMI need*/ //status = simDriver->reset(ExpectVolt, ResultVolt, warm, simInterface); sim_MT6302_addMsg(SIM_MT6302_ACTION_EOC, simInterface, drv_get_current_time(), 0); simDriver->EOC(simInterface); #else /*find out the hooked function table*/ simDriver = sim_driverTable[simInterface]; ASSERT(0 != simDriver); simDriver->addMessage(SIM_AL_ACTION_RESET, simInterface, (kal_uint32)kal_get_current_thread_ID(), 0); status = simDriver->reset(ExpectVolt, ResultVolt, warm, (sim_HW_cb *)(hwCbArray[simInterface])); #ifdef __SIM_HOT_SWAP_SUPPORT__ /* we should always register eint. If we bootup without plugin simcard, status will display NO_CARD. we will never get insert event because eint is not registered */ #if defined (__MD1__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__) if (application == SIM_ICC_APPLICATION_PHONE2) query = (kal_uint8 *)"MD1_SIM2_HOT_PLUG_EINT"; #elif defined (__MD2__) if (application == SIM_ICC_APPLICATION_PHONE2) query = (kal_uint8 *)"MD2_SIM2_HOT_PLUG_EINT"; #else if (application == SIM_ICC_APPLICATION_PHONE2) query = (kal_uint8 *)"SIM2_HOT_PLUG_EINT"; #endif /* if any rpc error happens, we should leave register eint */ #if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__) ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_NUMBER, (void *)&iccHotPlug.eintNo, 4); #else ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_NUMBER, (void *)&iccHotPlug.eintNo, 4); #endif if (ipcStatus < 0) { kal_sprintf(sim_dbg_str,"get eint no fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.eintNo); #if !defined( __MAUI_BASIC__) tst_sys_trace(sim_dbg_str); #else dbg_print(sim_dbg_str); #endif goto LEAVE_REG_EINT; } #if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__) ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_DEBOUNCETIME, (void *)&iccHotPlug.debounceTime, 4); #else ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_DEBOUNCETIME, (void *)&iccHotPlug.debounceTime, 4); #endif if (ipcStatus < 0) { kal_sprintf(sim_dbg_str,"get debounce fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.debounceTime); #if !defined( __MAUI_BASIC__) tst_sys_trace(sim_dbg_str); #else dbg_print(sim_dbg_str); #endif goto LEAVE_REG_EINT; } #if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__) ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_POLARITY, (void *)&iccHotPlug.polarity, 4); #else ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_POLARITY, (void *)&iccHotPlug.polarity, 4); #endif if (ipcStatus < 0) { kal_sprintf(sim_dbg_str,"get polarity fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.polarity); #if !defined( __MAUI_BASIC__) tst_sys_trace(sim_dbg_str); #else dbg_print(sim_dbg_str); #endif goto LEAVE_REG_EINT; } #if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__) ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_SENSITIVITY, (void *)&iccHotPlug.sensitivity, 4); #else ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_SENSITIVITY, (void *)&iccHotPlug.sensitivity, 4); #endif if (ipcStatus < 0) { kal_sprintf(sim_dbg_str,"get sensitivity fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.sensitivity); #if !defined( __MAUI_BASIC__) tst_sys_trace(sim_dbg_str); #else dbg_print(sim_dbg_str); #endif goto LEAVE_REG_EINT; } #if defined (__MD1__) || defined (__MD2__) || defined (__SIM_HOT_PLUG_SINGLE_MD_QUERY_STR__) ipcStatus = IPC_RPC_EINT_GetAttribute(query, 23, SIM_HOT_PLUG_EINT_SOCKETTYPE, (void *)&iccHotPlug.socketType, 4); #else ipcStatus = IPC_RPC_EINT_GetAttribute(query, 19, SIM_HOT_PLUG_EINT_SOCKETTYPE, (void *)&iccHotPlug.socketType, 4); #endif if (ipcStatus < 0) { kal_sprintf(sim_dbg_str,"get socket fail %d %d, please request HW to check ALPS DWS setting.", ipcStatus, iccHotPlug.socketType); #if !defined( __MAUI_BASIC__) tst_sys_trace(sim_dbg_str); #else dbg_print(sim_dbg_str); #endif goto LEAVE_REG_EINT; } sim_reg_hot_plug_eint(application, iccHotPlug.eintNo, iccHotPlug.debounceTime, iccHotPlug.polarity, iccHotPlug.sensitivity, iccHotPlug.socketType); LEAVE_REG_EINT: kal_sprintf(sim_dbg_str,"[SIM_DRV]EINT: %d, %d %d %d %d %d %d", application, ipcStatus, iccHotPlug.eintNo, iccHotPlug.debounceTime, iccHotPlug.polarity, iccHotPlug.sensitivity, iccHotPlug.socketType); #if !defined( __MAUI_BASIC__) tst_sys_trace(sim_dbg_str); #else dbg_print(sim_dbg_str); #endif kal_sprintf(sim_dbg_str,"[SIM_DRV]EINT: %s", query); #if !defined( __MAUI_BASIC__) tst_sys_trace(sim_dbg_str); #else dbg_print(sim_dbg_str); #endif #endif /* End of #ifdef __SIM_HOT_SWAP_SUPPORT__ */ simDriver->addMessage(SIM_AL_ACTION_EOC, simInterface, 0, 0); simDriver->EOC((sim_HW_cb *)(hwCbArray[simInterface])); #ifdef SIM_4_CARD_SMT_TEST /*find out the hooked function table*/ anotherSimDriver = sim_driverTable[anotherSimInterface]; ASSERT(0 != anotherSimDriver); anotherSimDriver->addMessage(SIM_AL_ACTION_RESET, anotherSimInterface, (kal_uint32)kal_get_current_thread_ID(), 0); anotherStatus = anotherSimDriver->reset(UNKNOWN_POWER_CLASS, &anotherResultVolt, warm, (sim_HW_cb *)(hwCbArray[anotherSimInterface])); if(USIM_NO_ERROR == anotherStatus) { #if !defined( __MAUI_BASIC__) tst_sys_trace("another SIM card found!!"); #else dbg_print("another SIM card found!!"); #endif } else { #if !defined( __MAUI_BASIC__) tst_sys_trace("another SIM card not found!!"); #else dbg_print("another SIM card not found!!"); #endif } anotherSimDriver->addMessage(SIM_AL_ACTION_EOC, anotherSimInterface, 0, 0); anotherSimDriver->EOC((sim_HW_cb *)(hwCbArray[anotherSimInterface])); #endif #endif #if defined (LPWR_SLIM) L1SM_SleepEnable(hw_cb->smHandler); //unlock sleep mode #endif return status; }
static S32 mmi_em_profiling_gdi_misc_speed_sw_fill_rect(void *v_param) { static const U32 PROFILING_MS = 4000; gdi_handle layer; S32 i; U32 start_time, duration; mmi_em_profiling_gdi_misc_speec_fill_rect_param *param = (mmi_em_profiling_gdi_misc_speec_fill_rect_param*)v_param; kal_int32 fill_x, fill_y, fill_width, fill_height; gdi_color fill_color; layer = mmi_em_profiling_gdi_create_layer( param->layer.cf, param->layer.x, param->layer.y, param->layer.width, param->layer.height); if (layer == 0) { return -1; } gdi_layer_push_and_set_active(layer); gdi_layer_clear(GDI_COLOR_BLACK); gdi_layer_pop_and_restore_active(); fill_x = param->fill.x; fill_y = param->fill.y; fill_width = param->fill.width; fill_height = param->fill.height; fill_color = gdi_cf_get_color(param->layer.cf, 255, 255, 255, 255); gdi_layer_push_and_set_active(layer); MMI_TRACE(MMI_COMMON_TRC_INFO, TRC_APP_EM_PROFILING_GDI_FRECT_START); start_time = drv_get_current_time(); i = 0; do { do { gdi_draw_solid_rect( fill_x, fill_y, fill_width, fill_height, fill_color); i++; } while ((i & 0xf) != 0); /* Calculate duration every 16 iterations */ duration = drv_get_duration_ms(start_time); } #ifdef __MTK_TARGET__ while (duration < PROFILING_MS); #else while (0); #endif MMI_TRACE(MMI_COMMON_TRC_INFO, TRC_APP_EM_PROFILING_GDI_FRECT_END, param->id, i, duration); gdi_layer_pop_and_restore_active(); gdi_layer_blt( layer, 0, 0, 0, 0, 0, GDI_LCD_WIDTH - 1, GDI_LCD_HEIGHT - 1); mmi_em_profiling_gdi_free_layer(layer); return 0; }
kal_uint32 F32K_Get_FQMTR_DATA_For_EOSC32_Trimming(kal_uint16 eosccal_value, kal_uint16 winset) { kal_uint16 reg_value, reg_xosccal_value; kal_uint32 FQMTR_DATA, wait_count, latency_time_start; DCL_HANDLE rtc_handler; RTC_CTRL_WRITE_OSC32CON_REG_T rtc_osc32_con; reg_xosccal_value = DRV_F32K_Reg(RTC_XOSCCAL); reg_xosccal_value &= ~0x1f; reg_xosccal_value |= eosccal_value; rtc_handler = DclRTC_Open(DCL_RTC, FLAGS_NONE); rtc_osc32_con.OSC32CON_Reg = reg_xosccal_value; DclRTC_Control(rtc_handler, RTC_CMD_WRITE_OSC32CON_REG, (DCL_CTRL_DATA_T *)&rtc_osc32_con); DclRTC_Close(rtc_handler); reg_value = FQMTR_RST; DRV_F32K_WriteReg(FQMTR_CON0, reg_value); // Stop freq-meter /* latency time (of FQMTR_BUSY bit eable) is 2 tick time of fixed clock fixed clock is EOSC32 clock */ latency_time_start = drv_get_current_time(); // 32k clock time tick wait_count = 0; while(wait_count < 0xffffffff) { if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 50) // 25*2 tick break; wait_count++; } #if defined(DRV_F32K_FQMTR_AS_6255) while(DRV_F32K_Reg(FQMTR_CON2) & FQMTR_BUSY); reg_value = FQMTR_EN | winset; DRV_F32K_WriteReg(FQMTR_CON0, reg_value); // start freq-meter #elif defined(DRV_F32K_FQMTR_AS_6250) while(DRV_F32K_Reg(FQMTR_CON0) & FQMTR_BUSY); reg_value = winset; DRV_F32K_WriteReg(FQMTR_CON3, reg_value); // start freq-meter reg_value = FQMTR_EN; DRV_F32K_WriteReg(FQMTR_CON0, reg_value); // start freq-meter #endif /* latency time (of FQMTR_BUSY bit eable) is 2 tick time of fixed clock fixed clock is EOSC32 clock */ latency_time_start = drv_get_current_time(); // 32k clock time tick wait_count = 0; while(wait_count < 0xffffffff) { if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 50) // 25*2 tick break; wait_count++; } #if defined(DRV_F32K_FQMTR_AS_6255) while(DRV_F32K_Reg(FQMTR_CON2) & FQMTR_BUSY); #elif defined(DRV_F32K_FQMTR_AS_6250) while(DRV_F32K_Reg(FQMTR_CON0) & FQMTR_BUSY); #endif /* latency time (of get fqmtr_data ) is 1 tick time of test clock test clock is 13M clock */ latency_time_start = drv_get_current_time(); wait_count = 0; while(wait_count<0xffffffff) { if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 10) // 10 32K tick break; wait_count++; } #if defined(DRV_F32K_FQMTR_AS_6255) //FQMTR_DATA = ((DRV_F32K_Reg(FQMTR_CON3)&0x7fff)<<15)|((DRV_F32K_Reg(FQMTR_CON2)&0x7fff)); FQMTR_DATA = DRV_F32K_Reg(FQMTR_CON2)&0x7fff; #elif defined(DRV_F32K_FQMTR_AS_6250) FQMTR_DATA = DRV_F32K_Reg(FQMTR_CON2); #endif return FQMTR_DATA; }
static void drv_reg_dbg_trace(kal_uint8 write, kal_uint16 line, kal_uint32 addr, kal_uint32 value) { DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].write_flag = write; DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].line_number = line; DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].reg_addr = addr; DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].reg_value = value; DRV_REG_DBG_INFO_DATA.dbg_data[DRV_REG_DBG_INFO_DATA.dbg_data_idx&(MAX_DRV_COMM_REG_DBG_INFO_SIZE - 1)].time_log = drv_get_current_time(); DRV_REG_DBG_INFO_DATA.dbg_data_idx++; }
kal_int32 idp_add_traced_begin(IdpTracedAPI const api) { kal_uint32 savedMask; kal_int32 my_idx; #if defined(ENABLE_LOGGING_FOR_IS_BUSY) kal_int32 my_idx_minus_1; kal_int32 my_idx_minus_2; #endif #if !defined(ENABLE_LOGGING_FOR_IS_BUSY) switch (api) { case IDP_TRACED_API_camera_preview_IS_BUSY: case IDP_TRACED_API_camera_preview_with_face_detection_IS_BUSY: case IDP_TRACED_API_camera_capture_to_jpeg_IS_BUSY: case IDP_TRACED_API_camera_capture_to_mem_IS_BUSY: case IDP_TRACED_API_camera_capture_to_barcode_IS_BUSY: case IDP_TRACED_API_jpeg_decode_IS_BUSY: case IDP_TRACED_API_jpeg_encode_IS_BUSY: case IDP_TRACED_API_jpeg_resize_IS_BUSY: case IDP_TRACED_API_image_resize_IS_BUSY: case IDP_TRACED_API_rgb2yuv_IS_BUSY: case IDP_TRACED_API_video_editor_decode_IS_BUSY: case IDP_TRACED_API_video_editor_encode_IS_BUSY: case IDP_TRACED_API_video_decode_IS_BUSY: case IDP_TRACED_API_video_encode_IS_BUSY: case IDP_TRACED_API_webcam_IS_BUSY: case IDP_TRACED_API_video_call_decode_IS_BUSY: case IDP_TRACED_API_video_call_encode_IS_BUSY: case IDP_TRACED_API_simple_display_with_rotate_IS_BUSY: case IDP_TRACED_API_image_effect_pixel_IS_BUSY: return -1; //break; default: break; } #endif savedMask = SaveAndSetIRQMask(); { my_idx = g_idp_traced_curr_idx; #if defined(ENABLE_LOGGING_FOR_IS_BUSY) // I don't want the same xxx_IS_BUSY fill out of my // g_idp_traced space. switch (my_idx) { case 0: my_idx_minus_1 = (IDP_TRACED_BUFFER_SIZE - 1); my_idx_minus_2 = (IDP_TRACED_BUFFER_SIZE - 2); break; case 1: my_idx_minus_1 = 0; my_idx_minus_2 = (IDP_TRACED_BUFFER_SIZE - 1); break; default: my_idx_minus_1 = (my_idx - 1); my_idx_minus_2 = (my_idx - 2); break; } switch (api) { case IDP_TRACED_API_camera_preview_IS_BUSY: case IDP_TRACED_API_camera_preview_with_face_detection_IS_BUSY: case IDP_TRACED_API_camera_capture_to_jpeg_IS_BUSY: case IDP_TRACED_API_camera_capture_to_mem_IS_BUSY: case IDP_TRACED_API_camera_capture_to_barcode_IS_BUSY: case IDP_TRACED_API_camera_capture_to_ybuffer_IS_BUSY: case IDP_TRACED_API_jpeg_decode_IS_BUSY: case IDP_TRACED_API_jpeg_encode_IS_BUSY: case IDP_TRACED_API_jpeg_resize_IS_BUSY: case IDP_TRACED_API_image_resize_IS_BUSY: case IDP_TRACED_API_rgb2yuv_IS_BUSY: case IDP_TRACED_API_video_editor_decode_IS_BUSY: case IDP_TRACED_API_video_editor_encode_IS_BUSY: case IDP_TRACED_API_video_decode_IS_BUSY: case IDP_TRACED_API_video_encode_IS_BUSY: case IDP_TRACED_API_webcam_IS_BUSY: case IDP_TRACED_API_video_call_decode_IS_BUSY: case IDP_TRACED_API_video_call_encode_IS_BUSY: case IDP_TRACED_API_simple_display_with_rotate_IS_BUSY: case IDP_TRACED_API_image_effect_pixel_IS_BUSY: if ((api == g_idp_traced[my_idx_minus_1].m_api) && (api == g_idp_traced[my_idx_minus_2].m_api)) { RestoreIRQMask(savedMask); return my_idx_minus_1; } break; default: break; } #endif ++g_idp_traced_curr_idx; g_idp_traced_curr_idx &= (IDP_TRACED_BUFFER_SIZE - 1); } RestoreIRQMask(savedMask); g_idp_traced[my_idx].m_api = api; g_idp_traced[my_idx].m_who = kal_get_current_thread_ID(); if (kal_if_hisr()) { g_idp_traced[my_idx].m_call_by_which_level = IDP_CALL_BY_HISR; } else if (kal_if_lisr()) { g_idp_traced[my_idx].m_call_by_which_level = IDP_CALL_BY_LISR; } else { g_idp_traced[my_idx].m_call_by_which_level = IDP_CALL_BY_TASK; } g_idp_traced[my_idx].m_done = KAL_FALSE; g_idp_traced[my_idx].m_start_time_drv = drv_get_current_time(); return my_idx; }
void F32K_Switch_32K_setting(void) { kal_uint16 reg_value, fqmtr_data, f32k_md_status; kal_uint32 wait_count, latency_time_start; // read MD CHIP STATUS register f32k_md_status = DRV_F32K_Reg(F32K_MD_CHIP_STATUS); // init FIXED clock = PAD_32K, TESTED clock= 26MHZ reg_value = FQMTR_FCKSEL_PAD32K | FQMTR_TCKSEL_CLKSSQ26M; DRV_F32K_WriteReg(FQMTR_CON1, reg_value); // reset FQMTR DRV_F32K_WriteReg(FQMTR_CON0, FQMTR_RST); latency_time_start = drv_get_current_time(); // 32k clock time tick wait_count = 0; while(wait_count < 0xffffffff) { if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 50) // 25*2 tick break; wait_count++; } while(DRV_F32K_Reg(FQMTR_CON1) & FQMTR_BUSY); // set WINSET and enable FQMTR reg_value = FQMTR_EN | F32K_FQMTR_WINSET; DRV_F32K_WriteReg(FQMTR_CON0, reg_value); latency_time_start = drv_get_current_time(); // 32k clock time tick wait_count = 0; while(wait_count < 0xffffffff) { if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 50) // 25*2 tick break; wait_count++; } while(DRV_F32K_Reg(FQMTR_CON1) & FQMTR_BUSY); latency_time_start = drv_get_current_time(); wait_count = 0; while(wait_count<0xffffffff) { if (drv_get_duration_tick(latency_time_start, drv_get_current_time()) > 10) // 10 32K tick break; wait_count++; } fqmtr_data = DRV_F32K_Reg(FQMTR_CON3); if ((f32k_md_status & F32K_SYS_PAD32K_BOND_EN) == F32K_SYS_PAD32K_BOND_EN) { if ((FQMTR_PAD32K_LOWER_BOUND < fqmtr_data) && (fqmtr_data < FQMTR_PAD32K_UPPER_BOUND)) { // chip is System pad_32K bonding and PAD_32K exist DRV_F32K_WriteReg32(F32K_AP_F32K_SEL, F32K_AP_PAD32K_CK_EN); } else { // chip is System pad_32K bonding but PAD_32K don't exist ASSERT(0); } } else { if ((FQMTR_PAD32K_LOWER_BOUND < fqmtr_data) && (fqmtr_data < FQMTR_PAD32K_UPPER_BOUND)) { // chip isn't System pad_32K bonding and PAD_32K exist DRV_F32K_WriteReg32(F32K_AP_F32K_SEL, F32K_AP_PAD32K_CK_EN); } } // reset FQMTR to default value DRV_F32K_WriteReg(FQMTR_CON1, FQMTR_CON0_DEFAULT_VAL); DRV_F32K_WriteReg(FQMTR_CON0, FQMTR_CON1_DEFAULT_VAL); }
void lcd_HISR(void) { #if (!defined(MT6205B)&&!defined(MT6208)) kal_uint32 save_irq_mask; kal_uint8 i; volatile kal_uint16 j; #if !defined(DRV_IDP_SUPPORT) #ifdef MT6225_IDP_DEBUG dbg_time3=drv_get_current_time(); kal_prompt_trace(MOD_BMT,"lcd int= %d", dbg_time3); #endif kal_set_eg_events(lcd_event_id,LCD_TRANSFER_COMPLETE_EVENT,KAL_OR); save_irq_mask=SaveAndSetIRQMask(); lcd_transfer_complete=KAL_FALSE; RestoreIRQMask(save_irq_mask); if (bWaitForLCDUpdate==KAL_TRUE) { /* for software udpate only */ bWaitForLCDUpdate=KAL_FALSE; if (main_lcd_operation_state==LCD_SW_UPDATE_STATE) main_lcd_operation_state=LCD_STANDBY_STATE; #ifdef DUAL_LCD if (sub_lcd_operation_state==LCD_SW_UPDATE_STATE) sub_lcd_operation_state=LCD_STANDBY_STATE; #endif config_lcd_layer_window_queue(); if (lcd_prev_run_block_cb!=NULL) lcd_prev_run_block_cb(); } IRQUnmask(IRQ_LCD_CODE); #elif defined(DRV_IDP_SUPPORT) if (current_update_lcd==MAIN_LCD) { if (lcd_transfer_complete==KAL_TRUE) { if ((main_lcd_operation_state==LCD_SW_UPDATE_STATE)|| (main_lcd_operation_state==LCD_WAIT_LAST_UPDATE_STATE)|| (main_lcd_operation_state==LCD_MEM_UPDATE_STATE)) { kal_set_eg_events(lcd_event_id,LCD_TRANSFER_COMPLETE_EVENT,KAL_OR); #ifdef __VIDEO_EDITOR__ /*video editor*/ if(is_video_editor_running()==KAL_TRUE) { video_editor_data_path2(); main_lcd_operation_state=temp_main_lcd_operation_state; } #endif } save_irq_mask=SaveAndSetIRQMask(); lcd_transfer_complete=KAL_FALSE; RestoreIRQMask(save_irq_mask); if (bWaitForLCDUpdate==KAL_TRUE) { /* for software udpate only */ bWaitForLCDUpdate=KAL_FALSE; if (main_lcd_operation_state==LCD_SW_UPDATE_STATE) main_lcd_operation_state=LCD_STANDBY_STATE; config_lcd_layer_window_queue(); if (lcd_prev_run_block_cb!=NULL) lcd_prev_run_block_cb(); } } if (lcd_cmd_latch_complete==KAL_TRUE)/*set TRUE in LCD_LISR*/ { if (lcd_hw_trigger_flag==KAL_TRUE) { #ifdef TV_OUT_SUPPORT if ((tv_output_owner == TV_OUT_OWNER_LCD) && (tv_output_buffer_count<2)) { IRQUnmask(IRQ_LCD_CODE); return; } #endif lcd_hw_trigger_flag=KAL_FALSE; if ((main_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)|| (main_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)||/*back to video size*/ (main_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)|| (main_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)|| (main_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)|| (main_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE)) { for (j=0;j<50;j++); #ifdef TV_OUT_SUPPORT if (tv_output_owner == TV_OUT_OWNER_LCD) { if (tv_out_current_fb==0) lcd_mem_out_address_shadow1=main_lcd_fb_update_para.tv_output_frame_buffer1_address; else lcd_mem_out_address_shadow1=main_lcd_fb_update_para.tv_output_frame_buffer2_address; } #endif DRV_WriteReg32(LCD_ROI_CTRL_REG,lcd_hw_trigger_roi_ctrl); DRV_WriteReg32(LCD_ROI_OFFSET_REG,lcd_hw_trigger_roi_offset); DRV_WriteReg32(LCD_ROI_SIZE_REG,lcd_hw_trigger_roi_size); #ifdef TV_OUT_SUPPORT DRV_WriteReg32(LCD_ROI_WMEM_ADDR_REG,lcd_mem_out_address_shadow1); #endif for (i=0;i<LCD_CMD_QUEUE_LENGTH;i++) *((volatile unsigned int *) (LCD_CMD_PARAMETER_ADDR+(i<<2)))=lcd_hw_trigger_para[i]; #ifdef __SYNC_LCM_SW_SUPPORT__ if ((sync_lcm_enable_mode==KAL_TRUE)&& ((main_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)|| (main_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE))) { kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR); save_irq_mask=SaveAndSetIRQMask(); lcd_cmd_latch_complete=KAL_FALSE; RestoreIRQMask(save_irq_mask); } else { START_LCD_TRANSFER; for (j=0;j<30;j++); } #else START_LCD_TRANSFER; for (j=0;j<30;j++); #endif } else kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR); #ifdef TV_OUT_SUPPORT if (tv_output_owner!=TV_OUT_OWNER_LCD) { DISABLE_LCD_TRANSFER_COMPLETE_INT; } #else DISABLE_LCD_TRANSFER_COMPLETE_INT; #endif } else /*lcd_hw_trigger_flag==KAL_FALSE*/ { if ((main_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)|| (main_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)|| (main_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)|| (main_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)|| (main_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)|| (main_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE)) { kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR); } save_irq_mask=SaveAndSetIRQMask(); lcd_cmd_latch_complete=KAL_FALSE; RestoreIRQMask(save_irq_mask); } } } #ifdef TV_OUT_SUPPORT if (tv_output_buffer_rotate==1) { #if defined(DRV_TVOUT_6228_SERIES) g2d_tv_output_src_buff.base_address=tv_output_buffer_base_address1; g2d_bitblt1(G2D_OWNER_LCD, &g2d_tv_output_bitblt); #elif defined(DRV_TVOUT_6238_SERIES) //KKKKK,OK //not necessary in 6238 because we use IRT3 #endif tv_output_buffer_rotate=0; } else if (tv_output_buffer_rotate==2) { #if defined(DRV_TVOUT_6228_SERIES) g2d_tv_output_src_buff.base_address=tv_output_buffer_base_address2; g2d_bitblt1(G2D_OWNER_LCD,&g2d_tv_output_bitblt); #elif defined(DRV_TVOUT_6238_SERIES) //KKKKK,OK //not necessary in 6238 because we use IRT3 #endif tv_output_buffer_rotate=0; } #endif #ifdef DUAL_LCD/*almost the same as the main LCD part, except TVout.*/ else if (current_update_lcd==SUB_LCD) { if (lcd_transfer_complete==KAL_TRUE) { if ((sub_lcd_operation_state==LCD_SW_UPDATE_STATE)|| (sub_lcd_operation_state==LCD_WAIT_LAST_UPDATE_STATE)) kal_set_eg_events(lcd_event_id,LCD_TRANSFER_COMPLETE_EVENT,KAL_OR); save_irq_mask=SaveAndSetIRQMask(); lcd_transfer_complete=KAL_FALSE; RestoreIRQMask(save_irq_mask); if (bWaitForLCDUpdate==KAL_TRUE) { /* for software udpate only */ bWaitForLCDUpdate=KAL_FALSE; if (sub_lcd_operation_state==LCD_SW_UPDATE_STATE) sub_lcd_operation_state=LCD_STANDBY_STATE; config_lcd_layer_window_queue(); if (lcd_prev_run_block_cb!=NULL) lcd_prev_run_block_cb(); } } if (lcd_cmd_latch_complete==KAL_TRUE) { if (lcd_hw_trigger_flag==KAL_TRUE) { lcd_hw_trigger_flag=KAL_FALSE; if ((sub_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)|| (sub_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)|| (sub_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)|| (sub_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)|| (sub_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)|| (sub_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE)) { for (j=0;j<100;j++); DRV_WriteReg32(LCD_ROI_CTRL_REG,lcd_hw_trigger_roi_ctrl); DRV_WriteReg32(LCD_ROI_OFFSET_REG,lcd_hw_trigger_roi_offset); DRV_WriteReg32(LCD_ROI_SIZE_REG,lcd_hw_trigger_roi_size); for (i=0;i<LCD_CMD_QUEUE_LENGTH;i++) DRV_WriteReg32(LCD_CMD_PARAMETER_ADDR+(i<<2),lcd_hw_trigger_para[i]); #ifdef __SYNC_LCM_SW_SUPPORT__ if ((sync_lcm_enable_mode==KAL_TRUE)&& ((sub_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)|| (sub_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE))) { kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR); save_irq_mask=SaveAndSetIRQMask(); lcd_cmd_latch_complete=KAL_FALSE; RestoreIRQMask(save_irq_mask); } else { START_LCD_TRANSFER; for (j=0;j<30;j++); } #else START_LCD_TRANSFER; for (j=0;j<30;j++); #endif } else kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR); #ifdef TV_OUT_SUPPORT if (tv_output_owner!=TV_OUT_OWNER_LCD) { DISABLE_LCD_TRANSFER_COMPLETE_INT; } #else DISABLE_LCD_TRANSFER_COMPLETE_INT; #endif } else { if ((sub_lcd_operation_state==LCD_HW_CMD_QUEUE_STATE)|| (sub_lcd_operation_state==LCD_DC_CMD_QUEUE_STATE)|| (sub_lcd_operation_state==LCD_HW_UPDATE_SLEEP_STATE)|| (sub_lcd_operation_state==LCD_DC_UPDATE_SLEEP_STATE)|| (sub_lcd_operation_state==LCD_HW_SLEEP_CMD_QUEUE_STATE)|| (sub_lcd_operation_state==LCD_DC_SLEEP_CMD_QUEUE_STATE)) kal_set_eg_events(lcd_event_id,LCD_CMD_COMPLETE_EVENT,KAL_OR); save_irq_mask=SaveAndSetIRQMask(); lcd_cmd_latch_complete=KAL_FALSE; RestoreIRQMask(save_irq_mask); } } } #endif /* DUAL_LCD */ IRQUnmask(IRQ_LCD_CODE); #endif /* MT6219 */ #endif /* MT6219 */ } /* lcd_HISR() */
kal_uint16 ADC_GetData(kal_uint8 sel) { #if defined(DRV_ADC_NOT_EXIST) return 0; #endif // #if defined(DRV_ADC_NOT_EXIST) #ifndef DRV_ADC_NOT_EXIST #if defined(DRV_ADC_MODEM_SIDE) kal_uint32 saved_current_time = 0; #endif kal_uint16 data; #if !defined(ADC_REMOVE_IRQMASK) kal_uint32 savedMask; #endif //#if !defined(ADC_REMOVE_IRQMASK) #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA) kal_uint32 savedMask2; #endif // #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA) adc_channel_number_check(sel); #if defined(DRV_ADC_NO_IMM) || defined(FPGA) ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask(); adc_pwrdown_disable(); #ifndef DRV_ADC_MODEM_SIDE DRV_ADC_WriteReg(AUXADC_CTRL,sel); #endif // #ifndef DRV_ADC_MODEM_SIDE adc_imm_mode_cnt++; ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask); while(!(DRV_ADC_Reg(AUXADC_STAT) & AUXADC_STAT_RDY)); data = DRV_ADC_Reg(AUXADC_DATA); #endif /*(DRV_ADC_NO_IMM,FPGA)*/ #if defined(DRV_ADC_IMM) ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask(); adc_imm_mode_cnt++; adcsche_adc_measure_en(KAL_TRUE); ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask); #if defined(__DRV_ADC_PMIC_TURN_ON_MEASURE_DELAY__) if((ADC_VBAT == sel) || (ADC_VISENSE == sel) || (ADC_VCHARGER == sel)) { kal_sleep_task(1); //delay 2 frames for HEPHAESTUS68 need delay to measure } #endif //#if defined(__DRV_ADC_PMIC_TURN_ON_MEASURE_DELAY__) ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask(); adc_pwrdown_disable(); #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA) { savedMask2 = SaveAndSetIRQMask(); } #endif // #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA) #if defined(DRV_ADC_VCHARGER_EXTEND_READING) if(ADC_VCHARGER == sel) { DRV_ADC_SetBits(MIX_ABB_base + 0x0b00,0x01f0); //extend to MAX ticks while reading } #endif #ifdef DRV_ADC_SET_CLR DRV_ADC_SetBits(AUXADC_CON1_CLR, (1<<sel)); DRV_ADC_SetBits(AUXADC_CON1_SET, (1<<sel)); #else DRV_ADC_WriteReg(AUXADC_IMM, 0); adc_dummy_read(); //DRV_ADC_Reg(AUXADC_IMM) = 0; DRV_ADC_SetBits(AUXADC_IMM, (1<<sel)); //DRV_ADC_Reg(AUXADC_IMM) |= (1<<sel); #endif ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask); #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA) { volatile kal_uint32 tmp_32; for (tmp_32=20;tmp_32!=0;tmp_32--){ ; } } #endif // #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA) #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA) { RestoreIRQMask(savedMask2); } #endif // #if defined(DRV_MT6268A_ADC_TP_MIXED_ISSUE_WA) #if !defined(DRV_MISC_IGNORE_ADC_RUN_STATUS_CHECK) #if defined(DRV_ADC_MODEM_SIDE) { kal_uint32 i; for(i=100;i!=0;i--); while((DRV_ADC_Reg(AUXADC_DAT(sel)) & 0x1000) == 0x1000); } #else adc_check_busy_bit(); #endif #endif // #if !defined(DRV_MISC_IGNORE_ADC_RUN_STATUS_CHECK) data = (DRV_ADC_Reg(AUXADC_DAT(sel)) & 0x0FFF); #if defined(DRV_ADC_MODEM_SIDE) saved_current_time = drv_get_current_time(); while(drv_get_duration_tick(saved_current_time, drv_get_current_time()) <= 2) // 64us { ;// Polling 32K reference clock } #endif #endif /*DRV_ADC_IMM*/ ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask(); adc_imm_mode_cnt--; if ((((kal_uint16)adc_imm_mode_cnt) == 0) && (((kal_bool)adc_sync_mode_on) == KAL_FALSE)) { adc_pwrdown_enable(); } ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask); ADCSAVEANDSETIRQMASK(savedMask); //savedMask = SaveAndSetIRQMask(); if ((((kal_uint16)adc_imm_mode_cnt) == 0) && (((kal_bool)adc_sync_mode_on) == KAL_FALSE)) { #if !defined(DRV_ADC_MODEM_SIDE) //don't write pmu bit to 0 adcsche_adc_measure_en(KAL_FALSE); #endif } ADCRESTOREIRQMASK(savedMask); //RestoreIRQMask(savedMask); return data; #endif // #ifndef DRV_ADC_NOT_EXIST }
U32 OS_GetSystemTime(void) { return drv_get_current_time(); }
/* DMA callback function for TX sent out data */ static void USB2UART_Tx_DMA_Callback(void) { kal_uint32 savedMask; kal_uint8 ep_num = 0; kal_bool setup_dma = KAL_FALSE; kal_bool b_force_isr_buffer = KAL_FALSE; if(USB2UARTPort.ownerid != MOD_TST_READER) { drv_trace1(TRACE_FUNC, USBACM_DMA_CALLBACK, USB2Uart_WriteLength); // kal_prompt_trace(MOD_USB, "DMA %d", USB2Uart_WriteLength); } /* tx complete callback*/ USB2UARTPort.tx_cb(uart_port_usb); #if 0 /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ #endif /*update read pointer for previously sent out buffer */ savedMask = SaveAndSetIRQMask(); USB2UART_Update_Transmit_Data(); RestoreIRQMask(savedMask); /* USB2Uart_MemType and USB2Uart_WriteLength are updated, so clear dma running state here*/ g_UsbACM.setup_dma = KAL_FALSE; // USB_DMA_Set_Run_Status(g_UsbACM.txpipe->byEP, KAL_FALSE); if(USB2UARTPort.Tx_Buffer_ISR.Read == USB2UARTPort.Tx_Buffer_ISR.Write) { /* no more data to send */ if(USB2UARTPort.Tx_Buffer.Read == USB2UARTPort.Tx_Buffer.Write) return; } /* must send ISR buffer again */ else if(USB2Uart_MemType == USBTRX_MEM_ISR) { b_force_isr_buffer = KAL_TRUE; } /* send data again in TX buffer or TXISR buffer */ savedMask = SaveAndSetIRQMask(); /* in case usb is plugged out just before this critical section */ if(gUsbDevice.device_type == USB_CDC_ACM) { // if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE) if(g_UsbACM.setup_dma == KAL_FALSE) { g_UsbACM.setup_dma = KAL_TRUE; setup_dma = KAL_TRUE; ep_num = g_UsbACM.txpipe->byEP; } } RestoreIRQMask(savedMask); if(setup_dma == KAL_TRUE) { USB_Dbg_Trace(USB_ACM_DMA_CALLBACK, drv_get_current_time(), ep_num, 0); USB2UART_DMATransmit(ep_num, b_force_isr_buffer); } // savedMask = SaveAndSetIRQMask(); /* in case usb is plugged out just before this critical section*/ // if(gUsbDevice.device_type == USB_CDC_ACM) // { // if(USB_DMA_Get_Run_Status(g_UsbACM.txpipe->byEP) == KAL_FALSE) // { // USB2UART_DMATransmit(g_UsbACM.txpipe->byEP); // } // } // RestoreIRQMask(savedMask); }
MM_ERROR_CODE_ENUM FdCtrl(PP_SCENARIO_ENUM ScenarioId, PP_SCENARIO_CTRL_ENUM CtrlCode, void* pParaIn, void* pParaOut,kal_uint16 ParaOutLen) { #ifdef FD_LOG_DEBUG_INFO kal_uint32 t1,mem_time, total_fdvt_time, period_time; #endif kal_uint32 t0; FD_PROCESS_IN_STRUCT FdProcIn ; // P_FD_PROC_PARA_IN_STRUCT pFdParaIn = (P_FD_PROC_PARA_IN_STRUCT )pParaIn; P_FD_RESULT_STRUCT pFdParaOut = &gFdResult; UTL_SWITCH_CACHE_STRUCT MemSwitch; UTL_BILINEAR_RESIZER_STRUCT UtlRisizerInfo; ASSERT(gFdState!=FD_IDLE_STATE); if(PP_CTRL_CODE_START == CtrlCode) { t0 = drv_get_current_time(); #ifdef FD_LOG_DEBUG_INFO period_time = drv_get_duration_ms(gFdStartTime); gFdStartTime = drv_get_current_time(); t1 = gFdStartTime; #endif /*-------------- MEM--------------*/ gFdState = FD_MEM_PROCESS_STATE; #if 0 /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ /* under construction !*/ #endif // copy source image form MDP to FD working memory if(PP_MEM_OP_COPY_TO_PROC_BUF == gFdSetMemInfo.PpMemOpType) { kal_mem_cpy((kal_uint8*)(gFdSetMemInfo.PpProcBufAddr), (kal_uint8*)gFdSetMemInfo.PpSrcBufAddr, gFdSetMemInfo.PpSrcBufSize); } else if(PP_MEM_OP_RESIZE_TO_PROC_BUF== gFdSetMemInfo.PpMemOpType) { UtlRisizerInfo.srcAddr = (kal_uint16*) gFdSetMemInfo.PpSrcBufAddr; UtlRisizerInfo.srcWidth= gSrcImageWidth; UtlRisizerInfo.srcHeight= gSrcImageHeight; UtlRisizerInfo.dstAddr = (kal_uint16*) gFdSetMemInfo.PpProcBufAddr; UtlRisizerInfo.dstWidth = gDstImageWidth; UtlRisizerInfo.dstHeight = gDstImageHeight; UtlBilinearResizer(&UtlRisizerInfo); } else { return MM_ERROR_INVALID_PARAMETER; } #ifdef FD_LOG_DEBUG_INFO mem_time = drv_get_duration_ms(t1); t1 = drv_get_current_time(); #endif /*-------------- FD --------------*/ gFdState = FD_PROCESS_STATE; kal_mem_set(pFdParaOut, 0, sizeof(FD_RESULT_STRUCT)); FdProcIn.OperationMode= FD_FDVT_MODE; FdCoreMain(&FdProcIn,pFdParaOut); /* add fd processing counter for facial AF usage */ gFdProcessCounter++; if(gFdProcessCounter>=255) { gFdProcessCounter=0; } pFdParaOut->result_counter = gFdProcessCounter; pFdParaOut->fd_start_time= t0; pFdParaOut->fd_end_time= drv_get_current_time(); //cached memory -> non-cachecd memory MemSwitch.pMemAddr=&gFdSetMemInfo.PpProcBufAddr; MemSwitch.Size=(kal_uint32) (FD_BUFFER_SIZE); MemSwitch.CacheableFlag=KAL_FALSE; UtlFeatureCtrl(UTL_FEATURE_EXT_MEM_SWITCH_CACHE,&MemSwitch,NULL,NULL); // cb to cal pfPpFdCb(PP_CBID_FD_RESULT, pFdParaOut, sizeof(FD_RESULT_STRUCT)); /*-------------- Save Log --------------*/ #if (defined(FD_LOG_DEBUG_INFO)) total_fdvt_time = drv_get_duration_ms(t1); gFdFileCount++; FdCoreSaveLog(gFdLogBuff); gFdLogBuff->version = FDVT_VERSION; gFdLogBuff->frame_idx = gFdFileCount; gFdLogBuff->mem_time = mem_time; gFdLogBuff->total_fdvt_time = total_fdvt_time; gFdLogBuff->fdvt_period_time = period_time; if (gFdFileCount>gFdFileCountMax) { gFdFileCount = 0; } FdSaveLog(gFdFileCount); #endif gFdState = FD_READY_STATE; } else if (PP_CTRL_CODE_RESET == CtrlCode) { FdCoreReset(); } return MM_ERROR_NONE; } /* FdControl() */