usrusbtool.c

VxWorks BSP for S3C2510A

LOCAL STATUS prnTxCallback
    (
    void *callbackParam,
    char *txChar
    )

    {
    /* If no more chars to send, return an error */

    if (txCharCount == 0)
	return ERROR;

    txCharCount--;


    /* Check if running a pattern test or a file dump */

    if (patternTest)
	{
	/* Running a pattern test.  Return the next pattern char */

	if ((nextCharVal & 1) == 0)
	    *txChar = nextCharVal >> 8;
	else
	    *txChar = nextCharVal & 0xff;

	nextCharVal++;
	}
    else
	{
	/* Running a file dump test.  Return the next char from file */

	if (txBfrCount == 0 && txCharCount > 0)
	    {
	    /* Read next buffer from file */

	    txBfrCount = fread (txBfr, sizeof (char), sizeof (txBfr), txFile);
	    txBfrIndex = 0;
	    }

	if (txCharCount == 0 || txBfrCount == 0)
	    {
	    closeTxFile ();
	    txCharCount = 0;
	    }

	if (txBfrCount == 0)
	    return ERROR;

	*txChar = txBfr [txBfrIndex++];
	--txBfrCount;
	}

    return OK;
    }


/*************************************************************************
*
* prnAttachCallback - receives attach callbacks from printer SIO driver
*
* RETURNS: N/A
*/

LOCAL SIO_CHAN *pPrnSioChan;

LOCAL VOID prnAttachCallback
    (
    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_PRN_ATTACH) ? "USB_PRN_ATTACH" : "USB_PRN_REMOVE");

    if (attachCode == USB_PRN_ATTACH)
	{
	if (pPrnSioChan == NULL)
	    {
	    if (usbPrinterSioChanLock (pChan) != OK)
		fprintf (fout, "usbPrinterSioChanLock() returned ERROR\n");
	    else
		{
		pPrnSioChan = pChan;

		if ((*pPrnSioChan->pDrvFuncs->callbackInstall) (pPrnSioChan, 
		    	SIO_CALLBACK_GET_TX_CHAR, 
	 	 	(STATUS  (*) (void *, ...)) prnTxCallback, 
			NULL) != OK)
		    {
		    fprintf (fout, "callbackInstall() returned ERROR.\n");
		    }
		}
	    }
	else
	    {
	    fprintf (fout, "Another channel already in use, ignored.\n");
	    }
	}
    else
	{
	if (pChan == pPrnSioChan)
	    {
	    if (usbPrinterSioChanUnlock (pChan) != OK)
		fprintf (fout, "usbPrinterSioChanUnlock() returned ERROR\n");

	    pPrnSioChan = NULL;
	    }
	}
    }


/*************************************************************************
*
* cmdPrnInit - initializes USB printer SIO driver
*
* RETURNS: RET_CONTINUE
*/

LOCAL BOOL prnInitialized = FALSE;

LOCAL UINT16 cmdPrnInit
    (
    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 (prnInitialized)
	{
	fprintf (fout, "USB printer SIO driver already initialized.\n");
	return RET_CONTINUE;
	}

    if (usbPrinterDevInit () == OK)
	{
	fprintf (fout, "usbPrinterDevInit() returned OK\n");
	prnInitialized = TRUE;

	/* Register for attach notification */

	if (usbPrinterDynamicAttachRegister (prnAttachCallback, (pVOID) fout) != OK)
	    {
	    fprintf (fout, "usbPrinterDynamicAttachRegister() returned ERROR\n");
	    return RET_CONTINUE;
	    }
	}
    else
	fprintf (fout, "usbPrinterDevInit() returned ERROR\n");

    return RET_CONTINUE;
    }


/*************************************************************************
*
* cmdPrnDown - shuts down USB printer SIO driver
*
* RETURNS: RET_CONTINUE
*/

LOCAL UINT16 cmdPrnDown
    (
    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 (!prnInitialized)
	{
	fprintf (fout, "USB printer SIO driver not initialized.\n");
	return RET_CONTINUE;
	}

    prnInitialized = FALSE;
    pPrnSioChan = NULL;

    /* unregister */

    if (usbPrinterDynamicAttachUnRegister (prnAttachCallback, (pVOID) fout) != OK)
	fprintf (fout, "usbPrinterDynamicAttachUnRegister() returned ERROR\n");

    if (usbPrinterDevShutdown () == OK)
	fprintf (fout, "usbPrinterDevShutdown() returned OK\n");
    else
	fprintf (fout, "usbPrinterDevShutdown() returned ERROR\n");

    return RET_CONTINUE;
    }


/*************************************************************************
*
* waitForPrinter - waits for a printer to be connected
*
* RETURNS: OK if printer connected, else ERROR
*/

LOCAL STATUS waitForPrinter 
    (
    FILE *fout
    )

    {
    THREAD_HANDLE thread;
    UINT8 * pBfr;
    USB_PRINTER_CAPABILITIES * pCaps;
    UINT16 idLen;
    UINT8 protocol;
    UINT16 i;


    /* Create thread to watch for keypress */

    enterPressed = FALSE;

    if (OSS_THREAD_CREATE (enterThread, 
			   (pVOID) fout, 
			   OSS_PRIORITY_INHERIT, 
			   "tEnter",
			   &thread) 
			!= OK)
	{
	fprintf (fout, "Error creating thread.\n");
	return ERROR;
	}


    /* Wait for a printer to be attached. */

    if (pPrnSioChan == NULL)
	{
	fprintf (fout, "Waiting for printer to be attached...\n");
	while (!enterPressed && pPrnSioChan == NULL)
	    OSS_THREAD_SLEEP (1);
	}


    /* kill keypress thread */

    OSS_THREAD_DESTROY (thread);

    if (enterPressed)
	return ERROR;

    if ((pBfr = OSS_MALLOC (USB_PRN_MAX_DEVICE_ID_LEN)) == NULL)
        return ERROR;

    pCaps = (USB_PRINTER_CAPABILITIES *) pBfr;

    /* Display the printer characteristics. */
    if ((*pPrnSioChan->pDrvFuncs->ioctl) (pPrnSioChan, 
					  SIO_USB_PRN_DEVICE_ID_GET, 
					  (void *) pBfr) 
					!= OK)
	fprintf (fout, "ioctl (SIO_USB_PRN_DEVICE_ID_GET) returned ERROR.\n");
    else
	{
	idLen = FROM_BIGW (pCaps->length);
	fprintf (fout, "Device ID length = %d\n", idLen);
	fprintf (fout, "Device ID = ");
	for (i = 0; i < idLen - 2; i++)
	    fprintf (fout, "%c", pCaps->caps [i]);
	fprintf (fout, "\n");
	}

    if ((*pPrnSioChan->pDrvFuncs->ioctl) (pPrnSioChan, SIO_USB_PRN_PROTOCOL_GET,
	(void *) &protocol) != OK)
	fprintf (fout, "ioctl (SIO_USB_PRN_PROTOCOL_GET) returned ERROR.\n");
    else
	{
	fprintf (fout, "protocol = 0x%x ", protocol);
	switch (protocol)
	    {
	    case USB_PROTOCOL_PRINTER_UNIDIR:
		fprintf (fout, "(USB_PROTOCOL_PRINTER_UNIDIR)\n");
		break;

	    case USB_PROTOCOL_PRINTER_BIDIR:
		fprintf (fout, "(USB_PROTOCOL_PRINTER_BIDIR)\n");
		break;

	    default:
		fprintf (fout, "(unknown)\n");
		break;
	    }
	}

    OSS_FREE (pBfr);

    return OK;
    }


/*************************************************************************
*
* cmdPrint - performs printer test
*
* RETURNS: RET_CONTINUE
*/

LOCAL UINT16 cmdPrint
    (
    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 blocks;


    /* Get parameters */

    *ppCmd = GetHexToken (*ppCmd, &blocks, 1);


    /* Wait for a printer to be connected */

    if (waitForPrinter (fout) == OK)
	{
	/* trigger a transmission. */

	patternTest = TRUE;
	nextCharVal = 0;
	txCharCount = blocks * 4096;

	fprintf (fout, "sending %d 4k blocks to printer...\n", (UINT16) blocks);

	if ((*pPrnSioChan->pDrvFuncs->txStartup) (pPrnSioChan) != OK)
	    fprintf (fout, "txStartup() returned ERROR.\n");
	}

    return RET_CONTINUE;
    }


/*************************************************************************
*
* cmdPrintFnm - sends file to printer
*
* RETURNS: RET_CONTINUE
*/

LOCAL UINT16 cmdPrintFnm
    (
    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) */
    )

    {
    char fnm [MAX_CMD_LEN];
    FILE *f;
    long fsize;


    /* Get filename parameter */

    *ppCmd = GetNextToken (*ppCmd, fnm, sizeof (fnm));


    /* Terminate any current dump test */

    closeTxFile ();


    /* Attempt to open file */

    if ((f = fopen (fnm, "rb")) == NULL)
	{
	fprintf (fout, "Unable to open '%s'.\n", fnm);
	return RET_CONTINUE;
	}


    /* Determine file size */

    fseek (f, 0, SEEK_END);
    fsize = ftell (f);

    fprintf (fout, "file '%s' is %ld bytes.\n", fnm, fsize);

    fseek (f, 0, SEEK_SET);


    /* Wait for printer */

    if (waitForPrinter (fout) == OK)
	{
	/* Initiate transmission */

	patternTest = FALSE;
	txFile = f;
	txBfrCount = 0;
	txCharCount = fsize;

	fprintf (fout, "sending %ld bytes to printer...\n", fsize);

	if ((*pPrnSioChan->pDrvFuncs->txStartup) (pPrnSioChan) != OK)
	    {
	    fprintf (fout, "txStartup() returned ERROR.\n");
	    closeTxFile ();
	    }

	/* NOTE: If this path is successful, the file will be closed by
	 * the prnTxCallback().
	 */

	}
    else
	{

	/* Close input file */

	fclose (f);
	}
    
    return RET_CONTINUE;
    }
#endif	/*INCLUDE_USB_PRINTER*/

#ifdef INCLUDE_USB_LOOPBACK
/*************************************************************************
*
* loopbackAttachCallback - receives attach callbacks from USB loopback driver
*
* RETURNS: N/A
*/

LOCAL USB_LOOPBACK_CHAN *pLoopbackChan;

LOCAL VOID loopbackAttachCallback
    (
    pVOID arg,			    /* caller-defined argument */
    USB_LOOPBACK_CHAN *pChan,		    /* pointer to affected USB_LOOPBACK_CHAN */
    UINT16 attachCode		    /* defined as USB_KBD_xxxx */
    )

    {
    FILE *fout = (FILE *) arg;
    UINT8 *pProtocol = NULL;   

    fprintf (fout, "pChan = %p, attach code = %s\n", pChan,
	(attachCode == USB_LOOPBACK_ATTACH) ? "USB_LOOPBACK_ATTACH" : "USB_LOOPBACK_REMOVE");

    if (attachCode == USB_LOOPBACK_ATTACH)
	{
	if (pLoopbackChan == NULL)
	    {
	    if (usbLoopbackChanLock (pChan) != OK)
		fprintf (fout, "usbLoopbackChanLock() returned ERROR\n");
	    else
		{
		pLoopbackChan = pChan;

		/* Here we can query for suuported loopback modes */
		pProtocol = OSS_MALLOC(sizeof (*pProtocol));
		if (pProtocol == NULL)
		{
			fprintf (fout, "USB_LOOPBACK_PROTOCOL_GET:memory alloc failed.\n");
			return;
    }

    /* Display the printer characteristics. */
    if ((*pLoopbackChan->pDrvFuncs->ioctl) (pLoopbackChan,
					  USB_LOOPBACK_PROTOCOL_GET,
					  (void *)pProtocol)
					!= OK)
		{
	     fprintf (fout, "ioctl (USB_LOOPBACK_PROTOCOL_GET) returned ERROR.\n");
    }
    else
	  {
    	fprintf (fout, "\nDevice supports following loopback modes:\n");
      if(USB_IS_CTRL_LOOPBACK_SUPPORTED(*pProtocol))
      fprintf (fout, "Control Loopback\n");
      if(USB_IS_BULK_LOOPBACK_SUPPORTED(*pProtocol))
      fprintf (fout, "Bulk Loopback\n");
      if(USB_IS_INT_LOOPBACK_SUPPORTED(*pProtocol))
      fprintf (fout, "Interrupt Loopback\n");
      if(USB_IS_ISOCH_LOOPBACK_SUPPORTED(*pProtocol))
      fprintf (fout, "Isochronous Loopback\n");
	  }
		}
	    }
	else
	    {
	    fprintf (fout, "Another channel already in use, ignored.\n");
	    }
	}
    else /* USB_LOOPBACK_REMOVE */
	{
	if (pChan == pLoopbackChan)
	    {
	    if (usbLoopbackChanUnlock (pChan) != OK)
		fprintf (fout, "usbLoopbackChanUnlock() returned ERROR\n");
	    pLoopbackChan = NULL;
	    }
	}
    }

/*************************************************************************
*
* cmdLoopbackInit - initializes USB loopback driver
*
* RETURNS: RET_CONTINUE
*/

LOCAL BOOL loopbackInitialized = FALSE;

LOCAL UINT16 cmdLoopbackInit
    (
    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 (loopbackInitialized)
	{
	fprintf (fout, "USB loopback driver already initialized.\n");
	return RET_CONTINUE;
	}

    if (usbLoopbackDevInit () == OK)
	{
	fprintf (fout, "usbLoopbackDevInit() returned OK\n");
	loopbackInitialized = TRUE;

	/* Register for attach notification */

	if (usbLoopbackDynamicAttachRegister (loopbackAttachCallback, (pVOID) fout) != OK)
	    {
	    fprintf (fout, "usbLoopbackDynamicAttachRegister() returned ERROR\n");
	    return RET_CONTINUE;
	    }
	}
    el