使用platform虚拟总线驱动按键

 Linux下按键驱动相对来说，编程简单。本例程使用了platform虚拟总线进行编程，主要是为了加深对总线，设备和驱动的了解，程序不是本人所写。只希望通过写下表笔记，梳理下思路。

 

    在设备驱动程序中经常会见到和platform相关的字段，分布在驱动程序的多个角落，这也是2.6内核中比较重要的一种机制，把它的原理弄懂了，对以后分析驱动程序很有帮助，下面简单介绍一下：

在linux2.6设备模型中，关心总线，设备，驱动这三个实体，总线将设备和驱动绑定，在系统每注册一个设备的时候，会寻找与之匹配的驱动。相反，在系统每注册一个驱动的时候，寻找与之匹配的设备，匹配是由总线来完成的。

一个现实的Linux 设备和驱动通常都需要挂接在一种总线上，对于本身依附于PCI、USB、I2C、SPI 等的设备而言，这自然不是问题，但是在嵌入式系统里面，SoC 系统中集成的独立的外设控制器、挂接在SoC 内存空间的外设等确不依附于此类总线。基于这一背景，Linux 发明了一种虚拟的总线，称为platform 总线。

  

        

首先，需要注册设备：

 static int __init platform_init(void)
{

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

    platform_device_add_resources(s3c_buttons,&s3c_buttons_resource,7);

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

}

s3c_buttons = platform_device_alloc(const char name,int id);  

为struct Platform_device设备分配空间.

struct platform_device *platform_device_alloc(const char *name, int id)
{
 struct platform_object *pa;

 pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);
 if (pa) {
  strcpy(pa->name, name);
  pa->pdev.name = pa->name;
  pa->pdev.id = id;
  device_initialize(&pa->pdev.dev);
  pa->pdev.dev.release = platform_device_release;
 }

 return pa ? &pa->pdev : NULL;
}

 

关于platform_device

 

struct platform_device {

const char *name;

u32 id;

struct device dev;

u32 num_resources;

struct resource *resource;

}; 关于platform_object: struct platform_object {  struct platform_device pdev;  char name[1]; };

关于resource:

struct resource{

     resource_size_t start;    //资源的起始物理地址

     resource_size_t end;     //资源的终止物理地址

     const char* name;          //资源名称

     unsigned long flags;       //资源的类型,比如MEM，IO，IRQ

     struct resource *parent,*sibling,*child;  //资源链表指针

}

/*pdev:用于添加资源到由platform_device_alloc分配的platform device

int platform_device_add_resources(struct platform_device *pdev，

 res:需要分配到device的资源集

 num：资源数

*/

struct resource *res,unsigned int num)

{

     struct resource *r;

     r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);
     if (r) {
      memcpy(r, res, sizeof(struct resource) * num);
      pdev->resource = r;
      pdev->num_resources = num;
 }
 return r ? 0 : -ENOMEM; 

}

 

/*

platform_device_register的第二部分

*/

int platform_device_add(struct platform_device *pdev)
{
 int i, ret = 0;

 if (!pdev)
  return -EINVAL;

 if (!pdev->dev.parent)
  pdev->dev.parent = &platform_bus;

 pdev->dev.bus = &platform_bus_type;

 if (pdev->id != -1)
  dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
 else
  dev_set_name(&pdev->dev, pdev->name);

 for (i = 0; i < pdev->num_resources; i++) {
  struct resource *p, *r = &pdev->resource[i];

  if (r->name == NULL)
   r->name = dev_name(&pdev->dev);

  p = r->parent;
  if (!p) {
   if (resource_type(r) == IORESOURCE_MEM)
    p = &iomem_resource;
   else if (resource_type(r) == IORESOURCE_IO)
    p = &ioport_resource;
  }

  if (p && insert_resource(p, r)) {
   printk(KERN_ERR
          "%s: failed to claim resource %d\n",
          dev_name(&pdev->dev), i);
   ret = -EBUSY;
   goto failed;
  }
 }

 pr_debug("Registering platform device '%s'. Parent at %s\n",
   dev_name(&pdev->dev), dev_name(pdev->dev.parent));

 ret = device_add(&pdev->dev);
 if (ret == 0)
  return ret;

 failed:
 while (--i >= 0) {
  struct resource *r = &pdev->resource[i];
  unsigned long type = resource_type(r);

  if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
   release_resource(r);
 }

 return ret;

调用此函数后，将在platform总线的devices下出现“mini2440-buttons”设备文件

 

关于资源：

/*平台资源的定义*/
static struct resource s3c_buttons_resource[] = {
 [0]={
  .start = S3C24XX_PA_GPIO,
  .end   = S3C24XX_PA_GPIO + S3C24XX_SZ_GPIO - 1,
  .flags = IORESOURCE_MEM,
 },
 
 [1]={
  .start = IRQ_EINT8,
  .end   = IRQ_EINT8,
  .flags = IORESOURCE_IRQ,
 },
 [2]={
  .start = IRQ_EINT11,
  .end   = IRQ_EINT11,
  .flags = IORESOURCE_IRQ,
 },
 [3]={
  .start = IRQ_EINT13,
  .end   = IRQ_EINT13,
  .flags = IORESOURCE_IRQ,
 },
 [4]={
  .start = IRQ_EINT14,
  .end   = IRQ_EINT14,
  .flags = IORESOURCE_IRQ,
 },
 [5]={
  .start = IRQ_EINT15,
  .end   = IRQ_EINT15,
  .flags = IORESOURCE_IRQ,
 },
 [6]={
  .start = IRQ_EINT19,
  .end   = IRQ_EINT19,
  .flags = IORESOURCE_IRQ,
 }
};

static struct platform_device *s3c_buttons;

 

 

 

介绍完设备，现在介绍驱动程序：

platform_driver_register(&mini2440buttons_driver)

 

int platform_driver_register(struct platform_driver *drv)
{
 drv->driver.bus = &platform_bus_type;  //将platform驱动注册到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;
 if (drv->suspend)
  drv->driver.suspend = platform_drv_suspend;
 if (drv->resume)
  drv->driver.resume = platform_drv_resume;
 return driver_register(&drv->driver);   注册驱动
}

 

关于driver_register:

int driver_register(struct device_driver *drv)
{
 int ret;
 struct device_driver *other;

 if ((drv->bus->probe && drv->probe) ||
     (drv->bus->remove && drv->remove) ||
     (drv->bus->shutdown && drv->shutdown))
  printk(KERN_WARNING "Driver '%s' needs updating - please use "
   "bus_type methods\n", drv->name);

 other = driver_find(drv->name, drv->bus);
 if (other) {
  put_driver(other);
  printk(KERN_ERR "Error: Driver '%s' is already registered, "
   "aborting...\n", drv->name);
  return -EEXIST;
 }

 ret = bus_add_driver(drv);
 if (ret)
  return ret;
 ret = driver_add_groups(drv, drv->groups);
 if (ret)
  bus_remove_driver(drv);
 return ret;
}

 

回头看mini2440buttons_driver:

 

static struct platform_driver mini2440buttons_driver = {
 .probe  = mini2440_buttons_probe,
 .remove  = mini2440_buttons_remove,
 .driver  = {
  .owner = THIS_MODULE,
  .name = "mini2440-buttons",  //与设备名相同
 },
};

 

当匹配了driver和device后，platform_driver通过probe检测platform总线上的设备：

static int mini2440_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(&mini2440_miscdev);
  
 return 0;

 err_map:
 iounmap(buttons_base);

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

 return ret;
}

 

关于函数platform_get_resource(struct platform_device *dev,unsigned int type,

unsigned int num)

dev:资源所属的设备

type:获取的资源类型 IORESOURCE_IRQ.....

num:获取资源数目

 

关于request_mem_region()

request_mem_region() -- 将起始地址为[start, start+n-1]的资源插入根资源iomem_resource中。参数start是I/O内存资源的起始物理地址(是CPU的RAM物理地址空间中的物理地址)，参数n指定I/O内存资源的大小。

#define request_mem_region(start, n, name) \
        __request_region(&iomem_resource, (start), (n), (name))

注: 调用request_mem_region()不是必须的，但是建议使用。该函数的任务是检查申请的资源是否可用，如果可用则申请成功，并标志为已经使用，其他驱动想再申请该资源时就会失败。

关于ioremap:

驱动程序并不能直接通过物理地址访问I/O内存资源，而必须将它们映射到核心虚地址空间内（通过页表），然后才能根据映射所得到的核心虚地址范围，通过访内指令访问这些I/O内存资源。Linux在io.h头文件中声明了函数ioremap（），用来将I/O内存资源的物理地址映射到核心虚地址空间（3GB－4GB）中，原型如下：

void * ioremap(unsigned long phys_addr, unsigned long size, unsigned long flags);

 

关于platform_get_resource(struct pdev *dev,unsigned int type,unsigned int num)

dev:资源所属的设备

type:获取的资源类型

num：获取的资源数

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

 for (i = 0; i < dev->num_resources; i++) {
  struct resource *r = &dev->resource[i];

  if (type == resource_type(r) && num-- == 0)
   return r;
 }
 return NULL;
}

 

由函数可以看出，函数返回了第num个资源的首地址，但是感觉这个函数做了很多无用功。

 

关于misc_register()

 

注册杂项字符设备，该类设备使用同一个主设备号10
杂项字符设备使用的数据结构
struct miscdevice  {
    int minor;
    const char *name;
    struct file_operations *fops;
    struct list_head list;
    struct device *dev;
    struct class_device *class;
    char devfs_name[64];
};

杂项设备也是在嵌入式系统中用得比较多的一种设备驱动。在 Linux 内核的include\linux\miscdevice.h文件，要把自己定义的misc device从设备定义在这里。其实是因为这些字符设备不符合预先确定的字符设备范畴，所有这些设备采用主设备号10 ，一起归于misc device，其实misc_register就是用主设备号10调用register_chrdev()的。也就是说，misc设备其实也就是特殊的字符设备。

misc_device是特殊的字符设备。注册驱动程序时采用misc_register函数注册，此函数中会自动创建设备节点，即设备文件。无需mknod指令创建设备文件。因为misc_register()会调用class_device_create()或者device_create()。

再看mini2440_miscdev

static struct miscdevice mini2440_miscdev = {
 
    .minor = MISC_DYNAMIC_MINOR,
    .name ="buttons",       //创建设备文件buttons
    .fops = &mini2440buttons_fops,
};

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