Linux設備驅動程序學習（1） -字符設備驅動程序

Linux設備驅動程序學習（1）
-字符設備驅動程序

今天進入《Linux設備驅動程序（第3版）》第三章字符設備驅動程序的學習。
這一章主要通過介紹字符設備scull（Simple Character Utility for Loading Localities，區域裝載的簡單字符工具）的驅動程序編寫，來學習Linux設備驅動的基本知識。scull可以爲真正的設備驅動程序提供樣板。

---

一、主設備號和次設備號
主設備號表示設備對應的驅動程序；次設備號由內核使用，用於正確確定設備文件所指的設備。
內核用dev_t類型（<linux/types.h>）來保存設備編號，dev_t是一個32位的數，12位表示主設備號，20爲表示次設備號。
在實際使用中，是通過<linux/kdev_t.h>中定義的宏來轉換格式。

(dev_t)-->主設備號、次設備號	MAJOR(dev_t dev)  MINOR(dev_t dev)
主設備號、次設備號-->(dev_t)	MKDEV(int major,int minor)

建立一個字符設備之前，驅動程序首先要做的事情就是獲得設備編號。其這主要函數在<linux/fs.h>中聲明：

int register_chrdev_region(dev_t first, unsigned int count,
char *name);   //指定設備編號

int alloc_chrdev_region(dev_t *dev, unsigned int firstminor,
unsigned int count, char *name);   //動態生成設備編號

void unregister_chrdev_region(dev_t first, unsigned int count);      //釋放設備編號

分配之設備號的最佳方式是：默認採用動態分配，同時保留在加載甚至是編譯時指定主設備號的餘地。

以下是在scull.c中用來獲取主設備好的代碼：

if (scull_major) {
    dev = MKDEV(scull_major, scull_minor);
    result = register_chrdev_region(dev, scull_nr_devs, "scull");
} else {
    result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs,"scull");
    scull_major = MAJOR(dev);
}
if (result < 0) {
    printk(KERN_WARNING "scull: can't get major %d\n", scull_major);
    return result;
}

在這部分中，比較重要的是在用函數獲取設備編號後，其中的參數name是和該編號範圍關聯的設備名稱，它將出現在/proc/devices和sysfs中。

看到這裏，就可以理解爲什麼mdev和udev可以動態、自動地生成當前系統需要的設備文件。udev就是通過讀取sysfs下的信息來識別硬件設備的.
(請看《理解和認識udev》
URL：http://blog.chinaunix.net/u/6541/showart_396425.html)

---

二、一些重要的數據結構
大部分基本的驅動程序操作涉及及到三個重要的內核數據結構，分別是file_operations、file和inode，它們的定義都在<linux/fs.h>。

---

三、字符設備的註冊

內核內部使用struct cdev結構來表示字符設備。在內核調用設備的操作之前，必須分配並註冊一個或多個struct cdev。代碼應包含<linux/cdev.h>，它定義了struct cdev以及與其相關的一些輔助函數。

註冊一個獨立的cdev設備的基本過程如下：

1、爲struct cdev 分配空間(如果已經將struct cdev 嵌入到自己的設備的特定結構體中，並分配了空間，這步略過！)

struct cdev *my_cdev = cdev_alloc();

2、初始化struct cdev

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

3、初始化cdev.owner

cdev.owner = THIS_MODULE;

4、cdev設置完成，通知內核struct cdev的信息（在執行這步之前必須確定你對struct cdev的以上設置已經完成！）

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

從系統中移除一個字符設備：void cdev_del(struct cdev *p)

以下是scull中的初始化代碼（之前已經爲struct scull_dev 分配了空間）：

/*
 * Set up the char_dev structure for this device.
 */
static void scull_setup_cdev(struct scull_dev *dev, int index)
{
    int err, devno = MKDEV(scull_major, scull_minor + index);
    
    cdev_init(&dev->cdev, &scull_fops);
    dev->cdev.owner = THIS_MODULE;
    dev->cdev.ops = &scull_fops;  //這句可以省略，在cdev_init中已經做過
    err = cdev_add (&dev->cdev, devno, 1);
    /* Fail gracefully if need be 這步值得注意*/
    if (err)
        printk(KERN_NOTICE "Error %d adding scull%d", err, index);
}

---

四、scull模型的內存使用

以下是scull模型的結構體：

/*
 * Representation of scull quantum sets.
 */
struct scull_qset {
    void **data;
    struct scull_qset *next;
};

struct scull_dev {
    struct scull_qset *data; /* Pointer to first quantum set */
    int quantum; /* the current quantum size */
    int qset; /* the current array size */
    unsigned long size; /* amount of data stored here */
    unsigned int access_key; /* used by sculluid and scullpriv */
    struct semaphore sem; /* mutual exclusion semaphore */
    struct cdev cdev;     /* Char device structure        */
};

scull驅動程序引入了兩個Linux內核中用於內存管理的核心函數，它們的定義都在<linux/slab.h>:

void *kmalloc(size_t size, int flags);
void kfree(void *ptr);

以下是scull模塊中的一個釋放整個數據區的函數（類似清零），將在scull以寫方式打開和scull_cleanup_module中被調用：

int scull_trim(struct scull_dev *dev)
{
  struct scull_qset *next, *dptr;
     int qset = dev->qset; /* 量子集中量子的個數*/
     int i;
     for (dptr = dev->data; dptr; dptr = next) { /* 循環scull_set個數次，直到dptr爲NULL爲止。*/
         if (dptr->data) {
               for (i = 0; i < qset; i++)/* 循環一個量子集中量子的個數次*/
                    kfree(dptr->data[i]);/* 釋放其中一個量子的空間*/

               kfree(dptr->data);/* 釋放當前的scull_set的量子集的空間*/
               dptr->data = NULL;/* 釋放一個scull_set中的void **data指針*/
          }
      next = dptr->next; /* 準備下個scull_set的指針*/
      kfree(dptr);/* 釋放當前的scull_set*/
      }
  dev->size = 0; /* 當前的scull_device所存的數據爲0字節*/
  dev->quantum = scull_quantum;/* 初始化一個量子的大小*/
  dev->qset = scull_qset;/* 初始化一個量子集中量子的個數*/
  dev->data = NULL;/* 釋放當前的scull_device的struct scull_qset *data指針*/
  return 0;
}

以下是scull模塊中的一個沿鏈表前行得到正確scull_set指針的函數，將在read和write方法中被調用：

/*Follow the list*/
struct scull_qset *scull_follow(struct scull_dev *dev, int n)
{
    struct scull_qset *qs = dev->data;
        /* Allocate first qset explicitly if need be */
    if (! qs) {
        qs = dev->data = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
        if (qs == NULL)
            return NULL; /* Never mind */
        memset(qs, 0, sizeof(struct scull_qset));
    }
    /* Then follow the list */
    while (n--) {
        if (!qs->next) {
            qs->next = kmalloc(sizeof(struct scull_qset), GFP_KERNEL);
            if (qs->next == NULL)
                return NULL; /* Never mind */
            memset(qs->next, 0, sizeof(struct scull_qset));
        }
        qs = qs->next;
        continue;
    }
    return qs;
}

其實這個函數的實質是：如果已經存在這個scull_set，就返回這個scull_set的指針。如果不存在這個scull_set，一邊沿鏈表爲scull_set分配空間一邊沿鏈表前行，直到所需要的scull_set被分配到空間並初始化爲止，就返回這個scull_set的指針。

---

五、open和release

open方法提供給驅動程序以初始化的能力，爲以後的操作作準備。應完成的工作如下：

(1)檢查設備特定的錯誤（如設備未就緒或硬件問題）；

(2)如果設備是首次打開，則對其進行初始化；

(3)如有必要，更新f_op指針；

(4)分配並填寫置於filp->private_data裏的數據結構。

而根據scull的實際情況，他的open函數只要完成第四步（將初始化過的struct scull_dev dev的指針傳遞到filp->private_data裏，以備後用）就好了，所以open函數很簡單。但是其中用到了定義在<linux/kernel.h>中的container_of宏，源碼如下：

#define container_of(ptr, type, member) ({            \
    const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
    (type *)( (char *)__mptr - offsetof(type,member) );})

其實從源碼可以看出，其作用就是：通過指針ptr，獲得包含ptr所指向數據（是member結構體）的type結構體的指針。即是用指針得到另外一個指針。

release方法提供釋放內存，關閉設備的功能。應完成的工作如下：

（1）釋放由open分配的、保存在file->private_data中的所有內容；

（2）在最後一次關閉操作時關閉設備。

由於前面定義了scull是一個全局且持久的內存區，所以他的release什麼都不做。

---

六、read和write

 read和write方法的主要作用就是實現內核與用戶空間之間的數據拷貝。因爲Linux的內核空間和用戶空間隔離的，所以要實現數據拷貝就必須使用在<asm/uaccess.h>中定義的：

unsigned long copy_to_user(void __user *to,
                           const void *from,
                           unsigned long count);
unsigned long copy_from_user(void *to,
                             const void __user *from,
                             unsigned long count);

而值得一提的是以上兩個函數和

#define __copy_from_user(to,from,n)    (memcpy(to, (void __force *)from, n), 0)
#define __copy_to_user(to,from,n)    (memcpy((void __force *)to, from, n), 0)

之間的關係：通過源碼可知，前者調用後者，但前者在調用前對用戶空間指針進行了檢查。

至於read和write 的具體函數比較簡單，就在實驗中驗證好了。

---

七、模塊實驗

這次模塊實驗的使用是友善之臂SBC2440V4，使用Linux2.6.22.2內核。

模塊程序鏈接：scull模塊源程序
模塊測試程序鏈接：模塊測試程序

測試結果：

量子大小爲6：

[Tekkaman2440@SBC2440V4]#cd /lib/modules/ [Tekkaman2440@SBC2440V4]#insmod scull.ko scull_quantum=6

[Tekkaman2440@SBC2440V4]#cat /proc/devices
Character devices:
  1 mem
  2 pty
  3 ttyp
  4 /dev/vc/0
  4 tty
  4 ttyS
  5 /dev/tty
  5 /dev/console
  5 /dev/ptmx
  7 vcs
 10 misc
 13 input
 14 sound
 81 video4linux
 89 i2c
 90 mtd
116 alsa
128 ptm
136 pts
180 usb
189 usb_device
204 s3c2410_serial
252 scull
253 usb_endpoint
254 rtc

Block devices:
  1 ramdisk
256 rfd
  7 loop
 31 mtdblock
 93 nftl
 96 inftl
179 mmc
[Tekkaman2440@SBC2440V4]#mknod -m 666 scull0 c  252 0
[Tekkaman2440@SBC2440V4]#mknod -m 666 scull1 c  252 1
[Tekkaman2440@SBC2440V4]#mknod -m 666 scull2 c  252 2
[Tekkaman2440@SBC2440V4]#mknod -m 666 scull3 c  252 3

---

啓動測試程序

[Tekkaman2440@SBC2440V4]#./scull_test 

write error! code=6 

write error! code=6 

write error! code=6 

write ok! code=2 

read error! code=6 

read error! code=6 

read error! code=6 

read ok! code=2 

[0]=0 [1]=1 [2]=2 [3]=3 [4]=4 

[5]=5 [6]=6 [7]=7 [8]=8 [9]=9 

[10]=10 [11]=11 [12]=12 [13]=13 [14]=14 

[15]=15 [16]=16 [17]=17 [18]=18 [19]=19

---

改變量子大小爲默認值4000：
[Tekkaman2440@SBC2440V4]#cd /lib/modules/
[Tekkaman2440@SBC2440V4]#rmmod scull
[Tekkaman2440@SBC2440V4]#insmod scull.ko

---

啓動測試程序
[Tekkaman2440@SBC2440V4]#./scull_test
write ok! code=20
read ok! code=20
[0]=0 [1]=1 [2]=2 [3]=3 [4]=4
[5]=5 [6]=6 [7]=7 [8]=8 [9]=9
[10]=10 [11]=11 [12]=12 [13]=13 [14]=14
[15]=15 [16]=16 [17]=17 [18]=18 [19]=19

[Tekkaman2440@SBC2440V4]#    

---

改變量子大小爲6，量子集大小爲2：
[Tekkaman2440@SBC2440V4]#cd /lib/modules/
[Tekkaman2440@SBC2440V4]#rmmod scull
[Tekkaman2440@SBC2440V4]#insmod scull.ko scull_quantum=6 scull_qset=2

---

啓動測試程序
[Tekkaman2440@SBC2440V4]#./scull_test
write error! code=6
write error! code=6
write error! code=6
write ok! code=2
read error! code=6
read error! code=6
read error! code=6
read ok! code=2
[0]=0 [1]=1 [2]=2 [3]=3 [4]=4
[5]=5 [6]=6 [7]=7 [8]=8 [9]=9
[10]=10 [11]=11 [12]=12 [13]=13 [14]=14
[15]=15 [16]=16 [17]=17 [18]=18 [19]=19
               

實驗不僅測試了模塊的讀寫能力，還測試了量子讀寫是否有效。