UINT32 MCI_PlayBTStream (bt_a2dp_audio_cap_struct *audio_cap) { INT32 result=0; mci_type_enum mediaType; hal_HstSendEvent(SYS_EVENT,0x10250010); hal_HstSendEvent(SYS_EVENT,audio_cap); hal_HstSendEvent(SYS_EVENT,audio_cap->codec_type); csw_SetResourceActivity(CSW_LP_RESOURCE_AUDIO_PLAYER, CSW_SYS_FREQ_104M); if(audio_cap->codec_type == AVDTP_MEDIA_CODEC_SBC) mediaType = MCI_TYPE_SBC; else if(audio_cap->codec_type == AVDTP_MEDIA_CODEC_MPEG1_2_AUDIO ) mediaType = MCI_TYPE_DAF; else if(audio_cap->codec_type == AVDTP_MEDIA_CODEC_MPEG2_4_AAC) mediaType = MCI_TYPE_AAC; else return MCI_ERR_BAD_FORMAT; g_mciAudioFinishedCallback=NULL; MCI_BTAudioCap = audio_cap; MCI_Play_BTStream = 1; MCI_Play_Stream_Buffer = 0; result = LILY_AudioPlay(0, 0,mediaType, 0); hal_HstSendEvent(SYS_EVENT,0x10250100); hal_HstSendEvent(SYS_EVENT,result); return result; }
PRIVATE VOID camerap_InteruptHandler(HAL_CAMERA_IRQ_CAUSE_T cause) { HAL_CAMERA_IRQ_CAUSE_T mask = {0,0,0,0}; hal_HstSendEvent(0x01); hal_HstSendEvent(hal_TimGetUpTime()); switch (gSensorInfo.cammode) { case CAM_MODE_PREP_IMG_CAPTURE: gIfcChan = hal_CameraStartXfer((gSensorInfo.npixels*2), (UINT8*)gSensorInfo.vidbuffer); //mask.vsync = 1; mask.fend = 1; hal_CameraIrqSetMask(mask); gSensorInfo.cammode = CAM_MODE_IMG_CAPTURE; gIsCameraStartXfer = TRUE; break; case CAM_MODE_IMG_CAPTURE: hal_CameraIrqSetMask(mask); gSensorInfo.cammode = CAM_MODE_IDLE; if(hal_CameraStopXfer(FALSE)==XFER_SUCCESS) { gSensorInfo.camirqhandler(0, gSensorInfo.currentbuf); } else { gSensorInfo.camirqhandler(1, gSensorInfo.currentbuf); } gIsCameraStartXfer = FALSE; break; default: gSensorInfo.camirqhandler(255, 255); break; } }
UINT32 MCI_StartBTSCO (UINT16 handle) { INT32 result=0; mci_type_enum mediaType = MCI_TYPE_SCO; MCI_Play_BTStream = 1; MCI_Play_Stream_Buffer = 0; result = LILY_AudioPlay(0, handle,mediaType, 0); hal_HstSendEvent(SYS_EVENT,0x10270100); hal_HstSendEvent(SYS_EVENT,result); return result; }
/******************************************************************************** * Description : Set the selected location which is specified by location. * * Arguments : * location: store drive name, path name, file name. * Returns : * TRUE: Successful * FALSE: Fail, detail information in fselError * Notes : Should select path in the case of only file name is invalid * ********************************************************************************/ UINT8 fselSetLocationC(file_location_t *location) { TCHAR name[12]; UINT32 entry; INT32 ret; fselFileNo = 0; fselError = 0; fselTotal = 0; fselDiskLetter = location->disk; FS_GetShortName(location->subdir_entry, name); if(strcmp(name, location->subdir_name) != 0) { fselError = FSEL_ERR_SETDIR; return FALSE; } FS_ChangeSubDir(location->subdir_entry); if(location->file_entry != 0) { FS_GetShortName(location->file_entry, name); //modify by wuxiang //扩展名大小写会导致比较出问题,在此修改成不区分大小写的比较函数 //if(strcmp(name, location->file_name) == 0) //modify end if(strnicmp(name, location->file_name, strlen(name)) == 0) { FS_SetCurDirEntry(location->file_entry); hal_HstSendEvent(SYS_EVENT, 0x19191919); } else { location->file_entry = 0; } } fselFileNo = 0; fselTotal = 0; ret = FS_GetNextEntry(&entry, GetExtBuf(), FS_DIR_FILE); while(ret == ERR_SUCCESS) { fselTotal ++; if(entry == location->file_entry) { fselFileNo = fselTotal; } ret = FS_GetNextEntry(&entry, GetExtBuf(), FS_DIR_FILE_CONT); } FS_SetCurDirEntry(location->file_entry); return TRUE; }
/********************************************************************************* * Description : 注册功能模块函数,提供外部调用 * * Arguments : * * Returns : * * Notes : * *********************************************************************************/ INT32 APP_ModCall(UINT8 mod, INT32 Param) { hal_HstSendEvent(SYS_EVENT, 0x10140000 + mod); g_current_module = mod; if((mod < MAX_FUNCTION_MOD) && (currModFuncPtrs[mod] != NULL)) { return currModFuncPtrs[mod](Param); } return -1; }
// ============================================================================= // memd_RamOpen // ----------------------------------------------------------------------------- /// That function configures the RAM. /// It must be called to configure the best settings for the RAM, thus enabling /// the fatest access. /// @param cfg Ram configuration used to open the RAM. /// // ============================================================================= PUBLIC VOID memd_RamOpen(CONST MEMD_RAM_CONFIG_T* cfg) { hal_HstSendEvent(0x854321); #ifdef MEMD_RAM_IS_BURST hal_EbcSramOpen(&cfg->csConfig, memd_RamConfigureBurstMode); #else //!MEMD_RAM_IS_BURST // Open External SRAM hal_EbcCsOpen(HAL_EBC_SRAM, &cfg->csConfig); #endif //!MEMD_RAM_IS_BURST }
PRIVATE BOOL lcddp_CheckProductId() { UINT16 productId=0; LCDD_CONFIG_T lcddReadConfig=LCDD_READ_CONFIG; hal_GoudaOpen(&lcddReadConfig.config, lcddReadConfig.timings, 0); sxr_Sleep(20 MS_WAITING); hal_GoudaReadReg(0x93, &productId); hal_GoudaClose(); SXS_TRACE(TSTDOUT, "hx8340b(0x%x): lcd read id is 0x%x ", LCD_HX8340B_ID, productId); hal_HstSendEvent(0x1cd00004); hal_HstSendEvent(productId); if(productId == LCD_HX8340B_ID) return TRUE; else return FALSE; }
PRIVATE BOOL lcddp_CheckProductId() { UINT16 productId=0; LCDD_CONFIG_T lcddReadConfig=LCDD_READ_CONFIG; hal_GoudaOpen(&lcddReadConfig.config, lcddReadConfig.timings, 0); sxr_Sleep(20 MS_WAITING); hal_GoudaReadReg(0xda, &productId); #if 0 hal_HstSendEvent(0xff9163C1); hal_HstSendEvent((UINT32)productId); hal_HstSendEvent(0xff9163C1); #endif hal_GoudaReadData(&productId); #if 0 hal_HstSendEvent(0xff9163C2); hal_HstSendEvent((UINT32)productId); hal_HstSendEvent(0xff9163C2); #endif hal_GoudaClose(); SXS_TRACE(TSTDOUT, "ili9163c(0x%x): lcd read id is 0x%x ", LCD_ILI9163C_ID, productId); if(productId == LCD_ILI9163C_ID) return TRUE; else return FALSE; }
void Rdabt_trap_write_r18(void) { // extern BOOL g_CalbClock; int32 i; #if 0 if(g_CalbClock) { hal_HstSendEvent(1, 0x88888888); for(i=0;i<sizeof(rda_trap_calib_18)/sizeof(rda_trap_calib_18[0]);i++) { rdabt_wirte_memory(rda_trap_calib_18[i][0],&rda_trap_calib_18[i][1],1,0x0); RDABT_DELAY(1); } } else #endif { for(i=0;i<sizeof(rda_trap_18)/sizeof(rda_trap_18[0]);i++) { rdabt_wirte_memory(rda_trap_18[i][0],&rda_trap_18[i][1],1,0); RDABT_DELAY(1); } #if 0 rdabt_adp_uart_stop(); rdabt_adp_uart_start(); rdabt_adp_uart_configure(115200,FALSE); rdabt_uart_register_cb(); rdabt_baudrate_ctrl(); RDABT_DELAY(100); for(i=0;i<sizeof(rda_trap_18_2)/sizeof(rda_trap_18_2[0]);i++) { rdabt_wirte_memory(rda_trap_18_2[i][0],&rda_trap_18_2[i][1],1,0); RDABT_DELAY(1); } #endif } }
// ============================================================================= // memd_FlashOpen // ----------------------------------------------------------------------------- /// That function configures the flash. /// It must be called before using any other function of the MEMD API. /// /// @param cfg Pointer to the configuration to use to open the flash. /// This parameter is ignored by the romulator driver. /// @return Pointer towards the structure describing the flash. // ============================================================================= PUBLIC MEMD_FLASH_LAYOUT_T* memd_FlashOpen(CONST MEMD_FLASH_CONFIG_T* cfg) { MEMD_ASSERT(cfg != NULL, "Opening flash with a NULL configuration"); // Open EBC ? (not needed with new hardware, as the only option // is enable ... hal_HstSendEvent(0x54388); // Open Flash, and store base address. #ifdef MEMD_FLASH_IS_BURST g_memdFlashBaseAddress = (UINT32) hal_EbcFlashOpen(HAL_SYS_FREQ_13M, &cfg->csConfig, memd_FlashConfigureBurstMode); #else //!MEMD_FLASH_IS_BURST #ifdef MEMD_RAM_IS_BURST g_memdFlashBaseAddress = (UINT32) hal_EbcFlashOpen(HAL_SYS_FREQ_13M, &cfg->csConfig, NULL); #else //!MEMD_RAM_IS_BURST g_memdFlashBaseAddress = (UINT32) hal_EbcFlashOpen(HAL_SYS_FREQ_39M, &cfg->csConfig, NULL); #endif //!MEMD_RAM_IS_BURST #endif //!MEMD_FLASH_IS_BURST return ((MEMD_FLASH_LAYOUT_T*) &g_memdFlashLayout); }
uint32 ScsiReadCapacity(PSCSI_DEVICE pDevice, PDISK_INFO pDiskInfo, uint8 Lun) { TRANSPORT_COMMAND tCommand; uint8 bCDB[MAX_CDB]; TRANSPORT_DATA tData; uint8 bDataBlock[8]; uint32 dwSizeDB = sizeof(bDataBlock); uint32 dwSizeDI = sizeof(DISK_INFO); uint32 dwErr = ERROR_SUCCESS; memset(pDiskInfo, 0, dwSizeDI); tCommand.Flags = DATA_IN; tCommand.Timeout = pDevice->Timeouts.ScsiCommandTimeout; tCommand.Length = USBMSC_SUBCLASS_SCSI == pDevice->DiskSubClass ?SCSI_CDB_10 : UFI_CDB; tCommand.CommandBlock = bCDB; tCommand.dwLun=Lun; memset( bCDB, 0, sizeof(bCDB)); bCDB[0] = SCSI_READ_CAPACITY; ASSERT(Lun <= 0x7); bCDB[1] = ((Lun & 0x7) << 5); // PMI & LBA support is TBD // It's useful in determining where longer access times occur memset( bDataBlock, 0, dwSizeDB); tData.TransferLength = 0; tData.RequestLength = dwSizeDB; tData.DataBlock = bDataBlock; dwErr = UsbsDataTransfer(pDevice->hUsbTransport, &tCommand, &tData ); if ( dwErr != ERROR_SUCCESS ||(tData.TransferLength != tData.RequestLength) ) { dwErr = ScsiGetSenseData( pDevice, Lun ); } else { hal_HstSendEvent(SYS_EVENT,0x09100010); //memcpy(bDataBlock, bDataBlock, sizeof(bDataBlock)); // Get total sectors from Last Logical Block Address pDiskInfo->di_total_sectors = GetDWORD(&bDataBlock[0])+1; // Block Length in bytes pDiskInfo->di_bytes_per_sect = GetDWORD(&bDataBlock[4]); pDiskInfo->di_flags |= DISK_INFO_FLAG_PAGEABLE | DISK_INFO_FLAG_CHS_UNCERTAIN; if ( pDiskInfo->di_bytes_per_sect && pDiskInfo->di_total_sectors) { // update our media info & flags pDevice->Flags.MediumPresent = TRUE; if ( 0 != memcmp(&pDevice->DiskInfo, pDiskInfo, dwSizeDI) ) { memcpy(&pDevice->DiskInfo, pDiskInfo, dwSizeDI); } } } //sxr_Free(pDataBlock); return dwErr; }
UINT16 put_data_to_CircularBuffer(struct CircularBuf *pCirBuff, UINT8 *pBuff,UINT16 uDataSize) { UINT16 Block_Len, Remain_Len, real_Len, First_half, Second_half; UINT32 status = hal_SysEnterCriticalSection(); // do thing with uart breakint not happen Block_Len = GET_DATA_BLOCK_LEN(pCirBuff->Get, pCirBuff->Put, pCirBuff->Buf_len); if ((Block_Len == 0) && (pCirBuff->NotEmpty)) { Block_Len = pCirBuff->Buf_len; } Remain_Len = pCirBuff->Buf_len - Block_Len; /*hal_HstSendEvent(SYS_EVENT, 0x07280100); hal_HstSendEvent(SYS_EVENT, Remain_Len); hal_HstSendEvent(SYS_EVENT, uDataSize);*/ if(Remain_Len==0) { hal_HstSendEvent(SYS_EVENT, 0x01010000); hal_DbgAssert("%s buffer overflow, Remain_Len=0!!",pCirBuff->Name); return 0; } if (uDataSize > Remain_Len) { hal_DbgAssert("%s buffer overflow!! uDataSize=%d, Remain_Len=%d",pCirBuff->Name,uDataSize,Remain_Len); return 0; } real_Len = uDataSize;// (uDataSize < Remain_Len) ? uDataSize : Remain_Len; if (real_Len > 0)/*circular buffer not full*/ { if (pCirBuff->Put < pCirBuff->Get) { memcpy(&pCirBuff->Buf[pCirBuff->Put], pBuff, real_Len); pCirBuff->Put = MOD_BUFF_LEN(pCirBuff->Put + real_Len,pCirBuff->Buf_len); } else { First_half = pCirBuff->Buf_len - pCirBuff->Put; if (real_Len < First_half) { memcpy(&pCirBuff->Buf[pCirBuff->Put], pBuff, real_Len); pCirBuff->Put = MOD_BUFF_LEN(pCirBuff->Put + real_Len, pCirBuff->Buf_len); } else { memcpy(&pCirBuff->Buf[pCirBuff->Put], pBuff , First_half); Second_half = real_Len - First_half; pCirBuff->Put = MOD_BUFF_LEN((pCirBuff->Put + First_half),pCirBuff->Buf_len); memcpy(&pCirBuff->Buf[pCirBuff->Put], &pBuff[First_half], Second_half); pCirBuff->Put = MOD_BUFF_LEN((pCirBuff->Put + Second_half),pCirBuff->Buf_len); } } pCirBuff->NotEmpty = 1; } else { SXS_TRACE(TSTDOUT,"warning put len %x",real_Len); } hal_SysExitCriticalSection(status); return Remain_Len -real_Len; }
// ============================================================================ // lcddp_Blit16 // ---------------------------------------------------------------------------- /// This function provides the basic bit-block transfer capabilities. /// This function copies the data (such as characters/bmp) on the LCD directly /// as a (rectangular) block. The data is drawn in the active window. /// The buffer has to be properly aligned (@todo define properly 'properly') /// /// @param pPixelData Pointer to the buffer holding the data to be displayed /// as a block. The dimension of this block are the one of the #pDestRect /// parameter /// @return #LCDD_ERR_NO, #LCDD_ERR_RESOURCE_BUSY or #LCDD_ERR_NOT_OPENED. // ============================================================================ PRIVATE LCDD_ERR_T lcddp_Blit16(CONST LCDD_FBW_T* frameBufferWin, UINT16 startX, UINT16 startY) { LCDD_ASSERT((frameBufferWin->fb.width&1) == 0, "LCDD: FBW must have an even number " "of pixels per line. Odd support is possible at the price of a huge " "performance lost"); // Active window coordinates. HAL_GOUDA_WINDOW_T inputWin; HAL_GOUDA_WINDOW_T activeWin; hal_HstSendEvent(0x88855516); UINT32 now = hal_TimGetUpTime(); if (0 == lcdd_MutexGet()) { return LCDD_ERR_RESOURCE_BUSY; } else { if (g_lcddInSleep) { lcdd_MutexFree(); return LCDD_ERR_NO; } // Set Input window inputWin.tlPX = frameBufferWin->roi.x; inputWin.brPX = frameBufferWin->roi.x + frameBufferWin->roi.width - 1; inputWin.tlPY = frameBufferWin->roi.y; inputWin.brPY = frameBufferWin->roi.y + frameBufferWin->roi.height - 1; // Set Active window activeWin.tlPX = startX; activeWin.brPX = startX + frameBufferWin->roi.width - 1; activeWin.tlPY = startY; activeWin.brPY = startY + frameBufferWin->roi.height - 1; // Check parameters // ROI must be within the screen boundary // ROI must be within the Frame buffer // Color format must be 16 bits BOOL badParam = FALSE; if (g_lcddRotate) { if ( (activeWin.tlPX >= LCDD_DISP_Y) || (activeWin.brPX >= LCDD_DISP_Y) || (activeWin.tlPY >= LCDD_DISP_X) || (activeWin.brPY >= LCDD_DISP_X) ) { badParam = TRUE; } } else { if ( (activeWin.tlPX >= LCDD_DISP_X) || (activeWin.brPX >= LCDD_DISP_X) || (activeWin.tlPY >= LCDD_DISP_Y) || (activeWin.brPY >= LCDD_DISP_Y) ) { badParam = TRUE; } } if (!badParam) { if ( (frameBufferWin->roi.width > frameBufferWin->fb.width) || (frameBufferWin->roi.height > frameBufferWin->fb.height) || (frameBufferWin->fb.colorFormat != LCDD_COLOR_FORMAT_RGB_565) ) { badParam = TRUE;; } } if (badParam) { lcdd_MutexFree(); return LCDD_ERR_INVALID_PARAMETER; } // this will allow to keep LCDD interface for blit while using gouda // directly for configuring layers if (frameBufferWin->fb.buffer != NULL) { g_lcddAutoCloseLayer = FALSE; WriteCommand_Addr(0x2a);WriteCommand_Data(0x00);WriteCommand_Data(activeWin.tlPX); WriteCommand_Data(0x00);WriteCommand_Data(activeWin.brPX); WriteCommand_Addr(0x2b);WriteCommand_Data(0x00);WriteCommand_Data(activeWin.tlPY ); WriteCommand_Data(0x00);WriteCommand_Data(activeWin.brPY); #if 0 LCM_WR_REG(0x0002,(hsa>>8)&0x00ff); // Column address start2 LCM_WR_REG(0x0003,hsa&0x00ff); // Column address start1 LCM_WR_REG(0x0004,(hea>>8)&0x00ff); // Column address end2 LCM_WR_REG(0x0005,hea&0x00ff); // Column address end1 LCM_WR_REG(0x0006,(vsa>>8)&0x00ff); // Row address start2 LCM_WR_REG(0x0007,vsa&0x00ff); // Row address start1 LCM_WR_REG(0x0008,(vea>>8)&0x00ff); // Row address end2 LCM_WR_REG(0x0009,vea&0x00ff); // Row address end1 #endif WriteCommand_Addr(0x2c); hal_GpioSet(g_slcd_a0); } if (frameBufferWin->roi.width == frameBufferWin->fb.width) { // The source buffer and the roi have the same width, we can // do a single linear transfer lcdd_TransferData(frameBufferWin->fb.buffer+frameBufferWin->roi.y*frameBufferWin->roi.width ,frameBufferWin->roi.width*frameBufferWin->roi.height,TRUE); hal_HstSendEvent(0x88855528); } else { // The source buffer is wider than the roi // we have to do a 2D transfer UINT16 curLine=0; UINT16 startLine = frameBufferWin->roi.y; UINT16 endLine = frameBufferWin->roi.y+frameBufferWin->roi.height-1; // Start at the base of the buffer // add the number of pixels corresponding to the start line // add the number of pixel corresponding to the startx UINT16* curBuf = frameBufferWin->fb.buffer +(frameBufferWin->roi.y*frameBufferWin->fb.width) +(frameBufferWin->roi.x); for (curLine=startLine; curLine<=endLine; curLine++) { // transfer one line if (curLine == endLine) { lcdd_TransferData(curBuf, frameBufferWin->roi.width, TRUE);hal_HstSendEvent(0x88855521); } else { lcdd_TransferData(curBuf, frameBufferWin->roi.width, FALSE); } // goto next line curBuf+=frameBufferWin->fb.width; } } UINT32 now2 = hal_TimGetUpTime(); SXS_TRACE(TSTDOUT, "lcd speed on frame %d ms ",(now2-now)*1000/16384); return LCDD_ERR_NO; }
/********************************************************************************* * Description : 初始化系统设置变量 * * Arguments : * * Returns : * * Notes : * *********************************************************************************/ void APP_ReadComPara(void) { //DSM_ReadUserData(); //NVRAMRead(g_comval, VM_SYSTEM, sizeof(g_comval)); g_comval = (comval_t*)NVRAMGetData(VM_SYSTEM, sizeof(comval_t)); hal_HstSendEvent(SYS_EVENT, 0x19880900); if(g_comval->magic != MAGIC_COMVAL) { hal_HstSendEvent(SYS_EVENT, 0x19880901); if(!LoadFactorySetting(g_comval, sizeof(g_comval))) { g_comval->DisplayContrast = 5; g_comval->langid = GUI_LANG_SM_CHINESE; g_comval->LightTime = 3; //g_comval->ReplayMode = 0; //g_comval->SleepTime = 0; g_comval->StandbyTime = 30; //g_comval->BatteryType = BATT_TYPE_ALKALINE; //g_comval->FMBuildInFlag = 0; //g_comval->RecordType = 0; //g_comval->BLightColor = 3; g_comval->BackLight = 5; g_comval->Volume = 8; // default volume g_comval->music_cfg.loop_mode = 0; g_comval->music_cfg.eq_mode = 0; g_comval->music_cfg.repeat_count = 3; g_comval->music_cfg.repeat_time = 30; #if APP_SUPPORT_FM==1 /*Surport fm*/ g_comval->fm_value.fm_band = 0; g_comval->fm_value.fm_sendfreq = 1000; #endif } hal_HstSendEvent(SYS_EVENT, 0x19880902); g_comval->magic = MAGIC_COMVAL; // no need save data //NVRAMWrite(g_comval, VM_SYSTEM,sizeof(g_comval)); //g_test_mode = 1; } if(!ReadConfigData(&g_sysconfig, CFG_SYSTEM, sizeof(g_sysconfig))) { g_sysconfig.AppSupportFlag = AP_SUPPORT_RECORD | (AP_SUPPORT_FM * APP_SUPPORT_FM) | (AP_SUPPORT_FMREC * APP_SUPPORT_FM_RECORD) | (AP_SUPPORT_LCD * APP_SUPPORT_LCD) | (AP_SUPPORT_MENU * APP_SUPPORT_MENU) | (AP_SUPPORT_LED * APP_SUPPORT_LED); } #if APP_SUPPORT_RGBLCD==1 if(AP_Support_LCD() && !ReadConfigData(&g_displayconfig, CFG_DISPLAY, sizeof(g_displayconfig))) { g_displayconfig.lcd_heigth = 128; g_displayconfig.lcd_width = 160; //g_displayconfig.log_x = 0; //g_displayconfig.log_y = 8; //g_displayconfig.usb_x = 0; //g_displayconfig.usb_y = 16; g_displayconfig.big_num_width = 16; g_displayconfig.big_colon_width = 9; g_displayconfig.small_num_width = 6; g_displayconfig.small_colon_width = 4; //g_displayconfig.num_key_img = GUI_IMG_BIG_NUM; //g_displayconfig.num_key_x = 32; //g_displayconfig.num_key_y = 16; g_displayconfig.position_batt = POSITION_BATT; g_displayconfig.message_y = 48; } #elif APP_SUPPORT_LCD==1 if(AP_Support_LCD() && !ReadConfigData(&g_displayconfig, CFG_DISPLAY, sizeof(g_displayconfig))) { g_displayconfig.lcd_heigth = 64; g_displayconfig.lcd_width = 128; //g_displayconfig.log_x = 0; //g_displayconfig.log_y = 8; //g_displayconfig.usb_x = 0; //g_displayconfig.usb_y = 16; g_displayconfig.big_num_width = 16; g_displayconfig.big_colon_width = 9; g_displayconfig.small_num_width = 6; g_displayconfig.small_colon_width = 4; //g_displayconfig.num_key_img = GUI_IMG_BIG_NUM; //g_displayconfig.num_key_x = 32; //g_displayconfig.num_key_y = 16; g_displayconfig.position_batt = POSITION_BATT; g_displayconfig.message_y = 24; } #endif #if APP_SUPPORT_BLUETOOTH==1 /*Surport bt*/ if(!ReadConfigData(&g_btconfig, CFG_BLUETOOTH, sizeof(g_btconfig))) { strcpy(g_btconfig.local_name, "RDA MP3 BT"); // bluetooth name strcpy(g_btconfig.password, "0000"); // bluetooth password } #endif //SetBackLightColor(g_comval->BLightColor); //设置背光颜色。 SetBackLight(g_comval->BackLight); SetContrast(g_comval->DisplayContrast); //设置屏幕的对比度 MESSAGE_Initial(g_comval); }
TASK_ENTRY BAL_MainTaskEntry(void *pData) { INT8 IsUDisk = 0; BOOL need_draw = TRUE; INT32 active = 0; //当前活动的项目 INT32 result = APP_DEFAULT_RESULT; INT32 ret = RESULT_NULL; INT32 bt_active_ret = RESULT_NULL; TM_SYSTEMTIME systime; extern BOOL g_usb_connected; // dump version and date //hal_HstSendEvent(SYS_EVENT,0x11223344); //hal_HstSendEvent(SYS_EVENT,GetPlatformVersion()); //hal_HstSendEvent(SYS_EVENT,GetPlatformRevision()); //hal_HstSendEvent(SYS_EVENT,GetPlatformBuildDate()); //hal_HstSendEvent(SYS_EVENT,AP_GetVersion()); //hal_HstSendEvent(SYS_EVENT,AP_GetBuildDate()); APP_ReadComPara(); //读取系统的全局变量。可以放在os初始化的过程中做 #if XDL_APP_SUPPORT_LOWBAT_DETECT==1//warkey 2.1 StartBatTimer(); #endif gui_load_resource(g_comval->langid); LED_SetPattern(GUI_LED_POWERON, 1); #if APP_SUPPORT_LCD==1 if(AP_Support_LCD()) { lcdd_Open(); GUI_Initialise(g_displayconfig.lcd_width, g_displayconfig.lcd_heigth); GUI_SetTextColor(g_displayconfig.font_color); GUI_SetBackColor(g_displayconfig.back_color); } #endif if(g_test_mode) { NVRAMWriteData(); APP_Test_Mode(); } APP_DisplaySysLogo(FALSE); AP_GetBuildDate();//force link date time functions. // check systemtime TM_GetSystemTime(&systime); if(systime.uHour >= 24 || systime.uDay == 0 || systime.uYear > 2050) // invalid date time { systime.uYear = 2012; systime.uMonth = 8; systime.uDay = 15; systime.uHour = 12; systime.uMinute = 30; TM_SetSystemTime(&systime); } #if APP_SUPPORT_LCD==1 TIMER_SetAlarm(1); #endif hal_HstSendEvent(SYS_EVENT, 0x09250001); APP_InitialFunPtr(); //初始化各个模块的回调函数,最后通过宏定义来实现开关 APP_Read_Sys_Config(); LED_SetPattern(GUI_LED_NONE, 1); hal_HstSendEvent(BOOT_EVENT, 0x09558000); #if APP_SUPPORT_LCD==0 //added for T_card update without LCD. Search TF card, if there is a file with the name "tflash_update.bin", then do the update. #ifdef MCD_TFCARD_SUPPORT { INT32 file = -1, card_ok = -1; UINT32 cur_data = AP_GetBuildDate(); UINT32 cur_time = AP_GetBuildTime(); boolean needupdate = FALSE; hal_HstSendEvent(BOOT_EVENT, 0x98880001); hal_HstSendEvent(BOOT_EVENT, cur_data); hal_HstSendEvent(BOOT_EVENT, cur_time); hal_HstSendEvent(BOOT_EVENT, 0x98880001); card_ok = FS_MountDevice(FS_DEV_TYPE_TFLASH); hal_HstSendEvent(BOOT_EVENT, card_ok); if(card_ok == ERR_SUCCESS) { FS_FILE_ATTR file_attr; TM_FILETIME sFileTime; TM_SYSTEMTIME sSysTm; UINT32 bin_createDate = 0; UINT32 bin_createTime = 0; UINT32 offset = 0; file = FS_Open(UPDATE_TFLASH_BIN_NAME, FS_O_RDWR, 0); hal_HstSendEvent(BOOT_EVENT, 0x09550000); hal_HstSendEvent(BOOT_EVENT, file); hal_HstSendEvent(BOOT_EVENT, 0x09550000); #if 1 FS_Seek(file, 0xc, FS_SEEK_SET); FS_Read(file, &offset, 4); FS_Seek(file, ((offset & 0x00ffffff)) - 0x10, FS_SEEK_SET); FS_Read(file, &bin_createDate, 4); FS_Read(file, &bin_createTime, 4); hal_HstSendEvent(BOOT_EVENT, 0x98880002); hal_HstSendEvent(BOOT_EVENT, bin_createDate); hal_HstSendEvent(BOOT_EVENT, bin_createTime); hal_HstSendEvent(BOOT_EVENT, 0x98880002); #else if(FS_GetFileAttrByHandle(file, &file_attr) == 0) { sFileTime.DateTime = file_attr.i_mtime; TM_FileTimeToSystemTime(sFileTime, &sSysTm); bin_createDate = ((sSysTm.uYear) * 10000 + ((sSysTm.uMonth) * 100) + sSysTm.uDay); bin_createTime = sSysTm.uHour * 10000 + sSysTm.uMinute * 100 + sSysTm.uSecond; hal_HstSendEvent(BOOT_EVENT, 0x98880002); hal_HstSendEvent(BOOT_EVENT, bin_createDate); hal_HstSendEvent(BOOT_EVENT, bin_createTime); hal_HstSendEvent(BOOT_EVENT, 0x98880002); } #endif //if((cur_data<bin_createDate) || //(cur_data==bin_createDate && cur_time<bin_createTime)) if((cur_data != bin_createDate) || (cur_time != bin_createTime)) //只要不是同一软件就允许升级 { needupdate = TRUE; } hal_HstSendEvent(BOOT_EVENT, needupdate); hal_HstSendEvent(BOOT_EVENT, 0x98880008); if(file >= 0 && needupdate) { Upgrade_Flash(file); RestartSystem(); } else { FS_Close(file); } } } #endif #endif g_last_reslt = result; if(GetUsbCableStatus()) { hal_HstSendEvent(APP_EVENT, 0x13113001); result = RESULT_UDISK; } if(gpio_detect_linein() == GPIO_DETECTED) { hal_HstSendEvent(APP_EVENT, 0x13113002); result = RESULT_LINE_IN; } // IsUDisk = g_comval->Onlinedev; #ifdef SUPPORT_POWERON_ENTER_CHARGE_AP//warkey 2.1 app_trace(APP_MAIN_TRC, "GetBattery:%d", GetBattery()); if(-1 == GetBattery() && g_usb_connected == 0) { // hal_HstSendEvent(SYS_EVENT, 0x13062707); hal_HstSendEvent(APP_EVENT, 0x13113003); result = Charging_Entry(); } #endif while(1) { if(result==RESULT_STANDBY) { LED_SetPattern(GUI_LED_NONE, 0xde); } else { LED_SetPattern(GUI_LED_NONE, 1); } hal_HstSendEvent(SYS_EVENT, 0x09250002); hal_HstSendEvent(SYS_EVENT, result); if(result == RESULT_NULL || result == RESULT_MAIN) { #if APP_SUPPORT_MENU==1 if(AP_Support_MENU()) { ui_auto_select = FALSE; result = GUI_Display_Menu(GUI_MENU_MAIN, main_menu_callback); g_last_reslt = RESULT_NULL; if(result == RESULT_TIMEOUT || result == RESULT_IGNORE || result == RESULT_NULL) { result = RESULT_IDLE; // RESULT_CALENDAR; } } else #endif { if(RESULT_STANDBY != result) { result = g_last_reslt; } switch(result) { case RESULT_STANDBY: break; case RESULT_BT: #if APP_SUPPORT_MUSIC==1 result = RESULT_MUSIC; break; case RESULT_MUSIC: #endif #if APP_SUPPORT_FM || APP_SUPPORT_LINEIN //没有Line in时才进入FM 2012-9-27 if(gpio_detect_linein() == GPIO_DETECTED) { #if APP_SUPPORT_LINEIN ==1 result = RESULT_LINE_IN; break; #else result = RESULT_RADIO; break; #endif } else { #if APP_SUPPORT_FM==1 result = RESULT_RADIO; break; #endif } case RESULT_LINE_IN: case RESULT_RADIO: #endif #if APP_SUPPORT_RECORD if(AP_Support_RECORD()) { result = RESULT_RECORD_NOSTART; break; } case RESULT_RECORD_NOSTART: #endif #if APP_SUPPORT_BLUETOOTH result = RESULT_BT; break; #endif default: result = APP_DEFAULT_RESULT; break; } } } else if(result == RESULT_POWERON) { if(AP_Support_LCD()) { GUI_ClearScreen(NULL); GUI_UpdateScreen(NULL); } LED_SetPattern(GUI_LED_POWERON, 1); APP_DisplaySysLogo(TRUE); LED_SetPattern(GUI_LED_NONE, 1); if (g_comval->LightTime == 0) //每次开机判断一次!解决Bug Report:27 { CloseBacklight(); } else { OpenBacklight(); } //APP_DUMP("g_last_reslt:", g_last_reslt); result = g_last_reslt; if(GetUsbCableStatus()) { hal_HstSendEvent(APP_EVENT, 0x07021549); result = RESULT_UDISK; } if(gpio_detect_linein() == GPIO_DETECTED) { hal_HstSendEvent(APP_EVENT, 0x07021550); result = RESULT_LINE_IN; } need_draw = TRUE; } else //boot with param or result != 0 { switch( result) { #if APP_SUPPORT_MUSIC==1 case RESULT_MUSIC: hal_HstSendEvent(SYS_EVENT, 0x20120000); ret = APP_ModCall(FUN_MUSIC, 0); g_last_reslt = result; result = ret; #if APP_SUPPORT_FADE_INOUT==1 if(g_fade_volume_backup != -1) { // hal_HstSendEvent(SYS_EVENT, 0x13101701); // hal_HstSendEvent(SYS_EVENT, g_fade_volume_backup); SetPAVolume(g_fade_volume_backup); g_fade_volume_backup = -1; } #endif if(g_usb_audio_tcard&&GetUsbCableStatus())//plug in tcard when usb audio is running { result = RESULT_UDISK; } hal_HstSendEvent(SYS_EVENT, 0x20124444); hal_HstSendEvent(SYS_EVENT, g_last_reslt); hal_HstSendEvent(SYS_EVENT, result); break; #endif case RESULT_RADIO: hal_HstSendEvent(SYS_EVENT, 0x20120033); ret = APP_ModCall(FUN_FM, 0); hal_HstSendEvent(SYS_EVENT, 0x20120044); g_last_reslt = result; result = ret; hal_HstSendEvent(SYS_EVENT, 0x20123001); break; case RESULT_RECORD_START: //进入录音 case RESULT_RECORD_NOSTART: case RESULT_FMREC_START: case RESULT_FMREC_NOSTART: ret = APP_ModCall(FUN_RECORD, result); //传入result,以判断是否直接开始FM录音? g_last_reslt = result; result = ret; break; case RESULT_RECORD_SWITCH: if(g_last_reslt == RESULT_RECORD_START || g_last_reslt == RESULT_RECORD_NOSTART) { result = RESULT_FMREC_NOSTART; } else if(g_last_reslt == RESULT_FMREC_START || g_last_reslt == RESULT_FMREC_NOSTART) { result = RESULT_RECORD_NOSTART; } ret = APP_ModCall(FUN_RECORD, result); //传入result,以判断是否直接开始FM录音? g_last_reslt = result; result = ret; break; case RESULT_CHARGING: result = APP_ModCall(FUN_CHARGING, 0); break; case RESULT_IDLE: //APP_DUMP("g_last_reslt:", g_last_reslt); result = APP_ModCall(FUN_IDLE, 0); break; case RESULT_LINE_IN: hal_HstSendEvent(SYS_EVENT, 0x20128888); if(event_detected_displaying_log == RESULT_LINE_IN) { event_detected_displaying_log = 0; } result = APP_ModCall(FUN_LINEIN, 0); hal_HstSendEvent(SYS_EVENT, 0x20129999); hal_HstSendEvent(SYS_EVENT, g_last_reslt); hal_HstSendEvent(SYS_EVENT, result); // if(result == RESULT_NULL || result == RESULT_MAIN) if(g_linein_out_event == 1)//line-in was removed { result = g_last_reslt; if(result == RESULT_LINE_IN) { result = APP_DEFAULT_RESULT; } g_linein_out_event = 0; if(g_usb_audio_linein&&GetUsbCableStatus())//plug in line-in when usb audio is running, so return usb audio again { result = RESULT_UDISK; hal_HstSendEvent(SYS_EVENT, 0x13071801); } } else { g_last_reslt = RESULT_LINE_IN; } break; case RESULT_STANDBY: { extern UINT8 g_light_time; #ifdef SUPPORT_POWERON_ENTER_CHARGE_AP//warkey 2.1 if(-1 == GetBattery()) { result = Charging_Entry(); } else #endif { g_light_time = 0; result = APP_StandBy(); if(g_comval->LightTime != 0) { g_light_time = g_comval->LightTime * 2; OpenBacklight(); } } } break; #if APP_SUPPORT_CALIB_KEY==1 case RESULT_KEYCALIB: result = APP_CalibKey(); break; #endif case RESULT_SYSTEM: ret = APP_ModCall(FUN_SYSTEM_SETTING, 0); g_last_reslt = result; result = ret; break; case RESULT_ALARM: ret = APP_ModCall(FUN_TIMER, 1); g_last_reslt = result; result = ret; break; case RESULT_TIMER: ret = APP_ModCall(FUN_TIMER, 0); g_last_reslt = result; result = ret; break; case RESULT_UDISK: //IsUDisk=1; //if(IsUDisk) { if(g_usb_active_after_bt != 0) { g_usb_active_after_bt = 0; } if(event_detected_displaying_log == RESULT_UDISK) { event_detected_displaying_log = 0; } hal_HstSendEvent(SYS_EVENT, 0x09250003); result = APP_ModCall(FUN_USB, 0); hal_HstSendEvent(SYS_EVENT, 0x09250004); } if(result == RESULT_NULL) { result = g_last_reslt; if(result == RESULT_UDISK) { result = APP_DEFAULT_RESULT; } } if(result == RESULT_BT_ACTIVE) { bt_active_ret = RESULT_UDISK; } //fix udisk return, drop key up //result = RESULT_MUSIC; hal_HstSendEvent(SYS_EVENT, result); break; #if APP_SUPPORT_BLUETOOTH==1 case RESULT_BT: hal_HstSendEvent(SYS_EVENT, 0x20120001); ret = APP_ModCall(FUN_BT, -1); g_last_reslt = result; result = ret; if(musicplay_timer) { COS_KillTimer(musicplay_timer); musicplay_timer = 0; } hal_HstSendEvent(SYS_EVENT, 0x20127777); hal_HstSendEvent(SYS_EVENT, g_last_reslt); hal_HstSendEvent(SYS_EVENT, result); break; case RESULT_BT_ACTIVE: hal_HstSendEvent(SYS_EVENT, 0x20120002); if(bt_active_ret != RESULT_NULL) { result = APP_ModCall(FUN_BT, bt_active_ret); } else { result = APP_ModCall(FUN_BT, g_last_reslt); } //add by wuxiang call_status = 0; g_bt_call_time = 0; bt_active_ret = RESULT_NULL; if(musicplay_timer) { COS_KillTimer(musicplay_timer); musicplay_timer = 0; } //add end hal_HstSendEvent(SYS_EVENT, 0x20126666); if(g_last_reslt == RESULT_ALARM) { result = RESULT_IDLE; } break; #endif case RESULT_CALENDAR: ret = APP_ModCall(FUN_CALENDAR, 0); g_last_reslt = result; result = ret; break; default: //APP_DUMP("never run here: ", result); hal_HstSendEvent(SYS_EVENT, 0x20125555); hal_HstSendEvent(SYS_EVENT, result); result = RESULT_MAIN; break; }//switch(reault) //APP_ReadComPara(); //IsUDisk = 1; //更新Onlinedev need_draw = TRUE; } }//while never exit }
PUBLIC MEMD_ERR_T memd_FlashErase_Continue(UINT8 *startFlashAddress, UINT8 *endFlashAddress,UINT32 time) { UINT8 rdstatus, rdstatus_old; UINT32 status; VOLATILE UINT8 * ptr; VOLATILE UINT16 *flashaddr; UINT32 Start, End; UINT32 phys_end_add, phys_start_add; UINT32 suspend_time = 0,max_time = 0; max_time = time MILLI_SECONDS; UINT32 now = hal_TimGetUpTime(); phys_start_add = (UINT32)startFlashAddress; MEMD_ASSERT((phys_start_add & 0xe0000000) == 0, "flash_address is expected to be a byte offset within the flash chip, not an absolute adresse"); // Check that start & end addresses are aligned if (endFlashAddress == NULL) { memd_FlashGetSectorLimits(phys_start_add, &Start, &End); phys_end_add = End; } else { phys_end_add = (UINT32)endFlashAddress; MEMD_ASSERT((phys_end_add & 0xe0000000) == 0, "flash_address is expected to be a byte offset within the flash chip, not an absolute adresse") if (phys_end_add != FLASH_SIZE) { memd_FlashGetSectorLimits(phys_end_add , &Start, &End); if (phys_end_add != Start) { return MEMD_ERR_ALIGN; } } } memd_FlashGetSectorLimits(phys_start_add, &Start, &End); if (phys_start_add != Start) { return MEMD_ERR_ALIGN; } hal_EbcFlashWriteEnable(TRUE); while (Start != phys_end_add) { flashaddr = (VOLATILE UINT16 *)(g_memdFlashBaseAddress + (Start&FLASHBANK_MASK)); ptr = (VOLATILE UINT8 *)(g_memdFlashBaseAddress + (Start&~0xfff)); if (!g_memdDybOverride) { if (memd_DYBCheck(flashaddr, (UINT16*)ptr)) { hal_EbcFlashWriteEnable(FALSE);hal_HstSendEvent(0x654314); return MEMD_ERR_PROTECT; } } status = hal_SysEnterCriticalSection(); *(ptr) = 0x30; hal_SysExitCriticalSection(status); // note the pooling could be done on data == 0xff also // pooling rdstatus = (*ptr); while(1){ suspend_time = hal_TimGetUpTime(); if (suspend_time - now > max_time) { status = hal_SysEnterCriticalSection(); *(ptr) = 0xb0; hal_SysExitCriticalSection(status); do { rdstatus_old = (*ptr); rdstatus = (*ptr); rdstatus_old &= 0x80; rdstatus &= 0x80; }while (!(rdstatus_old == 0x80 && rdstatus == 0x80)); // Wait for suspend active (*flashaddr) = 0xf0; hal_EbcFlashWriteEnable(FALSE); return MEMD_ERR_SUSPEND; } rdstatus_old = rdstatus; rdstatus = (*ptr); // DQ6 & DQ2 not toggling? => done if (((rdstatus ^ rdstatus_old) & 0x44) == 0) break; // DQ5 = 1 if ((rdstatus & 0x20) == 0x20) { rdstatus_old = (*ptr); rdstatus = (*ptr); // DQ6 & DQ2 not toggling? => done if (((rdstatus ^ rdstatus_old) & 0x44) == 0) break; // reset (*flashaddr) = 0xf0; hal_EbcFlashWriteEnable(FALSE);hal_HstSendEvent(0x654312); return MEMD_ERR_ERASE; } } if (End != FLASH_SIZE) { memd_FlashGetSectorLimits(End, &Start, &End); } else { Start = End; } } // erase done hal_EbcFlashWriteEnable(FALSE); hal_HstSendEvent(0x653333); return MEMD_ERR_NO; }
/********************************************************************************* * Description : 显示系统开机动画 * * Arguments : wait_key_up, 是否要等待按键 * * Returns : TRUE, 正常 FALSE, enter testmode * * Notes : * *********************************************************************************/ BOOL APP_DisplaySysLogo(BOOL wait_key_up) { INT32 i, j; BOOL keydown = FALSE; UINT32 key; UINT32 prekey = 0; hal_HstSendEvent(SYS_EVENT, 0x19884501); hal_HstSendEvent(SYS_EVENT, g_displayconfig.log_image_time); hal_HstSendEvent(SYS_EVENT, g_displayconfig.log_image_count); if(g_displayconfig.log_image_count == 0 && g_displayconfig.log_image_time == 0) { for(i = 0; i < 1; i++) for(j = 0; j < 1;) { key = MESSAGE_Wait(); //app_trace(APP_MAIN_TRC, "Display Log receive event 0x%x,prekey=0x%x, keydown=%d", key, prekey, keydown); switch(key) { case AP_MSG_RTC: case AP_MSG_CHARGING: j++; break; default: if((key & 0xffff) == AP_KEY_DOWN) { if(prekey != 0 || key != (AP_KEY_DOWN | AP_KEY_POWER)) { keydown = TRUE; } prekey = key; } if(keydown && (key & 0xffff) == AP_KEY_UP) { return TRUE; } key = MESSAGE_HandleHotkey(key);//handle unusual usb/t-card/line-in pluging event if(key != 0) { event_detected_displaying_log = key; hal_HstSendEvent(SYS_EVENT, 0x13063002); hal_HstSendEvent(SYS_EVENT, key); } break; } } } for(i = 0; i < g_displayconfig.log_image_count; i++) { #if APP_SUPPORT_RGBLCD==1 if(AP_Support_LCD()) { GUI_ClearScreen(NULL);//清全屏幕 GUI_ResShowImage(GUI_IMG_LOGO, i, 0, 40); //g_displayconfig.log_x, g_displayconfig.log_y);/*BootLogo*/ GUI_UpdateScreen(NULL); } #elif APP_SUPPORT_LCD==1 if(AP_Support_LCD()) { GUI_ClearScreen(NULL);//清全屏幕 GUI_ResShowImage(GUI_IMG_LOGO, i, 0, 8); //g_displayconfig.log_x, g_displayconfig.log_y);/*BootLogo*/ GUI_UpdateScreen(NULL); } #elif APP_SUPPORT_LED8S==1 GUI_ClearScreen(NULL); GUI_ResShowPic(0xffff, 0, 0); GUI_DisplayText(0, 0, "8888"); GUI_UpdateScreen(NULL); #endif hal_HstSendEvent(SYS_EVENT, 0x19884500); hal_HstSendEvent(SYS_EVENT, g_displayconfig.log_image_time); for(j = 0; j < g_displayconfig.log_image_time; ) { key = MESSAGE_Wait(); //app_trace(APP_MAIN_TRC, "Display Log receive event 0x%x,prekey=0x%x, keydown=%d", key, prekey, keydown); switch(key) { case AP_MSG_RTC: case AP_MSG_CHARGING: j++; break; default: if((key & 0xffff) == AP_KEY_DOWN) { if(prekey != 0 || key != (AP_KEY_DOWN | AP_KEY_POWER)) { keydown = TRUE; } prekey = key; } if(keydown && (key & 0xffff) == AP_KEY_UP) { return TRUE; } break; } } } return TRUE; }
// ============================================================================ // lcddp_FillRect16 // ---------------------------------------------------------------------------- /// This function performs a fill of the active window with some color. /// @param bgColor Color with which to fill the rectangle. It is a 16-bit /// data, as the one of #lcddp_SetPixel16 /// @return #LCDD_ERR_NO, #LCDD_ERR_RESOURCE_BUSY or #LCDD_ERR_NOT_OPENED. // ============================================================================ PRIVATE LCDD_ERR_T lcddp_FillRect16(CONST LCDD_ROI_T* regionOfInterrest, UINT16 bgColor) { // Active window coordinates. HAL_GOUDA_WINDOW_T activeWin; hal_HstSendEvent(0x88855506); if (0 == lcdd_MutexGet()) { hal_HstSendEvent(0x88855507); return LCDD_ERR_RESOURCE_BUSY; } else { if (g_lcddInSleep) { lcdd_MutexFree(); return LCDD_ERR_NO; } hal_HstSendEvent(0x88855508); // Set Active window activeWin.tlPX = regionOfInterrest->x; activeWin.brPX = regionOfInterrest->x + regionOfInterrest->width - 1; activeWin.tlPY = regionOfInterrest->y; activeWin.brPY = regionOfInterrest->y + regionOfInterrest->height - 1; // Check parameters // ROI must be within the screen boundary BOOL badParam = FALSE; if (g_lcddRotate) { if ( (activeWin.tlPX >= LCDD_DISP_Y) || (activeWin.brPX >= LCDD_DISP_Y) || (activeWin.tlPY >= LCDD_DISP_X) || (activeWin.brPY >= LCDD_DISP_X) ) { badParam = TRUE; } } else { if ( (activeWin.tlPX >= LCDD_DISP_X) || (activeWin.brPX >= LCDD_DISP_X) || (activeWin.tlPY >= LCDD_DISP_Y) || (activeWin.brPY >= LCDD_DISP_Y) ) { badParam = TRUE; } } if (badParam) { lcdd_MutexFree(); return LCDD_ERR_INVALID_PARAMETER; } // hal_GoudaSetBgColor(bgColor); lcddp_BlitRoi2Win(&activeWin,&activeWin,bgColor); return LCDD_ERR_NO; } }
// ============================================================================= // memd_FlashErase // ----------------------------------------------------------------------------- /// This function erases contiguous flash sectors. /// Addresses <B> must be aligned on sectors</B>: /// - The \c startFlashAddress is the address of the first sector to erase. /// - The \c endFlashAddress is the address of the first sector NOT to erase. /// If \c endFlashAddress is \c NULL, only one sector will be erased. /// . /// Care must be taken not to erase the code present at the beginning of the flash. /// /// @param start_flashAddress The address of the first sector to erase /// @param end_flashAddress The address of the first sector NOT to erase. /// If \c NULL, only one sector will be erased /// @return #MEMD_ERR_NO, #MEMD_ERR_ERASE, #MEMD_ERR_ALIGN or #MEMD_ERR_PROTECT /// whether the operation succeeded or failed /// // ============================================================================= PUBLIC MEMD_ERR_T memd_FlashErase(UINT8 *startFlashAddress, UINT8 *endFlashAddress) { UINT8 rdstatus, rdstatus_old; UINT32 status; VOLATILE UINT8 * ptr; VOLATILE UINT16 *flashaddr; UINT32 Start, End; UINT32 phys_end_add, phys_start_add; phys_start_add = (UINT32)startFlashAddress; MEMD_ASSERT((phys_start_add & 0xe0000000) == 0, "flash_address is expected to be a byte offset within the flash chip, not an absolute adresse"); hal_HstSendEvent(0x654300); hal_HstSendEvent(phys_start_add); hal_HstSendEvent(0x654301); // Check that start & end addresses are aligned if (endFlashAddress == NULL) { memd_FlashGetSectorLimits(phys_start_add, &Start, &End); phys_end_add = End; } else { phys_end_add = (UINT32)endFlashAddress; MEMD_ASSERT((phys_end_add & 0xe0000000) == 0, "flash_address is expected to be a byte offset within the flash chip, not an absolute adresse") if (phys_end_add != FLASH_SIZE) { memd_FlashGetSectorLimits(phys_end_add , &Start, &End); if (phys_end_add != Start) { return MEMD_ERR_ALIGN; } } } memd_FlashGetSectorLimits(phys_start_add, &Start, &End); if (phys_start_add != Start) { return MEMD_ERR_ALIGN; } hal_HstSendEvent(0x654311); hal_EbcFlashWriteEnable(TRUE); while (Start != phys_end_add) { flashaddr = (VOLATILE UINT16 *)(g_memdFlashBaseAddress + (Start&FLASHBANK_MASK)); ptr = (VOLATILE UINT8 *)(g_memdFlashBaseAddress + (Start&~0xfff)); if (!g_memdDybOverride) { if (memd_DYBCheck(flashaddr, (UINT16*)ptr)) { hal_EbcFlashWriteEnable(FALSE);hal_HstSendEvent(0x654314); return MEMD_ERR_PROTECT; } } status = hal_SysEnterCriticalSection(); // Sector Erase command *(flashaddr+0x555) = 0xaa; *(flashaddr+0x2aa) = 0x55; *(flashaddr+0x555) = 0x80; *(flashaddr+0x555) = 0xaa; *(flashaddr+0x2aa) = 0x55; *(ptr) = 0x30; hal_SysExitCriticalSection(status); // note the pooling could be done on data == 0xff also // pooling rdstatus = (*ptr); while(1){ rdstatus_old = rdstatus; rdstatus = (*ptr); // DQ6 & DQ2 not toggling? => done if (((rdstatus ^ rdstatus_old) & 0x44) == 0) break; // DQ5 = 1 if ((rdstatus & 0x20) == 0x20) { rdstatus_old = (*ptr); rdstatus = (*ptr); // DQ6 & DQ2 not toggling? => done if (((rdstatus ^ rdstatus_old) & 0x44) == 0) break; // reset (*flashaddr) = 0xf0; hal_EbcFlashWriteEnable(FALSE);hal_HstSendEvent(0x654312); return MEMD_ERR_ERASE; } } if (End != FLASH_SIZE) { memd_FlashGetSectorLimits(End, &Start, &End); } else { Start = End; } } // erase done hal_EbcFlashWriteEnable(FALSE); hal_HstSendEvent(0x654399); return MEMD_ERR_NO; }
// ============================================================================= // memd_FlashWrite // ----------------------------------------------------------------------------- /// This function writes data in the flash. It gets its data from \c buffer, copies /// \c byteSize bytes to the flash location designed by \c flashAddress. \c /// pWrittenbyteSize is filled with the actual number of written bytes (Equal /// to size, or less in case of error). /// /// @param flashAddress The byte offset within the flash chip. (Take care not /// to overwrite the code present at the beginning of the flash) /// @param byteSize Number of bytes to write in flash /// @param pWrittenbyteSize Number of bytes actually written in flash /// @param buffer Buffer where to get the data to write in the flash /// @return #MEMD_ERR_NO, #MEMD_ERR_WRITE or #MEMD_ERR_PROTECT /// whether the operation succeeded or failed. // ============================================================================= PUBLIC MEMD_ERR_T memd_FlashWrite(UINT8 *flashAddress, UINT32 byteSize, UINT32 * pWrittenbyteSize, CONST UINT8* buffer) { VOLATILE UINT16 * flashaddr; VOLATILE UINT16 * ptr; UINT16 rdstatus, data; UINT32 bsize=0, wsize=0, owsize=0; MEMD_ERR_T errorcode=MEMD_ERR_NO; UINT32 status; UINT32 phys_add; *pWrittenbyteSize=0; if (byteSize==0) { return MEMD_ERR_NO; } hal_EbcFlashWriteEnable(TRUE); phys_add = (UINT32)flashAddress; hal_HstSendEvent(0x555500); hal_HstSendEvent(phys_add); MEMD_ASSERT((phys_add & 0xe0000000) == 0, "flash_address is expected to be a byte offset within the flash chip, not an absolute adresse") flashaddr = (VOLATILE UINT16 *)(g_memdFlashBaseAddress + (phys_add&FLASHBANK_MASK)); if (!g_memdDybOverride) { ptr = (VOLATILE UINT16 *)(g_memdFlashBaseAddress + (phys_add&~0xfff)); if (memd_DYBCheck(flashaddr, (UINT16*)ptr)) { hal_EbcFlashWriteEnable(FALSE); return MEMD_ERR_PROTECT; } } ptr = (VOLATILE UINT16 *)(g_memdFlashBaseAddress + (phys_add&~1)); // Unlock Bypass Entry status = hal_SysEnterCriticalSection(); *(flashaddr+0x555) = 0xaa; *(flashaddr+0x2aa) = 0x55; *(flashaddr+0x555) = 0x20; hal_SysExitCriticalSection(status); if ((phys_add&1) == 1) { data = *(ptr); } else { data = (*buffer) | ~0x00ff; buffer ++; bsize ++; } if (bsize<byteSize) { data = data & (((*buffer) << 8) | 0x00ff); buffer ++; bsize ++; } if (bsize==byteSize) { // last byte data = data & *(ptr); } // first byte is prepared /* 16b data ready write it to flash*/ status = hal_SysEnterCriticalSection(); *(flashaddr) = 0xa0; *(ptr)=data; hal_SysExitCriticalSection(status); while(bsize<byteSize) { UINT16 tdata; VOLATILE UINT16 * tptr; // do the next data preparation before the pooling so we are ready to do a new programming just after pooling is OK. tdata = data; tptr = ptr; owsize = wsize; wsize = bsize; ptr+=1; if (bsize<byteSize) { data = (*buffer) | ~0x00ff; buffer ++; bsize ++; } if(bsize<byteSize) { data = data & (((*buffer) << 8) | 0x00ff); buffer ++; bsize ++; } // pooling while(1) { rdstatus = (*tptr); // DQ7 = prog value ? ok done if (((rdstatus ^ tdata) & 0x80) == 0) break; // DQ5 = 1 if ((rdstatus & 0x20) == 0x20) { rdstatus = (*tptr); // DQ7 = prog value ? ok done if (((rdstatus ^ tdata) & 0x80) == 0) break; errorcode=MEMD_ERR_WRITE; break; } } if (errorcode!=MEMD_ERR_NO) break; if(bsize==byteSize) { /* last byte */ data = data & *(ptr); } /* 16b data ready write it to flash*/ status = hal_SysEnterCriticalSection(); *(flashaddr) = 0xa0; *(ptr)=data; hal_SysExitCriticalSection(status); } if (errorcode!=MEMD_ERR_NO) { wsize = owsize; } else { // last data pooling while(1) { rdstatus = (*ptr); // DQ7 = prog value ? ok done if (((rdstatus ^ data) & 0x80) == 0) break; // DQ5 = 1 if ((rdstatus & 0x20) == 0x20) { rdstatus = (*ptr); // DQ7 = prog value ? ok done if (((rdstatus ^ data) & 0x80) == 0) break; errorcode=MEMD_ERR_WRITE; break; } } wsize = bsize; } *pWrittenbyteSize = wsize; // Unlock Bypass Exit status = hal_SysEnterCriticalSection(); *(flashaddr) = 0x90; *(flashaddr) = 0x00; hal_SysExitCriticalSection(status); hal_EbcFlashWriteEnable(FALSE); hal_HstSendEvent(0x555504); return errorcode; }
PUBLIC MEMD_ERR_T memd_FlashWrite(UINT8 *flashAddress, UINT32 byteSize, UINT32 * pWrittenbyteSize, CONST UINT8* buffer) { VOLATILE UINT16 * BankAddr; VOLATILE UINT16 * ptr; UINT16 data; UINT32 bsize=0; UINT32 wsize=0; UINT32 owsize=0; MEMD_ERR_T errorcode=MEMD_ERR_NO; UINT32 status; UINT32 phys_add; UINT32 phy_SectAddr; UINT32 phy_End; BOOL isLocked; UINT16 rdstatus; hal_HstSendEvent(0x5477); *pWrittenbyteSize=0; if (byteSize==0) { return MEMD_ERR_NO; } hal_EbcFlashWriteEnable(TRUE); phys_add = (UINT32)flashAddress; MEMD_ASSERT((phys_add & 0xe0000000) == 0, "flash_address is expected to be a byte offset within the flash chip, not an absolute address") memd_FlashGetSectorLimits((UINT32)flashAddress, &phy_SectAddr, &phy_End); BankAddr = (VOLATILE UINT16 *)(g_memdFlashBaseAddress + (phys_add&FLASHBANK_MASK)); ptr = (VOLATILE UINT16 *)(g_memdFlashBaseAddress + (phys_add&~1)); // Unlock block memd_FlashGetLockStatus((UINT8*)((UINT32)phy_SectAddr & MY_MASK),&isLocked); hal_EbcFlashWriteEnable(TRUE); if(isLocked == TRUE) memd_BlockLock((UINT8*)((UINT32)phy_SectAddr & MY_MASK),NULL,FALSE); if ((phys_add&1) == 1) { data = *(ptr); } else { data = (*buffer) | ~0x00ff; buffer ++; bsize ++; } if (bsize<byteSize) { data = data & (((*buffer) << 8) | 0x00ff); buffer ++; bsize ++; } if (bsize==byteSize) { // last byte data = data & *(ptr); } // first byte is prepared /* 16b data ready write it to flash*/ status = hal_SysEnterCriticalSection(); *(BankAddr) = CMD_PROG; *(ptr)=data; hal_SysExitCriticalSection(status); while(bsize<byteSize) { UINT16 tdata; VOLATILE UINT16 * tptr; // do the next data preparation before the pooling so we are ready to do a new programming just after pooling is OK. tdata = data; tptr = ptr; owsize = wsize; wsize = bsize; ptr+=1; if (bsize<byteSize) { data = (*buffer) | ~0x00ff; buffer ++; bsize ++; } if(bsize<byteSize) { data = data & (((*buffer) << 8) | 0x00ff); buffer ++; bsize ++; } // pooling // do{ rdstatus = *BankAddr; }while((rdstatus & SR7) != SR7); // Should probably fix this scheme for reporting errors more cleanly. // For now, just prioritize the errors with the most significant error returned // in errorcode (order this list from least to most significant) if ((rdstatus & SR4) != 0) { // Some other programming error, should be decoded, but maybe do it later errorcode=MEMD_ERR_WRITE; } else if ((rdstatus & SR1) != 0) { errorcode=MEMD_ERR_PROTECT; } if (errorcode!=MEMD_ERR_NO) break; if(bsize==byteSize) { /* last byte */ *BankAddr = CMD_READ_ARRAY; data = data & *(ptr); } /* 16b data ready write it to flash*/ status = hal_SysEnterCriticalSection(); *(BankAddr) = CMD_PROG; *(ptr)=data; hal_SysExitCriticalSection(status); } if (errorcode!=MEMD_ERR_NO) { wsize = owsize; } else { // last data pooling do{ rdstatus = *BankAddr; }while((rdstatus & SR7) != SR7); if ((rdstatus & SR4) != 0) { // Some other programming error, should be decoded, but maybe do it later errorcode=MEMD_ERR_WRITE; } else if ((rdstatus & SR1) != 0) { errorcode=MEMD_ERR_PROTECT; } wsize = bsize; } *pWrittenbyteSize = wsize; // return to Read Array mode status = hal_SysEnterCriticalSection(); *BankAddr = CMD_READ_ARRAY; hal_SysExitCriticalSection(status); if(errorcode != MEMD_ERR_NO) { status = hal_SysEnterCriticalSection(); *BankAddr = CMD_CLR_STATUS_REG; hal_SysExitCriticalSection(status); } hal_EbcFlashWriteEnable(FALSE); return errorcode; }
static void play_finished( void ) { hal_HstSendEvent(SYS_EVENT, 0x11111111); play_end = TRUE; }
UINT32 MCI_AudioPlay (INT32 OutputPath,HANDLE fileHandle, mci_type_enum fielType,MCI_AUDIO_PLAY_CALLBACK_T callback,INT32 PlayProgress) // MCI_MEDIA_PLAY_REQ, { INT32 result=MCI_ERR_NO; diag_printf( "***********OutputPath:%d*****file_name_p:%d, PlayProgress :%d ,fielType :%d ",OutputPath,fileHandle,PlayProgress,fielType); g_mciAudioFinishedCallback=callback; MCI_Play_Stream_Buffer = 0; #ifdef BT_SUPPORT MCI_Play_BTStream = 0; #endif hal_HstSendEvent(SYS_EVENT, 0x20131203); csw_SetResourceActivity(CSW_LP_RESOURCE_AUDIO_PLAYER, CSW_SYS_FREQ_104M); audio_mode = fielType; #ifdef VIDEO_PLAYER_SUPPORT if((audio_mode >=MCI_TYPE_3GP)&&(audio_mode <=MCI_TYPE_MJPG)) { if(PlayProgress ==0) { result= MCI_VideoOpenFile(2,2, fileHandle, 0, 0, fielType, MCI_vid_play_finish_ind,NULL); if (result !=ISOM_ERR_OK) { result = MCI_VideoClose(); return MCI_ERR_ERROR; } MCI_VideoPlay (0,0) ; } else { INT16 img_width = 0; INT16 img_height = 0; INT32 totaltime = 0; UINT16 aud_channel; UINT16 aud_sample_rate; UINT16 track; UINT16 audio_type; INT64 current_Progress; result=MCI_VideoOpenFile(2,2, fileHandle, 0, 0, fielType, MCI_vid_play_finish_ind,NULL); audio_type = MCI_VideoGetInfo(&img_width,&img_height, &totaltime,&aud_channel,&aud_sample_rate,& track); current_Progress= (((INT64)PlayProgress*(INT64)totaltime)/10000); MCI_VideoSeek (current_Progress, SEEK_TIME_MODE_ABSOLUTE, 0, 0) ; MCI_VideoPlay (0,0) ; } } else #endif result = LILY_AudioPlay(OutputPath, fileHandle,fielType, PlayProgress); if (result != MCI_ERR_NO) { csw_SetResourceActivity(CSW_LP_RESOURCE_AUDIO_PLAYER, CSW_SYS_FREQ_32K); } return result; }
void APP_Test_Mode(void) { UINT32 key; g_test_mode = TRUE; // test leds MESSAGE_Sleep(1); LED_SetPattern(GUI_LED_TEST_PATTERN1, 1); MESSAGE_Sleep(1); LED_SetPattern(GUI_LED_TEST_PATTERN2, 1); SetPAVolume(0); hal_HstSendEvent(BOOT_EVENT, 0x7e570100); // 10% // test lcd #if APP_SUPPORT_RGBLCD==1 if(AP_Support_LCD()) { GUI_ClearScreen(NULL); GUI_InvertRegion(NULL); GUI_UpdateScreen(NULL); MESSAGE_Sleep(1); GUI_InvertRegion(NULL); GUI_UpdateScreen(NULL); MESSAGE_Sleep(1); } #elif APP_SUPPORT_LCD==1 if(AP_Support_LCD()) { GUI_ClearScreen(NULL); GUI_InvertRegion(NULL); GUI_UpdateScreen(NULL); MESSAGE_Sleep(1); GUI_InvertRegion(NULL); GUI_UpdateScreen(NULL); MESSAGE_Sleep(1); } #elif APP_SUPPORT_LED8S==1 GUI_ClearScreen(NULL); GUI_ResShowPic(0xffff, 0, 0); GUI_UpdateScreen(NULL); COS_Sleep(200); GUI_DisplayText(0, 0, "8"); GUI_UpdateScreen(NULL); COS_Sleep(200); GUI_DisplayText(1, 0, "8"); GUI_UpdateScreen(NULL); COS_Sleep(200); GUI_DisplayText(2, 0, "8"); GUI_UpdateScreen(NULL); COS_Sleep(200); GUI_DisplayText(3, 0, "8"); GUI_UpdateScreen(NULL); COS_Sleep(200); #endif hal_HstSendEvent(BOOT_EVENT, 0x7e570300); // 30% // test fm #if APP_SUPPORT_FM hal_HstSendEvent(SYS_EVENT, 0x11220010); { extern FM_play_status_t *FMStatus; FMStatus = (FM_play_status_t*)NVRAMGetData(VM_AP_RADIO, sizeof(FM_play_status_t)); FM_SendCommand(MC_OPEN, 0); FMStatus->freq = AP_TEST_FM_FREQ1; FM_SendCommand(MC_PLAY, 0); if(!fmd_ValidStop(FMStatus->freq)) { FMStatus->freq = AP_TEST_FM_FREQ2; if(!fmd_ValidStop(FMStatus->freq)) { FMStatus->freq = AP_TEST_FM_FREQ3; if(!fmd_ValidStop(FMStatus->freq)) { goto test_fail; } } } SetPAVolume(0); FM_SendCommand(MC_CLOSE, 0); } #endif hal_HstSendEvent(BOOT_EVENT, 0x7e570500); // 50% // test bluetooth #if APP_SUPPORT_BLUETOOTH==1 hal_HstSendEvent(SYS_EVENT, 0x11220020); { extern bt_vars_t *g_pBT_vars; extern INT8 g_bt_cur_device; g_bt_cur_device = -1; g_pBT_vars = (bt_vars_t*)NVRAMGetData(VM_AP_BLUETOOTH, sizeof(bt_vars_t)); if(BT_Active_Bluetooth() != 0) { goto test_fail; // test_fail } } #endif hal_HstSendEvent(BOOT_EVENT, 0x7e570800); // 80% // test audio #if APP_SUPPORT_MUSIC==1 { hal_HstSendEvent(SYS_EVENT, 0x11220030); if(!MountDisk(FS_DEV_TYPE_TFLASH)) { goto test_fail; // test_fail } hal_HstSendEvent(SYS_EVENT, 0x11220040); if(!fselInit(FSEL_TYPE_MUSIC, FSEL_ALL_SEQUENCE, FSEL_TYPE_COMMONDIR, FS_DEV_TYPE_TFLASH)) { goto test_fail; // test_fail } if(!fselGetNextFile(&g_testfile_entry)) { goto test_fail; // test_fail } hal_HstSendEvent(SYS_EVENT, 0x11220042); hal_HstSendEvent(SYS_EVENT, g_testfile_entry); g_current_fd = FS_OpenDirect(g_testfile_entry, FS_O_RDONLY, 0); hal_HstSendEvent(SYS_EVENT, g_current_fd); if(g_current_fd < 0) { goto test_fail; // test_fail } hal_HstSendEvent(SYS_EVENT, 0x11220050); if(MCI_ERR_NO != MCI_AudioPlay(0, g_current_fd, MCI_TYPE_DAF, play_finished, 0)) { goto test_fail; } SetPAVolume(0); play_end = FALSE; GUI_DisplayMessage(0, 0, "Test Sucess!", GUI_MSG_FLAG_DISPLAY); hal_HstSendEvent(SYS_EVENT, 0x11220060); hal_HstSendEvent(BOOT_EVENT, 0x7e570a00); // 100% hal_HstSendEvent(BOOT_EVENT, 0x7e5752cc); // test success LED_SetPattern(GUI_LED_TEST_SUCESS, LED_LOOP_INFINITE); while(1) { key = MESSAGE_Wait(); if(play_end) { play_end = FALSE; MCI_AudioStop(); MCI_AudioPlay(0, g_current_fd, MCI_TYPE_DAF, play_finished, 0); } #if 1//warkey //按任意键打开音量播放音乐,MODE键退出并重启 if(key == (AP_KEY_MODE | AP_KEY_DOWN)) { MCI_AudioStop(); FS_Close(g_current_fd); RestartSystem(); } else if(((key >> 16) > 0) && ((key >> 16) < MAX_KEYS)) { if((key & 0xffff) == AP_KEY_DOWN) { SetPAVolume(7); } else if((key & 0xffff) == AP_KEY_UP) { SetPAVolume(0); g_test_mode = FALSE; } } #else//原始 if(key == (AP_KEY_PLAY | AP_KEY_DOWN)) { SetPAVolume(7); } else if(key == (AP_KEY_PLAY | AP_KEY_UP)) { SetPAVolume(0); hal_HstSendEvent(BOOT_EVENT, 0x7e5752cc); // test success g_test_mode = FALSE; } else if(key == (AP_KEY_MODE | AP_KEY_DOWN)) { MCI_AudioStop(); FS_Close(g_current_fd); RestartSystem(); } #endif }; } #else hal_HstSendEvent(BOOT_EVENT, 0x7e570a00); // 100% LED_SetPattern(GUI_LED_TEST_SUCESS, LED_LOOP_INFINITE); hal_HstSendEvent(BOOT_EVENT, 0x7e5752cc); // test success g_test_mode = FALSE; while(1) { key = MESSAGE_Wait(); if(key == (AP_KEY_MODE | AP_KEY_DOWN)) { RestartSystem(); } if(key == (AP_KEY_POWER | AP_KEY_DOWN)) { DM_DeviceSwithOff(); } }; #endif test_fail: GUI_DisplayMessage(0, 0, "Test Fail!", GUI_MSG_FLAG_DISPLAY); LED_SetPattern(GUI_LED_TEST_FAIL, LED_LOOP_INFINITE); hal_HstSendEvent(BOOT_EVENT, 0x7e57fa11); // test fail g_test_mode = FALSE; while(1) { key = MESSAGE_Wait(); if(key == (AP_KEY_MODE | AP_KEY_DOWN)) { RestartSystem(); } if(key == (AP_KEY_POWER | AP_KEY_DOWN)) { DM_DeviceSwithOff(); } } }
// ============================================================================= // memd_FlashErase // ----------------------------------------------------------------------------- /// This function erases contiguous flash sectors. /// Addresses <B> must be aligned on sectors</B>: /// - The \c startFlashAddress is the address of the first sector to erase. /// - The \c endFlashAddress is the address of the first sector NOT to erase. /// If \c endFlashAddress is \c NULL, only one sector will be erased. /// . /// Care must be taken not to erase the code present at the beginning of the flash. /// /// @param start_flashAddress The address of the first sector to erase. Must /// be a _physical_ address (byte offset from start of Flash) /// @param end_flashAddress The address of the first sector NOT to erase. /// If \c NULL, only one sector will be erased /// @return #MEMD_ERR_NO, #MEMD_ERR_ERASE, #MEMD_ERR_ALIGN or #MEMD_ERR_PROTECT /// whether the operation succeeded or failed /// // ============================================================================= PUBLIC MEMD_ERR_T memd_FlashErase(UINT8 *startFlashAddress, UINT8 *endFlashAddress) { UINT32 status; VOLATILE UINT16 * ptr; VOLATILE UINT16 *BankAddr; UINT32 phy_Start; UINT32 phy_End; UINT32 phys_end_add; UINT32 phys_start_add; MEMD_ERR_T errorcode=MEMD_ERR_NO; BOOL isLocked; UINT16 rdstatus; hal_HstSendEvent(0x5555); phys_start_add = (UINT32)startFlashAddress; MEMD_ASSERT((phys_start_add & 0xe0000000) == 0, "flash_address is expected to be a byte offset within the flash chip, not an absolute address"); // Check that start & end addresses are aligned if (endFlashAddress == NULL) { memd_FlashGetSectorLimits(phys_start_add, &phy_Start, &phy_End); phys_end_add = phy_End; } else { phys_end_add = (UINT32)endFlashAddress; MEMD_ASSERT((phys_end_add & 0xe0000000) == 0, "flash_address is expected to be a byte offset within the flash chip, not an absolute address") if (phys_end_add != FLASH_SIZE) { memd_FlashGetSectorLimits(phys_end_add , &phy_Start, &phy_End); if (phys_end_add != phy_Start) { return MEMD_ERR_ALIGN; } } } memd_FlashGetSectorLimits(phys_start_add, &phy_Start, &phy_End); if (phys_start_add != phy_Start) { return MEMD_ERR_ALIGN; } hal_EbcFlashWriteEnable(TRUE); BankAddr = NULL; while (phy_Start != phys_end_add) { BankAddr = (VOLATILE UINT16 *)(g_memdFlashBaseAddress + (phy_Start&FLASHBANK_MASK)); // phy_Start should already be aligned to sector boundary, so shouldn't need any more masking ptr = (VOLATILE UINT16 *)(g_memdFlashBaseAddress + phy_Start); memd_FlashGetLockStatus((UINT8*)((UINT32)ptr & MY_MASK),&isLocked); // Re-enable EBC write hal_EbcFlashWriteEnable(TRUE); if(isLocked == TRUE) { memd_BlockLock((UINT8*)((UINT32)ptr & MY_MASK),NULL,FALSE); } status = hal_SysEnterCriticalSection(); // Sector Erase command *(BankAddr) = CMD_BLOCK_ERASE_1; *(ptr) = CMD_BLOCK_ERASE_2; hal_SysExitCriticalSection(status); // pooling // Wait for Ready, then check status do{ rdstatus = *BankAddr; }while((rdstatus & SR7) != SR7); // Any address in the bank may be used // Should probably fix this scheme for reporting errors more cleanly. // For now, just prioritize the errors with the most significant error returned // in errorcode (order this list from least to most significant) if ((rdstatus & SR3) != 0) { // Vpp Invalid Error errorcode=MEMD_ERR_ERASE; } else if (((rdstatus & SR5) != 0) && ((rdstatus & SR4) != 0)) { // Command Sequence Error errorcode=MEMD_ERR_ERASE; } else if ((rdstatus & SR5) != 0) { // Erase Error errorcode=MEMD_ERR_ERASE; } else if ((rdstatus & SR1) != 0) { errorcode=MEMD_ERR_PROTECT; } // Reset to read array mode when every block erase operation is finished. status = hal_SysEnterCriticalSection(); *BankAddr = CMD_READ_ARRAY; hal_SysExitCriticalSection(status); // Clear status register if any error if(errorcode != MEMD_ERR_NO) { status = hal_SysEnterCriticalSection(); *BankAddr = CMD_CLR_STATUS_REG; hal_SysExitCriticalSection(status); hal_EbcFlashWriteEnable(FALSE); return errorcode; } if (phy_End != FLASH_SIZE) { memd_FlashGetSectorLimits(phy_End, &phy_Start, &phy_End); } else { phy_Start = phy_End; } } if (BankAddr != NULL) { // Return to Read Array mode status = hal_SysEnterCriticalSection(); *BankAddr = CMD_READ_ARRAY; hal_SysExitCriticalSection(status); } // erase done hal_EbcFlashWriteEnable(FALSE); return errorcode; }
uint32 ScsiModeSense6(PSCSI_DEVICE pDevice, uint8 Lun) { TRANSPORT_DATA tData; TRANSPORT_COMMAND tCommand; uint8 bCDB[SCSI_CDB_6]; uint8 bDataBlock[MAX_LIST_LENGTH] = {0}; // standard header + mode pages uint16 usPageLength = 8; // standard header size uint32 dwErr = ERROR_SUCCESS; ASSERT(SCSI_DEVICE_DIRECT_ACCESS == pDevice->DeviceType || SCSI_DEVICE_CDROM == pDevice->DeviceType); memset(bCDB, 0, sizeof(bCDB)); tCommand.Flags = DATA_IN; tCommand.Timeout = pDevice->Timeouts.ScsiCommandTimeout; tCommand.Length = USBMSC_SUBCLASS_SCSI == pDevice->DiskSubClass ? SCSI_CDB_6 : UFI_CDB; tCommand.CommandBlock = bCDB; tCommand.dwLun = Lun; bCDB[0] = SCSI_MODE_SENSE6; bCDB[1] = ((Lun & 0x7) << 5); bCDB[2] = 0x3f; switch (pDevice->DeviceType) { case SCSI_DEVICE_DIRECT_ACCESS: if (pDevice->DiskSubClass == USBMSC_SUBCLASS_UFI) { bCDB[2] = MODE_PAGE_FLEXIBLE_DISK; usPageLength += 32; } else { usPageLength = sizeof(bDataBlock); } break; default: usPageLength = sizeof(bDataBlock); break; } usPageLength = 8; memset(bDataBlock, 0, sizeof(bDataBlock)); // a device may fail this command if the header request length is only 8 bytes; // if this is the case, then the device should recover with extra buffer space tData.TransferLength = 0; tData.RequestLength = usPageLength; tData.DataBlock = bDataBlock; dwErr = UsbsDataTransfer(pDevice->hUsbTransport, &tCommand, &tData); if (dwErr != ERROR_SUCCESS || tData.TransferLength < 8 ) { // we want at least the header hal_HstSendEvent(SYS_EVENT,0x09090023); dwErr = ScsiGetSenseData(pDevice, Lun); } else { hal_HstSendEvent(SYS_EVENT,0x09090020); pDevice->MediumType = bDataBlock[2]; pDevice->Flags.WriteProtect = bDataBlock[3] & 0x80; // inspect WP bit } return dwErr; }
// The camera will be powered on in a particular mode specified here // Later, when the video capture or image capture is 'prepared', the frame buffer size // must correspond to the size here unless the format is changed. PRIVATE void camerap_PowerOn(CAM_SIZE_T CamOutSize, UINT16 IspOutWidth, UINT16 IspOutHeight, CAM_FORMAT_T Format) { // Turn on any power required for camera // Enable the Camera Interface Module // Turn on the Camera // Reset & initialize the Camera HAL_CAMERA_CFG_T CamConfig = {0,}; HAL_CAMERA_IRQ_CAUSE_T mask = {0,0,0,0}; UINT16 camOutWidth = 0, camOutHeight = 0; if (CamOutSize == CAM_NPIX_VGA) { camOutWidth = 640; camOutHeight = 480; } else if (CamOutSize == CAM_NPIX_QVGA) { camOutWidth = 320; camOutHeight = 240; } else if (CamOutSize == CAM_NPIX_QQVGA) { camOutWidth = 160; camOutHeight = 120; } else { SXS_TRACE(TSTDOUT,"DRV_CAM: Unsupported CAM Out Size"); return; } if ((camOutWidth < IspOutWidth) || (camOutHeight < IspOutHeight)) { SXS_TRACE(TSTDOUT,"DRV_CAM: ISP out is larger than Cam Out"); return; } s_camOpened = FALSE; #ifdef I2C_BASED_ON_GPIO gpio_i2c_open(); #else g_camdI2cBusId = tgt_GetCamdConfig()->i2cBusId; hal_I2cOpen(g_camdI2cBusId); #endif CamConfig.rstActiveH = FALSE; CamConfig.pdnActiveH = TRUE; CamConfig.dropFrame = FALSE; CamConfig.camClkDiv = 10; CamConfig.endianess = NO_SWAP; CamConfig.camId = camera_GetCameraID(); CamConfig.cropEnable = FALSE; #if CAM_ISP_FUNC if ((camOutWidth > IspOutWidth) || (camOutHeight > IspOutHeight)) { CamConfig.dstWinColStart = ((camOutWidth - IspOutWidth)/2)&0xFFF; CamConfig.dstWinColEnd = (CamConfig.dstWinColStart + IspOutWidth - 1)&0xFFF; CamConfig.dstWinRowStart = ((camOutHeight - IspOutHeight)/2)&0xFFF; CamConfig.dstWinRowEnd = (CamConfig.dstWinRowStart + IspOutHeight - 1)&0xFFF; CamConfig.cropEnable = TRUE; } CamConfig.colRatio= COL_RATIO_1_1; CamConfig.rowRatio= ROW_RATIO_1_1; #else UINT32 ratioCol = camOutWidth / IspOutWidth; UINT32 ratioRow = camOutHeight / IspOutHeight; if ((ratioCol*IspOutWidth == camOutWidth) && (ratioRow*IspOutHeight == camOutHeight)) { CamConfig.colRatio= ratioCol - 1; CamConfig.rowRatio= ratioRow - 1; if (ratioCol != 1 && ratioRow != 1) CamConfig.reOrder = 4; } else { SXS_TRACE(TSTDOUT, "DRV_CAM: failed to set decimation, %d, %d, %d, %d", camOutWidth, IspOutWidth, camOutHeight, IspOutHeight); hal_HstSendEvent(0x20); return; } #endif // Enable Camera LDO pmd_EnablePower(PMD_POWER_CAMERA, TRUE); hal_CameraOpen(&CamConfig); s_camOpened = TRUE; hal_CameraIrqSetMask(mask); hal_CameraPowerDown(FALSE); if (gSensorInfo.snrrst) { // Toggle the reset bit } else { // Just bring the sensor out of reset // hal_CameraReset(TRUE, FALSE); hal_CameraReset(FALSE); } // Should use FrameSize and Format to decide which sequence to use // FrameSize and Format may be changed later but the camera and IFC need // to be stopped and the IFC and camera re-enabled in the correct order // Power On seq // After this, the camera will start sending data to the camera module. The IFC will // need to be started at the correct time (typically after the end of frame interrupt // so the data will be properly synchronized in the buffer if (CamOutSize == CAM_NPIX_VGA) { camerap_SendRgSeq(RG_InitPowerOnVga, (sizeof(RG_InitPowerOnVga) / sizeof(CAM_REG_T))); SXS_TRACE(TSTDOUT,"hi704 CAM_NPIX_VGA"); } else if(CamOutSize == CAM_NPIX_QVGA) { camerap_SendRgSeq(RG_InitPowerOnQvga, (sizeof(RG_InitPowerOnQvga) / sizeof(CAM_REG_T))); SXS_TRACE(TSTDOUT,"hi704 CAM_NPIX_QVGA"); } else { camerap_SendRgSeq(RG_InitPowerOnQqvga, (sizeof(RG_InitPowerOnQqvga) / sizeof(CAM_REG_T))); SXS_TRACE(TSTDOUT,"hi704 CAM_NPIX_QQVGA"); } #if 1 if(CamConfig.camId == 0) { camerap_WriteOneReg(0x03,0x00); camerap_WriteOneReg(0x11,0x94); //camerap_WriteOneReg(0x03,0x02); //camerap_WriteOneReg(0x1a,0x21); } else { camerap_WriteOneReg(0x03,0x00); camerap_WriteOneReg(0x11,0x95); //camerap_WriteOneReg(0x03,0x02); //camerap_WriteOneReg(0x1a,0x31); } #endif SXS_TRACE(TSTDOUT,"hi704 F/W Id is %x", CamConfig.camId); // Sensor Init seq }
uint32 GetMediumInfo(PSCSI_DEVICE pDevice, uint8 Lun) { uint32 dwErr = ERROR_SUCCESS; do { if (SCSI_DEVICE_UNKNOWN == pDevice->DeviceType || SCSI_MEDIUM_UNKNOWN == pDevice->MediumType ) { dwErr = ScsiUnitAttention(pDevice, Lun); if (ERROR_SUCCESS != dwErr) break; } // determine device type if (SCSI_DEVICE_UNKNOWN == pDevice->DeviceType) { hal_HstSendEvent(SYS_EVENT,0x08290012); dwErr = ScsiInquiry(pDevice, Lun); if (ERROR_SUCCESS != dwErr) { break; } } // now that mode sense 6 and mode sense 10 is not mandatory, we don't execute this command /* if (SCSI_DEVICE_UNKNOWN != pDevice->DeviceType && SCSI_MEDIUM_UNKNOWN == pDevice->MediumType ) { dwErr = ScsiModeSense6(pDevice, Lun); hal_HstSendEvent(SYS_EVENT,0x09060001); if (ERROR_SUCCESS != dwErr) { TRANSPORT_DATA tData; uint8 senseData[18]; tData.TransferLength = 0; tData.RequestLength = sizeof(senseData); tData.DataBlock = senseData; memset(senseData,0,sizeof(senseData)); hal_HstSendEvent(SYS_EVENT,0x09060002); dwErr = ScsiRequestSense(pDevice, &tData, Lun); dwErr = ScsiModeSense10(pDevice, Lun); if (ERROR_SUCCESS != dwErr) { break; } } } */ pDevice->Flags.MediumPresent = FALSE; // determine disk information if (!pDevice->Flags.MediumPresent) { DISK_INFO di = {0}; dwErr = ScsiReadCapacity(pDevice, &di, Lun); hal_HstSendEvent(SYS_EVENT,0x09090024); hal_HstSendEvent(SYS_EVENT,dwErr); if (ERROR_SUCCESS != dwErr) { break; } } } while (0); dwErr = ERROR_SUCCESS; return dwErr; }
//============================================================================= // vpp_AudioJpegDecOpen function //----------------------------------------------------------------------------- HAL_ERR_T vpp_AudioJpegDecOpen(HAL_VOC_IRQ_HANDLER_T vocIrqHandler) { HAL_VOC_CFG_T cfg; vpp_AudioJpeg_DEC_IN_T * pDecIn; vpp_AudioJpeg_DEC_OUT_T *pDecStatus; INT32 * *pDMA; INT16 *pFilter; CALIB_BUFFER_T* calibPtr = tgt_GetCalibConfig(); diag_printf("[vpp_AudioJpeg_DEC]Opening VPP AUDIO_DEC\n"); if(calibPtr->aud.vocItfMap[audioItf]>=0) pFilter = &(calibPtr->aud.vocFilters[calibPtr->aud.vocItfMap[audioItf]].sdfFilter[0]); else { pFilter = mmc_MemMalloc(sizeof(CALIB_AUDIO_VOC_FILTERS_T)); memset(pFilter, 0, sizeof(CALIB_AUDIO_VOC_FILTERS_T)); } cfg.vocCode = G_VppCommonDecCode; cfg.vocCodeSize = vpp_AudioJpeg_DEC_CODE_SIZE; cfg.pcVal = vpp_AudioJpeg_DEC_CODE_ENTRY; cfg.pcValCriticalSecMin = vpp_AudioJpeg_DEC_CRITICAL_SECTION_MIN; cfg.pcValCriticalSecMax = vpp_AudioJpeg_DEC_CRITICAL_SECTION_MAX; cfg.needOpenDoneIrq = FALSE; cfg.irqMask.voc = (vocIrqHandler) ? 1 : 0; cfg.irqMask.dmaVoc = 0; cfg.vocIrqHandler = vocIrqHandler; cfg.eventMask.wakeupIfc0 = 0; cfg.eventMask.wakeupIfc1 = 0; cfg.eventMask.wakeupDmae = 0; cfg.eventMask.wakeupDmai = 0; cfg.eventMask.wakeupSof0 = 0; cfg.eventMask.wakeupSof1 = 0; // load the VPP AUDIO_DEC code and configure the VoC resource switch (hal_VocOpen(&cfg)) { // error opening the resource case HAL_ERR_RESOURCE_BUSY: diag_printf("[vpp_AudioJpeg_DEC]##WARNING##Error opening VoC resource\n"); return HAL_ERR_RESOURCE_BUSY; // first open, load the constant tables case HAL_ERR_RESOURCE_RESET: diag_printf("[vpp_AudioJpeg_DEC]First open.\n"); break; default: diag_printf("[vpp_AudioJpeg_DEC]No first open.\n"); break; } diag_printf("[vpp_AudioJpeg_DEC]Initializing the DMA addr.\n"); //mp3 pDMA = hal_VocGetPointer(VPP_MP3_Code_ExternalAddr_addr); *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppMp3DecCode, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppMp3DecConstX, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppMp3DecConstY, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); *((INT32*)hal_VocGetPointer(VPP_AUDIO_MIXING_MP3_ADDR))=FALSE; //aac pDMA = hal_VocGetPointer(VPP_AAC_Code_ExternalAddr_addr); *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecCode, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppMp3Layer12Dec_DMA_ConstY, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecConstY, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); //amr pDMA = hal_VocGetPointer(VPP_AMR_Code_ExternalAddr_addr); *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAmrDecCode, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppMp3Dec_EQ_DMA_ConstY, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAmrDecConstY, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); #ifndef TARGET_AAC_SUPPORT_OFF pDMA= hal_VocGetPointer(VPP_AAC_Tab_huffTabSpec_START_addr); *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecHuffTabSpec, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecCos4sin4tab, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecTwidTabOdd, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecSinWindow, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); #endif *((INT16*)hal_VocGetPointer( VPP_GLOBAL_NON_CLIP_BUFFER_MP3_CLEAR_FLAG))=1; #ifdef VIDEO_PLAYER_SUPPORT //jpeg pDMA = hal_VocGetPointer(VPP_JPEG_Code_ExternalAddr_addr); *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppJpegDecCode, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppJpegDecConstY, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA = hal_VocGetPointer(VPP_AAC_Tab_huffTabSpec_START_addr); *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecHuffTabSpec, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecCos4sin4tab, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecTwidTabOdd, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppAacDecSinWindow, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); //h263 zoom pDMA = hal_VocGetPointer(VPP_H263_Zoom_Code_ExternalAddr_addr); *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppH263ZoomCode, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA=pDMA+1; *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppH263ZoomConstX, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); #endif #ifdef bt_support //sbc encode pDMA = hal_VocGetPointer(VPP_SBC_ENC_Code_ExternalAddr_addr); *pDMA=hal_VocGetDmaiPointer((INT32*)G_VppSBCCode, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); #endif pDMA = hal_VocGetPointer(VPP_Speak_AntiDistortion_Filter_Coef_addr); // *pDMA=hal_VocGetDmaiPointer((INT32*)(&(calibPtr->bb->audio[4].vocFilters.sdfFilter[0])), HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); *pDMA=hal_VocGetDmaiPointer((INT32*)pFilter, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA = hal_VocGetPointer(VPP_GLOBAL_NON_CLIP_HISTORYDATA_L_MP3_ADDR); #ifdef SMALL_BSS_RAM_SIZE G_Mp3NonCliPLBuf_alloc = (UINT8*)mmc_MemMalloc_BssRam(G_Mp3NonCliPLBuf_Len+3); //G_Mp3NonCliPRBuf_alloc = (UINT8*)mmc_MemMalloc_BssRam(G_Mp3NonCliPRBuf_Len+3); G_Mp3NonCliPLBuf =(UINT32*) ((UINT32)(G_Mp3NonCliPLBuf_alloc +3) & ~0x3); //G_Mp3NonCliPRBuf =(UINT32*) ((UINT32)(G_Mp3NonCliPRBuf_alloc+3) & ~0x3); hal_HstSendEvent(SYS_EVENT,0xaccccccc); hal_HstSendEvent(SYS_EVENT,G_Mp3NonCliPLBuf_alloc); hal_HstSendEvent(SYS_EVENT,G_Mp3NonCliPLBuf); //hal_HstSendEvent(SYS_EVENT,G_Mp3NonCliPRBuf_alloc); //hal_HstSendEvent(SYS_EVENT,G_Mp3NonCliPRBuf); #endif *pDMA=hal_VocGetDmaiPointer((INT32*)G_Mp3NonCliPLBuf, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); //pDMA = hal_VocGetPointer(VPP_GLOBAL_NON_CLIP_HISTORYDATA_R_MP3_ADDR); // *pDMA=hal_VocGetDmaiPointer((INT32*)G_Mp3NonCliPRBuf, HAL_VOC_DMA_READ,HAL_VOC_DMA_BURST,HAL_VOC_DMA_B2S_NO); pDMA = hal_VocGetPointer(VPP_GLOBAL_DIGITAL_GAIN_MP3_ADDR); *pDMA=(INT32 *)(((32767)<<16)|(0x10)); for(INT32 i=0;i<30;i++) { //calibPtr->bb->audio[4].vocFilters.sdfFilter[32+i]=f_sbc_persition[i]; pFilter[32+i]=f_sbc_persition[i]; } for(INT32 i=0;i<288;i++) { G_Mp3NonCliPLBuf[i]=0; } pDecIn = hal_VocGetPointer(vpp_AudioJpeg_DEC_IN_STRUCT); pDecIn->reset=1; pDecIn->EQ_Type = -1; pDecStatus = (vpp_AudioJpeg_DEC_OUT_T *)hal_VocGetPointer(vpp_AudioJpeg_DEC_OUT_STRUCT); pDecStatus->ErrorStatus=0; pDecStatus->mode=-1;//not 0~9; // move to STALL location (VoC irq generated) vpp_AudioJpegDecVocOpen_status=TRUE; return hal_VocWakeup(HAL_VOC_START); }
// ============================================================================ // lcddp_BlitRoi2Win // ---------------------------------------------------------------------------- // Private function to transfer data to the LCD // ============================================================================ PRIVATE VOID lcddp_BlitRoi2Win(CONST HAL_GOUDA_WINDOW_T* pRoi, CONST HAL_GOUDA_WINDOW_T* pActiveWin, UINT16 bgColor) { hal_HstSendEvent(0x88855509); HAL_GOUDA_LCD_CMD_T cmd[13]; UINT32 j = 0,k =0; if(!((pRoi->tlPX < pRoi->brPX) && (pRoi->tlPY < pRoi->brPY))) { LCDD_TRACE(LCDD_WARN_TRC,0,"lcddp_BlitRoi2Win: Invalid Roi x:%d < %d, y:%d < %d",pRoi->tlPX, pRoi->brPX, pRoi->tlPY, pRoi->brPY); lcddp_GoudaBlitHandler(); return; } // building set roi sequence: #if 1 if(g_lcddRotate) { //Window Horizontal RAM Address Start LCDD_BUILD_CMD_WR_REG(cmd,0,0x0050,pActiveWin->tlPY); //Window Horizontal RAM Address End LCDD_BUILD_CMD_WR_REG(cmd,2,0x0051,pActiveWin->brPY); //Window Vertical RAM Address Start LCDD_BUILD_CMD_WR_REG(cmd,4,0x0052,LCDD_DISP_Y-1-pActiveWin->brPX); //Window Vertical RAM Address End LCDD_BUILD_CMD_WR_REG(cmd,6,0x0053,LCDD_DISP_Y-1-pActiveWin->tlPX); //Start point LCDD_BUILD_CMD_WR_REG(cmd,8,0x0020,pActiveWin->tlPY); LCDD_BUILD_CMD_WR_REG(cmd,10,0x0021,LCDD_DISP_Y-1-pActiveWin->tlPX); } else { hal_HstSendEvent(0x88855510); //Window Horizontal RAM Address Start // LCDD_BUILD_CMD_WR_REG(cmd,0,0x0050,pActiveWin->tlPX); WriteCommand_Addr(0x2a);WriteCommand_Data(0x00);WriteCommand_Data(pActiveWin->tlPX); WriteCommand_Data(0x00);WriteCommand_Data(pActiveWin->brPX); //Window Horizontal RAM Address End // LCDD_BUILD_CMD_WR_REG(cmd,2,0x0051,pActiveWin->brPX); //Window Vertical RAM Address Start // LCDD_BUILD_CMD_WR_REG(cmd,4,0x0052,pActiveWin->tlPY); //Window Vertical RAM Address End // LCDD_BUILD_CMD_WR_REG(cmd,6,0x0053,pActiveWin->brPY); WriteCommand_Addr(0x2b);WriteCommand_Data(0x00);WriteCommand_Data(pActiveWin->tlPY); WriteCommand_Data(0x00);WriteCommand_Data(pActiveWin->brPY); //Start point // LCDD_BUILD_CMD_WR_REG(cmd,8,0x0020,pActiveWin->tlPX); // LCDD_BUILD_CMD_WR_REG(cmd,10,0x0021,pActiveWin->tlPY); } k = ((pActiveWin->brPX-pActiveWin->tlPX)+1)*(1+(pActiveWin->brPY-pActiveWin->tlPY)); hal_HstSendEvent(0x88855511); hal_HstSendEvent(k); // Send command after which the data we sent // are recognized as pixels. WriteCommand_Addr(0x2c); hal_GpioSet(g_slcd_a0); // g_image[0]=0xf8 ; // g_image[1]= 0x00; g_image[0]=(UINT8)((bgColor&0xff00)>>8);g_image[1]=(UINT8)(bgColor&0x00ff); for( j =0; j<k; j++ ) { Write_Data_Image; // red } lcdd_MutexFree(); #else LCM_WR_REG(0x0050,pActiveWin->tlPX);//Window Horizontal RAM Address Start LCM_WR_REG(0x0051,pActiveWin->brPX);//Window Horizontal RAM Address End LCM_WR_REG(0x0052,pActiveWin->tlPY);//Window Vertical RAM Address Start LCM_WR_REG(0x0053,pActiveWin->brPY);//Window Vertical RAM Address End LCM_WR_REG(0x0020,pActiveWin->tlPX); LCM_WR_REG(0x0021,pActiveWin->tlPY); LCDD_BUILD_CMD_WR_CMD(cmd,0,0x0022); while(HAL_ERR_NO != hal_GoudaBlitRoi(pRoi, 1, cmd, lcddp_GoudaBlitHandler)); #endif }