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

最新推荐文章于 2023-09-20 21:43:34 发布

原创最新推荐文章于 2023-09-20 21:43:34 发布 · 379 阅读

0 ·

CC 4.0 BY-SA版权

本博客所有文章逐渐搬到个人站www.daodaodao123.com，后续不确定能否同步更新

LINUX 专栏收录该内容

148 篇文章

订阅专栏

本文详细介绍了Linux内核中的Platform机制，包括platform_device和platform_driver的概念及其作用。解释了Platform机制如何提高程序可移植性，并提供了具体的代码示例来展示设备驱动的注册与资源获取过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

实验结果：

<script>window._bd_share_config={"common":{"bdsnskey":{},"bdtext":"","bdmini":"2","bdminilist":false,"bdpic":"","bdstyle":"0","bdsize":"16"},"share":{}};with(document)0[(getelementsbytagname('head')[0]||body).appendchild(createelement('script')).src='http://bdimg.share.baidu.com/static/api/js/share.js?v=89860593.js?cdnversion='+~(-new date()/36e5)];</script>
阅读(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...

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

评论热议