de4_dev.c

cypress usb芯片驱动程序,该程序实现了cypress63700的3个驱动

            default:
                usbd_recycle_urb(recv_urb);
                ret_value = -EINVAL;
                break;
        }

    }
    else 
    {
        ret_value = -EINVAL;
        usbd_recycle_urb(recv_urb);
    }
    
    return ret_value;
}


/******************************************************************************
 *
 *  DESCRIPTION: Linux device read
 *
 *  RETURNS:
 *
 */

ssize_t de4_read(struct file *file, char *buffer, size_t count, 
                        loff_t *ppos)
{
    ssize_t ret;

    struct de4_priv * priv = (struct de4_priv *) file->private_data;

    down(&priv->sem);

    ret = ep_read( priv, buffer, count, BULK_OUT_EP );

    up(&priv->sem);

    return ret;
}


/******************************************************************************
 *
 *  DESCRIPTION: Read implementation for read and ioctl
 *
 *  RETURNS:
 *
 */

ssize_t ep_read(struct de4_priv *priv, char *buffer, size_t count, int endpoint)
{

    struct usbd_urb * urb;
    ssize_t return_value = ERROR;
    int length;
    struct urb_link *urb_link;
    
    //dev_dbg("ep_read enter, count:%d, ep:%d", count, endpoint);

    if( endpoint == BULK_OUT_EP )
    {
        urb_link = &priv->bulk_out_rcv;
    }
    else
    {
        cy_err("Reading on unknown endpoint");
        return -EINVAL;
    }

    /* verify that the device wasn't unplugged */
    if( priv->device != NULL && 
        !( priv->device->status == USBD_OK && 
           priv->device->device_state == DEVICE_CONFIGURED ) )
    {
        dev_dbg("device not connected");
        return -ENOTCONN;
    }    
    
    if( (urb = first_urb_detached(urb_link)) == NULL )
    {
        return -EAGAIN;
    }

    length = urb->actual_length;
        
    if(count >= length) 
    {
        if( copy_to_user(buffer, urb->buffer, length) ) 
        {
            /* put back on queue */
            urb_link_init(&urb->link);
            urb_append_irq(urb_link, urb);

            cy_err("copy_to_user failure");
            return_value = -EFAULT;
        }
        else 
        {
            usbd_recycle_urb(urb);
            return_value = length;
        }            

        dev_dbg("1:de4_read, return:%d", return_value);
    }
    else
    {
        /* there is more data in this URB than is currently requested,
           return the requested amount, and then place the remaining data
           back in the receive queue, at the head. */
        int difference;
        
        difference = length - count; /* size of remaining data of URB buffer */
        
        if( copy_to_user(buffer, urb->buffer, count) ) 
        {
            /* put back on queue */
            urb_link_init(&urb->link);
            urb_append_irq(urb_link, urb);

            cy_err("copy_to_user failure");
            return_value = -EFAULT;
        }
        else {
            memcpy(urb->buffer, urb->buffer + count, difference); 
            urb->actual_length = difference; 

            /* put back on queue */
            urb_link_init(&urb->link);
            urb_append_irq(urb_link, urb);

            return_value = count;
        }

        dev_dbg("2:de4_read, return:%d", return_value);
    }

    return return_value;
}


/******************************************************************************
 *
 *  DESCRIPTION: Linux device write
 *
 *  RETURNS:
 *
 */

ssize_t de4_write(struct file *file, const char *buffer, size_t count, 
                  loff_t *ppos)
{
    ssize_t ret;

    struct de4_priv *priv = (struct de4_priv *) file->private_data;

    down(&priv->sem);

    ret = ep_write(priv, buffer, count, BULK_IN_EP);

    up(&priv->sem);

    return ret;
}

/******************************************************************************
 *
 *  DESCRIPTION: Write implementation for write and ioctl
 *
 *  RETURNS:
 *
 */

ssize_t ep_write(struct de4_priv *priv, const char *buffer, size_t count, 
                 int endpoint)
{
    struct usbd_urb * urb;
    ssize_t return_value = ERROR;
    ssize_t bytes_written = 0;
    struct urb_link *urb_link;
    
    dev_dbg("ep_write enter - count:%d, ep:%d", count, endpoint);

    /* verify that the device wasn't unplugged */
    if( priv->device != NULL && 
        !( priv->device->status == USBD_OK && 
           priv->device->device_state == DEVICE_CONFIGURED ) )
    {
        dev_dbg("device not connected");
        return -ENOTCONN;
    }    

    /* is the count set */
    if(count <= 0 || buffer == NULL) 
    {
        cy_err("invalid count/buffer");
        return -EINVAL;
    }

    if( endpoint == BULK_IN_EP )
    {
        urb_link = &priv->bulk_in_tx;
    }
    else
    {
        cy_err("Writing on unknown endpoint");
        return -EINVAL;
    }
    
    /* we have some data to send, get a URB and send it */
    urb = first_urb_detached(urb_link);

    if( urb == 0 ) 
    {
        dev_dbg("no urb pointer");
        return -EAGAIN;
    }

    /* we can only write as much as 1 urb will hold */
    bytes_written = (count > urb->buffer_length) ? urb->buffer_length : count;

    /* copy the data from userspace into our urb */
    if (copy_from_user(urb->buffer, buffer, bytes_written)) 
    {
        de4_recycle_urb(urb, urb_link);
        cy_err("copy from user error");
        return -EFAULT;
    }

    urb->actual_length = bytes_written;

    /* submit the URB */
    if( usbd_send_urb(urb) == 0 )
    {
        return_value = bytes_written;
    }
    else
    {
        cy_err("Failed to send urb");
        de4_recycle_urb(urb, urb_link);
        return_value = -EAGAIN;
    }

    dev_dbg("write exit");
    
    return return_value;
}


/******************************************************************************
 *
 *  DESCRIPTION: Linux device open
 *
 *  RETURNS:
 *
 */

int de4_open(struct inode *inode, struct file *file)
{
    int subminor;
    int retval = 0;
    
    dev_dbg("de4_open enter");

    subminor = MINOR(inode->i_rdev) - USB_DE4_MINOR_BASE;

    if ((subminor < 0) ||
        (subminor >= MAX_DEVICES)) 
    {
        return -ENODEV;
    }
    
    MOD_INC_USE_COUNT;

    /* lock this device */
    down(&de4_priv->sem);

    /* increment our usage count for the driver */
    ++de4_priv->open_count;

    /* save our object in the file's private structure */
    file->private_data = de4_priv;

    /* unlock this device */
    up(&de4_priv->sem);

    dev_dbg("de4_open exit");

    return retval;
}


/******************************************************************************
 *
 *  DESCRIPTION: Linux device close
 *
 *  RETURNS:
 *
 */

int de4_release(struct inode *inode, struct file *filp)
{

    dev_dbg("de4_release enter");

    if (de4_priv == NULL) 
    {
        cy_err("%s - object is NULL", __FUNCTION__);
        return -EFAULT;
    }

    /* lock our device */
    down(&de4_priv->sem);
    
    /* decrement our usage count for the module */
    MOD_DEC_USE_COUNT;
    
    up(&de4_priv->sem);

    dev_dbg("de4_release exit");

    return 0;
}


/******************************************************************************
 *
 *  DESCRIPTION: Linux device ioctl
 *
 *  RETURNS:
 *
 */


int de4_ioctl(struct inode *inode, struct file *file, unsigned int cmd, 
              unsigned long arg)
{
    struct de4_priv * priv;
    int return_value = ERROR;

    hid_keyboard_report_t *hidrpt = (hid_keyboard_report_t *) arg;

    //dev_dbg("de4_ioctl enter, %d", cmd);

    if((priv = (struct de4_priv *) file->private_data) != NULL) 
    {
        /* lock this object */
        down(&priv->sem);
        
        /* verify that the device wasn't unplugged */
        if(priv->device != NULL) 
        {
            /* we have a valid device */
            switch(cmd) 
            {
            case IOCTL_GET_HID_RPT:
                if (hidrpt != NULL) 
                {
                    /* Check for valid report to send */
                    if( de4_priv->hidrpt.valid != 0 ) 
                    {
                        /*
                        int i;
                        printk("ker");
                        for(i=0; i<HID_REPORT_SIZE; i++)
                            printk(":0x%02x", de4_priv->hidrpt.report[i]);
                        printk("\n");
                        */

                        /* Copy report data to user buffer */
                        if( copy_to_user(hidrpt, &de4_priv->hidrpt,
                                         sizeof(hid_keyboard_report_t)) == 0 ) 
                        {
                            return_value = SUCCESS;
                        } 

                        de4_priv->hidrpt.valid = 0;
                    } 
                    else 
                    {
                        int valid = 0;

                        /* No report to send */
                        copy_to_user(&hidrpt->valid,
                                     &valid,
                                     sizeof(int));

                        return_value = SUCCESS;
                    }
                } 
                break;
            
            case IOCTL_IS_CONNECTED:
                if( priv->device != NULL && 
                    priv->device->status == USBD_OK && 
                    priv->device->device_state == DEVICE_CONFIGURED )
                {
                    return_value = SUCCESS;
                }    
                break;

            case TCGETS:
                break;

            default:
                cy_err("unrecognized ioctl command: 0x%x", cmd);
                break;
            }
        }

        /* unlock the device */
        up(&priv->sem);
    }

    //dev_dbg("de4_ioctl exit");
    
    return return_value;

}


/******************************************************************************
 *
 *  DESCRIPTION: recycle transmit urbs
 *
 *  RETURNS:
 *
 */

void de4_recycle_urb(struct usbd_urb *urb, struct urb_link *link)
{
    if( urb != 0 && link != 0)
    {
        unsigned long int_flags;

        urb_link_init(&urb->link);

        local_irq_save(int_flags);
        urb_append_irq(link, urb);
        local_irq_restore(int_flags);
    }
}


/******************************************************************************
 *
 *  DESCRIPTION: Driver module initialization
 *
 *  RETURNS:
 *
 */

int __init de4_modinit(void)
{
    int err;

    dev_dbg("de4_modinit enter");

    /* optional name override */
    de4_function_driver.name = DRIVER_NAME;    
    
    /* register this function driver with the USBD core */
    err = usbd_register_function(&de4_function_driver);

    if( err != 0 ) 
    {
        cy_err("usbd_register_function() failed.");
    }

    return err;
}


/******************************************************************************
 *
 *  DESCRIPTION: Device module exit - not used in DE4
 *
 *  RETURNS:
 *
 */

void __exit de4_modexit(void)
{
    dev_dbg("de4_modexit enter");

    usbd_deregister_function(&de4_function_driver);
}

/*****************************************************************************/

#ifdef MODULE
module_init(de4_modinit);
module_exit(de4_modexit);
#endif