Linux设备模型（下）之Platform

从Linux2.6内核起，引入一套新的驱动管理和注册机制：platform_device和 platform_driver 。Linux 中大部分的设备驱动，都可以使用这套机制，设备用 platform_device 表示；驱动用platform_driver 进行注册。 platform是一个虚拟的地址总线，相比pci，usb，它主要用于描述SOC上的片上资源，比如s3c2440上集成的控制器（lcd，watchdog，rtc等）， platform所描述的资源有一个共同点，就是在cpu的总线上直接取址。平台设备会分到一个名称(用在驱动绑定中)以及一系列诸如地址和中断请求号(IRQ)之类的资源.

[cpp] view plain copy print ?

1. struct platform_device {  
2.     const char * name;  
3.     intid;  
4.     struct device dev;  
5.     u32num_resources;  
6.     struct resource * resource;  
7.  };  

struct platform_device {
    const char * name;
    intid;
    struct device dev;
    u32num_resources;
    struct resource * resource;
 };

平台驱动遵循标准驱动模型的规范, 平台驱动按标准规范对电源管理和关机通告提供支 持

[cpp] view plain copy print ?

1. struct platform_driver {  
2.    int (*probe)(struct platform_device *);  
3.    int (*remove)(struct platform_device *);  
4.    void (*shutdown)(struct platform_device *);  
5.    int (*suspend)(struct platform_device *, pm_message_t state);  
6.    int (*suspend_late)(struct platform_device *, pm_message_t state);  
7.    int (*resume_early)(struct platform_device *);  
8.    int (*resume)(struct platform_device *);  
9.    struct device_driver driver;  
10. };  

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 (*suspend_late)(struct platform_device *, pm_message_t state);
   int (*resume_early)(struct platform_device *);
   int (*resume)(struct platform_device *);
   struct device_driver driver;
};

probe()总应该核实指定的设备硬件确实存在;平台设置代码有时不能确定这一点

 

系统为platform总线定义一个bus_type的实例platform_bus_type，通过其成员函数match()，确定device和driver如何匹配。

匹配platform_device和platform_driver主要看二者的name字段是否相同。（name必须要相同才能匹配）

 用platform_device_register(platform_device*)函数注册单个的平台设备。

一般是在平台的BSP文件中定义platform_device，通过platform_add_devices(platform_device*)函数将平台设备注册到系统中platform_driver 的注册与注销：

platform_driver_register(platform_driver*)

platform_driver_unregister(platform_driver*)

 

设备资源（struct resource)

关于资源的操作（平台设备会分到一系列诸如地址和中断请求号(IRQ)之类的资源)

struct resource {

   resource_size_t start;

   resource_size_t end;

   const char *name;

   unsigned long flags;

 // IORESOURCE_IO

 //IORESOURCE_MEM

 //IORESOURCE_IRQ

 //IORESOURCE_DMA

   struct resource *parent, *sibling, *child;

};

基于资源的分类（flags）有I/O端口、IRQ、DMA等等，而I/O端口又分为2种类型，IORESOURCE_IO（I/O映射） IORESOURCE_MEM（内存映射）CPU对外设IO端口物理地址的编址方式有2种：一种是IO映射方式（IO-mapped）， 另一种是内存映射方式（Memory-mapped）。具体采用哪一种方式则取决于CPU的体系结构。 像X86体系对外设就专门实现了一个单独地址空间，并且有专门的I/O指令来访问I/O端口，像ARM体系结构通常只是实现一个物理地址空间，I/O端口就被映射到CPU的单一物理地址空间中，而成为内存的一部分，所以一般资源都采用（IORESOURCE_MEM）。linux中对设备的资源按照资源树的结构来组织(其实就是一个链表结构的插入、删除、查找等操作），上面再添加设备（platform_device_add）的同时对相应的资源在资源树上进行插入操作

int insert_resource(struct resource *parent, struct resource *new)

 

关于platform resource有相关的函数进行对资源的操作。

struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);

int platform_get_irq(struct platform_device *, unsigned int);

struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, char *);

int platform_get_irq_byname(struct platform_device *, char *);

例如s3c2440的watchdog资源分配实例：

watchdog寄存器的基地址为0x5300000

#define S3C2410_PA_WATCHDOG (0x53000000)

#define S3C24XX_SZ_WATCHDOG SZ_1M

static struct resource s3c_wdt_resource[] = {

   [0] = {

      .start = S3C24XX_PA_WATCHDOG,

      .end = S3C24XX_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,

      .flags = IORESOURCE_MEM, //内存映射

   },

   [1] = {

      .start = IRQ_WDT,

      .end = IRQ_WDT,

      .flags = IORESOURCE_IRQ, //IRQ

   }

};

plat_button_device.c：

[cpp] view plain copy print ?

1. #include <linux/module.h>  
2. #include <linux/types.h>  
3. #include <linux/fs.h>  
4. #include <linux/init.h>  
5. #include <linux/platform_device.h>  
6. #include <mach/regs-gpio.h>  
7. #include <linux/interrupt.h>  
8. #include <linux/device.h>  
9. #include <linux/io.h>  
10.   
11. /*平台资源的定义*/  
12. static struct resource s3c_buttons_resource[] = {  
13.     [0]={  
14.         .start = S3C24XX_PA_GPIO,//                       (0x56000000)  
15.         .end   = S3C24XX_PA_GPIO + S3C24XX_SZ_GPIO - 1,//(0x56000000) + 0x00100000 -1   
16.         .flags = IORESOURCE_MEM,  
17.     },  
18.       
19.     [1]={  
20.         .start = IRQ_EINT7,  
21.         .end   = IRQ_EINT7,  
22.         .flags = IORESOURCE_IRQ,  
23.     },  
24.     [2]={  
25.         .start = IRQ_EINT1,  
26.         .end   = IRQ_EINT1,  
27.         .flags = IORESOURCE_IRQ,  
28.     },  
29.     [3]={  
30.         .start = IRQ_EINT2,  
31.         .end   = IRQ_EINT2,  
32.         .flags = IORESOURCE_IRQ,  
33.     },  
34.     [4]={  
35.         .start = IRQ_EINT3,  
36.         .end   = IRQ_EINT3,  
37.         .flags = IORESOURCE_IRQ,  
38.     },  
39.     [5]={  
40.         .start = IRQ_EINT4,  
41.         .end   = IRQ_EINT4,  
42.         .flags = IORESOURCE_IRQ,  
43.     },  
44.     [6]={  
45.         .start = IRQ_EINT5,  
46.         .end   = IRQ_EINT5,  
47.         .flags = IORESOURCE_IRQ,  
48.     }  
49. };  
50.   
51. static struct platform_device *s3c_buttons;  
52.   
53.   
54. static int __init platform_init(void)  
55. {  
56.   
57.     s3c_buttons = platform_device_alloc("gec2440-buttons",-1);  
58.   
59.     platform_device_add_resources(s3c_buttons,&s3c_buttons_resource,7);  
60.   
61.     /*平台设备的注册*/  
62.     platform_device_add(s3c_buttons);  
63. }  
64.   
65. static void __exit platform_exit(void)  
66. {  
67.     platform_device_unregister(s3c_buttons);  
68. }  
69.   
70. module_init(platform_init);  
71. module_exit(platform_exit);  
72.   
73. MODULE_AUTHOR("Steven Bai");  
74. MODULE_LICENSE("GPL");  
75. MODULE_ALIAS("platform:gec2440buttons");  

#include <linux/module.h>

#include <linux/types.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <mach/regs-gpio.h>
#include <linux/interrupt.h>

#include <linux/device.h>
#include <linux/io.h>

/*平台资源的定义*/
static struct resource s3c_buttons_resource[] = {
	[0]={
		.start = S3C24XX_PA_GPIO,//                       (0x56000000)
		.end   = S3C24XX_PA_GPIO + S3C24XX_SZ_GPIO - 1,//(0x56000000) + 0x00100000 -1 
		.flags = IORESOURCE_MEM,
	},
	
	[1]={
		.start = IRQ_EINT7,
		.end   = IRQ_EINT7,
		.flags = IORESOURCE_IRQ,
	},
	[2]={
		.start = IRQ_EINT1,
		.end   = IRQ_EINT1,
		.flags = IORESOURCE_IRQ,
	},
	[3]={
		.start = IRQ_EINT2,
		.end   = IRQ_EINT2,
		.flags = IORESOURCE_IRQ,
	},
	[4]={
		.start = IRQ_EINT3,
		.end   = IRQ_EINT3,
		.flags = IORESOURCE_IRQ,
	},
	[5]={
		.start = IRQ_EINT4,
		.end   = IRQ_EINT4,
		.flags = IORESOURCE_IRQ,
	},
	[6]={
		.start = IRQ_EINT5,
		.end   = IRQ_EINT5,
		.flags = IORESOURCE_IRQ,
	}
};

static struct platform_device *s3c_buttons;


static int __init platform_init(void)
{

    s3c_buttons = platform_device_alloc("gec2440-buttons",-1);

    platform_device_add_resources(s3c_buttons,&s3c_buttons_resource,7);

    /*平台设备的注册*/
    platform_device_add(s3c_buttons);
}

static void __exit platform_exit(void)
{
    platform_device_unregister(s3c_buttons);
}

module_init(platform_init);
module_exit(platform_exit);

MODULE_AUTHOR("Steven Bai");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:gec2440buttons");

plat_button_driver.c：

[cpp] view plain copy print ?

1. #include <linux/module.h>  
2. #include <linux/types.h>  
3. #include <linux/miscdevice.h>  
4. #include <linux/fs.h>  
5. #include <linux/init.h>  
6. #include <linux/platform_device.h>  
7. #include <linux/interrupt.h>  
8. #include <linux/clk.h>  
9. #include <linux/uaccess.h>  
10. #include <linux/io.h>  
11. #include <mach/map.h>  
12. #include <mach/regs-gpio.h>  
13. #include <linux/poll.h>  
14. #include <linux/irq.h>  
15. #include <asm/unistd.h>  
16. #include <linux/device.h>  
17.   
18. #define DEVICE_NAME "buttons"  
19.   
20.   
21. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);  
22.   
23. static volatile int ev_press = 0;  
24.   
25.   
26. static int key_value;  
27. static struct device     *buttons_dev;  /* platform device attached to */  
28. static struct resource  *buttons_mem;  
29. static struct resource   *buttons_irq;  
30. static void __iomem     *buttons_base;  
31.   
32.   
33. static int button_irqs[6];  
34.   
35. static irqreturn_t buttons_interrupt(int irq, void *dev_id)  
36. {  
37.     int i;  
38.     for(i=0; i<6; i++){  
39.         if(irq == button_irqs[i]){  
40.             printk("==>interrput number:%d\n",irq);    
41.             key_value = i;  
42.             ev_press =1;  
43.             wake_up_interruptible(&button_waitq);         
44.         }  
45.     }  
46.       
47.     return IRQ_RETVAL(IRQ_HANDLED);  
48.       
49. }  
50.   
51. static int s3c24xx_buttons_open(struct inode *inode, struct file *file)  
52. {  
53.     int i;  
54.     int err = 0;  
55.     /*注册中断*/  
56.     for(i=0; i<6; i++){  
57.         if (button_irqs[i] < 0)   
58.             continue;  
59.                               
60.                 /*中断触发方式：上升沿触发*/  
61.         err = request_irq(button_irqs[i],buttons_interrupt,IRQ_TYPE_EDGE_RISING,NULL,NULL);  
62.         if(err)  
63.           break;  
64.     }  
65.   
66.     if (err) {  
67.         i--;  
68.         for (; i >= 0; i--) {  
69.             if (button_irqs[i] < 0) {  
70.                 continue;  
71.             }  
72.             disable_irq(button_irqs[i]);  
73.             free_irq(button_irqs[i], NULL);  
74.         }  
75.         return -EBUSY;  
76.     }  
77.   
78.     ev_press = 0;     
79.     return 0;  
80. }  
81.   
82. static int s3c24xx_buttons_close(struct inode *inode, struct file *file)  
83. {  
84.     int i;      
85.     for (i=0; i<6; i++) {  
86.             if (button_irqs[i] < 0) {  
87.                 continue;  
88.             }  
89.             free_irq(button_irqs[i],NULL);  
90.     }  
91.     return 0;  
92. }  
93.   
94. static int s3c24xx_buttons_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)  
95. {  
96.     unsigned long err;  
97.     if (!ev_press) {  
98.         if (filp->f_flags & O_NONBLOCK)  
99.             return -EAGAIN;  
100.         else  
101.             wait_event_interruptible(button_waitq, ev_press);  
102.     }      
103.     ev_press = 0;  
104.     err = copy_to_user(buff, &key_value, sizeof(key_value));  
105.     return sizeof(key_value);  
106. }  
107.   
108. static unsigned int s3c24xx_buttons_poll( struct file *file, struct poll_table_struct *wait)  
109. {  
110.     unsigned int mask = 0;  
111.     poll_wait(file, &button_waitq, wait);  
112.     if (ev_press){  
113.         mask |= POLLIN | POLLRDNORM;  
114.     }  
115.     return mask;  
116. }  
117.   
118.   
119.   
120. static struct file_operations gec2440buttons_fops = {  
121.     .owner   =   THIS_MODULE,  
122.     .open    =   s3c24xx_buttons_open,  
123.     .release =   s3c24xx_buttons_close,  
124.     .read    =   s3c24xx_buttons_read,  
125.     .poll    =   s3c24xx_buttons_poll,  
126. };  
127.   
128. static struct miscdevice gec2440_miscdev = {  
129.       
130.     .minor = MISC_DYNAMIC_MINOR,  
131.     .name = DEVICE_NAME,  
132.     .fops = &gec2440buttons_fops,  
133. };  
134.   
135. /* device interface */  
136. static int gec2440_buttons_probe(struct platform_device *pdev)  
137. {  
138.     struct resource *res;  
139.     struct device *dev;  
140.     int ret;  
141.     int size;  
142.     int i;  
143.       
144.     printk("probe:%s\n", __func__);  
145.     dev = &pdev->dev;  
146.     buttons_dev = &pdev->dev;  
147.       
148.     /*平台资源获取*/  
149.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);  
150.     if (res == NULL) {  
151.         dev_err(dev, "no memory resource specified\n");  
152.         return -ENOENT;  
153.     }  
154.       
155.     size = (res->end - res->start) + 1;  
156.     buttons_mem = request_mem_region(res->start, size, pdev->name);  
157.     if (buttons_mem == NULL) {  
158.         dev_err(dev, "failed to get memory region\n");  
159.         ret = -ENOENT;  
160.         goto err_req;  
161.     }  
162.       
163.     buttons_base = ioremap(res->start, size);  
164.     if (buttons_base == NULL) {  
165.         dev_err(dev, "failed to ioremap() region\n");  
166.         ret = -EINVAL;  
167.         goto err_req;  
168.     }  
169.     printk(KERN_DEBUG"probe: mapped buttons_base=%p\n", buttons_base);  
170.   
171.  /*get irq number*/  
172.     for(i=0; i<6; i++)  
173.     {  
174.          buttons_irq = platform_get_resource(pdev,IORESOURCE_IRQ,i);  
175.          if(buttons_irq == NULL)  
176.          {  
177.             dev_err(dev,"no irq resource specified\n");  
178.               ret = -ENOENT;  
179.               goto err_map;  
180.           }  
181.         button_irqs[i] = buttons_irq->start;  
182.         printk("button_irqs[%d]=%d\n",i,button_irqs[i]);    
183.     }  
184.     ret = misc_register(&gec2440_miscdev);  
185.           
186.     return 0;  
187.   
188.  err_map:  
189.     iounmap(buttons_base);  
190.   
191.  err_req:  
192.     release_resource(buttons_mem);  
193.     kfree(buttons_mem);  
194.   
195.     return ret;  
196. }  
197.   
198. static int gec2440_buttons_remove(struct platform_device *dev)  
199. {  
200.     release_resource(buttons_mem);  
201.     kfree(buttons_mem);  
202.     buttons_mem = NULL;  
203.   
204.     iounmap(buttons_base);  
205.     misc_deregister(&gec2440_miscdev);  
206.     return 0;  
207. }  
208.   
209. /*平台驱动定义*/  
210. static struct platform_driver gec2440buttons_driver = {  
211.     .probe      = gec2440_buttons_probe,  
212.     .remove     = gec2440_buttons_remove,  
213.     .driver     = {  
214.         .owner  = THIS_MODULE,  
215.         .name   = "gec2440-buttons",  
216.     },  
217. };  
218.   
219. static char banner[] __initdata =  
220.      "gec2440 Buttons Driver\n";  
221.   
222. static int __init buttons_init(void)  
223. {  
224.     printk(banner);  
225.     /*平台驱动注册*/  
226.     platform_driver_register(&gec2440buttons_driver);  
227.     return 0;  
228. }  
229.   
230. static void __exit buttons_exit(void)  
231. {  
232.     platform_driver_unregister(&gec2440buttons_driver);  
233. }  
234.   
235. module_init(buttons_init);  
236. module_exit(buttons_exit);  
237.   
238. MODULE_AUTHOR("Steven Bai");  
239. MODULE_DESCRIPTION("gec2440 Buttons Driver");  
240. MODULE_LICENSE("GPL");  

#include <linux/module.h>

#include <linux/types.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>

#include <linux/clk.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <mach/map.h>
#include <mach/regs-gpio.h>
#include <linux/poll.h>

#include <linux/irq.h>
#include <asm/unistd.h>
#include <linux/device.h>

#define DEVICE_NAME "buttons"


static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

static volatile int ev_press = 0;


static int key_value;
static struct device     *buttons_dev;	/* platform device attached to */
static struct resource	*buttons_mem;
static struct resource   *buttons_irq;
static void __iomem	    *buttons_base;


static int button_irqs[6];

static irqreturn_t buttons_interrupt(int irq, void *dev_id)
{
	int i;
	for(i=0; i<6; i++){
		if(irq == button_irqs[i]){
			printk("==>interrput number:%d\n",irq);  
			key_value = i;
			ev_press =1;
			wake_up_interruptible(&button_waitq);		
		}
	}
	
    return IRQ_RETVAL(IRQ_HANDLED);
	
}

static int s3c24xx_buttons_open(struct inode *inode, struct file *file)
{
	int i;
	int err = 0;
	/*注册中断*/
	for(i=0; i<6; i++){
		if (button_irqs[i] < 0) 
			continue;
						    
				/*中断触发方式：上升沿触发*/
        err = request_irq(button_irqs[i],buttons_interrupt,IRQ_TYPE_EDGE_RISING,NULL,NULL);
		if(err)
		  break;
	}

	if (err) {
		i--;
		for (; i >= 0; i--) {
			if (button_irqs[i] < 0) {
				continue;
			}
			disable_irq(button_irqs[i]);
			free_irq(button_irqs[i], NULL);
		}
		return -EBUSY;
	}

    ev_press = 0;   
    return 0;
}

static int s3c24xx_buttons_close(struct inode *inode, struct file *file)
{
    int i;    
    for (i=0; i<6; i++) {
			if (button_irqs[i] < 0) {
				continue;
			}
			free_irq(button_irqs[i],NULL);
    }
    return 0;
}

static int s3c24xx_buttons_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
{
    unsigned long err;
    if (!ev_press) {
		if (filp->f_flags & O_NONBLOCK)
			return -EAGAIN;
		else
			wait_event_interruptible(button_waitq, ev_press);
    }    
    ev_press = 0;
    err = copy_to_user(buff, &key_value, sizeof(key_value));
    return sizeof(key_value);
}

static unsigned int s3c24xx_buttons_poll( struct file *file, struct poll_table_struct *wait)
{
    unsigned int mask = 0;
    poll_wait(file, &button_waitq, wait);
    if (ev_press){
        mask |= POLLIN | POLLRDNORM;
	}
    return mask;
}



static struct file_operations gec2440buttons_fops = {
    .owner   =   THIS_MODULE,
    .open    =   s3c24xx_buttons_open,
	.release =   s3c24xx_buttons_close,
    .read    =   s3c24xx_buttons_read,
	.poll    =   s3c24xx_buttons_poll,
};

static struct miscdevice gec2440_miscdev = {
	
    .minor = MISC_DYNAMIC_MINOR,
    .name = DEVICE_NAME,
    .fops = &gec2440buttons_fops,
};

/* device interface */
static int gec2440_buttons_probe(struct platform_device *pdev)
{
	struct resource *res;
	struct device *dev;
	int ret;
	int size;
	int i;
	
	printk("probe:%s\n", __func__);
	dev = &pdev->dev;
	buttons_dev = &pdev->dev;
	
	/*平台资源获取*/
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL) {
		dev_err(dev, "no memory resource specified\n");
		return -ENOENT;
	}
	
	size = (res->end - res->start) + 1;
	buttons_mem = request_mem_region(res->start, size, pdev->name);
	if (buttons_mem == NULL) {
		dev_err(dev, "failed to get memory region\n");
		ret = -ENOENT;
		goto err_req;
	}
	
	buttons_base = ioremap(res->start, size);
	if (buttons_base == NULL) {
		dev_err(dev, "failed to ioremap() region\n");
		ret = -EINVAL;
		goto err_req;
	}
	printk(KERN_DEBUG"probe: mapped buttons_base=%p\n", buttons_base);

 /*get irq number*/
	for(i=0; i<6; i++)
	{
		 buttons_irq = platform_get_resource(pdev,IORESOURCE_IRQ,i);
		 if(buttons_irq == NULL)
		 {
			dev_err(dev,"no irq resource specified\n");
			  ret = -ENOENT;
			  goto err_map;
		  }
		button_irqs[i] = buttons_irq->start;
		printk("button_irqs[%d]=%d\n",i,button_irqs[i]);  
	}
	ret = misc_register(&gec2440_miscdev);
		
	return 0;

 err_map:
	iounmap(buttons_base);

 err_req:
	release_resource(buttons_mem);
	kfree(buttons_mem);

	return ret;
}

static int gec2440_buttons_remove(struct platform_device *dev)
{
	release_resource(buttons_mem);
	kfree(buttons_mem);
	buttons_mem = NULL;

	iounmap(buttons_base);
	misc_deregister(&gec2440_miscdev);
	return 0;
}

/*平台驱动定义*/
static struct platform_driver gec2440buttons_driver = {
	.probe		= gec2440_buttons_probe,
	.remove		= gec2440_buttons_remove,
	.driver		= {
		.owner	= THIS_MODULE,
		.name	= "gec2440-buttons",
	},
};

static char banner[] __initdata =
	 "gec2440 Buttons Driver\n";

static int __init buttons_init(void)
{
	printk(banner);
	/*平台驱动注册*/
	platform_driver_register(&gec2440buttons_driver);
	return 0;
}

static void __exit buttons_exit(void)
{
	platform_driver_unregister(&gec2440buttons_driver);
}

module_init(buttons_init);
module_exit(buttons_exit);

MODULE_AUTHOR("Steven Bai");
MODULE_DESCRIPTION("gec2440 Buttons Driver");
MODULE_LICENSE("GPL");

 

开发板一上电后，可以/sys/bus/platform/下会挂上这个设备和对应的驱动