一个驱动程序对应多个设备

最新推荐文章于 2023-10-29 22:53:08 发布

qqliyunpeng

最新推荐文章于 2023-10-29 22:53:08 发布

阅读量7.2k

点赞数 7

分类专栏： linux驱动文章标签：字符驱动 linux 多设备

本文链接：https://blog.csdn.net/qqliyunpeng/article/details/52387525

版权

linux驱动专栏收录该内容

41 篇文章 7 订阅

订阅专栏

1. 对于驱动程序中有两个关键的结构体：

struct file *filp：

有一个关键的成员 -> void *private_data，用于存放用于私人的数据

inode：

有一个关键的成员 -> unsigned int i_flags

2. 一个驱动多个设备的程序思路：

1个驱动程序，

1个struct file_operations 结构体

2个用户结构体数据(包含 struct cdev 结构体)

在 struct file_operation 结构体的 open 方法中根据 inode 结构体中的 i_cdev 成员找到包含 cdev 的整个结构体，从而能在read/write中能够操作这个结构体的其他成员，具体如下：

在 open 中将得到的 cdev 通过 struct file 结构体中的private_data 传递给 read/write 方法：

filp->private_data = dev;

当然设备号和设备节点都是两个，通过访问不同的 /dev 下的设备，访问不同的用户数据

3. 程序：

char_multi_dev.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>
#include <linux/device.h>

MODULE_LICENSE ("GPL");

int hello_major       = 250;
int hello_minor       = 0;
int number_of_devices = 2;
struct class *my_class;

struct hello_device
{
    char data[128];
    struct cdev cdev;

} hello_device[2];


static int hello_open (struct inode *inode, struct file *filp)
{
    struct hello_device *dev = container_of(inode->i_cdev, struct hello_device, cdev); 

    filp->private_data = dev;
    printk (KERN_INFO "Hey! device opened\n");

    return 0;
}

static int hello_release (struct inode *inode, struct file *filp)
{
    printk (KERN_INFO "Hmmm... device closed\n");

    return 0;
}

ssize_t hello_read (struct file *filp, char *buff, size_t count, loff_t *offp)
{
    ssize_t result = 0;
    struct hello_device *dev = filp->private_data;

    if (count < 0) return -EINVAL;
    if (count > 127) count = 127;
    if (copy_to_user (buff, dev->data, count)) 
    {
        result = -EFAULT;
    }
    else
    {
        printk (KERN_INFO "wrote %d bytes\n", (int)count);
        result = count;
    }

    return result;
}

/*
 *ssize_t hello_write (struct file *filp, const char  *buf, size_t count,
 *        loff_t *f_pos)
 *{
 *    ssize_t ret = 0;
 *
 *    printk (KERN_INFO "Writing %d bytes\n", count);
 *    if (count > 127) return -ENOMEM;
 *    if (count < 0) return -EINVAL;
 *    if (copy_from_user (data, buf, count)) {
 *        ret = -EFAULT;
 *    }
 *    else {
 *        data[count] = '\0';
 *        printk (KERN_INFO"Received: %s\n", data);
 *        ret = count;
 *    }
 *
 *    return ret;
 *}
 */


struct file_operations hello_fops = {
    .owner = THIS_MODULE,
    .open  = hello_open,
    .release = hello_release,
    .read  = hello_read,
    /*  .write = hello_write */
};

static void char_reg_setup_cdev (struct cdev *cdev, dev_t devno)
{
    int error;

    cdev_init (cdev, &hello_fops);
    cdev->owner = THIS_MODULE;
    error = cdev_add (cdev, devno , 1);
    if (error)
        printk (KERN_NOTICE "Error %d adding char_reg_setup_cdev", error);
}

static int __init hello_2_init (void)
{
    int result;
    dev_t devno;

    devno = MKDEV (hello_major, hello_minor);
    result = register_chrdev_region (devno, number_of_devices, "hello_multi");

    if (result < 0) {
        printk (KERN_WARNING "hello: can't get major number %d\n", hello_major);
        return result;
    }
    my_class = class_create(THIS_MODULE,"multi_dev_class");
    if(IS_ERR(my_class)) 
    {
        printk("Err: failed in creating class.\n");
        return -1; 
    }
    device_create(my_class,NULL, devno, NULL, "multi_dev0");
    device_create(my_class,NULL, devno + 1, NULL, "multi_dev1");

    char_reg_setup_cdev (&hello_device[0].cdev, devno);
    char_reg_setup_cdev (&hello_device[1].cdev, devno+1);
    printk (KERN_INFO "char device registered\n");
    strcpy(hello_device[0].data, "0000000000000000000");
    strcpy(hello_device[1].data, "1111111111111111111");

    return 0;
}

static void __exit hello_2_exit (void)
{
    dev_t devno = MKDEV (hello_major, hello_minor);

    cdev_del (&hello_device[0].cdev);
    cdev_del (&hello_device[1].cdev);

    device_destroy(my_class, devno);         // delete device node under /dev//必须先删除设备，再删除class类
    device_destroy(my_class, devno + 1);     // delete device node under /dev//必须先删除设备，再删除class类
    class_destroy(my_class);                 // delete class created by us
    unregister_chrdev_region (devno, number_of_devices);
    printk("char device exited\n");
}

module_init (hello_2_init);
module_exit (hello_2_exit);

关键点是 96行和 98行

对 container_of 函数的理解请看： http://blog.csdn.net/boygrass/article/details/9962161?locationNum=1

Makefile

ifeq ($(KERNELRELEASE),)

KERNELDIR ?= /lib/modules/$(shell uname -r)/build 
#KERNELDIR ?= ~/wor_lip/linux-3.4.112
PWD := $(shell pwd)

modules:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules

modules_install:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules_install

clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions modules* Module*

.PHONY: modules modules_install clean

else
    obj-m := char_multi_dev.o
endif

test.c

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

int main (void) 
{
    int fd1, fd2;
    char buf[64];

    if ((fd1 = open ("/dev/multi_dev0",O_RDONLY)) < 0)
    {
        perror("fail to open");
        return -1;
    }
    if ((fd2 = open ("/dev/multi_dev1",O_RDONLY)) < 0)
    {
        perror("fail to open");
        return -1;
    }

    read(fd1, buf, 64);
    printf("read from device0 : %s\n", buf);
    read(fd2, buf, 64);
    printf("read from device1 : %s\n", buf);

    return 0;
}

结果：

> sudo insmod char_multi_dev.ko

>sudo ./a.out

read from device0 : 0000000000000000000

read from device1 : 1111111111111111111

>sudo rmmod char_multi_dev

>dmesg

[11074.012373] char device registered

[11087.349961] Hey! device opened

[11087.349965] Hey! device opened

[11087.349967] wrote 64 bytes

[11087.350021] wrote 64 bytes