ldd3学习之十一(3)：Linux设备模型---platform总线分析

platform机制由两部分组成，platform_device和platform_driver。

Platform驱动与传统的设备驱动模型（即通过driver_register函数进行注册）相比，优势在于platform机制将设备本身的资源注册进内核，由内核统一管理，在驱动程序使用这些资源时使用统一的接口(即通过platform device提供的标准接口)，这样提高了程序可移植性。

platform 是一个虚拟的地址总线，相比 PCI、USB、I2C，它主要用于描述 SOC 上的片上资源。比如 S3C2410 上集成的控制器（ LCD、Watchdog、RTC等），platform 所描述的资源有一个共同点：在 CPU 的总线上直接取址。

用platform机制开发底层设备驱动流程图。

1.平台设备

(1)描述

struct platform_device {
     const char    * name;//设备名字
     int        id;       //设备编号
     struct device    dev;
     u32        num_resources;
     struct resource    * resource;//设备资源

     struct platform_device_id    *id_entry;

     /* arch specific additions */
     struct pdev_archdata    archdata;
 };

(2)分配

struct platform_device *platform_device_alloc(const char *name, unsigned int id)
name:设备名
id：一般为-1

(3)注册

int platform_device_add(struct platform_device *pdev)
{
 //增加的platform设备，都以platform_bus(platform设备)为父节点
 if (!pdev->dev.parent) pdev->dev.parent = &platform_bus;

 //platform类型设备都挂接在platform总线上 /sys/bus/platform/
 pdev->dev.bus = &platform_bus_type;
 .
 .
 .
}

(4)资源描述

/*
  * Resources are tree-like, allowing
  * nesting etc..
  */
 struct resource {
     resource_size_t start;//资源的起始物理地址
     resource_size_t end;  //资源的结束物理地址
     const char *name;     //资源名称
     unsigned long flags;  //资源类型，MEM,IO,IRQ
     struct resource *parent, *sibling, *child; //资源链表指针
 };

比如linux-2.6.32内核自带的s3c2410-wdt设备加载过程如下

/* Watchdog */
#define S3C24XX_VA_WATCHDOG S3C_VA_WATCHDOG
#define S3C2410_PA_WATCHDOG (0x53000000)
#define S3C24XX_SZ_WATCHDOG SZ_1M

#define S3C24XX_PA_WATCHDOG S3C2410_PA_WATCHDOG

 static struct resource s3c_wdt_resource[] = {
     [0] = {//硬件寄存器资源
         .start = S3C24XX_PA_WATCHDOG, //0x53000000
         .end = S3C24XX_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,
         .flags = IORESOURCE_MEM,
     },
     [1] = {//中断资源
         .start = IRQ_WDT,
         .end = IRQ_WDT,
         .flags = IORESOURCE_IRQ,
     }

 };

 struct platform_device s3c_device_wdt = {
     .name         = "s3c2410-wdt",//name要与platform_driver中的name一致
     .id         = -1,
     .num_resources     = ARRAY_SIZE(s3c_wdt_resource),
     .resource     = s3c_wdt_resource,
 };
static struct platform_device *smdk2440_devices[] __initdata = {
 &s3c_device_usb,
 &s3c_device_lcd,
 &s3c_device_wdt,//platform_device指针
 &s3c_device_i2c0,
 &s3c_device_iis,
};
static void __init smdk2440_machine_init(void)
{
 s3c24xx_fb_set_platdata(&smdk2440_fb_info);
 s3c_i2c0_set_platdata(NULL);

//添加所有platform设备

 platform_add_devices(smdk2440_devices, ARRAY_SIZE(smdk2440_devices));
 smdk_machine_init();
}

MACHINE_START(S3C2440, "SMDK2440")
 /* Maintainer: Ben Dooks */
 .phys_io = S3C2410_PA_UART,
 .io_pg_offst = (((u32)S3C24XX_VA_UART) >> 18) & 0xfffc,
 .boot_params = S3C2410_SDRAM_PA + 0x100,

 .init_irq = s3c24xx_init_irq,
 .map_io = smdk2440_map_io,
 .init_machine = smdk2440_machine_init,
 .timer = &s3c24xx_timer,
MACHINE_END

(5)获取资源方法

/**
  * platform_get_resource - get a resource for a device
  * @dev: platform device
  * @type: resource type
  * @num: resource index
  */
 struct resource *platform_get_resource(struct platform_device *dev,
                  unsigned int type, unsigned int num)
dev:资源所属设备
type:获取资源类型
num:获取的资源index
比如：
platform_get_resource（pdev,IORESOURCE_IRQ,0）//获取中断号
platform_get_resource（pdev,IORESOURCE_MEM,0）//获取第0个资源

2.平台驱动

(1)描述

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;
     struct platform_device_id *id_table;
 };

(2)注册

/**
  * platform_driver_register
  * @drv: platform driver structure
  */
int platform_driver_register(struct platform_driver *drv)

在2.6.32内核s3c2410_wdt.c中实例注册过程

static struct platform_driver s3c2410wdt_driver = {
    .probe        = s3c2410wdt_probe,
    .remove        = __devexit_p(s3c2410wdt_remove),
    .shutdown    = s3c2410wdt_shutdown,
    .suspend    = s3c2410wdt_suspend,
    .resume        = s3c2410wdt_resume,
    .driver        = {
        .owner    = THIS_MODULE,
        .name    = "s3c2410-wdt",//名字与platform_device中的name一致
    },
};
static int __init watchdog_init(void)
{
    printk(banner);
    return platform_driver_register(&s3c2410wdt_driver);
}

static void __exit watchdog_exit(void)
{
    platform_driver_unregister(&s3c2410wdt_driver);
}
module_init(watchdog_init);
module_exit(watchdog_exit);

(3)probe函数

执行时机：当所加载驱动与相应设备匹配成功

功能：获得设备资源，完成一个设备驱动所有的操作接口

(4)remove函数

执行：设备或驱动移除时

功能：释放probe申请的一切资源

比如s3c2410_wdt.c

/* device interface */

 static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
 {
     struct resource *res;
     struct device *dev;
     unsigned int wtcon;
     int started = 0;
     int ret;
     int size;

     DBG("%s: probe=%p\n", __func__, pdev);

     dev = &pdev->dev;
     wdt_dev = &pdev->dev;

     /* get the memory region for the watchdog timer */

     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;
     wdt_mem = request_mem_region(res->start, size, pdev->name);
     if (wdt_mem == NULL) {
         dev_err(dev, "failed to get memory region\n");
         ret = -ENOENT;
         goto err_req;
     }

     wdt_base = ioremap(res->start, size);
     if (wdt_base == NULL) {
         dev_err(dev, "failed to ioremap() region\n");
         ret = -EINVAL;
         goto err_req;
     }

     DBG("probe: mapped wdt_base=%p\n", wdt_base);

     wdt_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);//获得中断号
     if (wdt_irq == NULL) {
         dev_err(dev, "no irq resource specified\n");
         ret = -ENOENT;
         goto err_map;
     }

     ret = request_irq(wdt_irq->start, s3c2410wdt_irq, 0, pdev->name, pdev);//注册中断
     if (ret != 0) {
         dev_err(dev, "failed to install irq (%d)\n", ret);
         goto err_map;
     }

     wdt_clock = clk_get(&pdev->dev, "watchdog");
     if (IS_ERR(wdt_clock)) {
         dev_err(dev, "failed to find watchdog clock source\n");
         ret = PTR_ERR(wdt_clock);
         goto err_irq;
     }

     clk_enable(wdt_clock);

     /* see if we can actually set the requested timer margin, and if
      * not, try the default value */

     if (s3c2410wdt_set_heartbeat(tmr_margin)) {
         started = s3c2410wdt_set_heartbeat(
                     CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);

         if (started == 0)
             dev_info(dev,
              "tmr_margin value out of range, default %d used\n",
              CONFIG_S3C2410_WATCHDOG_DEFAULT_TIME);
         else
             dev_info(dev, "default timer value is out of range, "
                             "cannot start\n");
     }

     ret = misc_register(&s3c2410wdt_miscdev);
     if (ret) {
         dev_err(dev, "cannot register miscdev on minor=%d (%d)\n",
             WATCHDOG_MINOR, ret);
         goto err_clk;
     }

     if (tmr_atboot && started == 0) {
         dev_info(dev, "starting watchdog timer\n");
         s3c2410wdt_start();
     } else if (!tmr_atboot) {
         /* if we're not enabling the watchdog, then ensure it is
          * disabled if it has been left running from the bootloader
          * or other source */

         s3c2410wdt_stop();
     }

     /* print out a statement of readiness */

     wtcon = readl(wdt_base + S3C2410_WTCON);

     dev_info(dev, "watchdog %sactive, reset %sabled, irq %sabled\n",
          (wtcon & S3C2410_WTCON_ENABLE) ? "" : "in",
          (wtcon & S3C2410_WTCON_RSTEN) ? "" : "dis",
          (wtcon & S3C2410_WTCON_INTEN) ? "" : "en");

     return 0;

  err_clk:
     clk_disable(wdt_clock);
     clk_put(wdt_clock);

  err_irq:
     free_irq(wdt_irq->start, pdev);

  err_map:
     iounmap(wdt_base);

  err_req:
     release_resource(wdt_mem);
     kfree(wdt_mem);

     return ret;
 }

3.平台总线

(1)描述

struct bus_type platform_bus_type = {
     .name        = "platform",
     .dev_attrs    = platform_dev_attrs,
     .match        = platform_match,
     .uevent        = platform_uevent,
     .pm        = &platform_dev_pm_ops,
 };

(2)match方法:当platform总线上有设备或驱动变化时执行一次或多次

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

     /* match against the id table first */
     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); //比较name成员
 }

4.小结：

(1)当platform总线上有设备或驱动加入时，platform总线的match方法被调用一次或多次，遍历所有设备，一旦name成员与driver匹配成功，调用driver的probe方法，移除时调用remove方法。

(2)platform总线只是提供了一个管理硬件资源与设备的机制，驱动接口真正的实现在probe()函数内完成。

一个简单的platform机制测试代码： platform.rar   

实验结果：

阅读(1476) | 评论(0) | 转发(8) |

0

上一篇：ldd3学习之十一(2)：Linux设备模型---总线、设备、驱动

下一篇：U-boot 用法

相关热门文章

• linux 常见服务端口
• xmanager 2.0 for linux配置
• 【ROOTFS搭建】busybox的httpd...
• openwrt中luci学习笔记
• 什么是shell

• linux dhcp peizhi roc
• 关于Unix文件的软链接
• 求教这个命令什么意思，我是新...
• sed -e "/grep/d" 是什么意思...
• 谁能够帮我解决LINUX 2.6 10...

给主人留下些什么吧！~~

评论热议