PVOID gdtAlloc(size_t tSize, BOOL fSwappable)
{
USHORT rc;
SEL sel;
rc = DosAllocSeg(tSize, &sel, 0);
if (rc)
return NULL;
printf("Allocating %p\n", MAKEP(sel,0));
fflush(stdout);
return MAKEP(sel, 0);
}
USHORT NEAR ActivatePhysConn( USHORT ReqHandle, USHORT Mode, ULONG Timeout,
USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
return ANDIS_RC_SUCCESS;
}
USHORT NEAR RegisterNullDLC( USHORT ReqHandle, USHORT PortID,
PENTRYTBL pEntryTbl, USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
return ANDIS_RC_SUCCESS;
}
USHORT NEAR RetrievePPIStatus( USHORT ReqHandle, PULONG pPPIStatus,
USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
return ANDIS_RC_SUCCESS;
}
USHORT NEAR GetPPATParms( USHORT ReqHandle, USHORT PPATSize, PXVPPAT pPPAT,
USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
return ANDIS_RC_SUCCESS;
}
USHORT _loadds PASCAL FAR TransmitImmData( USHORT PortID, USHORT ReqHandle,
USHORT DataLength, ULONG pImmData, USHORT FunctionCode, USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
if ( FunctionCode != ANDIS_FC_TX_IMM_DATA ) return ANDIS_RC_INVALID_FUNC;
return ANDIS_RC_SUCCESS;
}
USHORT _loadds PASCAL FAR PPATManagement( USHORT PortID, USHORT ReqHandle,
USHORT Param1, ULONG pPPAT, USHORT FunctionCode, USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
if ( FunctionCode != ANDIS_FC_UPDATE_PPAT ) return ANDIS_RC_INVALID_FUNC;
return ANDIS_RC_SUCCESS;
}
USHORT NEAR ReleasePCM( USHORT ReqHandle, USHORT PortID, USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
pModule->PCMEntryTbl.PortMgmtInd = NULL;
pModule->PCMEntryTbl.RecvImmData = NULL;
pModule->PCMEntryTbl.XmitImmDataCnf = NULL;
pModule->PCMEntryTbl.pcm_ds = 0;
return ANDIS_RC_SUCCESS;
}
/* Return the entry point for a driver given its handle */
PADDEntryPoint InitGetDriverEP (USHORT FilterHandle)
{
PDevClassTableStruc pDCTable; /* Pointer to list of ADDs */
PDevClassTableEntry pDCEntry; /* Pointer to device entry points */
pDCTable= E2GetADDTable(); /* Get device class list */
pDCEntry= pDCTable->DCTableEntries+FilterHandle-1;
/* Point to entry for ADDHandle */
return (PVOID) MAKEP(pDCEntry->DCSelector,pDCEntry->DCOffset);
/* Return the entry point */
}
USHORT _loadds PASCAL FAR ReceiveImmDataConfirm( USHORT PortID,
USHORT ReqHandle, USHORT Param1, ULONG Param2, USHORT FunctionCode,
USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
if ( FunctionCode != ANDIS_FC_RX_IMM_DATA_CNF )
return ANDIS_RC_INVALID_FUNC;
return ANDIS_RC_SUCCESS;
}
int IFSEXPORT
FS_INIT(
char far * pszParm,
unsigned long pDevHlp,
unsigned long far * pMiniFSD
)
{
int rc;
SEL aselMapping[2];
char far * p;
int i;
Device_Help = (PFN) pDevHlp;
pidDaemon = 0;
/* Parse the IFS name. */
p = pszParm;
while ((*p == ' ') || (*p == '\t')) p++;
if (*p) {
for (i = 0;
(i < sizeof(FS_NAME)) &&
(*p) &&
(*p != ' ') &&
(*p != '\t');
i++)
FS_NAME[i] = *p++;
FS_NAME[i] = 0;
}
/* Allocate enough GDT selectors. */
rc = DevHelp_AllocGDTSelector(aselMapping, 2);
if (rc) return rc;
pRequest = MAKEP(aselMapping[0], 0);
pFSData = MAKEP(aselMapping[1], 0);
return NO_ERROR;
}
USHORT MAllocMem(USHORT usSize, CHAR FAR ** ppBuffer) {
SEL sel;
unsigned int err;
err = DosAllocSeg(usSize, &sel, 0);
if (err) {
return(err);
}
*ppBuffer = MAKEP(sel, 0);
return(0);
}
/**********************************************************************/
#include <mt\stdio.h>
#include <mt\conio.h>
#include <mt\process.h>
#define INCL_BASE
#include <os2.h>
USHORT rc;
PCHAR Test;
struct _EXCEPTIONREGISTRATIONRECORD
{
struct _EXCEPTIONREGISTRATIONRECORD * prev_structure;
PFN Handler;
};
typedef struct _EXCEPTIONREGISTRATIONRECORD EXCEPTIONREGISTRATIONRECORD;
typedef struct _EXCEPTIONREGISTRATIONRECORD * PEXCEPTIONREGISTRATIONRECORD;
USHORT EXPENTRY SETEXCEPT(PEXCEPTIONREGISTRATIONRECORD);
USHORT EXPENTRY UNSETEXCEPT(PEXCEPTIONREGISTRATIONRECORD);
TID Tid;
#define STACKSIZE 0x2000
SEL SelStack;
PCHAR StackPtr;
void Thread(unsigned far *args); /* Playing thread function */
void cdecl main() {
EXCEPTIONREGISTRATIONRECORD ExceptReg;
printf("Setting exception handler\n");
rc=SETEXCEPT(&ExceptReg);
DosAllocSeg(STACKSIZE,&SelStack,1);
StackPtr=MAKEP(SelStack,0);
Tid=_beginthread(
Thread,
(VOID FAR *)StackPtr,
STACKSIZE,
NULL);
getch();
rc=UNSETEXCEPT(&ExceptReg);
}
USHORT NEAR RegisterPCM( USHORT ReqHandle, USHORT PortID, PENTRYTBL pEntryTbl,
USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
if ( pModule->PCMEntryTbl.PortMgmtInd == NULL )
{
pModule->PCMEntryTbl.PortMgmtInd = pEntryTbl->PortMgmtInd;
pModule->PCMEntryTbl.RecvImmData = pEntryTbl->RecvImmData;
pModule->PCMEntryTbl.XmitImmDataCnf = pEntryTbl->XmitImmDataCnf;
pModule->PCMEntryTbl.pcm_ds = pEntryTbl->pcm_ds;
}
else return ANDIS_RC_ALREADY_REG;
return ANDIS_RC_SUCCESS;
}
USHORT MNetAccessEnum (
const CHAR FAR * pszServer,
CHAR FAR * pszBasePath,
USHORT fsRecursive,
SHORT Level,
CHAR FAR ** ppBuffer,
USHORT FAR * pcEntriesRead ) {
USHORT usReturnCode,
cbTotalAvail;
SEL sel;
// get a 4K buffer
*ppBuffer = MGetBuffer(BIG_BUFFER_SIZE);
if (*ppBuffer == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
usReturnCode = NetAccessEnum(pszServer, pszBasePath, fsRecursive, Level,
*ppBuffer, BIG_BUFFER_SIZE, pcEntriesRead, & cbTotalAvail);
// is there more data? if so, allocate a big enough buffer to get it
if(usReturnCode == ERROR_MORE_DATA || usReturnCode == NERR_BufTooSmall)
{
NetApiBufferFree(*ppBuffer);
if (DEBUGALLOC(FULL_SEG_BUFFER_SIZE, & sel, SEG_NONSHARED))
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
*ppBuffer = MAKEP(sel, 0);
usReturnCode = NetAccessEnum(pszServer, pszBasePath, fsRecursive, Level,
*ppBuffer, FULL_SEG_BUFFER_SIZE, pcEntriesRead, & cbTotalAvail);
}
// If we're returning an error that's not moredata, or there are no
// entries to return, free the buffer first
if ((usReturnCode && usReturnCode != ERROR_MORE_DATA &&
usReturnCode != NERR_BufTooSmall) || *pcEntriesRead == 0) {
NetApiBufferFree(*ppBuffer);
}
return (usReturnCode);
}
VOID main(VOID)
{
USHORT usReturn_Code; /* Dos function Return Code */
PSZ pszName = SHARENAME; /* Shareable memory block name */
SEL selMem_Selector; /* Receive Segment selector */
PSZ pszSemName = SEMNAME; /* System semaphore name */
HSEM hsemSemHandle; /* System semaphore Handle */
WATCH FAR * Watch_Ptr; /* WATCH pointer */
/* Get Access to Shareable memory Block */
usReturn_Code = DosGetShrSeg(pszName, & selMem_Selector);
if (usReturn_Code == 0) {
Watch_Ptr = (WATCH FAR *) MAKEP(selMem_Selector,0);
DosOpenSem( & hsemSemHandle, /* Open System semaphore */
pszSemName);
DosSemRequest(hsemSemHandle, /* Waits for shared resources */
SEM_INDEFINITE_WAIT);
/* Restore Init value count if WATCHDOG enabled */
if (Watch_Ptr->Flag & ENABLE_MASK)
Watch_Ptr->Counter = Watch_Ptr->Counter_Init_Value ;
DosSemClear(hsemSemHandle); /* Release shared resources */
DosFreeSeg(selMem_Selector); /* Freeing Shared memory */
} else {
DosBeep(262,250);DosBeep(330,250);DosBeep(392,250);DosBeep(494,250);
DosBeep(392,250);DosBeep(330,250);DosBeep(262,250);
#ifdef DEBUG
printf("\n -*-*- STARTTPS Error Code %04x -*-*-\n",usReturn_Code);
printf(" -*- WatchDog not Started -*-\n");
#endif
} /* endif */
DosExit((USHORT) 0,usReturn_Code); /* Exit Process */
} /* end of main program */
/* adapters in turn. */
void InitScanDrivers (void)
{
PADDEntryPoint pADDEntry; /* .ADD entry point adapter */
PDevClassTableStruc pDCTable; /* Pointer to list of ADDs */
PDevClassTableEntry pDCEntry; /* Pointer to device entry */
int DeviceCount;
pDCTable= E2GetADDTable();
InitPrintVerbose ("Scanning Adapter device drivers:");
for (DeviceCount= pDCTable->DCCount,pDCEntry= pDCTable->DCTableEntries;
DeviceCount--;
pDCEntry++)
{
InitPrintVerbose (pDCEntry->DCName);
pADDEntry = (PVOID) MAKEP(pDCEntry->DCSelector,pDCEntry->DCOffset);
InitScanAdapter (pADDEntry);
}
}
void MPUTRACE_StrategyRead(PREQPACKET prp)
{
TRACE_EVENT __far *pte;
USHORT rc;
printf("MPUTRACE_StrategyRead\n");
rc = DevHelp_PhysToGDTSelector(prp->s.io.ulAddress, prp->s.io.usCount, selTrace);
if (rc)
int3();
pte = MAKEP(selTrace, 0);
while (!TraceRead(pte)) {
printf("MPUTRACE_StrategyRead blocking\n");
cli(); // yes, then block
fTraceWaiting = TRUE;
DevHelp_ProcBlock((ULONG) (void __far *) &fTraceEnabled, -1, 1);
fTraceWaiting = FALSE;
printf("MPUTRACE_StrategyRead released\n");
}
}
CHAR FAR * MGetBuffer(USHORT usSize) {
CHAR FAR * pBuffer;
SEL sel;
// see if i can use the static buffer
if (bBigBufferInUse || usSize > BIG_BUFFER_SIZE)
{
if (DEBUGALLOC(usSize, & sel, SEG_NONSHARED))
{
return(NULL);
}
pBuffer = MAKEP(sel, 0);
}
else if (pFirstBuffer)
{
#if defined(PMEMTRACE)
usNumStaticAllocs++;
#endif /* defined(PMEMTRACE) */
pBuffer = pFirstBuffer;
bBigBufferInUse = TRUE;
}
else
{
#if defined(PMEMTRACE)
usNumStaticAllocs++;
#endif /* defined(PMEMTRACE) */
if (!MAllocMem(BIG_BUFFER_SIZE, & pFirstBuffer))
{
return(NULL);
}
pBuffer = pFirstBuffer;
bBigBufferInUse = TRUE;
}
return (pBuffer);
}
USHORT MNetBiosEnum (
const CHAR FAR * pszServer,
SHORT Level,
CHAR FAR ** ppBuffer,
USHORT FAR * pcEntriesRead ) {
USHORT usReturnCode,
cbTotalAvail;
SEL sel;
// get a 4K buffer
*ppBuffer = MGetBuffer(BIG_BUFFER_SIZE);
if (*ppBuffer == NULL)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
usReturnCode = NetBiosEnum(pszServer, Level, *ppBuffer, BIG_BUFFER_SIZE,
pcEntriesRead, & cbTotalAvail);
// is there more data? if so, allocate a big enough buffer to get it
if(usReturnCode == ERROR_MORE_DATA || usReturnCode == NERR_BufTooSmall) {
NetApiBufferFree(*ppBuffer);
if (DEBUGALLOC(FULL_SEG_BUFFER_SIZE, & sel, SEG_NONSHARED))
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
*ppBuffer = MAKEP(sel, 0);
usReturnCode = NetBiosEnum(pszServer, Level, *ppBuffer, FULL_SEG_BUFFER_SIZE,
pcEntriesRead, & cbTotalAvail);
}
return (usReturnCode);
}
BOOL DumpDirectory(PDRIVEINFO pDrive, ULONG ulDirCluster, PSZ pszPath)
{
static BYTE szLongName[512];
int iIndex;
PDIRENTRY pDir;
PBYTE pbCluster;
PBYTE pbPath;
USHORT usClusters;
ULONG ulCluster;
ULONG ulBytesNeeded;
BYTE _huge * p;
PDIRENTRY pEnd;
BYTE bCheckSum, bCheck;
ULONG ulClustersNeeded;
ULONG ulClustersUsed;
ULONG ulEntries;
static BYTE szShortName[13];
if (!ulDirCluster)
{
printf("ERROR: Cluster for %s is 0!\n", pszPath);
return TRUE;
}
if (ulDirCluster == pDrive->bpb.RootDirStrtClus)
{
PULONG pulCluster;
ReadFATSector(pDrive, 0);
pulCluster = (PULONG)pDrive->pbFATSector;
printf("MEDIA BYTES in FAT: %8.8lX\n",
*pulCluster);
pulCluster = (PULONG)pDrive->pbFATSector + 1;
printf("DiskStatus: %8.8lX\n",
*pulCluster);
// vDumpSector(pDrive->pbFATSector);
}
//pDrive->ulTotalDirs++;
pbPath = malloc(512);
usClusters = GetClusterCount(pDrive, ulDirCluster);
ulTotalClusters += usClusters;
if (fDetailed > 2)
printf("\n\nDirectory of %s (%u clusters)\n\n", pszPath, usClusters);
ulBytesNeeded = (ULONG)pDrive->bpb.SectorsPerCluster * (ULONG)pDrive->bpb.BytesPerSector * usClusters;
pbCluster = calloc(usClusters, pDrive->bpb.SectorsPerCluster * pDrive->bpb.BytesPerSector);
if (!pbCluster)
{
printf("ERROR:Not enough memory!\n");
return FALSE;
}
ulCluster = ulDirCluster;
p = pbCluster;
while (ulCluster != FAT_EOF)
{
ReadCluster(pDrive, ulCluster);
memcpy(p, pDrive->pbCluster, pDrive->bpb.SectorsPerCluster * pDrive->bpb.BytesPerSector);
ulCluster = GetNextCluster(pDrive, ulCluster);
p += pDrive->bpb.SectorsPerCluster * pDrive->bpb.BytesPerSector;
}
memset(szLongName, 0, sizeof szLongName);
pDir = (PDIRENTRY)pbCluster;
pEnd = (PDIRENTRY)(pbCluster + ulBytesNeeded - sizeof (DIRENTRY));
ulEntries = 0;
bCheck = 0;
while (pDir <= pEnd)
{
if (fDetailed > 3)
{
ULONG ulOffset = (PBYTE)pDir - pbCluster;
if (ulOffset && !(ulOffset % 4096))
printf("-------- NEXT CLUSTER ----------\n");
}
if (pDir->bFileName[0] && pDir->bFileName[0] != 0xE5)
{
if (pDir->bAttr == FILE_LONGNAME)
{
if (fDetailed > 3)
{
printf("(longname)\n");
vDumpDirEntry(pDir);
}
if (strlen(szLongName) && bCheck != pDir->bReserved)
{
printf("A lost long filename was found: %s\n",
szLongName);
memset(szLongName, 0, sizeof szLongName);
}
bCheck = pDir->bReserved;
fGetLongName(pDir, szLongName, sizeof szLongName);
}
else
{
bCheckSum = 0;
for (iIndex = 0; iIndex < 11; iIndex++)
{
if (bCheckSum & 0x01)
{
bCheckSum >>=1;
bCheckSum |= 0x80;
}
else
bCheckSum >>=1;
bCheckSum += pDir->bFileName[iIndex];
}
if (strlen(szLongName) && bCheck != bCheckSum)
{
printf("The longname %s does not belong to %s\\%s\n",
szLongName, pszPath, MakeName(pDir, szShortName, sizeof szShortName));
memset(szLongName, 0, sizeof szLongName);
}
if (fDetailed > 2)
{
printf("%-8.8s.%-3.3s %2.2X ",
pDir->bFileName,
pDir->bExtention,
pDir->bAttr);
if (pDir->bAttr & FILE_DIRECTORY)
printf("<DIR> ");
else
printf("%10lu ", pDir->ulFileSize);
printf("%8.8lX ", MAKEP(pDir->wClusterHigh, pDir->wCluster));
if (pDir->fEAS)
printf("%2.2X ", pDir->fEAS);
else
printf(" ");
printf("%s\n", szLongName);
}
if (!(pDir->bAttr & FILE_DIRECTORY))
{
ulClustersNeeded = pDir->ulFileSize / pDrive->usClusterSize +
(pDir->ulFileSize % pDrive->usClusterSize ? 1:0);
ulClustersUsed = GetClusterCount(pDrive,(ULONG)pDir->wClusterHigh * 0x10000 + pDir->wCluster);
ulTotalClusters += ulClustersUsed;
if (ulClustersNeeded != ulClustersUsed)
{
printf("File allocation error detected for %s\\%s\n",
pszPath, MakeName(pDir, szShortName, sizeof szShortName));
printf("%lu clusters needed, %lu clusters allocated\n",
ulClustersNeeded, ulClustersUsed);
}
}
memset(szLongName, 0, sizeof szLongName);
}
ulEntries++;
}
/************************ 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;
}
USHORT NEAR ActivateMode( USHORT ReqHandle, USHORT MACMode, USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
return ANDIS_RC_SUCCESS;
}
USHORT NEAR ResetPort( USHORT ReqHandle, USHORT ResetType, USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
return ANDIS_RC_SUCCESS;
}
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);
}
}
}
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);
}
}
USHORT NEAR ReleaseNullDLC( USHORT ReqHandle, USHORT PortID, USHORT MACDS )
{
PMODULE pModule = MAKEP(MACDS,0);
return ANDIS_RC_SUCCESS;
}
main() {
printf("Cells - A Cellular Automata Demo for OS/2 2.0 \n");
printf(" By John E. Stone \n");
printf("For comments send E-Mail to: [email protected] \n");
printf("\n\n\n\n\n");
printf("The number of states is how many different colors\n");
printf("a pixel can take on. The larger the number of states\n");
printf("the longer it takes to complete, and it may even become\n");
printf("stagnant with more than 20 states.\n\n");
printf("\nProcess ID=%d\n",getpid());
printf("Would you like cells to continue processing when it\n");
printf("isn't visible on the screen? (1=no, 0=yes) \n");
scanf("%u",&VWAIT);
if ((VWAIT<0) || (VWAIT>1)) VWAIT=0;
printf("\n\nEnter the number of states in the system: (5-25) \n");
scanf("%d",&temp2);
st=10;
srand(getpid());
if ((temp2>4) || (temp2<26)) { st=temp2; }
/* setup for graphics mode */
phys.pBuf=(unsigned char *) 0xA0000;
phys.cb=65536;
moda.cb=12;
moda.fbType=3;
moda.color=8;
moda.row=25;
moda.col=40;
moda.hres=320;
moda.vres=200;
VioGetMode(&orig, HANDLE);
VioSetMode(&moda, HANDLE);
VioGetPhysBuf(&phys, 0);
ptr0=MAKEP(phys.asel[0], 0);
VioScrLock(1, &status, HANDLE); /* Wait for exclusive screenlock */
cls(ptr0,0);
for (i=0; i<=xs; i++) {
for (j=0; j<=ys; j++) {
nz[i][j]=(char) rand() % st;
oz[i][j]=nz[i][j];
}
}
numchange=1;
while ((kbhit()==0) && (numchange>0)) {
numchange=0;
for (i=0; i<=xs; i++) {
for (j=0; j<=ys; j++) {
for (x=0; x<=3; x++) {
k=(i+nx[x]+xc) % xc;
l=(j+ny[x]+yc) % yc;
if (oz[k][l]==((oz[i][j]+1) % st)) {
nz[i][j]=(oz[k][l] % st);
numchange++;
}
}
}
}
memcpy(oz,nz,sizeof(nz));
VioScrLock(VWAIT,&status,HANDLE);
if (!status) {
for (i=0; i<VRES; i++) {
for (j=0; j<HRES; j++) {
temp=COLORSET+nz[j][i];
putpixel(ptr0,j,i,temp);
}
}
}
VioScrUnLock(HANDLE);
}
VioScrLock(WAIT,&status,HANDLE);
cls(ptr0,0);
VioScrUnLock(HANDLE);
} /* end of cells.c */
int set_ea(char FAR *i_eas, char *name)
{
#ifdef HAVE_EAS
int rc=0;
char FAR *eas;
unsigned int i, total;
#if TARGET==OS2
#ifdef __32BIT__
FILESTATUS4 fs;
EAOP2 eaop;
char FAR *real_pfeal;
PFEA2LIST pfeal;
PFEA2 pf, opf;
#else
EAOP eaop;
PFEALIST pfeal;
PFEA pf;
FILESTATUS2 fs;
SEL selector;
#endif
#elif TARGET==WIN32
PFEALIST pfeal0, pfeal;
PFEA pf;
struct nt_sid *sid;
unsigned char *pstreambuf, *streambuf;
WIN32_STREAM_ID w32sid;
unsigned long stream_len;
#endif
eas=i_eas;
if(discard_ea(name))
return(-1);
if((total=mget_word(eas))==0)
return(0);
#if TARGET==OS2
#ifdef __32BIT__
/* This takes the 4-byte prefixes into account (are the V1.2 EAs still
valid if they flow beyond 64K when the oNextEntryOffset is applied?).
Also, we ensure that it is aligned properly. In theory, there may be
a way to crash this (72K doesn't consider the multitude of EAs) but we
don't know/care about it -- ASR 17/10/2000 */
real_pfeal=(char FAR *)farmalloc_msg(73728);
pfeal=(PFEA2LIST)align_dword(real_pfeal);
eaop.fpFEA2List=pfeal;
#else
if(DosAllocSeg(65535U, &selector, SEG_NONSHARED))
return(-1);
pfeal=(PFEALIST)MAKEP(selector, 0);
eaop.fpFEAList=pfeal;
#endif
#elif TARGET==WIN32
pstreambuf=(char *)farmalloc_msg(65536+260*total);
pfeal=pfeal0=(PFEALIST)(streambuf=align_dword(pstreambuf));
#endif
eas+=2;
pf=&pfeal->list[0];
for(i=0; i<total; i++)
{
#if TARGET==OS2&&defined(__32BIT__)
opf=pf;
#endif
#if TARGET==WIN32
pf=&pfeal->list[0];
#endif
pf->fEA=mget_byte(eas++);
pf->cbName=mget_byte(eas++);
pf->cbValue=mget_word(eas);
eas+=2;
#if TARGET==OS2&&defined(__32BIT__)
far_memmove((char FAR *)pf+sizeof(FEA2)-1, eas, pf->cbName);
*((char FAR *)pf+sizeof(FEA2)-1+pf->cbName)='\0';
#else /* Win32 or OS/2-16 */
far_memmove((char FAR *)pf+sizeof(FEA), eas, pf->cbName);
*((char FAR *)pf+sizeof(FEA)+pf->cbName)='\0';
#endif
eas+=pf->cbName;
#if TARGET==OS2&&defined(__32BIT__)
far_memmove((char FAR *)pf+sizeof(FEA2)+pf->cbName, eas, pf->cbValue);
#else /* Win32 or OS/2-16 */
far_memmove((char FAR *)pf+sizeof(FEA)+pf->cbName+1, eas, pf->cbValue);
#endif
eas+=pf->cbValue;
#if SFX_LEVEL>=ARJ
#if TARGET==OS2&&defined(__32BIT__)
if(ea_filter((char FAR *)pf+sizeof(FEA2), 0)&&((pf->fEA&FEA_NEEDEA)||!crit_eas))
#else /* Win32 or OS/2-16 */
if(ea_filter((char FAR *)pf+sizeof(FEA), 0)&&((pf->fEA&FEA_NEEDEA)||!crit_eas))
#endif
#endif
/* Update the offsets */
#if TARGET==OS2
#ifdef __32BIT__
pf=(PFEA2)((char FAR *)pf+sizeof(FEA2)+pf->cbName+pf->cbValue);
#else
pf=(PFEA)((char FAR *)pf+sizeof(FEA)+pf->cbName+1+pf->cbValue);
#endif
/* Align at DWORD boundary and issue the list fixups */
#ifdef __32BIT__
pf=(PFEA2)align_dword((char FAR *)pf);
opf->oNextEntryOffset=(i+1==total)?0:(char FAR *)pf-(char FAR *)opf;
#endif
#elif TARGET==WIN32
pfeal=(PFEALIST)((char FAR *)pfeal+sizeof(FEALIST)+pf->cbName+1+pf->cbValue);
if(i<total-1)
pfeal=(PFEALIST)align_dword((char FAR*)pfeal);
pfeal0->cbList=(i==total-1)?
0:
(((char FAR *)pfeal)-((char FAR *)pfeal0));
pfeal0=pfeal;
#endif
}
#if TARGET==OS2
pfeal->cbList=(char FAR *)pf-(char FAR *)pfeal;
#ifdef __32BIT__
rc=DosSetPathInfo((PSZ)name, FIL_QUERYEASIZE, (PBYTE)&eaop, sizeof(eaop), 0);
farfree(real_pfeal);
#else
rc=DosSetPathInfo((PSZ)name, FIL_QUERYEASIZE, (PBYTE)&eaop, sizeof(eaop), 0, 0L);
DosFreeSeg(selector);
#endif
if(!rc)
{
#ifdef __32BIT__
if(DosQueryPathInfo(name, FIL_QUERYEASIZE, (PVOID)&fs, sizeof(fs)))
#else
if(DosQPathInfo(name, FIL_QUERYEASIZE, (PVOID)&fs, sizeof(fs), 0L))
#endif
rc=-1;
else
if(fs.cbList<=4)
rc=-1;
}
#elif TARGET==WIN32
if((sid=open_streams(name, 1))==NULL)
rc=-1;
else
{
memset(&w32sid, 0, sizeof(w32sid));
w32sid.dwStreamId=BACKUP_EA_DATA;
w32sid.Size.LowPart=stream_len=(((char FAR *)pfeal)-streambuf);
if(create_stream(&w32sid, sid)||write_stream(streambuf, stream_len, sid)<stream_len)
rc=-1;
close_streams(sid);
}
free(pstreambuf);
#endif
return(rc);
#else
return(-1);
#endif
}
