一个驱动支持多个设备再usb子系统、input子系统、platform、iic子系统 中的实现

platform

你写的驱动你应该知道它适用与哪些设备吧，如果你想支持一个设备，那么你就构造一个
usb_device_id (USB)、i2c_device_id (IIC)、platform_device_id（Platform）放到对应驱动的id_table中

/**
    先看平台总线。
*/
struct bus_type platform_bus_type = {
    .name       = "platform",
    .dev_attrs  = platform_dev_attrs,
    /**
        匹配驱动与设备
    */
    .match      = platform_match,  
    .uevent     = platform_uevent,
    .pm     = &platform_dev_pm_ops,
};

    /**
        匹配的方法有两种 : 
                    1 : 是利用了platform_driver中定义的id_table，(一个驱动可能支持多个设备)
                        如果定义了id_table,那么，就会逐一遍历id_table表中的每一项
                        否则，使用name来匹配
                    2 : 使用name来匹配 (一个驱动只能支持一个设备)    
    */
    static int platform_match(struct device * dev,struct device_driver * drv)
    {
        /**
            底层调用container_of宏来获取平台设备、平台设备驱动
        */
        struct platform_device = to_platform_device(dev);
        struct platform_driver = to_platform_driver(drv);
        /**
            这个函数，如果drv->of_match_table不存在，或者dev->of_node不存在
            就会返回NULL,实际中用的不多
            最终还是比较 drv->of_match_table 和 dev->of_node的name、type等是不是一样
            if ((!matches) || (!dev->of_node))
                return NULL;
            return of_match_node(matches, dev->of_node);
        */
        if(of_driver_match_device(dev,drv))
        {
            return 1;
        }
        /**
            如果平台驱动提供了id_table，那么就会platform_match_id函数
            id_table的出现，让一个驱动支持多个设备成为可能。
            platform_match_id()这个函数会在下面说
        */
        if(pdrv->id_table)
        {
            return platform_match_id(pdrv->id_table,pdev) != NULL;
        }

        /**
          如果平台驱动没有提供id_table，那么就会利用名字来比较了
          如果是这样，一个驱动只能支持一个设备了
        */  
        return (strcmp(pdev->name,drv->name) == 0);
    }

    /**
        这个函数 会在驱动的id_table表里面 查找和platform_device的name字段相同的一项
        如果相同，那么就返回true，否则返回false，
        所以 ：
            这样就可以一个驱动支持多个设备，
            如果只是简单的比较ｎａｍｅ的话，那么一个驱动只能支持一个设备  
    */
    static const struct platform_device_id *platform_match_id(
            const struct platform_device_id *id,
            struct platform_device *pdev)
    {
        while (id->name[0]) 
        {
            /**
                还是比较每一项的名字
            */
            if (strcmp(pdev->name, id->name) == 0) {
                pdev->id_entry = id;
                return id;
            }
            id++;
        }
        return NULL;
    }

iic子系统

在前面的博文中已经详细的分析过，这里简单的说一下，方便对比

struct bus_type i2c_bus_type = {
    .name       = "i2c",
    /**
        匹配函数，下面看这个函数。
    */
    .match      = i2c_device_match,
    /**
        iic总线提供了probe，匹配成功后会调用这个probe，
        然后再这个probe中调用驱动的probe
    */
    .probe      = i2c_device_probe,
    .....
};
static int i2c_device_match(struct device *dev, struct device_driver *drv)
{
    /**
        根据type类型来检查是不是iic_client类型，
    */
    struct i2c_client   *client = i2c_verify_client(dev);
    struct i2c_driver   *driver;
    /**
        不是iic_client类型，就直接返回，因为这里要匹配是iic_client和对应的驱动
    */
    if (!client) 
    {
        return 0;
    }   
    /**
        获取iic_driver,是为了在下面取出来它的id_table
    */
    driver = to_i2c_driver(drv);
    /**
        如果提供了id_table就调用i2c_match_id()来比较
    */
    if (driver->id_table)
    {
        /**
            这个函数就是遍历id_table，取出每一个表项来与iic_client的name比较
            其实还是利用了name比较，
        */
        return i2c_match_id(driver->id_table, client) != NULL;
    }   

    return 0;
}
/**
    看最终还是和上面的platform调用的是同一个函数。
*/
static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
                        const struct i2c_client *client)
{
    while (id->name[0]) {
        if (strcmp(client->name, id->name) == 0)
            return id;
        id++;
    }
    return NULL;
}

usb子系统

struct bus_type usb_bus_type = {
    .name =     "usb",
    /**
        当调用usb_register()注册一个usb_driver的时候
        __driver_attach()
            ....
               driver_match_device()
                     调用总线提供的match函数  
        如果这个match函数匹配不成功的话，那么就不会调用驱动提供的probe函数(这里总线没有提供probe)
        具体match函数怎么做的，下面有分析          
    */
    .match =    usb_device_match,
    .uevent =   usb_uevent,
};

static struct usb_driver usb_mouse_driver = {
    .name       = "usbmouse",
    .probe      = usb_mouse_probe,
    /**
        usb设备拔出后调用的函数
        主要做一些销毁、释放、杀死urb的工作
    */
    .disconnect = usb_mouse_disconnect,
    /**
        前面说过，要想你写的驱动支持某一个设备的话，
        可以构造一个usb_device_id放到usb_mouse_id_table这个数组中
        怎么构造，以前的博文已经说过，可以使用内核提供了一些宏来构造。
    */
    .id_table   = usb_mouse_id_table,
};