platform设备树实现“热插拔”--驱动

platform驱动实现

platform驱动实现

实验现象

应用程序

#include<string.h>
#include<stdlib.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<unistd.h>
#include<sys/ioctl.h>
#include<fcntl.h>


int main(int argc, const char* argv[])
{
    int fd;
    int number;

    if ((fd = open("/dev/myplatform", O_RDWR)) == -1) {
        perror("open error");
        exit(EXIT_FAILURE);
    }

    while (1) {
        read(fd, &number, sizeof(number));
        printf("number = %d\n", number);
    }
    close(fd);
    return 0;
}

驱动程序

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/gpio.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/mod_devicetable.h>
/*myplatform{
        compatible = "hqyj,myplatform";
        reg=<0X12345678 0X400>;
        interrupt-parent=<&gpiof>;
        interrupts=<9 0>;   //9表示引用中断父节点时的索引信息  0表示默认设置
        led1=<&gpioe 10 0>;
    
    };*/
#define CNAME "myplatform"
int major; 		//保存主设备号
struct class *cls;
struct device *dev;
wait_queue_head_t wq; 	//定义等待队列头
unsigned int condition = 0;  //事件
unsigned int number = 0; 		

struct device_node *node; 
struct gpio_desc *desc;     //
//unsigned int irqno;

struct resource *res;
unsigned int irqno; 		//中断号
struct gpio_desc *gpiono;   //GPIO子系统

//中断处理函数
irqreturn_t irq_led_handle(int irq, void *dev)
{
    printk("中断处理函数， %s:%s:%d\n",__FILE__,__func__,__LINE__);
    number = gpiod_get_value(desc);
    number = !number;
    gpiod_set_value(desc,number);

    condition = 1;
    wake_up_interruptible(&wq);

    return IRQ_HANDLED;
}

//
int irq_led_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

ssize_t irq_led_read(struct file *file, char __user *ubuf, size_t size, loff_t *offs)
{
    int ret;
    printk("回调底层read函数，%s:%s:%d\n",__FILE__,__func__,__LINE__);

    if(file->f_flags & O_NONBLOCK){
        //非阻塞
        return -EINVAL;
    }else{
        //阻塞
        ret = wait_event_interruptible(wq,condition);
        if(ret < 0){
            printk("receive signal....\n");
            return ret;
        }
    }
    //将数据拷贝到用户空间
    if(size > sizeof(number)) size = sizeof(number);
    ret = copy_to_user(ubuf,(void *)&number,size);
    if(ret){
        printk("copy data to user error\n");
        return -EIO;
    }

    condition = 0;
    return size;
}

int irq_led_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

//对象结构体
struct file_operations fops = {
    .open = irq_led_open,
    .read = irq_led_read,
    .release = irq_led_close,
};


//probe函数，匹配设备成功执行
int pdrv_probe(struct platform_device *pdev) 
{
     printk("probe函数，设备匹配成功%s:%s:%d\n",__FILE__,__func__,__LINE__);
	
	 int ret;

     //获取设备信息
     res = platform_get_resource(pdev,IORESOURCE_MEM,0);
     if(res == NULL)
     {
        printk("获取资源失败\n");
        return -ENXIO;
     }
     printk("获取资源信息成功 %x\n",res->start);

	 //初始化等待队列头
	init_waitqueue_head(&wq);

	//获取中断号
     irqno = platform_get_irq(pdev,0);
     if(irqno < 0)
     {
        printk("获取中断资源失败\n");
        return irqno;
     }
     printk("中断类型资源为%d\n",irqno);
	
	 //注册中断号
	ret = request_irq(irqno,irq_led_handle,IRQF_TRIGGER_FALLING,CNAME,NULL);
	if(ret){
        printk("注册中断号失败request irq error\n");
        goto ERR5;
    }

	//注册字符设备驱动
    major = register_chrdev(0,CNAME,&fops);
    if(major < 0){
        printk("register char device driver error\n");
        ret = major;
        goto ERR1;
    }
	printk("注册字符设备驱动成功\n");

    //创建设备节点,向上提交目录
    cls = class_create(THIS_MODULE,CNAME);
    if(IS_ERR(cls)){
        printk("class create error\n");
        ret = PTR_ERR(cls);
        goto ERR2;
    }
	printk("向上提交目录成功\n");
	
	// 向上提交设备节点信息
    dev = device_create(cls,NULL,MKDEV(major,0),NULL,CNAME);
    if(IS_ERR(dev)){
        printk("device create error\n");
        ret = PTR_ERR(dev);
        goto ERR3;
    }
	printk("向上提交设备节点信息成功\n");
    
	//获取gpio信息
     //pdev->dev.of_node  设备树匹配之后会把设备树节点结构体首地址赋值给dev的of_node成员
    gpiono=gpiod_get_from_of_node(pdev->dev.of_node,"led1",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(gpiono))
    {
        printk("解析GPIO信息失败\n");
        return -PTR_ERR(gpiono);
    }

    //亮灯
    gpiod_set_value(gpiono,1);
    return 0;

/*
    //3.初始化等待队列头
    init_waitqueue_head(&wq);

    //4.解析设备树节点，申请使用的中断和led
    node = of_find_node_by_path("/irq_led");
    if(node == NULL){
        printk("get node error");
        ret = -EAGAIN;
        goto ERR4;
    }
    //获取gpio结构体信息
    desc = gpiod_get_from_of_node(node,"led1",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(desc)){
        printk("get gpiod error\n");
        ret = PTR_ERR(desc);
        goto ERR4;
    }

    return 0;
*/

ERR5:
    gpiod_put(desc);
ERR4:
    device_destroy(cls,MKDEV(major,0));
ERR3:
    class_destroy(cls);
ERR2:
    unregister_chrdev(major,CNAME);
ERR1:
    return ret;
}

//remove 设备和驱动分离时执行
int pdrv_remove(struct platform_device *pdev)
{
     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	
	//注销中断
    free_irq(irqno,NULL);

     //灭灯
     gpiod_set_value(gpiono,0);
     //s释放gpio信息
     gpiod_put(desc);

    // 销毁设备节点信息
    device_destroy(cls, MKDEV(major, 0));
    printk("销毁设备节点信息成功\n");

    // 销毁目录
    class_destroy(cls);
    printk("销毁目录成功\n");

    // 字符设备驱动的注销
    unregister_chrdev(major, CNAME);
    printk("注销字符设备驱动成功\n");

    return 0;
}

//构建设备树匹配的表
struct of_device_id oftable[]={
   {.compatible="hqyj,myplatform",}, 
   {.compatible="hqyj,myplatform1",}, 
   {},
};

struct platform_driver pdrv={
    .probe=pdrv_probe,
    .remove=pdrv_remove,
    .driver={
        .name="aaaaa", 
        .of_match_table=oftable,//设置设备树匹配
    },
    
};


//一键注册宏
module_platform_driver(pdrv);

MODULE_LICENSE("GPL");