ADC转换

// adc_drv.c，光敏电阻的驱动程序
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/serio.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <mach/regs-clock.h>
#include <plat/regs-timer.h>
#include <plat/regs-adc.h>
#include <mach/regs-gpio.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>
#include <linux/semaphore.h>
#define DEVICE_NAME "ldr_adc"

static void __iomem *base_addr; // 定义用来保存经虚拟映射的内存地址

typedef struct
{
    wait_queue_head_t wait; // 等待队列
    int channel;            // AIN 通道号
    int prescale;           // 分频系数
} ADC_DEV;
/* 定义一个外部的信号量 ADC_LOCK，因为 ADC_LOCK 在 ldr_adc 驱动程序中已申明
这样就能保证 ADC 资源在 ldr_adc 驱动和触摸屏驱动中进行互斥访问 */
extern struct semaphore ADC_LOCK;
static struct class *ldr_adc_drv_class;
static int ownADC = 0;

static ADC_DEV adcdev;
static volatile int ev_adc = 0;
static int adc_data;

static struct clk *adc_clk; // ADC 所需时钟

/* 启动 AD 转换的宏,里面用到的寄存器都在“arch/arm/plat-samsung/include/plat/regs-adc.h”
文件中定义 */

#define START_ADC_AIN(ch, prescale)     \
    \ 
do                                  \
    {                                   \
        \ 
 iowrite32(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(prescale) \ 
| S3C2410_ADCCON_SELMUX(ch),            \
           base_addr + S3C2410_ADCCON); \
        \ 
 iowrite32(ioread32(base_addr + S3C2410_ADCCON) \ 
| S3C2410_ADCCON_ENABLE_START,          \
           base_addr + S3C2410_ADCCON); \
    \ 
}                                  \
    while (0)

static irqreturn_t adc_handler(int irq, void *dev_id)
{
    if (ownADC)
    {
        adc_data = ioread32(base_addr + S3C2410_ADCDAT0) & 0x3ff;

        ev_adc = 1; // 表示有数据可读，唤醒等待队列
        wake_up_interruptible(&adcdev.wait);
    }
    return IRQ_HANDLED;
}

static int s3c2440_adc_open(struct inode *inode, struct file *filp)
{
    init_waitqueue_head(&adcdev.wait); // 初始化等待队列
    adcdev.channel = 0;
    adcdev.prescale = 0xff;

    return 0;
}

static int s3c2440_adc_close(struct inode *inode, struct file *filp)
{
    return 0;
}

static ssize_t s3c2440_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
    int ret;

    if (down_trylock(&ADC_LOCK)) // 尝试获取信号量
    {
        return -EBUSY;
    }

    ownADC = 1;
    START_ADC_AIN(adcdev.channel, adcdev.prescale); // 开始 AIN0 通道的 AD 转换
    wait_event_interruptible(adcdev.wait, ev_adc);  // 等待有数据可读，中断处理中将唤醒此处

    ev_adc = 0;

    ret = copy_to_user(buffer, (char *)&adc_data, sizeof(adc_data)); // 结果 copy 到用户空间

    ownADC = 0;
    up(&ADC_LOCK); // 释放信号量

    return sizeof(adc_data);
}

static struct file_operations dev_fops =
    {
        .owner = THIS_MODULE,
        .open = s3c2440_adc_open,
        .read = s3c2440_adc_read,
        .release = s3c2440_adc_close,
};

int major;
static int __init dev_init(void)
{
    int ret;
    /* 将 ADC 的 IO 端口占用的这段 IO 空间映射到内存的虚拟地址, S3C2410_PA_ADC 是
   ADC 控制器的基地址，定义在 arch/arm/mach-s3c24xx/include/mach/map.h */
    base_addr = ioremap(S3C2410_PA_ADC, 0x20);
    if (base_addr == NULL)
    {
        printk(KERN_ERR "Failed to remap ADC register\n");
        return -ENOMEM;
    }

    /* 从平台时钟队列中获取 ADC 的时钟，ADC 的转换频率跟时钟有关。定义在
   arch/arm/plat-s3c24xx/s3c2410-clock.c 中 */
    adc_clk = clk_get(NULL, "adc");
    if (!adc_clk)
    {
        printk(KERN_ERR "Failed to get adc clk\n");
        return -ENOENT;
    }

    clk_enable(adc_clk);

    iowrite32(0, base_addr + S3C2410_ADCTSC);

    /*申请 ADC 中断，使用的是共享中断:IRQF_SHARED,为什么要使用共享中断，因为在
   触摸屏驱动中也使用了这个中断号。中断服务程序为:adc_irq 在下面实现，IRQ_ADC 是 ADC
   的中断号。共享中断最后一个参数不能为 NULL*/
    ret = request_irq(IRQ_ADC, adc_handler, IRQF_SHARED, DEVICE_NAME, &adcdev);
    if (ret)
    {
        iounmap(base_addr);
        printk(KERN_ERR "Failed to req adc_irq\n");
        return ret;
    }

    major = register_chrdev(0, DEVICE_NAME, &dev_fops); // 动态申请设备号、注册设备
    // 在/sys/class/下创建 ldr_adc 目录
    ldr_adc_drv_class = class_create(THIS_MODULE, "ldr_adc");
    if (IS_ERR(ldr_adc_drv_class))
    {
        printk(KERN_INFO "create ldr_adc_drv class error\n");
        return -1;
    }
    /* 将创建 /dev/ldr_adc 设备文件 */
    device_create(ldr_adc_drv_class, NULL, MKDEV(major, 0), NULL, DEVICE_NAME);

    printk(KERN_INFO DEVICE_NAME " initialized\n");
    return ret;
}

static void __exit dev_exit(void)
{
    // 释放设备号、注销设备
    unregister_chrdev(major, DEVICE_NAME);
    device_destroy(ldr_adc_drv_class, MKDEV(major, 0));

    free_irq(IRQ_ADC, &adcdev);
    iounmap(base_addr);

    if (adc_clk)
    {
        clk_disable(adc_clk);
        clk_put(adc_clk);
        adc_clk = NULL;
    }

    class_destroy(ldr_adc_drv_class);
    printk(KERN_INFO "ldr_adc_driver is exited!\n");
}
module_init(dev_init);
module_exit(dev_exit);
MODULE_LICENSE("GPL");