void far GameStrategy()
{
PRPH pRP; // Pointer to Request Packet (Header)
UCHAR Cmd; // strategy Command
_asm
{ // Strategy routine is called with ES:BX pointing to the Request Packet
mov word ptr pRP[0], bx
mov word ptr pRP[2], es
}
/*
Request Packet Status field is defined only for Open and Close request packets
on entry to the Strategy routine (is 0). For all other request packets,
the Status field is undefined on entry.
*/
pRP->Status = 0;
Cmd = pRP->Cmd;
#ifdef DEBUG
dsPrint2 (DBG_HLVLFLOW, "GENGAME: Strategy Cmd=%x unit=%x\r\n", Cmd, pRP->Unit);
#endif
if (Cmd > CMDInitComplete)
CmdError (pRP);
else
(*gStratList[Cmd])(pRP);
pRP->Status |= STDON;
#ifdef DEBUG
dsPrint1 (DBG_HLVLFLOW, "GENGAME: Strategy S=%x\r\n", pRP->Status);
#endif
}
void FAR USBDStrategy()
{
RPH far *pRP;
USHORT Cmd;
_asm
{
mov word ptr pRP[0], bx
mov word ptr pRP[2], es
}
Cmd = pRP->Cmd;
#ifdef DEBUG
dsPrint1( DBG_HLVLFLOW, "USBD: USBDStrategy: Cmd = %x\r\n", Cmd );
#endif
if (Cmd > MAX_USB_CMD)
{
CmdError( pRP );
}
else
{
/*---------------------*/
/* Call Worker Routine */
/*---------------------*/
(*gStratList[Cmd])(pRP);
}
#ifdef DEBUG
dsPrint1( DBG_HLVLFLOW, "USBD: USBDStrategy: Exit: Cmd = %x\r\n", Cmd );
#endif
}
int ParseArgs(int nArgc, char *ppArgv[], CommandArgs *pArgs)
{
char c;
ArgsStream stream;
memset(pArgs, 0, sizeof(CommandArgs));
stream.Initialize(nArgc, ppArgv);
// GetCygpath();
while ((c = stream.PeekChar()) != 0) {
if (IsCommandSwitch(c)) {
stream.GetChar(); // skip switch char: '-'
switch (c = stream.GetChar()) {
case 'o':
if (pArgs->dwAttribs & Command_o_GenLBO) {
CmdError(CommandError_DupSwitch, c);
return CommandError_DupSwitch;
}
pArgs->dwAttribs |= Command_o_GenLBO;
if (!IsCommandSwitch(stream.PeekChar())) {
GetFileName(&stream, ".lbo", pArgs, &pArgs->pszLBO);
}
break;
case 'u':
pArgs->dwAttribs |= Command_u_ListUserFuncs;
break;
case 'p':
pArgs->dwAttribs |= Command_p_Preview;
break;
case 'I':
// if(HasCygpath()){
// pArgs->pszSourcePath = Turn2WinPath(stream.GetWord());
// } else {
pArgs->pszSourcePath = stream.GetWord();
// }
if (!pArgs->pszSourcePath) {
CmdError(CommandError_NoPathStr, c);
return CommandError_NoPathStr;
}
break;
case '?':
fputs(c_pszCopyright, stdout);
fputs(c_pszUsage, stdout);
exit(0);
default:
CmdError(CommandError_UnknownArg, c);
return CommandError_UnknownArg;
}
}
else {
if (pArgs->pszSource) {
CmdError(CommandError_DupSource, c);
return CommandError_DupSource;
}
// if(HasCygpath()){
// pArgs->pszSource = Turn2WinPath(stream.GetWord());
// } else {
pArgs->pszSource = stream.GetWord();
// }
}
}
if (pArgs->dwAttribs & Command_u_ListUserFuncs) {
ListAllUserFuncs();
if (!pArgs->pszSource) exit(0);
}
if (!pArgs->pszSource) {
CmdError(CommandError_NoSource, c);
return CommandError_NoSource;
}
if ((pArgs->dwAttribs & Command_o_GenLBO) && NULL == pArgs->pszLBO) {
pArgs->pszLBO = GenFileName(pArgs->pszSource, ".lbo");
if (NULL == pArgs->pszLBO) {
CmdError(CommandError_OutOfMemory, 0);
return CommandError_OutOfMemory;
}
}
return 0;
}
int ParseArgs(int nArgc, char *ppArgv[], CommandArgs *pArgs)
{
char c;
ArgsStream stream;
char *pszStr;
memset(pArgs, 0, sizeof(CommandArgs));
stream.Initialize(nArgc, ppArgv);
#ifdef _win32
GetCygpath();
#endif
while ((c = stream.PeekChar()) != 0) {
if (IsCommandSwitch(c)) {
stream.GetChar(); // skip switch char: '-'
switch (c = stream.GetChar()) {
case 'B':
#ifdef _win32
if(HasCygpath()){
pArgs->pszInputLBO = Turn2WinPath(stream.GetWord());
} else {
#endif
pArgs->pszInputLBO = stream.GetWord();
#ifdef _win32
}
#endif
if (!pArgs->pszInputLBO) {
CmdError(CommandError_NoFile, c);
return CommandError_NoFile;
}
break;
case 'C':
pszStr = stream.GetWord();
if (!pszStr) {
CmdError(CommandError_NoFile, c);
return CommandError_NoFile;
}
if (ContainsSemicolon(pszStr)) {
CmdError(CommandError_InvalidSemicolon, c);
return CommandError_InvalidSemicolon;
}
ConcatCommasStr(&(pArgs->pszInputCLS), pszStr);
break;
case 'e':
pArgs->mAttribs |= Command_e_NoElastos;
break;
case 'k':
pArgs->mAttribs |= Command_k_InKernel;
break;
case 's':
pArgs->mAttribs |= Command_k_InSDK;
break;
case 'T':
pszStr = stream.GetWord();
if (strcmp(pszStr, "foreground") == 0) {
pArgs->mAttribs |= Command_r_Foreground;
}
if (!pszStr) {
CmdError(CommandError_NoTemplate, c);
return CommandError_NoTemplate;
}
if (ContainsSemicolon(pszStr)) {
CmdError(CommandError_InvalidSemicolon, c);
return CommandError_InvalidSemicolon;
}
ConcatCommasStr(&(pArgs->pszTemplates), pszStr);
break;
case 'I':
pszStr = stream.GetWord();
if (!pszStr) {
CmdError(CommandError_NoPathStr, c);
return CommandError_NoPathStr;
}
if (ContainsSemicolon(pszStr)) {
CmdError(CommandError_InvalidSemicolon, c);
return CommandError_InvalidSemicolon;
}
#ifdef _win32
if(HasCygpath()){
pszStr = Turn2WinPath(pszStr);
}
#endif
ConcatCommasStr(&(pArgs->pszInputPath), pszStr);
#ifdef _win32
if(HasCygpath()){
delete pszStr;
}
#endif
break;
case 'p':
#ifdef _win32
if(HasCygpath()){
pArgs->pszOutputPath = Turn2WinPath(stream.GetWord());
} else {
#endif
pArgs->pszOutputPath = stream.GetWord();
#ifdef _win32
}
#endif
if (!pArgs->pszOutputPath) {
CmdError(CommandError_NoPathStr, c);
return CommandError_NoPathStr;
}
break;
case 'o':
pArgs->pszOutputFile = stream.GetWord();
if (!pArgs->pszOutputFile) {
CmdError(CommandError_NoPathStr, c);
return CommandError_NoPathStr;
}
break;
case 'l':
pArgs->mAttribs |= Command_l_ListTemplates;
break;
case 'f':
pArgs->mAttribs |= Command_r_Overwrite;
break;
case 'v':
pArgs->mAttribs |= Command_r_Redirect;
break;
case 'z':
pArgs->mAttribs |= Command_z_UseCustomClassObject;
break;
case 'w':
pArgs->mAttribs |= Command_w_HaveSandwichMethod;
break;
case 'n':
pArgs->mAttribs |= Command_n_UseNakedMode;
break;
case 'u':
pArgs->mAttribs |= Command_u_WeakRef;
break;
case '?':
fputs(c_pszCopyright, stdout);
fputs(c_pszUsage, stdout);
exit(0);
default:
CmdError(CommandError_UnknownArg, c);
return CommandError_UnknownArg;
}
}
else {
CmdError(CommandError_UnknownArg, c);
return CommandError_UnknownArg;
}
}
if (!(pArgs->mAttribs & Command_l_ListTemplates)
&& (!pArgs->pszTemplates || !pArgs->pszInputCLS)) {
CmdError(CommandError_NoSource, c);
return CommandError_NoSource;
}
return 0;
}
int ParseArgs(int nArgc, char *ppArgv[], CommandArgs *pArgs)
{
char c;
ArgsStream stream;
BOOL bCharSkipped;
memset(pArgs, 0, sizeof(CommandArgs));
stream.Initialize(nArgc, ppArgv);
if (stream.PeekChar() == 0) {
fputs(c_pszCopyright, stdout);
fputs(c_pszUsage, stdout);
exit(0);
}
while ((c = stream.PeekChar()) != 0) {
if (IsCommandSwitch(c)) {
stream.GetChar(); // skip switch char: '-'
bCharSkipped = FALSE;
c = stream.PeekChar();
if (IsCommandSwitch(c)) { // another '-'
stream.GetChar(); // skip switch char: '-'
c = stream.PeekChar();
}
switch (c) {
case 'o': // output
stream.GetWord(); // skip char "c" or the rest of "output"
bCharSkipped = TRUE;
pArgs->pszOutputFile = stream.GetWord();
if (!pArgs->pszOutputFile) {
CmdError(CommandError_NoPathStr, c);
return CommandError_NoPathStr;
}
break;
case 'i': // interface
pArgs->dwAttribs |= Command_r_Interface;
break;
case 'c':
if (stream.PeekCharAt(2) == 'a') { // callback
pArgs->dwAttribs |= Command_r_Callback;
}
else if (stream.PeekCharAt(2) == 'o') { // const
pArgs->dwAttribs |= Command_r_Const;
}
else {
pArgs->dwAttribs |= Command_r_Class;
}
break;
case 'b':
pArgs->dwAttribs |= Command_r_BaseClass;
break;
case 'a':
if (stream.PeekCharAt(2) == 'l') { // all
pArgs->dwAttribs |= Command_r_All;
}
else { // aspect
pArgs->dwAttribs |= Command_r_Aspect;
}
break;
case 'g': // generic
pArgs->dwAttribs |= Command_r_Generic;
break;
case 'h':
if (stream.PeekCharAt(2) == 'e') { // help
fputs(c_pszCopyright, stdout);
fputs(c_pszUsage, stdout);
exit(0);
}
else { // callback handler
pArgs->dwAttribs |= Command_r_Callback;
}
break;
case 'n':
pArgs->dwAttribs |= Command_r_Const;
break;
case 'e': // enum
pArgs->dwAttribs |= Command_r_Enum;
break;
case 'r': // regime
pArgs->dwAttribs |= Command_r_Regime;
break;
case 's': // struct
pArgs->dwAttribs |= Command_r_Struct;
break;
case 'm': // method
pArgs->dwAttribs |= Command_r_Method;
break;
case 'f':
pArgs->dwAttribs |= Command_r_ForceOverride;
break;
case '?':
fputs(c_pszCopyright, stdout);
fputs(c_pszUsage, stdout);
exit(0);
default:
CmdError(CommandError_UnknownArg, c);
return CommandError_UnknownArg;
}
if (!bCharSkipped) {
stream.GetWord(); //skip the char and the rest
}
}
else {
pArgs->pszInputFile = stream.GetWord();
}
}
if (!pArgs->pszInputFile) {
CmdError(CommandError_NoSource, c);
return CommandError_NoSource;
}
return 0;
}
//卡上电
//查询所有SDIO接口上的卡设备,并查询其电压和配置时钟
//返回值:错误代码;(0,无错误)
SD_Error SD_PowerON(void)
{
u8 i=0;
SD_Error errorstatus=SD_OK;
u32 response=0,count=0,validvoltage=0;
u32 SDType=SD_STD_CAPACITY;
//配置CLKCR寄存器
SDIO->CLKCR=0; //清空CLKCR之前的设置
SDIO->CLKCR|=0<<9; //非省电模式
SDIO->CLKCR|=0<<10; //关闭旁路,CK根据分频设置输出
SDIO->CLKCR|=0<<11; //1位数据宽度
SDIO->CLKCR|=0<<13; //SDIOCLK上升沿产生SDIOCK
SDIO->CLKCR|=0<<14; //关闭硬件流控制
SDIO_Clock_Set(SDIO_INIT_CLK_DIV);//设置时钟频率(初始化的时候,不能超过400Khz)
SDIO->POWER=0X03; //上电状态,开启卡时钟
SDIO->CLKCR|=1<<8; //SDIOCK使能
for(i=0;i<74;i++)
{
SDIO_Send_Cmd(SD_CMD_GO_IDLE_STATE,0,0);//发送CMD0进入IDLE STAGE模式命令.
errorstatus=CmdError();
if(errorstatus==SD_OK)break;
}
if(errorstatus)return errorstatus;//返回错误状态
SDIO_Send_Cmd(SDIO_SEND_IF_COND,1,SD_CHECK_PATTERN);//发送CMD8,短响应,检查SD卡接口特性.
//arg[11:8]:01,支持电压范围,2.7~3.6V
//arg[7:0]:默认0XAA
//返回响应7
errorstatus=CmdResp7Error(); //等待R7响应
if(errorstatus==SD_OK) //R7响应正常
{
CardType=SDIO_STD_CAPACITY_SD_CARD_V2_0; //SD 2.0卡
SDType=SD_HIGH_CAPACITY; //高容量卡
}
SDIO_Send_Cmd(SD_CMD_APP_CMD,1,0); //发送CMD55,短响应
errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应
if(errorstatus==SD_OK)//SD2.0/SD 1.1,否则为MMC卡
{
//SD卡,发送ACMD41 SD_APP_OP_COND,参数为:0x80100000
while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
{
SDIO_Send_Cmd(SD_CMD_APP_CMD,1,0); //发送CMD55,短响应
errorstatus=CmdResp1Error(SD_CMD_APP_CMD); //等待R1响应
if(errorstatus!=SD_OK)return errorstatus; //响应错误
SDIO_Send_Cmd(SD_CMD_SD_APP_OP_COND,1,SD_VOLTAGE_WINDOW_SD|SDType);//发送ACMD41,短响应
errorstatus=CmdResp3Error(); //等待R3响应
if(errorstatus!=SD_OK)return errorstatus; //响应错误
response=SDIO->RESP1;; //得到响应
validvoltage=(((response>>31)==1)?1:0); //判断SD卡上电是否完成
count++;
}
if(count>=SD_MAX_VOLT_TRIAL)
{
errorstatus=SD_INVALID_VOLTRANGE;
return errorstatus;
}
if(response&=SD_HIGH_CAPACITY)
{
CardType=SDIO_HIGH_CAPACITY_SD_CARD;
}
}else//MMC卡
{
//MMC卡,发送CMD1 SDIO_SEND_OP_COND,参数为:0x80FF8000
while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
