Linux驱动学习--platform设备与驱动的程序实现

最新推荐文章于 2024-03-18 02:40:02 发布

HL-SIRB

最新推荐文章于 2024-03-18 02:40:02 发布

阅读量663

点赞数 13

文章标签： linux 驱动开发学习

本文链接：https://blog.csdn.net/qq_39717374/article/details/136346661

版权

一、程序的编写

实验我们需要编写一个驱动模块和一个设备模块，其中驱动模块是 platform 驱动程序，设备模块是 platform 的设备信息。当这两个模块都加载成功以后就会匹配成功，然后 platform驱动模块中的 probe 函数就会执行， probe 函数中就是传统的字符设备驱动那一套。

二、platform设备程序

首先是入口函数，调用platform_device_register函数，向内核注册leddevice结构体

/**
 * 设备块加载
*/
static int __init leddevice_init(void)
{
    return platform_device_register(&leddevice);
}

leddevice结构体如地下

/**
 * platform结构体
*/
static struct platform_device leddevice = {
    .name = "imx6ull-led",
    .id = -1,
    .dev = {
        .release = &led_release,
    },
    .num_resources = ARRAY_SIZE(led_resources),
    .resource = led_resources,
};

注意 name 字段为“imx6ull-led”，所以稍后编写 platform 驱动中的 name 字段也要为“imx6ull-led”，否则设备和驱动匹配失败。其中led_resources是一个关于设备资源信息的结构体，里面有LED设备所使用的所有寄存器。也就是 IORESOURCE_MEM 资源。
led_resources结构体如下：

/**
 * 设备资源信息，也就是LED0所使用的所有寄存器
*/
static struct resource led_resources[] = {
    [0] = {
        .start = CCM_CCGR1_BASE,
        .end = (CCM_CCGR1_BASE + REGISTER_LENGTH - 1),
        .flags = IORESOURCE_MEM,
    },
    [1] = {
        .start = SW_MUX_GPIO1_IO03_BASE,
        .end = (SW_MUX_GPIO1_IO03_BASE + REGISTER_LENGTH - 1),
        .flags = IORESOURCE_MEM,
    },
    [2] = {
        .start = SW_PAD_GPIO1_IO03_BASE,
        .end = (SW_PAD_GPIO1_IO03_BASE + REGISTER_LENGTH -1),
        .flags = IORESOURCE_MEM,
    },
    [3] = {
        .start = GPIO1_DR_BASE,
        .end = (GPIO1_DR_BASE + REGISTER_LENGTH - 1),
        .flags = IORESOURCE_MEM,
    },
    [4] = {
        .start = GPIO1_GDIR_BASE,
        .end = (GPIO1_GDIR_BASE + REGISTER_LENGTH - 1),
        .flags = IORESOURCE_MEM,
    },
};

其次是设备卸载函数，调用platform_device_unregister函数，从Linux内核中删除掉leddevice这个总线设备。

/**
 * 设备注销
*/
static void __exit leddevice_exit(void)
{
    platform_device_unregister(&leddevice);
}

至此，我们的platform的设备文件就写完了，接下来，我们继续写platform驱动文件。

三、platform驱动程序（没设备树）

首先，也是入口函数，在该函数中通过调用platform_driver_register向Linux内核注册一个platform_driver结构体。

/**
 * 驱动模块加载函数
*/
static int __init leddriver_init(void)
{
    return platform_driver_register(&led_driver);
}

其中，该platform_driver结构体如下：

/*platform 驱动结构体*/
static struct platform_driver led_driver = {
    .driver = {
        .name = "imx6ull-led",      /*驱动名字用于和设备匹配*/
    },
    .probe = led_probe,
    .remove = led_remove,
};

在该结构体中，name 字段为"imx6ull-led"，和我们在leddevice.c 文件里面设置的设备 name 字段一致。当设备和驱动匹配以后此函数就会执行，当匹配成功以后会在终端上输出“led driver and device has matched!”，在 probe 函数里面初始化 LED、注册字符设备驱动。也就是将原来在驱动加载函数里面做的工作全部放到 probe 函数里面完成。
led_probe函数如下：

/**
 * paltform驱动的probe函数，当驱动与设备匹配以后此函数就会执行
 * dev：platform设备
 * 返回值：0 成功；其他负值，失败
*/
static int led_probe(struct platform_device *dev)
{
    int i = 0;
    int ressize[5];
    u32 val = 0;
    struct resource *ledsource[5];

    printk("led driver and device has matched!\r\n");

    /*1、获取资源*/
    for(i= 0; i < 5; i++){
        ledsource[i] = platform_get_resource(dev, IORESOURCE_MEM, i);
        if(!ledsource[i]){
            dev_err(&dev->dev, "No MEM resource for always on\n");
            return -ENXIO;
        }
        ressize[i] = resource_size(ledsource[i]);
    }

    /**2、初始化LED*/
    /*寄存器地址映射*/
    IMX6U_CCM_CCGR1 = ioremap(ledsource[0]->start, ressize[0]);
    SW_MUX_GPIO1_IO03 = ioremap(ledsource[1]->start, ressize[1]);
    SW_PAD_GPIO1_IO03 = ioremap(ledsource[2]->start, ressize[2]);
    GPIO1_DR = ioremap(ledsource[3]->start, ressize[3]);
    GPIO1_GDIR = ioremap(ledsource[4]->start, ressize[4]);

    val = readl(IMX6U_CCM_CCGR1);
    val &= ~(3 << 26);      /*清除以前的设置*/
    val |= (3 << 26);       /*设置新值*/
    writel(val,IMX6U_CCM_CCGR1);

    /*设置GPIO1_IO03复用功能，将其复用为GPIO1_IO03*/
    writel(5, SW_MUX_GPIO1_IO03);
    writel(0x10B0, SW_PAD_GPIO1_IO03);

    /**设置GPIO1_IO03输出功能*/
    val = readl(GPIO1_GDIR);
    val &= ~(1 << 3);   /*清除以前的设置*/
    val |= (1 << 3);
    writel(val, GPIO1_GDIR);

    /**默认关闭LED1*/
    val = readl(GPIO1_DR);
    val |= (1 << 3);
    writel(val, GPIO1_DR);

    /**注册字符设备驱动*/
    /*1、创建设备号*/
    if(leddev.major){
        leddev.devid = MKDEV(leddev.major, 0);
        register_chrdev_region(leddev.devid, LEDDEV_CNT,LEDDEV_NAME);
    }else{
        alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, LEDDEV_NAME);
        leddev.major = MAJOR(leddev.devid);
    }

    /**2、初始化cdev*/
    leddev.cdev.owner = THIS_MODULE;
    cdev_init(&leddev.cdev, &led_fops);

    /*3、添加一个cdev*/
    cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);

    /*4、创建类*/
    leddev.class = class_create(THIS_MODULE, LEDDEV_NAME);
    if(IS_ERR(leddev.class)){
        return PTR_ERR(leddev.class);
    }

    /*5、创建设备*/
    leddev.device = device_create(leddev.class, NULL, leddev.devid, NULL, LEDDEV_NAME);
    if(IS_ERR(leddev.device)){
        return PTR_ERR(leddev.device);
    }

    return 0;
}

该函数首先通过调用platform_get_resource函数，获取设备资源，其次是初始化LED，其中初始化又分为（1）寄存器地址的映射；（2）设置引脚的复用功能，设置IO电气属性；（3）设置引脚为输入或者输出功能；（4）设置初始状态。然后，注册字符设备驱动，注册字符设备驱动又分为五步：（1）创建设备号；（2）初始化cdev；（3）添加一个cdev；（4）创建类；（5）创建设备；在该函数中还调用了各种函数进行了各种操作，其中比较重要的初始化cdev时，会初始化设备操作函数file_operations，该结构体中有open和write函数，他们都是在应用程序中调用open函数和write函数时会调用这两个函数，函数如下所示：

/**设备操作函数*/
static struct file_operations led_fops = {
    .owner = THIS_MODULE,
    .open = led_open,
    .write = led_write,
};

1、在led_open 函数中设置文件的私有数据 private_data 指向leddev结构体，该结构体，包含以下变量，表示led设备：

/**
 * leddev设备结构体
*/
struct leddev_dev{
    dev_t devid;            /*设备号*/
    struct cdev cdev;       /*cdev*/
    struct class *class;    /*类*/
    struct device *device;  /*设备*/
    int major;              /*主设备号*/
};

struct leddev_dev leddev;   /*led 设备*/



/**
 * 描述：打开设备
 * inode：传递给驱动inode
 * filp：设备文件，file结构体有个叫做private_data的成员变量
 *      一般在open的时候将private_data指向设备结构体
 * 返回值：0 成功； 其他 失败
*/
static int led_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &leddev;   /*设置私有数据*/
    return 0;
}

2、led_write函数，在应用函数调用write函数时会调用该函数，函数如下：

/**
 * 向设备写数据
 * filp：设备文件，表示打开的文件描述符
 * buf：要写给设备写入的数据
 * cnt：要写入的数据长度
 * offt：相对于文件首地址的偏移
 * 返回值：写入的字节数，如果为负值，表示写入失败
*/
static ssize_t led_write(struct file *filp, const char __user *buf, 
                            size_t cnt, loff_t *offt)
{
    int retvalue;
    unsigned char databuf[1];
    unsigned char ledstat;

    retvalue = copy_from_user(databuf, buf, cnt);
    if(retvalue < 0)
    {
        return -EFAULT;
    }

    ledstat = databuf[0];       /*获取状态值*/
    if(ledstat == LEDON){
        led0_switch(LEDON);     /*打开LED灯*/
    }else if(ledstat == LEDOFF){
        led0_switch(LEDOFF);    /*关闭LED灯*/
    }
    return 0;
}

最后，驱动模块卸载函数，在此函数里面通过 platform_driver_unregister 从 Linux内核卸载 led_driver 驱动。这时会调用platform_driver结构体中的remove函数，在此函数里面释放内存、注销字符设备等。也就是将原来驱动卸载函数里面的工作全部都放到 remove 函数中完成。

/**
 * 驱动模块卸载函数
*/
static void __exit leddriver_exit(void)
{
    platform_driver_unregister(&led_driver);
}

remove 函数如下所示：

/**
 * 函数描述：移除platform驱动的时候此函数会执行
 * dev：platform设备
 * 返回值：0，成功；其他负值，失败
*/
static int led_remove(struct platform_device *dev)
{
    iounmap(IMX6U_CCM_CCGR1);
    iounmap(SW_MUX_GPIO1_IO03);
    iounmap(SW_PAD_GPIO1_IO03);
    iounmap(GPIO1_DR);
    iounmap(GPIO1_GDIR);

    cdev_del(&leddev.cdev);     /*删除cdev*/
    unregister_chrdev_region(leddev.devid, LEDDEV_CNT);
    device_destroy(leddev.class, leddev.devid);
    class_destroy(leddev.class);

    return 0;
}

四、platform驱动（带设备树）

在使用设备树的时候，设备的描述被放到了设备树中，因此 platform_device 就不需要我们去编写了，我们只需要实现 platform_driver 即可。

1）在设备树中创建设备节点

在设备树中创建设备节点来描述设备信息，重点是要设置好 compatible属性的值，因为 platform 总线需要通过设备节点的 compatible 属性值来匹配驱动。设备节点如下：

gpioled {
 #address-cells = <1>;
 #size-cells = <1>;
 compatible = "atkalpha-gpioled";
 pinctrl-names = "default";
 pinctrl-0 = <&pinctrl_led>;
 led-gpio = <&gpio1 3 GPIO_ACTIVE_LOW>;
 status = "okay";
};

compatible 属性值为“atkalpha-gpioled”，因此一会在编写 platform驱动的时候 of_match_table 属性表中要有“atkalpha-gpioled”。

2）编写 platform 驱动的时候要注意兼容属性
使用设备树的时候 platform 驱动会通过 of_match_table 来保存兼容性值，也就是表明此驱动兼容哪些设备。如下所示：

/* 匹配列表 */
static const struct of_device_id led_of_match[] = {
	{ .compatible = "atkalpha-gpioled" },
	{ /* Sentinel */ }
};

/* platform驱动结构体 */
static struct platform_driver led_driver = {
	.driver		= {
		.name	= "imx6ull-led",			/* 驱动名字，用于和设备匹配 */
		.of_match_table	= led_of_match, /* 设备树匹配表 		 */
	},
	.probe		= led_probe,
	.remove		= led_remove,
};

of_device_id 表，也就是驱动的兼容表，是一个数组，每个数组元素为 of_device_id类型。每个数组元素都是一个兼容属性，表示兼容的设备，一个驱动可以跟多个设备匹配。
compatible 值为“atkalpha-gpioled”，驱动中的 compatible 属性和设备中的 compatible 属性相匹配，因此驱动中对应的 probe 函数就会执行。

        在编写 of_device_id 的时候最后一个元素一定要为空！
        通过 MODULE_DEVICE_TABLE 声明一下 leds_of_match 这个设备匹配表
        设置 platform_driver 中的 of_match_table 匹配表为上面创建的 leds_of_match，至此我们就设置好了 platform 驱动的匹配表了。

3）编写 platform 驱动

基于设备树的 platform 驱动和上一章无设备树的 platform 驱动基本一样，都是当驱动和设备匹配成功以后就会执行 probe 函数。我们需要在 probe 函数里面执行字符设备驱动那一套，当注销驱动模块的时候 remove 函数就会执行，都是大同小异的。这里就不分析了。

5、应用程序

应用程序就哈斯对led的驱动文件惊醒进本的打开、关闭、写操作等

/**
 * 函数描述：main主程序
 * 参数argc：argv数组元素的个数
 * 参数argv：具体参数
 * 返回值：0 成功，其他失败
*/
int main(int argc, char *argv[])
{
    int fd, retvalue;
    char *filename;
    unsigned char databuf[2];
    if(argc != 3){
        printf("Error Usage!\r\n");

        return -1;
    }

    filename = argv[1];
    /*打开led驱动*/
    fd = open(filename, O_RDWR);
    if(fd < 0){
        printf("file %s open failed!\r\n", argv[1]);
        return -1;
    }

    databuf[0] = atoi(argv[2]);     /*要执行的操作，打开或者关闭*/
    retvalue = write(fd, databuf, sizeof(databuf));
    if(retvalue < 0)
    {
        printf("LED Control Failed!!\r\n");
        close(fd);
        return -1;
    }

    retvalue = close(fd);   /*关闭文件*/
    if(retvalue < 0)
    {
        printf("file %s close failed!\r\n", argv[1]);
        return -1;
    }
    return 0;
}

首先，判断参数是否正确，正确就继续运行；然后是打开led驱动，要执行的操作，调用write函数进行写操作；最后关闭文件。看到这里了，大家点个赞吧！！！