本节书摘来异步社区《嵌入式Linux开发实用教程》一书中的第4章，第4.2节，作者：朱兆祺 ,李强 ,袁晋蓉 ，更多章节内容可以访问云栖社区“异步社区”公众号查看

4.2 字符设备驱动

嵌入式Linux开发实用教程
Linux操作系统将所有的设备都会看成是文件，因此当我们需要访问设备时，都是通过操作文件的方式进行访问。对字符设备的读写是以字节为单位进行的。

对字符设备驱动程序的学习过程，主要以两个具有代表性且在OK6410开发平台可实践性的字符驱动展开分析，分别为LED驱动程序、ADC驱动程序。

4.2.1 LED驱动程序设计

为了展现LED的裸板程序和基于Linux系统的LED驱动程序的区别与减少难度梯度，在写LED驱动程序之前很有必要先看一下LED的裸板程序是怎样设计的。

1．LED裸板程序
OK6410开发平台中有4个LED灯，原理图如图4.1所示。

从图4.1中可知，4个LED采用的是共阳极连接方式，GPM0～GPM3分别控制着LED1～LED4。而GPMCON寄存器地址为：0x7F008820；GPMDAT寄存器地址为：0x7F008824。那么GPM中3个寄存器宏定义为：

/*===============================================================
**　　基地址的定义
===============================================================*/
#define　　AHB_BASE　　　　(0x7F000000)
/****************************************************************
**　GPX的地址定义
****************************************************************/
#define　　GPX_BASE　　　　(AHB_BASE+0x08000)
……
/****************************************************************
**　　　　GPM寄存器地址定义
****************************************************************/
#define　　GPMCON　　　　(*(volatile unsigned long *)(GPX_BASE + 0x0820))
#define　　GPMDAT　　　　(*(volatile unsigned long *)(GPX_BASE + 0x0824))
#define　　GPMPUD　　　　(*(volatile unsigned long *)(GPX_BASE + 0x0828))
将GPM0～GPM3设置为输出功能：

/* GPM0,1,2,3设为输出引脚 */
/*
**　　每一个GPXCON的引脚有 4位二进制进行控制
**　　0000-输入　　 0001-输出
*/
GPMCON = 0x1111;
点亮LED1，则是让GPM3～GPM0输出：1110。

GPMDAT = 0x0e;
点亮LED3，则是让GPM3～GPM0输出：1011。

GPMDAT = 0x0b;

2．LED驱动程序
有了LED裸板程序的基础，那么移植到Linux系统LED驱动设备程序的难度也不会很大了。但是在Linux中，特别注意《s3c6410用户手册》提供的GPM寄存器地址不能直接用于Linux中。

在一般情况下，Linux系统中，进程的4GB（232）内存空间被划分成为两个部分：用户空间（3G）和内核空间（1GB），大小分别为0～3GB和3～4GB，如图4.2所示。

在3～4GB之间的内核空间中，从低地址到高地址依次为：系统物理内存映射区、VMALLOC_OFFSET、vmalloc用来分配物理地址非连续的内存空间、8KB隔离带、高端内存永久映射区、高端内存固定映射区。

在通常情况下，进程只能访问用户空间的虚拟地址，不能访问内核空间。

每个进程的用户空间都是完全独立、互不相干的，用户进程各自有不同的页表。而内核空间是由内核负责映射的，它并不会跟着进程改变，是固定的。内核空间地址有自己对应的页表，内核的虚拟空间独立于其他程序。

在内核中，访问I/O内存之前，我们只有I/O内存的物理地址，这样是无法通过软件直接访问的，需要首先用ioremap()函数将设备所处的物理地址映射到内核虚拟地址空间（3GB～4GB）。然后才能根据映射所得到的内核虚拟地址范围，通过访问指令访问这些I/O内存资源。

一般来说，在系统运行时，外设的I/O内存资源的物理地址是已知的，由硬件的设计决定。但是CPU通常并没有为这些已知的外设I/O内存资源的物理地址预定义虚拟地址范围，驱动程序并不能直接通过物理地址访问I/O内存资源，而必须将它们映射到核心虚拟地址空间内（通过页表），然后才能根据映射所得到的核心虚拟地址范围，通过访内指令访问这些I/O内存资源。Linux在io.h头文件中声明了函数ioremap()，用来将I/O内存资源的物理地址映射到核心虚拟地址空间（3GB～4GB）中，如下所示：

void * ioremap(unsigned long phys_addr, unsigned long size, 
unsigned long flags);
iounmap函数用于取消ioremap()所做的映射，如下所示：

void iounmap(void * addr);```
到这里应该明白，像GPMCON（0x7F00 8820）这个物理地址是不能直接操控的，必须通过映射到内核的虚拟地址中，才能进行操作。

现在开始设计第一个LED驱动程序。

字符驱动程序所要包含的头文件主要位于include/linux及/arch/arm/mach-s3c64xx /include/mach目录下，如下LED驱动程序所包含的头文件：

/*
*　head file
*/
//moudle.h 包含了大量加载模块需要的函数和符号的定义

include

//kernel.h以便使用printk()等函数

include

//fs.h包含常用的数据结构，如struct file等

include

//uaccess.h 包含copy_to_user()、copy_from_user()等函数

include

//io.h 包含inl()、outl()、readl()、writel()等I/O操作函数

include

include

include

//init.h来指定你的初始化和清理函数，例如：module_init(init_function)、module_exit(cleanup_function)

include

include

include

include

include

//irq.h中断与并发请求事件

include

//下面这些头文件是I/O口在内核的虚拟映射地址，涉及I/O口的操作所必须包含的
//#include

include

include

include

include `

上面所列出的头文件即是本次LED驱动程序所需要包含的头文件。

#define DEVICE_NAME　　 "led"
#define LED_MAJOR　　　　240　　　　　　　　　　/*主设备号*/```
这是LED驱动程序的驱动名称和主设备号。

设备节点位于/dev目录下，如下所示，例举出了ubuntu系统/dev/vcs*的设备节点：

zhuzhaoqi@zhuzhaoqi-desktop:～$ ls -l /dev/vcs*
……
crw-rw---- 1 root tty 7,　 7 2013-04-09 20:56 /dev/vcs7
crw-rw---- 1 root tty 7, 128 2013-04-09 20:56 /dev/vcsa
……`
/dev/vcs7设备节点的主设备号为：7，次设备号为：7；/dev/vcsa设备节点的主设备号为：7，次设备号为：128。

#define LED_ON　　　　　 0
#define LED_OFF　　　　　1```
这是LED灯打开或者关闭的宏定义，由于OK6410开发平台的4个LED是共阳连接，所以输出1即为熄灭LED，输出0为点亮LED。

字符驱动程序中实现了open、close、read、write等系统调用。

open函数指针的声明位于fs.h的file_operations结构体中，如下所示：

struct file_operations {
　　……

 int (*open) (struct inode* , struct file *);

　　……
};`
open函数指针的回调函数led_open()完成的任务是设置GPM的输出模式。

static int led_open(struct inode *inode,struct file *file)
{
　　unsigned int i;
　　/*设置GPM0～GPM3为输出模式*/
　　for (i = 0; i < 4; i++) 
　　{
　　　　s3c_gpio_cfgpin(S3C64XX_GPM(i),S3C_GPIO_OUTPUT);
printk("The GPMCON %x is %x \n",i,s3c_gpio_getcfg(S3C64XX_GPM(i)) );
　　}
　　printk("Led open... \n");
　　return 0;
}```
s3c_gpio_cfgpin()函数原型位于gpio-cfg.h中，如下：

extern int s3c_gpio_cfgpin(unsigned int pin, unsigned int to);`
内核对这个函数是这样注释的：s3c_gpio_cfgpin()函数用于改变引脚的GPIO功能。参数pin是GPIO的引脚名称，参数to是需要将GPIO这个引脚设置成为的功能。

GPIO的名称在arch/arm/mach-s3c6400/include/mach/gpio.h进行了宏定义：

/* S3C64XX GPIO number definitions. */
#define S3C64XX_GPA(_nr)　　(S3C64XX_GPIO_A_START + (_nr))
#define S3C64XX_GPB(_nr)　　(S3C64XX_GPIO_B_START + (_nr))
#define S3C64XX_GPC(_nr)　　(S3C64XX_GPIO_C_START + (_nr))
#define S3C64XX_GPD(_nr)　　(S3C64XX_GPIO_D_START + (_nr))
#define S3C64XX_GPE(_nr)　　(S3C64XX_GPIO_E_START + (_nr))
#define S3C64XX_GPF(_nr)　　(S3C64XX_GPIO_F_START + (_nr))
#define S3C64XX_GPG(_nr)　　(S3C64XX_GPIO_G_START + (_nr))
#define S3C64XX_GPH(_nr)　　(S3C64XX_GPIO_H_START + (_nr))
#define S3C64XX_GPI(_nr)　　(S3C64XX_GPIO_I_START + (_nr))
#define S3C64XX_GPJ(_nr)　　(S3C64XX_GPIO_J_START + (_nr))
#define S3C64XX_GPK(_nr)　　(S3C64XX_GPIO_K_START + (_nr))
#define S3C64XX_GPL(_nr)　　(S3C64XX_GPIO_L_START + (_nr))
#define S3C64XX_GPM(_nr)　　(S3C64XX_GPIO_M_START + (_nr))
#define S3C64XX_GPN(_nr)　　(S3C64XX_GPIO_N_START + (_nr))
#define S3C64XX_GPO(_nr)　　(S3C64XX_GPIO_O_START + (_nr))
#define S3C64XX_GPP(_nr)　　(S3C64XX_GPIO_P_START + (_nr))
#define S3C64XX_GPQ(_nr)　　(S3C64XX_GPIO_Q_START + (_nr))

S3C64XX_GPIO_M_START的定义如下：

enum s3c_gpio_number {
 　　S3C64XX_GPIO_A_START = 0,
 　　S3C64XX_GPIO_B_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_A),
 　　S3C64XX_GPIO_C_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_B),
 　　S3C64XX_GPIO_D_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_C),
 　　S3C64XX_GPIO_E_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_D),
 　　S3C64XX_GPIO_F_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_E),
 　　S3C64XX_GPIO_G_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_F),
 　　S3C64XX_GPIO_H_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_G),
 　　S3C64XX_GPIO_I_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_H),
 　　S3C64XX_GPIO_J_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_I),
 　　S3C64XX_GPIO_K_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_J),
 　　S3C64XX_GPIO_L_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_K),
     S3C64XX_GPIO_M_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_L),
 　　S3C64XX_GPIO_N_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_M),
 　　S3C64XX_GPIO_O_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_N),
 　　S3C64XX_GPIO_P_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_O),
 　　S3C64XX_GPIO_Q_START = S3C64XX_GPIO_NEXT(S3C64XX_GPIO_P),
};```
S3C64XX_GPIO_NEXT的定义：

define S3C64XX_GPIO_NEXT(__gpio) \

　　((__gpio##_START) + (__gpio##_NR) + CONFIG_S3C_GPIO_SPACE + 1)`
宏定义一层一层很多，但是通过这个设置，可以很方便地选择想要的任何一个GPIO口进行操作。

GPIO功能设置位于gpio-cfg.h中：

#define S3C_GPIO_SPECIAL_MARK　　(0xfffffff0)
#define S3C_GPIO_SPECIAL(x)　　(S3C_GPIO_SPECIAL_MARK | (x))
/* Defines for generic pin configurations */
#define S3C_GPIO_INPUT　　(S3C_GPIO_SPECIAL(0))
#define S3C_GPIO_OUTPUT　　(S3C_GPIO_SPECIAL(1))
#define S3C_GPIO_SFN(x)　　(S3C_GPIO_SPECIAL(x))```
通过上面的宏定义可知，GPIO的引脚功能有输入、输出，和你想要的任何可以实现的功能设置，S3C_GPIO_SFN（x）这个函数即是通过设定x的值，实现任何存在功能的设置。如果要设置GPM0～GPM3为输出功能，则：

for (i = 0; i < 4; i++) {
s3c_gpio_cfgpin(S3C64XX_GPM(i),S3C_GPIO_OUTPUT);
}`
通过这样的操作，设置就显得比较简洁实用。

s3c_gpio_getcfg(S3C64XX_GPM(i))```
这行代码的作用是获取GMP（argv）的当前值。这个函数的原型在include/linux/gpio.h中：

static inline void gpio_get_value(unsigned int gpio)
{
　　__gpio_get_value(gpio);
}`
完成端口模式设定，接下来的程序是完成LED操作。在fs.h的file_operations结构体中，有unlocked_ioctl函数指针的声明，如下所示：

struct file_operations {
……
　　long (*unlocked_ioctl) (struct file *,unsigned int,unsigned long);
……　
};```
unlocked_ioctl函数指针所要回调的led_ioctl()函数即是需要实现应用层对LED1～LED4的控制操作。

static long led_ioctl ( struct file *file, unsigned int cmd, \
　　　　　　　　　　　　unsigned long argv )
{
　　if (argv > 4) {
　　　　return -EINVAL;
　　}
printk("LED ioctl... n");
/ 获取应用层的操作 /
　　switch(cmd) {
/ 如果是点亮LED(argv) /
　　case LED_ON:
　　　　gpio_set_value(S3C64XX_GPM(argv),0);
　　　　printk("LED ON n");
　 printk( "S3C64XX_GPM(i) = %xn",gpio_get_value(S3C64XX_GPM(argv)) );
　　　　return 0;
/ 如果是熄灭LED(argv) /
　　case LED_OFF:
　　　　gpio_set_value(S3C64XX_GPM(argv),1);
　　　　printk("LED OFF n");
　　　　printk( "S3C64XX_GPM(i) = %x n",gpio_get_value(S3C64XX_GPM(argv)) );
　　　　return 0;
　　default:
　　　　return -EINVAL;
　　}
}`
本函数调用了GPIO端口值设定函数。

gpio_set_value(S3C64XX_GPM(argv),1);```
这是设定GMP（argv）输出为1。函数的原型位于include/linux/gpio.h中：

static inline void gpio_set_value(unsigned int gpio, int value)
{
　　__gpio_set_value(gpio, value);
}`
release函数指针所要回调的函数led_release ()函数：

static int led_release(struct inode *inode,struct file *file)
{
　　　　printk("zhuzhaoqi >>> s3c6410_led release \n");
　　　　return 0;
}```
这是驱动程序的核心控制，各个函数指针所对应的回调函数：

struct file_operations led_fops = {
　　　　.owner　　　　　= THIS_MODULE,
　　　　.open　　　　　 = led_open,
　　　　.unlocked_ioctl = led_ioctl,
　　　　.release　　　　= led_release,
};`
由于Linux3.8.3内核中没有ioctl函数指针，取而代之的是unlocked_ioctl函数指针实现对led_ioctl()函数的回调。

驱动程序的加载分为静态加载和动态加载，将驱动程序编译进内核称为静态加载，将驱动程序编译成模块，使用时再加载称为动态加载。动态加载模块的扩展名为：.ko，使用insmod命令进行加载，使用rmmod命令进行卸载。

static int __init led_init(void)
{
　　　　int rc;
　　　　printk("LEDinit... \n");
　　　　rc = register_chrdev(LED_MAJOR,"led",&led_fops);
　　　　if (rc < 0)
　　　　{
　　　　　　　　printk("register %s char dev error\n","led");
　　　　　　　　return -1;
　　　　}
　　　　printk("OK!\n");
　　　　return 0;
}```
_init修饰词对内核是一种暗示，表明该初始化函数仅仅在初始化期间使用，在模块装载之后，模块装载器就会将初始化函数释放掉，这样就能将初始化函数所占用的内存释放出来以作他用。

当使用insmod命令加载LED驱动模块时，led_init()初始化函数将被调用，向内核注册LED驱动程序。

static void __exit led_exit(void)
{
　　　　unregister_chrdev(LED_MAJOR,"led");
　　　　printk("LED exit...n");
}`
_exit这个修饰词告诉内核这个退出函数仅仅用于模块卸载，并且仅仅能在模块卸载或者系统关闭时被调用。

当使用rmmod命令卸载LED驱动模块时，led_exit ()清除函数将被调用，向内核注册LED驱动程序。

module_init(led_init);
module_exit(led_exit);```
module_init和module_exit是强制性使用的，这个宏会在模块的目标代码中增加一个特殊的段，用于说明函数所在位置。如果没有这个宏，则初始化函数和退出函数永远不会被调用。

MODULE_LICENSE("GPL");`
如果没有声明LICENSE，模块被加载时，会给出处理内核被污染（kernel taint）的警告。如果在zzq_led.c中没有许可证（LICENSE），则会给出如下提示：

[YJR@zhuzhaoqi 3.8.3]# insmod zzq_led.ko 
zzq_led: module license 'unspecified' taints kernel.
Disabling lock debugging due to kernel taint```
Linux遵循GNU通用公共许可证（GPL），GPL是由*软件基金会为GNU项目设计，它允许任何人对其重新发布甚至销售。

当然，也许程序还会有驱动程序的作者和描述信息：

MODULE_AUTHOR("zhuzhaoqi jxlgzzq@163.com");
MODULE_DESCRIPTION("OK6410(S3C6410) LED Driver");`
完成驱动程序的设计之后，将zzq_led.c驱动程序放置于/drivers/char目录下，打开Makefile文件：

zhuzhaoqi@zhuzhaoqi-desktop:～/Linux/linux-3.8.3/drivers/char$ gedit Makefile
在Makefile中添加LED驱动：

obj-m　　　　　　　　　　　　　 += zzq_led.o```
回到内核的根目录执行make modules命令生成LED驱动模块：

zhuzhaoqi@zhuzhaoqi-desktop:～/Linux/linux-3.8.3$ make modules
……
　CC [M]　drivers/char/zzq_led.o
……`
编译完成之后在/drivers/char目录下会生成zzq_led.ko模块，将其拷贝到文件系统下面的/lib/modules/3.8.3（如果没有3.8.3目录，则建立）目录下。

加载LED驱动模块：

[YJR@zhuzhaoqi]\# cd lib/module/3.8.3/
[YJR@zhuzhaoqi]\# ls
zzq_led.ko
[YJR@zhuzhaoqi]\# insmod zzq_led.ko 
LED init... 
OK!```
根据信息输出可知加载zzq_led.ko驱动模块成功。通过lsmod查看加载模块：

[YJR@zhuzhaoqi]# lsmod
zzq_led 1548 0 - Live 0xbf000000`
在/dev目录下建立设备文件，进行如下操作：

[YJR@zhuzhaoqi]\# mknod /dev/led c 240 0```
是否建立成功，可以查看/dev下的节点得知：

[YJR@zhuzhaoqi]# ls /dev/l*
/dev/led　　　　　 /dev/log　　　　　 /dev/loop-control`
说明LED设备文件已经成功建立。

3．LED应用程序
驱动程序需要应用程序对其操控。程序如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define　 LED_ON　　 0
#define　 LED_OFF　　1

/*
 * LED 操作说明信息输出
 */
void usage(char *exename)
{
　　printf("How to use: \n");
　　printf("　　%s <LED Number><on/off> \n", exename);
　　printf("　　LED Number = 1, 2, 3 or 4 \n");
}

/*　
*　应用程序主函数
*/
int main(int argc, char *argv[])
{
　　unsigned int led_number;

　　if (argc != 3) {
　　　　goto err;
　　}

　　int fd = open("/dev/led",2,0777);
　　if (fd < 0) {
　　　　printf("Can't open /dev/led \n");
　　　　return -1;
　　}
　　printf("open /dev/led ok ... \n");

　　led_number = strtoul(argv[1], 0, 0) - 1;
　　if (led_number > 3) {
　　　　goto err;
}

　　/* LED ON */
　　if (!strcmp(argv[2], "on")) {
　　　　ioctl(fd, LED_ON, led_number);
　　}
　　/* LED OFF */
　　else if (!strcmp(argv[2], "off")) {
　　　　ioctl(fd, LED_OFF, led_number);
　　}
　　else {
　　　　goto err;
　　}

　　close(fd);
　　return 0;

err:
　　if (fd > 0) {
　　　　close(fd);
　　}
　　usage(argv[0]);
　　return -1;

}```
在main()函数中，涉及了open()函数，其原型如下：

int open( const char * pathname,int flags, mode_t mode);`
当然，很多open函数中的入口参数也只有2个，原型如下：

int open( const char * pathname, int flags);```
第一个参数pathname是一个指向将要打开的设备文件途径的字符串。

第二个参数flags是打开文件所能使用的旗标，常用的几种旗标有：

O_RDONLY：以只读方式打开文件
O_WRONLY：以只写方式打开文件
O_RDWR：以可读写方式打开文件`
上述3种常用的旗标是互斥使用，但可与其他的旗标进行或运算符组合。

第3个参数mode是使用该文件的权限。比如777、755等。

通过这个应用程序实现对LED驱动程序的控制，为了更加方便快捷地编译这个应用程序，为其写一个Makefile文件，如下所示：

#交叉编译链安装路径
CC = /usr/local/arm/4.4.1/bin/arm-linux-gcc

zzq_led_app:zzq_led_app.o
　　　　$(CC) -o zzq_led_appzzq_led_app.o

zzq_led_app.o:zzq_led_app.c
　　　　$(CC) -c zzq_led_app.c

clean :
　　　　rm zzq_led_app.o zzq_led_app```
执行Makefile之后会生成zzq_led_app可执行应用文件，如下：

zhuzhaoqi@zhuzhaoqi-desktop:～/LDD/linux-3.8.3/zzq_led$ make
/usr/local/arm/4.4.1/bin/arm-linux-gcc -c zzq_led_app.c
/usr/local/arm/4.4.1/bin/arm-linux-gcc -o zzq_led_app zzq_led_app.o
zhuzhaoqi@zhuzhaoqi-desktop:～/LDD/linux-3.8.3/zzq_led$ ls
Makefile　zzq_led_app　zzq_led_app.c　zzq_led_app.o　zzq_led.c`
将生成的zzq_led_app可执行应用文件拷贝到根文件系统的/usr/bin目录下，执行应用文件，如下操作：

[YJR@zhuzhaoqi]\# ./zzq_led_app 
How to use: 
　　./zzq_led_app <LED Number><on/off>
　　LED Number = 1, 2, 3 or 4```
根据信息提示可以进行对LED驱动程序的控制，点亮LED1，则如下：

[YJR@zhuzhaoqi]# ./zzq_led_app 1 on
The GPMCON 0 is fffffff1
The GPMCON 1 is fffffff1
The GPMCON 2 is fffffff1
The GPMCON 3 is fffffff1
zhuzhaoqi >>> LED open...
LED ioctl...
LED ON
S3C64XX_GPM(i) = 0
LED release...
open /dev/led ok ...`
此时可以看到LED1点亮。

12260036.jpg本节配套视频位于光盘中“嵌入式Linux开发实用教程视频”目录下第四章01课（字符设备驱动之LED）。

4.2.2 ADC驱动程序设计

A/D转换即是将模拟量转换为数字量，在物联网迅速发展的今天，作为物联网的感知前端传感器也随之迅速更新，压力、温度、湿度等众多模拟信号的处理都需要涉及A/D转换，因此A/D驱动程序在学习嵌入式中占据着重要地位。

1．S3C6410的ADC控制寄存器简介
S3C6410控制芯片自带有4路独立专用A/D转换通道，如图4.3所示。

通过三星公司提供的《S3C6410用户手册》可知，ADCCON为ADC控制寄存器，地址为：0x7E00 B0000。ADCCON的复位值为：0x3FC4，即为：0011 1111 1100 0100。

#define S3C_ADCREG(x) 　　　　　　(x)
#define S3C_ADCCON　　　　　　    S3C_ADCREG(0x00)```
ADCCON控制寄存器具有16位，每一位都能通过赋值来实现其相对应的功能。

ADCCON[0]：ENABLE_START，A/D 转换开始启用。如果READ_START 启用，这个值是无效的。ENABLE_START = 0，无行动；ENABLE_START = 1，A/D 转换开始和该位被清理后开启。ADCCON[0]的复位值为0，即复位之后默认为无行动。

define S3C_ADCCON_NO_ENABLE_START　　　　(0<<0)

define S3C_ADCCON_ENABLE_START　　　　(1<<0)`

ADCCON[1]：READ_START，A/D 转换开始读取。READ_START = 0，禁用开始读操作；READ_START = 1，启动开始读操作。ADCCON[1]的复位值为0，禁用开始读操作。

#define S3C_ADCCON_NO_READ_START　　　　(0<<1)
#define S3C_ADCCON_READ_START　　　　(1<<1)```
ADCCON[2]：STDBM，待机模式选择。STDBM = 0，正常运作模式；STDBM = 1，待机模式。ADCCON[2]的复位值为1，待机模式。

define S3C_ADCCON_RUN　　　　(0<<2)

define S3C_ADCCON_STDBM　　　　(1<<2)`

ADCCON[5:3]：SEL_MUX，模拟输入通道选择。SEL_MUX = 000，AIN0；SEL_MUX = 001，AIN1；SEL_MUX = 010，AIN2；SEL_MUX = 011，AIN3；SEL_MUX = 100，YM；SEL_MUX = 101，YP；SEL_MUX = 110，XM；SEL_MUX = 111，XP。ADCCON[5:3]的复位值为000，选用AIN0通道。

#define S3C_ADCCON_RESSEL_10BIT_1　　(0x0<<3)
#define S3C_ADCCON_RESSEL_12BIT_1　　(0x1<<3)
#define S3C_ADCCON_MUXMASK　　　　(0x7<<3)
#define S3C_ADCCON_SELMUX(x)　　　　(((x)&0x7)<<3) //任意通道的选择```
ADCCON[13:6]：PRSCVL，ADC 预定标器值0xFF。数据值：5～255。ADCCON[13:6]的复位值为1111 1111，即为0xFF。

define S3C_ADCCON_PRSCVL(x)　　　　(((x)&0xFF)<<6) // 任意值设定

define S3C_ADCCON_PRSCVLMASK　　　　(0xFF<<6) //复位值`

ADCCON[14]：PRSCEN，ADC预定标器启动。PRSCEN = 0，禁用；PRSCEN = 0，启用。ADCCON[14]的复位值为0，禁用ADC预定标器。

#define S3C_ADCCON_NO_PRSCEN　　　　(0<<14)
#define S3C_ADCCON_PRSCEN　　　　(1<<14)```
ADCCON[15]：ECFLG，转换的结束标记（只读）。ECFLG = 0，A/D 转换的过程中；ECFLG = 1，A/D 转换结束。ADCCON[15]的复位值为0，A/D 转换的过程中。

define S3C_ADCCON_ECFLG_ING　　　　(0<<15)

define S3C_ADCCON_ECFLG　　　　(1<<15)`

ADCDAT0寄存器为ADC 的数据转换寄存器。地址为：0x7E00B00C。

ADCDAT0[9:0]：XPDATA，X 坐标的数据转换（包括正常的ADC 的转换数据值）。数据值： 0x000～0x3FF。

ADCDAT0[11:10]：保留。当启用12位AD时作为转换数据值使用。

#define S3C_ADCDAT0_XPDATA_MASK　　　　(0x03FF)
#define S3C_ADCDAT0_XPDATA_MASK_12BIT　　(0x0FFF)```
上面所介绍的是专用A/D转换通道常用寄存器，LCD触摸屏A/D转换有另外的A/D通道。

2．ADC驱动程序
A/D转化驱动由于也属于字符设备驱动，所以其程序设计流程和LED驱动大体一致。在linux-3.8.3/drivers/char目录下新建zzqadc.c驱动文件，当然也可写好之后再拷贝到linux-3.8.3/ drivers/char目录下。

zhuzhaoqi@zhuzhaoqi-desktop:～/Linux/linux-3.8.3/drivers/char$ vim zzqadc.c`
头文件是必不可少的，A/D驱动程序所要包含的头文件如下所示：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/serio.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/sched.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>

#include <asm/io.h>
#include <asm/irq.h>
#include <asm/uaccess.h>

#include <mach/map.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>

#include <plat/regs-adc.h>```
与LED驱动程序所包含的头文件相比较，多了ADC专用的头文件，如regs-adc.h，这个头文件位于linux-3.8.3/arch/arm/plat-samsung/include/plat目录下。

static void __iomem *base_addr;
static struct clk *adc_clock;

define　 __ADCREG(name)　 ((unsigned long int )(base_addr + name))

自从linux-2.6.9版本开始便把_iomem加入内核，_iomem是表示指向一个I/O的内存空间。将_iomem加入linux，主要是考虑到驱动程序的通用性。由于不同的CPU体系结构对I/O空间的表示可能不同，但是当使用_iomem时，就会忽略对变量的检查，因为_iomem使用的是void。

define　 S3C_ADCREG(x)　　　(x)

define　 S3C_ADCCON　　　　 S3C_ADCREG(0x00)

define　 S3C_ADCDAT0　　　　S3C_ADCREG(0x0C)

/ ADC contrl /

define　 ADCCON　　　　　　 _ADCREG(S3C_ADCCON)

/ read the ADdata /

define　 ADCDAT0　　　　　　_ADCREG(S3C_ADCCON)`

声明ADC控制寄存器的地址。

/* The set of ADCCON */
#define　 S3C_ADCCON_ENABLE_START　　　　　 (1 << 0)
#define　 S3C_ADCCON_READ_START　　　　　　 (1 << 1)
#define　 S3C_ADCCON_RUN　　　　　　　　　　(0 << 2)
#define　 S3C_ADCCON_STDBM　　　　　　　　　(1 << 2)
#define　 S3C_ADCCON_SELMUX(x)　　　　　　　( ((x)&0x7) << 3 )
#define　 S3C_ADCCON_PRSCVL(x)　　　　　　　( ((x)&0xFF) << 6 )
#define　 S3C_ADCCON_PRSCEN　　　　　　　　 (1 << 14)
#define　 S3C_ADCCON_ECFLG　　　　　　　　　(1 << 15)

/* The set of ADCDAT0 */
#define　 S3C_ADCDAT0_XPDATA_MASK　　　　　 (0x03FF)
#define　 S3C_ADCDAT0_XPDATA_MASK_12BIT　　(0x0FFF)```
根据上一小节对ADCCON和ADCDAT0的介绍，可以很容易写出上面的宏定义。

在使用ADC之前，先得对ADC进行初始化设置，由于OK6410开发平台自带的A/D电压采样电路选用的是AIN0通道，则这里需要对AIN0进行初始化。初始化阶段需要完成的事情为：A/D 转换开始和该位被清理后开启、正常运作模式、模拟输入通道选择AIN0、ADC 预定标器值0xFF、ADC预定标器启动。

/*
*　AIN0 init　
*/
static int adc_init(void)
{

　　ADCCON = S3C_ADCCON_PRSCEN | S3C_ADCCON_PRSCVL(0xFF) | \
　S3C_ADCCON_SELMUX(0x00) | S3C_ADCCON_RUN;
ADCCON |=S3C_ADCCON_ENABLE_START;

　　return 0;
}`
open函数指针的实现函数adc_open()：

/*
 *　open dev
 */
static int adc_open(struct inode *inode, struct file *filp)
{
　　adc_init();
　　return 0;
}
release函数指针的实现函数adc_release()：

/*
 *　release dev
 */
static int adc_release(struct inode *inode,struct file *filp)
{
　　return 0;
}```
read()函数指针的实现函数adc_read()，这个函数的作用是读取ADC采样数据。

/*

• adc_read
  */

static ssize_t adc_read(struct file filp, char __user buff,
size_t size, loff_t *ppos)
{
　　ADCCON |= S3C_ADCCON_READ_START;
　　/ check the adc Enabled ,The [0] is low/
　　while(ADCCON & 0x01);
　　/ check adc change end /
　　while(!(ADCCON & 0x8000));
　　
/ return the data of adc /
　　return (ADCDAT0 & S3C_ADCDAT0_XPDATA_MASK);
}`
ADC驱动程序的核心控制部分：

static struct file_operations dev_fops =
{
　　.owner　 = THIS_MODULE,
　　.open　　= adc_open,
　　.release = adc_release,
　　.read　　= adc_read,
};
static struct miscdevice misc =
{
　　.minor = MISC_DYNAMIC_MINOR,
　　.name　= “zzqadc“,
　　.fops　= &dev_fops,
};```
加载insmod驱动程序，如下所示：

static int __init dev_init()
{
　　int ret;

　　/ Address Mapping /
　　base_addr = ioremap(SAMSUNG_PA_ADC,0X20);
　　if(base_addr == NULL)
　　{
　　　　printk(KERN_ERR"failed to remap n");
　　　　return -ENOMEM;
　　}

　　/ Enabld acd clock /
　　adc_clock = clk_get(NULL,"adc");
　　if(!adc_clock)
　　{
　　　　printk(KERN_ERR"failed to get adc clock n");
　　　　return -ENOENT;
　　}
　　clk_enable(adc_clock);

　　ret = misc_register(&misc);
　　printk("dev_init return ret: %d n", ret);

　　return ret;
}`
加载insmod驱动程序，这里使用到了ioremap()函数。在内核驱动程序的初始化阶段，通过ioremap()函数将物理地址映射到内核虚拟空间；在驱动程序的mmap系统调用中，使用remap_page_range()函数将该块ROM映射到用户虚拟空间。这样内核空间和用户空间都能访问这段被映射后的虚拟地址。

ioremap()宏定义在asm/io.h内：

　　#define ioremap(cookie,size)　　　　　 __ioremap(cookie,size,0)
_ioremap函数原型为（arm/mm/ioremap.c）：

　　void _iomem * _ioremap(unsigned long phys_addr, size_t size, unsigned longflags);```
phys_addr：要映射的起始的I/O地址；

size：要映射的空间的大小；

flags：要映射的I/O空间和权限有关的标志。

该函数返回映射后的内核虚拟地址（3GB～4GB），接着便可以通过读写该返回的内核虚拟地址去访问之这段I/O内存资源。

base_addr = ioremap(SAMSUNG_PA_ADC,0X20);`
这行代码即是将SAMSUNG_PA_ADC（0x7E00 B000）映射到内核，返回内核的虚拟地址给base_addr。

clk_get（NULL,"adc"）可以获得adc时钟，每一个外设都有自己的工作频率，PRSCVL是A/D转换器时钟的预分频功能时A/D时钟的计算公式，A/D时钟　= PCLK / （PRSCVL+1）。

注意：AD时钟最大为2.5MHz并且应该小于PCLK的1/5。

　　adc_clock = clk_get(NULL,"adc");```
即为获取adc的工作时钟频率。

ret = misc_register(&misc);`
创建杂项设备节点。这里使用到了杂项设备，杂项设备也是在嵌入式系统中用得比较多的一种设备驱动。在 Linux 内核的include/linux目录下有miscdevice.h文件，要把自己定义的misc device从设备定义到这里。其实是因为这些字符设备不符合预先确定的字符设备范畴，所有这些设备采用主编号10，一起归于misc device，其实misc_register就是用主标号10调用register_chrdev()的。也就是说，misc设备其实也就是特殊的字符设备，可自动生成设备节点。

卸载rmmod驱动程序：

static void __exit dev_exit()
{
　　iounmap(base_addr);

　　/* disable ths adc clock */
　　if(adc_clock)
　　{
　　　　clk_disable(adc_clock);
　　　　clk_put(adc_clock);
　　　　adc_clock = NULL;
　　}

　　misc_deregister(&misc);
}```
许可证声明、作者信息、调用加载和卸载程序：

MODULE_LICENSE("GPL");
MODULE_AUTHOR("zhuzhaoqi jxlgzzq@163.com");

module_init(dev_init);
module_exit(dev_exit);`
在/linux-3.8.3/drivers/char目录下的Makefile中添加：

obj-m　　　　　　　　　　　　　 += zzqadc.o```
回到/linux-3.8.3根目录下：

/home/zhuzhaoqi/Linux/linux-3.8.3# make modules`
将/linux-3.8.3/drivers/char目录下生成的zzqadc.ko拷贝到文件系统的/lib/module/3.8.3目录中。

3．ADC应用程序
ADC应用程序也是相对简单，打开设备驱动文件之后进行数据读取即可。

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main()
{
　　int fp,adc_data,i;
　　fp = open("/dev/zzqadc",O_RDWR);

　　if (fp < 0)
　　{
　　　　printf("open failed! \n");
　　}
　　printf("opened ... \n");

　　for ( ; ; i++)
　　{
　　　　adc_data = read(fp,NULL,0);
　　　　printf("Begin the NO. %d test... \n",i);
　　　　printf("adc_data = %d \n",adc_data);
　　　　printf("The Value = %f V \n" , ( (float)adc_data )* 3.3 / 1024);
　　　　printf("End the NO. %d test ...... \n \n",i);

　　　　sleep(1);
　　}

　　close(fp);
　　return 0;
}```
由于本次使用的A/D转换是10位，则数据转换值即为1024，而OK6410的参考电压是3.3V，则A/D采集数据和电压之间的转换公式为：（float）adc_data ）* 3.3 / 1024。

为ADC应用程序编写Makefile：

CC = /usr/local/arm/4.4.1/bin/arm-linux-gcc

zzqadcapp:zzqadcapp.o
　　　　$(CC) -o zzqadcapp zzqadcapp.o

zzqadcapp.o:zzqadcapp.c
　　　　$(CC) -c zzqadcapp.c

clean :
　　　　rm zzqadcapp.o zzqadcapp`
将生成的zzqadcapp应用文件拷贝到文件系统/usr/bin文件夹下。

加载zzqadc.ko设备：

[YJR@zhuzhaoqi 3.8.3]# insmod zzqadc.ko 
dev_init return ret: 0

[YJR@zhuzhaoqi]\# ls -l /dev/zzqadc
crw-rw----　　1 root　　 root　　　10,　60 Jan　1 08:00 /dev/zzqadc```
在/dev目录下存在zzqadc设备节点，则说明ADC驱动加载成功。

执行ADC应用程序，电压采样如下所示：

[YJR@zhuzhaoqi]# ./zzqadcapp
opened ...
……
Begin the NO. 10 test...
adc_data = 962
The Value = 3.100195 V
End the NO. 10 test ......
……`