usbmpc5200sffdevlib.c

MPC5200 BSP 支持ATA,USB, I2C,扩展网口

        return (NULL); 
        } 

    if ( usbSFFBulkCmdExecute (pBulkDev) != USB_COMMAND_SUCCESS )
        {
        USB_SFF_BULK_ERR ("usbSFFBulkBlkDevCreate: Error executing USB_SFF_INQUIRY "\
                      "command\n", 0, 0, 0, 0, 0, 0);        
        OSS_MUTEX_RELEASE (sffbulkDevMutex);
        return (NULL);  
        }
 
    /* Check the media type bit  */

    if (inquiry[1] & USB_SFF_INQUIRY_RMB_BIT)
        {
        pBulkDev->blkDev.bd_removable = TRUE;
        }
    else
        {
        pBulkDev->blkDev.bd_removable = FALSE;      
        }

    /* read the block size and capacity of device (in terms of blocks) */

    if ( usbSFFBulkFormSFFCmd (pBulkDev, 
			     USB_SFF_READ_CAPACITY, 
			     NULL, 
			     NULL) 
			   != OK )
        {
        OSS_MUTEX_RELEASE (sffbulkDevMutex); 
        return (NULL); 
        } 

    /* 
     * Read Capacity command will usually return CHECK CONDITION status
     * very first time, just try again.
     */

    if ( usbSFFBulkCmdExecute (pBulkDev) != USB_COMMAND_SUCCESS )
        {
        if ( usbSFFBulkCmdExecute (pBulkDev) != USB_COMMAND_SUCCESS )  
            {
            USB_SFF_BULK_ERR ("usbSFFBulkBlkDevCreate: Read Capacity command failed\n",
                          0, 0, 0, 0, 0, 0);
            OSS_MUTEX_RELEASE (sffbulkDevMutex);
            return (NULL);  
            } 
        } 
    
    /* SFF response is in BIG endian format. Swap it to get correct value */
   
    pBulkDev->numBlks   = USB_SFF_SWAP_32(*((UINT32 *)inquiry)) + 1;
    pBulkDev->blkOffset = blkOffset;

    if ( numBlks == NULL )
        pBulkDev->blkDev.bd_nBlocks = (pBulkDev->numBlks - blkOffset); 
    else 
        pBulkDev->blkDev.bd_nBlocks = numBlks;

    pBulkDev->blkDev.bd_bytesPerBlk = USB_SFF_SWAP_32(*((UINT32 *)(inquiry+4))); 
  	
    /* determine which type of SFF read command is implemnted */

    if ( (flags & USB_SFF_FLAG_READ_WRITE10) == 1 )
	pBulkDev->read10Able = TRUE;
    else
	pBulkDev->read10Able = FALSE;
#if 0
    if (blkOffset<=0)
        {
        /*  
         * Read the first block off the disk to determine where the logical
         * disk begins.  This code was adapted from usrAta.c.  It  trys
         * to determine if the first block is a partition table.  If so, it
         * pulls the offset into the logical disk and stores it in the BLK_DEVs
         * offset paramter.  If not it assumes the first block (LBA = 0) is the
         * beginning of the logical disk.
         */
        
        usbSFFBulkDevBlkRd ((BLK_DEV *) pBulkDev, 
                         0,				/* read LBA #0 */
                         1,				/* read only this block */
                         blk0Buffer);
        
        /* get the offset into the partition table */
        
        pPart	= (DOS_PART_TBL *)&blk0Buffer[DOS_BOOT_PART_TBL];
        
        for (ix = 0; ix < 4; ix++)		/* active primary DOS partition */
            {
            if (pPart->dospt_status == 0x80)
                if ((pPart->dospt_type == 0x01) ||
                    (pPart->dospt_type == 0x04) ||
                    (pPart->dospt_type == 0x06))
                    {
                    offset = pPart->dospt_absSec;
                    break;
                    }
            pPart++;
            }
        
        
        pBulkDev->blkOffset = offset;
      
        if ( numBlks == NULL )
            pBulkDev->blkDev.bd_nBlocks = (pBulkDev->numBlks - offset); 
        else 
            pBulkDev->blkDev.bd_nBlocks = numBlks;
        
        pBulkDev->blkDev.bd_bytesPerBlk = USB_SFF_SWAP_32(*((UINT32 *)(inquiry+4)));
      
        }
        
#endif        
    OSS_MUTEX_RELEASE (sffbulkDevMutex);

    return (&pBulkDev->blkDev);
       
    }        


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

    pUSB_SFF_BULK_DEV  pBulkDev = (USB_SFF_BULK_DEV *)pBlkDev;   
    UINT readType;

    /*  Ensure that the device has not been removed during a transfer */

    if ( pBulkDev->connected == FALSE ) 
	return ERROR;

    USB_SFF_BULK_DEBUG ("usbSFFBulkDevBlkRd: Number of blocks = %d, Starting blk = %d\n",
                    numBlks, blkNum, 0, 0, 0, 0); 

    OSS_MUTEX_TAKE (sffbulkDevMutex, OSS_BLOCK);

    /* intialise the pointer to store bulk in data */ 

    pBulkDev->bulkInData = (UINT8 *)pBuf ; 

    if (pBulkDev->read10Able)
	readType = USB_SFF_READ10;
    else 
	readType = USB_SFF_READ12;

    if ( usbSFFBulkFormSFFCmd (pBulkDev, 
			     readType, 
			     blkNum, 
			     numBlks) 
			   != OK )
        {
        OSS_MUTEX_RELEASE (sffbulkDevMutex);
        return (ERROR);  
        }

    if ( usbSFFBulkCmdExecute (pBulkDev) != USB_COMMAND_SUCCESS )
        {
        OSS_MUTEX_RELEASE (sffbulkDevMutex);
        return (ERROR); 
        }

    OSS_MUTEX_RELEASE (sffbulkDevMutex);
    return (OK);
  
    }


LOCAL STATUS usbSFFBulkDevBlkWrt
    (
    BLK_DEV * pBlkDev,           /* pointer to bulk device    */  
    int       blkNum,            /* logical block number      */
    int       numBlks,           /* number of blocks to write */ 
    char *    pBuf               /* data to be written        */ 
    )
    {

    pUSB_SFF_BULK_DEV  pBulkDev = (USB_SFF_BULK_DEV *)pBlkDev;   
    UINT writeType;

    /*  Ensure that the device has not been removed during a transfer */

    if ( pBulkDev->connected == FALSE ) 
	return ERROR;

    USB_SFF_BULK_DEBUG ("usbSFFBulkDevBlkWrt: Number of blocks = %d, Starting blk = %d\n",
                    numBlks, blkNum, 0, 0, 0, 0);

    OSS_MUTEX_TAKE (sffbulkDevMutex, OSS_BLOCK); 

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

    pBulkDev->bulkOutData = (UINT8 *)pBuf;

    if (pBulkDev->read10Able)
	writeType = USB_SFF_WRITE10;
    else 
	writeType = USB_SFF_WRITE12;


    if ( usbSFFBulkFormSFFCmd (pBulkDev, 
			     writeType, 
			     blkNum, 
                             numBlks) 
			   != OK )
        {
        OSS_MUTEX_RELEASE (sffbulkDevMutex);
        return (ERROR); 
        }

    if ( usbSFFBulkCmdExecute (pBulkDev) != USB_COMMAND_SUCCESS )
        {
        OSS_MUTEX_RELEASE (sffbulkDevMutex);
        return (ERROR); 
        }

    OSS_MUTEX_RELEASE (sffbulkDevMutex);
    return (OK);
    }


LOCAL void usbSFFBulkIrpCallback
    (
    pVOID p                      /* pointer to the IRP submitted */
    )
    {
    pUSB_IRP      pIrp     = (pUSB_IRP) p;
    pUSB_SFF_BULK_DEV pBulkDev = pIrp->userPtr;


    /* check whether the IRP was for bulk out/ bulk in / status transport */

    if (pIrp == &(pBulkDev->outIrp))
        {  
        if (pIrp->result == OK)     /* check the result of IRP */
            {
            USB_SFF_BULK_DEBUG ("usbSFFBulkIrpCallback: Num of Bytes transferred on "\
                            "out pipe %d\n", pIrp->bfrList[0].actLen, 
                            0, 0, 0, 0, 0); 
            }
        else
            {

            USB_SFF_BULK_ERR ("usbSFFBulkIrpCallback: Irp failed on Bulk Out %x \n",
                            pIrp->result, 0, 0, 0, 0, 0); 

            /* Clear HALT Feature on Bulk out Endpoint */ 

            if ((usbdFeatureClear (usbdSFFHandle, 
				   pBulkDev->bulkDevId, 
				   USB_RT_ENDPOINT, 
				   USB_FSEL_DEV_ENDPOINT_HALT, 
				   (pBulkDev->outEpAddress & 0x0F))) 
				 != OK)
                {
                USB_SFF_BULK_ERR ("usbSFFBulkIrpCallback: Failed to clear HALT "\
                              "feauture on bulk out Endpoint %x\n", 0, 0, 0, 
                              0, 0, 0);
                }
            }
      
        } 
    else if (pIrp == &(pBulkDev->statusIrp))    /* if status block IRP */
        {
        if (pIrp->result == OK)     /* check the result of the IRP */
            {
            USB_SFF_BULK_DEBUG ("usbSFFBulkIrpCallback : Num of Status Bytes \
                            read  =%d \n", pIrp->bfrList[0].actLen, 0, 0, 0, 0, 0);
            }
        else     /* status IRP failed */
            {

            USB_SFF_BULK_ERR ("usbSFFBulkIrpCallback: Status Irp failed on Bulk in "\
                          "%x\n", pIrp->result, 0, 0, 0, 0, 0);
            } 

        }
    else     /* IRP for bulk_in data */
        {
        if (pIrp->result == OK)
            {
            USB_SFF_BULK_DEBUG ("usbSFFBulkIrpCallback: 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_SFF_BULK_ERR ("usbSFFBulkIrpCallback : Irp failed on Bulk in ,%x\n", 
                            pIrp->result, 0, 0, 0, 0, 0);

            /* Clear HALT Feature on Bulk in Endpoint */

            if ((usbdFeatureClear (usbdSFFHandle, pBulkDev->bulkDevId, USB_RT_ENDPOINT, 
                                   USB_FSEL_DEV_ENDPOINT_HALT, 
                                   (pBulkDev->inEpAddress & 0x0F))) != OK)
                {
                USB_SFF_BULK_ERR ("usbSFFBulkIrpCallback: Failed to clear HALT "\
                              "feature on bulk in Endpoint %x\n", 0, 0, 0, 0, 0, 0);
                }
            }

        }

    OSS_SEM_GIVE (sffbulkIrpSem);
   
    }   


LOCAL STATUS usbSFFBulkDevStatusChk
    (
    BLK_DEV *pBlkDev             /* pointer to bulk device */
    )
    {
     
    USB_COMMAND_STATUS status;
    UINT8   requestSense[20];         /* store for REQUEST SENSE data  */                 
    pUSB_SFF_BULK_DEV  pBulkDev = (USB_SFF_BULK_DEV *)pBlkDev;    
 
    OSS_MUTEX_TAKE (sffbulkDevMutex, OSS_BLOCK);

    /* 
     * The device might take long time to respond when the disk is
     * changed. So the time out for this IRP is increased.
     */

    usbSFFBulkIrpTimeOut = (USB_SFF_BULK_IRP_TIME_OUT * 4);

    /* Form a SFF Test Unit Ready command and send it */ 
 
    if ( usbSFFBulkFormSFFCmd (pBulkDev, 
			     USB_SFF_TEST_UNIT_READY, 
			     NULL, 
			     NULL) 
			   != OK )
        {
        OSS_MUTEX_RELEASE (sffbulkDevMutex);
        return (ERROR); 
        } 

    status = usbSFFBulkCmdExecute (pBulkDev);

    usbSFFBulkIrpTimeOut = USB_SFF_BULK_IRP_TIME_OUT;

    if (status == USB_COMMAND_FAILED )
        {

        /* TEST_UNIT_READY command failed.  Get request sense data.*/

        pBulkDev->bulkInData = requestSense;
        if ( usbSFFBulkFormSFFCmd (pBulkDev, 
				 USB_SFF_REQ_SENSE, 
				 NULL, 
				 NULL) 
				!= OK )
            {
            USB_SFF_BULK_ERR ("usbSFFBulkDevStatusChk: Error forming command\n",
                          0, 0, 0, 0, 0, 0);
            OSS_MUTEX_RELEASE (sffbulkDevMutex);
            return (ERROR); 
            } 

        if ( usbSFFBulkCmdExecute (pBulkDev) != USB_COMMAND_SUCCESS )
            {
            USB_SFF_BULK_ERR ("usbSFFBulkDevStatusChk: Error executing USB_SFF_REQ_SENSE" \
                          "command\n", 0, 0, 0, 0, 0, 0);        
            OSS_MUTEX_RELEASE (sffbulkDevMutex);
            return (ERROR);  
            }

        /* Check the sense data for possible reasons of CHECK_CONDITION */

        /* This is real