Linux字符设备驱动详解五（使用platform虚拟平台总线）

系列文章目录

Linux字符设备驱动详解
Linux字符设备驱动详解二（使用设备驱动模型）
Linux字符设备驱动详解三（使用class）
Linux字符设备驱动详解四（使用自属的xbus驱动总线）
Linux字符设备驱动详解五（使用platform虚拟平台总线）
Linux字符设备驱动详解六（设备树实现RGB灯驱动）
Linux字符设备驱动详解七（“插件“设备树实现RGB灯驱动）

前言

本文主要来自正点原子、野火Linux教程及本人理解，若有侵权请及时联系本人删除。

驱动目录

sys/bus/platform（系统已有）
sys/bus/platform/devices drivers
sys/bus/platform/devices/imx6ull-rled
sys/bus/platform/drivers/imx6ull-rled

正文

platform：虚拟的平台总线

• platform_device：继承device，关联硬件代码
• platform_driver：继承device_driver，重设probe函数指针
• platform(bus_type)：统一管理、设置match匹配规则

平台总线注册

platform_bus_init()函数

struct bus_type platform_bus_type = {
	.name		= "platform",
	.dev_groups	= platform_dev_groups,
	.match		= platform_match,
	.uevent		= platform_uevent,
	.dma_configure	= platform_dma_configure,
	.pm		= &platform_dev_pm_ops,
};

int __init platform_bus_init(void)
{
...
	error =  bus_register(&platform_bus_type);
...
	return error;
}

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);
}

• of_driver_match_device：设备树匹配
• acpi_driver_match_device：ACPI匹配
• platform_match_id：id_table匹配
• strcmp(pdev->name, drv->name)：设备名和驱动名匹配

平台设备注册

platform_device_register()函数

int platform_device_register(struct platform_device *pdev)

• 继承device

resources结构体，描述驱动的硬件资源

• start：资源的开始值
• end：资源的结束值
• flasg：资源的类型
  • IORESOURCE_MEM：内存地址
  • IORESOURCE_IO：IO端口
  • IORESOURCE_DMA：DMA传输
  • IORESOURCE_IRQ：中断

平台驱动注册

platform_driver_register()宏

#define platform_driver_register(drv) \
	__platform_driver_register(drv, THIS_MODULE)
extern int __platform_driver_register(struct platform_driver *,
					struct module *);

平台驱动获取资源

platform_get_resource()函数

struct resource *platform_get_resource(struct platform_device *dev, unsigned int type, unsigned int num)

• dev：平台设备
• type：资源类型
• num：resources数组中资源编号

代码示例

以野火设备驱动模型代码为例
platform_device.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/platform_device.h>


#define CCM_CCGR1 																			  0x20C406C		//时钟控制寄存器
#define IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO04 				0x20E006C	  //GPIO1_04复用功能选择寄存器
#define IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO04 				 0x20E02F8		//PAD属性设置寄存器
#define GPIO1_GDIR 																			   0x0209C004	//GPIO方向设置寄存器（输入或输出）
#define GPIO1_DR 																				  0x0209C000   //GPIO输出状态寄存器
#define REGISTER_LENGTH																 4							//寄存器长度

/*定义平台设备的硬件资源列表*/
static struct resource rled_resource[] = {
	
	[0] = {
		.start 	= GPIO1_DR,
		.end 	= (GPIO1_DR + REGISTER_LENGTH - 1),
		.flags 	= IORESOURCE_MEM,
	},	
	[1] = {
		.start	= GPIO1_GDIR,
		.end	= (GPIO1_GDIR + REGISTER_LENGTH - 1),
		.flags	= IORESOURCE_MEM,
	},
	[2] = {
		.start	= IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO04,
		.end	= (IOMUXC_SW_MUX_CTL_PAD_GPIO1_IO04 + REGISTER_LENGTH - 1),
		.flags	= IORESOURCE_MEM,
	},
	[3] = {
		.start	= CCM_CCGR1,
		.end	= (CCM_CCGR1 + REGISTER_LENGTH - 1),
		.flags	= IORESOURCE_MEM,
	},
	[4] = {
		.start	= IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO04,
		.end	= (IOMUXC_SW_PAD_CTL_PAD_GPIO1_IO04 + REGISTER_LENGTH - 1),
		.flags	= IORESOURCE_MEM,
	},
};

/*释放paltform设备模块时执行*/
static void	rled_release(struct device *dev)
{
	printk(KERN_ALERT "led device released!\r\n");	
}

/*定义平台设备*/
static struct platform_device rled_pdev = {
	.name = "imx6ull-rled",
	.id = -1,
	.dev.release  = rled_release,
	.num_resources = ARRAY_SIZE(rled_resource),
	.resource = rled_resource,
};

/*模块入口函数，注册平台设备*/
static __init int leddevice_init(void)
{
	printk(KERN_ALERT "leddevice_init\r\n");
	platform_device_register(&rled_pdev);
	return 0;
}

/*模块退出函数，注销平台设备*/
static __exit void leddevice_exit(void)
{
	platform_device_unregister(&rled_pdev);
}

module_init(leddevice_init);
module_exit(leddevice_exit);


MODULE_LICENSE("GPL");
MODULE_AUTHOR("embedfire ");
MODULE_DESCRIPTION("led_module");
MODULE_ALIAS("led_module");

platform_driver.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>

#include <linux/fs.h>
#include <linux/uaccess.h>
#include <asm/io.h>

#include <linux/mod_devicetable.h>
#include <linux/platform_device.h>
#include <linux/device.h>

#define DEV_MAJOR		0		/* 动态申请主设备号 */
#define DEV_NAME		"red_led" 	/*led设备名字 */

/* GPIO虚拟地址指针 */
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO04;
static void __iomem *SW_PAD_GPIO1_IO04;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

static int led_open(struct inode *inode, struct file *filp)
{
	return 0;
}

static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return -EFAULT;
}

static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{

	unsigned char databuf[10];

	if(cnt >10)
		cnt =10;
		
    /*从用户空间拷贝数据到内核空间*/
    if(copy_from_user(databuf, buf, cnt)){
		return -EIO;
	}
    	
	if(!memcmp(databuf,"on",2)) {	
		iowrite32(0 << 4, GPIO1_DR);	
	} else if(!memcmp(databuf,"off",3)) {
		iowrite32(1 << 4, GPIO1_DR);
	}
	/*写成功后，返回写入的字数*/
	return cnt;
}

static int led_release(struct inode *inode, struct file *filp)
{
	return 0;
}

/* 自定义led的file_operations 接口*/
static struct file_operations led_fops = {
	.owner = THIS_MODULE,
	.open = led_open,
	.read = led_read,
	.write = led_write,
	.release = 	led_release,
};


int major = 0;
struct class *class_led;
static int led_probe(struct platform_device *pdev)
{

	struct resource *mem_dr;
	struct resource *mem_gdir;
	struct resource *mem_iomuxc_mux;
	struct resource *mem_ccm_ccgrx;
	struct resource *mem_iomux_pad; 

	printk(KERN_ALERT "led_probe\r\n");
	mem_dr = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	mem_gdir = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	mem_iomuxc_mux = platform_get_resource(pdev, IORESOURCE_MEM, 2);
	mem_ccm_ccgrx = platform_get_resource(pdev, IORESOURCE_MEM, 3);
	mem_iomux_pad = platform_get_resource(pdev, IORESOURCE_MEM, 4);

	/* GPIO相关寄存器映射 */
  	IMX6U_CCM_CCGR1 = ioremap(mem_ccm_ccgrx->start,resource_size(mem_ccm_ccgrx));
	SW_MUX_GPIO1_IO04 = ioremap(mem_iomuxc_mux->start,resource_size(mem_iomuxc_mux));
  	SW_PAD_GPIO1_IO04 = ioremap(mem_iomux_pad->start,resource_size(mem_iomux_pad));
	GPIO1_GDIR = ioremap(mem_gdir->start, resource_size(mem_gdir));
	GPIO1_DR = ioremap(mem_dr->start, resource_size(mem_dr));	
		
		
	/* 使能GPIO1时钟 */
	iowrite32(0xffffffff, IMX6U_CCM_CCGR1);

	/* 设置GPIO1_IO04复用为普通GPIO*/
	iowrite32(5, SW_MUX_GPIO1_IO04);
	
    /*设置GPIO属性*/
	iowrite32(0x10B0, SW_PAD_GPIO1_IO04);

	/* 设置GPIO1_IO04为输出功能 */
	iowrite32(1 << 4, GPIO1_GDIR);

	/* LED输出高电平 */
	iowrite32(1<< 4, GPIO1_DR);	

	/* 注册字符设备驱动 */
	major = register_chrdev(DEV_MAJOR, DEV_NAME, &led_fops);
    printk(KERN_ALERT "led major:%d\n",major);

	/*创建/sys/class/xxx目录项*/
	class_led = class_create(THIS_MODULE, "xxx");

	/*创建/sys/class/xxx/my_led目录项，并生成dev属性文件*/
	device_create(class_led, NULL, MKDEV(major, 0), NULL,"my_led");

	return 0;
}

static int led_remove(struct platform_device *dev)
{
		/* 取消映射 */
	iounmap(IMX6U_CCM_CCGR1);
	iounmap(SW_MUX_GPIO1_IO04);
	iounmap(SW_PAD_GPIO1_IO04);
	iounmap(GPIO1_DR);
	iounmap(GPIO1_GDIR);

	/* 注销字符设备驱动 */
	unregister_chrdev(major, DEV_NAME);

	/*销毁/sys/class/xxx/my_led目录项*/
	device_destroy(class_led, MKDEV(major, 0));

	/*销毁/sys/class/xxx目录项*/
	class_destroy(class_led);

	return 0;
}

/*与平台设备文件名匹配*/
static struct platform_device_id led_ids[] = {
	{.name = "imx6ull-rled"},
	{}
};

/*定义平台驱动*/
static struct platform_driver led_driver = {
	.driver.name       =   "imx6ull-rled",
	.probe		 = led_probe,
	.remove	  = led_remove,
	.id_table = led_ids,
};

/*模块入口函数，注册平台驱动*/
static int __init leddriver_init(void)
{
	printk(KERN_ALERT "leddriver_init\r\n");
	return platform_driver_register(&led_driver);
}

/*模块退出函数，注销平台驱动*/
static void __exit leddriver_exit(void)
{
	platform_driver_unregister(&led_driver);
}


module_init(leddriver_init );
module_exit(leddriver_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("embedfire ");
MODULE_DESCRIPTION("led_module");
MODULE_ALIAS("led_module");

总结

通过使用platform虚拟平台总线，实现了软件与硬件代码分离。