usbcbiufidevlib.c

来自「MPC5200 BSP 支持ATA,USB, I2C,扩展网口」· C语言 代码 · 共 2,132 行 · 第 1/5 页

        OSS_MUTEX_RELEASE (cbiUfiDevMutex);

        return (ERROR);
        }
    else if (pCbiUfiDev->intrStatus[0] != USB_UFI_NO_SENSE) 
        {

        if (pCbiUfiDev->intrStatus[0] == USB_UFI_ASC_NO_MEDIA) 
            {
            USB_CBI_UFI_DEBUG ("usbCbiUfiDevStChk: Media not present\n",
                               0, 0, 0, 0, 0, 0);
   
            /* declare that device has to be mounted on next IO operation */

            if (pCbiUfiDev->blkDev.bd_removable == TRUE)
                pCbiUfiDev->blkDev.bd_readyChanged = TRUE;

            rtnStatus = ERROR; 
            }

        /* check for media change */

        else if (pCbiUfiDev->intrStatus[0] == USB_UFI_ASC_MEDIA_CHANGE) 
            {
            USB_CBI_UFI_DEBUG ("usbCbiUfiDevStChk: Media changed\n",
                               0, 0, 0, 0, 0, 0);
  
            if (pCbiUfiDev->blkDev.bd_removable == TRUE)
                pCbiUfiDev->blkDev.bd_readyChanged = TRUE;


	    usbCbiUfiReqSense (pCbiUfiDev);

	    /* set pointer */

	    pCbiUfiDev->bulkInData  = pInquiry;

	    if ( usbCbiUfiFormCmd (pCbiUfiDev, 
				   USB_UFI_READ_CAPACITY, 
				   0, 
				   0) 
				   != OK )
		{
		rtnStatus = ERROR; 
		} 

	    if ( usbCbiUfiCmdExecute (pCbiUfiDev) != USB_COMMAND_SUCCESS )
		{

		usbCbiUfiReqSense (pCbiUfiDev);

		rtnStatus = ERROR; 
		}
	    else
		{

     		pCbiUfiDev->blkDev.bd_nBlocks = \
				 USB_SWAP_32 (*((UINT32 *) pInquiry)) + 1;
 
		pCbiUfiDev->blkDev.bd_bytesPerBlk = \
                                 USB_SWAP_32 (*((UINT32 *) (pInquiry+4)));

                rtnStatus = OK; 
		}
	    }    

 
        else
            rtnStatus = ERROR;
        } 

    usbCbiUfiReqSense (pCbiUfiDev);

    if ( rtnStatus == ERROR )     
        {
        OSS_FREE (pSenseData);

        OSS_FREE (pInquiry);

        OSS_MUTEX_RELEASE (cbiUfiDevMutex);

        return (ERROR);  
        } 

     pCbiUfiDev->bulkInData = pSenseData;

    if ( usbCbiUfiFormCmd (pCbiUfiDev, USB_UFI_MODE_SENSE, 0, 0) != OK )
        {
        USB_CBI_UFI_ERR ("usbCbiUfiDevStChk: Error forming command\n",
                         0, 0, 0, 0, 0, 0);

        OSS_FREE (pSenseData);

        OSS_FREE (pInquiry);

        OSS_MUTEX_RELEASE (cbiUfiDevMutex);

        return (ERROR); 
        } 

    if ( (s = usbCbiUfiCmdExecute (pCbiUfiDev)) != USB_COMMAND_SUCCESS )
        {
        usbCbiUfiReqSense (pCbiUfiDev);

        if ( s == USB_COMMAND_FAILED )
            usbCbiUfiDevReset (pBlkDev); 
 
        USB_CBI_UFI_ERR ("usbCbiUfiDevStChk: Error executing " \
                        "USB_UFI_MODE_SENSE command\n", 0, 0, 0, 0, 0, 0);        

        OSS_FREE (pSenseData);

        OSS_FREE (pInquiry);

        OSS_MUTEX_RELEASE (cbiUfiDevMutex);

        return (ERROR);  
        }
   
    if ((*(pSenseData + 3) & USB_UFI_WRITE_PROTECT_BIT) \
				== USB_UFI_WRITE_PROTECT_BIT)
        {
        USB_CBI_UFI_DEBUG ("usbCbiUfiDevStChk: Media Write protected\n",
                           0, 0, 0, 0, 0, 0);
        pCbiUfiDev->blkDev.bd_mode = O_RDONLY;
        }
    else 
        pCbiUfiDev->blkDev.bd_mode = O_RDWR;
 
    OSS_FREE (pSenseData);

    OSS_FREE (pInquiry);

    OSS_MUTEX_RELEASE (cbiUfiDevMutex);

    return (OK);

    }


LOCAL STATUS usbCbiUfiDevReset
    (
    BLK_DEV * pBlkDev                /* pointer to MSC/CBI/UFI device */
    )
    {

    USBD_NODE_INFO    ufiNodeInfo;
    pUSB_CBI_UFI_DEV pCbiUfiDev = (USB_CBI_UFI_DEV *)pBlkDev;

    USB_CBI_UFI_DEBUG ("usbCbiUfiDevReset: Sending Command block reset\n",
                       0, 0, 0, 0, 0, 0);

    pCbiUfiDev->ufiCmdBlk.dataXferLen = 0;
    pCbiUfiDev->ufiCmdBlk.direction   = 0;

    memset (&(pCbiUfiDev->ufiCmdBlk.cmd), 0xFF, USB_UFI_MAX_CMD_LEN);    
 
    pCbiUfiDev->ufiCmdBlk.cmd[0]      = 0x1D;     
    pCbiUfiDev->ufiCmdBlk.cmd[1]      = 0x04;


    if ( usbCbiUfiCmdExecute (pCbiUfiDev) != USB_COMMAND_SUCCESS )
        {
        USB_CBI_UFI_ERR ("usbCbiUfiDevReset: Error executing " \
                         "Class specific Reset command\n", 0, 0, 0, 0, 0, 0);

                
        if (usbdNodeInfoGet (usbdHandle, pCbiUfiDev->cbiUfiDevId, &ufiNodeInfo,
                             sizeof (USBD_NODE_INFO) ) != OK )
            {
            OSS_MUTEX_RELEASE (cbiUfiDevMutex);
            return (ERROR);  
            }

        if ( usbdFeatureSet (usbdHandle, pCbiUfiDev->cbiUfiDevId,
                             USB_RT_CLASS | USB_RT_OTHER, 
                             USB_HUB_FSEL_PORT_RESET, 
                             ufiNodeInfo.parentHubPort) != OK)
            {
            OSS_MUTEX_RELEASE (cbiUfiDevMutex);
            return (ERROR);  
            } 
        }

 
    if ((usbdFeatureClear (usbdHandle,  
			   pCbiUfiDev->cbiUfiDevId, 
			   USB_RT_ENDPOINT, 
                           USB_FSEL_DEV_ENDPOINT_HALT, 
                           (pCbiUfiDev->inEpAddress & 0x0F))) 
			   != OK)
        {
        USB_CBI_UFI_ERR ("usbCbiUfiDevReset: Failed to clear HALT feauture"\
                      " on bulk in Endpoint %x\n", 0, 0, 0, 0, 0, 0);
        }  

    if ((usbdFeatureClear (usbdHandle,  
			   pCbiUfiDev->cbiUfiDevId, 
			   USB_RT_ENDPOINT, 
                           USB_FSEL_DEV_ENDPOINT_HALT, 
                           (pCbiUfiDev->outEpAddress & 0x0F))) 
			   != OK)
        {
        USB_CBI_UFI_ERR ("usbCbiUfiDevReset: Failed to clear HALT feauture"\
                      " on bulk out Endpoint %x\n", 0, 0, 0, 0, 0, 0);
        } 

    return (OK);

    }

LOCAL VOID notifyAttach
    (
    USBD_NODE_ID cbiUfiDevId,
    UINT16 attachCode
    )

    {
    pATTACH_REQUEST pRequest = usbListFirst (&reqList);

    while (pRequest != NULL)
    {
    (*pRequest->callback) (pRequest->callbackArg, 
	                   cbiUfiDevId, attachCode);

    pRequest = usbListNext (&pRequest->reqLink);
    }
    }


STATUS usbCbiUfiDynamicAttachRegister
    (
    USB_UFI_ATTACH_CALLBACK callback,	/* new callback to be registered */
    pVOID arg                           /* user-defined arg to callback  */
    )

    {
    pATTACH_REQUEST   pRequest;
    pUSB_CBI_UFI_DEV  pCbiUfiDev;
    int status = OK;


    /* Validate parameters */

    if (callback == NULL)
        return (ossStatus (S_usbCbiUfiDevLib_BAD_PARAM));

    OSS_MUTEX_TAKE (cbiUfiDevMutex, OSS_BLOCK);

    /* Create a new request structure to track this callback request. */

    if ((pRequest = OSS_CALLOC (sizeof (*pRequest))) == NULL)
        {
        status = S_usbCbiUfiDevLib_OUT_OF_MEMORY;
        }
    else
        {
        pRequest->callback    = callback;
        pRequest->callbackArg = arg;

        usbListLink (&reqList, pRequest, &pRequest->reqLink, LINK_TAIL) ;
    
      

        pCbiUfiDev = usbListFirst (&cbiUfiDevList);

        while (pCbiUfiDev != NULL)
	    {
            if (pCbiUfiDev->connected)
                (*callback) (arg, pCbiUfiDev->cbiUfiDevId, USB_UFI_ATTACH);

	    pCbiUfiDev = usbListNext (&pCbiUfiDev->cbiUfiDevLink);
	    }
        }

    OSS_MUTEX_RELEASE (cbiUfiDevMutex);

    return (ossStatus (status));
    }


STATUS usbCbiUfiDynamicAttachUnregister
    (
    USB_UFI_ATTACH_CALLBACK callback,  /* callback to be unregistered  */
    pVOID arg                          /* user-defined arg to callback */
    )

    {
    pATTACH_REQUEST pRequest;
    int status = S_usbCbiUfiDevLib_NOT_REGISTERED;

    OSS_MUTEX_TAKE (cbiUfiDevMutex, OSS_BLOCK);

    pRequest = usbListFirst (&reqList);

    while (pRequest != NULL)
        {
        if ((callback == pRequest->callback) && (arg == pRequest->callbackArg))
	    {
	    /* We found a matching notification request. */

	    usbListUnlink (&pRequest->reqLink);

            /* Dispose of structure */

            OSS_FREE (pRequest);
	    status = OK;
	    break;
	    }
        pRequest = usbListNext (&pRequest->reqLink);
        }

    OSS_MUTEX_RELEASE (cbiUfiDevMutex);

    return (ossStatus (status));
    }


STATUS usbCbiUfiDevLock
    (
    USBD_NODE_ID nodeId    /* NodeId of the BLK_DEV to be marked as in use */
    )

    {
    pUSB_CBI_UFI_DEV pCbiUfiDev = usbCbiUfiDevFind (nodeId);

    if ( pCbiUfiDev == NULL)
        return (ERROR);

    pCbiUfiDev->lockCount++;

    return (OK);
    }


STATUS usbCbiUfiDevUnlock
    (
    USBD_NODE_ID nodeId    /* NodeId of the BLK_DEV to be marked as unused */
    )

    {
    int status = OK;
    pUSB_CBI_UFI_DEV pCbiUfiDev = usbCbiUfiDevFind (nodeId);
 
    if ( pCbiUfiDev == NULL)
        return (ERROR);

    OSS_MUTEX_TAKE (cbiUfiDevMutex, OSS_BLOCK);

    if (pCbiUfiDev->lockCount == 0)
        {
        status = S_usbCBiUfiDevLib_NOT_LOCKED;
        }
    else
    {
    if ((--pCbiUfiDev->lockCount == 0) && (!pCbiUfiDev->connected))
	usbCbiUfiDevDestroy (pCbiUfiDev);
    }

    OSS_MUTEX_RELEASE (cbiUfiDevMutex);

    return (ossStatus (status));
    }

LOCAL STATUS usbCbiUfiDescShow 
    (
    USBD_NODE_ID nodeId           /* node ID of the device        */
    )
    {

    UINT8    bfr[255];            /* store for descriptors         */
    UINT8    index;               
    UINT8    numCfg;              /* number of configuration       */
    UINT8    mfcIndex;            /* index for manufacturer string */
    UINT8    productIndex;        /* index for product string      */
    UINT16   actLength;           /* actual length of descriptor   */
    pUSB_DEVICE_DESCR  pDevDescr; /* pointer to device descriptor  */
    pUSB_STRING_DESCR  pStrDescr; /* pointer to string descriptor  */   

    /* Get the Device descriptor first */

    if (usbdDescriptorGet (usbdHandle, nodeId, 
                           USB_RT_STANDARD | USB_RT_DEVICE,
                           USB_DESCR_DEVICE, 0, 0, 20, bfr, &actLength) != OK)
        {
        USB_CBI_UFI_ERR ("usbCbiUfiDescShow: Failed to read Device descriptor\n",
                         0, 0, 0, 0, 0, 0);
        return (ERROR);
        }

    if ((pDevDescr = usbDescrParse (bfr, actLength, USB_DESCR_DEVICE)) == NULL)
        {
         USB_CBI_UFI_ERR ("usbCbiUfiDescShow: No Device descriptor was found "\
                          "in the buffer \n", 0, 0, 0, 0, 0, 0);
         return (ERROR);
        }

    numCfg       = pDevDescr->numConfigurations;
    mfcIndex     = pDevDescr->manufacturerIndex;
    productIndex = pDevDescr->productIndex;

    printf ("DEVICE DESCRIPTOR:\n");
    printf ("------------------\n");
    printf (" Length                    = 0x%x\n", pDevDescr->length);
    printf (" Descriptor Type           = 0x%x\n", pDevDescr->descriptorType);
    printf (" USB release in BCD        = 0x%x\n", pDevDescr->bcdUsb);
    printf (" Device Class              = 0x%x\n", pDevDescr->deviceClass);
    printf (" Device Sub-Class          = 0x%x\n", pDevDescr->deviceSubClass);
    printf (" Device Protocol           = 0x%x\n", pDevDescr->deviceProtocol);
    printf (" Max Packet Size           = 0x%x\n", pDevDescr->maxPacketSize0);
    printf (" Vendor ID                 = 0x%x\n", pDevDescr->vendor);
    printf (" Product ID                = 0x%x\n", pDevDescr->product);
    printf (" Dev release in BCD        = 0x%x\n", pDevDescr->bcdDevice);
    printf (" Manufacturer              = 0x%x\n", pDevDescr->manufacturerIndex);
    printf (" Product                   = 0x%x\n", pDevDescr->productIndex);
    printf (" Serial Number             = 0x%x\n", 
            pDevDescr->serialNumberIndex);
    printf (" Number of Configurations  = 0x%x\n\n", 
            pDevDescr->numConfigurations);

    if (usbdDescriptorGet (usbdHandle, nodeId, 
                           USB_RT_STANDARD | USB_RT_DEVICE,