Linux总线设备驱动模型

Linux总线设备驱动模型

基于Linux Kernel3.0.8版本

总线

总线是处理器和设备之间的通道，在设备模型中, 所有的设备都通过总线相连, 甚至是内部的虚拟“platform”总线。
在 Linux 设备模型中, 总线由 bus_type 结构表示, 定义在

/**
 * struct bus_type - The bus type of the device
 *
 * @name: The name of the bus.
 * @bus_attrs: Default attributes of the bus.
 * @dev_attrs: Default attributes of the devices on the bus.
 * @drv_attrs: Default attributes of the device drivers on the bus.
 * @match: Called, perhaps multiple times, whenever a new device or driver
 * is added for this bus. It should return a nonzero value if the
 * given device can be handled by the given driver.
 * @uevent: Called when a device is added, removed, or a few other things
 * that generate uevents to add the environment variables.
 * @probe: Called when a new device or driver add to this bus, and callback
 * the specific driver's probe to initial the matched device.
 * @remove: Called when a device removed from this bus.
 * @shutdown: Called at shut-down time to quiesce the device.
 * @suspend: Called when a device on this bus wants to go to sleep mode.
 * @resume: Called to bring a device on this bus out of sleep mode.
 * @pm: Power management operations of this bus, callback the specific
 * device driver's pm-ops.
 * @p: The private data of the driver core, only the driver core can
 * touch this.
 *
 * A bus is a channel between the processor and one or more devices. For the
 * purposes of the device model, all devices are connected via a bus, even if
 * it is an internal, virtual, "platform" bus. Buses can plug into each other.
 * A USB controller is usually a PCI device, for example. The device model
 * represents the actual connections between buses and the devices they control.
 * A bus is represented by the bus_type structure. It contains the name, the
 * default attributes, the bus' methods, PM operations, and the driver core's
 * private data.
 */
struct bus_type {
const char      *name; /*总线名称*/
struct bus_attribute    *bus_attrs; /*总线属性*/
struct device_attribute *dev_attrs; /*设备属性*/
struct driver_attribute *drv_attrs; /*驱动属性*/

/* 当一个新设备或新驱动被添加到该总线时调用，用于device和driver的匹配，匹配返回非0值 */
int (*match)(struct device *dev, struct device_driver *drv);
/* 在为用户空间产生热插拔事件之前，改方法允许总线添加环境变量 */
int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
int (*probe)(struct device *dev);
int (*remove)(struct device *dev);
void (*shutdown)(struct device *dev);

int (*suspend)(struct device *dev, pm_message_t state);
int (*resume)(struct device *dev);

const struct dev_pm_ops *pm;

struct iommu_ops *iommu_ops;

struct subsys_private *p;
};

struct subsys_private {
struct kset subsys;
struct kset *devices_kset;

struct kset *drivers_kset;
struct klist klist_devices;
struct klist klist_drivers;
struct blocking_notifier_head bus_notifier;
unsigned int drivers_autoprobe:1;
struct bus_type *bus;

struct list_head class_interfaces;
struct kset glue_dirs;
struct mutex class_mutex;
struct class *class;
};

总线的注册

int bus_register(struct bus_type *bus);
若成功，新的总线将被添加进系统，并可在sysfs 的 /sys/bus 下看到。

/**
 * bus_register - register a bus with the system.
 * @bus: bus.
 *
 * Once we have that, we registered the bus with the kobject
 * infrastructure, then register the children subsystems it has:
 * the devices and drivers that belong to the bus.
 * 基于sysfs文件系统的kobject kset来注册总线
 */
int bus_register(struct bus_type *bus)
{
    int retval;
    struct subsys_private *priv;

    priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
if (!priv)
return -ENOMEM;

    priv->bus = bus;
    bus->p = priv;

    BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);

    retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
if (retval)
        goto out;

    priv->subsys.kobj.kset = bus_kset;
    priv->subsys.kobj.ktype = &bus_ktype;
    priv->drivers_autoprobe = 1;

    retval = kset_register(&priv->subsys); // 生成/sys/bus/busname/目录
if (retval)
        goto out;
/* 创建总线属性 */
    retval = bus_create_file(bus, &bus_attr_uevent);
if (retval)
        goto bus_uevent_fail;
/* 动态创建一个名为devices的kset结构并添加到sysfs */
    priv->devices_kset = kset_create_and_add("devices", NULL,
&priv->subsys.kobj);// 生成/sys/bus/busname/devices/目录
if (!priv->devices_kset) {
        retval = -ENOMEM;
        goto bus_devices_fail;
    }

    priv->drivers_kset = kset_create_and_add("drivers", NULL,
&priv->subsys.kobj);
if (!priv->drivers_kset) {
        retval = -ENOMEM;
        goto bus_drivers_fail;
    }

    klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
    klist_init(&priv->klist_drivers, NULL, NULL);

    retval = add_probe_files(bus);
if (retval)
        goto bus_probe_files_fail;

    retval = bus_add_attrs(bus);
if (retval)
        goto bus_attrs_fail;

    pr_debug("bus: '%s': registered\n", bus->name);
return 0;

bus_attrs_fail:
    remove_probe_files(bus);
bus_probe_files_fail:
    kset_unregister(bus->p->drivers_kset);
bus_drivers_fail:
    kset_unregister(bus->p->devices_kset);
bus_devices_fail:
    bus_remove_file(bus, &bus_attr_uevent);
bus_uevent_fail:
    kset_unregister(&bus->p->subsys);
out:
    kfree(bus->p);
    bus->p = NULL;
return retval;
}

总线的删除

void bus_unregister(struct bus_type *bus);

/**
 * bus_unregister - remove a bus from the system
 * @bus: bus.
 *
 * Unregister the child subsystems and the bus itself.
 * Finally, we call bus_put() to release the refcount
 */
void bus_unregister(struct bus_type *bus)
{
    pr_debug("bus: '%s': unregistering\n", bus->name);
    bus_remove_attrs(bus);
    remove_probe_files(bus);
    kset_unregister(bus->p->drivers_kset);
    kset_unregister(bus->p->devices_kset);
    bus_remove_file(bus, &bus_attr_uevent);
    kset_unregister(&bus->p->subsys);
    kfree(bus->p);
    bus->p = NULL;
}

总线属性

总线属性由结构bus_attribute 描述，定义如下:

struct bus_attribute {
struct attribute    attr;
    ssize_t (*show)(struct bus_type *bus, char *buf);
    ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
};

构造属性

#define BUS_ATTR(_name, _mode, _show, _store) \
struct bus_attribute bus_attr_##_name = __ATTR(_name, _mode, _show, _store)

#define __ATTR(_name,_mode,_show,_store) { \
.attr = {.name = __stringify(_name), .mode = _mode },   \
.show   = _show,                    \
.store  = _store,                   \
}

drivers\base\bus.c

static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store);
static BUS_ATTR(drivers_probe, S_IWUSR, NULL, store_drivers_probe);
static BUS_ATTR(drivers_autoprobe, S_IWUSR | S_IRUGO,
        show_drivers_autoprobe, store_drivers_autoprobe);

创建总线属性

int bus_create_file(struct bus_type *bus, struct bus_attribute *attr);

int bus_create_file(struct bus_type *bus, struct bus_attribute *attr)
{
int error;
if (bus_get(bus)) {
        error = sysfs_create_file(&bus->p->subsys.kobj, &attr->attr);
        bus_put(bus);
    } else
        error = -EINVAL;
return error;
}

删除总线属性

void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr);

void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr)
{
if (bus_get(bus)) {
        sysfs_remove_file(&bus->p->subsys.kobj, &attr->attr);
        bus_put(bus);
    }
}

设备

Linux 系统中的每个设备由一个 struct device 描述：

/**
 * struct device - The basic device structure
 * @parent: The device's "parent" device, the device to which it is attached.
 * In most cases, a parent device is some sort of bus or host
 * controller. If parent is NULL, the device, is a top-level device,
 * which is not usually what you want.
 * @p: Holds the private data of the driver core portions of the device.
 * See the comment of the struct device_private for detail.
 * @kobj: A top-level, abstract class from which other classes are derived.
 * @init_name: Initial name of the device.
 * @type: The type of device.
 * This identifies the device type and carries type-specific
 * information.
 * @mutex: Mutex to synchronize calls to its driver.
 * @bus: Type of bus device is on.
 * @driver: Which driver has allocated this
 * @platform_data: Platform data specific to the device.
 * Example: For devices on custom boards, as typical of embedded
 * and SOC based hardware, Linux often uses platform_data to point
 * to board-specific structures describing devices and how they
 * are wired. That can include what ports are available, chip
 * variants, which GPIO pins act in what additional roles, and so
 * on. This shrinks the "Board Support Packages" (BSPs) and
 * minimizes board-specific #ifdefs in drivers.
 * @power: For device power management.
 * See Documentation/power/devices.txt for details.
 * @pwr_domain: Provide callbacks that are executed during system suspend,
 * hibernation, system resume and during runtime PM transitions
 * along with subsystem-level and driver-level callbacks.
 * @numa_node: NUMA node this device is close to.
 * @dma_mask: Dma mask (if dma'ble device).
 * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
 * hardware supports 64-bit addresses for consistent allocations
 * such descriptors.
 * @dma_parms: A low level driver may set these to teach IOMMU code about
 * segment limitations.
 * @dma_pools: Dma pools (if dma'ble device).
 * @dma_mem: Internal for coherent mem override.
 * @archdata: For arch-specific additions.
 * @of_node: Associated device tree node.
 * @devt: For creating the sysfs "dev".
 * @devres_lock: Spinlock to protect the resource of the device.
 * @devres_head: The resources list of the device.
 * @knode_class: The node used to add the device to the class list.
 * @class: The class of the device.
 * @groups: Optional attribute groups.
 * @release: Callback to free the device after all references have
 * gone away. This should be set by the allocator of the
 * device (i.e. the bus driver that discovered the device).
 *
 * At the lowest level, every device in a Linux system is represented by an
 * instance of struct device. The device structure contains the information
 * that the device model core needs to model the system. Most subsystems,
 * however, track additional information about the devices they host. As a
 * result, it is rare for devices to be represented by bare device structures;
 * instead, that structure, like kobject structures, is usually embedded within
 * a higher-level representation of the device.
 */
struct device {
struct device       *parent;

struct device_private   *p;

struct kobject kobj;
const char      *init_name; /* initial name of the device */
const struct device_type *type;

struct mutex        mutex;  /* mutex to synchronize calls to
 * its driver.
 */

struct bus_type *bus;       /* type of bus device is on 设备所在总线 */
struct device_driver *driver;   /* which driver has allocated this
 device 管理该设备的驱动 */
void        *platform_data; /* Platform specific data, device
 core doesn't touch it 该设备驱动使用的私有数据成员 */
struct dev_pm_info  power;
struct dev_power_domain *pwr_domain;

#ifdef CONFIG_NUMA
int     numa_node;  /* NUMA node this device is close to */
#endif
    u64     *dma_mask;  /* dma mask (if dma'able device) */
    u64     coherent_dma_mask;/* Like dma_mask, but for
 alloc_coherent mappings as
 not all hardware supports
 64 bit addresses for consistent
 allocations such descriptors. */

struct device_dma_parameters *dma_parms;

struct list_head    dma_pools;  /* dma pools (if dma'ble) */

struct dma_coherent_mem *dma_mem; /* internal for coherent mem
 override */
#ifdef CONFIG_DMA_CMA
struct cma  *cma_area;  /* contiguous memory area for dma
 allocation */
#endif
/* arch specific additions */
struct dev_archdata archdata;

struct device_node  *of_node; /* associated device tree node */

    dev_t           devt;   /* dev_t, creates the sysfs "dev" */

    spinlock_t      devres_lock;
struct list_head    devres_head;

struct klist_node   knode_class;
struct class        *class;
const struct attribute_group **groups;  /* optional groups */

void    (*release)(struct device *dev);
};

注册设备

int device_register(struct device *dev)

/**
 * device_register - register a device with the system.
 * @dev: pointer to the device structure
 *
 * This happens in two clean steps - initialize the device
 * and add it to the system. The two steps can be called
 * separately, but this is the easiest and most common.
 * I.e. you should only call the two helpers separately if
 * have a clearly defined need to use and refcount the device
 * before it is added to the hierarchy.
 *
 * NOTE: _Never_ directly free @dev after calling this function, even
 * if it returned an error! Always use put_device() to give up the
 * reference initialized in this function instead.
 */
int device_register(struct device *dev)
{
    device_initialize(dev);
return device_add(dev);
}

注销设备

void device_unregister(struct device *dev)

/**
 * device_unregister - unregister device from system.
 * @dev: device going away.
 *
 * We do this in two parts, like we do device_register(). First,
 * we remove it from all the subsystems with device_del(), then
 * we decrement the reference count via put_device(). If that
 * is the final reference count, the device will be cleaned up
 * via device_release() above. Otherwise, the structure will
 * stick around until the final reference to the device is dropped.
 */
void device_unregister(struct device *dev)
{
    pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
    device_del(dev);
    put_device(dev);
}

总线也是个设备，也必须按设备注册

设备属性

设备属性由struct device_attribute 描述：

/* interface for exporting device attributes */
struct device_attribute {
struct attribute    attr;
    ssize_t (*show)(struct device *dev, struct device_attribute *attr,
char *buf);
    ssize_t (*store)(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count);
};

创建设备属性

int device_create_file(struct device *dev, const struct device_attribute *attr);

/**
 * device_create_file - create sysfs attribute file for device.
 * @dev: device.
 * @attr: device attribute descriptor.
 */
int device_create_file(struct device *dev,
const struct device_attribute *attr)
{
int error = 0;
if (dev)
        error = sysfs_create_file(&dev->kobj, &attr->attr);
return error;
}

删除设备属性

void device_remove_file(struct device *dev, const struct device_attribute *attr);

/**
 * device_remove_file - remove sysfs attribute file.
 * @dev: device.
 * @attr: device attribute descriptor.
 */
void device_remove_file(struct device *dev,
const struct device_attribute *attr)
{
if (dev)
        sysfs_remove_file(&dev->kobj, &attr->attr);
}

驱动

驱动程序由struct device_driver 描述 ：

/**
 * struct device_driver - The basic device driver structure
 * @name: Name of the device driver.
 * @bus: The bus which the device of this driver belongs to.
 * @owner: The module owner.
 * @mod_name: Used for built-in modules.
 * @suppress_bind_attrs: Disables bind/unbind via sysfs.
 * @of_match_table: The open firmware table.
 * @probe: Called to query the existence of a specific device,
 * whether this driver can work with it, and bind the driver
 * to a specific device.
 * @remove: Called when the device is removed from the system to
 * unbind a device from this driver.
 * @shutdown: Called at shut-down time to quiesce the device.
 * @suspend: Called to put the device to sleep mode. Usually to a
 * low power state.
 * @resume: Called to bring a device from sleep mode.
 * @groups: Default attributes that get created by the driver core
 * automatically.
 * @pm: Power management operations of the device which matched
 * this driver.
 * @p: Driver core's private data, no one other than the driver
 * core can touch this.
 *
 * The device driver-model tracks all of the drivers known to the system.
 * The main reason for this tracking is to enable the driver core to match
 * up drivers with new devices. Once drivers are known objects within the
 * system, however, a number of other things become possible. Device drivers
 * can export information and configuration variables that are independent
 * of any specific device.
 */
struct device_driver {
const char      *name; /*驱动程序的名字( 体现在 sysfs 中 )*/
struct bus_type     *bus;  /*驱动程序所在的总线*/

struct module       *owner;
const char      *mod_name;  /* used for built-in modules */

bool suppress_bind_attrs;   /* disables bind/unbind via sysfs */

const struct of_device_id   *of_match_table;

int (*probe) (struct device *dev); // 驱动找到对应的设备时调用
int (*remove) (struct device *dev);
void (*shutdown) (struct device *dev);
int (*suspend) (struct device *dev, pm_message_t state);
int (*resume) (struct device *dev);
const struct attribute_group **groups;

const struct dev_pm_ops *pm;

struct driver_private *p;
};

注册驱动

int driver_register(struct device_driver *drv)

/**
 * driver_register - register driver with bus
 * @drv: driver to register
 *
 * We pass off most of the work to the bus_add_driver() call,
 * since most of the things we have to do deal with the bus
 * structures.
 */
int driver_register(struct device_driver *drv)
{
    int ret;
    struct device_driver *other;

    BUG_ON(!drv->bus->p);

if ((drv->bus->probe && drv->probe) ||
        (drv->bus->remove && drv->remove) ||
        (drv->bus->shutdown && drv->shutdown))
        printk(KERN_WARNING "Driver '%s' needs updating - please use "
"bus_type methods\n", drv->name);

    other = driver_find(drv->name, drv->bus);
if (other) {
        put_driver(other);
        printk(KERN_ERR "Error: Driver '%s' is already registered, "
"aborting...\n", drv->name);
return -EBUSY;
    }

    ret = bus_add_driver(drv);
if (ret)
return ret;
    ret = driver_add_groups(drv, drv->groups);
if (ret)
        bus_remove_driver(drv);
return ret;
}

注销驱动

void driver_unregister(struct device_driver *drv)

/**
 * driver_unregister - remove driver from system.
 * @drv: driver.
 *
 * Again, we pass off most of the work to the bus-level call.
 */
void driver_unregister(struct device_driver *drv)
{
if (!drv || !drv->p) {
        WARN(1, "Unexpected driver unregister!\n");
return;
    }
    driver_remove_groups(drv, drv->groups);
    bus_remove_driver(drv);
}

驱动属性

驱动的属性使用struct driver_attribute 来描述：

/* sysfs interface for exporting driver attributes */
struct driver_attribute {
struct attribute attr;
    ssize_t (*show)(struct device_driver *driver, char *buf);
    ssize_t (*store)(struct device_driver *driver, const char *buf,
             size_t count);
};

创建驱动属性

int driver_create_file(struct device_driver *drv,const struct driver_attribute *attr);

/**
 * driver_create_file - create sysfs file for driver.
 * @drv: driver.
 * @attr: driver attribute descriptor.
 */
int driver_create_file(struct device_driver *drv,
const struct driver_attribute *attr)
{
int error;
if (drv)
        error = sysfs_create_file(&drv->p->kobj, &attr->attr);
else
        error = -EINVAL;
return error;
}

删除驱动属性

void driver_remove_file(struct device_driver *drv,const struct driver_attribute *attr);

/**
 * driver_remove_file - remove sysfs file for driver.
 * @drv: driver.
 * @attr: driver attribute descriptor.
 */
void driver_remove_file(struct device_driver *drv,
const struct driver_attribute *attr)
{
if (drv)
        sysfs_remove_file(&drv->p->kobj, &attr->attr);
}

设备和驱动什么时候会去相互匹配？
注册驱动或者注册设备时

驱动和设备怎么匹配？
由总线的match函数的规则来匹配