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

#include

#include

#include

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

#include

#include

#include

#include

#include

#include   //包含copy_to_user...

#include    //包含mdelay...

#include

#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%xn',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%xn',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

#include

#include

#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=%sn',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 Vn',(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硬件上有问题，待后续研究。