今日驱动作业

驱动代码

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/mod_devicetable.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/interrupt.h>
#include <linux/uaccess.h>

/*
mywork{
        compatible="hqyj,mywork";
        interrupt-parent=<&gpiof>;
        interrupts=<9 0>;  //按键中断
        led-gpio=<&gpioe 10 0>;  //pe10引脚
    };
*/

int major;
struct class *cls;
struct device *dev;
wait_queue_head_t wq;
unsigned int condition = 0;
unsigned int status = 0;
struct gpio_desc *desc;
unsigned int irqno;

irqreturn_t irq_led_handler(int irq, void *dev)
{
    status = gpiod_get_value(desc);
    status = !status;
    gpiod_set_value(desc, status);

    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("%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(status)) size=sizeof(status);
    ret=copy_to_user(ubuf,(void *)&status,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函数和remove函数
int pdrv_probe(struct platform_device *pdev)
{
    int ret;
    // 注册字符设备驱动
    major = register_chrdev(0, "pdrv1", &fops);
    if(major<0)
    {
        printk("register char device driver error\n");
        ret=major;
        goto ERR1;
    }
    //创建设备节点
    cls=class_create(THIS_MODULE,"pdrv1");
    if(IS_ERR(cls))
    {
        printk("class create error\n");
        ret=PTR_ERR(cls);
        goto ERR2;
    }
    dev=device_create(cls,NULL,MKDEV(major,0),NULL,"pdrv1");
    if(IS_ERR(dev))
    {
        printk("device create error\n");
        ret=PTR_ERR(dev);
        goto ERR3;
    }
    //初始化等待队列头
    init_waitqueue_head(&wq);

    desc=gpiod_get_from_of_node(pdev->dev.of_node,"led-gpio",0,GPIOD_OUT_LOW,NULL);
    if(IS_ERR(desc))
    {
        printk("get gpiod error");
        ret=PTR_ERR(desc);
        goto ERR4;
    }

    irqno=platform_get_irq(pdev,0);
    if(irqno<0)
    {
        printk("get irq resource error\n");
        ret=irqno;
        goto ERR5;
    }

    ret=request_irq(irqno,irq_led_handler,IRQF_TRIGGER_FALLING,"pdrv1",NULL);
    if(ret)
    {
        printk("request irq error\n");
        goto ERR5;
    }
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
ERR5:
    gpiod_put(desc);
ERR4:
    device_destroy(cls,MKDEV(major,0));
ERR3:
    class_destroy(cls);
ERR2:
    unregister_chrdev(major,"pdrv1");
ERR1:
    return ret;
}

int pdrv_remove(struct platform_device *pdev)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    free_irq(irqno,NULL);
    gpiod_put(desc);
    device_destroy(cls,MKDEV(major,0));
    class_destroy(cls);
    unregister_chrdev(major,"pdrv1");
    // 1、释放相关设备资源
    // 2、销毁目录和设备信息
    // 3、注销字符设备驱动
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}

// 构建用于设备树匹配的表
struct of_device_id oftable[] = {
    {
        .compatible = "hqyj,mywork",
    },
    {
        .compatible = "hqyj,mywork1",
    },
    {
        .compatible = "hqyj,mywork2",
    },
    {},
};

// 分配驱动信息对象并初始化
struct platform_driver pdrv1 = {
    .probe = pdrv_probe,
    .remove = pdrv_remove,
    .driver = {
        .name = "aaaaa",
        .of_match_table = oftable,
    },
};

// 一键注册宏
module_platform_driver(pdrv1);
MODULE_LICENSE("GPL");

应用代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc, char const *argv[])
{
    /* code */
    int fd;
    int status;

    if((fd=open("/dev/pdrv1",O_RDWR))==-1){
        perror("open error");
        return -1;
    }

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