开发可统计单词个数的Android驱动程序（2）

八、 指定回调函数

      本节讲的内容十分关键。不管Linux驱动程序的功能多么复杂还是多么“酷”，都必须允许用户空间的应用程序与内核空间的驱动程序进行交互才有意义。而最 常用的交互方式就是读写设备文件。通过file_operations.read和file_operations.write成员变量可以分别指定读写 设备文件要调用的回调函数指针。

     在本节将为word_count.c添加两个函数：word_count_read和word_count_write。这两个函数分别处理从设备文件读 数据和向设备文件写数据的动作。本节的例子先不考虑word_count要实现的统计单词数的功能，先用word_count_read和 word_count_write函数做一个读写设备文件数据的实验，以便让读者了解如何与设备文件交互数据。本节编写的word_count.c文件是 一个分支，读者可在word_count/read_write目录找到word_count.c文件。可以用该文件覆盖word_count目录下的同 名文件测试本节的例子。

     本例的功能是向设备文件/dev/wordcount写入数据后，都可以从/dev/wordcount设备文件中读出这些数据（只能读取一次）。下面先看看本例的完整的代码。

1. #include <linux/module.h>   
2. #include <linux/init.h>   
3. #include <linux/kernel.h>   
4. #include <linux/fs.h>   
5. #include <linux/miscdevice.h>   
6. #include <asm/uaccess.h>   
7.    
8. #define DEVICE_NAME "wordcount"         //  定义设备文件名   
9. static unsigned char mem[10000];                //  保存向设备文件写入的数据   
10. static char read_flag = 'y';                    //  y：已从设备文件读取数据   n：未从设备文件读取数据   
11. static int written_count = 0;                   // 向设备文件写入数据的字节数   
12.    
13. //  从设备文件读取数据时调用该函数   
14. //  file：指向设备文件、buf：保存可读取的数据   count：可读取的字节数  ppos：读取数据的偏移量   
15. static ssize_t word_count_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)   
16. {      
17.     //  如果还没有读取设备文件中的数据，可以进行读取   
18.     if(read_flag == 'n')   
19.     {      
20.         //  将内核空间的数据复制到用户空间，buf中的数据就是从设备文件中读出的数据   
21.         copy_to_user(buf, (void*) mem, written_count);   
22.         //  向日志输出已读取的字节数   
23.         printk("read count:%d", (int) written_count);   
24.         //  设置数据已读状态   
25.         read_flag = 'y';   
26.         return written_count;   
27.     }   
28.     //  已经从设备文件读取数据，不能再次读取数据   
29.     else   
30.     {      
31.         return 0;   
32.     }   
33. }   
34. //  向设备文件写入数据时调用该函数   
35. //  file：指向设备文件、buf：保存写入的数据   count：写入数据的字节数  ppos：写入数据的偏移量   
36. static ssize_t word_count_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)   
37. {      
38.     //  将用户空间的数据复制到内核空间，mem中的数据就是向设备文件写入的数据   
39.     copy_from_user(mem, buf, count);   
40.     //  设置数据的未读状态   
41.     read_flag = 'n';   
42.     //  保存写入数据的字节数   
43.     written_count = count;   
44.     //  向日志输出已写入的字节数   
45.     printk("written count:%d", (int)count);   
46.     return count;   
47. }   
48. //  描述与设备文件触发的事件对应的回调函数指针   
49. //  需要设置read和write成员变量，系统才能调用处理读写设备文件动作的函数   
50. static struct file_operations dev_fops =   
51. { .owner = THIS_MODULE, .read = word_count_read, .write = word_count_write };   
52.    
53. //  描述设备文件的信息   
54. static struct miscdevice misc =   
55. { .minor = MISC_DYNAMIC_MINOR, .name = DEVICE_NAME, .fops = &dev_fops };   
56.    
57. //  初始化Linux驱动   
58. static int word_count_init(void)   
59. {   
60.     int ret;   
61.     //  建立设备文件   
62.     ret = misc_register(&misc);   
63.     //  输出日志信息   
64.     printk("word_count_init_success\n");   
65.     return ret;   
66. }   
67.    
68. // 卸载Linux驱动   
69. static void word_count_exit(void)   
70. {   
71.     //  删除设备文件   
72.     misc_deregister(&misc);   
73.     //  输出日志信息   
74.     printk("word_init_exit_success\n");   
75. }   
76.    
77. //  注册初始化Linux驱动的函数   
78. module_init( word_count_init);   
79. //  注册卸载Linux驱动的函数   
80. module_exit( word_count_exit);   
81.    
82. MODULE_AUTHOR("lining");   
83. MODULE_DESCRIPTION("statistics of word count.");   
84. MODULE_ALIAS("word count module.");   
85. MODULE_LICENSE("GPL");   

编写上面代码需要了解如下几点。

1. word_count_read和word_count_write函数的参数基本相同，只有第2个参数buf稍微一点差异。 word_count_read函数的buf参数类型是char*，而word_count_write函数的buf参数类型是const char*，这就意味着word_count_write函数中的buf参数值无法修改。word_count_read函数中的buf参数表示从设备文 件读出的数据，也就是说，buf中的数据都可能由设备文件读出，至于可以读出多少数据，取决于word_count_read函数的返回值。如果 word_count_read函数返回n，则可以从buf读出n个字符。当然，如果n为0，表示无法读出任何的字符。如果n小于0，表示发生了某种错误 （n为错误代码）。word_count_write函数中的buf表示由用户空间的应用程序写入的数据。buf参数前有一个“__user”宏，表示 buf的内存区域位于用户空间。

2. 由于内核空间的程序不能直接访问用户空间中的数据，因此，需要在word_count_read和word_count_write函数中分别使用 copy_to_user和copy_from_user函数将数据从内核空间复制到用户空间或从用户空间复制到内核空间。

3. 本例只能从设备文件读一次数据。也就是说，写一次数据，读一次数据后，第二次无法再从设备文件读出任何数据。除非再次写入数据。这个功能是通过 read_flag变量控制的。当read_flag变量值为n，表示还没有读过设备文件，在word_count_read函数中会正常读取数据。如果 read_flag变量值为y，表示已经读过设备文件中的数据，word_count_read函数会直接返回0。应用程序将无法读取任何数据。

4. 实际上word_count_read函数的count参数表示的就是从设备文件读取的字节数。但因为使用cat命令测试word_count驱动时。直 接读取了32768个字节。因此count参数就没什么用了（值总是32768）。所以要在word_count_write函数中将写入的字节数保存， 在word_count_read函数中直接使用写入的字节数。也就是说，写入多少个字节，就读出多少个字节。

5.  所有写入的数据都保存在mem数组中。该数组定义为10000个字符，因此写入的数据字节数不能超过10000，否则将会溢出。

      为了方便读者测试本节的例子，笔者编写了几个Shell脚本文件，允许在UbuntuLinux、S3C6410开发板和Android模拟器上测试 word_count驱动。其中有一个负责调度的脚本文件build.sh。本书所有的例子都会有一个build.sh脚本文件，执行这个脚本文件就会要 求用户选择将源代码编译到那个平台，选择菜单如图6-11所示。用户可以输入1、2或3选择编译平台。如果直接按回车键，默认值会选择第1个编译平台 （UbuntuLinux）。

build.sh脚本文件的代码如下：

1. source /root/drivers/common.sh   
2. #  select_target是一个函数，用语显示图6-11所示的选择菜单，并接收用户的输入   
3. #  改函数在common.sh文件中定义   
4. select_target   
5. if [ $selected_target == 1 ]; then   
6.     source ./build_ubuntu.sh            # 执行编译成Ubuntu Linux平台驱动的脚本文件   
7. elif [ $selected_target == 2 ]; then       
8.     source ./build_s3c6410.sh           # 执行编译成s3c6410平台驱动的脚本文件   
9. elif [ $selected_target == 3 ]; then   
10.     source ./build_emulator.sh          # 执行编译成Android模拟器平台驱动的脚本文件   
11. fi   

     在build.sh脚本文件中涉及到了3个脚本文件（build_ubuntu.sh、build_s3c6410.sh和 build_emulator.sh），这3个脚本文件的代码类似，只是选择的Linux内核版本不同。对于S3C6410和Android模拟器平台， 编译完后Linux驱动，会自动将编译好的Linux驱动文件（*.so文件）上传到相应平台的/data/local目录，并安装Linux驱动。例 如，build_s3c6410.sh脚本文件的代码如下：

1. source /root/drivers/common.sh   
2. # S3C6410_KERNEL_PATH变量是适用S3C6410平台的Linux内核源代码的路径，   
3. # 该变量以及其它类似变量都在common.sh脚本文件中定义   
4. make  -C $S3C6410_KERNEL_PATH  M=${PWD}   
5. find_devices    
6. #  如果什么都选择，直接退出    
7. if [ "$selected_device" == "" ]; then    
8.     exit   
9. else       
10.     #  上传驱动程序（word_count.ko）   
11.     adb -s $selected_device push ${PWD}/word_count.ko /data/local   
12.     ＃ 判断word_count驱动是否存在   
13.     testing=$(adb -s $selected_device shell lsmod | grep  "word_count")   
14.     if [ "$testing" != "" ]; then   
15.         #  删除已经存在的word_count驱动   
16.         adb -s $selected_device shell rmmod word_count   
17.     fi   
18.     #  在S3C6410开发板中安装word_count驱动    
19.     adb -s $selected_device shell "insmod /data/local/word_count.ko"   
20. fi   

使用上面的脚本文件，需要在read_write目录建立一个Makefile文件，内容如下：

obj-m := word_count.o

现在执行build.sh脚本文件，选择要编译的平台，并执行下面的命令向/dev/word_count设备文件写入数据。

# echo ‘hello lining’ > /dev/wordcount

然后执行如下的命令从/dev/word_count设备文件读取数据。

# cat /dev/wordcount

如果输出“hello lining”，说明测试成功。

 注意：如 果在S3C6410开发板和Android模拟器上测试word_count驱动，需要执行shell.sh脚本文件或adb shell命令进入相应平台的终端。其中shell.sh脚本在/root/drivers目录中。这两种方式的区别是如果有多个Android设备和 PC相连时，shell.sh脚本会出现一个类似图6-11所示的选择菜单，用户可以选择进入哪个Android设备的终端，而adb shell命令必须要加-s命令行参数指定Android设备的ID才可以进入相应Android设备的终端。

九、实现统计单词数的算法

      本节开始编写word_count驱动的业务逻辑：统计单词数。本节实现的算法将由空格、制表符（ASCII：9）、回车符（ASCII：13）和换行符 （ASCII：10）分隔的字符串算做一个单词，该算法同时考虑了有多个分隔符（空格符、制表符、回车符和换行符）的情况。下面是word_count驱 动完整的代码。在代码中包含了统计单词数的函数get_word_count。

1. #include <linux/module.h>   
2. #include <linux/init.h>   
3. #include <linux/kernel.h>   
4. #include <linux/fs.h>   
5. #include <linux/miscdevice.h>   
6. #include <asm/uaccess.h>   
7.    
8. #define DEVICE_NAME "wordcount"     //  定义设备文件名   
9. static unsigned char mem[10000];        // 保存向设备文件写入的数据   
10. static int word_count = 0;                  //  单词数   
11. #define TRUE -1   
12. #define FALSE 0   
13.    
14. //  判断指定字符是否为空格（包括空格符、制表符、回车符和换行符）   
15. static char is_spacewhite(char c)   
16. {      
17.     if(c == ' ' || c == 9 || c == 13  || c == 10)   
18.         return TRUE;   
19.     else   
20.         return FALSE;   
21. }   
22. //  统计单词数   
23. static int get_word_count(const char *buf)   
24. {   
25.     int n = 1;   
26.     int i = 0;   
27.     char c = ' ';   
28.    
29.     char flag = 0;   // 处理多个空格分隔的情况，0：正常情况，1：已遇到一个空格   
30.     if(*buf == '\0')   
31.         return 0;   
32.     //  第1个字符是空格，从0开始计数   
33.     if(is_spacewhite(*buf) == TRUE)   
34.         n--;   
35.     //  扫描字符串中的每一个字符   
36.     for (; (c = *(buf + i)) != '\0'; i++)   
37.     {   
38.         //  只由一个空格分隔单词的情况   
39.         if(flag == 1 && is_spacewhite(c) == FALSE)   
40.         {   
41.            flag = 0;   
42.         }   
43.         //  由多个空格分隔单词的情况，忽略多余的空格   
44.         else if(flag == 1 && is_spacewhite(c) == TRUE)   
45.         {   
46.             continue;   
47.         }   
48.         //  当前字符为空格时单词数加1   
49.         if(is_spacewhite(c) == TRUE)   
50.         {   
51.             n++;   
52.             flag = 1;   
53.         }   
54.     }   
55.     //  如果字符串以一个或多个空格结尾，不计数（单词数减1）   
56.     if(is_spacewhite(*(buf + i - 1)) == TRUE)   
57.         n--;   
58.     return n;   
59. }   
60. //  从设备文件读取数据时调用的函数   
61. static ssize_t word_count_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)   
62. {   
63.     unsigned char temp[4];   
64.     //  将单词数（int类型）分解成4个字节存储在buf中   
65.     temp[0] = word_count >> 24;   
66.     temp[1] = word_count >> 16;   
67.     temp[2] = word_count >> 8;   
68.     temp[3] = word_count;   
69.     copy_to_user(buf, (void*) temp, 4);   
70.     printk("read:word count:%d", (int) count);   
71.    
72.     return count;   
73. }   
74. //  向设备文件写入数据时调用的函数   
75. static ssize_t word_count_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)   
76. {   
77.     ssize_t written = count;   
78.    
79.     copy_from_user(mem, buf, count);   
80.     mem[count] = '\0';   
81.     //  统计单词数   
82.     word_count = get_word_count(mem);   
83.     printk("write:word count:%d", (int)word_count);   
84.     return written;   
85. }   
86.    
87. //  描述与设备文件触发的事件对应的回调函数指针   
88. static struct file_operations dev_fops =   
89. { .owner = THIS_MODULE, .read = word_count_read, .write = word_count_write };   
90.    
91. //  描述设备文件的信息   
92. static struct miscdevice misc =   
93. { .minor = MISC_DYNAMIC_MINOR, .name = DEVICE_NAME, .fops = &dev_fops };   
94.    
95. //  初始化Linux驱动   
96. static int word_count_init(void)   
97. {   
98.     int ret;   
99.     //  建立设备文件   
100.     ret = misc_register(&misc);   
101.     //  输出日志信息   
102.     printk("word_count_init_success\n");   
103.     return ret;   
104. }   
105.    
106. // 卸载Linux驱动   
107. static void word_count_exit(void)   
108. {   
109.     //  删除设备文件   
110.     misc_deregister(&misc);   
111.     //  输出日志信息   
112.     printk("word_init_exit_success\n");   
113. }   
114.    
115. //  注册初始化Linux驱动的函数   
116. module_init( word_count_init);   
117. //  注册卸载Linux驱动的函数   
118. module_exit( word_count_exit);   
119.    
120. MODULE_AUTHOR("lining");   
121. MODULE_DESCRIPTION("statistics of word count.");   
122. MODULE_ALIAS("word count module.");   
123. MODULE_LICENSE("GPL");   

编写word_count驱动程序需要了解如下几点。

1.  get_word_count函数将mem数组中第1个为“\0”的字符作为字符串的结尾符，因此在word_count_write函数中将 mem[count]的值设为“\0”，否则get_word_count函数无法知道要统计单词数的字符串到哪里结束。由于mem数组的长度为 10000，而字符串最后一个字符为“\0”，因此待统计的字符串最大长度为9999。

2.  单词数使用int类型变量存储。在word_count_write函数中统计出了单词数（word_count变量的值），在 word_count_read函数中将word_count整型变量值分解成4个字节存储在buf中。因此，在应用程序中需要再将这4个字节组合成 int类型的值。

十、编译、安装、卸载Linux驱动程序

      在上一节word_count驱动程序已经全部编写完成了，而且多次编译测试该驱动程序。安装和卸载word_count驱动也做过多次。 word_count驱动与read_write目录中的驱动一样，也有一个build.sh和3个与平台相关的脚本文件。这些脚本文件与6.3.5节的 实现类似，这里不再详细介绍。现在执行build.sh脚本文件，并选择要编译的平台。然后执行下面两行命令查看日志输出信息和word_count驱动 模块（word_count.ko）的信息。

# dmesg |tail -n 1

# modinfo word_count.ko

如果显示如图6-12所示的信息，表明word_count驱动工作完全正常。

本书的脚本文件都是使用insmod命令安装Linux驱动的，除了该命令外，使用modprobe命令也可以安装Linux驱动。insmod和 modprobe的区别是modprobe命令可以检查驱动模块的依赖性。如A模块依赖于B模块（装载A之前必须先装载B）。如果使用insmod命令装 载A模块，会出现错误。而使用modprobe命令装载A模块，B模块会现在装载。在使用modprobe命令装载驱动模块之前，需要先使用depmod 命令检测Linux驱动模块的依赖关系。

# depmod  /root/drivers/ch06/word_count/word_count.ko

depmod命令实际上将Linux驱动模块文件（包括其路径）添加到如下的文件中。

/lib/modules/3.0.0-16-generic/modules.dep

使用depmod命令检测完依赖关系后，就可以调用modprobe命令装载Linux驱动。

# modprobe word_count

使用depmod和modprobe命令需要注意如下几点：

1. depmod命令必须使用Linux驱动模块（.ko文件）的绝对路径。

2. depmod命令会将内核模块的依赖信息写入当前正在使用的内核的modules.dep文件。例如，笔者的Ubuntu Linux使用的是Linux3.0.0.16，所以应到3.0.0-16-generic目录去寻找modules.dep文件。如果读者使用了其他 Linux内核，需要到相应的目录去寻找modules.dep文件。

3. modprobe命令只需使用驱动名称即可，不需要跟.ko。

使用Android模拟器测试Linux驱动（1）

本文节选至《Android深度探索（卷1）：HAL与驱动开发》， 接下来几篇文章将详细阐述如何开发ARM架构的Linux驱动，并分别利用android程序、NDK、可执行文件测试Linux驱动。可在ubuntu Linux、Android模拟器和S3C6410开发板（可以选购OK6410-A开发板，需要刷Android）

 本文转自 androidguy 51CTO博客，原文链接：http://blog.51cto.com/androidguy/1144185，如需转载请自行联系原作者