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
}
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 CmdError (PRPH pRP)
{
#ifdef DEBUG
dsPrint1 (DBG_CRITICAL, "GENGAME: CmdError=%x\r\n", pRP->Cmd);
#endif
pRP->Status = STDON | STERR | ERROR_I24_BAD_COMMAND;
}
/************************ END OF SPECIFICATIONS ***********************/
void CmdError( RPH FAR *pRP)
{
#ifdef DEBUG
dsPrint1( DBG_CRITICAL, "USBD: CmdError - Strategy Command = %d\r\n", pRP->Cmd );
#endif
pRP->Status = STDON + STERR + ERROR_I24_BAD_COMMAND;
return;
}
void USBInitComplete (RPH FAR *pRP)
{
//LR0612begin
#ifdef DEBUG
dsPrint1 (DBG_HLVLFLOW, "USBD: USBInitComplete start=%x\r\n", gDelayHostStart);
#endif
if (gDelayHostStart)
{ // delayed host start
//LR0831 gDelayHostStart = FALSE;
DevHelp_ArmCtxHook (0, gStartHostHookHandle);
}
//LR0612end
USBAPMRegister(); // 01/20/2000 MB - added to support APM
pRP->Status = STATUS_DONE;
#ifdef DEBUG
dsPrint1( DBG_HLVLFLOW, "USBD: USBInitComplete Rc=%x\r\n",pRP->Status );
#endif
return;
}
void IRQSwitch (PRP_GENIOCTL pRP)
{
USBRB FAR *pRB = (USBRB FAR *)pRP->ParmPacket;
SHORT DevIndex = (SHORT)pRB->requestData2;
USHORT awakeCount=0;
USHORT rc;
#ifdef DEBUG
dsPrint4 (DBG_IRQFLOW, "USBRESMGR: IRQ %x from Dev[%x], S=%x, s=%x\r\n",
pRB->requestData1, DevIndex, pRP->rph.Status, pRB->status);
#endif
switch (pRB->requestData1)
{
case RES_IRQ_STRINGLEN:
GetStringD(DevIndex,pRB->requestData3);
break;
case RES_IRQ_STRING:
case RES_IRQ_CONTROL:
case RES_IRQ_RWIRQ:
#ifdef DEBUG
dsPrint1 (DBG_IRQFLOW, "USBRESMGR: IRQ Unblock %x\r\n",
pRB->requestData3);
#endif
pRB->requestData1 = RES_IRQ_PROCESSED;
//DevHelp_Beep(440,100);
rc = DevHelp_ProcRun(pRB->requestData3,&awakeCount);
#ifdef DEBUG
dsPrint2 (DBG_IRQFLOW, "USBRESMGR: IRQ Unblock rc=%x, Thread Count = %d\r\n",
rc, awakeCount);
#endif
break;
case RES_IRQ_RWBULK:
gusCheck++;
DataRW(pRP);
break;
case RES_IRQ_GETDESC:
break;
}
}
static void IrqRW (PRP_GENIOCTL pRP)
{
USBRB FAR *pRB = (USBRB FAR *)pRP->ParmPacket;
USHORT usToggleGrp = (pRB->flags &USRB_FLAGS_TTYPE_IN)?0:1;
PUSB_IORB pIoRB = (PUSB_IORB)pRB->requestData2;
USHORT rc;
UCHAR ucEndpoint = pRB->endPointId &DEV_ENDPT_ADDRMASK;
USHORT usToggleBit = 1<< ucEndpoint;
PLIBUSB_IRQ_DATA pIrqData;
#ifdef DEBUG
dsPrint2 ( DBG_DETAILED,
"USBRESMGR: IrqRW to Device[%x], L=%x\r\n",
pIoRB->pDevice, pRB->buffer1Length);
dsPrint4 ( DBG_IRQFLOW,
"USBRESMGR: Endpoint %d Toggle Group %d, Value %0x UpdateBit %0x\r\n",
pRB->endPointId &DEV_ENDPT_ADDRMASK,
usToggleGrp,
pIoRB->pDevice->wToggle[usToggleGrp],
usToggleBit);
#endif
// Safty check that the RB wasn't freed and re used while the USB transaction was done
if (pIoRB->ulID != pRB->requestData3)
{
return;
}
if(DevHelp_PhysToGDTSelector(pIoRB->pPhysData,
sizeof(LIBUSB_BULK_REQ),
gSelIoRB[SEL_IRQ]))
{
DevHelp_Beep(4400,500);
DevHelp_UnLock(pIoRB->ulLockData);
DevHelp_UnLock(pIoRB->ulLockParam);
if(DevHelp_OpenEventSem (pIoRB->ulEventDone) == 0)
{
DevHelp_PostEventSem (pIoRB->ulEventDone);
DevHelp_CloseEventSem (pIoRB->ulEventDone);
}
FreeIoRB(pIoRB);
return;
}
pIrqData = MAKEP(gSelIoRB[SEL_BULK], NULL);
if (pRP->rph.Status == USB_IDC_RC_IOFAILED)
{
DevHelp_Beep(440,500);
#ifdef DEBUG
dsPrint1 (DBG_DETAILED, "USBRESMGR: IO failed Status = %d\r\n",
pRB->status);
#endif
if (pRB->status & USRB_STATUS_STALLED)
{
ClearStalled (pIoRB->pDevice, ucEndpoint);
pIoRB->pDevice->wToggle[usToggleGrp] |= usToggleBit;
pIrqData->usStatus = USB_IORB_STALLED;
}
else
pIrqData->usStatus = USB_IORB_FAILED;
DevHelp_UnLock(pIoRB->ulLockData);
DevHelp_UnLock(pIoRB->ulLockParam);
if(DevHelp_OpenEventSem (pIoRB->ulEventDone) == 0)
{
DevHelp_PostEventSem (pIoRB->ulEventDone);
DevHelp_CloseEventSem (pIoRB->ulEventDone);
}
FreeIoRB(pIoRB);
}
else
{
// No I/O Errors
BOOL fChanged=FALSE;
UCHAR i;
if (! (pRB->flags & USRB_FLAGS_DET_DTGGLEON))
{
#ifdef DEBUG
dsPrint (DBG_DETAILED, "USBRESMGR: Set Toggle Bit\r\n");
#endif
pIoRB->pDevice->wToggle[usToggleGrp] |= usToggleBit;
}
else
{
#ifdef DEBUG
dsPrint (DBG_DETAILED, "USBRESMGR: Clear Toggle Bit\r\n");
#endif
pIoRB->pDevice->wToggle[usToggleGrp] &= ~usToggleBit;
}
#ifdef DEBUG
dsPrint1 ( DBG_DETAILED, "USBRESMGR: New Toggle Value %0x\r\n",
pIoRB->pDevice->wToggle[usToggleGrp] );
#endif
for(i = 0; i < pRB->buffer1Length; i++)
{
if(pIrqData->ucBufferCurrent[i] != pIrqData->ucBufferLast[i])
fChanged = TRUE;
pIrqData->ucBufferCurrent[i] = pIrqData->ucBufferLast[i];
}
if(fChanged || pIrqData->usRes==0)
{
pIrqData->usRes = 1;
if(DevHelp_OpenEventSem (pIrqData->ulEventChanged) == 0)
{
DevHelp_PostEventSem (pIrqData->ulEventChanged);
DevHelp_CloseEventSem (pIrqData->ulEventChanged);
}
}
#ifdef DEBUG
dsPrint (DBG_DETAILED, "USBRESMGR: Next Buffer\r\n");
#endif
ProcessIoRB(pIoRB);
}
}
static void DataRW (PRP_GENIOCTL pRP)
{
USBRB FAR *pRB = (USBRB FAR *)pRP->ParmPacket;
USHORT usToggleGrp = (pRB->flags &USRB_FLAGS_TTYPE_IN)?0:1;
PUSB_IORB pIoRB = (PUSB_IORB)pRB->requestData2;
USHORT rc;
UCHAR ucEndpoint = pRB->endPointId &DEV_ENDPT_ADDRMASK;
USHORT usToggleBit = 1<< ucEndpoint;
PLIBUSB_BULK_REQ pBulkReq;
#ifdef DEBUG
dsPrint2 ( DBG_DETAILED,
"USBRESMGR: DataRW to Device[%x], L=%x\r\n",
pIoRB->pDevice, pRB->buffer1Length);
dsPrint4 ( DBG_IRQFLOW,
"USBRESMGR: Endpoint %d Toggle Group %d, Value %0x UpdateBit %0x\r\n",
pRB->endPointId &DEV_ENDPT_ADDRMASK,
usToggleGrp,
pIoRB->pDevice->wToggle[usToggleGrp],
usToggleBit);
#endif
// Safty check that the RB wasn't freed and re used while the USB transaction was done
if (pIoRB->ulID != pRB->requestData3)
{
DevHelp_Beep(2200,200);
return;
}
if(DevHelp_PhysToGDTSelector(pIoRB->pPhys,
sizeof(LIBUSB_BULK_REQ),
gSelIoRB[SEL_BULK]))
{
DevHelp_Beep(4400,500);
DevHelp_UnLock(pIoRB->ulLockData);
DevHelp_UnLock(pIoRB->ulLockParam);
if(DevHelp_OpenEventSem (pIoRB->ulEventDone) == 0)
{
DevHelp_PostEventSem (pIoRB->ulEventDone);
DevHelp_CloseEventSem (pIoRB->ulEventDone);
}
FreeIoRB(pIoRB);
return;
}
pBulkReq = MAKEP(gSelIoRB[SEL_BULK], NULL);
if (pRP->rph.Status == USB_IDC_RC_IOFAILED)
{
DevHelp_Beep(440,500);
#ifdef DEBUG
dsPrint1 (DBG_DETAILED, "USBRESMGR: IO failed Status = %d\r\n",
pRB->status);
#endif
if (pRB->status & USRB_STATUS_STALLED)
{
ClearStalled (pIoRB->pDevice, ucEndpoint);
pIoRB->pDevice->wToggle[usToggleGrp] |= usToggleBit;
pBulkReq->usStatus = USB_IORB_STALLED;
}
else
pBulkReq->usStatus = USB_IORB_FAILED;
DevHelp_UnLock(pIoRB->ulLockData);
DevHelp_UnLock(pIoRB->ulLockParam);
if(DevHelp_OpenEventSem (pIoRB->ulEventDone) == 0)
{
DevHelp_PostEventSem (pIoRB->ulEventDone);
DevHelp_CloseEventSem (pIoRB->ulEventDone);
}
FreeIoRB(pIoRB);
}
else
{
// No I/O Errors
if (! (pRB->flags & USRB_FLAGS_DET_DTGGLEON))
{
#ifdef DEBUG
dsPrint (DBG_DETAILED, "USBRESMGR: Set Toggle Bit\r\n");
#endif
pIoRB->pDevice->wToggle[usToggleGrp] |= usToggleBit;
}
else
{
#ifdef DEBUG
dsPrint (DBG_DETAILED, "USBRESMGR: Clear Toggle Bit\r\n");
#endif
pIoRB->pDevice->wToggle[usToggleGrp] &= ~usToggleBit;
}
#ifdef DEBUG
dsPrint1 ( DBG_DETAILED, "USBRESMGR: New Toggle Value %0x\r\n",
pIoRB->pDevice->wToggle[usToggleGrp] );
#endif
pBulkReq->usDataProcessed = pBulkReq->usDataProcessed + pRB->buffer1Length;
pBulkReq->usDataRemain = pBulkReq->usDataRemain - pRB->buffer1Length;
pIoRB->usDataProcessed = pBulkReq->usDataProcessed;
pIoRB->usDataRemain = pBulkReq->usDataRemain;
#ifdef DEBUG
dsPrint3 ( DBG_DETAILED, "USBRESMGR: Processed %d bytes, remaining %d (buffersize %d)\r\n",
pBulkReq->usDataProcessed, pBulkReq->usDataRemain, pRB->buffer1Length );
#endif
if(pBulkReq->usDataRemain)
{
#ifdef DEBUG
dsPrint (DBG_DETAILED, "USBRESMGR: Next Buffer\r\n");
#endif
ProcessIoRB(pIoRB);
}
else
{
#ifdef DEBUG
dsPrint (DBG_DETAILED, "USBRESMGR: Done\r\n");
#endif
pBulkReq->usStatus = USB_IORB_DONE;
DevHelp_UnLock(pIoRB->ulLockData);
DevHelp_UnLock(pIoRB->ulLockParam);
if(DevHelp_OpenEventSem (pIoRB->ulEventDone) == 0)
{
DevHelp_PostEventSem (pIoRB->ulEventDone);
DevHelp_CloseEventSem (pIoRB->ulEventDone);
}
else
{
#ifdef DEBUG
dsPrint (DBG_DETAILED, "USBRESMGR: Open Semaphore failed\r\n");
#endif
}
FreeIoRB(pIoRB);
}
}
}
/************************ END OF SPECIFICATIONS ***********************/
void USBInit( RPH FAR *pRP )
{
PRPINITOUT pRPO; /* output request packet far pointer */
PRPINITIN pRPI; /* input request packet far pointer */
UINT ctrlID;
KeyData keyData[3]={"V",CFSTR_TYPE_DEC,0,0,
"REQ:",CFSTR_TYPE_STRING,0,0,
"I13",CFSTR_TYPE_DEC,0,0}; // 31/05/1999 MB
PSZ cmdLine;
ULONG cmdRStatus, errColumn;
USHORT cmdRc;
#ifdef DEBUG
dsPrint(DBG_HLVLFLOW, "USBD: USBInit started\r\n");
#endif
pRP->Status = STATUS_DONE;
if (ghDriver) // initialization already passed
return;
pRPI = (PRPINITIN) pRP;
pRPO = (PRPINITOUT) pRP;
Device_Help = ((PRPINITIN)pRP)->DevHlpEP; /* save devhlp entry point */
// process CONFIG.SYS BASEDEV= line parameters
cmdLine=(PSZ) MAKEP( SELECTOROF(pRPI->InitArgs),
OFFSETOF(((PDDD_PARM_LIST)pRPI->InitArgs)->cmd_line_args) );
cmdRStatus=ProcessConfigString(cmdLine, sizeof(keyData)/sizeof(keyData[0]), (KeyData FAR *)&keyData);
cmdRc=LOUSHORT(cmdRStatus); errColumn=(ULONG)HIUSHORT(cmdRStatus);
switch (cmdRc) // set cmd line processing errors
{
case CFSTR_UNKWN_KEYS:
SetLongValue( gVMessages[INIT_MESSAGE_UNKNOWNKWD], errColumn );
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_UNKNOWNKWD, gMessageCount, MAX_INIT_MESSAGE_COUNT );
break;
case CFSTR_CONVERR:
SetLongValue( gVMessages[INIT_MESSAGE_INVNUMERIC], errColumn );
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_INVNUMERIC, gMessageCount, MAX_INIT_MESSAGE_COUNT );
break;
default:
break;
}
if (keyData[1].value && // check for HCD layer drivers
!CheckHCDDriversLoaded( cmdLine, LOUSHORT(keyData[1].value), HIUSHORT(keyData[1].value) ))
{
pRP->Status = STATUS_DONE | STERR | ERROR_I24_QUIET_INIT_FAIL; // 05/16/2000 MB - exit code changed to quiet exit code
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_NO_HCD, gMessageCount, MAX_INIT_MESSAGE_COUNT );
}
gVerbose= keyData[0].keyStatus!=CFSTR_STATUS_NOTFOUND;
gDelayHostStart = keyData[2].keyStatus!=CFSTR_STATUS_NOTFOUND; // 31/05/1999 MB
if(gDelayHostStart && (pRP->Status == STATUS_DONE) ) // 05/16/2000 MB - fixed error code processing
{
USHORT ctxOffset;
USHORT rc;
ctxOffset=(USHORT)(LONG)(StartHostCtxHookRtn); // IRQ processing thread
rc = DevHelp_AllocateCtxHook((NPFN)ctxOffset, &gStartHostHookHandle);
if (rc)
{
pRP->Status = STATUS_DONE | STERR | STATUS_ERR_UNKCMD;
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_SETCTXFAILED, gMessageCount, MAX_INIT_MESSAGE_COUNT );
#ifdef DEBUG
dsPrint(DBG_CRITICAL, " USBD: USBDInit failed to allocate CTX hook routine\r\n");
#endif
}
}
/*---------------------------------------------------*/
/* Register device driver with resource manager */
/*---------------------------------------------------*/
if (pRP->Status == STATUS_DONE)
RegisterUSBD();
if (pRP->Status == STATUS_DONE)
{
// initialize local structures
setmem((PSZ)&gHostControllers,0,sizeof(gHostControllers));
setmem((PSZ)&gClassDrivers,0,sizeof(gClassDrivers));
setmem((PSZ)&gDevices,0,sizeof(gDevices));
setmem((PSZ)&gHubs,0,sizeof(gHubs));
for (ctrlID=1; ctrlID<gMaxControllers; ctrlID++)
{
gSetAddress[ctrlID]=gSetAddress[0];
gSetConfiguration[ctrlID]=gSetConfiguration[0];
gDeviceStruct[ctrlID]=gDeviceStruct[0];
gGetConfiguration[ctrlID]=gGetConfiguration[0];
gGetHubConfigurationLength[ctrlID]=gGetHubConfigurationLength[0];
}
}
if (pRP->Status == STATUS_DONE)
{
SetLongValue( gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MajorVer );
SetLongValue( gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MinorVer );
gMessageCount=AddToMsgArray( gMessageIDs, INIT_MESSAGE_LOADED, gMessageCount, MAX_INIT_MESSAGE_COUNT );
pRPO->CodeEnd = ((USHORT) &USBInit) - 1; /* set end of code segment */
pRPO->DataEnd = ((USHORT) &gInitDataStart) - 1; /* set end of data segment */
}
else
{
pRPO->CodeEnd = 0; /* set end of code segment */
pRPO->DataEnd = 0; /* set end of data segment */
}
TTYWrite(gVMessages, gMessageIDs, gMessageCount);
#ifdef DEBUG
dsPrint1(DBG_HLVLFLOW, "USBD: USBInit ended. Status %x\r\n", pRP->Status);
#endif
return;
}
void JOYInit()
{
KeyData keyData[2] = {"V", CFSTR_TYPE_DEC, 0, 0,
"DEVICE:", CFSTR_TYPE_DEC, 0, 0};
PSZ kbdCmdLine;
ULONG cmdRStatus, errColumn;
USHORT cmdRc, i;
#ifdef DEBUG
dsPrint (DBG_HLVLFLOW, "USBJOY: Init Entry\r\n");
#endif
pRP->Status = STATUS_DONE;
if (ghDriver)
return; // initialization already passed
Device_Help = ((PRPINITIN)pRP)->DevHlpEP; // save DevHlp Entry Point
kbdCmdLine = (PSZ)MAKEP (SELECTOROF (((PRPINITIN)pRP)->InitArgs),
OFFSETOF (((PRPINITIN)pRP)->InitArgs));
cmdRStatus = ProcessConfigString (kbdCmdLine, 2, (KeyData FAR *)&keyData);
cmdRc = LOUSHORT (cmdRStatus);
errColumn = (ULONG)HIUSHORT (cmdRStatus);
switch (cmdRc)
{
case CFSTR_UNKWN_KEYS:
SetLongValue (gVMessages[INIT_MESSAGE_UNKNOWNKWD], errColumn);
gMessageCount = AddToMsgArray (gMessageIDs, INIT_MESSAGE_UNKNOWNKWD, gMessageCount, MAX_INIT_MESSAGE_COUNT);
break;
case CFSTR_CONVERR:
SetLongValue (gVMessages[INIT_MESSAGE_INVNUMERIC], errColumn );
gMessageCount = AddToMsgArray (gMessageIDs, INIT_MESSAGE_INVNUMERIC, gMessageCount, MAX_INIT_MESSAGE_COUNT);
}
gVerbose = (BYTE)(keyData[0].keyStatus != CFSTR_STATUS_NOTFOUND);
if (keyData[1].keyStatus == CFSTR_STATUS_OK)
gDevice = (keyData[1].value < MAX_JOYS)? (BYTE)keyData[1].value : (BYTE)NULL;
else gDevice = NULL;
if (DevHelp_AttachDD ("USBHID$ ", (NPBYTE)&gIDCTable)) // obtain USBHID's IDC entry point
{
pRP->Status |= STERR;
gMessageCount = AddToMsgArray (gMessageIDs, INIT_MESSAGE_NO_HID, gMessageCount, MAX_INIT_MESSAGE_COUNT);
#ifdef DEBUG
dsPrint (DBG_HLVLFLOW, "USBJOY: Init Faild to Attach to USBHID$ \r\n");
#endif
}
else
{
gpHIDIDC = (PUSBIDCEntry)gIDCTable.ProtIDCEntry;
gdsHIDIDC = gIDCTable.ProtIDC_DS;
}
if (pRP->Status == STATUS_DONE)
{
RegisterJOY(); // register driver with RM
gNoOfJOYs = 0;
for (i = 0; i < MAX_JOYS; i++)
gJOY[i].active = 0;
((PRPINITOUT)pRP)->CodeEnd = ((USHORT)&JOYInit); // set end of code segment
((PRPINITOUT)pRP)->DataEnd = ((USHORT)&gInitDataStart); // set end of data segment
SetLongValue (gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MajorVer);
SetLongValue (gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDriverStruct.MinorVer);
SetLongValue (gVMessages[INIT_MESSAGE_LOADED], (ULONG)gDevice);
gMessageCount = AddToMsgArray (gMessageIDs, INIT_MESSAGE_LOADED, gMessageCount, MAX_INIT_MESSAGE_COUNT);
}
else
{
((PRPINITOUT)pRP)->CodeEnd = 0;
((PRPINITOUT)pRP)->DataEnd = 0;
}
if (gVerbose) TTYWrite (gVMessages, gMessageIDs, gMessageCount);
#ifdef DEBUG
dsPrint1 (DBG_HLVLFLOW, "USBJOY: Init Status = %x\r\n", pRP->Status);
#endif
return;
}
