struct usb_device_id {
    /* 確定裝置資訊去和結構體中哪幾個欄位匹配來判斷驅動的適用性 */
    __u16        match_flags;
    /* Used for product specific matches; range is inclusive */
    __u16        idVendor;

/* Define these values to match your devices */
#define USB_SKEL_VENDOR_ID    0xfff0
#define USB_SKEL_PRODUCT_ID    0xfff0

/* table of devices that work with this driver */
static struct usb_device_id skel_table [] = {
    { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },
    { }                    /* Terminating entry */
};
MODULE_DEVICE_TABLE(usb, skel_table);

static struct usb_device_id usb_ids[] = {
 {.driver_info = 42},
    {} 
};

struct usb_driver {
    const char *name;    
    /*指向驅動程式名字的指標. 它必須在核心所有的 USB 驅動中是唯一的(通常被設為和驅動模組名相同).當驅動在核心中執行時,會出現在/sys/bus/usb/drivers目錄中 */

    int (*probe) (struct usb_interface *intf,
         const struct usb_device_id *id);
    /* 指向 USB 驅動中探測函式指標. 當USB 核心認為它有一個本驅動可處理的 struct usb_interface時此函式將被呼叫. USB 核心用來做判斷的 struct usb_device_id 指標也被傳遞給此函式.如果這個 USB 驅動確認傳遞給它的 struct usb_interface, 它應當正確地初始化裝置並返回 0. 如果驅動沒有確認這個裝置或發生錯誤,則返回負錯誤值 */

    void (*disconnect) (struct usb_interface *intf);
    /*指向 USB 驅動的斷開函式指標.當 struct usb_interface 從系統中清除或驅動 USB 核心解除安裝時,函式將被 USB 核心呼叫*/

    int (*ioctl) (struct usb_interface *intf, unsigned int code,
            void *buf);
    /*指向 USB 驅動的 ioctl 函式指標. 若此函式存在, 在使用者空間程式對usbfs 檔案系統關聯的裝置呼叫 ioctl 時,此函式將被呼叫. 實際上,當前只有 USB 集線器驅動使用這個 ioctl*/

    int (*suspend) (struct usb_interface *intf, pm_message_t message);
    /*指向 USB 驅動中掛起函式的指標*/
    int (*resume) (struct usb_interface *intf);
    /*指向 USB 驅動中恢復函式的指標*/
    int (*reset_resume)(struct usb_interface *intf);
    /*要復位一個已經被掛起的USB裝置時呼叫此函式*/

    int (*pre_reset)(struct usb_interface *intf);
    /*在裝置被複位之前由usb_reset_composite_device()呼叫*/
    int (*post_reset)(struct usb_interface *intf);
    /*在裝置被複位之後由usb_reset_composite_device()呼叫*/

    const struct usb_device_id *id_table;
    /*指向 struct usb_device_id 表的指標*/

    struct usb_dynids dynids;
    struct usbdrv_wrap drvwrap;
    /*是struct device_driver driver的再包裝,struct device_driver 包含 struct module *owner;*/
    unsigned int no_dynamic_id:1;
    unsigned int supports_autosuspend:1;
    unsigned int soft_unbind:1;
};
#define    to_usb_driver(d) container_of(d, struct usb_driver, drvwrap.driver)

static struct usb_driver skel_driver = {
 .name = "skeleton",
 .id_table = skel_table,
 .probe = skel_probe,
 .disconnect = skel_disconnect, 
};

//向 USB 核心註冊 struct usb_driver 
static int __init usb_skel_init(void)
{
        int result;
        /* register this driver with the USB subsystem */
        result = usb_register(&skel_driver);
        if (result)
                err("usb_register failed. Error number %d", result);
        return result;
}

/*當 USB 驅動被解除安裝, struct usb_driver 需要從核心登出(程式碼如下). 當以下呼叫發生, 當前繫結到這個驅動的任何 USB 介面將會斷開, 並呼叫斷開函式*/
static void __exit usb_skel_exit(void)
{
        /* deregister this driver with the USB subsystem */
        usb_deregister(&skel_driver);
}

    /* set up the endpoint information */
    /* use only the first bulk-in and bulk-out endpoints */
    iface_desc = interface->cur_altsetting;        //從輸入的interface中提取當前介面的端點總數
    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)) {    //如果是批量輸入端點，
            /* we found a bulk in endpoint */
            buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
            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) {
                err("Could not allocate bulk_in_buffer");
                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)) {    //如果不是這兩種端點，報錯
        err("Could not find both bulk-in and bulk-out endpoints");
        goto error;
    }

//這裡端點判斷的函式給我們的程式設計帶來了方便：
/*-------------------------------------------------------------------------*/
/**
 * usb_endpoint_num - get the endpoint's number
 * @epd: endpoint to be checked
 *
 * Returns @epd's number: 0 to 15.
 */
static inline int usb_endpoint_num(const struct usb_endpoint_descriptor *epd)
{
    return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
}

/**
 * usb_endpoint_type - get the endpoint's transfer type
 * @epd: endpoint to be checked
 *
 * Returns one of USB_ENDPOINT_XFER_{CONTROL, ISOC, BULK, INT} according
 * to @epd's transfer type.
 */
static inline int usb_endpoint_type(const struct usb_endpoint_descriptor *epd)
{
    return epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK;
}

/**
 * usb_endpoint_dir_in - check if the endpoint has IN direction
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint is of type IN, otherwise it returns false.
 */
static inline int usb_endpoint_dir_in(const struct usb_endpoint_descriptor *epd)
{
    return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN);
}

/**
 * usb_endpoint_dir_out - check if the endpoint has OUT direction
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint is of type OUT, otherwise it returns false.
 */
static inline int usb_endpoint_dir_out(
                const struct usb_endpoint_descriptor *epd)
{
    return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);
}

/**
 * usb_endpoint_xfer_bulk - check if the endpoint has bulk transfer type
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint is of type bulk, otherwise it returns false.
 */
static inline int usb_endpoint_xfer_bulk(
                const struct usb_endpoint_descriptor *epd)
{
    return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
        USB_ENDPOINT_XFER_BULK);
}

/**
 * usb_endpoint_xfer_control - check if the endpoint has control transfer type
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint is of type control, otherwise it returns false.
 */
static inline int usb_endpoint_xfer_control(
                const struct usb_endpoint_descriptor *epd)
{
    return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
        USB_ENDPOINT_XFER_CONTROL);
}

/**
 * usb_endpoint_xfer_int - check if the endpoint has interrupt transfer type
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint is of type interrupt, otherwise it returns
 * false.
 */
static inline int usb_endpoint_xfer_int(
                const struct usb_endpoint_descriptor *epd)
{
    return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
        USB_ENDPOINT_XFER_INT);
}

/**
 * usb_endpoint_xfer_isoc - check if the endpoint has isochronous transfer type
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint is of type isochronous, otherwise it returns
 * false.
 */
static inline int usb_endpoint_xfer_isoc(
                const struct usb_endpoint_descriptor *epd)
{
    return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
        USB_ENDPOINT_XFER_ISOC);
}

/**
 * usb_endpoint_is_bulk_in - check if the endpoint is bulk IN
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint has bulk transfer type and IN direction,
 * otherwise it returns false.
 */
static inline int usb_endpoint_is_bulk_in(
                const struct usb_endpoint_descriptor *epd)
{
    return (usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_in(epd));
}

/**
 * usb_endpoint_is_bulk_out - check if the endpoint is bulk OUT
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint has bulk transfer type and OUT direction,
 * otherwise it returns false.
 */
static inline int usb_endpoint_is_bulk_out(
                const struct usb_endpoint_descriptor *epd)
{
    return (usb_endpoint_xfer_bulk(epd) && usb_endpoint_dir_out(epd));
}

/**
 * usb_endpoint_is_int_in - check if the endpoint is interrupt IN
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint has interrupt transfer type and IN direction,
 * otherwise it returns false.
 */
static inline int usb_endpoint_is_int_in(
                const struct usb_endpoint_descriptor *epd)
{
    return (usb_endpoint_xfer_int(epd) && usb_endpoint_dir_in(epd));
}

/**
 * usb_endpoint_is_int_out - check if the endpoint is interrupt OUT
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint has interrupt transfer type and OUT direction,
 * otherwise it returns false.
 */
static inline int usb_endpoint_is_int_out(
                const struct usb_endpoint_descriptor *epd)
{
    return (usb_endpoint_xfer_int(epd) && usb_endpoint_dir_out(epd));
}

/**
 * usb_endpoint_is_isoc_in - check if the endpoint is isochronous IN
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint has isochronous transfer type and IN direction,
 * otherwise it returns false.
 */
static inline int usb_endpoint_is_isoc_in(
                const struct usb_endpoint_descriptor *epd)
{
    return (usb_endpoint_xfer_isoc(epd) && usb_endpoint_dir_in(epd));
}

/**
 * usb_endpoint_is_isoc_out - check if the endpoint is isochronous OUT
 * @epd: endpoint to be checked
 *
 * Returns true if the endpoint has isochronous transfer type and OUT direction,
 * otherwise it returns false.
 */
static inline int usb_endpoint_is_isoc_out(
                const s