树莓派添加驱动程序（三）

https://blog.csdn.net/xiaodingqq/article/details/80415082

一、内容介绍

在驱动层添加一个虚拟键盘驱动程序（cc-vkeyboard），该驱动是一个字符设备+输入子系统的组合，主要功能：

1. 接收write操作用户发送的内容
2. 以键盘按键方式写入用户子系统

二、驱动层实现

vkeyboard.c

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/fcntl.h>
#include <linux/aio.h>
#include <asm/uaccess.h>
#include <linux/ioctl.h>
#include <linux/cdev.h>
#include <linux/input.h>
#include <linux/uaccess.h>
#define DRVNAME "cc-vkeyboard"
#define DEVNAME "cc_vkeyboard"
int major = 0;
struct keyboard_event
{
    int press;
    int key;
};
static struct input_dev *vkeyboard_input_dev = NULL;
static struct class *fir_driv_class;
static int vkeyboard_open(struct inode* inode, struct file* filp)
{
    return 0;
}
static int vkeyboard_release(struct inode* inode, struct file* filp)
{
    return 0;
}
static ssize_t vkeyboard_read(struct file* filp, char __user *buf, size_t count, loff_t* f_pos)
{
    printk(KERN_INFO"%s\n", __func__);
    return count;
}
static ssize_t vkeyboard_write(struct file* filp, const char __user * buf, size_t count, loff_t* f_pos)
{
    int ret = 0;
    struct keyboard_event event;
    while(ret < count)
    {
        if(copy_from_user(&event, buf + ret, sizeof(event)))
        {
            return -EFAULT;
        }
        ret += sizeof(event);
        input_event(vkeyboard_input_dev, EV_MSC, MSC_SCAN, event.key);
        input_report_key(vkeyboard_input_dev, event.key, event.press);
        input_sync (vkeyboard_input_dev);
        printk(KERN_INFO"%s p=%d key=%d with scan code\n", __func__, event.press, event.key);
    }
    return ret;
}
static struct file_operations vkeyboard_fops =
{
    .owner = THIS_MODULE,
    .open = vkeyboard_open,
    .release = vkeyboard_release,
    .read = vkeyboard_read,
    .write = vkeyboard_write,
};
static int vkeyboard_input_dev_open(struct input_dev* idev)
{
    printk(KERN_INFO"%s\n", __func__);
    return 0;
}
static void vkeyboard_input_dev_close(struct input_dev* idev)
{
    printk(KERN_INFO"%s\n", __func__);
    return;
}
static int vkeyboard_input_dev_setup(void)
{
    int ret = 0;
    vkeyboard_input_dev = input_allocate_device();
    if(vkeyboard_input_dev == NULL)
    {
        return -ENOMEM;
    }
    set_bit(EV_KEY, vkeyboard_input_dev->evbit);
    set_bit(EV_REP, vkeyboard_input_dev->evbit);//设置可以产生重复类事件
    //KEY_MAX是多个值，不能使用set_bit,可以使用bitmap_fill
    //set_bit(KEY_MAX, vkeyboard_input_dev->keybit);
    bitmap_fill(vkeyboard_input_dev->keybit, KEY_MAX);
    vkeyboard_input_dev->name = "vkeyboard";
    vkeyboard_input_dev->phys = "vkeyboard/input0";
    vkeyboard_input_dev->open = vkeyboard_input_dev_open;
    vkeyboard_input_dev->close = vkeyboard_input_dev_close;
#if 0
    //bitmap_fill(vkeyboard_input_dev->relbit, REL_MAX);
    //bitmap_fill(vkeyboard_input_dev->absbit, ABS_MAX);
    int i = 0;
    for(i = 32; i < KEY_MAX; i++)
    {
        input_set_capability(vkeyboard_input_dev, EV_KEY, i);
    }
    __set_bit(EV_KEY, vkeyboard_input_dev->evbit);
#endif
    ret = input_register_device(vkeyboard_input_dev);
    return ret;
}
static int __init vkeyboard_init(void)
{
    //注册字符设备驱动
    major = register_chrdev(0, DRVNAME, &vkeyboard_fops);
    //注册输入子系统设备
    vkeyboard_input_dev_setup();
     //新建类
    fir_driv_class = class_create(THIS_MODULE, DRVNAME);
    if(IS_ERR(fir_driv_class))
    {
        return PTR_ERR(fir_driv_class);
    }
    //创建设备 /dev/fir_dev
    device_create(fir_driv_class,NULL,MKDEV(major, 0),NULL,DEVNAME);
    printk(KERN_INFO"%s,%d\n", __func__,major);
    return 0;
}
static void __exit vkeyboard_cleanup(void)
{
    //删除设备结点
    device_destroy(fir_driv_class,MKDEV(major, 0));
    class_destroy(fir_driv_class);
    input_unregister_device(vkeyboard_input_dev);
    input_free_device(vkeyboard_input_dev);
    unregister_chrdev(major, DRVNAME);
    return;
}
module_init(vkeyboard_init);
module_exit(vkeyboard_cleanup);
module_param(major, int, 0);
MODULE_AUTHOR("zhangsan");
MODULE_LICENSE("GPL");

makefile

ifeq ($(KERNELRELEASE),)
    KERNELDIR := /home/pi/linux-rpi-4.19.y-x86
    KERNELDIR := /lib/modules/`uname -r`/build
    PWD := $(shell pwd)
    ARCH = x86
    CROSS_COMPILE =
modules:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE)
modules_install:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE)
clean:
    rm -rf *.o *~core.depend .*.cmd *.mod.c *.tmp_version *.order *.symvers
else
    obj-m := vkeyboard.o
endif

将驱动添加到内核:

sudo insmod vkeyboard.ko

结果如下：

1. 自动生成设备文件： /dev/cc_vkeyboard
2. 自动生成输入子系统文件： /dev/input/eventx

三、驱动测试

#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#include <linux/input.h>

#define DEVICE_NAME "/dev/cc_vkeyboard"

struct keyboard_event
{
    int press;
    int key;
};

int main(void)
{
    struct keyboard_event event;
    int fd, i = 0, j = 50;

    event.key = KEY_A;
    fd=open(DEVICE_NAME,O_RDWR|O_NDELAY);
    if(fd<0)
    {
        perror("open error");
        exit(-1);
    }
    while(j--)
    {
        event.press=1;
        write(fd,&event,sizeof(event));
        event.press=0;
        write(fd,&event,sizeof(event));
        sleep(1);

        printf("%d \n",i++);
    }
    close(fd);
    return 0;
}