linux设备驱动(1)基本知识

1. 前言

由于Linux支持世界上几乎所有的、不同功能的硬件设备（这是Linux的优点），导致Linux内核中有一半的代码是设备驱动，而且随着硬件的快速升级换代，设备驱动的代码量也在快速增长。个人意见，这种现象打破了“简洁就是美”的理念，是丑陋的。它导致Linux内核看上去非常臃肿、杂乱、不易维护。但蜗蜗也知道，这不是Linux的错，Linux是一个宏内核，它必须面对设备的多样性，并实现对应的驱动。

为了降低设备多样性带来的Linux驱动开发的复杂度，以及设备热拔插处理、电源管理等，Linux内核提出了设备模型（也称作Driver Model）的概念。设备模型将硬件设备归纳、分类，然后抽象出一套标准的数据结构和接口。驱动的开发，就简化为对内核所规定的数据结构的填充和实现。

2. Linux设备模型的基本概念

2.1 Bus, Class, Device和Device Driver的概念

下图是嵌入式系统常见的硬件拓扑的一个示例

硬件拓扑描述Linux设备模型中四个重要概念中三个：Bus，Class、Device和Device Driver。

基于Linux 3.10.73，结构体定义位于include\linux\device.h，如下：

Bus（总线）：Linux认为（可以参考include/linux/device.h中struct bus_type的注释），总线是CPU和一个或多个设备之间信息交互的通道。而为了方便设备模型的抽象，所有的设备都应连接到总线上（无论是CPU内部总线、还是虚拟的总线“platform Bus”）。

/**
 * struct bus_type - The bus type of the device
 *
 * @name:    The name of the bus.
 * @dev_name:    Used for subsystems to enumerate devices like ("foo%u", dev->id).
 * @dev_root:    Default device to use as the parent.
 * @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.
 * @iommu_ops:  IOMMU specific operations for this bus, used to attach IOMMU
 *              driver implementations to a bus and allow the driver to do
 *              bus-specific setup
 * @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; 总线名字
    const char        *dev_name;用于子系统枚举设备
    struct device        *dev_root;作为父设备使用的默认设备
    struct bus_attribute    *bus_attrs;总线的默认属性
    struct device_attribute    *dev_attrs;总线上设备的默认属性
    struct driver_attribute    *drv_attrs;总线上设备驱动的默认属性

    int (*match)(struct device *dev, struct device_driver *drv);当为该总线添加新设备或驱动程序时，可能会调用多次。如果给定的驱动程序可以处理给定的设备，那么它应该返回一个非零值。
    int (*uevent)(struct device *dev, struct kobj_uevent_env *env);当设备被添加、删除或其他一些操作时调用，生成uevent来添加环境变量

    int (*probe)(struct device *dev);新设备或驱动程序添加到此总线时调用，并回调特定驱动程序的探测（probe）以初始化匹配的设备。
    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;总线的电源管理操作，回调特定设备驱动程序的pm-ops。

    struct iommu_ops *iommu_ops;此总线的IOMMU特定操作，用于将IOMMU驱动程序实现附加到总线，并允许驱动程序做特定的总线的设置

    struct subsys_private *p;驱动内核的私有数据，只有驱动内核可以访问它。
    struct lock_class_key lock_key;
};

Class（分类）：在Linux设备模型中，Class的概念非常类似面向对象程序设计中的Class（类），它主要是集合具有相似功能或属性的设备，这样就可以抽象出一套可以在多个设备之间共用的数据结构和接口函数。因而从属于相同Class的设备的驱动程序，就不再需要重复定义这些公共资源，直接从Class中继承即可。

/**
 * struct class - device classes
 * @name:    Name of the class.
 * @owner:    The module owner.
 * @class_attrs: Default attributes of this class.
 * @dev_attrs:    Default attributes of the devices belong to the class.
 * @dev_bin_attrs: Default binary attributes of the devices belong to the class.
 * @dev_kobj:    The kobject that represents this class and links it into the hierarchy.
 * @dev_uevent:    Called when a device is added, removed from this class, or a
 *        few other things that generate uevents to add the environment
 *        variables.
 * @devnode:    Callback to provide the devtmpfs.
 * @class_release: Called to release this class.
 * @dev_release: Called to release the device.
 * @suspend:    Used to put the device to sleep mode, usually to a low power
 *        state.
 * @resume:    Used to bring the device from the sleep mode.
 * @ns_type:    Callbacks so sysfs can detemine namespaces.
 * @namespace:    Namespace of the device belongs to this class.
 * @pm:        The default device power management operations of this class.
 * @p:        The private data of the driver core, no one other than the
 *        driver core can touch this.
 *
 * A class is a higher-level view of a device that abstracts out low-level
 * implementation details. Drivers may see a SCSI disk or an ATA disk, but,
 * at the class level, they are all simply disks. Classes allow user space
 * to work with devices based on what they do, rather than how they are
 * connected or how they work.
 */
struct class {
    const char        *name;类名字
    struct module        *owner;累的所有者

    struct class_attribute        *class_attrs;类的默认属性
    struct device_attribute        *dev_attrs;类中设备的默认属性
    struct bin_attribute        *dev_bin_attrs;类中设备的binary的默认属性
    struct kobject            *dev_kobj;代表这个类并将其链接到分层结构kobject中。

    int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);当一个设备被添加，从这个类中删除，或者其他事情要生成uevent添加环境变量时调用。
    char *(*devnode)(struct device *dev, umode_t *mode);提供devtmps回调

    void (*class_release)(struct class *class);类释放时调用
    void (*dev_release)(struct device *dev);设备释放时调用

    int (*suspend)(struct device *dev, pm_message_t state);用于将设备设置为休眠模式，通常为低功耗状态。
    int (*resume)(struct device *dev);退出睡眠模式

    const struct kobj_ns_type_operations *ns_type;sys回调，使其知道命名空间
    const void *(*namespace)(struct device *dev);类中设备的命名空间

    const struct dev_pm_ops *pm;类的默认设备电源管理操作

    struct subsys_private *p;驱动程序内核的私有数据，除了驱动程序内核之外，其他不可访问
};

Device（设备）：抽象系统中所有的硬件设备，描述它的名字、属性、从属的Bus、从属的Class等信息。

/**
 * 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.
 * @pm_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.
 * @pins:    For device pin management.
 *        See Documentation/pinctrl.txt for details.
 * @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.
 * @acpi_node:    Associated ACPI device node.
 * @devt:    For creating the sysfs "dev".
 * @id:        device instance
 * @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 device_private

    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.
                     */互斥同步锁，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 */设备的特定平台数据。例如:对于custom板上的设备，作为典型的嵌入式和基于SOC的硬件，
 80     Linux经常使用platform_data来指向custom板的结构，这些结构描述设备及其连接方式。这可以包括可用的端口、芯片变体、GPIO引脚等等。这减少了“板支持包”(bsp).
    struct dev_pm_info    power;设备电源管理信息，详见Documentation/power/devices.txt 
    struct dev_pm_domain    *pm_domain;提供在系统挂起、休眠、系统恢复和运行时PM转换期间执行的回调，以及子系统级和驱动程序级回调。

#ifdef CONFIG_PINCTRL
    struct dev_pin_info    *pins;用于设备pin管理。有关详细信息，详见Documentation/pinctrl.txt。
#endif

#ifdef CONFIG_NUMA
    int        numa_node;    /* NUMA node this device is close to */设备的NUMA节点
#endif
    u64        *dma_mask;    /* dma mask (if dma'able device) */dma掩码
    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_CMA
    struct cma *cma_area;        /* contiguous memory area for dma
                       allocations */
#endif
    /* arch specific additions */
    struct dev_archdata    archdata;

    struct device_node    *of_node; /* associated device tree node */
    struct acpi_dev_node    acpi_node; /* associated ACPI device node */

    dev_t            devt;    /* dev_t, creates the sysfs "dev" */设备号
    u32            id;    /* device instance */

    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);回调函数，所有引用都释放掉之后。由bus设置。
    struct iommu_group    *iommu_group;
};

Device Driver（驱动）：Linux设备模型用Driver抽象硬件设备的驱动程序，它包含设备初始化、电源管理相关的接口实现。而Linux内核中的驱动开发，基本都围绕该抽象进行（实现所规定的接口函数）。

/**
 * 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.
 * @acpi_match_table: The ACPI match 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;驱动名字
    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 */通过sysfs disable bind/unbind

    const struct of_device_id    *of_match_table;
    const struct acpi_device_id    *acpi_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;
};

注：什么是Platform Bus？ 
在计算机中有这样一类设备，它们通过各自的设备控制器，直接和CPU连接，CPU可以通过常规的寻址操作访问它们（或者说访问它们的控制器【寄存器】）。这种连接方式，并不属于传统意义上的总线连接。但设备模型应该具备普适性，因此Linux就虚构了一条Platform Bus，供这些设备挂靠。

2.2 设备模型的核心思想

Linux设备模型的核心思想是（通过xxx手段，实现xxx目的）：

1. 用Device（struct device）和Device Driver（struct device_driver）两个数据结构，分别从“有什么用”和“怎么用”两个角度描述硬件设备。这样就统一了编写设备驱动的格式，使驱动开发从论述题变为填空体，从而简化了设备驱动的开发。

2. 同样使用Device和Device Driver两个数据结构，实现硬件设备的即插即用（热拔插）。 
在Linux内核中，只要任何Device和Device Driver具有相同的名字，内核就会执行Device Driver结构中的初始化函数（probe），该函数会初始化设备，使其为可用状态。 
而对大多数热拔插设备而言，它们的Device Driver一直存在内核中。当设备没有插入时，其Device结构不存在，因而其Driver也就不执行初始化操作。当设备插入时，内核会创建一个Device结构（名称和Driver相同），此时就会触发Driver的执行。这就是即插即用的概念。

3. 通过"Bus-->Device”类型的树状结构解决设备之间的依赖，而这种依赖在开关机、电源管理等过程中尤为重要。 
试想，一个设备挂载在一条总线上，要启动这个设备，必须先启动它所挂载的总线。很显然，如果系统中设备非常多、依赖关系非常复杂的时候，无论是内核还是驱动的开发人员，都无力维护这种关系。 
而设备模型中的这种树状结构，可以自动处理这种依赖关系。启动某一个设备前，内核会检查该设备是否依赖其它设备或者总线，如果依赖，则检查所依赖的对象是否已经启动，如果没有，则会先启动它们，直到启动该设备的条件具备为止。而驱动开发人员需要做的，就是在编写设备驱动时，告知内核该设备的依赖关系即可。

4. 使用Class结构，在设备模型中引入面向对象的概念，这样可以最大限度地抽象共性，减少驱动开发过程中的重复劳动，降低工作量。

感谢博友分享，参考博文：https://blog.csdn.net/qq_16777851/java/article/details/81367246