linux usb设备驱动（1）

/*
 * USB Skeleton driver - 2.2
*功能：探测插入usb设备的次数，主要根据linux内核源码usb_skeleton.c修改，本事例以插入手机为例，因为系统原来已经有了u盘设备的驱动
 *
 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
 *
 *        This program is free software; you can redistribute it and/or
 *        modify it under the terms of the GNU General Public License as
 *        published by the Free Software Foundation, version 2.
 *
 * This driver is based on the 2.6.3 version of drivers/usb/usb-skeleton.c
 * but has been rewritten to be easier to read and use.
 *
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/uaccess.h>
#include <linux/usb.h>
#include <linux/mutex.h>


/* Define these values to match your devices */
#define USB_SKEL_VENDOR_ID        0xfff0
#define USB_SKEL_PRODUCT_ID        0xfff0
//手机的生产厂商号和设备号
#define USBr  0x2717
#define USBs 0x904d
int count=0;
/* table of devices that work with this driver */
//驱动支持的USB设备列表
static const struct usb_device_id skel_table[] = {
        { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
        { USB_DEVICE(USBr, USBs) },
        { }                                        /* Terminating entry */
};
MODULE_DEVICE_TABLE(usb, skel_table);


/* Get a minor range for your devices from the usb maintainer */
#define USB_SKEL_MINOR_BASE        192

/* our private defines. if this grows any larger, use your own .h file */
#define MAX_TRANSFER                (PAGE_SIZE - 512)
/* MAX_TRANSFER is chosen so that the VM is not stressed by
   allocations > PAGE_SIZE and the number of packets in a page
   is an integer 512 is the largest possible packet on EHCI */
#define WRITES_IN_FLIGHT        8
/* arbitrarily chosen */

/* Structure to hold all of our device specific stuff */
struct usb_skel {
        struct usb_device        *udev;                        /* the usb device for this device */
        struct usb_interface        *interface;                /* the interface for this device */
        struct semaphore        limit_sem;                /* limiting the number of writes in progress */
        struct usb_anchor        submitted;                /* in case we need to retract our submissions */
        struct urb                *bulk_in_urb;                /* the urb to read data with */
        unsigned char           *bulk_in_buffer;        /* the buffer to receive data */
        size_t                        bulk_in_size;                /* the size of the receive buffer */
        size_t                        bulk_in_filled;                /* number of bytes in the buffer */
        size_t                        bulk_in_copied;                /* already copied to user space */
        __u8                        bulk_in_endpointAddr;        /* the address of the bulk in endpoint */
        __u8                        bulk_out_endpointAddr;        /* the address of the bulk out endpoint */
        int                        errors;                        /* the last request tanked */
        bool                        ongoing_read;                /* a read is going on */
        spinlock_t                err_lock;                /* lock for errors */
        struct kref                kref;
        struct mutex                io_mutex;                /* synchronize I/O with disconnect */
        wait_queue_head_t        bulk_in_wait;                /* to wait for an ongoing read */
};
#define to_skel_dev(d) container_of(d, struct usb_skel, kref)

static struct usb_driver skel_driver;

static void skel_delete(struct kref *kref)
{
        /*
           1.获得设备
           2.减少设备的引用次数
           3.释放分配的数据空间
           4.释放分配的驱动空间
         */
        struct usb_skel *dev = to_skel_dev(kref);

        usb_free_urb(dev->bulk_in_urb);
        usb_put_dev(dev->udev);
        kfree(dev->bulk_in_buffer);
        kfree(dev);
}


static const struct file_operations skel_fops = {
        .owner =        THIS_MODULE,
};

/*
 * usb class driver info in order to get a minor number from the usb core,
 * and to have the device registered with the driver core
 */
static struct usb_class_driver skel_class = {
        .name =                "skel%d",
        .fops =                &skel_fops,
        .minor_base =        USB_SKEL_MINOR_BASE,
};

static int group8(struct usb_interface *interface,
                      const struct usb_device_id *id)
{
        /*
        probe函数主要完成以下工作:
        1.分配一个设备驱动空间，并对这个设备进行引用计数
        2.设备空间中的usb device,interface两个成员，分别由真实成员来赋值，目的是把这些真实成员跟这个新的设备空间关联起来
        3.判断接口所包含的端点特性，看跟硬件是否一致，如果不一致，则出错，即返回值不等于0
        4.注册一个文件设备，这个文件设备是提供给应用程序用于操作设备的，包含打开，关闭，读，写等功能。
        5.成功则返回0
        */
        struct usb_skel *dev;
        struct usb_host_interface *iface_desc;
        struct usb_endpoint_descriptor *endpoint;
        size_t buffer_size;
        int i;
        int retval = -ENOMEM;
        printk("in the skel_probe\n");
        count++;
        printk("in the skel_post_reset : %d %d %s\n",count,__LINE__,__FILE__);
        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
        if (!dev) {
                dev_err(&interface->dev, "Out of memory\n");
                goto error;
        }
        kref_init(&dev->kref);
        sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);
        mutex_init(&dev->io_mutex);
        spin_lock_init(&dev->err_lock);
        init_usb_anchor(&dev->submitted);
        init_waitqueue_head(&dev->bulk_in_wait);

        dev->udev = usb_get_dev(interface_to_usbdev(interface));
        dev->interface = interface;
          /* 设置端点信息 */
            /* 只使用第一个批量IN和批量OUT端点 */
        iface_desc = interface->cur_altsetting;
        /*在探测函数里，这个循环首先访问该接口中存在的每一个端点，给该端点一个局部指针以便以后访问*/
        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
                endpoint = &iface_desc->endpoint[i].desc;
                   /*如果所有这些探测都通过了，驱动程序就知道它已经发现了正确的端点类型，可以把该端点的相关信息保存到一个局部结构体中以便稍后用它来和端点进行通信*/
                if (!dev->bulk_in_endpointAddr &&
                    usb_endpoint_is_bulk_in(endpoint)) {
                        /* 找到一个批量IN类型的端点 */
                        buffer_size = usb_endpoint_maxp(endpoint);
                        dev->bulk_in_size = buffer_size;
                        dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
                        dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
                        if (!dev->bulk_in_buffer) {
                                dev_err(&interface->dev,
                                        "Could not allocate bulk_in_buffer\n");
                                goto error;
                        }
                        dev->bulk_in_urb = usb_alloc_urb(0, GFP_KERNEL);
                        if (!dev->bulk_in_urb) {
                                dev_err(&interface->dev,
                                        "Could not allocate bulk_in_urb\n");
                                goto error;
                        }
                }

                if (!dev->bulk_out_endpointAddr &&
                    usb_endpoint_is_bulk_out(endpoint)) {
                        /* we found a bulk out endpoint */
                        dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
                }
        }
        if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
                dev_err(&interface->dev,
                        "Could not find both bulk-in and bulk-out endpoints\n");
                goto error;
        }
            /*因为USB驱动程序要在设备的生命周期的稍后时间获取和接口相关联的局部数据结构体，所以调用了usb_set_intfdata函数，把它保存到struct usb_interface结构体中以便后面的访问*/

         /* 把数据指针保存到这个接口设备中 */
        usb_set_intfdata(interface, dev);
         /*我们以后调用usb_set_intfdata函数来获取数据。当这一切都完成后，USB驱动程序必须在探测函数中调用usb_register_dev函数来把该设备注册到USB核心里*/

        /* 注册设备到USB核心 */
        retval = usb_register_dev(interface, &skel_class);
        if (retval) {
                /* 有些情况下是不允许注册驱动程序的 */
                dev_err(&interface->dev,
                        "Not able to get a minor for this device.\n");
                usb_set_intfdata(interface, NULL);
                goto error;
        }

        dev_info(&interface->dev,
                 "USB Skeleton device now attached to USBSkel-%d",
                 interface->minor);
        return 0;

error:
        if (dev)
                kref_put(&dev->kref, skel_delete);
        return retval;
}

static void group8_disconnect(struct usb_interface *interface)
{
        struct usb_skel *dev;
        int minor = interface->minor;

        dev = usb_get_intfdata(interface);
        usb_set_intfdata(interface, NULL);

        /* give back our minor */
        usb_deregister_dev(interface, &skel_class);

        /* prevent more I/O from starting */
        mutex_lock(&dev->io_mutex);
        dev->interface = NULL;
        mutex_unlock(&dev->io_mutex);

        usb_kill_anchored_urbs(&dev->submitted);

        /* decrement our usage count */
        kref_put(&dev->kref, skel_delete);

        dev_info(&interface->dev, "USB Skeleton #%d now disconnected", minor);
}

static struct usb_driver skel_driver = {
        .name =                "skeleton",
        .probe =        group8,
        .disconnect =        group8_disconnect,
        .id_table =        skel_table,
        .supports_autosuspend = 1,
};

module_usb_driver(skel_driver);

MODULE_LICENSE("GPL");

KERNELBUILD :=/lib/modules/$(shell uname -r)/build #内核源代码位置，这里是标准情况下链接到正在使用的内核
default: 
        make -C $(KERNELBUILD) M=$(shell pwd) modules #编译连接目标
#  以下内容不是必须 ，属于执行和清理部分
        echo insmod ./hello.ko to turn it on 
clean:
        rm -rf *.o *.ko *.mod.c .*.cmd *.markers *.order *.symvers .tmp_versions