usbloopbacklib.c

VxWorks BSP for S3C2510A

  /* Return immediately if the output IRP is already in use. */
  if (pLoopbackDev->bulkLoopbackInProgress)
	return OK;

  /* mark the bulk loopback tarnsfer as in progress */
  pLoopbackDev->bulkLoopbackInProgress = TRUE;

  while(iteration-- != 0)
  {
    /* Prepare the IRP for bulk out tarnsfer */
    pIrp = &pLoopbackDev->bulkOutIrp;
  
    /* Initialize IRP */
    memset (pIrp, 0, sizeof (*pIrp));
  
    pIrp->userPtr = pLoopbackDev;
    pIrp->irpLen = sizeof (*pIrp);
    pIrp->userCallback = usbLoopbackIrpCallback;
    pIrp->timeout = 0/*USB_LOOPBACK_TIMEOUT*/;
    pIrp->transferLen = loopbackLen;

    pIrp->bfrCount = 1;
    pIrp->bfrList [0].pid = USB_PID_OUT;
    pIrp->bfrList [0].pBfr = (UCHAR *)outBfr;
    pIrp->bfrList [0].bfrLen = loopbackLen;
  
  
    /* Submit IRP */
    if (usbdTransfer (usbdHandle, pLoopbackDev->bulkOutPipeHandle, pIrp) != OK)
    {
      pLoopbackDev->bulkLoopbackInProgress = FALSE;
      bulkOutErrors++;
      printf("usbdTransfer failed -Bulk Out \n");
      return ERROR;
    }
  	
  	/* Wait for transfer to be completed */
    if (OSS_SEM_TAKE (pLoopbackDev->bulkLoopbackSem,/*USB_LOOPBACK_TIMEOUT + 100*/OSS_BLOCK ) != OK )
    {
      OSS_SEM_GIVE (pLoopbackDev->bulkLoopbackSem);
      printf("OSS_SEM_TAKE failed -Bulk Out \n");
      pLoopbackDev->bulkLoopbackInProgress = FALSE;
      bulkOutErrors++;
      return (S_usbLoopbackLib_GENERAL_FAULT);
    }
#if 0 
  	if (pIrp->result != OK)
  	{
  	  printf("pIrp->result is %x\n",pIrp->result);
      bulkOutErrors++;
      OSS_SEM_GIVE (pLoopbackDev->bulkLoopbackSem);
  	  continue;/* Continue for next iteration */
    }
#endif

    
    /* Prepare the IRP for bulk IN transfer */
    pIrp = &pLoopbackDev->bulkInIrp;
  
    /* Initialize IRP */
    memset (pIrp, 0, sizeof (*pIrp));
  
    pIrp->userPtr = pLoopbackDev;
    pIrp->irpLen = sizeof (*pIrp);
    pIrp->userCallback = usbLoopbackIrpCallback;
    pIrp->timeout = 0/*USB_LOOPBACK_TIMEOUT*/;
    pIrp->transferLen = loopbackLen;
  
    pIrp->bfrCount = 1;
    pIrp->bfrList [0].pid = USB_PID_IN;
    pIrp->bfrList [0].pBfr = (UCHAR *)inBfr;
    pIrp->bfrList [0].bfrLen = loopbackLen;

    /* Submit IRP */
    if (usbdTransfer (usbdHandle, pLoopbackDev->bulkInPipeHandle, pIrp) != OK)
  	{
      pLoopbackDev->bulkLoopbackInProgress = FALSE;
      bulkInErrors++;
      printf("usbdTransfer failed -Bulk In \n");
      return ERROR;
    }
  	
  	/* Wait for transfer to be completed */
    if (OSS_SEM_TAKE (pLoopbackDev->bulkLoopbackSem,OSS_BLOCK /*USB_LOOPBACK_TIMEOUT + 100*/) != OK )
    {
      OSS_SEM_GIVE (pLoopbackDev->bulkLoopbackSem);
      pLoopbackDev->bulkLoopbackInProgress = FALSE;
      bulkInErrors++;
      printf("OSS_SEM_TAKE failed -Bulk In \n");
      return (S_usbLoopbackLib_GENERAL_FAULT);
    }
#if 0

  	if (pIrp->result != OK)
  	{
  	  bulkInErrors++;
  	  OSS_SEM_GIVE (pLoopbackDev->bulkLoopbackSem);
  	  continue;/* Continue for next iteration */
    }
#endif

    /* Match the inBfr with outBfr for equality */
    for (count = 0; count < loopbackLen; count++)
    {
    	if( inBfr[count]!= outBfr[count])
    	{
    		bulkPacketMismatch++;
      }
    }
  }/* While loop */


  printf("\nBulk loopback report:\n");
  printf("Bulk-Out errors:%d\n",bulkOutErrors);
  printf("Bulk-In errors:%d\n",bulkInErrors);
  printf("Bulk-Loopback packet mismatch:%d\n",bulkPacketMismatch);
  
  /* Update the stats in the pLoopbackDevice */
  pLoopbackDev->deviceStat.bulkOutErrors += bulkOutErrors;
  pLoopbackDev->deviceStat.bulkInErrors += bulkInErrors;
  pLoopbackDev->deviceStat.bulkPacketMismatch += bulkPacketMismatch;


  pLoopbackDev->bulkLoopbackInProgress = FALSE;
  return OK;
}

/***************************************************************************
*
* usbLoopbackInt - initiates loopback data transmission for interrupt endpoint.
*
* If the interrupt loopback is not already in use, this function populates the
* interrupt out and IN IRP with the buffer and submits the IRPs for
* requested number of times.
*
* This function assumes that the outBfr and inBfr are allocated with enough size to
* hold the loopbackLen data.Also the first two bytes of buffer contains the
* length of whole buffer including these length field
*
* RETURNS: OK, or ERROR if unable to initiate transmission
*/

LOCAL int usbLoopbackInt(USB_LOOPBACK_CHAN *pChan,char *outBfr,
                          char *inBfr,int loopbackLen,int iteration)
{

  pUSB_LOOPBACK_DEVICE pLoopbackDev = (pUSB_LOOPBACK_DEVICE) pChan;
  pUSB_IRP pIrp;
  UINT16 count;
  UINT32 intOutErrors =0;
  UINT32 intInErrors =0;
  UINT32 intPacketMismatch =0;


  /* Return if Interrupt looop back is not supported on the device */
  if (!USB_IS_INT_LOOPBACK_SUPPORTED(pLoopbackDev->protocol))
  {
    printf("Interrupt loopback is not supported on the device!!!\n");
    return ENOSYS;
  }
  
  /* validate the loopback buffer */
  if ((outBfr == NULL) ||(inBfr == NULL))
  {
    printf ("Invalid bulk loopback buffers!!\n" );
  	return S_usbLoopbackLib_BAD_PARAM;
  }
  
  /* Validate the length */
  if(loopbackLen < 2 )
  {
  	printf ("Invalid bulk loopback length!!\n" );
  	return S_usbLoopbackLib_BAD_PARAM;
  }
  
  if (loopbackLen > USB_LOOPBACK_MAX_LEN)
  {
    loopbackLen = USB_LOOPBACK_MAX_LEN;
  }

  
  /* Return immediately if the output IRP is already in use. */
  if (pLoopbackDev->intLoopbackInProgress)
	return OK;

  /* mark the int loopback tarnsfer as in progress */
  pLoopbackDev->intLoopbackInProgress = TRUE;

  while(iteration-- != 0)
  {
    /* Prepare the IRP for bulk out tarnsfer */
    pIrp = &pLoopbackDev->intOutIrp;

    /* Initialize IRP */
    memset (pIrp, 0, sizeof (*pIrp));

    pIrp->userPtr = pLoopbackDev;
    pIrp->irpLen = sizeof (*pIrp);
    pIrp->userCallback = usbLoopbackIrpCallback;
    pIrp->timeout = USB_TIMEOUT_NONE;
    pIrp->transferLen = loopbackLen;

    pIrp->bfrCount = 1;
    pIrp->bfrList [0].pid = USB_PID_OUT;
    pIrp->bfrList [0].pBfr = (UCHAR *)outBfr;
    pIrp->bfrList [0].bfrLen = loopbackLen;


    /* Submit IRP */

    if (usbdTransfer (usbdHandle, pLoopbackDev->intOutPipeHandle, pIrp) != OK)
    {
      pLoopbackDev->intLoopbackInProgress = FALSE;
      intOutErrors++;
      printf("usbdTransfer failed -Int Out \n");
      return ERROR;
    }

  	/* Wait for transfer to be completed */
    if (OSS_SEM_TAKE (pLoopbackDev->intLoopbackSem,/*USB_LOOPBACK_TIMEOUT + 100*/OSS_BLOCK) != OK )
    {
      OSS_SEM_GIVE (pLoopbackDev->intLoopbackSem);
      pLoopbackDev->intLoopbackInProgress = FALSE;
      intOutErrors++;
      printf("OSS_SEM_TAKE failed -Int Out \n");
      return (S_usbLoopbackLib_GENERAL_FAULT);
    }
#if 0
  	if (pIrp->result != OK)
  	{
  	  intOutErrors++;
  	  OSS_SEM_GIVE (pLoopbackDev->intLoopbackSem);
  	  continue;/* Continue for next iteration */
    }
#endif

    /* Prepare the IRP for int IN transfer */
    pIrp = &pLoopbackDev->intInIrp;

    /* Initialize IRP */
    memset (pIrp, 0, sizeof (*pIrp));

    pIrp->userPtr = pLoopbackDev;
    pIrp->irpLen = sizeof (*pIrp);
    pIrp->userCallback = usbLoopbackIrpCallback;
    pIrp->timeout = USB_LOOPBACK_TIMEOUT;
    pIrp->transferLen = loopbackLen;

    pIrp->bfrCount = 1;
    pIrp->bfrList [0].pid = USB_PID_IN;
    pIrp->bfrList [0].pBfr = (UCHAR *)inBfr;
    pIrp->bfrList [0].bfrLen = loopbackLen;


    /* Submit IRP */
    if (usbdTransfer (usbdHandle, pLoopbackDev->intInPipeHandle, pIrp) != OK)
  	{
      pLoopbackDev->intLoopbackInProgress = FALSE;
      intInErrors++;
      printf("usbdTransfer failed -Int In \n");
      return ERROR;
    }

  	/* Wait for transfer to be completed */
    if (OSS_SEM_TAKE (pLoopbackDev->intLoopbackSem,/*USB_LOOPBACK_TIMEOUT + 100*/OSS_BLOCK) != OK )
    {
      OSS_SEM_GIVE (pLoopbackDev->intLoopbackSem);
      pLoopbackDev->intLoopbackInProgress = FALSE;
      intInErrors++;
      printf("OSS_SEM_TAKE failed -Int In \n");
      return (S_usbLoopbackLib_GENERAL_FAULT);
    }
#if 0
  	if (pIrp->result != OK)
  	{
  	  intInErrors++;
  	  OSS_SEM_GIVE (pLoopbackDev->intLoopbackSem);
  	  continue;/* Continue for next iteration */
    }
#endif
    /* Match the inBfr with outBfr for equality */
    for (count = 0; count < loopbackLen; count++)
    {
    	if( inBfr[count]!= outBfr[count])
    	{
    		intPacketMismatch++;
      }
    }
  }/* While loop */

  printf("\nInt loopback report:\n");
  printf("Int-Out errors:%d\n",intOutErrors);
  printf("Int-In errors:%d\n",intInErrors);
  printf("Int-Loopback packet mismatch:%d\n",intPacketMismatch);
  
  /* Update the stats in the pLoopbackDevice */
  pLoopbackDev->deviceStat.intOutErrors += intOutErrors;
  pLoopbackDev->deviceStat.intInErrors += intInErrors;
  pLoopbackDev->deviceStat.intPacketMismatch += intPacketMismatch;


  pLoopbackDev->intLoopbackInProgress = FALSE;
  return OK;
}

/***************************************************************************
*
* usbLoopbackIsoch - initiates loopback data transmission for isoch endpoint.
*
* If the isoch loopback is not already in use, this function populates the
* isoch out and IN IRP with the buffer and submits the IRPs for
* requested number of times.
*
* This function assumes that the outBfr and inBfr are allocated with enough size to
* hold the loopbackLen data.Also the first two bytes of buffer contains the
* length of whole buffer including these length field
*
* RETURNS: OK, or ERROR if unable to initiate transmission
*/

LOCAL int usbLoopbackIsoch(USB_LOOPBACK_CHAN *pChan,char *outBfr,
                          char *inBfr,int loopbackLen,int iteration)
{

  pUSB_LOOPBACK_DEVICE pLoopbackDev = (pUSB_LOOPBACK_DEVICE) pChan;
  pUSB_IRP pIrp;
  UINT16 count;
  UINT32 isochOutErrors =0;
  UINT32 isochInErrors =0;
  UINT32 isochPacketMismatch =0;

  /* Return if Isoch looop back is not supported on the device */
  if (!USB_IS_ISOCH_LOOPBACK_SUPPORTED(pLoopbackDev->protocol))
  {
    printf("Isoch loopback is not supported on the device!!!\n");
    return ENOSYS;
  }

  /* validate the loopback buffer */
  if ((outBfr == NULL) ||(inBfr == NULL))
  {
    printf ("Invalid bulk loopback buffers!!\n" );
  	return S_usbLoopbackLib_BAD_PARAM;
  }
  
  /* Validate the length */
  if(loopbackLen < 2 )
  {
  	printf ("Invalid bulk loopback length!!\n" );
  	return S_usbLoopbackLib_BAD_PARAM;
  }
  
  if (loopbackLen > USB_LOOPBACK_MAX_LEN)
  {
    loopbackLen = USB_LOOPBACK_MAX_LEN;
  }
  
  /* Return immediately if the output IRP is already in use. */
  if (pLoopbackDev->isochLoopbackInProgress)
	return OK;

  /* mark the int loopback tarnsfer as in progress */
  pLoopbackDev->isochLoopbackInProgress = TRUE;

  while(iteration-- != 0)
  {
    /* Prepare the IRP for bulk out tarnsfer */
    pIrp = &pLoopbackDev->isochOutIrp;

    /* Initialize IRP */
    memset (pIrp, 0, sizeof (*pIrp));

    pIrp->userPtr = pLoopbackDev;
    pIrp->irpLen = sizeof (*pIrp);
    pIrp->userCallback = usbLoopbackIrpCallback;
    pIrp->timeout = USB_TIMEOUT_NONE;
    pIrp->transferLen = loopbackLen;

    pIrp->bfrCount = 1;
    pIrp->bfrList [0].pid = USB_PID_OUT;
    pIrp->bfrList [0].pBfr = (UCHAR *)outBfr;
    pIrp->bfrList [0].bfrLen = loopbackLen;


    /* Submit IRP */

    if (usbdTransfer (usbdHandle, pLoopbackDev->isochOutPipeHandle, pIrp) != OK)
    {
      pLoopbackDev->isochLoopbackInProgress = FALSE;
      isochOutErrors++;
      printf("usbdTransfer failed -Isoch Out \n");
      return ERROR;
    }

  	/* Wait for transfer to be completed */
    if (OSS_SEM_TAKE (pLoopbackDev->isochLoopbackSem,/*USB_LOOPBACK_TIMEOUT + 100*/OSS_BLOCK) != OK )
    {
      OSS_SEM_GIVE (pLoopbackDev->isochLoopbackSem);
      pLoopbackDev->isochLoopbackInProgress = FALSE;
      isochOutErrors++;
      printf("OSS_SEM_TAKE failed -Isoch Out \n");
      return (S_usbLoopbackLib_GENERAL_FAULT);
    }
#if 0
  	if (pIrp->result != OK)
  	{
  	  isochOutErrors++;
  	  OSS_SEM_GIVE (pLoopbackDev->isochLoopbackSem);
  	  continue;/* Continue for next iteration */
    }
#endif

    /* Prepare the IRP for int IN transfer */
    pIrp = &pLoopbackDev->isochInIrp;

    /* Initialize IRP */
    memset (pIrp, 0, sizeof (*pIrp));

    pIrp->userPtr = pLoopbackDev;
    pIrp->irpLen = sizeof (*pIrp);
    pIrp->userCallback = usbLoopbackIrpCallback;
    pIrp->timeout = USB_LOOPBACK_TIMEOUT;
    pIrp->transferLen = loopbackLen;

    pIrp->bfrCount = 1;
    pIrp->bfrList [0].pid = USB_PID_IN;
    pIrp->bfrList [0].pBfr = (UCHAR *)inBfr;
    pIrp->bfrList [0].bfrLen = loopbackLen;


    /* Submit IRP */
    if (usbdTransfer (usbdHandle, pLoopbackDev->isochInPipeHandle, pIrp) != OK)
  	{
      pLoopbackDev->isochLoopbackInProgress = FALSE;
      isochInErrors++;
      printf("usbdTransfer failed -Isoch In \n");
      return ERROR;
    }

  	/* Wait for transfer to be completed */
    if (OSS_SEM_TAKE (pLoopbackDev->isochLoopbackSem,/*USB_LOOPBACK_TIMEOUT + 100*/OSS_BLOCK) != OK )
    {
      OSS_SEM_GIVE (pLoopbackDev->isochLoopbackSem);
      pLoopbackDev->isochLoopbackInProgress = FALSE;
      isochInErrors++;
      printf("OSS_SEM_TAKE failed -Isoch In \n");
      return (S_usbLoopbackLib_GENERAL_FAULT);
    }
#if 0

  	if (pIrp->result != OK)
  	{
  	  isochInErrors++;
  	  OSS_SEM_GIVE (pLoopbackDev->isochLoopbackSem);
  	  continue;/* Continue for next iteration */
    }
#endif

    /* Match the inBfr with outBfr for equality */
    for (count = 0; count < loopbackLen; count++)
    {
    	if( inBfr[count]!= outBfr[count])
    	{
    		isochPacketMismatch++;
      }
    }
  }/* While loop */

  printf("\nIsoch loopback report:\n");
  printf("Int-Out errors:%d\n",isochOutErrors);
  printf("Int-In errors:%d\n",isochInErrors);
  printf("Int-Loopback packet mismatch:%d\n",isochPacketMismatch);
  
  /* Update the stats in the pLoopbackDevice */
  pLoopbackDev->deviceStat.isochOutErrors += isochOutErrors;
  pLoopbackDev->deviceStat.isochInErrors += isochInErrors;
  pLoopbackDev->deviceStat.isochPacketMismatch += isochPacketMismatch;

  pLoopbackDev->isochLoopbackInProgress = FALSE;
  return OK;
}


/***************************************************************************
*
* findEndpoint - Searches for a BULK endpoint of the indicated direction.
*
* RETURNS: pointer to matching endpoint descriptor or NULL if not found
*/

LOCAL pUSB_ENDPOINT_DESCR findEndpoint
    (
    pUINT8 pBfr,
    UINT16 bfrLen,
    UINT16 direction,
    UINT8 attribute
    )

    {
    pUSB_ENDPOINT_DESCR pEp;

    while ((pEp = usbDescrParseSkip (&pBfr, 
				     &bfrLen, 
				     USB_DESCR_ENDPOINT)) 
				  != NULL)
	{
	if ((pEp->attributes & USB_ATTR_EPTYPE_MASK) == attribute &&
	    (pEp->endpointAddress & USB_ENDPOINT_DIR_MASK) == direction)
	    break;
	}

    return pEp;
    }


/***************************************************************************
*
* configureLoopbackDevice - configure USB Loopback for operation
*
* Selects the configuration/interface specified in the <pLoopbackDev>
* structure.  These values come from the USBD dynamic attach callback,
* which in turn retrieved them from the configuration/interface
* descriptors which reported the device to be a Loopback.
*
* RETURNS: OK if successful, else ERROR if failed to configure channel
*/

LOCAL STATUS configureLoopbackDevice
    (
    pUSB_LOOPBACK_DEVICE pLoopbackDev
    )

    {
    pUSB_CONFIG_DESCR pCfgDescr = NULL;