usbcbiufidevlib.c

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

    if (pCbiUfiDev == NULL)
        {
        USB_CBI_UFI_ERR ("usbCbiUfiBlkDevCreate: No MSC/CBI/UFI found\n",
                         0, 0, 0, 0, 0, 0);
        return (NULL);
        }

    OSS_MUTEX_TAKE (cbiUfiDevMutex, OSS_BLOCK); 

    pCbiUfiDev->blkDev.bd_blkRd        = (FUNCPTR) usbCbiUfiDevBlkRd;
    pCbiUfiDev->blkDev.bd_blkWrt       = (FUNCPTR) usbCbiUfiDevBlkWrt;
    pCbiUfiDev->blkDev.bd_ioctl        = (FUNCPTR) usbCbiUfiDevIoctl;
    pCbiUfiDev->blkDev.bd_reset        = (FUNCPTR) NULL; 
    pCbiUfiDev->blkDev.bd_statusChk    = (FUNCPTR) usbCbiUfiDevStChk;
    pCbiUfiDev->blkDev.bd_retry        = 1;
    pCbiUfiDev->blkDev.bd_mode         = O_RDWR;
    pCbiUfiDev->blkDev.bd_readyChanged = TRUE;


    if ((pInquiry = OSS_MALLOC (UFI_STD_INQUIRY_LEN)) == NULL)
	{
	return NULL;
	}

    pCbiUfiDev->bulkInData  = pInquiry;

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

	OSS_FREE (pInquiry);

        OSS_MUTEX_RELEASE (cbiUfiDevMutex);

        return (NULL); 
        } 


    if ( usbCbiUfiCmdExecute (pCbiUfiDev) != USB_COMMAND_SUCCESS)
        {
        USB_CBI_UFI_ERR ("usbCbiUfiBlkDevCreate: Error executing "\
                         "USB_UFI_INQUIRY command\n", 0, 0, 0, 0, 0, 0);        

        usbCbiUfiReqSense (pCbiUfiDev);

        OSS_FREE (pInquiry);

        OSS_MUTEX_RELEASE (cbiUfiDevMutex);

        return (NULL);
        }

    /* Check the media type bit  */

    if (*(pInquiry + 1) & USB_UFI_INQUIRY_RMB_BIT)
        {
        pCbiUfiDev->blkDev.bd_removable = TRUE;
        }
    else
        {
        pCbiUfiDev->blkDev.bd_removable = FALSE;      
        }

    usbCbiUfiReqSense (pCbiUfiDev);

    pCbiUfiDev->bulkInData  = pInquiry;

    if ( usbCbiUfiFormCmd (pCbiUfiDev, 
			   USB_UFI_READ_CAPACITY, 
			   0, 
			   0)   
			  != OK )
        {
        OSS_FREE (pInquiry);

        OSS_MUTEX_RELEASE (cbiUfiDevMutex); 

        return (NULL); 
        } 

    if ( (s = usbCbiUfiCmdExecute (pCbiUfiDev)) == USB_COMMAND_FAILED )
	{

	usbCbiUfiReqSense (pCbiUfiDev);
	    
	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;

	    /* fake the disk size */
 
	    pCbiUfiDev->blkDev.bd_nBlocks =  (UINT32) 0xb40;
 
	    pCbiUfiDev->blkDev.bd_bytesPerBlk = (UINT32)  0x200;

	    printf ("No disk in drive\n");
 
            OSS_FREE (pInquiry);

	    OSS_MUTEX_RELEASE (cbiUfiDevMutex);

	    return (&pCbiUfiDev->blkDev);

	    }
	
	/*  Here we go with the second try */

	if (pCbiUfiDev->intrStatus[0] == USB_UFI_ASC_MEDIA_CHANGE) 
	    {
            pCbiUfiDev->bulkInData  = pInquiry;

            if ( usbCbiUfiFormCmd (pCbiUfiDev, 
	    		           USB_UFI_READ_CAPACITY, 
			           0, 
			           0) 
			           != OK )
                {
        	OSS_FREE (pInquiry);

                OSS_MUTEX_RELEASE (cbiUfiDevMutex); 

                return (NULL); 
                } 

            if ( usbCbiUfiCmdExecute (pCbiUfiDev) != USB_COMMAND_SUCCESS )
                {

        	USB_CBI_UFI_ERR ("usbCbiUfiBlkDevCreate: Error executing "\
                         "USB_UFI_READ_CAPACITY command\n", 0, 0, 0, 0, 0, 0);

	        OSS_FREE (pInquiry);

    		OSS_MUTEX_RELEASE (cbiUfiDevMutex); 

	   	return (NULL);

            	}
	    
	 
            usbCbiUfiReqSense (pCbiUfiDev);

	    }
 
        }

    else if ( s != USB_COMMAND_SUCCESS)
        { 
        USB_CBI_UFI_ERR ("usbCbiUfiBlkDevCreate: Error executing "\
                         "USB_UFI_READ_CAPACITY command\n", 0, 0, 0, 0, 0, 0);

        OSS_FREE (pInquiry);

        OSS_MUTEX_RELEASE (cbiUfiDevMutex); 

        return (NULL);     
        }

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

    USB_CBI_UFI_DEBUG ("usbCbiUfiBlkDevCreate: Number of Blocks : %x, "
                       "Block Size: %x \n", pCbiUfiDev->blkDev.bd_nBlocks, 
                       pCbiUfiDev->blkDev.bd_bytesPerBlk, 0, 0, 0, 0 );   

    OSS_FREE (pInquiry);

    OSS_MUTEX_RELEASE (cbiUfiDevMutex);

    return (&pCbiUfiDev->blkDev);

    }        


LOCAL STATUS usbCbiUfiDevBlkRd
    (
    BLK_DEV * pBlkDev,           /* pointer to UFI  device   */ 
    UINT32       blkNum,            /* logical block number     */
    UINT32       numBlks,           /* number of blocks to read */
    char *    pBuf               /* store for data           */ 
    )
    {

    USB_COMMAND_STATUS s;
    pUSB_CBI_UFI_DEV  pCbiUfiDev = (USB_CBI_UFI_DEV *)pBlkDev;   

    USB_CBI_UFI_DEBUG ("usbCbiUfiDevBlkRd: Reading from block number: %x\n",
                       blkNum, 0, 0, 0, 0, 0);
 
    OSS_MUTEX_TAKE (cbiUfiDevMutex, OSS_BLOCK); 

    /* initialise the pointer to fetch bulk out data */

    pCbiUfiDev->bulkInData = (UINT8 *)pBuf;

    if ( usbCbiUfiFormCmd (pCbiUfiDev, USB_UFI_READ10, 
                           blkNum, numBlks) != OK )
        {
        OSS_MUTEX_RELEASE (cbiUfiDevMutex);
        return (ERROR);  
        }
  
    s = usbCbiUfiCmdExecute (pCbiUfiDev);
   
    if ( s != USB_COMMAND_SUCCESS )
        {
        if ( s == USB_COMMAND_FAILED)
            usbCbiUfiDevReset (pBlkDev); 
       
        usbCbiUfiReqSense (pCbiUfiDev);

        OSS_MUTEX_RELEASE (cbiUfiDevMutex);
        return (ERROR); 
        }

    OSS_MUTEX_RELEASE (cbiUfiDevMutex); 
    return (OK);

    }

LOCAL STATUS usbCbiUfiDevBlkWrt
    (
    BLK_DEV * pBlkDev,           /* pointer to UFI device     */  
    UINT32       blkNum,            /* logical block number      */
    UINT32       numBlks,           /* number of blocks to write */ 
    char *    pBuf               /* data to be written        */ 
    )
    {
    USB_COMMAND_STATUS s;

    pUSB_CBI_UFI_DEV  pCbiUfiDev = (USB_CBI_UFI_DEV *)pBlkDev;   

    USB_CBI_UFI_DEBUG ("usbCbiUfiDevBlkWrt: Writing from block number: %x\n",
                        blkNum, 0, 0, 0, 0, 0);

    OSS_MUTEX_TAKE (cbiUfiDevMutex, OSS_BLOCK); 

    /* initialise the pointer to fetch bulk out data */

    pCbiUfiDev->bulkOutData = (UINT8 *)pBuf;

    if ( usbCbiUfiFormCmd (pCbiUfiDev, USB_UFI_WRITE10, blkNum, 
                           numBlks) != OK )
        {
        OSS_MUTEX_RELEASE (cbiUfiDevMutex);
        return (ERROR); 
        }

    s = usbCbiUfiCmdExecute (pCbiUfiDev);

    if ( s != USB_COMMAND_SUCCESS )
        {
        if ( s == USB_COMMAND_FAILED)
            {
            usbCbiUfiDevReset (pBlkDev); 
            }

        usbCbiUfiReqSense (pCbiUfiDev);   
        OSS_MUTEX_RELEASE (cbiUfiDevMutex);
        return (ERROR); 
        }

    OSS_MUTEX_RELEASE (cbiUfiDevMutex); 
    return (OK);

    }

LOCAL VOID usbCbiUfiIrpCallback
    (
    pVOID p                      /* pointer to the IRP submitted */
    )
    {
    pUSB_IRP      pIrp     = (pUSB_IRP) p;

    pUSB_CBI_UFI_DEV pCbiUfiDev = pIrp->userPtr;


    if (pIrp == &(pCbiUfiDev->outIrp))
        {  
        if (pIrp->result == OK)     /* check the result of IRP */
            {
            USB_CBI_UFI_DEBUG ("usbCbiUfiIrpCallback: Num of Bytes transferred on "\
                               "out pipe %d\n", pIrp->bfrList[0].actLen, 
                               0, 0, 0, 0, 0); 
            }
        else
            {
            USB_CBI_UFI_ERR ("usbCbiUfiIrpCallback: Irp failed on Bulk Out %x \n",
                            pIrp->result, 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 ("usbCbiUfiIrpCallback: Failed to clear HALT "\
                                 "feature on bulk out Endpoint %x\n", 0, 0, 0, 
                                 0, 0, 0);
                }
            }
        } 
     else  if (pIrp == &(pCbiUfiDev->inIrp))   /* IRP for bulk_in data */
        {
        if (pIrp->result == OK)
            {
            USB_CBI_UFI_DEBUG ("usbCbiUfiIrpCallback: Num of Bytes read from Bulk "\
                               "In =%d\n", pIrp->bfrList[0].actLen, 0, 0, 0, 0, 0); 
            }
        else   /* IRP on BULK IN failed */
            {
            USB_CBI_UFI_ERR ("usbCbiUfiIrpCallback : Irp failed on Bulk in ,%x\n", 
                          pIrp->result, 0, 0, 0, 0, 0);

            /* Clear HALT Feature on Bulk in Endpoint */

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

        }
     else  if (pIrp == &(pCbiUfiDev->statusIrp))   /* IRP for bulk_in data */
        {

        if (pIrp->result == OK)
            {
            USB_CBI_UFI_DEBUG ("usbCbiUfiIrpCallback: Num of Bytes read from "\
                               "status pipe =%d, %d, %d\n", pIrp->bfrList[0].actLen, 
                                pCbiUfiDev->intrStatus[0], 
                                pCbiUfiDev->intrStatus[1], 0, 0, 0); 
            }
        else   /* IRP on BULK IN failed */
            {
            USB_CBI_UFI_ERR ("usbCbiUfiIrpCallback : Irp failed on interrupt pipe ,%x\n", 
                          pIrp->result, 0, 0, 0, 0, 0);


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


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

    UINT8 * pSenseData;  /* store for SENSE data  */                 
    UINT8 * pInquiry;  /* store for SENSE data  */                 
    USB_COMMAND_STATUS s ;
    STATUS  rtnStatus = OK;

    pUSB_CBI_UFI_DEV pCbiUfiDev = (USB_CBI_UFI_DEV *)pBlkDev;
 
    OSS_MUTEX_TAKE (cbiUfiDevMutex, OSS_BLOCK);

    if ((pSenseData = OSS_MALLOC (USB_UFI_MS_HEADER_LEN)) == NULL)
	{
        OSS_MUTEX_RELEASE (cbiUfiDevMutex);

	return ERROR;
	}

    if ((pInquiry = OSS_MALLOC (UFI_STD_INQUIRY_LEN)) == NULL)
	{
  	OSS_FREE (pSenseData);	

        OSS_MUTEX_RELEASE (cbiUfiDevMutex);

        return ERROR;
	}


    USB_CBI_UFI_DEBUG ("usbCbiUfiDevStChk: About to send TEST_UNIT_READY\n",
                       0, 0, 0, 0, 0, 0);    

 
    if ( usbCbiUfiFormCmd (pCbiUfiDev, USB_UFI_TEST_UNIT_READY, 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 (usbCbiUfiCmdExecute (pCbiUfiDev) != USB_COMMAND_SUCCESS)
        {
        usbCbiUfiReqSense (pCbiUfiDev);

        USB_CBI_UFI_DEBUG ("usbCbiUfiDevStChk: device not ready\n",
                           0, 0, 0, 0, 0, 0);
        OSS_FREE (pSenseData);

        OSS_FREE (pInquiry);