在Linux 2.6以后的设备驱动模型中,需关心总线、设备和驱动这3个实体,总线将设备和驱动绑定。在系统每注册一个设备的时候,会寻找与之匹配的驱动;相反地,在系统每注册一个驱动的时候,会寻找与之匹配的设备,而匹配由总线完成。
platform总线是一种虚拟的总线,相应的设备则为platform_device,而驱动则为platform_driver。Linux 2.6的设备驱动模型中,把I2C、RTC、LCD等都归纳为platform_device。
1. platform_device
platform_device结构体的定义如下:
struct platform_device {
const char *name;
int id;
bool id_auto;
struct device dev;
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;
}
留意platform_device结构体定义的第6、7两行,它们描述了platform_device的资源,资源本身由resource结构体描述,定义如下:
struct resource {
resource_size_t start;
resource_size_t end;
const char *name;
unsigned long flags;
struct resource *parent, *sibling, *child;
};
我们通常关心start、end和flags三个字段,它们分别标识资源的开始值、结束值和类型。flags可为IORESOURCE_IO、IORESOURCE_MEM、IORESOURCE_IRQ和IORESOURCE_DMA等。对resource的定义也通常在BSP的板级文件中进行,在具体的设备驱动中通过platform_get_resource()这样的API来获取,其定义为:
struct resource *platform_get_resource(struct plarform_device* , unsigned int, unsigned int);
对于IRQ而言,还有另一个获取的方法:
int platform_get_irq(struct platform_device* dev, unsigned int num);
设备除了可以在BSP中定义资源以外,还可以附加一些数据信息。platform提供了对platform_data的支持,其形式由每个驱动自定义。在具体的设备驱动中通过dev_get_platdata()这样的API来获取,其定义为:
static inline void *dev_get_platdata(const struct device *dev);
2. platform_driver
platform_driver结构体的定义如下:
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 struct platform_device_id *id_table;
bool prevent_deferred_probe;
};
device_driver的定义:
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;
};
platform_driver结构体有device_driver成员,该成员的各自字段如上所示,device_driver也有probe、remove、shutdown等函数,在平台驱动注册的时候被初始化。
3. platform_bus_type
Linux2.6系统中定义了一个bus_type的实例platform_bus_type,其定义如下:
struct bus_type platform_bus_type = {
.name = "platform",
.dev_groups = platform_dev_groups,
.match = platform_match, //设备和驱动使用match函数来判断是否匹配
.uevent = platform_uevent,
.pm = &platform_dev_pm_ops,
};
这里需要重点关注match()成员函数,它决定了platform_device和platform_driver之间是如何进行匹配的,其定义如下:
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);
}
从match()函数的定义可以看出,platform_device和platform_driver匹配有四种可能性:
- 基于devicetree风格的匹配;
- 基于ACPI风格的匹配;
- 匹配ID表(即platform_device设备名是否出现在platform_driver的ID表内);
- 匹配platform_device设备名和驱动的名字
匹配成功则调用platform_driver的probe函数。
4. platform_device的注册和注销
对于Linux 2.6的平台而言,对platform_device的定义通常在BSP的板级文件实现,在板级文件中,将platform_device归纳为一个数组,最终通过platform_add_devices()函数统一注册,将平台设备添加到系统中。其定义如下:
int platform_add_devices(struct platform_device **devs, int num)
{
int i, ret = 0;
for (i = 0; i < num; i++) {
ret = platform_device_register(devs[i]);
if (ret) {
while (--i >= 0)
platform_device_unregister(devs[i]);
break;
}
}
return ret;
}
它内部调用了platform_device_register()函数以注册单个的平台设备。
对于3.x以后的系统,ARM Linux更多使用devicetree的内容自动展开platform_device。
相反地,如果要注销平台设备则使用platform_device_unregister()函数,其定义如下:
void platform_device_unregister(struct platform_device *pdev)
{
platform_device_del(pdev);
platform_device_put(pdev);
}
5. platform_driver的注册和注销
platform_driver的注册使用platform_driver_register()函数,其定义如下:
int __platform_driver_register(struct platform_driver *drv,
struct module *owner)
{
drv->driver.owner = owner;
drv->driver.bus = &platform_bus_type;
if (drv->probe)
drv->driver.probe = platform_drv_probe;
if (drv->remove)
drv->driver.remove = platform_drv_remove;
if (drv->shutdown)
drv->driver.shutdown = platform_drv_shutdown;
return driver_register(&drv->driver);
}
platform_driver的注销使用platform_driver_unregister()函数,其定义如下:
void platform_driver_unregister(struct platform_driver *drv)
{
driver_unregister(&drv->driver);
}
宏module_platform_driver(struct platform_driver)所定义的模块加载和卸载函数仅仅通过platform_driver_register()和platform_driver_unregister()函数进行platform_driver的注册和注销。
6. platform driver代码
/*
* a simple char device driver: globalfifo
*
* Licensed under GPLv2 or later.
*
*
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/platform_device.h>
#include <linux/miscdevice.h>
#define GLOBALFIFO_SIZE 0x1000
#define FIFO_CLEAR 0x1
struct globalfifo_dev
{
unsigned int current_len;
unsigned char mem[GLOBALFIFO_SIZE];
struct mutex mutex;
wait_queue_head_t r_wait;
wait_queue_head_t w_wait;
struct fasync_struct* async_queue;
struct miscdevice miscdev;
};
static int globalfifo_fasync(int fd, struct file* filp, int mode)
{
struct globalfifo_dev* dev = container_of(filp->private_data, struct globalfifo_dev, miscdev);
//初始化/释放 fasync_struct 结构体 (fasync_struct->fa_file->f_owner->pid)
return fasync_helper(fd, filp, mode, &dev->async_queue);
}
static int globalfifo_open(struct inode* inode, struct file* filp)
{
return 0;
}
static int globalfifo_release(struct inode* inode, struct file* filp)
{
globalfifo_fasync (-1, filp, 0);
return 0;
}
static long globalfifo_ioctl(struct file* filp, unsigned int cmd, unsigned long arg)
{
struct globalfifo_dev* dev = container_of(filp->private_data, struct globalfifo_dev, miscdev);
switch(cmd)
{
case FIFO_CLEAR:
mutex_lock(&dev->mutex);
memset(dev->mem, 0, GLOBALFIFO_SIZE);
printk(KERN_INFO "globalfifo is set to zero\n");
mutex_unlock(&dev->mutex);
break;
default:
return -EINVAL;
}
return 0;
}
static ssize_t globalfifo_read(struct file* filp, char __user* buf, size_t count, loff_t* ppos)
{
int ret = 0;
struct globalfifo_dev* dev = container_of(filp->private_data, struct globalfifo_dev, miscdev);
DECLARE_WAITQUEUE(wait, current);
mutex_lock(&dev->mutex);
add_wait_queue(&dev->r_wait,&wait);
while(dev->current_len == 0)
{
if(filp->f_flags & O_NONBLOCK)
{
ret = -EAGAIN;
goto out;
}
__set_current_state(TASK_INTERRUPTIBLE);
mutex_unlock(&dev->mutex);
schedule();
if( signal_pending(current) )
{
ret = -ERESTARTSYS;
goto out2;
}
mutex_lock(&dev->mutex);
}
if( count > dev->current_len )
count = dev->current_len;
if(copy_to_user(buf, dev->mem, count))
{
ret = -EFAULT;
goto out;
}
else
{
memcpy(dev->mem, dev->mem + count, dev->current_len - count );
dev->current_len -= count;
printk(KERN_INFO "read %d bytes(s), current_len:%d\n", count, dev->current_len);
wake_up_interruptible(&dev->w_wait);
ret = count;
}
out:
mutex_unlock(&dev->mutex);
out2:
remove_wait_queue(&dev->r_wait, &wait);
set_current_state(TASK_RUNNING);
return ret;
}
static ssize_t globalfifo_write(struct file* filp, const char __user* buf, size_t count, loff_t* ppos)
{
int ret;
struct globalfifo_dev* dev = container_of(filp->private_data, struct globalfifo_dev, miscdev);
DECLARE_WAITQUEUE(wait, current);
mutex_lock(&dev->mutex);
add_wait_queue(&dev->w_wait,&wait);
while( dev->current_len == GLOBALFIFO_SIZE )
{
if(filp->f_flags & O_NONBLOCK)
{
ret = -EAGAIN;
goto out;
}
__set_current_state(TASK_INTERRUPTIBLE);
mutex_unlock(&dev->mutex);
schedule();
if( signal_pending(current) )
{
ret = -ERESTARTSYS;
goto out2;
}
mutex_lock(&dev->mutex);
}
if( count > GLOBALFIFO_SIZE - dev->current_len )
count = GLOBALFIFO_SIZE - dev->current_len;
if( copy_from_user( dev->mem + dev->current_len, buf, count ) )
{
ret = -EFAULT;
goto out;
}
else
{
dev->current_len += count;
printk(KERN_INFO "write %d bytes(s),current_len:%d\n", count, dev->current_len);
wake_up_interruptible(&dev->r_wait);
if ( dev->async_queue)
{
//发送信号SIGIO信号给fasync_struct 结构体所描述的PID,触发应用程序的SIGIO信号处理函数
kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
printk(KERN_DEBUG "%s kill SIGIO\n", __func__);
}
ret = count;
}
out:
mutex_unlock(&dev->mutex);
out2:
remove_wait_queue(&dev->w_wait, &wait);
set_current_state(TASK_RUNNING);
return ret;
}
static unsigned int globalfifo_poll(struct file* filp, poll_table* wait)
{
unsigned int mask = 0;
struct globalfifo_dev* dev = container_of(filp->private_data, struct globalfifo_dev, miscdev);
mutex_lock(&dev->mutex);
poll_wait(filp, &dev->r_wait, wait);
poll_wait(filp, &dev->w_wait, wait);
if(dev->current_len != 0)
mask |= POLLIN | POLLRDNORM;
if(dev->current_len != GLOBALFIFO_SIZE)
mask |= POLLOUT | POLLWRNORM;
mutex_unlock(&dev->mutex);
return mask;
}
static const struct file_operations globalfifo_fops =
{
.owner = THIS_MODULE,
.read = globalfifo_read,
.write = globalfifo_write,
.unlocked_ioctl = globalfifo_ioctl,
.open = globalfifo_open,
.release = globalfifo_release,
.poll = globalfifo_poll,
.fasync = globalfifo_fasync,
};
static int globalfifo_probe(struct platform_device* pdev)
{
struct globalfifo_dev* gl;
int ret;
gl = devm_kzalloc(&pdev->dev, sizeof(*gl), GFP_KERNEL);
if(!gl)
return -ENOMEM;
gl->miscdev.minor = MISC_DYNAMIC_MINOR;
gl->miscdev.name = "globalfifo";
gl->miscdev.fops = &globalfifo_fops;
mutex_init(&gl->mutex);
init_waitqueue_head(&gl->r_wait);
init_waitqueue_head(&gl->w_wait);
platform_set_drvdata(pdev, gl);
ret = misc_register(&gl->miscdev);
if(ret < 0)
goto err;
return 0;
err:
return ret;
}
static int globalfifo_remove(struct platform_device* pdev)
{
struct globalfifo_dev* gl = platform_get_drvdata(pdev);
misc_deregister(&gl->miscdev);
return 0;
}
static struct platform_driver globalfifo_driver =
{
.driver =
{
.name = "globalfifo",
.owner = THIS_MODULE,
},
.probe = globalfifo_probe,
.remove = globalfifo_remove,
};
static int __init globalfifo_init(void)
{
return platform_driver_register(&globalfifo_driver);
}
static void __exit globalfifo_exit(void)
{
platform_driver_unregister(&globalfifo_driver);
}
module_init(globalfifo_init);
module_exit(globalfifo_exit);
MODULE_AUTHOR("were0415");
MODULE_LICENSE("GPL v2");
7. platform device代码
#include <linux/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
static struct platform_device* globalfifo_pdev;
static int __init globalfifodev_init(void)
{
int ret;
globalfifo_pdev = platform_device_alloc("globalfifo", -1);
if(!globalfifo_pdev)
return -ENOMEM;
ret = platform_device_add(globalfifo_pdev);
if(ret)
{
platform_device_put(globalfifo_pdev);
return ret;
}
return 0;
}
static void __exit globalfifodev_exit(void)
{
platform_device_unregister(globalfifo_pdev);
}
module_init(globalfifodev_init);
module_exit(globalfifodev_exit);
MODULE_AUTHOR("were0415");
MODULE_LICENSE("GPL v2");
8. 编译并测试
编译6、7两个模块代码会生成两个文件:globalfifo.ko和globalfifo-dev.ko,把globalfifo.ko和globalfifo-dev.ko先后insmod,会导致platform_driver和platform_device的匹配,globalfifo_probe()会执行,/dev/globalfifo节点也会自动生成,默认情况下需要root权限来访问/dev/globalfifo。
如果此后我们rmmod globalfifo-dev,则会导致platform_driver的remove函数执行,即globalfifo_remove()函数被执行,/dev/globalfifo节点会自动消失。