TQ210搭载Android4.0.3系统构建之ADC从驱动到HAL到JNI到应用程序(驱动篇)

      ADC的驱动也采用platform设备驱动的方式进行编写，platform_device为platform_driver提供ADC控制器/ADC数据存储器/ADC延时器的地址，在platform_driver的probe函数在进行ioremap的映射，进而操作相应的寄存器。

     对于ADC寄存器的操作，可分为三步：

    1.使用clk_get获取adc时钟,接着使用clk_enable使能adc时钟

    2.设置ADCCON的工作方式，预分频比之类的

    3.当开始读取数据值时，开启ADC转换，判断是否开始转换，判断是否转换完成，最终读取数据，返回给用户空间

硬件电路图：

 

       ADCIN1的模拟量输入端接一个滑动变阻器，通过滑动变阻器，提供不同的模拟量输入端。

 

adc平台设备代码

adc_under_device.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/printk.h>
#include <linux/platform_device.h>


static struct resource adc_under_resource[]=  //adc的资源
{
	[0]=  //adc_con0
		{
		.start=0xE1700000,
		.end=0xE1700000+0x3,
		.flags=IORESOURCE_MEM,
		},
	[1]=//adc_delay0
		{
		.start=0xE1700000+0x8,
		.end=0xE1700000+0xB,
		.flags=IORESOURCE_MEM,
		},
	[2]=//adc_data0
		{
		.start=0xE1700000+0xC,
		.end=0xE1700000+0xF,
		.flags=IORESOURCE_MEM,
		},
	[3]=//adc_con1
		{
		.start=0xE1701000,
		.end=0xE1701000+0x3,
		.flags=IORESOURCE_MEM,
		},
	[4]=//adc_delay1
		{
		.start=0xE1701000+0x8,
		.end=0xE1701000+0xB,
		.flags=IORESOURCE_MEM,
		},
	[5]=//adc_data1
		{
		.start=0xE1701000+0xC,
		.end=0xE1701000+0xF,
		.flags=IORESOURCE_MEM,
		},
};


static void adc_under_release(struct device *dev)  //释放adc设备函数
{
	
}

static struct platform_device adc_under_platform_device=  //adc的平台函数
{
	.name="adc_under",  //用于与驱动进行匹配的名称
	.id=-1,
	.num_resources=sizeof(adc_under_resource)/sizeof(adc_under_resource[0]),
	.resource=adc_under_resource,
	.dev=
		{
			.release=adc_under_release,
	       },
	
	
};


static int __init adc_under_init(void)  //adc模块初始化函数
{
	int ret=platform_device_register(&adc_under_platform_device); //注册adc平台设备，为adc驱动提供资源
	if(ret==0)  printk(KERN_INFO "adc_under_platform_device register success.\n");
	else printk(KERN_INFO "adc_under_platform_device register failed.\n");
	return ret;
}

static void __exit adc_under_exit(void) //adc的模块卸载函数
{
	 platform_device_unregister(&adc_under_platform_device); //卸载adc平台设备
	 printk(KERN_INFO "adc_under_platform_device unregister success.\n");
}

module_init(adc_under_init);
module_exit(adc_under_exit);
MODULE_LICENSE("GPL");

 

编译文件 Makefile

obj-m	:=adc_under_device.o
KERNELDIR	:=~/java/Kernel_3.0.8_TQ210_for_Android_v1.0/
PWD			:=$(shell pwd)

build:kernel_module
kernel_module:
	make  -C  $(KERNELDIR) M=$(PWD) modules
clean:
	make -C $(KERNELDIR)	  M=$(PWD) clean

 

 

adc平台驱动文件

adc_under_driver.c

#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/printk.h>
#include <linux/clk.h>
#include <asm/io.h>
#include <asm/uaccess.h>  //包含copy_to_user...
#include <linux/delay.h>   //包含mdelay...
#include <linux/platform_device.h>

#define ADC_DEVICE_NAME "adc_unders"   //adc的设备名称


static struct class *cls;  //类指针
static void __iomem *adccon1,*adcdata1,*adcdly1; //adc控制器/数据存储器/延时器
//__iomem表示指向一个I/O的内存空间，目的为了开发通用的驱动,编译器不会对其进行检查
static struct clk *adc_clk;//adc时钟指针

#define ADCCON (*(volatile unsigned long *)(adccon1))  //adc控制器宏
#define ADCDATA (*(volatile unsigned long *)(adcdata1))//将__iomem指针转为unsigned long *型指针
#define ADCDLY (*(volatile unsigned long *)(adcdly1)) //volatile表示变量是易变的，总是需要从内存地址中读取，而不是从寄存器中读取，对该变量不进行优化

int major;  //存储设备主设备号


static int adc_under_open(struct inode *inode,struct file *file) //adc打开函数
{
       printk(KERN_INFO "adc_under_open.\n");
	return 0;
}

static int adc_under_close(struct platform_device *pdev)  //adc关闭函数，将申请的资源释放
{
	unregister_chrdev(major, ADC_DEVICE_NAME);  //从chrdevs指针数组中删掉adc字符设备
	device_destroy(cls, MKDEV(major,0));    //从subsystem中将其删除，并将其引用减一
	class_destroy(cls);  //删除cls类
	iounmap(adccon1);  //取消物理地址到虚拟地址的映射
	iounmap(adcdata1);
	iounmap(adcdly1);
	printk(KERN_INFO "adc_under_close success.\n");
	return 0;
}


static int  adc_under_read(struct file *file,char __user *buf,size_t count,loff_t *fops)  //adc读取转换后的数字量
{
	int adc_val,n,con;
	ADCCON |=0x01;  //开启ADC的转换
	while(ADCCON&0x1);  //判断是否开始转换
	while(!ADCCON&0x8000); //判断是否转换完成
	con=ADCCON&0xffff;
	adc_val=(ADCDATA&0x03ff);  //获取到转换后的结果值
	mdelay(100);
	n=copy_to_user(buf, &adc_val, sizeof(adc_val));  //将adc_val的值从内核空间拷到用户空间
	printk(KERN_INFO "adc_under_read,adc_val=%d,con=0x%x\n",adc_val,con);
	return n;
}

struct file_operations adc_under_fops=  //adc文件操作
{
	.owner=THIS_MODULE,
	.open=adc_under_open,
	.read=adc_under_read,
};

static void adc_reg_init(void)  //adc的初始化函数
{
	int con;
	adc_clk=clk_get(NULL, "adc");  //获取到adc的时钟，在S5PV210中，进行ADC转换的时候，使用的是PCLK(Max 66MHz) is used
	clk_enable(adc_clk); //使能clk时钟
	ADCDLY=100;  //adc采样转换的延迟时间，影响stylus down,x-conversion,y-conversion时间
	ADCCON=(0<<0) | //没有操作
		(0<<1) |  //disable start by read operation
		(0<<2) |  //正常操作模式
		(65<<6) |  //分频值为65 ，因为PCLK=66 所以prscvl=65 即 a/d转换频率为1MHz ,Conversion time=5us
		(1<<14) ;// 使能预分频值
	con=ADCCON&0xffff;  //调试信息
	printk(KERN_INFO "adc_reg_init.con=0x%x\n",con);
}

static int adc_under_probe(struct platform_device *pdev)  //adc的探针函数，与platform_device匹配后调用，用于初始化platform_driver
{
       struct resource *rescon1,*resdata1,*resdly1;  //资源指针
	 rescon1=platform_get_resource(pdev,IORESOURCE_MEM, 3);  //获取到ADCCON1的资源，详情见adc_under_device.c
	 if(rescon1==NULL) { printk(KERN_INFO "can not find rescon1.\n"); return -1;}  //判断是否获得资源
	 adccon1=ioremap(rescon1->start, rescon1->end-rescon1->start+1);  //物理地址映射为虚拟地址
	if(adccon1==NULL) { printk(KERN_INFO "no mem to adccon1.\n"); return -1;}  //判断映射是否成功
	 
	  resdata1=platform_get_resource(pdev,IORESOURCE_MEM, 5);//获取到ADCDATA1的资源，详情见adc_under_device.c
	  if(resdata1==NULL) { printk(KERN_INFO "cann not find resdata1->\n"); return -1;} //判断是否获得资源
	  adcdata1=ioremap(resdata1->start, resdata1->end-resdata1->start+1);//物理地址转为虚拟地址
	if(adcdata1==NULL) { printk(KERN_INFO "no mem to adcdata1.\n"); return -1;}//判断映射是否成功
	  
	  resdly1=platform_get_resource(pdev,IORESOURCE_MEM, 4); //获取到ADCDLY1的资源，详情见adc_under_device.c
	  if(resdly1==NULL) { printk(KERN_INFO "can not find resdly1.\n"); return -1; } //判断是否获取资源
	 adcdly1=ioremap(resdly1->start, resdly1->end-resdly1->start+1); //物理地址映射为虚拟地址
	if(adcdly1==NULL) { printk(KERN_INFO "no mem to adcdly1.\n"); return -1;}//判断映射是否成功

	 adc_reg_init();  //adc寄存器的初始化

	 major=register_chrdev(0, ADC_DEVICE_NAME,&adc_under_fops); //创建并注册字符设备
	 cls=class_create(THIS_MODULE, ADC_DEVICE_NAME);  //创建类
	 device_create(cls,NULL, MKDEV(major,0), NULL, ADC_DEVICE_NAME); //建立/dev/adc_unders设备文件，利用udev策略
	 printk(KERN_INFO "adc_under_probe success.\n");
	return 0;
}


static struct platform_driver adc_under_platform_driver=  //adc的平台驱动
{
	.probe=adc_under_probe,
	.remove=adc_under_close,
	.driver=
		{
			.name="adc_under",  //用于与platform_device匹配的名称
		},
};

static int __init adc_driver_init(void)  //adc模块初始化函数
{
	int ret=platform_driver_register(&adc_under_platform_driver);  //注册平台驱动
	if(ret==0) printk(KERN_INFO "adc_under_platform_driver success.\n");
	else printk(KERN_INFO "adc_under_platform_driver failed.\n");
	return ret;
}

static void __exit adc_driver_exit(void) //模块卸载函数
{
  	platform_driver_unregister(&adc_under_platform_driver);  //卸载平台驱动
}


module_init(adc_driver_init);
module_exit(adc_driver_exit);
MODULE_LICENSE("GPL");

编译文件 Makefile

obj-m	:=adc_under_driver.o
KERNELDIR	:=~/java/Kernel_3.0.8_TQ210_for_Android_v1.0/
PWD			:=$(shell pwd)

build:kernel_module
kernel_module:
	make  -C  $(KERNELDIR) M=$(PWD) modules
clean:
	make -C $(KERNELDIR)	  M=$(PWD) clean

 

 

最后的测试文件

adc_under_test.c

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


#define DEVICE_NAME "/dev/adc_unders"

int main(void)
{
	int fd,ret=0,data,count=0;
	fd=open(DEVICE_NAME, O_RDWR);
	if(fd<0) {printf("can not open fd=%s\n",DEVICE_NAME); return -1; }
	while(count<10){
		ret=read(fd,&data,sizeof(data));
		if(ret<0)
				printf("read data is error \n");
		printf("adc is %f V\n",(float)data*3.3/1024);
		sleep(2);
		count++;
	}

	close(fd);
	return ret;
}

测试文件的Android.mk

LOCAL_PATH	:=$(call my-dir)
include $(CLEAR_VARS)
LOCAL_MODULE_TAGS		:=eng
LOCAL_SRC_FILES		:=adc_under_test.c
LOCAL_MODULE	:=adc_test
LOCAL_MODULE_PATH		:=$(LOCAL_PATH)
include $(BUILD_EXECUTABLE)

 

 

    对于这个adc的驱动，我在测试的时候出现了一个很奇怪的现象，我在adc驱动测试代码中总共是读取了10次adc的值，偶合会有一两次的值是错的，就是3,3V，即adc没开始转换的值，嗯，对于这个问题暂时还不清楚，是不是我的adc硬件上有问题，待后续研究。