USB系列-2-DNW源码

对DNW驱动源码进行简要分析。

“`

include

include

include

include

include

include

include

define SECBULK_MAJOR 102

define SECBULK_MINOR 0

define DRIVER_NAME “secbulk”

define BULKOUT_BUFFER_SIZE 512

struct secbulk_dev
{
struct usb_device *udev;
struct mutex io_mutex;
char* bulkout_buffer;
__u8 bulk_out_endpointAddr;
};

static struct usb_class_driver secbulk_class;

static struct usb_device_id secbulk_table[]= {
{ USB_DEVICE(0x04e8, 0x1234)}, //c
{ }
};

static struct usb_driver secbulk_driver;
static void secbulk_disconnect(struct usb_interface *interface)
{
struct secbulk_dev *dev = NULL;
printk(KERN_INFO “secbulk:secbulk disconnected!\n”);
dev = usb_get_intfdata(interface);
if( NULL != dev )
kfree(dev);
usb_deregister_dev(interface, &secbulk_class);
return;
}

static ssize_t secbulk_read(struct file *file, char __user *buf, size_t len, loff_t *loff)
{
return -EPERM;
}

static ssize_t secbulk_write(struct file *file, const char __user *buf, size_t len, loff_t *loff)
{
size_t to_write;
struct secbulk_dev *dev = file->private_data;
int ret;
int actual_length;
size_t total_writed;

total_writed = 0;
while(len > 0)
{
    to_write = min(len, BULKOUT_BUFFER_SIZE);

    if(copy_from_user(dev->bulkout_buffer, buf+total_writed, to_write)) //得到用户空间数据
    {
        printk(KERN_ERR "secbulk:copy_from_user failed!\n");
        return -EFAULT;
    }

    ret = usb_bulk_msg(dev->udev, usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),   //构造批量传输信息，传输给usbCore处理
            dev->bulkout_buffer,
            to_write,
            &actual_length,
            3*HZ);
    if(ret || actual_length!=to_write)
    {
        printk(KERN_ERR "secbulk:usb_bulk_msg failed!\n");
        return -EFAULT;
    }
    len -= to_write;
    total_writed += to_write;
}
return total_writed;

}

static int secbulk_open(struct inode *node, struct file *file)
{
struct usb_interface *interface;
struct secbulk_dev *dev;

interface = usb_find_interface(&secbulk_driver, iminor(node));
if(!interface)
    return -ENODEV;

dev = usb_get_intfdata(interface);
dev->bulkout_buffer = kzalloc(BULKOUT_BUFFER_SIZE, GFP_KERNEL);
if(!(dev->bulkout_buffer))
    return -ENOMEM;
if(!mutex_trylock(&dev->io_mutex))
    return -EBUSY;
file->private_data = dev;
return 0;

}

static int secbulk_release(struct inode *node, struct file *file)
{
struct secbulk_dev *dev;

dev = (struct secbulk_dev*)(file->private_data);
kfree(dev->bulkout_buffer);
mutex_unlock(&dev->io_mutex);
return 0;

}

static struct file_operations secbulk_fops = {
.owner = THIS_MODULE,
.read = secbulk_read,
.write = secbulk_write,
.open = secbulk_open,
.release= secbulk_release,
};

static struct usb_class_driver secbulk_class = {
.name = “secbulk%d”,
.fops = &secbulk_fops,
.minor_base= 100,
};

static int secbulk_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
int ret;
struct secbulk_dev *dev;
struct usb_host_interface *iface_desc;
struct usb_endpoint_descriptor *endpoint;
int i;

printk(KERN_INFO "secbulk:secbulk probing...\n");

dev = kzalloc(sizeof(*dev), GFP_KERNEL);        //分配一个指针空间，只是为了索引内核的空间
if(!dev)
{
    ret = -ENOMEM;
    goto error;
}

iface_desc = interface->cur_altsetting;
for(i=0; i < iface_desc->desc.bNumEndpoints; i++) //从USBCore传入的借口中得到得到输出端点
{
    endpoint = &(iface_desc->endpoint[i].desc);
    if(!dev->bulk_out_endpointAddr
    && usb_endpoint_is_bulk_out(endpoint))
    {
        printk(KERN_INFO "secbulk:bulk out endpoint found!\n");
        dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
        break;
    }
}

if(!(dev->bulk_out_endpointAddr))
{
    ret = -EBUSY;
    goto error;
}

ret = usb_register_dev(interface, &secbulk_class);  //将usb驱动注册成字符设备驱动提供给用户程序
if(ret)
{
    printk(KERN_ERR "secbulk: usb_register_dev failed!\n");
    return ret;
}
dev->udev = usb_get_dev(interface_to_usbdev(interface));

usb_set_intfdata(interface, dev);

mutex_init(&dev->io_mutex);
return 0;

error:
if(!dev)
kfree(dev);
return ret;
}

static struct usb_driver secbulk_driver= {
.name= “secbulk”,
.probe= secbulk_probe,
.disconnect= secbulk_disconnect,
.id_table= secbulk_table,
.supports_autosuspend=0,
};
static int __init secbulk_init(void)
{
int result;
printk(KERN_INFO “secbulk:secbulk loaded\n”);
result = usb_register(&secbulk_driver); //1 注册 secbulk_driver, 此处我们就注册了usb_driver，当插入USB后，
//会调用add_dev,然后将ID号与驱动支持的id进行对比，如果对比通过，就会调用probe
if(result)
{ printk(KERN_ERR “secbulk:usb_register failed: %d”, result);
return result;
}
return 0;
}

static void __exit secbulk_exit(void)
{
usb_deregister(&secbulk_driver);
printk(KERN_INFO “secbulk:secbulk unloaded\n”);
}

module_init(secbulk_init);
module_exit(secbulk_exit);
MODULE_LICENSE(“GPL”);