ARM Linux字符设备驱动程序

浏览数：288 / 时间：2015年06月20日

1、主设备号和次设备号（二者一起为设备号）：
　　一个字符设备或块设备都有一个主设备号和一个次设备号。主设备号用来标识与设备文件相连的驱动程序，用来反映设备类型。次设备号被驱动程序用来辨别操作的是哪个设备，用来区分同类型的设备。
　　linux内核中，设备号用dev_t来描述，2.6.28中定义如下：
　　typedef u_long dev_t;

　　在32位机中是4个字节，高12位表示主设备号，低12位表示次设备号。

可以使用下列宏从dev_t中获得主次设备号：　　　　　　　　　　　　　　　　　　

也可以使用下列宏通过主次设备号生成dev_t:
MAJOR(dev_t dev);

MKDEV(int major,int minor);

MINOR(dev_t dev);

//宏定义：
#define MINORBITS    20
#define MINORMASK    ((1U << MINORBITS) - 1)  //1U后面的U表示1是unsigned int (如果是在VS编译器下的话，就是32位)，把1U左移（<<，这是位运算符号，按位左移）20位就相当于1 * 2^20，然后-1，也就是mask替代了（2^20-1）。
                                              //得到的结果就是高12位全为0,低20位全为1
#define MAJOR(dev)    ((unsigned int) ((dev) >> MINORBITS))
#define MINOR(dev)    ((unsigned int) ((dev) & MINORMASK))
#define MKDEV(ma,mi)    (((ma) << MINORBITS) | (mi))

2.分配设备号（两种方法）

（1静态申请

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

(2)动态分配

int alloc_chardev_region(dev_t *dev,unsigned baseminor,unsigned count,const char *name);

注销设备号：

void unregister_chrdev_region(dev_t from, unsigned count)；

创建设备文件：

利用cat /proc/devices查看申请到的设备名，设备号。

（1）使用mknod手工创建：mknod filename type major minor

(2) 自动创建：

利用udev(mdev)来实现设备文件的自动创建，首先应保证支持udev(mdev),由busybox

配置，在驱动初始化代码里调用class_create为该设备创建一个class,再为每个设备调用device_create

创建对应的设备。

3、字符设备驱动程序重要的数据结构：
（1）struct file：

代表一个打开的文件描述符，系统中每一个打开的文件在内核中都有一个关联的struct file。它由内核在open时创建，并传递给在文件上操作的任何函数，直到最后关闭。当文件的所有实例都关闭之后，内核释放这个数据结构。

//重要成员

const struct file_operations *f_op; //该操作是定义文件关联操作的。内核在执行open时对这个指针赋值。

off_t f_pos; //该文件读写位置。

void *private_data; //该成员是系统调用时保存状态信息非常有用的资源。

2）struct inode:

用来记录文件的物理信息。它和代表打开的file结构是不同的。一个文件可以对应多个file结构，但只有一个inode结构。inode一般作为file_operations结构中函数的参数传递过来。
　　inode译成中文就是索引节点。每个存储设备或存储设备的分区（存储设备是硬盘、软盘、U盘 ... ... ）被格式化为文件系统后，应该有两部份，一部份是inode，另一部份是Block，Block是用来存储数据用的。而inode呢，就是用来存储这些数据的信息，这些信息包括文件大小、属主、归属的用户组、读写权限等。inode为每个文件进行信息索引，所以就有了inode的数值。操作系统根据指令，能通过inode值最快的找到相对应的文件。

dev_t i_rdev; //对表示设备文件的inode结构，该字段包含了真正的设备编号。

struct cdev *i_cdev; //是表示字符设备的内核的内部结构，当inode指向一个字符设备文件时，该字段包含了指向struct_cdev结构的指针。

我们也可以使用下边两个宏从inode中获得主设备号和次设备号

unsigned int iminor(struct inode *inode);

unsigned int imajor(struct inode *inode);

（3）struct file_operations

struct file_operation ***_ops={

.owner=THIS_MODULE,

.llseek=***_llseek,

.read=***_read,

.write=***_write,

.ioctl=***_ioctl,

.open=***_open,

.release=***_release,

.....

}; //strude file_operations 是一个函数指针的集合

struct module *owner;

字符设备驱动程序注意事项

1）open()调用可能由于几个原因而失败。

（2）成功运行的read()和write()返回的字节数可能是1至请求的字节数之间的任意值，因此应用程序必须能处理这些情况。

（3）即使1字节的数据读或写就绪，select()也会返回成功。

（4）很多字符驱动程序方法是可选的，并不是所有的方法都提供。

另外，字符驱动程序不仅在drivers/char/目录下。下面是一些“超级”字符驱动程序：

（1）串行驱动程序，放在drivers/serial/目录下。

（2）输入驱动程序，放在drivers/input/目录下。

（3）帧缓存区(/dev/fb/*)提供对显存的访问，/dev/mem提供对系统内存的访问途径。

（4）一些设备类支持少量采用字符接口的硬件。

（5）一些子系统提供额外的字符接口，以向用户空间提供原始的设备模型。例如MTD子系统。

（6）一些内核层提供钩子，通过导出相应的字符接口实现用户空间的设备驱动程序。例如ioctl。

在drivers/目录下的register_chrdev上运行grep-r可了解内核中字符驱动程序的大致情况。

设备驱动程序是内核的一部分，它完成以下的功能

1、对设备初始化和释放；

（1）字符设备cdev结构体初始化：

***********不是每个字符设备驱动都需要，cdev是为了构建设备模型，便于设备文件的管理所产生的。如果你的字符设备比较简单或者你不需要构建设备模型，是可以不需要cdev.
file_operation结构是虚拟层上的东西，这样使得驱动程序可以操作设备。*******************

           内核中每个字符设备都对应一个 cdev 结构的变量，下面是它的定义： linux-2.6.22/include/linux/cdev.h
struct cdev {
   struct kobject kobj;          // 每个 cdev 都是一个 kobject
   struct module *owner;       // 指向实现驱动的模块
   const struct file_operations *ops;   // 操纵这个字符设备文件的方法
   struct list_head list;       // 与 cdev 对应的字符设备文件的 inode->i_devices 的链表头
   dev_t dev;                   // 起始设备编号
   unsigned int count;       // 设备范围号大小
};

静态内存定义初始化：
                        struct cdev my_cdev;
                        cdev_init(&my_cdev, &fops);
                        my_cdev.owner = THIS_MODULE;

void cdev_init(struct cdev *cdev, const struct file_operations *fops)
                        {
   memset(cdev, 0, sizeof *cdev);
   INIT_LIST_HEAD(&cdev->list);
   kobject_init(&cdev->kobj, &ktype_cdev_default);
   cdev->ops = fops;
}

        动态内存定义初始化：
                        struct cdev *my_cdev = cdev_alloc();
                    my_cdev->ops = &fops;
                        my_cdev->owner = THIS_MODULE;

                        struct cdev *cdev_alloc(void)
                        {
   struct cdev *p = kzalloc(sizeof(struct cdev), GFP_KERNEL);
   if (p) {
                                 INIT_LIST_HEAD(&p->list);
       kobject_init(&p->kobj, &ktype_cdev_dynamic);
}
   return p;
                        }

由此可见，两个函数完成都功能基本一致，只是 cdev_init() 还多赋了一个 cdev->ops 的值。

      初始化 cdev 后，需要把它添加到系统中去。为此可以调用 cdev_add() 函数。传入 cdev 结构的指针，起始设备编号，以及设备编号范围。
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
   p->dev = dev;
   p->count = count;
   return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
}
关于 kobj_map() 函数就不展开了，我只是大致讲一下它的原理。内核中所有都字符设备都会记录在一个 kobj_map 结构的 cdev_map 变量中。这个结构的变量中包含一个散列表用来快速存取所有的对象。kobj_map() 函数就是用来把字符设备编号和 cdev 结构变量一起保存到 cdev_map 这个散列表里。当后续要打开一个字符设备文件时，通过调用 kobj_lookup() 函数，根据设备编号就可以找到 cdev 结构变量，从而取出其中的 ops 字段。
当一个字符设备驱动不再需要的时候（比如模块卸载），就可以用 cdev_del() 函数来释放 cdev 占用的内存。
void cdev_del(struct cdev *p)
{
   cdev_unmap(p->dev, p->count);
   kobject_put(&p->kobj);
}
其中 cdev_unmap() 调用 kobj_unmap() 来释放 cdev_map 散列表中的对象。kobject_put() 释放 cdev 结构本身。

下面这个是必须要有的：

设备初始化

static int first_drv_init(void)
{
   major=register_chrdev(0,"first_drv",&first_drv_fops); //注册，告诉内核。
   firstdrv_class=class_create(THIS_MODULE,"firstdrv");   //创建一个类
   if(IS_ERR(firstdrv_class))
   return PTR_ERR(firstdrv_class);

   firstdrv_class_dev=class_device_create(firstdrv_class,NULL,MKDEV(major,0),NULL,"xyz");//xyz为设备名字
   gpfcon=(volatile unsigned long *)ioremap(0x56000050,16);
   gpfdat=gpfcon+1;
   if(unlikely(IS_ERR(firstdrv_class_dev)))
   return PTR_ERR(firstdev_class_drv);
   return 0;
}

设备卸载
static vodi first_drv_exit(void)
{
   unregister_chrdev(major,"first_drv");//卸载
   class_device_unregister(firstdrv_class_dev);
   class_destroy(firstdrv_class);
   iounremap();
}

　　2、把数据从内核传送到硬件（copy_to_user)和从硬件读取数据(copy_form_user)；

结构体file_operations在头文件 linux/fs.h中定义，用来存储驱动内核模块提供的对设备进行各种操作的函数的指针。该结构体的每个域都对应着驱动内核模块用来处理某个被请求的事务的函数的地址。

fileoprations结构体上定义的函数进行具体的数据操作。

static struct file_operations second_drv fops={
        .owner=THIS_MODULE;
        .write=second_drv_write;
        .open=second_drv_open;
        .read=second_drv_read;
        }

      int major;

static int first_drv_open(struct inode *inode,struct file *file)
    {
     gpfcon &= ~((0x3<<(4*2))|(0x3<<(5*2))|(0x3<<(6*2)));    //GPF4,5,6为输出
     gpfcon |= ((0x1<<(4*2))|(0x1<<(5*2))|(0x1<<(6*2)));    //

     return 0;
    }

static ssize_t first_drv_read(struct inode *inode,struct file *file)
    {

      return 0;
    }

    static ssize_t first_drv_write(struct file *file,const char _user *buf,size_t count,loff_t *ppos)
    {
      int val;
      copy_from_user(&val,buf,count);
      if(val==1)
      {
         gpfdata|=((1<<4)|(1<<5)|(1<<6));          //点灯
      }
      else
      {
         gpfdata &=~ ((1<<4)|(1<<5)|(1<<6));                 //灭灯
      }
      return 0;
    }

测试程序：
int main()
     {
        int fd;
        int val=1;
        fd=open(("/dev/xyz",O_RDWR);
         if(fd<0)
         {
          printf("cant‘t open");
         }
         if(argc！=2）
         {
           printf("Usage:\n");
           printf("%s<on|off>\n",argv[0]);//<>表示参数不可以省略，|表示或者的意思/
         }
         if(strcmp(argc[1],on)==0）   //如果第二个参数等于on的话
         {
           val=1;
         }
         else
         {
         val=0;
         }
        write(fd,&val,4);
        return 0;
      }

      写驱动程序的时候要：1.写框架。2.看原理图 3.看手册 3.写代码（在驱动程序中，不能直接使用物理地址，要ioremap，使用虚拟地址）
   主设备号作用是找到fileoperations。次设备号是留给我们自己用的。
   int minor=MINOR(inode->i_rdev);次设备号代表的意思有我们自己决定。

　　3、读取应用程序传送给设备文件的数据和回送应用程序请求的数据；

应用程序、库、内核、驱动程序的关系

1)应用程序调用一系列函数库，通过对文件的操作完成一系列功能：

应用程序以文件形式访问各种硬件设备（linux特有的抽象方式，把所有的硬件访问抽象为对文件的读写、设置）

函数库：

部分函数无需内核的支持，由库函数内部通过代码实现，直接完成功能

部分函数涉及到硬件操作或内核的支持，由内核完成对应功能，我们称其为系统调用

2)内核处理系统调用，根据设备文件类型、主设备号、从设备号（后面会讲解），调用设备驱动程序；

3)设备驱动直接与硬件通信；