linux-2.2.12内核的ADC驱动程序----光敏，电池电量

以下是我参考网络上嵌入式linux之我行的博文，对我的驱动程序进行了更改，我的驱动程序没有写时钟操作，导致驱动卡死，读不出数据。
static int __init adc_init(void)
{
    int ret;
 
/*从平台时钟队列中获取ADC的时钟，这里为什么要取得这个时钟，因为ADC的转换频率跟时钟有关。
系统的一些时钟定义在arch/arm/plat-s3c24xx /s3c2410-clock.c中*/
    adc_clk = clk_get(NULL, "adc");
    if (!adc_clk)
    {
/*错误处理*/
        printk(KERN_ERR "failed to find adc clock source\n");
        return -ENOENT;
    }
 
/*时钟获取后要使能后才可以使用，clk_enable定义在arch/arm/plat-s3c/clock.c中*/
    clk_enable(adc_clk);
........
........省略其他程序代码
}

加载时钟后在驱动模块退出程序时要记得销毁时钟
static void __exit adc_exit(void)
{
    free_irq(IRQ_ADC, 1);/*释放中断*/
    iounmap(adc_base);/*释放虚拟地址映射空间*/
 
    if (adc_clk)/*屏蔽和销毁时钟*/
    {
        clk_disable(adc_clk);    
        clk_put(adc_clk);
        adc_clk = NULL;
    }
 
    misc_deregister(&adc_miscdev);/*注销misc设备*/
}

以下是我的ADC驱动程序，采集光敏的硬件接在了AIN1 采集电池电量的接在了AIN0 的管脚，判断是否插入电源接在了GPJ9管脚

#include <linux/kernel.h>
#include <linux/module.h>

#include <asm/uaccess.h>
#include <linux/mm.h>
#include <linux/ioport.h>

#include <asm/io.h>
#include <linux/ioport.h>
#include <linux/fs.h>
#include <linux/devfs_fs_kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/serio.h>
#include <linux/miscdevice.h>
#include <asm/irq.h>

 

#define ADC_MAJOR 113              //定义主设备号
#define DEVICE_NAME  "adc_dev"     //定义设备名称
#define SUCCESS   0

#define adc_con   (unsigned long)ioremap(0x58000000,4)
#define adc_dat0  (volatile unsigned long)ioremap(0x5800000c,4)
#define gpj_con   (unsigned long)ioremap(0x560000d0,4)//gpj9
#define gpj_dat   (unsigned long)ioremap(0x560000d4,4)//

static int Device_Open = 0;

int adc_init(void);
void adc_cleanup(void);
static int device_open(struct inode *,struct file *);
static int device_release(struct inode *,struct file *);
static ssize_t device_read(struct file *,char *,size_t,loff_t *);
int init_module(void);
void cleanup_module(void);

 

struct file_operations  adc_ops =            // 该结构包含在<linux/fs.h>中
{                                      //结构中的每个字段指向驱动程序中实现特定的函数
 .owner = THIS_MODULE,
 .read     =   device_read,
 .open =   device_open,
 .release = device_release,
};
static int Major;
static struct clk *adc_clk;
int __init adc_init(void)               //初始化
{

 /*从平台时钟队列中获取ADC的时钟，这里为什么要取得这个时钟，因为ADC的转换频率跟时钟有关。
  * 系统的一些时钟定义在arch/arm/plat-s3c24xx /s3c2410-clock.c中*/
     adc_clk = clk_get(NULL, "adc");
  if (!adc_clk)
      {
      /*错误处理*/
   printk(KERN_ERR "failed to find adc clock source\n");
      return -ENOENT;
  }
   
   /*时钟获取后要使能后才可以使用，clk_enable定义在arch/arm/plat-s3c/clock.c中*/
 clk_enable(adc_clk);
 
 Major = register_chrdev(ADC_MAJOR,DEVICE_NAME,&adc_ops);  //注册操作，返回主设备值
 if(Major <0)
 {
  printk("ADC init_module:failed with %d\n",Major);    //主设备号小于0，则注册失败
  return Major;
 }
 Major = ADC_MAJOR;
 devfs_mk_cdev(MKDEV(ADC_MAJOR, 0), S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP, DEVICE_NAME);
 
 __raw_writel((1<<14)|(0x8f<<6), adc_con);       //设置ADCCON
 //__raw_writel(__raw_readl(adc_con)|0x1, adc_con); //设置自动启动
 *(unsigned long *)gpj_con &= ~(0x3<<18);
 printk("ADC registered: Major = %d\n",Major);
 
 return 0;
}

static int device_open(struct inode * inode,struct file *file)        //与应用程序中open函数对应的驱动函数
{
    if(Device_Open)
    {
        return -EBUSY;
    }
    Device_Open++;
    return SUCCESS;
}

static int device_release(struct inode * inode,struct file *file)
{
    Device_Open --;
    return 0;
}

static ssize_t device_read(struct file *file,
                            char * buffer,
                            size_t length,
                            loff_t * offset)
{
 unsigned long j;
 char i,a;
 char data[2];
 
 /*for(i=0;i<2;i++){
  printk("read testi=%d \n",i);
  if(i==0) __raw_writel(__raw_readl(adc_con)&(~(0x7<<3)),adc_con); 
  if(i==1) __raw_writel((__raw_readl(adc_con)&(~(0x7<<3)))|(0x1<<3),adc_con);
  //__raw_writel((1<<14)|(0x5<<6)|(1<<3), adc_con);       //设置ADCCON
  __raw_writel(__raw_readl(adc_con)|0x1, adc_con);  //启动AD转换
  while(__raw_readl(adc_con) &0x1);              //启动转换后，等待启动位清零
      while(!(__raw_readl(adc_con) & 0x8000));            //等待转换是否完毕
  buf=__raw_readl(adc_dat0) & 0x3ff;                 //取出转换后得到的有效数据
  *buffer=(unsigned char)buf;
  buffer++;
  *buffer=(unsigned char)(buf>>8);
  buffer++;
 }*/
 i = *buffer;
 buffer++;
 if (i==1)
 { 
  __raw_writel(__raw_readl(adc_con)&(~(0x7<<3)),adc_con); 
  __raw_writel(__raw_readl(adc_con)|0x1, adc_con);  //启动AD转换
  while(__raw_readl(adc_con) &0x1);              //启动转换后，等待启动位清零
      while(!(__raw_readl(adc_con) & 0x8000));            //等待转换是否完毕
  j=__raw_readl(adc_dat0) & 0x3ff;                 //取出转换后得到的有效数据
  data[0]=(unsigned char)j;
  data[1]=(unsigned char)(j>>8);
  copy_to_user(buffer, data, 2);

 }
  else if(i==2)
 { 
  __raw_writel((__raw_readl(adc_con)&(~(0x7<<3)))|(0x1<<3),adc_con);
  __raw_writel(__raw_readl(adc_con)|0x1, adc_con);  //启动AD转换
  while(__raw_readl(adc_con) &0x1);              //启动转换后，等待启动位清零
      while(!(__raw_readl(adc_con) & 0x8000));            //等待转换是否完毕
  j=__raw_readl(adc_dat0) & 0x3ff;                 //取出转换后得到的有效数据
  data[0]=(unsigned char)j;
  data[1]=(unsigned char)(j>>8);
  copy_to_user(buffer, data, 2);
  }
 else if(i==3)
 {
  a = ((*(unsigned long *)gpj_dat)>>9) & 0x1;
  data[0] = a;
  data[1] = 0;
  copy_to_user(buffer, data, 2);   
  }
 return 2;
}

void adc_cleanup()            //卸载驱动时执行该函数
{
    int ret;
    if (adc_clk)/*屏蔽和销毁时钟*/
 {
       clk_disable(adc_clk);    
    clk_put(adc_clk);
    adc_clk = NULL;
     }

        iounmap((void *)adc_con);
        iounmap((void *)adc_dat0);
    ret = unregister_chrdev(Major,DEVICE_NAME);     //注销驱动
    if(ret < 0)                                    //返回值小于0时注销失败
    {
        printk("unregister_chrdev:error %d\n",ret); 
    } 
}
module_init(adc_init);        
module_exit(adc_cleanup);
MODULE_LICENSE("GPL");

附上我的测试程序
#include "stdlib.h"
#include "termios.h"
#include "sys/time.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>

static int getch(void)                    //定义函数在终端上获得输入，并把输入的量（int）返回
{
 struct termios oldt,newt;             //终端结构体struct termios
 int ch;

 if (!isatty(STDIN_FILENO)) {                       //判断串口是否与标准输入相连
    fprintf(stderr, "this problem should be run at a terminal\n");           
    exit(1);
 }
// save terminal setting
 if(tcgetattr(STDIN_FILENO, &oldt) < 0) {        //获取终端的设置参数
    perror("save the terminal setting");
    exit(1);
 }
// set terminal as need
 newt = oldt;
 newt.c_lflag &= ~( ICANON | ECHO );                    //控制终端编辑功能参数ICANON 表示使用标准输入模式；参数ECH0表示显示输入字符
 if(tcsetattr(STDIN_FILENO,TCSANOW, &newt) < 0) {   //保存新的终端参数
    perror("set terminal");
    exit(1);
 }

 ch = getchar();

// restore termial setting
 if(tcsetattr(STDIN_FILENO,TCSANOW,&oldt) < 0) {           //恢复保存旧的终端参数
    perror("restore the termial setting");
    exit(1);
 }
 return ch;
}

/********************************
num=1，读光耦
num=2，读电池电压
num=3，读是否正在充电，正在充电返回1，没有返回0
*********************************/
unsigned short r_from_ad(int fd,int num)
{
 unsigned short adcdata;
 char buf[3];
 buf[0]=num;
 read(fd,buf,2);
 adcdata = buf[2];
 adcdata = (adcdata<<8)|buf[1];
// printf("adcdata%d=%d ",num,adcdata);
 return adcdata;
 
}

char adc_judge(int adc)
{
    int i;
    i = adc;
    if(0 < i <=200) return 5;
    else if(200 < i <= 400) return 4;
    else if(400 < i <= 600) return 3;
    else if(600 < i <= 800) return 2;
    else if(800 < i <= 1023) return 1;
    else return 6;
}
/********************************
电池电压范围为1.9v到2.8v，分六档，每0.15v一档
*********************************/
char pow_adc_judge(int adc)
{
 int i;
 i=adc;
 if(0 < i <=636) return 1;
 else if(637 < i <= 682) return 2;
 else if(683 < i <= 729) return 3;
 else if(730 < i <= 775) return 4;
 else if(776 < i <= 822) return 5;
 else if(823 < i <= 1023) return 6;
}

int main()
{
 int ad,pwm,ret;
 unsigned short adc;
        char adcjud=0,buf[3];
        static char cha,adccha=0;
        ad=open("/dev/adc_dev",O_RDONLY);
 //pwm=open("/dev/pwm_dev",O_RDWR);
 if(ad<0)
        {
                printf("open adc error\n");
                exit(1);
        }
 else printf("open sucess \n");
  //else if(pwm<0)
 //{
  //printf("can't open device\n");
  //return(0);
 //}      
 while(1)   
                { 
   adc = r_from_ad(ad,2);
                        /*adcjud = adc_judge(adc);
                        if(adccha!=adcjud)
                        {
                            adccha = adcjud;
                            cha=1;
                        }
                        else cha=0;
                        if (cha==1) ioctl(pwm,adcjud);
   printf("adc=%d \n",adc);
                        sleep(1);*/
   //adc=r_from_ad(fd,2);
   printf("adc=%d \n",adc);
   sleep(1);
                }

        close(ad);
 close(pwm);
}

以下是我借鉴的一篇博文

嵌入式Linux之我行，主要讲述和总结了本人在学习嵌入式linux中的每个步骤。一为总结经验，二希望能给想入门嵌入式Linux的朋友提 供方便。如有错误之处，谢请指正。
一、开发环境
主  机：VMWare--Fedora 9
开发板：Mini2440--64MB Nand, Kernel:2.6.30.4
编译器：arm-linux-gcc-4.3.2
二、硬件原理分析
S3C2440内部ADC结构图

我们从上面的结构图和数据手册可以知道，该ADC模块总共有8个通道可以进行模拟信号的输入，分别是AIN0、AIN1、AIN2、AIN3、 YM、YP、XM、XP。那么ADC是怎么实现模拟信号到数字信号的转换呢？首先模拟信号从任一通道输入，然后设定寄存器中预分频器的值来确定AD转换器 频率，最后ADC将模拟信号转换为数字信号保存到ADC数据寄存器0中(ADCDAT0)，然后ADCDAT0中的数据可以通过中断或查询的方式来访问。 对于ADC的各寄存器的操作和注意事项请参阅数据手册。

上图是mini2440上的ADC应用实例，开发板通过一个10K的电位器(可变电阻)来产生电压模拟信号，然后通过第一个通道(即：AIN0)将 模拟信号输入ADC。
三、实现步骤
ADC设备在Linux中可以看做是简单的字符设备，也可以当做是一混杂设备(misc设备)，这里我们就看做是misc设备来实现ADC的驱动。 注意：这里我们获取AD转换后的数据将采用中断的方式，即当AD转换完成后产生AD中断，在中断服务程序中来读取ADCDAT0的第0-9位的值(即AD 转换后的值)。
1、建立驱动程序文件my2440_adc.c，实现驱动的初始化和退出，代码如下：
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/serio.h>
#include <linux/clk.h>
#include <linux/miscdevice.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
 
/*定义了一个用来保存经过虚拟映射后的内存地址*/
static void __iomem *adc_base;
 
/*保存从平台时钟队列中获取ADC的时钟*/
static struct clk *adc_clk;
 
/*申明并初始化一个信号量ADC_LOCK，对ADC资源进行互斥访问*/
DECLARE_MUTEX(ADC_LOCK);
 
static int __init adc_init(void)
{
    int ret;
 
/*从平台时钟队列中获取ADC的时钟，这里为什么要取得这个时钟，因为ADC的转换频率跟时钟有关。
系统的一些时钟定义在arch/arm/plat-s3c24xx /s3c2410-clock.c中*/
    adc_clk = clk_get(NULL, "adc");
    if (!adc_clk)
    {
/*错误处理*/
        printk(KERN_ERR "failed to find adc clock source\n");
        return -ENOENT;
    }
 
/*时钟获取后要使能后才可以使用，clk_enable定义在arch/arm/plat-s3c/clock.c中*/
    clk_enable(adc_clk);
 
/*将ADC的IO端口占用的这段 IO空间映射到内存的虚拟地址，ioremap定义在io.h中。
注意：IO空间要映射后才能使用，以后对虚拟地址的操作就是对IO空间的操作, S3C2410_PA_ADC
是ADC控制器的基地址，定义在mach-s3c2410/include/mach/map.h中，0x20是虚拟地址长度大小*/
    adc_base = ioremap(S3C2410_PA_ADC, 0x20);
    if (adc_base == NULL)
    {
/*错误处理*/
        printk(KERN_ERR "Failed to remap register block\n");
        ret = -EINVAL;
        goto err_noclk;
    }
 
/*把看ADC注册成为misc设备，misc_register定义在miscdevice.h中adc_miscdev结构体定义
及内部接口函数在第②步中讲,MISC_DYNAMIC_MINOR是次设备号，定义在miscdevice.h中*/
    ret = misc_register(&adc_miscdev);
    if (ret)
    {
/*错误处理*/
        printk(KERN_ERR "cannot register miscdev on minor=%d (%d)\n",
MISC_DYNAMIC_MINOR, ret);
        goto err_nomap;
    }
 
    printk(DEVICE_NAME " initialized!\n");
 
    return 0;
 
//以下是上面错误处理的跳转点
err_noclk:
    clk_disable(adc_clk);
    clk_put(adc_clk);
 
err_nomap:
    iounmap(adc_base);
 
    return ret;
}
 
static void __exit adc_exit(void)
{
    free_irq(IRQ_ADC, 1);/*释放中断*/
    iounmap(adc_base);/*释放虚拟地址映射空间*/
 
    if (adc_clk)/*屏蔽和销毁时钟*/
    {
        clk_disable(adc_clk);    
        clk_put(adc_clk);
        adc_clk = NULL;
    }
 
    misc_deregister(&adc_miscdev);/*注销misc设备*/
}
 
/*导出信号量ADC_LOCK在触摸屏驱动中使用，因为触摸屏驱动和ADC驱动公用
相关的寄存器，为了不产生资源竞态，就用信号量来保证资源的互斥访问*/
EXPORT_SYMBOL(ADC_LOCK);
 
module_init(adc_init);
module_exit(adc_exit);
 
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Huang Gang");
MODULE_DESCRIPTION("My2440 ADC Driver");
2、adc_miscdev结构体定义及内部各接口函数的实现，代码如下：
#include <plat/regs-adc.h>
 
/*设备名称*/
#define DEVICE_NAME    "my2440_adc"
 
/*定义并初始化一个等待队列adc_waitq，对ADC资源进行阻塞访问*/
static DECLARE_WAIT_QUEUE_HEAD(adc_waitq);
 
/*用于标识AD转换后的数据是否可以读取，0表示不可读取*/
static volatile int ev_adc = 0;
 
/*用于保存读取的AD转换后的值，该值在ADC中断中读取*/
static int adc_data;
 
/*misc设备结构体实现*/
static struct miscdevice adc_miscdev =
{
    .minor   = MISC_DYNAMIC_MINOR, /*次设备号，定义在 miscdevice.h中，为255*/
    .name    = DEVICE_NAME,        /* 设备名称*/
    .fops    = &adc_fops,          /*对ADC设备文件操作*/
};
 
/*字符设备的相关操作实现*/
static struct file_operations adc_fops =
{
    .owner    = THIS_MODULE,
    .open     = adc_open,
    .read     = adc_read,    
    .release  = adc_release,
};
 
/*ADC设备驱动的打开接口函数*/
static int adc_open(struct inode *inode, struct file *file)
{
    int ret;
 
/*申请ADC中断服务，这里使用的是共享中断:IRQF_SHARED,为什么要使用共享中断，因为在触摸屏驱动中
也使用了这个中断号。中断服务程序为:adc_irq在下面实现，IRQ_ADC是ADC的中断号，这里注意：
申请中断函数的最后一个参数一定不能为NULL，否则中断申请会失败，如果中断服务程序中用不到这个
参数，就随便给个值就好了，我这里就给个1*/
    ret = request_irq(IRQ_ADC, adc_irq, IRQF_SHARED, DEVICE_NAME, 1);
    if (ret)
    {
/*错误处理*/
        printk(KERN_ERR "IRQ%d error %d\n", IRQ_ADC, ret);
        return -EINVAL;
    }
 
    return 0;
}
 
/*ADC中断服务程序，该服务程序主要是从ADC数据寄存器中读取AD转换后的值*/
static irqreturn_t adc_irq(int irq, void *dev_id)
{
/*保证了应用程序读取一次这里就读取 AD转换的值一次，
避免应用程序读取一次后发生多次中断多次读取AD转换值*/
    if(!ev_adc)
    {
/*读取AD转换后的值保存到全局变量adc_data 中，S3C2410_ADCDAT0定义在regs-adc.h中，
这里为什么要与上一个0x3ff，很简单，因为AD转换后的数据是保存在ADCDAT0的第0-9位，
所以与上0x3ff(即：1111111111)后就得到第0-9位的数据，多余的位就都为0*/
        adc_data = readl(adc_base + S3C2410_ADCDAT0) & 0x3ff;
 
/*将可读标识为1，并唤醒等待队列*/
        ev_adc = 1;
        wake_up_interruptible(&adc_waitq);
    }
 
    return IRQ_HANDLED;
}
 
/*ADC设备驱动的读接口函数*/
static ssize_t adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
/*试着获取信号量(即：加锁)*/
    if (down_trylock(&ADC_LOCK))
    {
        return -EBUSY;
    }
 
    if(!ev_adc)/*表示还没有AD转换后的数据，不可读取*/
    {
        if(filp->f_flags & O_NONBLOCK)
        {
/*应用程序若采用非阻塞方式读取则返回错误*/
            return -EAGAIN;
        }
        else/*以阻塞方式进行读取*/
        {
/*设置ADC控制寄存器，开启AD转换*/
            start_adc();
 
/*使等待队列进入睡眠*/
            wait_event_interruptible(adc_waitq, ev_adc);
        }
    }
 
/*能到这里就表示已有AD转换后的数据，则标识清0，给下一次读做判断用*/
    ev_adc = 0;
 
/*将读取到的AD转换后的值发往到上层应用程序*/
    copy_to_user(buffer, (char *)&adc_data, sizeof(adc_data));
 
/*释放获取的信号量(即：解锁)*/
    up(&ADC_LOCK);
 
    return sizeof(adc_data);
}
 
/*设置ADC控制寄存器，开启AD转换*/
static void start_adc(void)
{
    unsigned int tmp;
 
    tmp = (1 << 14) | (255 << 6) | (0 << 3);/* 0 1 00000011 000 0 0 0 */
    writel(tmp, adc_base + S3C2410_ADCCON); /*AD预分频器使能、模拟输入通道设为AIN0*/
 
    tmp = readl(adc_base + S3C2410_ADCCON);
    tmp = tmp | (1 << 0);                 /* 0 1 00000011 000 0 0 1 */
    writel(tmp, adc_base + S3C2410_ADCCON); /*AD转换开始*/
}
 
/*ADC设备驱动的关闭接口函数*/
static int adc_release(struct inode *inode, struct file *filp)
{
    return 0;
}
注意：在上面实现的每步中，为了让代码逻辑更加有条理和容易理解，就没有考虑代码的顺序，比如函数要先定义后调用。如果要编译此代码，请严格按照C 语言的规范来调整代码的顺序。
3、编写用户应用程序测试my2440_adc驱动。建立应用程序adc_test.c，代码如下：
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
 
int main(int argc, char **argv)
{
    int fd;
 
    //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    fd = open("/dev/my2440_adc", 0);
 
    if(fd < 0)
    {
        printf("Open ADC Device Faild!\n");
        exit(1);
    }
 
    while(1)
    {
        int ret;
        int data;
        
        //读设备
        ret = read(fd, &data, sizeof(data));
 
        if(ret != sizeof(data))
        {
            if(errno != EAGAIN)
            {
                printf("Read ADC Device Faild!\n");
            }
 
            continue;
        }
        else
        {
            printf("Read ADC value is: %d\n", data);
        }
    }
    close(fd);
    return 0;
}
4、将驱动程序下载挂载到内核，下载应用程序到开发板上后，运行应用程序，扭动mini2440开发板上的定位器，可以观察到ADC转换值的变化， 证明驱动程序工作正常。效果图如下：