嵌入式系统驱动高级【3】——平台总线式驱动开发下__ID匹配和设备树匹配

# 一、ID匹配之框架代码

id匹配（可想象成八字匹配）：一个驱动可以对应多个设备 ------优先级次低

注意事项：

1.  device模块中，id的name成员必须与struct platform_device中的name成员内容一致，因此device模块中，struct platform_device中的name成员必须指定

2.  driver模块中，struct platform_driver成员driver的name成员必须指定，但与device模块中name可以不相同

```c

/*platform device框架*/

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/platform_device.h>

//定义资源数组

static void device_release(struct device *dev)

{

    printk("platform: device release\n");

}

struct platform_device_id test_id = {

    .name = "test_device",

};

struct platform_device test_device = {

    .name = "test_device",//必须初始化

    .dev.release = device_release,

    .id_entry = &test_id,

};

static int __init platform_device_init(void)

{

    platform_device_register(&test_device);

    return 0;

}

static void __exit platform_device_exit(void)

{

    platform_device_unregister(&test_device);

}

module_init(platform_device_init);

module_exit(platform_device_exit);

MODULE_LICENSE("Dual BSD/GPL");

```

 

```c

/*platform driver框架*/

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/platform_device.h>

static int driver_probe(struct platform_device *dev)

{

    printk("platform: match ok!\n");

    return 0;

}

static int driver_remove(struct platform_device *dev)

{

    printk("platform: driver remove\n");

    return 0;

}

struct platform_device_id testdrv_ids[] =

{

    [0] = {.name = "test_device"},

    [1] = {.name = "abcxyz"},

    [2] = {}, //means ending

};

struct platform_driver test_driver = {

    .probe = driver_probe,

    .remove = driver_remove,

    .driver = {

        .name = "xxxxx", //必须初始化

    },

    .id_table = testdrv_ids,

};

static int __init platform_driver_init(void)

{

    platform_driver_register(&test_driver);

    return 0;

}

static void __exit platform_driver_exit(void)

{

    platform_driver_unregister(&test_driver);

}

module_init(platform_driver_init);

module_exit(platform_driver_exit);

MODULE_LICENSE("Dual BSD/GPL");

```

用到结构体数组，一般不指定大小，初始化时最后加{}表示数组结束

设备中增加资源，驱动中访问资源

# 二、ID匹配之led驱动

leds_device.c

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

#define GPX1CON 0x11000C20
#define GPX1DAT 0x11000C24

#define GPX2CON 0x11000C40
#define GPX2DAT 0x11000C44

#define GPF3CON 0x114001E0
#define GPF3DAT 0x114001E4

void leds_dev_release (struct device *dev)
{
    printk("leds_dev_release recalled.\n");
}

struct resource leds_dev_res [] =
{
	[0] = {.start = GPX1CON,.end= GPX1CON + 3,.name="GPX1CON",.flags = IORESOURCE_MEM},
	[1] = {.start = GPX1DAT,.end= GPX1DAT + 3,.name="GPX1DAT",.flags = IORESOURCE_MEM},

    [2] = {.start = GPX2CON,.end= GPX2CON + 3,.name="GPX2CON",.flags = IORESOURCE_MEM},
	[3] = {.start = GPX2DAT,.end= GPX2DAT + 3,.name="GPX2DAT",.flags = IORESOURCE_MEM},

    [4] = {.start = GPF3CON,.end= GPF3CON + 3,.name="GPX3CON",.flags = IORESOURCE_MEM},
	[5] = {.start = GPF3DAT,.end= GPF3DAT + 3,.name="GPX3DAT",.flags = IORESOURCE_MEM},

};

struct platform_device_id leds_id = {
    .name = "leds",
};

struct platform_device leds_device = {
    .name = "leds",
    .dev.release = leds_dev_release,
    .resource = leds_dev_res,
    .num_resources = ARRAY_SIZE(leds_dev_res),
    .id_entry = &leds_id,
};

int __init leds_device_init(void)
{
    platform_device_register(&leds_device);
    return 0;
}

void __exit leds_device_exit(void)
{
    platform_device_unregister(&leds_device);
}

MODULE_LICENSE("GPL");
module_init(leds_device_init);
module_exit(leds_device_exit);

leds_driver.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/init.h>
#include "led_dev.h"

int major = 11, minor = 0, num = 1;

struct myled_dev
{
	struct cdev mydev;

	volatile unsigned long *pled2_con;
	volatile unsigned long *pled2_dat;

	volatile unsigned long *pled3_con;
	volatile unsigned long *pled3_dat;

	volatile unsigned long *pled4_con;
	volatile unsigned long *pled4_dat;

	volatile unsigned long *pled5_con;
	volatile unsigned long *pled5_dat;
};

struct myled_dev *pgmydev = NULL;

int myopen(struct inode *pnode, struct file * pfile)
{
	pfile->private_data = (void *) (container_of(pnode->i_cdev, struct myled_dev, mydev));

	return 0;
}

int myclose(struct inode *pnode, struct file * pfile)
{

	return 0;
}



void led_on(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
	case 2:
		writel((readl(pmydev->pled2_dat) | (0x1 << 7)),pmydev->pled2_dat);
		break;
	case 3:
		writel(readl(pmydev->pled3_dat) | (0x1),pmydev->pled3_dat);
		break;
	case 4:
		writel(readl(pmydev->pled4_dat) | (0x1 << 4),pmydev->pled4_dat);
		break;
	case 5:
		writel(readl(pmydev->pled5_dat) | (0x1 << 5),pmydev->pled5_dat);
		break;
	}
}

void led_off(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
	case 2:
		writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)),pmydev->pled2_dat);
		break;
	case 3:
		writel(readl(pmydev->pled3_dat) & (~(0x1)),pmydev->pled3_dat);
		break;
	case 4:
		writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)),pmydev->pled4_dat);
		break;
	case 5:
		writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)),pmydev->pled5_dat);
		break;
	}
}

long myled_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
{
	struct myled_dev *pmydev = (struct myled_dev *) pfile->private_data;

	if(arg < 2 || arg > 5)
	{
		return -1;
	}
	switch (cmd)
	{
		case MY_LED_ON:
			led_on(pmydev,arg);
			break;
		case MY_LED_OFF:
	 		led_off(pmydev,arg);
	 		break;
		default:
	 		return -1;
	}
	return 0;
}

void ioremap_ledreg(struct myled_dev *pmydev, struct platform_device *pdev)
{
	struct resource *pres = NULL;

	pres = platform_get_resource(pdev, IORESOURCE_MEM, 2);
	pmydev->pled2_con = ioremap(pres->start,4);
	pres = platform_get_resource(pdev, IORESOURCE_MEM, 3);
	pmydev->pled2_dat = ioremap(pres->start,4);

	pres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	pmydev->pled3_con = ioremap(pres->start,4);
	pres = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	pmydev->pled3_dat = ioremap(pres->start,4);

	pres = platform_get_resource(pdev, IORESOURCE_MEM, 4);
	pmydev->pled4_con = ioremap(pres->start,4);
	pres = platform_get_resource(pdev, IORESOURCE_MEM, 5);
	pmydev->pled4_dat = ioremap(pres->start,4);

	pmydev->pled5_con = pmydev->pled4_con;
	pmydev->pled5_dat = pmydev->pled4_dat;
}

void iounmap_ledreg(struct myled_dev *pmydev)
{
	iounmap(pmydev->pled2_con);
	pmydev->pled2_con = NULL;
	iounmap(pmydev->pled2_dat);
	pmydev->pled2_dat = NULL;

	iounmap(pmydev->pled3_con);
	pmydev->pled3_con = NULL;
	iounmap(pmydev->pled3_dat);
	pmydev->pled3_dat = NULL;

	iounmap(pmydev->pled4_con);
	pmydev->pled4_con = NULL;
	iounmap(pmydev->pled4_dat);
	pmydev->pled4_dat = NULL;

	pmydev->pled5_con = NULL;
	pmydev->pled5_dat = NULL;
}

void set_output_ledconreg(struct myled_dev *pmydev)
{
	writel((readl(pmydev->pled2_con) & (~(0xF << 28))) | (0x1 << 28),pmydev->pled2_con);
	writel((readl(pmydev->pled3_con) & (~(0xF))) | (0x1),pmydev->pled3_con);
	writel((readl(pmydev->pled4_con) & (~(0xF << 16))) | (0x1 << 16),pmydev->pled4_con);
	writel((readl(pmydev->pled5_con) & (~(0xF << 20))) 	| (0x1 << 20),pmydev->pled5_con);

	writel(readl(pmydev->pled2_dat) & (~(0x1 << 7)),pmydev->pled2_dat);
	writel(readl(pmydev->pled3_dat) & (~(0x1)),pmydev->pled3_dat);
	writel(readl(pmydev->pled4_dat) & (~(0x1 << 4)),pmydev->pled4_dat);
	writel(readl(pmydev->pled5_dat) & (~(0x1 << 5)),pmydev->pled5_dat);
}

struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = myopen,
	.release = myclose,
	.unlocked_ioctl = myled_ioctl,
};

int myled_probe(struct platform_device *pdev)
{
	int ret = 0;
	dev_t devno = MKDEV(major,minor);
	ret = register_chrdev_region(devno, num, "myled");

	if(ret)
	{
		ret = alloc_chrdev_region(&devno, minor, num, "myled");
		if(ret)
		{
			printk("devno failed.\n");
			return -1;
		}
		major = MAJOR(devno);
		minor = MINOR(devno);
	}

	pgmydev = (struct myled_dev *) kmalloc(sizeof(struct myled_dev), GFP_KERNEL);
	if(pgmydev == NULL)
	{
		unregister_chrdev_region(devno, num);
		printk("kmalloc failed.\n");
		return -1;
	}
	memset(pgmydev,0,sizeof(struct myled_dev));

	cdev_init(&pgmydev->mydev,&myops);
	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev,devno,num);

	/*ioremap*/
	ioremap_ledreg(pgmydev,pdev);

	/*set gpio output*/
	set_output_ledconreg(pgmydev);

	return 0;
}

int myled_remove(struct platform_device *pdev)
{
	dev_t devno = MKDEV(major,minor);

	iounmap_ledreg(pgmydev);

	cdev_del(&pgmydev->mydev);

	kfree(pgmydev);
	pgmydev = NULL;

	unregister_chrdev_region(devno, num);

	return 0;
}

struct platform_device_id ledsdrv_id[] = {
	[0] = {.name = "leds"},
	[1] = {.name = "abc"},
	[2] = {},
};

struct platform_driver leds_driver = {
	.driver.name = "leds",
	.probe = myled_probe,
	.remove = myled_remove,
	.id_table = ledsdrv_id,
};

int __init myled_init(void)
{
	platform_driver_register(&leds_driver);
	return 0;
}

void __exit myled_exit(void)
{
	platform_driver_unregister(&leds_driver);
}

MODULE_LICENSE("GPL");
MODULE_AUTHOR("imysy_22");

module_init(myled_init);
module_exit(myled_exit);

led_dev.h

#ifndef LED_DEV_H
#define LED_DEV_H

#define LED_DEV_MAGIC 'g'

#define MY_LED_OFF _IO(LED_DEV_MAGIC, 0)
#define MY_LED_ON _IO(LED_DEV_MAGIC, 1)

#endif

# 三、设备树匹配

设备树匹配：内核启动时根据设备树自动产生的设备 ------ 优先级最高

注意事项：

1. 无需编写device模块，只需编写driver模块

2. 使用compatible属性进行匹配，注意设备树中compatible属性值不要包含空白字符

3. id_table可不设置，但struct platform_driver成员driver的name成员必须设置

```c

/*platform driver框架*/

#include <linux/module.h>

#include <linux/kernel.h>

#include <linux/init.h>

#include <linux/platform_device.h>

static int driver_probe(struct platform_device *dev)

{

    printk("platform: match ok!\n");

    return 0;

}

static int driver_remove(struct platform_device *dev)

{

    printk("platform: driver remove\n");

    return 0;

}

struct platform_device_id testdrv_ids[] =

{

    [0] = {.name = "test_device"},

    [1] = {.name = "abcxyz"},

    [2] = {}, //means ending

};

struct of_device_id test_of_ids[] =

{

    [0] = {.compatible = "xyz,abc"},

    [1] = {.compatible = "qwe,opq"},

    [2] = {},

};

struct platform_driver test_driver = {

    .probe = driver_probe,

    .remove = driver_remove,

    .driver = {

        .name = "xxxxx", //必须初始化

        .of_match_table = test_of_ids,

    },

};

static int __init platform_driver_init(void)

{

    platform_driver_register(&test_driver);

    return 0;

}

static void __exit platform_driver_exit(void)

{

    platform_driver_unregister(&test_driver);

}

module_init(platform_driver_init);

module_exit(platform_driver_exit);

MODULE_LICENSE("Dual BSD/GPL");

```

 

# 四、设备树匹配之led驱动

dtb_led_dev.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/fs.h>
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/cdev.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/io.h>
#include <linux/of.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>

#include "led_dev.h"

int major = 11, minor = 0, num = 1;

struct myled_dev
{
	struct cdev mydev;

	unsigned int led2gpio;
	unsigned int led3gpio;
	unsigned int led4gpio;
	unsigned int led5gpio;
};

struct myled_dev *pgmydev = NULL;

int myopen(struct inode *pnode, struct file * pfile)
{
	pfile->private_data = (void *) (container_of(pnode->i_cdev, struct myled_dev, mydev));

	return 0;
}

int myclose(struct inode *pnode, struct file * pfile)
{

	return 0;
}

void led_on(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
	case 2:
		gpio_set_value(pmydev->led2gpio, 1);
		break;
	case 3:
		gpio_set_value(pmydev->led3gpio, 1);
		break;
	case 4:
		gpio_set_value(pmydev->led4gpio, 1);
		break;
	case 5:
		gpio_set_value(pmydev->led5gpio, 1);
		break;
	}
}

void led_off(struct myled_dev *pmydev,int ledno)
{
	switch(ledno)
	{
	case 2:
		gpio_set_value(pmydev->led2gpio, 0);
		break;
	case 3:
		gpio_set_value(pmydev->led3gpio, 0);
		break;
	case 4:
		gpio_set_value(pmydev->led4gpio, 0);
		break;
	case 5:
		gpio_set_value(pmydev->led5gpio, 0);
		break;
	}
}

long myled_ioctl(struct file *pfile, unsigned int cmd, unsigned long arg)
{
	struct myled_dev *pmydev = (struct myled_dev *) pfile->private_data;

	if(arg < 2 || arg > 5)
	{
		return -1;
	}
	switch (cmd)
	{
		case MY_LED_ON:
			led_on(pmydev,arg);
			break;
		case MY_LED_OFF:
	 		led_off(pmydev,arg);
	 		break;
		default:
	 		return -1;
	}
	return 0;
}



void request_leds_gpio(struct myled_dev *pmydev, struct device_node *pnode)
{
	pmydev->led2gpio = of_get_named_gpio(pnode, "led2-gpio", 0);
	gpio_request(pmydev->led2gpio, "led2");

	pmydev->led3gpio = of_get_named_gpio(pnode, "led3-gpio", 0);
	gpio_request(pmydev->led3gpio, "led3");

	pmydev->led4gpio = of_get_named_gpio(pnode, "led4-gpio", 0);
	gpio_request(pmydev->led4gpio, "led4");

	pmydev->led5gpio = of_get_named_gpio(pnode, "led5-gpio", 0);
	gpio_request(pmydev->led5gpio, "led5");
}

void free_leds_gpio(struct myled_dev *pmydev)
{
	gpio_free(pmydev->led2gpio);
	gpio_free(pmydev->led3gpio);
	gpio_free(pmydev->led4gpio);
	gpio_free(pmydev->led5gpio);
}

void set_leds_gpio_output(struct myled_dev *pmydev)
{
	gpio_direction_output(pmydev->led2gpio, 0);
	gpio_direction_output(pmydev->led3gpio, 0);
	gpio_direction_output(pmydev->led4gpio, 0);
	gpio_direction_output(pmydev->led5gpio, 0);
}

struct file_operations myops = {
	.owner = THIS_MODULE,
	.open = myopen,
	.release = myclose,
	.unlocked_ioctl = myled_ioctl,
};

int leds_probe(struct platform_device *pdev)
{
	int ret = 0;
	dev_t devno = MKDEV(major,minor);
	
	struct device_node *pnode = NULL;

	ret = register_chrdev_region(devno, num, "myled");
	if(ret)
	{
		ret = alloc_chrdev_region(&devno, minor, num, "myled");
		if(ret)
		{
			printk("devno failed.\n");
			return -1;
		}
		major = MAJOR(devno);
		minor = MINOR(devno);
	}

	pgmydev = (struct myled_dev *) kmalloc(sizeof(struct myled_dev), GFP_KERNEL);
	if(pgmydev == NULL)
	{
		unregister_chrdev_region(devno, num);
		printk("kmalloc failed.\n");
		return -1;
	}
	memset(pgmydev,0,sizeof(struct myled_dev));

	cdev_init(&pgmydev->mydev,&myops);
	pgmydev->mydev.owner = THIS_MODULE;
	cdev_add(&pgmydev->mydev,devno,num);

	pnode = pdev->dev.of_node;
	/*ioremap*/
	request_leds_gpio(pgmydev,pnode);

	/*set gpio output*/
	set_leds_gpio_output(pgmydev);

	return 0;
}

int leds_remove(struct platform_device *pdev)
{
	dev_t devno = MKDEV(major,minor);

	free_leds_gpio(pgmydev);

	cdev_del(&pgmydev->mydev);

	unregister_chrdev_region(devno, num);

	kfree(pgmydev);
	pgmydev = NULL;

}

struct of_device_id leds_of_dev[] = 
{
	[0] = {.compatible = "fs4412,led2-5"},
	[1] = {},
};


struct platform_driver leds_drv = {
	.probe = leds_probe,
	.remove = leds_remove,
	.driver = {
		.name = "xyz",
		.of_match_table = leds_of_dev,
	},
};

int __init myled_init(void)
{
	platform_driver_register(&leds_drv);
	return 0;
}

void __exit myled_exit(void)
{
	platform_driver_unregister(&leds_drv);
}

MODULE_LICENSE("GPL");
MODULE_AUTHOR("imysy_22");

module_init(myled_init);
module_exit(myled_exit);

 

# 五、一个编写驱动用的宏

```c

struct platform_driver xxx = {  

    ...

};

module_platform_driver(xxx);

//最终展开后就是如下形式：

static int __init xxx_init(void)

{

        return platform_driver_register(&xxx);

}

module_init(xxx_init);

static void __exit xxx_init(void)

{

        return platform_driver_unregister(&xxx);

}

module_exit(xxx_exit)

```

;