全志_ADC驱动

ADC_驱动

---

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/platform_device.h>
#include <linux/device.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/irqreturn.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/gpio.h>
#include <linux/cdev.h>
#include <asm/string.h>
#include <asm-generic/ioctl.h>
#include <linux/kernel.h>
#include <linux/input.h>
#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/rwsem.h>
#include <linux/timer.h>
#include <linux/err.h>
#include <linux/ctype.h>
#include <linux/sysfs.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/sys_config.h>


#define IR_GPIO GPIOH(10)               //外部中断引脚


//定义个数据包
struct fsp_event{
    int code;         
    int value;     
};


//面向对象-设备的类型
struct fsp{
    //unsigned int major;
    dev_t  devno;
    struct class * cls;
    struct device * dev;
    struct cdev  *cdev;
    unsigned int irqno;
    struct fsp_event event;
    int data;
};
struct fsp *fsp_dev;


//void __iomem *adc_base;   //必须是void __iomem类型因为偏移地址不一样


volatile unsigned long * adc_ctrl;  //ADC控制寄存器
volatile unsigned long * adc_intc;    //ADC中断控制寄存器 
volatile unsigned long * adc_ints;    //ADC中断状态寄存器
volatile unsigned long * adc_dat0;    //ADC数据1寄存器
volatile unsigned long * adc_dat1;    //ADC数据2寄存器


wait_queue_head_t adcq;   //等待队列头
int flag = 0;


//中断服务函数
irqreturn_t fsp_irq_svc(int irqno,void *id)
{
    //开始必须要清中断，内核没有进行清中断我们必须在驱动中手动清中断
 //   writel(0,adc_base + 0x18);
     //ADC中断状态寄存器设置  （清除中断标志位）
    *adc_ints &= ~(0x1f<<0);     //0--4清0
    *adc_ints |=   0x1f<<0;      //0---4赋值:00010001
 
    
    //唤醒阻塞（进入中断表明转换完成，唤醒阻塞，读取数据，上报数据）
    wake_up_interruptible(&adcq);
    flag = 1;
    return IRQ_HANDLED;
}




//open接口            ADC0
int fsp_adc_open(struct inode *inode,struct file *filp)
{
    printk("fsp open success !
");
    
    
    //ADC控制寄存器设置    （打开ADC,转换速率62.5HZ）
    *adc_ctrl &= ~(0x00<<0);     //0 清0
    *adc_ctrl |=   0x00<<0 ;     //0 赋值:1
    
    //ADC中断控制寄存器设置（使能ADC0 中断控制，）
    *adc_intc &= ~(0x1f<<0);     //0--4清0
    *adc_intc |=   0x1f<<0;      //0---4赋值:11111
    
    //ADC中断状态寄存器设置  （清除中断标志位）
    *adc_ints &= ~(0x1f<<0);     //0--4清0
    *adc_ints |=   0x1f<<0;      //0---4赋值:00010001
    
/*    
    //ADC数据0寄存器设置
    *(adc_base+24) &= ~(0xff<<12);     //19--12清0
    *(adc_base+24) |= 0x11<<12;        //19---12赋值:00010001
    
    //ADC数据1寄存器设置
    *(adc_base+32) &= ~(0xff<<12);     //19--12清0
    *(adc_base+32) |= 0x11<<12;        //19---12赋值:00010001
*/    
    
    return 0;
}


//read接口
ssize_t fsp_adc_read(struct file *filp,char __user *ubuf,size_t size,loff_t *off)
{
    int ret;
    int data;
    //开始转换数据
    //writel(readl(adc_base) | 1 << 0,adc_base);//转换完成后才会出现中断
     *adc_ctrl |=   0x01<<0 ;     //0 赋值:1
    
    
    //阻塞等待一下
    wait_event_interruptible(adcq,flag != 0);

    //只有转化完成且中断唤醒阻塞后才能读取数据,直接不能读取数据
    //data = readl(adc_base + 0x0c) & 0xfff;
    
    data = readl(adc_dat0) & 0xfff;
    
    
    ret = copy_to_user(ubuf,&data,sizeof(data));
    flag = 0;
    
    printk("adc :  %d
",data);
    
    return sizeof(data);
}



//close接口
int fsp_adc_close(struct inode *inode, struct file *filp)
{
    printk("fsp close success !
");
    return 0;
}




//实现FOPS
struct file_operations fops = {
    .owner   = THIS_MODULE,
    .open    = fsp_adc_open,
    .read    = fsp_adc_read,
    .release = fsp_adc_close,
};



//初始化函数
static int __init fsp_init(void)   
{
    
    printk("fsp_init  success !
");
    
    int ret;
    fsp_dev = kzalloc(sizeof(struct fsp),GFP_KERNEL);
    if(IS_ERR(fsp_dev)){
        printk("kzalloc error!
");
        ret = PTR_ERR(fsp_dev);
        return -ENOMEM;
    }
    

    //动态申请设备号
    ret = alloc_chrdev_region(&fsp_dev->devno,0,1,"button_drv");
    if(ret < 0){
        printk("register_chrdev_region error!
");
        ret =  -EINVAL;
        goto err_kfree;
    }


    //申请cdev的空间
    fsp_dev->cdev = cdev_alloc();
    if(IS_ERR(fsp_dev->cdev)){        
        printk("fsp_dev->cdev error!
");
        ret = PTR_ERR(fsp_dev->cdev);
        goto err_unregister;
    }

    //初始化cdev的成员
    cdev_init(fsp_dev->cdev,&fops);

    //将cdev加入到内核中----链表
    ret = cdev_add(fsp_dev->cdev,fsp_dev->devno,1);

    //创建设备文件
    fsp_dev->cls = class_create(THIS_MODULE,"fsp_dev");
    if(IS_ERR(fsp_dev->cls)){
        printk("class_create error!
");
        ret = PTR_ERR(fsp_dev->cls);
        goto err_cdev_del;
    }
    
    fsp_dev->dev = device_create(fsp_dev->cls,NULL,fsp_dev->devno,NULL,"fsp_EINT");
    if(IS_ERR(fsp_dev->dev)){
        printk("device_create error!
");
        ret = PTR_ERR(fsp_dev->dev);
        goto err_class;
    }
    
    
    
    //1.中断申请
    fsp_dev->irqno = gpio_to_irq(IR_GPIO);   //中断号
    ret = request_irq(fsp_dev->irqno,fsp_irq_svc,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,"eint-keydown",NULL);
    if(ret != 0){
        printk("request_irq error!
");
        ret = -EBUSY;
        goto err_device;
    }


    //2.地址映射
    adc_ctrl = ioremap(0x01c24400,8);//将物理地址映射成虚拟地址
    adc_intc = adc_ctrl + 1;
    adc_ints = adc_ctrl + 2;
    adc_intc = adc_dat0 + 3;
    adc_intc = adc_dat1 + 4;

    
//    writel(255 << 6 | 1 << 14 | 1 << 16,adc_base);
//    writel(3,adc_base + 0x1c);



    init_waitqueue_head(&adcq);  //初始化等待对列头

    return 0;
    
err_device:
    device_destroy(fsp_dev->cls,fsp_dev->devno);
err_class:
    class_destroy(fsp_dev->cls);
    
err_cdev_del:
    cdev_del(fsp_dev->cdev);
    
err_unregister:
    unregister_chrdev_region(fsp_dev->devno,1);
    
err_kfree:
    kfree(fsp_dev);
    return ret;
  
}



static void __exit fsp_exit(void)   
{
    printk("fsp_init  success !
");
    
    free_irq(fsp_dev->irqno,NULL);
    device_destroy(fsp_dev->cls,fsp_dev->devno);
    class_destroy(fsp_dev->cls);
    cdev_del(fsp_dev->cdev);
    unregister_chrdev_region(fsp_dev->devno,1);
    kfree(fsp_dev);
}



module_init(fsp_init);
module_exit(fsp_exit);
MODULE_LICENSE("GPL");

测试：

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>


int main(void)
{
    int fd;

    fd = open("/dev/fsp_EINT",O_RDWR);

    int data;
    while(1)
    {
        read(fd,&data,sizeof(data));
        printf("data = %d
",data);
        sleep(1);
    }
    close(fd);
    return 0;
}

博客：http://www.itkeyword.com/doc/3093906707123520x327/c-kernel-linux

　　　https://www.cnblogs.com/hslixiqian/p/9676526.html