# 前置知识
总线驱动模型简介：
总线是处理器与一个或者多个设备之间的通道，在设备模型中，所有的设备都是通过总线相连，当然也包括虚拟的 platform 平台总线。
总线驱动模型中有三要素：
1. 总线
/*** 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.* @dev_attrs: Default attributes of the devices on the bus.* @bus_groups: Default attributes of the bus.* @dev_groups: Default attributes of the devices on the bus.* @drv_groups: 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.** @online: Called to put the device back online (after offlining it).* @offline: Called to put the device offline for hot-removal. May fail.** @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.* @lock_key: Lock class key for use by the lock validator** 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 device_attribute *dev_attrs; /* use dev_groups instead */const struct attribute_group **bus_groups;const struct attribute_group **dev_groups;const struct attribute_group **drv_groups;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 (*online)(struct device *dev);int (*offline)(struct device *dev);int (*suspend)(struct device *dev, pm_message_t state);int (*resume)(struct device *dev);const struct dev_pm_ops *pm;const struct iommu_ops *iommu_ops;struct subsys_private *p;struct lock_class_key lock_key;
};API：
extern int __must_check bus_register(struct bus_type *bus);extern void bus_unregister(struct bus_type *bus);平台总线定义：
struct bus_type platform_bus_type = {.name = "platform",.dev_groups = platform_dev_groups,.match = platform_match,.uevent = platform_uevent,.pm = &platform_dev_pm_ops,
};平台总线的注册如下：
int __init platform_bus_init(void)
{int error;early_platform_cleanup();error = device_register(&platform_bus);if (error)return error;error = bus_register(&platform_bus_type);if (error)device_unregister(&platform_bus);of_platform_register_reconfig_notifier();return error;
}2. 总线设备
struct platform_device {const char *name; /* 名字 */ int id; /* 用于标识该设备的ID */bool id_auto; /* 指示在注册设备时，是否自动赋予ID值 */struct device dev; /* 真正的设备（Platform设备只是一个特殊的设备，因此其核心逻辑还是由底层的模块实现） */u32 num_resources; /* 资源个数 */struct resource *resource; /* 该设备的资源描述 */const struct platform_device_id *id_entry;char *driver_override; /* Driver name to force a match *//* MFD cell pointer */struct mfd_cell *mfd_cell;/* arch specific additions */struct pdev_archdata archdata; /* 私有数据 */
};struct resource {resource_size_t start; /* 起始地址 */resource_size_t end; /* 结束地址 */const char *name; /* 资源名字 */unsigned long flags; /* 资源标识 */struct resource *parent, *sibling, *child;
};API：
/* 注册平台设备 */
int platform_device_register(struct platform_device *);/* 注销平台设备 */
void platform_device_unregister(struct platform_device *);/* 设置platform_device变量中的archdata指针 */
void arch_setup_pdev_archdata(struct platform_device *);/* 通过资源类型获取platform_device变量中的resource信息 */
struct resource *platform_get_resource(struct platform_device *,unsigned int, unsigned int);/* 通过资源名字获取platform_device变量中的resource信息 */
struct resource *platform_get_resource_byname(struct platform_device *,unsigned int,const char *);3. 总线驱动
struct platform_driver {int (*probe)(struct platform_device *); /* 当驱动和硬件信息匹配成功之后，就会调用probe函数，驱动所有的资源的注册和初始化全部放在probe函数中 */int (*remove)(struct platform_device *); /* 硬件信息被移除了，或者驱动被卸载了，全部要释放，释放资源的操作就放在该函数中 */void (*shutdown)(struct platform_device *);int (*suspend)(struct platform_device *, pm_message_t state);int (*resume)(struct platform_device *) ;struct device_driver driver; /* 内核维护的所有的驱动必须包含该成员，通常driver->name用于和设备进行匹配 */const struct platform_device_id *id_table; /* 往往一个驱动可能能同时支持多个硬件，这些硬件的名字都放在该结构体数组中 */bool prevent_deferred_probe;
};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 */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;
};API：
/** use a macro to avoid include chaining to get THIS_MODULE*/
/* 注册设备 */
#define platform_driver_register(drv) \__platform_driver_register(drv, THIS_MODULE)
extern int __platform_driver_register(struct platform_driver *,struct module *);/* 注销设备 */
extern void platform_driver_unregister(struct platform_driver *);/* non-hotpluggable platform devices may use this so that probe() and* its support may live in __init sections, conserving runtime memory.*/
#define platform_driver_probe(drv, probe) \__platform_driver_probe(drv, probe, THIS_MODULE)
extern int __platform_driver_probe(struct platform_driver *driver,int (*probe)(struct platform_device *), struct module *module);/* 获取设备私有资源 */
static inline void *platform_get_drvdata(const struct platform_device *pdev)
{return dev_get_drvdata(&pdev->dev);
}设备与驱动匹配过程
来自：https://blog.csdn.net/qq_16504163/article/details/118562670
# 示例代码
platform_device:
#include <linux/init.h>
#include <linux/file.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/slab.h>#define CCM_CCGR1_ADDR 0x20C406C
#define IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03_ADDR 0x20E0068
#define IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO03_ADDR 0x20E02F4
#define GPIO1_BASE_ADDR 0x209C000 static struct resource atk_led_resource[] = {[0] = {.start = CCM_CCGR1_ADDR,.end = CCM_CCGR1_ADDR + 4,.name = "led_clock",.flags = IORESOURCE_MEM,},[1] = {.start = IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03_ADDR,.end = IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO03_ADDR + 4,.name = "led_mux_ctrl",.flags = IORESOURCE_MEM,},[2] = {.start = IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO03_ADDR,.end = IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO03_ADDR + 4,.name = "led_pad_ctrl",.flags = IORESOURCE_MEM,},[3] = {.start = GPIO1_BASE_ADDR,.end = GPIO1_BASE_ADDR + 4,.name = "led_gpio_ctrl",.flags = IORESOURCE_MEM,}
};static void atk_led_release(struct device *dev)
{}static struct platform_device atk_led_dev = {.name = "atk_led",.id = -1,.resource = atk_led_resource,.num_resources = ARRAY_SIZE(atk_led_resource),.dev = {.release = atk_led_release,},
};static int __init led_device_init(void)
{int err;err = platform_device_register(&atk_led_dev);return 0;
}static void __exit led_device_exit(void)
{platform_device_unregister(&atk_led_dev);
}module_init(led_device_init);
module_exit(led_device_exit);MODULE_LICENSE("GPL");platform_driver:
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/miscdevice.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/mutex.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/stat.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/tty.h>
#include <linux/kmod.h>
#include <linux/gfp.h>
#include <linux/io.h>
#include <linux/platform_device.h>typedef struct
{volatile uint32_t GPIO_DR;volatile uint32_t GPIO_GDIR;volatile uint32_t GPIO_PSR;volatile uint32_t GPIO_ICR1;volatile uint32_t GPIO_ICR2;volatile uint32_t GPIO_IMR;volatile uint32_t GPIO_ISR;volatile uint32_t GPIO_EDGE_SEL;
}GPIO_TypeDef;static GPIO_TypeDef *GPIO;static volatile uint32_t *CCM_CCGR;
static volatile uint32_t *IOMUXC_SW_MUX_CTL_PAD;
static volatile uint32_t *IOMUXC_SW_PAD_CTL_PAD;struct pri_led_TypeDef
{char drv_name[50]; /* 驱动名称 */int major; /* 主设备号 */int minor; /* 次设备号 */dev_t devt; /* 设备号 */struct device *device; /* 设备 */char device_name[50]; /* 设备名称 */struct class *class; /* 类 */char class_name[50]; /* 类名称 */
};static struct pri_led_TypeDef pri_led = {.drv_name = "led_drv",.major = 0,.minor = 0,.devt = 0,.device = NULL,.device_name = "led_dev",.class = NULL,.class_name = "led_class",
};static int led_open(struct inode *inode, struct file *file)
{uint32_t val;/* 使能GPIO1时钟 */*CCM_CCGR |= (3 << 26);/* 设置IO复用 */val = *IOMUXC_SW_MUX_CTL_PAD;val &= ~(0x0F);val |= 5;*IOMUXC_SW_MUX_CTL_PAD = val;/* 设置IO属性 *//* 设置IO方向,设置GPIO1_IO03为输出 */GPIO->GPIO_GDIR |= (1 << 3);return 0;
}static int led_release(struct inode *inode, struct file *file)
{return 0;
}static ssize_t led_write(struct file *file, const char __user *buff, size_t size, loff_t *ppos)
{uint8_t status;int err;err = copy_from_user(&status, buff, 1);if(status == 1){GPIO->GPIO_DR &= ~(1<<3);}else{GPIO->GPIO_DR |= (1<<3);}return 1;
}static const struct file_operations led_op = {.owner = THIS_MODULE,.open = led_open,.release = led_release,.write = led_write,
};static int atk_led_drv_probe(struct platform_device *dev)
{struct resource *res;int err;printk("atk_led_drv_probe\r\n");res = platform_get_resource(dev, IORESOURCE_MEM, 0);CCM_CCGR = ioremap(res->start, (res->end - res->start));res = platform_get_resource(dev, IORESOURCE_MEM, 1);IOMUXC_SW_MUX_CTL_PAD = ioremap(res->start, (res->end - res->start));res = platform_get_resource(dev, IORESOURCE_MEM, 2);IOMUXC_SW_PAD_CTL_PAD = ioremap(res->start, (res->end - res->start));res = platform_get_resource(dev, IORESOURCE_MEM, 3);GPIO = ioremap(res->start, sizeof(GPIO_TypeDef));pri_led.major = register_chrdev(0, pri_led.drv_name, &led_op);pri_led.devt = MKDEV(pri_led.major, pri_led.minor);pri_led.class = class_create(THIS_MODULE, pri_led.class_name);if(IS_ERR(pri_led.class)){printk("class_create error\r\n");err = PTR_ERR(pri_led.class);goto err_class_create_out;}pri_led.device = device_create(pri_led.class, NULL, pri_led.devt, NULL, pri_led.device_name);if(IS_ERR(pri_led.device)){printk("device_create error\r\n");err = PTR_ERR(pri_led.device);goto err_device_create_out;}return 0;err_device_create_out:class_destroy(pri_led.class);
err_class_create_out:unregister_chrdev(pri_led.major, pri_led.drv_name);return err;
}static int atk_led_drv_remove(struct platform_device *dev)
{printk("atk_led_drv_remove\r\n");iounmap(GPIO);iounmap(CCM_CCGR);iounmap(IOMUXC_SW_MUX_CTL_PAD);iounmap(IOMUXC_SW_PAD_CTL_PAD);device_destroy(pri_led.class, pri_led.devt);class_destroy(pri_led.class);unregister_chrdev(pri_led.major, pri_led.drv_name);return 0;
}static struct platform_driver atk_led_driver = {.probe = atk_led_drv_probe,.remove = atk_led_drv_remove,.driver = {.name = "atk_led",},
};static int __init led_driver_init(void)
{int err;err = platform_driver_register(&atk_led_driver);return 0;
}static void __exit led_driver_exit(void)
{platform_driver_unregister(&atk_led_driver);
}module_init(led_driver_init);
module_exit(led_driver_exit);MODULE_LICENSE("GPL");# 补充知识
1. platform_match 匹配规程
static int platform_match(struct device *dev, struct device_driver *drv)
{struct platform_device *pdev = to_platform_device(dev);struct platform_driver *pdrv = to_platform_driver(drv);/* When driver_override is set, only bind to the matching driver */if (pdev->driver_override)return !strcmp(pdev->driver_override, drv->name);/* Attempt an OF style match first */if (of_driver_match_device(dev, drv))return 1;/* Then try ACPI style match */if (acpi_driver_match_device(dev, drv))return 1;/* Then try to match against the id table */if (pdrv->id_table)return platform_match_id(pdrv->id_table, pdev) != NULL;/* fall-back to driver name match */return (strcmp(pdev->name, drv->name) == 0);
}- 最先比较：platform_device.driver_override 和 platform_driver.driver.name，可以设置 platform_device 的 driver_override，强制选择某个 platform_driver
- 然后比较：platform_device. name 和 platform_driver.id_table[i].name，Platform_driver.id_table 是“platform_device_id”指针，表示该 drv 支持若干个 device，它里面列出了各个 device 的{.name, .driver_data}，其中的“ name”表示该drv 支持的设备的名字， driver_data 是些提供给该 device 的私有数据
- 最后比较：platform_device.name 和 platform_driver.driver.name，platform_driver.id_table 可能为空，这时可以根据 platform_driver.driver.name 来寻找同名的 platform_device
2. struct platform_device 中 id 的作用
switch (pdev->id) {default:dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);break;case PLATFORM_DEVID_NONE: /* -1 */dev_set_name(&pdev->dev, "%s", pdev->name);break;case PLATFORM_DEVID_AUTO: /* -2 *//** Automatically allocated device ID. We mark it as such so* that we remember it must be freed, and we append a suffix* to avoid namespace collision with explicit IDs.*/ret = ida_simple_get(&platform_devid_ida, 0, 0, GFP_KERNEL);if (ret < 0)goto err_out;pdev->id = ret;pdev->id_auto = true;dev_set_name(&pdev->dev, "%s.%d.auto", pdev->name, pdev->id);break;}- id = -1 时，名称直接为名字
- id = -2时，名称为自动获取的id加上.auto
- 其他为名称加上id
