结构体s3c＿device＿adc定义在以下文件：

rchrmplat－samsungDevs．c
＃ifdef CONFIG＿PLAT＿S3C24XX
static struct resource s3c＿adc＿resource［］ ＝ ｛
 ［0］ ＝ DEFINE＿RES＿MEM（S3C24XX＿PA＿ADC， S3C24XX＿SZ＿ADC），
 ［1］ ＝ DEFINE＿RES＿IRQ（IRQ＿TC），
 ［2］ ＝ DEFINE＿RES＿IRQ（IRQ＿ADC），
｝；
struct platform＿device s3c＿device＿adc ＝ ｛
 ．name    ＝ ＂s3c24xx－adc＂，
 ．id    ＝ －1，
 ．num＿resources  ＝ ARRAY＿SIZE（s3c＿adc＿resource），
 ．resource  ＝ s3c＿adc＿resource，
｝；
＃endif  CONFIG＿PLAT＿S3C24XX
＃if defined（CONFIG＿SAMSUNG＿DEV＿ADC）
static struct resource s3c＿adc＿resource［］ ＝ ｛
 ［0］ ＝ DEFINE＿RES＿MEM（SAMSUNG＿PA＿ADC， SZ＿256），
 ［1］ ＝ DEFINE＿RES＿IRQ（IRQ＿TC），
 ［2］ ＝ DEFINE＿RES＿IRQ（IRQ＿ADC），
｝；
struct platform＿device s3c＿device＿adc ＝ ｛
 ．name    ＝ ＂samsung－adc＂，
 ．id    ＝ －1，
 ．num＿resources  ＝ ARRAY＿SIZE（s3c＿adc＿resource），
 ．resource  ＝ s3c＿adc＿resource，
｝；
＃endif  CONFIG＿SAMSUNG＿DEV＿ADC

由代码可知，平台驱动对应的platform＿device具体内容由宏CONFIG＿PLAT＿S3C24XX、CONFIG＿SAMSUNG＿DEV＿ADC来控制。驱动编写架构和流程如下

read（）
｛
      1、向adc设备发送要读取的命令
         ADCCON    1＜＜0 ｜ 1＜＜14 ｜ 0X1＜＜16 ｜ 0XFF＜＜6
      2、读取不到数据就休眠
           wait＿event＿interruptible（）；
      3、等待被唤醒读数据
         havedata ＝ 0；
｝
adc＿handler（）
｛
      1、清中断 ADC使用中断来通知转换数据完毕的
      2、状态位置位；
           havedata＝1；
      3、唤醒阻塞进程
           wake＿up（）
｝
probe（）
｛
     1、读取中断号，注册中断处理函数
     2、读取寄存器的地址，ioremap
     3、字符设备的操作
｝

驱动需要首先捕获中断信号后再去寄存器读取相应的数据，在ADC控制器没有准备好数据之前，应用层需要阻塞读取数据，所以在读取数据的函数中，需要借助等待队列来实现驱动对应用进程的阻塞。驱动程序

驱动程序对寄存器的操作参考裸机程序，只是基地址需要通过ioremap（）做映射，对寄存器的读写操作需要用readl、writel。

driver．c

＃include ＜linux／module．h＞
＃include ＜linux／device．h＞
＃include ＜linux／platform＿device．h＞
＃include ＜linux／interrupt．h＞
＃include ＜linux／fs．h＞
＃include ＜linux／wait．h＞
＃include ＜linux／sched．h＞
＃include ＜asm／uaccess．h＞
＃include ＜asm／io．h＞
static int major ＝ 250；


static wait＿queue＿head＿t wq；
static int have＿data ＝ 0；
static int adc；
static struct resource ＊res1；
static struct resource ＊res2；
static void ＊adc＿base；

＃define ADCCON 0x0000
＃define ADCDLY 0x0008
＃define ADCDAT 0x000C
＃define CLRINTADC 0x0018
＃define ADCMUX 0x001C


static  irqreturn＿t adc＿handler（int irqno， void ＊dev）
｛
 have＿data ＝ 1；

 printk（＂11111＂）；
 清中断
 writel（0x12，adc＿base ＋ CLRINTADC）；
 wake＿up＿interruptible（＆wq）；
 return IRQ＿HANDLED；
｝
static int adc＿open （struct inode ＊inod， struct file ＊filep）
｛

 return 0；
｝
static ssize＿t adc＿read（struct file ＊filep， char ＿＿user ＊buf， size＿t len， loff＿t ＊pos）
｛
   writel（0x3，adc＿base ＋ ADCMUX）；
 writel（1＜＜0 ｜ 1＜＜14 ｜ 0X1＜＜16 ｜ 0XFF＜＜6 ，adc＿base ＋ADCCON ）；

 wait＿event＿interruptible（wq， have＿data＝＝1）；

 read data
 adc ＝ readl（adc＿base＋ADCDAT）＆0xfff；
 
 if（copy＿to＿user（buf，＆adc，sizeof（int）））
 ｛
   return －EFAULT；
 ｝
 have＿data ＝ 0；
 return len；
｝
static  int adc＿release（struct inode ＊inode， struct file ＊filep）
｛
 return 0；
｝
static struct file＿operations  adc＿ops ＝
｛
 ．open ＝ adc＿open，
 ．release ＝ adc＿release，
 ．read ＝ adc＿read，
｝；


static int hello＿probe（struct platform＿device ＊pdev）
｛
 int ret；
 printk（＂match 0k ＂）；

 res1 ＝ platform＿get＿resource（pdev，IORESOURCE＿IRQ， 0）；
   res2 ＝ platform＿get＿resource（pdev，IORESOURCE＿MEM， 0）；
   
 ret ＝ request＿irq（res1－＞start，adc＿handler，IRQF＿DISABLED，＂adc1＂，NULL）；
     adc＿base ＝ ioremap（res2－＞start，res2－＞end－res2－＞start）；

 register＿chrdev（ major， ＂adc＂， ＆adc＿ops）；
 init＿waitqueue＿head（＆wq）；
 
 return 0；
｝
static int hello＿remove（struct platform＿device ＊pdev）
｛
 free＿irq（res1－＞start，NULL）；
 free＿irq（res2－＞start，NULL）；  
 unregister＿chrdev（ major， ＂adc＂）；
 return 0；
｝

static struct of＿device＿id adc＿id［］＝
｛
 ｛．compatible ＝ ＂fs4412，adc＂ ｝，
｝；

static struct platform＿driver hello＿driver＝
｛
 
 ．probe ＝ hello＿probe，
 ．remove ＝ hello＿remove，
 ．driver ＝｛
   ．name ＝ ＂bigbang＂，
   ．of＿match＿table ＝ adc＿id，
 ｝，
｝；

static int hello＿init（void）
｛
 printk（＂hello＿init＂）；
 return platform＿driver＿register（＆hello＿driver）；
｝
static void hello＿exit（void）
｛
 platform＿driver＿unregister（＆hello＿driver）；
 printk（＂hello＿exit ＂）；
 return；
｝
MODULE＿LICENSE（＂GPL＂）；
module＿init（hello＿init）；
module＿exit（hello＿exit）；

测试程序

test．c

＃include ＜sys／types．h＞
＃include ＜sys／stat．h＞
＃include ＜fcntl．h＞
＃include ＜stdio．h＞

main（）
｛
 int fd，len；
 int adc；
 fd ＝ open（＂／dev／hello＂，O＿RDWR）；
 if（fd＜0）
 ｛
   perror（＂open fail ＂）；
   return ；
 ｝

 while（1）
 ｛
   read（fd，＆adc，4）；
   printf（＂adc％0．2f V ＂，（1．8＊adc）／4096）；
 ｝

 close（fd）；
｝