de3_dev.c

来自「linux嵌入式课程实践中的一个关于声卡驱动程序 。」· C语言 代码 · 共 901 行 · 第 1/2 页

    if((recv_urb != NULL) && (recv_urb->status != RECV_ERROR)) 
    {
     
        // determine which endpoint received the URB.    
        switch(recv_urb->endpoint->endpoint_address & 0xf) 
        {
            default:
                usbd_recycle_urb(recv_urb);
                break;
        }

    }
    else 
    {
        usbd_recycle_urb(recv_urb);
    }
    
    return ret_value;
}


/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION:
 *
 *  RETURNS:
 *
 */
ssize_t de3_read(struct file *file, char *buffer, size_t count, 
                        loff_t *ppos)
{
    cy_err("Bulk reads not supported in DE3");
    return -EINVAL;
}


/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION:
 *
 *  RETURNS:
 *
 */

#if 0
ssize_t ep_read(struct de3_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:de3_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:de3_read, return:%d", return_value);
    }

    return return_value;
}
#endif


/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION:
 *
 *  RETURNS:
 *
 */
ssize_t de3_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
{
    cy_err("Bulk writes not supported in DE3");
    return -EINVAL;
}

/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION:
 *
 *  RETURNS:
 *
 */
ssize_t ep_write(struct de3_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 == INT_IN_EP )
    {
        urb_link = &priv->int_in_tx;
    }
    else
    {
        cy_err("Writing on unknown endpoint");
        return -EINVAL;
    }
    
    /* we have some data to send, get a URB and send it */
    //urb = usbd_alloc_urb(priv->device, priv->device->function_instance_array, 
                         //BULK_IN_EP, count);

    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;
    //bytes_written = count;

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

    urb->actual_length = bytes_written;

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

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


/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION:
 *
 *  RETURNS:
 *
 */
int de3_open(struct inode *inode, struct file *file)
{
    int subminor;
    int retval = 0;
    
    dev_dbg("de3_open enter");

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

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

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

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

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

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

    dev_dbg("de3_open exit");

    return retval;
}


/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION:
 *
 *  RETURNS:
 *
 */
int de3_release(struct inode *inode, struct file *filp)
{

    dev_dbg("de3_release enter");

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

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

    dev_dbg("de3_release exit");

    return 0;
}


/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION:
 *
 *  RETURNS:
 *
 */
int de3_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    struct de3_priv * priv;
    int return_value = ERROR;

    hid_keyboard_report_t *hidrpt = (hid_keyboard_report_t *) arg;

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

    if((priv = (struct de3_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_SEND_REPORT:
                if (hidrpt != NULL) 
                {
                    return_value = ep_write( priv, (char*)hidrpt->report, 
                                             HID_REPORT_SIZE, INT_IN_EP );

                    if( return_value >=0 )
                    {
                        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("de3_ioctl exit");
    
    return return_value;

}


/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION: recycle transmit urbs
 *
 *  RETURNS:
 *
 */
void de3_recycle_urb(struct usbd_urb *urb, struct urb_link *link)
{
    if( urb != 0 && link != 0)
    {
        unsigned long int_flags;

        //HWTrace(0x7474);

        urb_link_init(&urb->link);

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


/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION:
 *
 *  RETURNS:
 *
 */
int __init de3_modinit(void)
{
    int err;

    dev_dbg("de3_modinit enter");

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

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

    return err;
}


/******************************************************************************
 *  PARAMETERS:
 *
 *  DESCRIPTION:
 *
 *  RETURNS:
 *
 */
void __exit de3_modexit(void)
{
    dev_dbg("de3_modexit enter");

    usbd_deregister_function(&de3_function_driver);
}

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

#ifdef MODULE
module_init(de3_modinit);
module_exit(de3_modexit);
#endif