字符设备驱动

一．       知识点

1.      设备号；

2.      创建设备文件；

3.      设备注册；

4.      重要数据结构；

5.      设备操作；

 

二．主设备号

字符设备通过字符设备文件来存取。字符设备文件由使用ls  -l 的输出的第一列的”C”标识；

如果使用ls –l 命令，会看到在设备文件项中有2个数（由一个逗号分隔）这些数字就是设备文件的主次设备编

举例：

crw-rw----  1 root uucp     4,  66 04-18 21:59 ttyS2

crw-rw----  1 root uucp     4,  67 04-18 21:59 ttyS3

crw-rw-rw-  1 root root     1,   9 04-18 22:00 urandom

crw-rw----  1 root root   249,   0 04-18 22:00 usbdev1.1_ep00

crw-rw----  1 root root   249,   1 04-18 22:00 usbdev1.1_ep81

crw-rw----  1 root root   249,   2 04-18 22:00 usbdev2.1_ep00

crw-rw----  1 root root   249,   3 04-18 22:00 usbdev2.1_ep81

crw-rw----  1 root root   251,   0 04-18 22:00 usbmon0

crw-rw----  1 root root   251,   1 04-18 22:00 usbmon1

crw-rw----  1 root root   251,   2 04-18 22:00 usbmon2

crw-rw----  1 vcsa tty      7,   0 04-18 22:00 vcs

crw-rw----  1 vcsa tty      7,   1 04-18 22:00 vcs1

crw-rw----  1 vcsa tty      7,   2 04-18 22:00 vcs2

crw-rw----  1 vcsa tty      7,   3 04-18 22:00 vcs3

crw-rw----  1 vcsa tty      7,   4 04-18 22:00 vcs4

 

设备号

设备号用来做什么？？

设备号的作用

 

1>.主设备号用来标识与设备文件相连的驱动程序。

次设备号被驱动程序用来辨别操作的是哪个设备。

 

*****主设备号用来反映设备类型******

***次设备号用来区分同类型的哪一个设备***

 

三．主次设备号

Q:内核中如何描述设备号？

A:dev_t

*****其实质为unsigned  int  32位整数，其中高12位为主设备号，低20位为次设备号。

 

Q：如何从dev_t中分解出主设备号？

A：MAJOR(dev_t  dev)

 

Q:如何从dev_t只分解出次设备号？

A：MINOR(dev_t dev)

 

四．分配主设备号

Linux 内核如何给设备分配主设备号？

可以采用静态申请，动态分配两种方法

（动态、静态是针对主设备号来说的）

 

静态申请

int  register_chrdev_region(dev_t from ,unsigned count ,const char *name)

 

功能：申请使用从from开始的count 个设备号（主设备号不变，次设备号增加）

参数：

From :希望申请使用的设备号数目

Count :希望申请使用的设备号数目

Name :设备名（体现在/proc/devices）

 

动态分配

 

方法：

使用alloc_chrdev_region分配设备号

 

优点：简单，易于驱动推广

缺点：无法在安装驱动前创建设备文件（因为安装前还没分配到主设备号。）

 

解决办法：

安装驱动后，从/proc/devices中查询设备号

 

动态分配

Int alloc_chrdev_region(dev_t *dev,  unsigned baseminor,  unsigned count,  const char *name)

功能：动态申请count个设备号，第1个设备号的次设备号为baseminor.

参数：

Dev:分配到的设备号

Baseminor :起始次设备号

Count :要注册的设备号个数

Name :设备名（体现在/proc/devices）

主设备号是动态产生的，次设备号（的第一个）是要指定的；

 

  五．注销设备号

       不论使用何种方法分配设备号，都应该在不再使用它们的时候释放这些设备号。

 

Void unregister_chrdev_region(dev_t  from,  unsigned count)

 功能：

释放从from 开始的count个设备号

 

六．创建设备文件

两种方法：1.使用mknod命令手工创建；

   2.自动创建

 

手工创建：

mknod用法：

mknod  filename type major minor

filename :设备文件名

type: 设备文件类型

major：主设备号

minor :次设备号

 

例如：mknod serial0  c  100  0

 

之后 ls  serial0  命令可查

不要0也可以，通过0知道是第几个设备

 

七．重要结构

在Linux 字符设备驱动程序设计中，有3种非常重要的数据结构：

1.      struct  file

2.      struct  inode

3.      struct  file_operations

 

Stuct  file 

代表一个开打的文件。系统中每一个打开的文件在内核空间都有一个关联的struct  file .  它由内核在打开文件时创建，在文件关闭后释放。

(一个文件被打开一次对应一个Struct  file，这个文件同时被打开10次，则对应10个Struct  file)

 

***重要成员

Loff_t  f_pos  /*文件读写位置*/

Struct  file_operations *f_op

 

struct  inode

用来记录文件的物理上的信息。因此，他和代表打开文件的file结构是不同的。

一个文件可以对应多个file结构，但只有一个inode结构。

 

***重要成员：

dev_t  i_rdev :设备号

 

struct  file_operations

一个函数指针的集合，定义能在设备上进行的操作。结构中成员指向驱动中的函数，这些函数实现一个特别的操作，对于不支持的操作保留为NULL

 

例：mem_fops

Struct file_operations mem_fops={

.owner = THIS_MODULE,

.llseek =mem_seek,

.read =mem_read,

.write = mem_ioctl,

.ioctl =mem_open,

.release =mem_release,

};

（左边红色为指针,右边为函数）

 

应用程序如何访问驱动程序？（read_write.c）

八．设备注册（分配）

在Linux 2.6内核中，字符设备使用struct cdev来描述。

 

字符设备的注册可分为如下3个步骤：

1.      分配cdev

2.      初始化cdev

3.      注册（添加）cdev

 

struct cdev的分配可以使用cdev_alloc函数来完成。

       Struct  cdev *cdev_alloc(void)

（去分配是因为我们想拿到一个cdev的结构，若是静态的直接定义一个变量，则不需要分配。例如：是整型指针需要分配空间，是一个整型变量则不需要分配空间）

 

struct cdev的初始化可以使用cdev_init函数来完成。

       Void  cdev_init(struct  cdev *cdev, const struct  file_operations *fops)

 

注意：第二个参数：file_operations *fops就把结构file_operations和驱动程序绑定起来了

参数：

Cdev:待初始化的cdev结构

fops :设备对应的操作函数集

 

struct cdev的注册使用cdev_add函数来完成。

        Int  cdev_add(struct cdev *p,  dev_t  dev,unsigned  count)

作用把struct cdev注册到内核里面去

参数：

p:待添加到内核的字符设备结构

dev:设备号

count :添加的设备个数

 

设备操作

§ int (*open)(struct  inode*, struct file*)

在设备文件上的第一个操作，并不要求驱动程序一定要实现这个方法。如果该项为NULL,设备的打开操作永远成功。

§void (*release)(struct inode*,struct file*)

当设备文件被关闭时调用这个操作。与open相仿，release也可以没有。

§ssize_t(*read)(struct file*,char_user*,size_t,loff_t*)

从设备中读取数据

§ ssize_t(*write)(struct file*,char_user*,size_t,loff_t*)

向设备中写数据

§unsigned int(*poll)(stuct file*,struct poll_table_struct*)

对应select系统调用

§int (*ioctl)(struct inode*, struct file*,unsigned int,unsigned long)

控制设备

§int (*mmap)(stuct file*,struct vm_area_struct*)

将设备映射到进程虚拟地址空间中

§off_t (*llseek)(struct file*, loff_t,int)

修改文件的当前读写位置，并将新位置作为返回值

 

Open方法

Open方法是驱动程序用来为以后的操作完成初始化准备工作的。在大部分驱动程序中，open完成如下工作：

1>.初始化设备；

2>.表明次设备号；

 

Release方法：

Release方法的作用正好与open相反，关闭设备作用；

 

读和写

读和写方法都完成类似工作：从设备中读取数据到用户空间；将数据给驱动程序。它的原型也相似：

Ssize_t xxx_read(struct  file *filp ,  char_user *buff,  size_t count,  loff_t *offp);

Ssize_t xxx_write(struct file *filp,  char_user *buff,  size_t count, loff_t *offp);

对于2个方法，filp是文件指针，count是请求传输的数据量。Buff参数指向数据缓存。最后，offp指向文件当前的访问位置。

 

读和写

Read和write方法的buff参数是用户空间指针。因此，它不能被内核代码直接引用，理由如下：

用户空间指针在内核空间时可能根本是无效的—没有那个地址映射。

 

因此：内核提供了专门的函数用于访问用户空间的指针,例如：

 

**int  copy_from_user(void *to,  const void_user *from,  int n)

***int  copy_to_user(void_user *to,  const  void *from,  int n)

 

应该从应用程序角度看待：

用户要去读这个设备，则数据从设备流向用户：copy_to_user

 

驱动程序

（目的：把内存的4k空间看出字符设备，编写字符设备驱动去操作这块内存）

#include <linux/module.h>

#include <linux/types.h>

#include <linux/fs.h>

#include <linux/errno.h>

#include <linux/mm.h>

#include <linux/sched.h>

#include <linux/init.h>

#include <linux/cdev.h>

#include <asm/io.h>

#include <asm/system.h>

#include <asm/uaccess.h>

 

#include "memdev.h"

 

static mem_major = MEMDEV_MAJOR;

module_param(mem_major, int, S_IRUGO);

struct mem_dev *mem_devp; /*设备结构体指针*/

struct cdev cdev;

 

/*文件打开函数*/

int mem_open(struct inode *inode, struct file *filp)

{

    struct mem_dev *dev;

    /*获取次设备号*/

    int num = MINOR(inode->i_rdev);//只有在open中能拿到inode提取num

    if (num >= MEMDEV_NR_DEVS)

            return -ENODEV;

    dev = &mem_devp[num];//只有在open中能拿到inode提取num,并将对应dev保存到filp->private_data   

    /*将设备描述结构指针赋值给文件私有数据指针*/

    filp->private_data = dev; 

    return 0;

}

 

/*文件释放函数*/

int mem_release(struct inode *inode, struct file *filp)

{

  return 0;

}

/*读函数*/

static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)

{

  unsigned long p =  *ppos;

  unsigned int count = size;

  int ret = 0;

  struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/

  /*判断读位置是否有效*/

  if (p >= MEMDEV_SIZE)//读的位置大于设备大小--无效

    return 0;

  if (count > MEMDEV_SIZE - p)//要读的大小>设备剩下的大小

    count = MEMDEV_SIZE - p;

  /*读数据到用户空间*/

  if (copy_to_user(buf, (void*)(dev->data + p), count))

  {

    ret =  - EFAULT;

  }

  else

  {

    *ppos += count;//读后，改写读指针位置

    ret = count;

   

    printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);

  }

  return ret;

}

 

/*写函数*/

static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)

{

  unsigned long p =  *ppos;

  unsigned int count = size;

  int ret = 0;

  struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/

 

  /*分析和获取有效的写长度*/

  if (p >= MEMDEV_SIZE)

    return 0;

  if (count > MEMDEV_SIZE - p)

    count = MEMDEV_SIZE - p;

  /*从用户空间写入数据*/

  if (copy_from_user(dev->data + p, buf, count))

    ret =  - EFAULT;

  else

  {

    *ppos += count;

    ret = count;

   

    printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);

  }

 

  return ret;

}

 

/* seek文件定位函数 */

static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)

{

    loff_t newpos;

 

    switch(whence) {

      case 0: /* SEEK_SET 文件头*/

        newpos = offset;

        break;

 

      case 1: /* SEEK_CUR 文件中*/

        newpos = filp->f_pos + offset;//filp->f_pos:当前位置

        break;

 

      case 2: /* SEEK_END 文件尾*/

        newpos = MEMDEV_SIZE -1 + offset;//MEMDEV_SIZE -1 ：从文件尾

        break;

 

      default: /* can't happen */

        return -EINVAL;

    }

    if ((newpos<0) || (newpos>MEMDEV_SIZE))//不合法的当前位置

           return -EINVAL;      

    filp->f_pos = newpos;

    return newpos;

}

 

/*文件操作结构体*/

static const struct file_operations mem_fops =

{

  .owner = THIS_MODULE,//

  .llseek = mem_llseek,

  .read = mem_read,

  .write = mem_write,

  .open = mem_open,//先分析open

  .release = mem_release,

};

 

/*设备驱动模块加载函数*/

static int memdev_init(void)

{

  int result;

  int i;

  /*利用主设备号、此设备号构造--设备号*/

  dev_t devno = MKDEV(mem_major, 0);//mem_major在.h头文件中为254

 

  /* 静态申请设备号*/

  if (mem_major)//当mem_major>0，则静态申请设备号

    result = register_chrdev_region(devno, 2, "memdev");

  else  /* mem_major<0,则动态分配设备号 */

  {

    result = alloc_chrdev_region(&devno, 0, 2, "memdev");//动态分配的设备号填到devno

    mem_major = MAJOR(devno);//把主设备号提取出来

  } 

  if (result < 0)

    return result;

  /*初始化cdev结构*/

  cdev_init(&cdev, &mem_fops);//因为cdev定义的是一个静态的结构，所以不需分配空间

  cdev.owner = THIS_MODULE;

  cdev.ops = &mem_fops;

  /* 注册字符设备 */

  cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);//MEMDEV_NR_DEVS:多少个设备

  /* 为设备描述结构分配内存（因为我们用内存模拟设备，操作设备就要操作这段内存）*/

  mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);

  if (!mem_devp)    /*申请失败*/

  {

    result =  - ENOMEM;

    goto fail_malloc;

  }

  memset(mem_devp, 0, sizeof(struct mem_dev));

  /*为设备分配内存*/

  for (i=0; i < MEMDEV_NR_DEVS; i++)

  {

        mem_devp[i].size = MEMDEV_SIZE;//MEMDEV_SIZE:4096 

        mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);

        memset(mem_devp[i].data, 0, MEMDEV_SIZE);

  }

  return 0;

  fail_malloc:

  unregister_chrdev_region(devno, 1);

  return result;

}

 

/*模块卸载函数*/

static void memdev_exit(void)

{

  cdev_del(&cdev);   /*注销设备*/

  kfree(mem_devp);     /*释放设备结构体内存*/

  unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/

}

MODULE_AUTHOR("David Xie");

MODULE_LICENSE("GPL")

module_init(memdev_init);

module_exit(memdev_exit);

 

测试程序：

#include <stdio.h>

int main()

{

       FILE *fp0 = NULL;

       char Buf[4096];    

       /*初始化Buf*/

       strcpy(Buf,"Mem is char dev!");

       printf("BUF: %s\n",Buf);

       /*打开设备文件*/

       fp0 = fopen("/dev/memdev0","r+");

       if (fp0 == NULL)

       {

              printf("Open Memdev0 Error!\n");

              return -1;

       }

       /*写入设备*/

       fwrite(Buf, sizeof(Buf), 1, fp0);

   

       /*（思考没有该指令，会有何后果)？*/

       //答：因为前面假如写了8个字节，指针就会停在8个字节处，如果要读的话，指针就从8个字节以后开始读，

       //这样就读不到东西，因为8个字节后没写东西

       /*重新定位文件位置*/

       fseek(fp0,0,SEEK_SET);

       /*清除Buf*/

       strcpy(Buf,"Buf is NULL!");

       printf("BUF: %s\n",Buf);

      

         /*读出设备*/

       fread(Buf, sizeof(Buf), 1, fp0);

      

       /*检测结果*/

       printf("BUF: %s\n",Buf);

        return 0; 

}

 

(简单字符设备驱动实例分析)

思路：

1.      拿到主设备号；

2.      初始化cdev=结构；

3.      注册cdev结构（实际上是注册驱动程序）

4.      最后有一些额外的工作是分配内存；

 

分析一个字符设备程序：

（分析一个字符设备的过程实际也就是实现字符设备的过程）

第一步，分析它的初始化函数；

第二步，分析 file_operation ，找到file_operation当中的函数指针；

（而分析file_operation 需要先分析open函数）