linux驱动：（14）平台总线模型 （platform设备 二）

目录

编写probe函数思路

获得硬件资源

直接获取

函数获取

直接获取和函数获取例子

注册 杂项 / 字符 设备

步骤

登记硬件资源

接上面获取硬件资源后登记的例子

注册设备

---

编写probe函数思路

1. 从 device.c里面获得硬件资源
2. 注册 杂项 / 字符 设备，完善 file_operation 结构体，并生成设备节点

获得硬件资源

有两种方法

• 直接获取
• 函数获取

直接获取

• 先看probe函数，这个函数有一个参数 struct platform_device *pdev
• 当匹配成功后就会调用probe这个函数，就会将device里定义的platform_device结构体当作参数来传递进来
• 这个结构体里又定义了硬件资源，就是寄存器地址什么的，可以直接拿到
  • 例如在probe里输出 pdev->resource[0].name 就可以输出该寄存器的名字了
  • 例如在probe里输出 pdev->resource[0].start 就可以输出该寄存器的起始地址了
• 但这个方法不安全，不推荐

函数获取

可以利用函数来将硬件资源单独复制出来一份

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

参数

• 第一个：probe的参数pdev
• 第二个：访问硬件资源的类型，就是硬件资源的flags
• 第三个：访问该类型的第几个硬件资源

获取步骤

• 先定义一个resource结构体变量指针
• 使用函数，返回值赋值给前面定义的resource结构体变量指针
• 判断返回值是不是空
• 然后打印

直接获取和函数获取例子

struct resource *beep_mem;

int beep_probe(struct platform_device *pdev)
{
    printk("beep_probe\n");
    //方法1
    //printk("%s\n",pdev->resource[0].name);
    //方法2
    beep_mem = platform_get_resource(pdev,IORESOURCE_MEM,0);
    if (beep_mem == NULL)
    {
        printk("platform_get_resource error\n");
        return -EBUSY;
    }
    printk("start 0x%x\n",beep_mem->start);
    printk("end 0x%x\n",beep_mem->end);
    printk("platform_get_resource ok\n");
    return 0;
}

注册 杂项 / 字符 设备

步骤

1. 登记硬件资源，登记就是为了告诉内核我要用到这个寄存器，当别人已经在用的时候就会错误
2. 注册设备

登记硬件资源

到了第二步注册，但在注册前我们要先登记，用到的函数定义在ioport.h里

request_mem_region(start,n,name)

参数

• start：起始地址
• n：长度
• name：登记为什么名字
• 返回值：resource结构体

 登记不成功就需要注销登记，也有函数

release_mem_region(start,n)

参数

• start：起始地址
• n：长度

接上面获取硬件资源后登记的例子

步骤

• 定义资源变量指针
• 登记
• 判断登记成不成功
  • 成功就返回
  • 不成功就注销登记

struct resource *beep_mem;
struct resource *beep_mem_tmp;


int beep_probe(struct platform_device *pdev)
{
    printk("beep_probe\n");
    //方法1
    //printk("%s\n",pdev->resource[0].name);
    //方法2
    beep_mem = platform_get_resource(pdev,IORESOURCE_MEM,0);
    if (beep_mem == NULL)
    {
        printk("platform_get_resource error\n");
        return -EBUSY;
    }
    printk("start 0x%x\n",beep_mem->start);
    printk("end 0x%x\n",beep_mem->end);
    printk("platform_get_resource ok\n");
    beep_mem_tmp = request_mem_region(beep_mem->start,beep_mem->end-beep_mem->start+1,"beep");
    if (beep_mem_tmp==NULL)
    {
        printk("request_mem_region error\n");
        goto .err_region;
    }
    
    return 0;
err_region:
    release_mem_region(beep_mem->start,beep_mem->end-beep_mem->start+1);
    return -EBUSY;
}

注册设备

我这就注册一个杂项设备，下面是完整driver.c代码

#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/uaccess.h>
#include <linux/cdev.h>
#include <linux/device.h> 
#include <linux/platform_device.h> 

struct resource *beep_mem;
struct resource *beep_mem_tmp;
unsigned int *vir_gpio5_dr;

int misc_open(struct inode *inode,struct file *file)
{
    printk("hello misc_open\n");
    return 0;
}

struct  file_operations misc_fops =
{
    .owner = THIS_MODULE,
    .open = misc_open
};
struct miscdevice misc_dev =
{
    .minor = MISC_DYNAMIC_MINOR,
    .name = "hello_misc",
    .fops = &misc_fops
};



int beep_probe(struct platform_device *pdev)
{
    int ret = 0;
    printk("beep_probe\n");
    //方法1
    //printk("%s\n",pdev->resource[0].name);
    //方法2
    beep_mem = platform_get_resource(pdev,IORESOURCE_MEM,0);
    if (beep_mem == NULL)
    {
        printk("platform_get_resource error\n");
        return -EBUSY;
    }
    printk("start 0x%x\n",beep_mem->start);
    printk("end 0x%x\n",beep_mem->end);
    printk("platform_get_resource ok\n");
    beep_mem_tmp = request_mem_region(beep_mem->start,beep_mem->end-beep_mem->start+1,"beep");
    if (beep_mem_tmp==NULL)
    {
        printk("request_mem_region error\n");
        goto .err_region;
    }
    
    vir_gpio5_dr = ioremap(beep_mem->start,4);
    if (vir_gpio5_dr ==NULL)
    {
        printk("ioremap error\n");
        return -EBUSY;
    }
    printk("ioremap ok\n");
    ret = misc_register(&misc_dev);
    if (ret<0)
    {
        printk("misc_register error\n");
        return -1;
    }
    printk("misc_register ok\n");
    return 0;


err_region:
    release_mem_region(beep_mem->start,beep_mem->end-beep_mem->start+1);
    return -EBUSY;
}

int beep_remove(struct platform_device *pedv)
{
    printk("beep_remove\n");
    return 0;
};
const struct platform_device_id beep_id_table =
{
    .name = "123"
};

struct platform_driver beep_device =
{
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name = "beep_test"
    },
    .id_table = &beep_id_table
};

 
static int beep_driver_init(void)
{
    int ret = 0;
    ret = platform_driver_register(&beep_device);
    if (ret<0)
    {
        printk("platform_driver_register error\n");
        return ret;
    }
    
    printk("platform_driver_register ok\n");
    return 0;
}
 
static void beep_driver_exit(void)
{
    printk("beep goodbye");
    platform_driver_unregister(&beep_device);
    misc_deregister(&misc_dev);
    iounmap(vir_gpio5_dr);
}
 
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");