ARM學習筆記之驅動程序篇七----字符設備驅動

1.11 字符設備驅動模型

在任何一種驅動模型中，設備都會用內核中的一種結構來描述。字符設備在內核中使用struct cdev來描述。

struct cdev{
    struct kobject kobj;
    struct module *owner;
    const struct file_operations *ops;//設備操作函數集
    struct list_head list;
    dev_t dev;//設備號
    unsigned int count;//設備數
};

字符設備驅動模型的整體框架：

                    

1.11.1 設備號

1，主設備號和次設備號

字符設備文件與字符驅動程序通過主設備號建立起對應關係；驅動程序通過次設備號區分同類型的設備。

2，分配設備號

（1）靜態申請

開發者自己選擇一個數字作爲主設備號，然後通過函數register_chrdev_region向內核申請使用。缺點：如果申請使用的設備號已經被內核中的其他驅動使用了，則申請失敗。

int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count,const char*name)
//參數
//dev:存放分配的設備號
//baseminor：次設備號的起始值
//count:設備數
//name:設備名

（2）動態申請

使用alloc_chrdev_region由內核分配一個可用的主設備號。優點：因爲內核知道哪些號已經被使用了，所以不會導致分配到已經被使用的號。

int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count,const char *name)
//參數:
//dev:設備號
//baseminor:次設備起始值
//count:設備數
//name:設備名

3，操作設備號

linux內核中使用dev_t類型來定義設備號，dev_t這種類型其實質爲32位的unsigned int ,其中高12位爲主設備號，低20位次設備號。

（1）由主設備號和次設備號組合成dev_t（類型）

dev_t dev=MKDEV(主設備號，次設備號)

（2）從dev_t中分解出主設備號

主設備號=MAJOR（dev_t dev）

（3）從dev_t中分解出次設備號

次設備號=MINOR(dev_t dev)

4，註銷設備號

不論使用什麼方法分配設備號，都應該在驅動退出時，使用unregister_chrdev_region函數釋放這些設備號。

1.11.2 操作函數集

struct file_operations是一個函數指針的集合，定義能在設備上進行的操作。

struct file_operations{
    struct module *owner;
	loff_t (*llseek) (struct file *, loff_t, int);
	ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
	ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
	ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
	int (*readdir) (struct file *, void *, filldir_t);
	unsigned int (*poll) (struct file *, struct poll_table_struct *);
    long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
	long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
	int (*mmap) (struct file *, struct vm_area_struct *);
	int (*open) (struct inode *, struct file *);
	int (*flush) (struct file *, fl_owner_t id);
	int (*release) (struct inode *, struct file *);
	int (*fsync) (struct file *, int datasync);
	int (*aio_fsync) (struct kiocb *, int datasync);
	int (*fasync) (int, struct file *, int);
	int (*lock) (struct file *, int, struct file_lock *);
	ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
	unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long,             
unsigned long, unsigned long);
	int (*check_flags)(int);
	int (*flock) (struct file *, int, struct file_lock *);
	ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
	ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
	int (*setlease)(struct file *, long, struct file_lock **);
	long (*fallocate)(struct file *file, int mode, loff_t offset, loff_t len);
};

結構中的函數指針指向驅動程序中的函數，這些函數實現一個針對設備的操作，對於不支持的操作則設置函數指針爲NULL。例如

struct file_operation dev_fops={
    .llseek=NULL,
    .read=dev_read,
    .write=dev_write,
    .ioctl=dev_ioctl,
    .open=dev_open,
    .release=dev_release,
};

1.11.3 字符設備初始化

1，分配描述結構cdev

（1）靜態分配

struct cdev mdev;//直接定義一個struct cdev類型的變量。

（2）動態分配

struct cdev *pdev=cdev_alloc();//使用cdev_alloc()動態分配

2，初始化描述結構 cdev

struct cdv的初始化使用cdev_init函數來完成。

cdev_init(struct cdev *cdev,const struct file_opertations *fops)
//參數:
//cdev:待初始化的cdev結構 ; fops:設備對應的操作函數集

3，註冊描述結構cdev

字符設備的註冊使用cdev_add函數來完成。

cdev_add(struct cdev*p,dev_t dev,unsigned count)
//參數:
//p:待添加到內核的字符設備結構
//dev:設備號
//count:該類設備的設備個數

 1.11.4 實現設備操作

struct file:在linux系統中，每一個打開的文件，在內核中都會關聯一個struct file，它由內核在打開文件時創建，在文件關閉後釋放。

loff_t f_pos;//文件讀寫指針
struct file_operation *f_op;//該文件所對應的操作

struct inode:每一個存在於文件系統裏面的文件都會關聯一個inode結構，該結構主要用來記錄文件物理上的信息。因此，它和代表打開文件的file結構是不同的。一個文件沒有被打開時不會關聯file結構，但是卻會關聯一個inode結構。

dev_t i_rdev;//設備號

注意：（1）從應用程序提供的地址中取出數據；（2）將數據寫入設備中；

要使用專門的函數：（1）int copy_from_user(void *to,const void __user *from,int n)

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

1.11.5 驅動註銷

當我們從內核中卸載驅動程序時候，需要使用cdev_del函數來完成字符設備的註銷

1.11.6 使用字符驅動程序

1，編譯/安裝字符設備

 在Linux系統中，驅動程序通常採用內核模塊的程序結構來進行編碼。因此，編譯/安裝一個驅動程序，其實質就是編譯/安裝一個內核模塊。

2， 字符設備文件

通過字符設備文件，應用程序可以使用相應的字符設備驅動程序來控制字符設備。創建字符設備文件的方法一般有兩種：
（1）使用mknod命令

mknod /dev/文件名 c 主設備號 次設備號

（2）使用函數在驅動程序中創建

                                                   

1.11.7 內存操作驅動實例

    /**********************************/
   /*                                */
  /*            驅動程序             */
 /*                                */
/**********************************/
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <asm/uaccess.h>


int dev1_registers[5];
int dev2_registers[5];

struct cdev cdev; 
dev_t devno;

/*文件打開函數*/
int mem_open(struct inode *inode, struct file *filp)
{
    
    /*獲取次設備號*/
    int num = MINOR(inode->i_rdev);
    
    if (num==0)
        filp->private_data = dev1_registers;
    else if(num == 1)
        filp->private_data = dev2_registers;
    else
        return -ENODEV;  //無效的次設備號
    
    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;
  int *register_addr = filp->private_data; /*獲取設備的寄存器基地址*/

  /*判斷讀位置是否有效*/
  if (p >= 5*sizeof(int))
    return 0;
  if (count > 5*sizeof(int) - p)
    count = 5*sizeof(int) - p;

  /*讀數據到用戶空間*/
  if (copy_to_user(buf, register_addr+p, count))
  {
    ret = -EFAULT;
  }
  else
  {
    *ppos += count;
    ret = count;
  }

  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;
  int *register_addr = filp->private_data; /*獲取設備的寄存器地址*/
  
  /*分析和獲取有效的寫長度*/
  if (p >= 5*sizeof(int))
    return 0;
  if (count > 5*sizeof(int) - p)
    count = 5*sizeof(int) - p;
    
  /*從用戶空間寫入數據*/
  if (copy_from_user(register_addr + p, buf, count))
    ret = -EFAULT;
  else
  {
    *ppos += count;
    ret = count;
  }

  return ret;
}

/* seek文件定位函數 */
static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
{ 
    loff_t newpos;

    switch(whence) {
      case SEEK_SET: 
        newpos = offset;
        break;

      case SEEK_CUR: 
        newpos = filp->f_pos + offset;
        break;

      case SEEK_END: 
        newpos = 5*sizeof(int)-1 + offset;
        break;

      default: 
        return -EINVAL;
    }
    if ((newpos<0) || (newpos>5*sizeof(int)))
    	return -EINVAL;
    	
    filp->f_pos = newpos;
    return newpos;

}

/*文件操作結構體*/
static const struct file_operations mem_fops =
{
  .llseek = mem_llseek,
  .read = mem_read,
  .write = mem_write,
  .open = mem_open,
  .release = mem_release,
};

/*設備驅動模塊加載函數*/
static int memdev_init(void)
{
  /*初始化cdev結構*/
  cdev_init(&cdev, &mem_fops);
  
  /* 註冊字符設備 */
  alloc_chrdev_region(&devno, 0, 2, "memdev");
  cdev_add(&cdev, devno, 2);
}

/*模塊卸載函數*/
static void memdev_exit(void)
{
  cdev_del(&cdev);   /*註銷設備*/
  unregister_chrdev_region(devno, 2); /*釋放設備號*/
}

MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);


    /**********************************/
   /*                                */
  /*            應用程序             */
 /*                                */
/**********************************/
//write.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
	int fd = 0;
	int src = 2013;
	
	/*打開設備文件*/
	fd = open("/dev/memdev0",O_RDWR);
	
	/*寫入數據*/
	write(fd, &src, sizeof(int));
	
	/*關閉設備*/
	close(fd);
	
	return 0;	

}

//read.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main()
{
	int fd = 0;
	int dst = 0;
	
	/*打開設備文件*/
	fd = open("/dev/memdev0",O_RDWR);
	
	/*寫入數據*/
	read(fd, &dst, sizeof(int));
	
	printf("dst is %d\n",dst);
	
	/*關閉設備*/
	close(fd);
	
	return 0;	

}