Linux platform平台总线、平台设备、平台驱动
平台总线（platform_bus）的需求来源？
随着soc的升级，S3C2440->S3C6410->S5PV210->4412，以前的程序就得重新写一遍，做着大量的重复工作，
人们为了提高效率，发现控制器的操作逻辑（方法）是一样的，只有寄存器地址不一样，如果将与硬件有关的
代码（platform_device）和驱动代码（platform_driver）分开，升级soc后，因为驱动方式一样，
只需要修改与硬件有关的代码就可以，实现一个驱动控制多个设备。
平台（platform）总线是一种虚拟的总线，在 /sys/bus/platform 目录可以看到。
平台总线三要素：平台总线、平台设备、平台驱动
平台总线原则：先分离，后合并
分离：
将设备信息封装成 platform_device，将驱动信息封装成 platform_driver，并为各自起名称，
然后将 platform_device 中的 struct device 和 platform_driver 中的 struct device_driver 分别注册到设备链表和驱动链表中。
int platform_device_register(struct platform_device *pdev)
return platform_device_add(pdev);
ret = device_add(&pdev->dev);
int platform_driver_register(struct platform_driver *drv)
return driver_register(&drv->driver);
ret = bus_add_driver(drv);
合并：
在系统每注册一个设备（驱动）时，平台总线会找与之匹配的驱动（设备），匹配原则是名称相同。
装载（insmod）时设备和驱动没有顺序，卸载（rmmod）时必须先卸载设备文件，因为卸载设备会调用驱动中的 remove 函数
// 下面的“|”表示包含于上一个之中 // 描述设备的信息 struct platform_device { const char * name; // 用于和platform_driver进行匹配的名字--自定义 int id; // 一般直接填-1，区分不同的控制组 struct device dev; // 父类 | void (*release)(struct device *dev); // 设备卸载时调用的函数 void *platform_data; // 匹配后传递的自定义数据 ... ... u32 num_resources; // 资源的个数 struct resource * resource; // 描述资源信息 | resource_size_t start; // 起始位置 resource_size_t end; // 结束位置 const char *name; // 自定义 unsigned long flags; // 区分不同的资源，一般是 内存或者中断资源 ... ... }; // 描述设备的操作方法 struct platform_driver { int (*probe)(struct platform_device *); // 设备和驱动匹配后调用的函数 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; // 父类 | const char *name; // 该名字可以用于匹配，但比id_table中的name优先级低 // 此名称在 /sys/bus/platform/drivers/xxx ... ... const struct platform_device_id *id_table; | char name[PLATFORM_NAME_SIZE]; // 用于和platform_device的名字进行匹配，优先级高 }; // 平台总线 struct bus_type platform_bus_type = { .name = "platform", .dev_attrs = platform_dev_attrs, .match = platform_match, // 用于匹配，此函数可以看出匹配名称的优先级 .uevent = platform_uevent, .pm = &platform_dev_pm_ops, };
// 注册 platform_devive
int platform_device_register(struct platform_device *pdev);
// 注销 platform_devive
void platform_device_unregister(struct platform_device *pdev);
// 注册 platform_driver
int platform_driver_register(struct platform_driver *drv);
// 注销 platform_driver
void platform_driver_unregister(struct platform_driver *drv);
// 批量注册pdev
int platform_add_devices(struct platform_device **devs, int num);
获取资源的接口：
// 通过类型和编号获取资源
// 参数1：pdev
// 参数2：获取的资源类型
// 参数3：获取的资源编号
struct resource *platform_get_resource(struct platform_device *dev,unsigned int type, unsigned int num);
// 通过类型和名称获取资源
// 参数3：获取资源的名称
struct resource * platform_get_resource_byname(struct platform_device * dev,unsigned int type,const char * name);
// 通过编号获取中断资源
int platform_get_irq(struct platform_device * dev,unsigned int num);
// 通过名称获取中断资源
int platform_get_irq_byname(struct platform_device * dev,const char * name);
// 重点：资源编号一定是按照同种类型来排序的 struct resource led_res[] = { [0] = { // 获取内存资源时，此内存资源的编号为0 ... ... .flags = IORESOURCE_MEM, }, [1] = { // 获取中断资源时，此中断资源的编号为0 ... ... .flags = IORESOURCE_IRQ, }, [2] = { // 获取内存资源时，此内存资源的编号为1 ... ... .flags = IORESOURCE_MEM, }, };
plat_led_dev.c
#include <linux/module.h> #include <linux/init.h> #include <linux/platform_device.h> #include "plat_led.h" #define GPL2_0 0x11000100 #define GP_SIZE 8 // 平台自定义数据，与硬件相关 struct regled led_reg = { .ctl_clr = 0x0f, .ctl_set = 0x01, .dat_clr = 0x01, .dat_set = 0x01, }; static struct resource led_res[] = { [0] = { .start = GPL2_0, .end = GPL2_0 + GP_SIZE - 1, .name = "led0", .flags = IORESOURCE_MEM, }, [1] = { .start = 888, .end = 888, .name = "virt_irq", .flags = IORESOURCE_IRQ, }, }; void plat_led_release(struct device *dev) { // 为了卸载模块时不报错误 } struct platform_device led_pdev = { .name = "plat_led", .id = -1, .dev = { .platform_data = &led_reg, .release = plat_led_release, }, .num_resources = ARRAY_SIZE(led_res), .resource = led_res, }; static int __init plat_led_dev_init(void) { platform_device_register(&led_pdev); return 0; } static void __exit plat_led_dev_exit(void) { platform_device_unregister(&led_pdev); } module_init(plat_led_dev_init); module_exit(plat_led_dev_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Aaron Lee");
plat_led_drv.c
#include <linux/module.h> #include <linux/init.h> #include <linux/fs.h> #include <linux/device.h> #include <linux/slab.h> #include <linux/platform_device.h> #include <asm/io.h> #include <asm/uaccess.h> #include "plat_led.h" struct samsung *platled; static int platled_open(struct inode *inode, struct file *fops) { writeb(readb(platled->reg_base+4) & (~platled->reg->dat_clr), platled->reg_base+4); return 0; } static int platled_close(struct inode *inode, struct file *fops) { return 0; } static ssize_t platled_write(struct file *fops, const char __user *buf, size_t size, loff_t *fpos) { int value; //暂时忽略返回值 copy_from_user(&value, buf, size); if (value) writeb((readb(platled->reg_base+4) & (~platled->reg->dat_clr)) | platled->reg->dat_set, platled->reg_base+4); else writeb(readb(platled->reg_base+4) & (~platled->reg->dat_clr), platled->reg_base+4); return 0; } const struct file_operations platled_fops = { .open = platled_open, .release = platled_close, .write = platled_write, }; static int led_register(void) { int ret; platled = kmalloc(sizeof(struct samsung), GFP_KERNEL); if (platled == NULL) { printk("kmalloc fail!\n"); return -ENOMEM; } platled->major = register_chrdev(0, "plat_led", &platled_fops); if (platled->major < 0) { printk("register_chrdev fail!\n"); ret = -EFAULT; goto chrdev_err; } platled->cls = class_create(THIS_MODULE, "plat_led"); if (platled->cls < 0) { printk("class_create fail!\n"); ret = -EFAULT; goto class_err; } platled->dev = device_create(platled->cls, NULL, MKDEV(platled->major, 0), NULL, "plat_led"); if (platled->dev < 0) { printk("device_create fail!\n"); ret = -EFAULT; goto device_err; } return 0; device_err: class_destroy(platled->cls); class_err: unregister_chrdev(platled->major, "plat_led"); chrdev_err: kfree(platled); return ret; } static void led_unregister(void) { device_destroy(platled->cls, MKDEV(platled->major, 0)); class_destroy(platled->cls); unregister_chrdev(platled->major, "plat_led"); kfree(platled); } int plat_led_probe(struct platform_device *pdev) { int ret; struct resource *res; ret = led_register(); if (ret < 0) { printk("plat_led_probe fail\n"); return -EFAULT; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { printk("platform_get_resource fail\n"); return -ENODEV; } // 获取平台自定义数据 platled->reg = pdev->dev.platform_data; platled->reg_base = ioremap(res->start, resource_size(res)); writel((readl(platled->reg_base) & (~platled->reg->ctl_clr)) | platled->reg->ctl_set, platled->reg_base); return 0; } int plat_led_remove(struct platform_device *pdev) { iounmap(platled->reg_base); led_unregister(); return 0; } const struct platform_device_id led_id_table[] = { {"plat_led", 0x1234}, //第二个整数是自定义 }; struct platform_driver led_pdrv = { .probe = plat_led_probe, .remove = plat_led_remove, .driver = { .name = "red_led", }, .id_table = led_id_table,// name用于匹配 }; static int __init plat_led_drv_init(void) { platform_driver_register(&led_pdrv); return 0; } static void __exit plat_led_drv_exit(void) { platform_driver_unregister(&led_pdrv); } module_init(plat_led_drv_init); module_exit(plat_led_drv_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Aaron Lee");
plat_led.h
#ifndef __PLAT_LED_H_ #define __PLAT_LED_H_ struct regled { unsigned long ctl_clr; unsigned long ctl_set; unsigned long dat_clr; unsigned long dat_set; }; struct samsung { int major; struct class *cls; struct device *dev; struct regled *reg; void *reg_base; }; #endif
