Exynos4412 ADC 设备驱动开发

       具体ADC硬件知识及裸机驱动请看： Exynos4412裸机开发 —— A/D转换器

1、原理图如下：

2、相关寄存器信息

ADC_BASE      0x126C0000 ADCCON        0x0000               1<<0 | 1<<14 | 0X1<<16 | 0XFF<<6 ADCDLY          0x0008               
ADCDAT         0x000C              &0XFFF
CLRINTADC    0x0018
ADCMUX        0x001C

3、大体驱动编写流程如下

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、字符设备的操作}

4、设备树中的节点编写

fs4412-adc{
    compatible = "fs4412,adc";
    reg = <0x126C0000 0x20>;
    interrupt-parent = <&combiner>;
    interrupts = <10 3>;
};

5、驱动编写

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\n");
/*清中断*/
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 \n");

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 \n");
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 \n");
return ;
}

while(1)
{
read(fd,&adc,4);
printf("adc%0.2f V \n",(1.8*adc)/4096);
}

close(fd);
}