/*******************************************************************************
** Name: RK618DevShellMc
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:aaron.sun
** Date: 2014.12.16
** Time: 17:00:38
*******************************************************************************/
_DRIVER_RK61X_RK618DEVICE_SHELL_
SHELL FUN rk_err_t RK618DevShellMc(HDC dev, uint8 * pstr)
{
RK618_DEV_ARG stRK618DevArg;
rk_err_t ret;
uint32 DevID;
if(StrCmpA(pstr, "0", 1) == 0)
{
DevID = 0;
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
DevID = 1;
}
else
{
DevID = 0;
}
//Init RK618Dev arg...
//stRK618DevArg.usbmode = USBOTG_MODE_DEVICE;
//Create RK618Dev...
ret = RKDev_Create(DEV_CLASS_RK618, DevID, &stRK618DevArg);
if(ret != RK_SUCCESS)
{
rk_print_string("RK618Dev create failure");
}
return RK_SUCCESS;
}
/*******************************************************************************
** Name: WDTDevShellDel
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:wrm
** Date: 2015.5.19
** Time: 10:16:13
*******************************************************************************/
_DRIVER_WATCHDOG_WATCHDOGDEVICE_SHELL_
SHELL FUN rk_err_t WDTDevShellDel(HDC dev, uint8 * pstr)
{
uint32 DevID;
//Get WDTDev ID...
if(StrCmpA(pstr, "0", 1) == 0)
{
DevID = 0;
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
DevID = 1;
}
else
{
DevID = 0;
}
if(RKDev_Delete(DEV_CLASS_WDT, DevID, NULL) != RK_SUCCESS)
{
rk_print_string("WDTDev delete failure");
}
return RK_SUCCESS;
}
/*******************************************************************************
** Name: SpiDevShellBspInit
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:hj
** Date: 2014.11.11
** Time: 15:45:43
*******************************************************************************/
_DRIVER_SPI_SPIDEVICE_SHELL_
SHELL FUN rk_err_t SpiDevShellBspInit(HDC dev, uint8 * pstr)
{
if(StrCmpA(pstr, "0", 1) == 0)
{
SPI_TEST_MODE = SPI_TRANSMIT_ONLY;
SPI_CH_TEST = SPI_CH0;
DEBUG("SPI_TRANSMIT_ONLY 0");
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
SPI_TEST_MODE = SPI_TRANSMIT_ONLY;
SPI_CH_TEST = SPI_CH1;
DEBUG("SPI_TRANSMIT_ONLY 1");
}
else if(StrCmpA(pstr, "2", 1) == 0)
{
SPI_TEST_MODE = SPI_TRANSMIT_RECEIVE;
DEBUG("SPI_Read_Write");
}
//ScuClockGateCtr(CLOCK_GATE_I2C, 1);
//ScuClockGateCtr(CLOCK_GATE_I2S, 1);
//ScuClockGateCtr(CLOCK_GATE_GRF, 1);
//I2s_Iomux_Set();
//I2c_Iomux_Set();
rk_print_string("\r\nspi init over");
}
/*******************************************************************************
** Name: RK618DevShellTest
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:aaron.sun
** Date: 2014.12.16
** Time: 17:00:38
*******************************************************************************/
_DRIVER_RK61X_RK618DEVICE_SHELL_
SHELL FUN rk_err_t RK618DevShellTest(HDC dev, uint8 * pstr)
{
HDC hRK618Dev;
uint32 DevID;
//Get RK618Dev ID...
if(StrCmpA(pstr, "0", 1) == 0)
{
DevID = 0;
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
DevID = 1;
}
else
{
DevID = 0;
}
//Open RK618Dev...
hRK618Dev = RKDev_Open(DEV_CLASS_RK618, 0, NOT_CARE);
if((hRK618Dev == NULL) || (hRK618Dev == (HDC)RK_ERROR) || (hRK618Dev == (HDC)RK_PARA_ERR))
{
rk_print_string("RK618Dev open failure");
return RK_SUCCESS;
}
//do test....
//close RK618Dev...
RKDev_Close(hRK618Dev);
return RK_SUCCESS;
}
/*******************************************************************************
** Name: RK618DevShellDel
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:aaron.sun
** Date: 2014.12.16
** Time: 17:00:38
*******************************************************************************/
_DRIVER_RK61X_RK618DEVICE_SHELL_
SHELL FUN rk_err_t RK618DevShellDel(HDC dev, uint8 * pstr)
{
uint32 DevID;
//Get RK618Dev ID...
if(StrCmpA(pstr, "0", 1) == 0)
{
DevID = 0;
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
DevID = 1;
}
else
{
DevID = 0;
}
if(RKDev_Delete(DEV_CLASS_RK618, DevID) != RK_SUCCESS)
{
rk_print_string("RK618Dev delete failure");
}
return RK_SUCCESS;
}
/*******************************************************************************
** Name: EmmcDevInit
** Input:HDC dev
** Return: rk_err_t
** Owner:Aaron.sun
** Date: 2014.2.24
** Time: 10:43:17
*******************************************************************************/
_DRIVER_SDMMC_SDMMCDEVICE_SHELL_
rk_err_t SdMmcShellCreate(HDC dev, uint8 * pstr)
{
SDC_DEV_ARG stSdcArg;
rk_err_t ret;
int DevID;
#ifdef SHELL_HELP
pstr--;
if (pstr[0] == '.')
{
//list have sub cmd
pstr++;
if (StrCmpA((uint8 *) pstr, "help", 4) == 0)
{
rk_print_string("sdmmc.open : sdmmc open cmd.\r\n");
return RK_SUCCESS;
}
}
else
#endif
{
pstr++;
if (StrCmpA((uint8 *) pstr, "/0/0", 2) == 0)
{
DevID = 0;
stSdcArg.Channel = 0;
}
else if (StrCmpA((uint8 *) pstr, "/1", 2) == 0)
{
DevID = 1;
stSdcArg.Channel = 0;
}
else if (StrCmpA((uint8 *) pstr, "/0/1", 2) == 0)
{
DevID = 0;
stSdcArg.Channel = 1;
}
else
{
return RK_ERROR;
}
}
stSdcArg.hDma = RKDev_Open(DEV_CLASS_DMA, 0, NOT_CARE);
if (stSdcArg.hDma <= 0)
{
rk_printf("hDma open failure");
}
ret = RKDev_Create(DEV_CLASS_SDC, DevID, &stSdcArg);
if (ret != RK_SUCCESS)
{
rk_printf("sdc%d open failure", DevID);
}
return RK_SUCCESS;
}
/*******************************************************************************
** Name: SpiDevShellMc
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:Aaron.sun
** Date: 2014.5.30
** Time: 9:18:00
*******************************************************************************/
_DRIVER_SPI_SPIDEVICE_SHELL_
SHELL FUN rk_err_t SpiDevShellMc(HDC dev, uint8 * pstr)
{
SPI_DEV_ARG stSpiArg;
rk_err_t ret;
#ifdef SHELL_HELP
pstr--;
if(pstr[0] == '.')
{
//list have sub cmd
pstr++;
if(StrCmpA(pstr, "help", 4) == 0)
{
rk_print_string("spi.mc : mc cmd.\r\n");
return RK_SUCCESS;
}
}
#endif
return RK_SUCCESS;
stSpiArg.Ch = 0;
stSpiArg.CtrlMode = SPI_CTL_MODE;
stSpiArg.SpiRate = SPI_BUS_CLK;
ret = RKDev_Create(DEV_CLASS_SPI, 0, &stSpiArg);
if(ret != RK_SUCCESS)
{
rk_print_string("Spi Device Create failure");
}
return RK_SUCCESS;
}
rk_err_t ShellCheckCmd(uint8 * CmdStr[], uint8 * Cmd, uint32 len)
{
int32 i = 0;
while (1) //compare the name
{
if (len != StrLenA(CmdStr[i]))
{
i++;
}
else
{
if (StrCmpA(CmdStr[i], Cmd, len) != 0)
{
i++;
}
else
{
break;
}
}
if (*(CmdStr[i]) == '\b')
return RK_ERROR;
}
return i;
}
/*******************************************************************************
** Name: SdMmcShellDel
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:Aaron.sun
** Date: 2014.6.14
** Time: 9:40:35
*******************************************************************************/
_DRIVER_SDMMC_SDMMCDEVICE_SHELL_
SHELL FUN rk_err_t SdMmcShellDel(HDC dev, uint8 * pstr)
{
SDC_DEV_ARG stSdcArg;
#ifdef SHELL_HELP
pstr--;
if (pstr[0] == '.')
{
//list have sub cmd
pstr++;
if (StrCmpA(pstr, "help", 4) == 0)
{
rk_print_string("sdc.del : 删除sdc 设备命令.\r\n");
return RK_SUCCESS;
}
}
#endif
if (RKDev_Delete(DEV_CLASS_SDC, 1, &stSdcArg) != RK_SUCCESS)
{
printf("sdc1 delete failure\n");
return RK_ERROR;
}
if(stSdcArg.hDma != NULL)
{
if (RKDev_Close(stSdcArg.hDma) != RK_SUCCESS)
{
printf("sdmmc hDma close failure\n");
return RK_ERROR;
}
}
return RK_SUCCESS;
}
/*******************************************************************************
** Name: WDTDevShellPcb
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:wrm
** Date: 2015.5.19
** Time: 10:16:13
*******************************************************************************/
_DRIVER_WATCHDOG_WATCHDOGDEVICE_SHELL_
SHELL FUN rk_err_t WDTDevShellPcb(HDC dev, uint8 * pstr)
{
HDC hWDTDev;
uint32 DevID;
//Get WDTDev ID...
if(StrCmpA(pstr, "0", 1) == 0)
{
DevID = 0;
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
DevID = 1;
}
else
{
DevID = 0;
}
//Display pcb...
if(gpstWDTDevISR[DevID] != NULL)
{
rk_print_string("rn");
rk_printf_no_time("WDTDev ID = %d Pcb list as follow:", DevID);
rk_printf_no_time(" &stWDTDevice---0x%08x", &gpstWDTDevISR[DevID]->stWDTDevice);
rk_printf_no_time(" osWDTOperReqSem---0x%08x", gpstWDTDevISR[DevID]->osWDTOperReqSem);
rk_printf_no_time(" osWDTOperSem---0x%08x", gpstWDTDevISR[DevID]->osWDTOperSem);
rk_printf_no_time(" osWDTReadReqSem---0x%08x", gpstWDTDevISR[DevID]->osWDTReadReqSem);
rk_printf_no_time(" osWDTReadSem---0x%08x", gpstWDTDevISR[DevID]->osWDTReadSem);
rk_printf_no_time(" osWDTWriteReqSem---0x%08x", gpstWDTDevISR[DevID]->osWDTWriteReqSem);
rk_printf_no_time(" osWDTWriteSem---0x%08x", gpstWDTDevISR[DevID]->osWDTWriteSem);
//rk_printf_no_time(" usbmode---0x%08x", gpstUsbOtgDevISR[DevID]->usbmode);
//rk_printf_no_time(" usbspeed---0x%08x", gpstUsbOtgDevISR[DevID]->usbspeed);
}
else
{
rk_print_string("rn");
rk_printf_no_time("WDTDev ID = %d not exit", DevID);
}
return RK_SUCCESS;
}
/*******************************************************************************
** Name: WDTDevShellTest
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:wrm
** Date: 2015.5.19
** Time: 10:16:13
*******************************************************************************/
_DRIVER_WATCHDOG_WATCHDOGDEVICE_SHELL_
SHELL FUN rk_err_t WDTDevShellTest(HDC dev, uint8 * pstr)
{
HDC hWDTDev;
uint32 DevID;
//Get WDTDev ID...
if(StrCmpA(pstr, "0", 1) == 0)
{
DevID = 0;
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
DevID = 1;
}
else
{
DevID = 0;
}
//Open WDTDev...
hWDTDev = RKDev_Open(DEV_CLASS_WDT, 0, NOT_CARE);
if((hWDTDev == NULL) || (hWDTDev == (HDC)RK_ERROR) || (hWDTDev == (HDC)RK_PARA_ERR))
{
rk_print_string("WDTDev open failure");
return RK_SUCCESS;
}
//do test....
rk_printf ("Test WatchDog Device\n");
IsWatchDogTestClearInt= 0;
WatchDogInit(RESP_MODE_INT_RESET, PCLK_CYCLES_128, PERIOD_RANGE_0X07FFFFFF);
WatchDogStart();
//close WDTDev...
RKDev_Close(hWDTDev);
return RK_SUCCESS;
}
/*******************************************************************************
** Name: WDTDevShellMc
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:wrm
** Date: 2015.5.19
** Time: 10:16:13
*******************************************************************************/
_DRIVER_WATCHDOG_WATCHDOGDEVICE_SHELL_
SHELL FUN rk_err_t WDTDevShellMc(HDC dev, uint8 * pstr)
{
WDT_DEV_ARG stWDTDevArg;
rk_err_t ret;
uint32 DevID;
DevID = 0;
if(StrCmpA(pstr, "0", 1) == 0)
{
DevID = 0;
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
DevID = 1;
}
else
{
DevID = 0;
}
//Init WDTDev arg...
//stWDTDevArg.usbmode = USBOTG_MODE_DEVICE;
rk_printf ("Entry WatchDogDev Create\n");
stWDTDevArg.Channel = 0;
stWDTDevArg.DevID = 0;
//Create WDTDev...
ret = RKDev_Create(DEV_CLASS_WDT, DevID, &stWDTDevArg);
if(ret != RK_SUCCESS)
{
rk_print_string("WDTDev create failure");
}
return RK_SUCCESS;
}
/*******************************************************************************
** Name: EmmcShellPcb
** Input:HDC dev
** Return: rk_err_t
** Owner:Aaron.sun
** Date: 2014.2.24
** Time: 10:43:17
*******************************************************************************/
_DRIVER_SDMMC_SDMMCDEVICE_SHELL_
rk_err_t SdMmcShellPcb(HDC dev, uint8 * pstr)
{
#ifdef SHELL_HELP
pstr--;
if (pstr[0] == '.')
{
//list have sub cmd
pstr++;
if (StrCmpA((uint8 *) pstr, "help", 4) == 0)
{
rk_print_string("sdmmc.pcb : sdmmc pcb info.\r\n");
return RK_SUCCESS;
}
}
#endif
// TODO:
//add other code below:
//...
return RK_SUCCESS;
}
/*******************************************************************************
** Name: SpiDevShellPcb
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:Aaron.sun
** Date: 2014.5.30
** Time: 9:18:00
*******************************************************************************/
_DRIVER_SPI_SPIDEVICE_SHELL_
SHELL FUN rk_err_t SpiDevShellPcb(HDC dev, uint8 * pstr)
{
#ifdef SHELL_HELP
pstr--;
if(pstr[0] == '.')
{
//list have sub cmd
pstr++;
if(StrCmpA(pstr, "help", 4) == 0)
{
rk_print_string("spi.pcb : pcb info cmd.\r\n");
return RK_SUCCESS;
}
}
#endif
// TODO:
//add other code below:
//...
return RK_SUCCESS;
}
/*******************************************************************************
** Name: SpiDevShellBspDMA_ReadWrite
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:hj
** Date: 2014.12.9
** Time: 20:39:07
*******************************************************************************/
_DRIVER_SPI_SPIDEVICE_SHELL_
SHELL FUN rk_err_t SpiDevShellBspDMA_ReadWrite(HDC dev, uint8 * pstr)
{
rk_size_t realsize,_RXrealsize;
pSPI_REG Spi_Reg0,Spi_Reg1;
uint8 Spi_clockBuffer[5] = {0,};
eSPI_ch_t spiChMaster,spiChSlave;
uint32 i = 0;
uint32 SPI0_RX_FIFO_ADDR, SPI0_TX_FIFO_ADDR,SPI1_RX_FIFO_ADDR,SPI1_TX_FIFO_ADDR;
Spi_Reg0 = SpiGetCH(SPI_CH0);
Spi_Reg1 = SpiGetCH(SPI_CH1);
SPI0_RX_FIFO_ADDR = SpiGetRxFIFOaddr(SPI_CH0);
SPI0_TX_FIFO_ADDR = SpiGetTxFIFOaddr(SPI_CH0);
SPI1_RX_FIFO_ADDR = SpiGetRxFIFOaddr(SPI_CH1);
SPI1_TX_FIFO_ADDR = SpiGetTxFIFOaddr(SPI_CH1);
if(StrCmpA(pstr, "0", 1) == 0)
{
spiChMaster = SPI_CH0;
spiChSlave = SPI_CH1;
DEBUG("Master-SPI0;Slave-SPI1\n");
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
spiChMaster = SPI_CH1;
spiChSlave = SPI_CH0;
DEBUG("Master-SPI1;Slave-SPI0\n");
}
Spi_NeedTransLen = 0;
Spi_NeedTransLen_RX = 5;
Spi_Testflag = 1;
for(i=0;i<10;i++)
{
Spi_TestBuffer[i++] = 0x55;
Spi_TestBuffer[i] = 0xaa;
}
//open uart clk
ScuClockGateCtr(HCLK_DMA_GATE, 1);
//open rst uart ip
ScuSoftResetCtr(SYSDMA_SRST, 1);
DelayMs(1);
ScuSoftResetCtr(SYSDMA_SRST, 0);
IntRegister(INT_ID_DMA ,SpiDMAIntIsr_Test);
IntPendingClear(INT_ID_DMA);
IntEnable(INT_ID_DMA);
DmaEnableInt(2);
SPIInit(spiChMaster,0, 12*1000*1000, SPI_CTL_TXRX_MASTER_TEST);
SPIInit(spiChSlave,0, 12*1000*1000, SPI_CTL_TXRX_SLAVE_TEST);
SPIDmaRead(spiChSlave,5);
SpiEanbleChannel(spiChMaster,0);
SPIDmaWrite(spiChMaster);
//写入0x55 0xaa 0x55 0xaa 0x55 发送到slave
if(spiChMaster == SPI_CH0)
{
DmaConfig(2, (uint32)Spi_TestBuffer, (uint32)SPI0_TX_FIFO_ADDR,5, &SPI0ControlDmaCfg_TX, NULL);
}
else
{
DmaConfig(2, (uint32)Spi_TestBuffer, (uint32)SPI1_TX_FIFO_ADDR,5, &SPI1ControlDmaCfg_TX, NULL);
}
SpiGetInt(spiChMaster);
//SpiEnableTxInt(SPI_CH_TEST);
SpiWaitIdle(spiChMaster);
//从Slave读出0x55 0xaa 0x55 0xaa 0x55
DmaEnableInt(2);
if(spiChMaster == SPI_CH0)
{
DmaConfig(2, (uint32)SPI1_RX_FIFO_ADDR,(uint32)Spi_TestBuffer_Read, 5, &SPI1ControlDmaCfg_RX, NULL);
}
else
{
DmaConfig(2, (uint32)SPI0_RX_FIFO_ADDR,(uint32)Spi_TestBuffer_Read, 5, &SPI0ControlDmaCfg_RX, NULL);
}
//SPIReadFIFO(spiChSlave,Spi_TestBuffer_Read,5);
//读出master Read FIFO里面的无效数据
SPIReadFIFO(spiChMaster,&Spi_TestBuffer_Read[10],5);
//check
if((Spi_TestBuffer_Read[0] == 0x55)
&& (Spi_TestBuffer_Read[1] == 0xaa)
&& (Spi_TestBuffer_Read[2] == 0x55)
&& (Spi_TestBuffer_Read[3] == 0xaa)
&& (Spi_TestBuffer_Read[4] == 0x55))
{
//写入0x55 0xaa 0x55 0xaa 0x55 发送到master
//SPIDmaWrite(spiChSlave);
DmaEnableInt(2);
//写入数据，需要MASTER提供clock
if(spiChMaster == SPI_CH0)
{
DmaConfig(2, (uint32)Spi_TestBuffer, (uint32)SPI1_TX_FIFO_ADDR,5, &SPI1ControlDmaCfg_TX, NULL);
}
else
{
DmaConfig(2, (uint32)Spi_TestBuffer, (uint32)SPI0_TX_FIFO_ADDR,5, &SPI0ControlDmaCfg_TX, NULL);
}
//SPIWriteFIFO(spiChSlave,Spi_TestBuffer,5);
SPIWriteFIFO(spiChMaster,Spi_clockBuffer,5); //master 发送无效数据0x00，只提供clock
SpiGetInt(spiChMaster);
//SpiEnableTxInt(SPI_CH_TEST);
SpiWaitIdle(spiChMaster);
DelayMs(10);
//读出0x55 0xaa 0x55 0xaa 0x55
//SPIDmaRead(spiChMaster,5);
DmaEnableInt(2);
if(spiChMaster == SPI_CH0)
{
DmaConfig(2, (uint32)SPI0_RX_FIFO_ADDR,(uint32)&Spi_TestBuffer_Read[10], 5, &SPI0ControlDmaCfg_RX, NULL);
}
else
{
DmaConfig(2,(uint32)SPI1_RX_FIFO_ADDR,(uint32)&Spi_TestBuffer_Read[10],5, &SPI1ControlDmaCfg_RX, NULL);
}
//SPIReadFIFO(spiChMaster,&Spi_TestBuffer_Read[10],5);
if((Spi_TestBuffer_Read[10] == 0x55)
&& (Spi_TestBuffer_Read[11] == 0xaa)
&& (Spi_TestBuffer_Read[12] == 0x55)
&& (Spi_TestBuffer_Read[13] == 0xaa)
&& (Spi_TestBuffer_Read[14] == 0x55))
{
Spi_Testflag = 0;
}
}
while(Spi_Testflag);
DEBUG("SPI_TRANSMIT_RECEIVE is ok\n");
}
std::tstring ContainerManager::GetContainerName(unsigned int charid, unsigned int containerid) const
{
if (containerid == 1) {
return _T("Bank");
}
else if (containerid == 2) {
return _T("Inventory/Equip");
}
else if (containerid == 3) {
return _T("Shop");
}
std::tstring result;
__int64 key = ((__int64)charid) << 32;
key += containerid;
FILETIME lastWrite;
lastWrite.dwHighDateTime = lastWrite.dwLowDateTime = 0;
std::tstring filename;
for (unsigned int i = 0; i < m_accounts.size(); i++)
{
filename = STREAM2STR( AOManager::instance().getAOPrefsFolder() << _T("\\") << m_accounts[i] << _T("\\Char") << charid << _T("\\Containers\\Container_51017x") << containerid << _T(".xml") );
if (PathFileExists(filename.c_str()))
{
WIN32_FILE_ATTRIBUTE_DATA atribs;
if (GetFileAttributesEx(filename.c_str(), GetFileExInfoStandard, &atribs))
{
lastWrite = atribs.ftLastWriteTime;
break;
}
}
}
bool wasInCache = m_containerFileCache.find(key) != m_containerFileCache.end();
// Clear invalid cache
if ((filename.empty() || (lastWrite.dwHighDateTime == 0 && lastWrite.dwHighDateTime == 0)) && wasInCache)
{
m_containerFileCache.erase(m_containerFileCache.find(key));
}
// Create cache from file
if (!filename.empty())
{
bool update = true;
// If already in cache, check timestamps
if (m_containerFileCache.find(key) != m_containerFileCache.end())
{
FILETIME stamp = m_containerFileCache[key].second;
if (stamp.dwHighDateTime == lastWrite.dwHighDateTime &&
stamp.dwLowDateTime == lastWrite.dwLowDateTime)
{
update = false;
result = m_containerFileCache[key].first;
}
}
if (update)
{
TiXmlDocument document;
if (document.LoadFile(to_ascii_copy(filename), TIXML_ENCODING_UTF8))
{
TiXmlHandle docHandle( &document );
TiXmlElement* element = docHandle.FirstChild( "Archive" ).FirstChild( "String" ).Element();
while (element)
{
if (StrCmpA(element->Attribute("name"), "container_name") == 0)
{
result = from_utf8_copy(element->Attribute("value"));
boost::algorithm::replace_all(result, _T("&"), _T("&")); // Fixes wierd encoding in the AO xml.
m_containerFileCache[key] = std::pair<std::tstring, FILETIME>(result, lastWrite);
break;
}
element = element->NextSiblingElement();
}
}
}
}
if (result.empty())
{
result = MakeContainerName(charid, containerid);
}
return result;
}
/*******************************************************************************
** Name: SpiDevShellBspPIO_ReadWrite
** Input:HDC dev, uint8 * pstr
** Return: rk_err_t
** Owner:hj
** Date: 2014.12.9
** Time: 20:38:05
*******************************************************************************/
_DRIVER_SPI_SPIDEVICE_SHELL_
SHELL FUN rk_err_t SpiDevShellBspPIO_ReadWrite(HDC dev, uint8 * pstr)
{
rk_size_t realsize,_RXrealsize;
pSPI_REG Spi_Reg0,Spi_Reg1;
uint8 Spi_clockBuffer[5] = {0,};
eSPI_ch_t spiChMaster,spiChSlave;
uint32 i = 0;
if(StrCmpA(pstr, "0", 1) == 0)
{
spiChMaster = SPI_CH0;
spiChSlave = SPI_CH1;
DEBUG("Master-SPI0;Slave-SPI1\n");
}
else if(StrCmpA(pstr, "1", 1) == 0)
{
spiChMaster = SPI_CH1;
spiChSlave = SPI_CH0;
DEBUG("Master-SPI1;Slave-SPI0\n");
}
Spi_NeedTransLen = 0;
Spi_NeedTransLen_RX = 5;
for(i=0;i<10;i++)
{
Spi_TestBuffer[i++] = 0x55;
Spi_TestBuffer[i] = 0xaa;
}
SPIInit(spiChMaster,0, 12*1000*1000, SPI_CTL_TXRX_MASTER_TEST);
SPIInit(spiChSlave,0, 12*1000*1000, SPI_CTL_TXRX_SLAVE_TEST);
SPIPioRead(spiChSlave,5);
SpiEanbleChannel(spiChMaster,0);
SPIPioWrite(spiChMaster);
Spi_Testflag = 1;
//写入0x55 0xaa 0x55 0xaa 0x55 发送到slave
SPIWriteFIFO(spiChMaster,&Spi_TestBuffer[0],5);
SpiGetInt(spiChMaster);
//SpiEnableTxInt(SPI_CH_TEST);
SpiWaitIdle(spiChMaster);
//读出0x55 0xaa 0x55 0xaa 0x55
SPIReadFIFO(spiChSlave,Spi_TestBuffer_Read,5);
//读出master Read FIFO里面的无效数据
SPIReadFIFO(spiChMaster,&Spi_TestBuffer_Read[10],5);
//check
if((Spi_TestBuffer_Read[0] == 0x55)
&& (Spi_TestBuffer_Read[1] == 0xaa)
&& (Spi_TestBuffer_Read[2] == 0x55)
&& (Spi_TestBuffer_Read[3] == 0xaa)
&& (Spi_TestBuffer_Read[4] == 0x55))
{
//写入0x55 0xaa 0x55 0xaa 0x55 发送到master
SPIWriteFIFO(spiChSlave,Spi_TestBuffer,5); //写入数据，需要MASTER提供clock
SPIWriteFIFO(spiChMaster,Spi_clockBuffer,5); //master 发送无效数据0x00，只提供clock
SpiGetInt(spiChMaster);
//SpiEnableTxInt(SPI_CH_TEST);
SpiWaitIdle(spiChMaster);
DelayMs(10);
//读出0x55 0xaa 0x55 0xaa 0x55
SPIReadFIFO(spiChMaster,&Spi_TestBuffer_Read[10],5);
if((Spi_TestBuffer_Read[10] == 0x55)
&& (Spi_TestBuffer_Read[11] == 0xaa)
&& (Spi_TestBuffer_Read[12] == 0x55)
&& (Spi_TestBuffer_Read[13] == 0xaa)
&& (Spi_TestBuffer_Read[14] == 0x55))
{
Spi_Testflag = 0;
}
}
while(Spi_Testflag);
DEBUG("SPI_TRANSMIT_RECEIVE is ok\n");
}
