字符设备驱动

主次设备号

字符设备通过字符设备文件来存取。字符设备文件由使用ls -l 的输出的第一列的“c”标识。如果使用ls -l 命令, 会看到在设备文件项中有2 个数(由一个逗号分隔) 这些数字就是设备文件的主次设备编号。

主设备号用来标识与设备文件相连的驱动程序。次编号被驱动程序用来辨别操作的是哪个设备。主设备号用来反映设备类型，次设备号用来区分同类型的设备

 

内核中dev_t描述设备号

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

MAJOR(dev_t dev)              从dev_t中分解出主设备号

MINOR(dev_t dev)              从dev_t中分解出次设备号

 

分配主设备号：Linux内核可以采用静态申请，动态申请两种方法给设备分配主设备号

 

静态申请

方法：

1、根据Documentation/devices.txt，确定一个没有使用的主设备号

2、使用register_chrdev_region 函数注册设备号

优点：简单

缺点：一旦驱动被广泛使用, 这个随机选定的主设备号可能会导致设备号冲突，而使驱动程序无法注册。

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

功能：注册从from 开始的count 个设备号(主设备号不变，次设备号增加，如果次设备号溢出，主设备号加1）

参数：

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个设备号

 

创建设备文件2种方法：

1. 使用mknod 命令手工创建

2. 自动创建

 

mknod 用法：mknod filename type major minor

filename:设备文件名

type: 设备文件类型

major: 主设备号

minor: 次设备号

例： mknod serial0 c 100 0

 

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

Struct file              Struct inode           Struct file_operations

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

Struct Inode：用来记录文件的物理上的信息。因此, 它和代表打开文件的file结构是不同的。一个文件可以对应多个file结构, 但只有一个inode 结构。

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

例：mem_fops

struct file_operations mem_fops = {

.owner = THIS_MODULE,

.llseek = mem_seek,

.read = mem_read,

.write = mem_write,

.ioctl = mem_ioctl,

.open = mem_open,

.release = mem_release,

};

 

设备注册

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

1. 分配cdev

2. 初始化cdev

3. 添加cdev

Struct cdev的分配可使用cdev_alloc函数来完成：struct cdev *cdev_alloc(void)

Struct cdev的初始化使用cdev_init函数来完成。

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

参数：

cdev: 待初始化的cdev结构

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

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

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

参数：

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 *, const char __user *, size_t, loff_t *) 向设备发送数据。

unsigned int (*poll) (struct file *, struct poll_table_struct *)    对应select系统调用

int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long)   控制设备

int (*mmap) (struct file *, struct vm_area_struct *)    将设备映射到进程虚拟地址空间中。

off_t (*llseek) (struct file *, loff_t, int)        修改文件的当前读写位置，并将新位置作为返回值。

 

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

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

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

 

设备注消

字符设备的注销使用cdev_del函数来完成。

int cdev_del(struct cdev *p)

参数：

p: 要注销的字符设备结构

 

实例：字符设备驱动程序memdev.c

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

 

#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);

 

    if (num >= MEMDEV_NR_DEVS)

            return -ENODEV;

    dev = &mem_devp[num];

   

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

    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;

        break;

 

      case 2: /* SEEK_END */

        newpos = MEMDEV_SIZE -1 + offset;

        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,

  .release = mem_release,

};

 

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

static int memdev_init(void)

{

  int result;

  int i;

 

  dev_t devno = MKDEV(mem_major, 0);

 

  /* 静态申请设备号*/

  if (mem_major)

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

  else  /* 动态分配设备号*/

  {

    result = alloc_chrdev_region(&devno, 0, 2, "memdev");

    mem_major = MAJOR(devno);

  } 

 

  if (result < 0)

    return result;

 

  /*初始化cdev结构*/

  cdev_init(&cdev, &mem_fops);

  cdev.owner = THIS_MODULE;

  cdev.ops = &mem_fops;

 

  /* 注册字符设备*/

  cdev_add(&cdev, MKDEV(mem_major, 0), 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;

        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_init(memdev_init);

module_exit(memdev_exit);

MODULE_LICENSE("GPL");

 

课件：    字符设备驱动.pdf   

完整源代码： 字符设备驱动程序.rar   

注意：运行设备文件时需手动创建设备文件