fprintf (fout, "usbdAddressGet() returned %d\n", s);    else	fprintf (fout, "current address = 0x%x\n", address);    return RET_CONTINUE;    }/*************************************************************************** cmdSetAddress - set USB address for a node** RETURNS:  RET_CONTINUE;*/LOCAL UINT16 cmdSetAddress    (    pVOID Param,		/* Generic parameter passed down */    char **ppCmd,		/* Ptr to remainder of cmd line */    FILE *fin,			/* stream for input (if any) */    FILE *fout			/* stream for output (if any) */    )    {    long nodeId;    long address;    UINT16 s;    /* Extract parameters. */    *ppCmd = GetHexToken (*ppCmd, &nodeId, -1);    *ppCmd = GetHexToken (*ppCmd, &address, -1);    /* Validate parameters */    if (nodeId == -1 || address == -1)	{	fprintf (fout, "Must specify a node id and address value.\n");	return RET_CONTINUE;	}    /* Execute function. */    s = usbdAddressSet (usbdClientHandle, (GENERIC_HANDLE) nodeId, (UINT16) address);    fprintf (fout, "usbdAddressnSet() returned %d\n", s);    return RET_CONTINUE;    }/*************************************************************************** cmdSetFeature - set a USB feature** RETURNS:  RET_CONTINUE;*/LOCAL UINT16 cmdSetFeature    (    pVOID Param,		/* Generic parameter passed down */    char **ppCmd,		/* Ptr to remainder of cmd line */    FILE *fin,			/* stream for input (if any) */    FILE *fout			/* stream for output (if any) */    )    {    long nodeId;    long featureType;    long feature;    long index;    UINT16 s;    /* Extract parameters. */    *ppCmd = GetHexToken (*ppCmd, &nodeId, -1);    *ppCmd = GetHexToken (*ppCmd, &featureType, -1);    *ppCmd = GetHexToken (*ppCmd, &feature, -1);    *ppCmd = GetHexToken (*ppCmd, &index, -1);    /* Validate parameters */    if (nodeId == -1 || featureType == -1 || feature == -1 || index == -1)	{	fprintf (fout, "Must specify a node id, feature type, selector, and index.\n");	return RET_CONTINUE;	}    /* Execute function. */    s = usbdFeatureSet (usbdClientHandle, (GENERIC_HANDLE) nodeId, featureType, feature, index);    fprintf (fout, "usbdFeatureSet() returned %d\n", s);    return RET_CONTINUE;    }/*************************************************************************** cmdClrFeature - clear a USB feature** RETURNS:  RET_CONTINUE;*/LOCAL UINT16 cmdClrFeature    (    pVOID Param,		/* Generic parameter passed down */    char **ppCmd,		/* Ptr to remainder of cmd line */    FILE *fin,			/* stream for input (if any) */    FILE *fout			/* stream for output (if any) */    )    {    long nodeId;    long featureType;    long feature;    long index;    UINT16 s;    /* Extract parameters. */    *ppCmd = GetHexToken (*ppCmd, &nodeId, -1);    *ppCmd = GetHexToken (*ppCmd, &featureType, -1);    *ppCmd = GetHexToken (*ppCmd, &feature, -1);    *ppCmd = GetHexToken (*ppCmd, &index, -1);    /* Validate parameters */    if (nodeId == -1 || featureType == -1 || feature == -1 || index == -1)	{	fprintf (fout, "Must specify a node id, feature type, selector, and index.\n");	return RET_CONTINUE;	}    /* Execute function. */    s = usbdFeatureClear (usbdClientHandle, (GENERIC_HANDLE) nodeId, featureType, feature, index);    fprintf (fout, "usbdFeatureClear() returned %d\n", s);    return RET_CONTINUE;    }/*************************************************************************** cmdGetDescr - retrieve a USB descriptor** RETURNS:  RET_CONTINUE;*/LOCAL UINT16 cmdGetDescr    (    pVOID Param,		/* Generic parameter passed down */    char **ppCmd,		/* Ptr to remainder of cmd line */    FILE *fin,			/* stream for input (if any) */    FILE *fout			/* stream for output (if any) */    )    {    long nodeId;    long requestType;    long descriptorType;    long index;    long languageId;    long length;    UINT8 * pDescrBuf;    UINT16 actLen;    UINT16 s;    /* Extract parameters. */    *ppCmd = GetHexToken (*ppCmd, &nodeId, -1);    *ppCmd = GetHexToken (*ppCmd, &requestType, -1);    *ppCmd = GetHexToken (*ppCmd, &descriptorType, -1);    *ppCmd = GetHexToken (*ppCmd, &index, -1);    *ppCmd = GetHexToken (*ppCmd, &languageId, -1);    *ppCmd = GetHexToken (*ppCmd, &length, -1);    /* Validate parameters */    if (nodeId == -1 || requestType == -1 || descriptorType == -1 || index == -1 	|| languageId == -1 || length == -1)	{	fprintf (fout, "Must specify a node id, descr. type, index, language, and length.\n");	return RET_CONTINUE;	}    if (length > GENERIC_USB_BFR)	{	fprintf (fout, "length must be 0x%x or less.\n", 	    (unsigned int) GENERIC_USB_BFR);	return RET_CONTINUE;	}    if ((pDescrBuf = OSS_MALLOC (GENERIC_USB_BFR)) == NULL)        return RET_CONTINUE;    /* Execute function. */    s = usbdDescriptorGet (usbdClientHandle, 			   (GENERIC_HANDLE) nodeId, 			   requestType, 			   descriptorType, 			   index, 			   languageId, 			   length, 			   pDescrBuf, 			   &actLen);    if (s != OK)	fprintf (fout, "usbdDescriptorGet() returned %d\n", s);    else	{	fprintf (fout, "actLen = 0x%x (%d) bytes\n", actLen, actLen);	displayMem (actLen, pDescrBuf, fout);	}    OSS_FREE (pDescrBuf);    return RET_CONTINUE;    }/*************************************************************************** cmdGetSynchFrame - retrieve current synch frame from a device endpoint** RETURNS:  RET_CONTINUE;*/LOCAL UINT16 cmdGetSynchFrame    (    pVOID Param,		/* Generic parameter passed down */    char **ppCmd,		/* Ptr to remainder of cmd line */    FILE *fin,			/* stream for input (if any) */    FILE *fout			/* stream for output (if any) */    )    {    long nodeId;    long endpoint;    UINT16 * pSynchFrame;    UINT16 s;    /* Extract parameters. */    *ppCmd = GetHexToken (*ppCmd, &nodeId, -1);    *ppCmd = GetHexToken (*ppCmd, &endpoint, -1);    /* Validate parameters */    if (nodeId == -1 || endpoint == -1)	{	fprintf (fout, "Must specify a node id and endpoint.\n");	return RET_CONTINUE;	}    if ((pSynchFrame = OSS_MALLOC (sizeof (UINT16))) == NULL)        return RET_CONTINUE;    /* Execute function. */    if ((s = usbdSynchFrameGet (usbdClientHandle, 				(GENERIC_HANDLE) nodeId, 				endpoint, 				pSynchFrame)) 			!= OK)	fprintf (fout, "usbdSynchFrameGet() returned %d\n", s);    else	fprintf (fout, "synch frame = 0x%4.4x\n", FROM_LITTLEW (*pSynchFrame));    OSS_FREE (pSynchFrame);    return RET_CONTINUE;    }/*************************************************************************** cmdGetCurrentFrame - retrieve current frame for a USB** RETURNS:  RET_CONTINUE*/LOCAL UINT16 cmdGetCurrentFrame    (    pVOID Param,		/* Generic parameter passed down */    char **ppCmd,		/* Ptr to remainder of cmd line */    FILE *fin,			/* stream for input (if any) */    FILE *fout			/* stream for output (if any) */    )    {    long nodeId;    UINT32 frameNo;    UINT32 frameWindow;    UINT16 s;    /* Extract parameters. */    *ppCmd = GetHexToken (*ppCmd, &nodeId, -1);    /* Validate parameters */    if (nodeId == -1)	{	fprintf (fout, "Must specify a node id.\n");	return RET_CONTINUE;	}    /* Execute function. */    if ((s = usbdCurrentFrameGet (usbdClientHandle, (GENERIC_HANDLE) nodeId, 	&frameNo, &frameWindow)) != OK)	fprintf (fout, "usbdCurrentFrameGet() returned %d\n", s);    else	{	fprintf (fout, "frame number = %ld\n", (long) frameNo);	fprintf (fout, "frame window = %ld\n", (long) frameWindow);	}    return RET_CONTINUE;    }/*************************************************************************** enterThread - waits for user to press [enter]** RETURNS:  N/A*/LOCAL VOID enterThread    (    pVOID param    )    {    FILE *fout = (FILE *) param;    char bfr [256];    fprintf (fout, "Press [enter] to terminate polling.\n");    gets (bfr);    enterPressed = TRUE;    }/*************************************************************************** irpCallback - called when IRP completes** RETURNS:  N/A*/LOCAL VOID irpCallback    (    pVOID pIrp    )    {    irpCallbackInvoked = TRUE;    }/*************************************************************************** cmdIntPoll - polls interrupt endpoint for input** Continuously reads IN packets from interrupt endpoint until key * pressed.** RETURNS:  RET_CONTINUE*/LOCAL UINT16 cmdIntPoll    (    pVOID Param,		/* Generic parameter passed down */    char **ppCmd,		/* Ptr to remainder of cmd line */    FILE *fin,			/* stream for input (if any) */    FILE *fout			/* stream for output (if any) */    )    {    THREAD_HANDLE thread;    long nodeId;    long endpoint;    long length;    USBD_PIPE_HANDLE handle;    char bfr [256];    USB_IRP irp;    UINT16 s;    /* Extract parameters. */    *ppCmd = GetHexToken (*ppCmd, &nodeId, -1);    *ppCmd = GetHexToken (*ppCmd, &endpoint, -1);    *ppCmd = GetHexToken (*ppCmd, &length, USB_MIN_CTRL_PACKET_SIZE);    /* Validate parameters */    if (nodeId == -1 || endpoint == -1)	{	fprintf (fout, "Must specify a node id and endpoint.\n");	return RET_CONTINUE;	}    if (length > sizeof (bfr))	{	fprintf (fout, "Length must be %d or less.\n", (int) sizeof (bfr));	return RET_CONTINUE;	}    /* Create a pipe to talk to this endpoint */    if ((s = usbdPipeCreate (usbdClientHandle, (GENERIC_HANDLE) nodeId, (UINT16) endpoint, 0, 0,	USB_XFRTYPE_INTERRUPT, USB_DIR_IN, length, length, INT_PIPE_SRVC_INTERVAL,	&handle)) != OK)	{	fprintf (fout, "usbdPipeCreate() returned %d\n", s);	return RET_CONTINUE;	}    /* Create thread to watch for keypress */    enterPressed = FALSE;    if (OSS_THREAD_CREATE (enterThread, (pVOID) fout, OSS_PRIORITY_INHERIT, "tEnter",	&thread) != OK)	goto pipe_done;    while (!enterPressed)	{	/* initialize IRP */	memset (&irp, 0, sizeof (irp));	irp.irpLen = sizeof (irp);	irp.userCallback = irpCallback;	irp.transferLen = length;	irp.bfrCount = 1;	irp.bfrList [0].pid = USB_PID_IN;	irp.bfrList [0].pBfr = bfr;	irp.bfrList [0].bfrLen = length;    	irpCallbackInvoked = FALSE;	if ((s = usbdTransfer (usbdClientHandle, handle, &irp)) != OK)	    {	    fprintf (fout, "usbdTransfer() returned %d\n", s);	    break;	    }	while (!enterPressed && !irpCallbackInvoked)	    OSS_THREAD_SLEEP (1);	if (irpCallbackInvoked)	    {	    if (irp.result != OK)		{		fprintf (fout, "irp.result == %d\n", irp.result);		break;		}	    fprintf (fout, "actLen = %d: ", irp.bfrList [0].actLen);	    displayMem (irp.bfrList [0].actLen, bfr, fout);	    }	else	    {	    if ((s = usbdTransferAbort (usbdClientHandle, handle, &irp)) 		!= OK)		{		fprintf (fout, "usbdTransferAbort() returned %d\n", s);		break;		}	    /* wait for the callback to be invoked */	    while (!irpCallbackInvoked)		OSS_THREAD_SLEEP (1);	    }	}    OSS_THREAD_DESTROY (thread);pipe_done:    if ((s = usbdPipeDestroy (usbdClientHandle, handle)) != OK)	{	fprintf (fout, "usbdPipeDestroy() returned %d\n", s);	return RET_CONTINUE;	}    return RET_CONTINUE;    }#ifdef INCLUDE_USB_KEYBOARD/*************************************************************************** cmdKbdInit - initializes USB keyboard SIO driver** RETURNS: RET_CONTINUE*/LOCAL UINT16 cmdKbdInit    (    pVOID Param,		/* Generic parameter passed down */    char **ppCmd,		/* Ptr to remainder of cmd line */    FILE *fin,			/* stream for input (if any) */    FILE *fout			/* stream for output (if any) */    )    {    if (usbKeyboardDevInit () == OK)	fprintf (fout, "usbKeyboardDevInit() returned OK\n");    else	fprintf (fout, "usbKeyboardDevInit() returned ERROR\n");    return RET_CONTINUE;    }/*************************************************************************** cmdKbdDown - shuts down USB keyboard SIO driver** RETURNS: RET_CONTINUE*/LOCAL UINT16 cmdKbdDown    (    pVOID Param,		/* Generic parameter passed down */    char **ppCmd,		/* Ptr to remainder of cmd line */    FILE *fin,			/* stream for input (if any) */    FILE *fout			/* stream for output (if any) */    )    {    if (usbKeyboardDevShutdown () == OK)	fprintf (fout, "usbKeyboardDevShutdown() returned OK\n");    else	fprintf (fout, "usbKeyboardDevShutdown() returned ERROR\n");    return RET_CONTINUE;    }/*************************************************************************** kbdAttachCallback - receives callbacks from USB keyboard SIO driver** RETURNS: N/A*/LOCAL SIO_CHAN *pKbdSioChan;LOCAL VOID kbdAttachCallback    (    pVOID arg,			    /* caller-defined argument */    SIO_CHAN *pChan,		    /* pointer to affected SIO_CHAN */    UINT16 attachCode		    /* defined as USB_KBD_xxxx */    )    {    FILE *fout = (FILE *) arg;    fprintf (fout, "pChan = %p, attach code = %s\n", pChan,	(attachCode == USB_KBD_ATTACH) ? "USB_KBD_ATTACH" : "USB_KBD_REMOVE");    if (attachCode == USB_KBD_ATTACH)	{	if (pKbdSioChan == NULL)	    {	    if (usbKeyboardSioChanLock (pChan) != OK)		fprintf (fout, "usbKeyboardSioChanLock() returned ERROR\n");	    else		pKbdSioChan = pChan;	    }