[OK210开发板体验]功能篇（7） Linux字符驱动之ADC模数转换驱动

原创 2015-12-24 16:25:00 [OK210开发板体验]功能篇（7） Linux字符驱动之ADC模数转换驱动
前面进行了OK210试用体验的入门篇介绍，算是初步入门，分别包含：
[OK210开发板体验]入门篇(1)：开箱验板
[OK210开发板体验]入门篇(2)：板载资源
[OK210开发板体验]入门篇(3)：开发环境（软件安装，开发环境，烧写系统）
[OK210开发板体验]入门篇(4)：编程入门（NFS登录，驱动入门）
[OK210开发板体验]功能篇(1)：Linux字符驱动之Led
[OK210开发板体验]功能篇(2)：Linux字符驱动之Key按键
[OK210开发板体验]功能篇(3)：Linux Input子系统之Key按键
[OK210开发板体验]功能篇(4)：Linux字符驱动之DS18B20
[OK210开发板体验]功能篇(5)：Linux字符驱动之PWM蜂鸣器
[OK210开发板体验]功能篇(6)：Linux字符驱动之红外遥控    
今天是功能篇的第七篇：Linux字符驱动之ADC模数转换，本节主要分3部分：硬件分析，软件基础，驱动编程。
一、硬件分析
在【OK210试用体验】的第二篇：板载资源中，简单分析了ADC的功能和作用。其实对ADC的操作，可以看作是对一些模拟量的采集操作，如温湿度，光度。
首先从OK210的底板原理图中可知，通过一个可调电位器RP1，连接到S5PV210的模拟输入0通道，通过对该可调电位器的调节可以改变模拟通道的输入电压值，电压的调节范围为0V-3V，可以利用这个可调电位器来熟悉S5PV210的ADC控制器的使用，如下图所示

模拟输入0通首家引脚为XADCAIN0，由S5PV210用户手册，可知，该引脚是一个模块引脚，如下图所示。
所以，我们要对ADC进行操作，就是通过对配置ADC的各寄存器进行实现。
二、软件基础
1、S5PV210的ADC的主要特征：
（1）分辨率(输出离散值的个数)可以是10位或者12位(可以通过TSADCCON0/TSADCCON1的第16位RES进行设定，将RES设为0表示10位，设为1表示12位)。
（2）10通道的模拟输入(AIN[9]---AIN[0])。
（3）输入电压为0--3.3V。
（4）最大转换速率：1MSPS。
对于转换速率的计算，S5PV210_UM手册上是这样介绍的：当PCLK=66MHz时，预分频比P=65时，12位分辨率的转换时间如下：
A/D转换频率=66MHz/(65+1)=1MHz
A/D转换时间=1/(1MHz/5cycles)=1/200kHz=5us
PS
1)A/D的转换频率最大可达5MHz,所以A/D转换时间最大可达1MSPS
2)对于官方手册上，所说的A/D转换时间的计算，可能我们第一次看的时候会不太理解，会什么要1MHz/5cycles?原因是这样的，因为A/D转换时间包括A/D建立时间，1位1位转换时间，保存数据时间等等，加起来一共是5个时钟周期，所以会是1MHz/5cycles。其实对于A/D转换时间=1/(1MHz/5cycles) 可以换种写法：A/D转换时间=1/1MHz *5=5us 也是一样的，所以当最大转换频率达到5MHz时，A/D转换时间可达1MSPS(SPS为每秒的采样率)。
（5）具有采样保持功能。
（6）ADC有10通道的模拟输入，但是只有AIN[0]，AIN[1]没有复用，而AIN[2]--AIN[9]是复用为触摸屏的两路控制信号(XM,XP)。
2、S5PV210的ADC的寄存器
操作AIN[0]，在编写ADC的驱动代码的时候，一般情况下只需考虑三个寄存器，分别是
寄存器 映射地址 读/写 描述 复位值
TSADCCON0 0xE170_0000 R/W TS0/ADC控制寄存器 0x0000_3FC4
TSDLY0 0xE170_0008 R/W TS0/ADC延时寄存器 0x0000_00FF
TSDATX0 0xE170_000C R TS0/ADC转换数据X寄存器 ---
上面表格即是操作AIN[0]时需要用到的三个寄存器，对于上面的映射地址，在编写驱动代码的时候可使用ioremap的形式进行映射，然后强制转为(volatile unsigned long *)指针形式，接下来就可以直接操作寄存器。
3、S5PV210的ADC操作流程
主要分三步：
（1）使用clk_get获取adc时钟,接着使用clk_enable使能adc时钟；
（2）设置ADCCON的工作方式，预分频比之类的；
（3）当开始读取数据值时，开启ADC转换，判断是否开始转换，判断是否转换完成，最终读取数据，返回给用户空间。值得注意的是，S5PV210的控制寄存器，是没有通道选择的，因为在使用之前，直接用ioremap进行地址的映射时，就相当于选择了不同的通道，所以无需通道选择了。

三、驱动编程
有图有真相，

1 驱动代码
  1. #include <linux/kernel.h>
  2. #include <linux/module.h>
  3. #include <linux/slab.h>
  4. #include <linux/input.h>
  5. #include <linux/init.h>
  6. #include <linux/errno.h>
  7. #include <linux/serio.h>
  8. #include <linux/delay.h>
  9. #include <linux/clk.h>
  10. #include <linux/wait.h>
  11. #include <linux/sched.h>
  12. #include <linux/cdev.h>
  13. #include <linux/miscdevice.h>

  15. #include <asm/io.h>
  16. #include <asm/irq.h>
  17. #include <asm/uaccess.h>

  19. #include <mach/map.h>
  20. #include <mach/regs-clock.h>
  21. #include <mach/regs-adc.h>
  22. #include <mach/regs-gpio.h>
  23. #include <plat/regs-timer.h>

  25. #undef DEBUG
  26. //#define DEBUG
  27. #ifdef DEBUG
  28. #define DPRINTK(x...) {printk(__FUNCTION__"(%d): ",__LINE__);printk(##x);}
  29. #else
  30. #define DPRINTK(x...) (void)(0)
  31. #endif

  33. #define DEVICE_NAME        "adc"
  34. static void __iomem *base_addr;

  36. typedef struct {
  37.         wait_queue_head_t wait;
  38.         int channel;
  39.         int prescale;
  40. } ADC_DEV;

  42. static int __ADC_locked = 0;
  43. static ADC_DEV adcdev;
  44. static volatile int ev_adc = 0;
  45. static int adc_data;
  46. static struct clk        *adc_clock;

  48. #define __ADCREG(name)        (*(volatile unsigned long *)(base_addr + name))
  49. #define ADCCON                        __ADCREG(S3C_ADCCON)        // ADC control
  50. #define ADCTSC                        __ADCREG(S3C_ADCTSC)        // ADC touch screen control
  51. #define ADCDLY                        __ADCREG(S3C_ADCDLY)        // ADC start or Interval Delay
  52. #define ADCDAT0                        __ADCREG(S3C_ADCDAT0)        // ADC conversion data 0
  53. #define ADCDAT1                        __ADCREG(S3C_ADCDAT1)        // ADC conversion data 1
  54. #define ADCUPDN                        __ADCREG(S3C_ADCUPDN)        // Stylus Up/Down interrupt status

  56. #define PRESCALE_DIS                (0 << 14)
  57. #define PRESCALE_EN                        (1 << 14)
  58. #define PRSCVL(x)                        ((x) << 6)
  59. #define ADC_INPUT(x)                ((x) << 3)
  60. #define ADC_START                        (1 << 0)
  61. #define ADC_ENDCVT                        (1 << 15)

  63. #define START_ADC_AIN(ch, prescale) \
  64.         do { \
  65.                 ADCCON = PRESCALE_EN | PRSCVL(prescale) | ADC_INPUT((ch)) ; \
  66.                 ADCCON |= ADC_START; \
  67.         } while (0)


  70. static irqreturn_t adcdone_int_handler(int irq, void *dev_id)
  71. {
  72. #if        1
  73.         if (__ADC_locked) {
  74.                 adc_data = ADCDAT0 & 0x3ff;

  76.                 ev_adc = 1;
  77.                 wake_up_interruptible(&adcdev.wait);

  79.                 /* clear interrupt */
  80.                 __raw_writel(0x0, base_addr + S3C_ADCCLRINT);
  81.         }
  82. #endif

  84.         return IRQ_HANDLED;
  85. }

  87. static ssize_t ok210_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
  88. {
  89.         char str[20];
  90.         int value;
  91.         size_t len;

  93.     __ADC_locked = 1;
  94.     START_ADC_AIN(adcdev.channel, adcdev.prescale);
  95.     wait_event_interruptible(adcdev.wait, ev_adc);
  96.     ev_adc = 0;
  97.     DPRINTK("AIN[%d] = 0x%04x, %d\n", adcdev.channel, adc_data, ADCCON & 0x80 ? 1:0);
  98.     value = adc_data;
  99.     __ADC_locked = 0;
  100.         len = sprintf(str, "%d\n", value);
  101.         if (count >= len) {
  102.                 int r = copy_to_user(buffer, str, len);
  103.                 return r ? r : len;
  104.         } else {
  105.                 return -EINVAL;
  106.         }
  107. }

  109. static int ok210_adc_open(struct inode *inode, struct file *filp)
  110. {
  111.         init_waitqueue_head(&(adcdev.wait));

  113.         adcdev.channel=0;
  114.         adcdev.prescale=0xff;

  116.         DPRINTK("adc opened\n");
  117.         return 0;
  118. }

  120. static int ok210_adc_release(struct inode *inode, struct file *filp)
  121. {
  122.         DPRINTK("adc closed\n");
  123.         return 0;
  124. }


  127. static struct file_operations dev_fops = {
  128.         owner:        THIS_MODULE,
  129.         open:        ok210_adc_open,
  130.         read:        ok210_adc_read,
  131.         release:        ok210_adc_release,
  132. };

  134. static struct miscdevice misc = {
  135.         .minor        = MISC_DYNAMIC_MINOR,
  136.         .name        = "adc",        //DEVICE_NAME,
  137.         .fops        = &dev_fops,
  138. };

  140. static int __init dev_init(void)
  141. {
  142.         int ret;

  144.         base_addr = ioremap(SAMSUNG_PA_ADC, 0x20);
  145.         if (base_addr == NULL) {
  146.                 printk(KERN_ERR "Failed to remap register block\n");
  147.                 return -ENOMEM;
  148.         }

  150.         adc_clock = clk_get(NULL, "adc");
  151.         if (!adc_clock) {
  152.                 printk(KERN_ERR "failed to get adc clock source\n");
  153.                 return -ENOENT;
  154.         }
  155.         clk_enable(adc_clock);

  157.         /* normal ADC */
  158.         ADCTSC = 0;

  160. #if        1
  161.         ret = request_irq(IRQ_ADC, adcdone_int_handler, IRQF_SHARED, DEVICE_NAME, &adcdev);
  162.         if (ret) {
  163.                 printk("request IRQ %d failed for adc, %d\n", IRQ_ADC, ret);
  164.                 iounmap(base_addr);
  165.                 return ret;
  166.         }
  167. #endif

  169.         ret = misc_register(&misc);

  171.         printk (DEVICE_NAME"\tinitialized\n");
  172.         return ret;
  173. }

  175. static void __exit dev_exit(void)
  176. {
  177.         free_irq(IRQ_ADC, &adcdev);
  178.         iounmap(base_addr);

  180.         if (adc_clock) {
  181.                 clk_disable(adc_clock);
  182.                 clk_put(adc_clock);
  183.                 adc_clock = NULL;
  184.         }

  186.         misc_deregister(&misc);
  187. }

  189. module_init(dev_init);
  190. module_exit(dev_exit);

  192. MODULE_LICENSE("GPL");
  193. MODULE_AUTHOR("gjianw217@163.com");
  194. MODULE_DESCRIPTION("ADC driver");
复制代码
2 测试代码
  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <stdlib.h>
  4. #include <sys/types.h>
  5. #include <sys/stat.h>
  6. #include <sys/ioctl.h>
  7. #include <fcntl.h>
  8. #include <linux/fs.h>
  9. #include <errno.h>
  10. #include <string.h>

  12. int main(void)
  13. {
  14.         fprintf(stderr, "press Ctrl-C to stop\n");
  15.         int fd = open("/dev/adc", "r");
  16.         if (fd < 0) {
  17.                 perror("open ADC device:");
  18.                 return 1;
  19.         }
  20.         ioctl(fd,'s',0);
  21.         int ADCValue=0;
  22.         double voltage=0;
  23.         for(;;) {
  24.                 ADCValue=0;
  25.                 voltage=0;
  26.                 read(fd, &ADCValue, sizeof(int));
  27.                 if(ADCValue==-1) continue;
  28.                 //channel 0 12bit ADC max voltage = 3.3v /10K+1k *10K =3v
  29.                 voltage=(float)3.3*ADCValue/4096;
  30.                 printf("adc = %d voltage=%f V \n",ADCValue,voltage);
  31.                 usleep(500* 1000);
  32.         }

  34.         close(fd);
  35. }
复制代码
3 Makefile
  1. #adc Makefile
  2. ARCH=arm
  3. CROSS_COMPILE=/home/ok210/arm-2009q3/bin/arm-none-linux-gnueabi-
  4. APP_COMPILE=/home/ok210/arm-2009q3/bin/arm-none-linux-gnueabi-
  5. #obj-m := app-drv.o
  6. obj-m := pwm-drv.o
  7. #KDIR := /path/to/kernel/linux/
  8. KDIR := /home/ok210/android-kernel-samsung-dev/
  9. PWD := $(shell pwd)
  10. default:
  11.         make -C $(KDIR) M=$(PWD) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) modules
  12. app:pwm-app.c
  13.         $(APP_COMPILE)gcc -o app pwm-app.c
  14. clean:
  15.         $(MAKE) -C $(KDIR) M=$(PWD) clean
复制代码

相关产品 >

  • OKMX6UL-C开发板

    飞凌嵌入式专注imx6系列imx6ul开发板、飞思卡尔imx6ul核心板等ARM嵌入式核心控制系统研发、设计和生产,i.mx6UL系列产品现已畅销全国，作为恩智浦imx6ul,imx6ul开发板,i.mx6提供者，飞凌嵌入式提供基于iMX6 iMX6UL解决方案定制。

    了解详情
    OKMX6UL-C开发板

  • OKMX6ULL-C开发板

    40*29mm,双网双CAN，8路串口| i.MX6ULL开发板是基于NXP i.MX6ULL设计开发的的一款Linux开发板 ，主频800MHz，体积小，其核心板仅40*29mm，采用板对板连接器，适应场景丰富。 了解详情
    OKMX6ULL-C开发板
上一篇：[OK210开发板体验]系统篇（3） 基于OK210的智能家居系统之后端设计CGI 下一篇：[充电桩]飞凌嵌入式充电桩解决方案-计费控制单元

推荐阅读 换一批 换一批