ev44b0_usb.c

linux下用VC++编写的USB驱动程序源码

//
//****************************************************************************
static void USBWriteEndpoint(unsigned long ulEndpoint, const unsigned char **ppucData,
                 unsigned long *pulLength)
{
    unsigned long ulIdx, ulLength;

    //
    // Determine the size of the packet to be sent based on the endpoint.
    //
    if(ulEndpoint == USB_ENDPOINT_CONTROL_IN)
    {
        //
        // The maximum packet size for the control endpoint is 16.
        //
        ulLength = (*pulLength > 16) ? 16 : *pulLength;
    }
    else
    {
        //
        // The maxmium packet size for the bulk endpoint is 64.
        //
        ulLength = (*pulLength > 64) ? 64 : *pulLength;
    }

    //
    // Select the appropriate endpoint.
    //
    USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT + ulEndpoint);

    //
    // Send the write buffer command.
    //
    USBWriteCommand(USB_COMMAND_WRITE_BUFFER);

    //
    // Write the reserved byte to the buffer.
    //
    USBWriteData(0);

    //
    // Write the length of the data packet.
    //
    USBWriteData(ulLength);

    //
    // Write the data into the transmit buffer.
    //
    for(ulIdx = 0; ulIdx < ulLength; ulIdx++)
    {
        USBWriteData(*(*ppucData)++);
    }

    //
    // Decrement the count of bytes to write.
    //
    *pulLength -= ulLength;

    //
    // Send the validate buffer command so that the endpoint will transmit the
    // packet.
    //
    USBWriteCommand(USB_COMMAND_VALIDATE_BUFFER);
}


static int ev44b0ii_usb_fasync(int fd, struct file *filp, int mode)
{
	return 0;
}

static int ev44b0ii_usb_release(struct inode *inode, struct file *filp)
{
	filp->f_op->fasync( -1, filp, 0 );  /* Remove ourselves from the async list */

   	USBWriteCommand(USB_COMMAND_SEND_RESUME);
    usb_wait_ms (10); /* Delay 10ms*/
    USBWriteCommand(USB_COMMAND_SET_ADDRESS_ENABLE);
    USBWriteData(0);
    
    USBWriteCommand(USB_COMMAND_SET_ENDPOINT_ENABLE);
    USBWriteData(0);
    //
    // Enable the interrupts for the bulk endpoints.
    //
    USBWriteCommand(USB_COMMAND_SET_DMA);
    USBWriteData(USB_DMA_ENDP4_INT_ENABLE | USB_DMA_ENDP5_INT_ENABLE);
     
    USBWriteCommand(USB_COMMAND_SET_MODE);
    USBWriteData(0);
    USBWriteData(USB_CONFIG2_SET_TO_ONE | USB_CONFIG2_CLOCK_4M);

	MOD_DEC_USE_COUNT;
    
    USB_CONNECT_FLAG = 0; // we using soft-link, so we remove the pull up res.
	return 0;
}

static int ev44b0ii_usb_open(struct inode *inode, struct file *filp)
{
	struct ev44b0ii_usb_priv *dev;

	filp->private_data = &gusb;
	if (verbose)
	    printk("open usb\n");
    //
    // Configure the PDIUSBD12 and enable the SoftConnect pull-up.
    //
    USBWriteCommand(USB_COMMAND_SET_MODE);
    USBWriteData(USB_CONFIG1_NO_LAZY_CLOCK | USB_CONFIG1_CLOCK_RUNNING |
                 USB_CONFIG1_SOFT_CONNECT);
    USBWriteData(USB_CONFIG2_SET_TO_ONE | USB_CONFIG2_CLOCK_4M);

	MOD_INC_USE_COUNT;
	while(USB_CONNECT_FLAG == 0); // wait till usb opend.
	return 0;
}

static ssize_t
ev44b0ii_usb_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
{
    
    while ( sUSB.ulBulkInCount != 0 )// must wait send all last data.
    {
        if ( file->f_flags & O_NONBLOCK )
		        return -EAGAIN;          
    }

    sUSB.ulBulkInCount = count;
    sUSB.pucBulkIn = buf;
    USBWriteEndpoint(USB_ENDPOINT_BULK_IN, &sUSB.pucBulkIn,
                     &sUSB.ulBulkInCount);
    return count;
}

static ssize_t 
ev44b0ii_usb_read(struct file *filp, char *buf, size_t count, loff_t *l)
{
   	struct ev44b0ii_usb_priv *dev = (struct ev44b0ii_usb_priv *)filp->private_data;
   	size_t size;

	if (verbose)
	    printk("read usb\n");

    while ( dev->head == dev->tail )
    {
        if ( filp->f_flags & O_NONBLOCK )
		        return -EAGAIN;          
    }
    size = dev->head - dev->tail ;
    if (size < count) // read all?
    {
        count = size;
    }

   	if ( copy_to_user(buf, &dev->buf[dev->tail], count) ) 
	{
		return -EFAULT;
    }
    dev->tail += count;
    if (dev->tail == dev->head)
    {
        dev->head = 0;
        dev->tail = 0;
        sUSB.pucBulkOut = gbuffer; // reset the buffer.
    }

    sUSB.ulBulkOutCount += count;
    
    return count;
}
//****************************************************************************
//
// USB_isr is the interrupt handler routine for the USB on polling mode.
//
//****************************************************************************

static void USB_isr(int irq, void *dev_id, struct pt_regs *regs)
{
    unsigned long ulIntStatus, ulTransactionStatus, ulLength;
    unsigned char *pucChar;

    //
    // Read the PDIUSBD12 interrupt register.
    //
    USBWriteCommand(USB_COMMAND_READ_INTERRUPT);
    ulIntStatus = USBReadData();
    ulIntStatus |= USBReadData() << 8;

    //
    // Do nothing if there was a bus reset.
    //
    if(ulIntStatus & USB_INT1_BUS_RESET)
    {
        if (verbose)
            printk("Host Send BUS-Reset Command.\n");
//        return;
    }

    //
    // Handle an interrupt on the bulk out endpoint.
    //
    if(ulIntStatus & USB_INT1_ENDPOINT2_OUT)
    {
        if (verbose)
            printk("Occur Main-Out-Endpoint Interrupt.\n");

        //
        // Read the status of the last transaction on the bulk out endpoint.
        //
        USBWriteCommand(USB_COMMAND_READ_LAST_XACTION_STATUS +
                        USB_ENDPOINT_BULK_OUT);
        ulTransactionStatus = USBReadData();

        //
        // Was a packet of data received successfully?
        //
        if(ulTransactionStatus & USB_XACTION_STATUS_DATA_RX_TX_SUCCESS)
        {
            //
            // If there is a buffer to read this data into, then read the data
            // into that buffer.
            //
            //
            // Read the packet.
            //
            USBReadEndpoint(USB_ENDPOINT_BULK_OUT, &sUSB.pucBulkOut,
                            &sUSB.ulBulkOutCount);
        }
    }

    //
    // Handle an interrupt on the control out endpoint.
    //
    if(ulIntStatus & USB_INT1_CONTROL_OUT)
    {
        if (verbose)
            printk("Occur Control-Out-Endpoint Interrupt.\n");

        //
        // Read the status of the last transaction on the control out endpoint.
        //
        USBWriteCommand(USB_COMMAND_READ_LAST_XACTION_STATUS +
                        USB_ENDPOINT_CONTROL_OUT);
        ulTransactionStatus = USBReadData();

        //
        // Was a setup packet received?
        //
        if(ulTransactionStatus & USB_XACTION_STATUS_SETUP_PACKET)
        {
            //
            // Read the packet.
            //
            pucChar = (unsigned char *)&sUSB.sControlOut;
            ulLength = sizeof(ControlTransfer);
            if(USBReadEndpoint(USB_ENDPOINT_CONTROL_OUT, &pucChar,
                               &ulLength) != sizeof(ControlTransfer))
            {
                //
                // The size of the setup packet is incorrect, so stall both of
                // the control endpoints.
                //
                USBStallEndpoint(USB_ENDPOINT_CONTROL_OUT, 1);
                USBStallEndpoint(USB_ENDPOINT_CONTROL_IN, 1);
            }
            else
            {
                //
                // Acknowledge both the control in and control out endpoints,
                // and send a clear buffer command to the control out endpoint.
                //
                USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT +
                                USB_ENDPOINT_CONTROL_OUT);
                USBWriteCommand(USB_COMMAND_ACKNOWLEDGE_ENDPOINT);
                USBWriteCommand(USB_COMMAND_CLEAR_BUFFER);
                USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT +
                                USB_ENDPOINT_CONTROL_IN);
                USBWriteCommand(USB_COMMAND_ACKNOWLEDGE_ENDPOINT);

                //
                //
                // Process the command in the setup packet.
                //
                if(((sUSB.sControlOut.bmRequestType & USB_RT_TYPE_MASK) ==
                    USB_RT_TYPE_STANDARD) && (sUSB.sControlOut.bRequest < 16))
                {
                    //
                    // This is a standard request, so call the appropriate
                    // routine.
                    //
                    (*USBStandardDeviceRequest[sUSB.sControlOut.bRequest])();
                }
                else
                {
                    //
                    // All other requests are treated as reserved requests.
                    //
                    USBReserved();
                }
            }
        }
        else
        {
            //
            // The packet was not a setup packet, so ignore it.  Send a clear
            // buffer command to the control out endpoint so it will receive
            // new packets.
            //
            USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT +
                            USB_ENDPOINT_CONTROL_OUT);
            USBWriteCommand(USB_COMMAND_CLEAR_BUFFER);

            //
            // Acknowledge both the control in and control out endpoints.
            //
            USBWriteCommand(USB_COMMAND_ACKNOWLEDGE_ENDPOINT);
            USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT +
                            USB_ENDPOINT_CONTROL_IN);
            USBWriteCommand(USB_COMMAND_ACKNOWLEDGE_ENDPOINT);
        }
    }

    //
    // Handle an interrupt on the control in endpoint.
    //
    if(ulIntStatus & USB_INT1_CONTROL_IN)
    {
        if (verbose)
            printk("Occur Control-In--Endpoint Interrupt.\n");

        //
        // Read the status of the last transaction on the control in endpoint.
        //
        USBWriteCommand(USB_COMMAND_READ_LAST_XACTION_STATUS +
                        USB_ENDPOINT_CONTROL_IN);
        USBReadData();

        //
        // Was this the last block of data to be sent back to the host?
        //
        if(sUSB.ulControlInCount != 0)
        {
            //
            // Send the next packet of data to the host.
            //
            USBWriteEndpoint(USB_ENDPOINT_CONTROL_IN, &sUSB.pucControlIn,
                             &sUSB.ulControlInCount);
        }
        else
        {
            //
            // There is no more data to send, so send an empty packet.
            //
            ulLength = 0;
            USBWriteEndpoint(USB_ENDPOINT_CONTROL_IN, 0, &ulLength);
        }
    }

    //
    // Handle an interrupt on the bulk in endpoint.
    //
    if(ulIntStatus & USB_INT1_ENDPOINT2_IN)
    {
        if (verbose)
            printk("Occur Main-In--Endpoint Interrupt.\n");

        //
        // Read the status of the last transaction on the bulk in endpoint.
        //
        USBWriteCommand(USB_COMMAND_READ_LAST_XACTION_STATUS +
                        USB_ENDPOINT_BULK_IN);
        USBReadData();

        //
        // Was this the last block of data to be sent back to the host?
        //
        if(sUSB.ulBulkInCount != 0)
        {
            //
            // Send the next packet of data to the host.
            //
            USBWriteEndpoint(USB_ENDPOINT_BULK_IN, &sUSB.pucBulkIn,
                             &sUSB.ulBulkInCount);
        }
    }
    CLEAR_PEND_INT(irq);
}

//****************************************************************************
//
// USBStallEndpoint stalls or un-stalls the specified endpoint.
//
//****************************************************************************
static void USBStallEndpoint(unsigned long ulEndpoint, unsigned long bStall)
{
    //
    // Send the appropriate set endpoint status command to the PDIUSBD12.
    //
    USBWriteCommand(USB_COMMAND_SET_ENDPOINT_STATUS + ulEndpoint);
    USBWriteData(bStall ? 1 : 0);
}

//****************************************************************************
//
// USBReserved handles device requests which are not supported by this USB
// device implementation.
//
//****************************************************************************
static void USBReserved(void)
{
    //
    // Stall both control endpoints.
    //
    USBStallEndpoint(USB_ENDPOINT_CONTROL_OUT, 1);
    USBStallEndpoint(USB_ENDPOINT_CONTROL_IN, 1);
}
//****************************************************************************
//
// USBGetStatus implements the USB Get_Status device request.
//
//****************************************************************************
static void USBGetStatus(void)
{
    unsigned char ucStatus[2];
    unsigned long ulEndpoint;

    //
    // Determine how to handle this request based on the recipient.
    //
    switch(sUSB.sControlOut.bmRequestType & USB_RT_RECIPIENT_MASK)
    {
        //
        // If the recipient is a device, return the state of the device's
        // remote wakeup and self powered states.
        //
        case USB_RT_RECIPIENT_DEVICE:
        {
            //
            // The player is self powered and does not support remote wakeup.
            //
            ucStatus[0] = USB_DEVICE_STATUS_SELF_POWERED;
            ucStatus[1] = 0;

            //
            // Send our response back to the host.
            //
            USBSendControl(ucStatus, 2);

            //
            // We're done handling this request.
            //
            break;
        }

        //
        // If the recipient is a device interface, return a value of
        // 0x00 as required by the USB spec.
        //
        case USB_RT_RECIPIENT_INTERFACE:
        {
            //
            // The USB spec. requires a GetStatus request for an interface
            // return a pair of zero bytes.
            //
            ucStatus[0] = 0;
            ucStatus[1] = 0;

            //
            // Send our response back to the host.
            //
            USBSendControl(ucStatus, 2);

            //
            // We're done handling this request.
            //
            break;
        }

        //
        // If the recipient is an endpoint, determine whether it is stalled or
        // not and return that information to the host.
        //
        case USB_RT_RECIPIENT_ENDPOINT:
        {
            //
            // Find out which endpoint is the recipient of the request.
            //
            ulEndpoint = sUSB.sControlOut.wIndex & USB_ENDPOINT_ADDRESS_MASK;

            //
            // Determine whether the IN or the OUT endpoint is being addressed
            // in the device request.
            //
            ulEndpoint *= 2;
            if(sUSB.sControlOut.wIndex & USB_ENDPOINT_DIRECTION_MASK)
            {
                ulEndpoint++;
            }

            //
            // Read the endpoint status.
            //
            USBWriteCommand(USB_COMMAND_SELECT_ENDPOINT);
            ulEndpoint = USBReadData();

            //
            // Send the endpoint's status to the host.
            //
            if(ulEndpoint & USB_ENDPOINT_STALL)
            {
                ucStatus[0] = USB_ENDPOINT_STATUS_STALLED;
            }
            else
            {
                ucStatus[0] = 0;
            }
            ucStatus[1] = 0;

            //
            // Send our response back to the host.
            //
            USBSendControl(ucStatus, 2);

            //
            // We're done handling this request.
            //
            break;
        }

        //
        // If an invalid request is received, stall the control endpoint.
        //
        default: