基于linux(2.6.32)通用adc接口的简单测试驱动
2014-12-30 15:30
483 查看
1. 在arch/arm/mach-s3c2440/mini2440.c中添加:
2. 写自己的驱动
3. Makefile:
4. 测试文件:
附:linux通用adc接口:
static struct platform_device mini2440_adc = { .name = "mini2440_adc", .id = -1, .dev.parent = &s3c_device_adc.dev, // .num_resources = ARRAY_SIZE(s3c_adc_resource), // .resource = s3c_adc_resource, };
static struct platform_device *mini2440_devices[] __initdata = { &s3c_device_usb, &s3c_device_rtc, &s3c_device_lcd, &s3c_device_wdt, &s3c_device_i2c0, &s3c_device_iis, &mini2440_device_eth, &s3c24xx_uda134x, &s3c_device_nand, &s3c_device_sdi, &s3c_device_usbgadget, &s3c_device_adc, //添加下两行 &mini2440_adc, };
2. 写自己的驱动
/*=============================================================== * Copyright (C) 2014 All rights reserved. * * 文件名称:adc.c * 创 建 者:Gavin(Gavinlu1015@gmail.com) * 创建日期:2014年12月15日 * 描 述: * ================================================================*/ #include <linux/module.h> #include <linux/kernel.h> #include <linux/init.h> #include <linux/fs.h> #include <linux/cdev.h> #include <asm/uaccess.h> #include <linux/platform_device.h> #include <plat/adc.h> #include <plat/regs-adc.h> MODULE_LICENSE ("GPL"); int adc_major = 250; int adc_minor = 0; int number_of_devices = 1; struct s3c_adc_client *client; static struct class *cls; struct cdev cdev; dev_t devno = 0; static ssize_t adc_mini2440_read(struct file *file, char __user *buff, size_t count, loff_t *offset) { unsigned int data; unsigned int ch; data = 10; ch = 0; /*read*/ data = s3c_adc_read(client, ch); printk("data0 = %d\n", data); if(copy_to_user(buff, (char *)&data, sizeof(data))) return -EFAULT; return 0; } static int adc_mini2440_open(struct inode *inode, struct file *file) { return 0; } static int adc_mini2440_release(struct inode *inode, struct file *file) { return 0; } static struct file_operations adc_mini2440_fops = { .owner = THIS_MODULE, .read = adc_mini2440_read, .open = adc_mini2440_open, .release = adc_mini2440_release, }; static int __devinit adc_mini2440_probe( struct platform_device *pdev ) { struct device *dev = &pdev->dev; int ret; printk("mini2440 adc : function = %s\n", __func__); devno = MKDEV(adc_major, adc_minor); /* 申请设备 */ ret = register_chrdev_region(devno, number_of_devices, "mini2440_adc"); if(ret) { dev_err(dev, "failed to register device number\n"); goto err_register_chrdev_region; } /*初始化设备*/ cdev_init(&cdev, &adc_mini2440_fops); cdev.owner = THIS_MODULE; /* 加入到内核 */ ret = cdev_add(&cdev, devno, number_of_devices); if(ret) { dev_err(dev, "failed to add device\n"); goto err_cdev_add; } /* 申请adc */ client = s3c_adc_register (pdev, NULL, NULL, 0); if(IS_ERR(client)) { dev_err(dev, "failed to register adc client\n"); goto err_s3c_adc_register; } /* 创class自动创建节点 */ cls = class_create(THIS_MODULE, "s3c_adc"); device_create(cls, NULL, MKDEV(adc_major, 0), NULL, "adc"); return 0; err_s3c_adc_register: cdev_del(&cdev); err_cdev_add: unregister_chrdev_region(devno, number_of_devices); err_register_chrdev_region: return ret; } static int __devexit adc_mini2440_remove(struct platform_device *pdev) { s3c_adc_release(client); device_destroy(cls, MKDEV(adc_major, 0)); class_destroy(cls); cdev_del(&cdev); unregister_chrdev_region(devno, number_of_devices); return 0; } static struct platform_driver adc_mini2440_driver = { .driver = { .name = "mini2440_adc", .owner = THIS_MODULE, }, .probe = adc_mini2440_probe, .remove = __devexit_p(adc_mini2440_remove) }; static int __init adc_mini2440_init (void) { return platform_driver_register( &adc_mini2440_driver ); } static void __exit adc_mini2440_exit (void) { platform_driver_unregister(&adc_mini2440_driver ); } module_init (adc_mini2440_init); module_exit (adc_mini2440_exit);
3. Makefile:
NAME=adc obj-m = $(NAME).o PATH_=/home/nfs_share/rootfs KERN_DIR := /home/lu/study_mini2440/kernel/linux-2.6.32.2_mini22440/ #用uname -r可显示出内核版本号 PWD := $(shell pwd) all: make -C $(KERN_DIR) M=$(PWD) modules sudo cp $(NAME).ko $(PATH_) sudo chmod 777 $(PATH_) $(NAME).ko clean: rm -rf *.o *.ko *.mod.c *.order *.symvers
4. 测试文件:
/*=============================================================== * Copyright (C) 2014 All rights reserved. * * 文件名称:test.c * 创 建 者:Gavin * 创建日期:2014年12月15日 * 描 述: * ================================================================*/ #include <stdio.h> #include <sys/types.h> #include <unistd.h> #include <stdlib.h> #include <fcntl.h> int main (void) { int fd; int data; fd = open ("/dev/adc",O_RDWR); if (fd < 0) { perror("open"); return -1; } while(1) { read (fd, (char *)&data, sizeof(data)); printf("Voltage = %.2f\n", 3.3/1024*data); sleep(1); } close (fd); printf ("/dev/adc closed :)\n"); return 0; }
附:linux通用adc接口:
/* arch/arm/plat-s3c24xx/adc.c * * Copyright (c) 2008 Simtec Electronics * http://armlinux.simtec.co.uk/ * Ben Dooks <ben@simtec.co.uk>, <ben-linux@fluff.org> * * S3C24XX ADC device core * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License. */ #include <linux/module.h> #include <linux/kernel.h> #include <linux/platform_device.h> #include <linux/sched.h> #include <linux/list.h> #include <linux/err.h> #include <linux/clk.h> #include <linux/interrupt.h> #include <linux/io.h> #include <plat/regs-adc.h> #include <plat/adc.h> /* This driver is designed to control the usage of the ADC block between * the touchscreen and any other drivers that may need to use it, such as * the hwmon driver. * * Priority will be given to the touchscreen driver, but as this itself is * rate limited it should not starve other requests which are processed in * order that they are received. * * Each user registers to get a client block which uniquely identifies it * and stores information such as the necessary functions to callback when * action is required. */ struct s3c_adc_client { struct platform_device *pdev; struct list_head pend; wait_queue_head_t *wait; unsigned int nr_samples; int result; unsigned char is_ts; unsigned char channel; void (*select_cb)(struct s3c_adc_client *c, unsigned selected); void (*convert_cb)(struct s3c_adc_client *c, unsigned val1, unsigned val2, unsigned *samples_left); }; struct adc_device { struct platform_device *pdev; struct platform_device *owner; struct clk *clk; struct s3c_adc_client *cur; struct s3c_adc_client *ts_pend; void __iomem *regs; unsigned int prescale; int irq; }; static struct adc_device *adc_dev; static LIST_HEAD(adc_pending); #define adc_dbg(_adc, msg...) dev_dbg(&(_adc)->pdev->dev, msg) static inline void s3c_adc_convert(struct adc_device *adc) { unsigned con = readl(adc->regs + S3C2410_ADCCON); con |= S3C2410_ADCCON_ENABLE_START; writel(con, adc->regs + S3C2410_ADCCON); } static inline void s3c_adc_select(struct adc_device *adc, struct s3c_adc_client *client) { unsigned con = readl(adc->regs + S3C2410_ADCCON); client->select_cb(client, 1); con &= ~S3C2410_ADCCON_MUXMASK; con &= ~S3C2410_ADCCON_STDBM; con &= ~S3C2410_ADCCON_STARTMASK; if (!client->is_ts) con |= S3C2410_ADCCON_SELMUX(client->channel); writel(con, adc->regs + S3C2410_ADCCON); } static void s3c_adc_dbgshow(struct adc_device *adc) { adc_dbg(adc, "CON=%08x, TSC=%08x, DLY=%08x\n", readl(adc->regs + S3C2410_ADCCON), readl(adc->regs + S3C2410_ADCTSC), readl(adc->regs + S3C2410_ADCDLY)); } static void s3c_adc_try(struct adc_device *adc) { struct s3c_adc_client *next = adc->ts_pend; if (!next && !list_empty(&adc_pending)) { next = list_first_entry(&adc_pending, struct s3c_adc_client, pend); list_del(&next->pend); } else adc->ts_pend = NULL; if (next) { adc_dbg(adc, "new client is %p\n", next); adc->cur = next; s3c_adc_select(adc, next); s3c_adc_convert(adc); s3c_adc_dbgshow(adc); } } int s3c_adc_start(struct s3c_adc_client *client, unsigned int channel, unsigned int nr_samples) { struct adc_device *adc = adc_dev; unsigned long flags; if (!adc) { printk(KERN_ERR "%s: failed to find adc\n", __func__); return -EINVAL; } if (client->is_ts && adc->ts_pend) return -EAGAIN; local_irq_save(flags); client->channel = channel; client->nr_samples = nr_samples; if (client->is_ts) adc->ts_pend = client; else list_add_tail(&client->pend, &adc_pending); if (!adc->cur) s3c_adc_try(adc); local_irq_restore(flags); return 0; } EXPORT_SYMBOL_GPL(s3c_adc_start); static void s3c_convert_done(struct s3c_adc_client *client, unsigned v, unsigned u, unsigned *left) { client->result = v; wake_up(client->wait); } int s3c_adc_read(struct s3c_adc_client *client, unsigned int ch) { DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wake); int ret; client->convert_cb = s3c_convert_done; client->wait = &wake; client->result = -1; ret = s3c_adc_start(client, ch, 1); if (ret < 0) goto err; ret = wait_event_timeout(wake, client->result >= 0, HZ / 2); if (client->result < 0) { ret = -ETIMEDOUT; goto err; } client->convert_cb = NULL; return client->result; err: return ret; } EXPORT_SYMBOL_GPL(s3c_adc_read); static void s3c_adc_default_select(struct s3c_adc_client *client, unsigned select) { } struct s3c_adc_client *s3c_adc_register(struct platform_device *pdev, void (*select)(struct s3c_adc_client *client, unsigned int selected), void (*conv)(struct s3c_adc_client *client, unsigned d0, unsigned d1, unsigned *samples_left), unsigned int is_ts) { struct s3c_adc_client *client; WARN_ON(!pdev); if (!select) select = s3c_adc_default_select; if (!pdev) return ERR_PTR(-EINVAL); client = kzalloc(sizeof(struct s3c_adc_client), GFP_KERNEL); if (!client) { dev_err(&pdev->dev, "no memory for adc client\n"); return ERR_PTR(-ENOMEM); } client->pdev = pdev; client->is_ts = is_ts; client->select_cb = select; client->convert_cb = conv; return client; } EXPORT_SYMBOL_GPL(s3c_adc_register); void s3c_adc_release(struct s3c_adc_client *client) { /* We should really check that nothing is in progress. */ if (adc_dev->cur == client) adc_dev->cur = NULL; if (adc_dev->ts_pend == client) adc_dev->ts_pend = NULL; else { struct list_head *p, *n; struct s3c_adc_client *tmp; list_for_each_safe(p, n, &adc_pending) { tmp = list_entry(p, struct s3c_adc_client, pend); if (tmp == client) list_del(&tmp->pend); } } if (adc_dev->cur == NULL) s3c_adc_try(adc_dev); kfree(client); } EXPORT_SYMBOL_GPL(s3c_adc_release); static irqreturn_t s3c_adc_irq(int irq, void *pw) { struct adc_device *adc = pw; struct s3c_adc_client *client = adc->cur; unsigned long flags; unsigned data0, data1; if (!client) { dev_warn(&adc->pdev->dev, "%s: no adc pending\n", __func__); return IRQ_HANDLED; } data0 = readl(adc->regs + S3C2410_ADCDAT0); data1 = readl(adc->regs + S3C2410_ADCDAT1); adc_dbg(adc, "read %d: 0x%04x, 0x%04x\n", client->nr_samples, data0, data1); client->nr_samples--; if (client->convert_cb) (client->convert_cb)(client, data0 & 0x3ff, data1 & 0x3ff, &client->nr_samples); if (client->nr_samples > 0) { /* fire another conversion for this */ client->select_cb(client, 1); s3c_adc_convert(adc); } else { local_irq_save(flags); (client->select_cb)(client, 0); adc->cur = NULL; s3c_adc_try(adc); local_irq_restore(flags); } return IRQ_HANDLED; } static int s3c_adc_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct adc_device *adc; struct resource *regs; int ret; adc = kzalloc(sizeof(struct adc_device), GFP_KERNEL); if (adc == NULL) { dev_err(dev, "failed to allocate adc_device\n"); return -ENOMEM; } adc->pdev = pdev; adc->prescale = S3C2410_ADCCON_PRSCVL(49); adc->irq = platform_get_irq(pdev, 1); if (adc->irq <= 0) { dev_err(dev, "failed to get adc irq\n"); ret = -ENOENT; goto err_alloc; } ret = request_irq(adc->irq, s3c_adc_irq, 0, dev_name(dev), adc); if (ret < 0) { dev_err(dev, "failed to attach adc irq\n"); goto err_alloc; } adc->clk = clk_get(dev, "adc"); if (IS_ERR(adc->clk)) { dev_err(dev, "failed to get adc clock\n"); ret = PTR_ERR(adc->clk); goto err_irq; } regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!regs) { dev_err(dev, "failed to find registers\n"); ret = -ENXIO; goto err_clk; } adc->regs = ioremap(regs->start, resource_size(regs)); if (!adc->regs) { dev_err(dev, "failed to map registers\n"); ret = -ENXIO; goto err_clk; } clk_enable(adc->clk); writel(adc->prescale | S3C2410_ADCCON_PRSCEN, adc->regs + S3C2410_ADCCON); dev_info(dev, "attached adc driver\n"); platform_set_drvdata(pdev, adc); adc_dev = adc; return 0; err_clk: clk_put(adc->clk); err_irq: free_irq(adc->irq, adc); err_alloc: kfree(adc); return ret; } static int s3c_adc_remove(struct platform_device *pdev) { struct adc_device *adc = platform_get_drvdata(pdev); iounmap(adc->regs); free_irq(adc->irq, adc); clk_disable(adc->clk); clk_put(adc->clk); kfree(adc); return 0; } #ifdef CONFIG_PM static int s3c_adc_suspend(struct platform_device *pdev, pm_message_t state) { struct adc_device *adc = platform_get_drvdata(pdev); u32 con; con = readl(adc->regs + S3C2410_ADCCON); con |= S3C2410_ADCCON_STDBM; writel(con, adc->regs + S3C2410_ADCCON); clk_disable(adc->clk); return 0; } static int s3c_adc_resume(struct platform_device *pdev) { struct adc_device *adc = platform_get_drvdata(pdev); clk_enable(adc->clk); writel(adc->prescale | S3C2410_ADCCON_PRSCEN, adc->regs + S3C2410_ADCCON); return 0; } #else #define s3c_adc_suspend NULL #define s3c_adc_resume NULL #endif static struct platform_driver s3c_adc_driver = { .driver = { .name = "s3c24xx-adc", .owner = THIS_MODULE, }, .probe = s3c_adc_probe, .remove = __devexit_p(s3c_adc_remove), .suspend = s3c_adc_suspend, .resume = s3c_adc_resume, }; static int __init adc_init(void) { int ret; ret = platform_driver_register(&s3c_adc_driver); if (ret) printk(KERN_ERR "%s: failed to add adc driver\n", __func__); return ret; } arch_initcall(adc_init);
相关文章推荐
- linux S3C2440 spi 驱动简单测试 (基于简单字符驱动)
- linux S3C2440 spi 驱动简单测试 (基于简单字符驱动)
- 基于Linux视频驱动接口V4L2视频采集编程
- 基于Linux视频驱动接口V4L2视频采集编程
- 基于Linux视频驱动接口V4L2视频采集编程
- 基于数据驱动的接口测试框架设计
- 基于Linux内核的USB鼠标驱动的简单实现
- 基于Linux视频驱动接口V4L2视频采集编程
- Linux 2.6.32系统中基于dm6467平台ASOC架构的音频驱动
- linux input输入子系统分析《二》:s3c2440的ADC简单驱动实例分析
- 基于Linux视频驱动接口V4L2视频采…
- 基于Linux视频驱动接口V4L2视频采集编程
- linux-2.6.26下SPI1(4) S3C2440 spi驱动简单测试
- 简单、规范的Linux下的ds18b20驱动(基于mini2440开发板,2.6.29内核)
- 编译和安装linux内核2.6.x,一个简单的内核驱动测试
- 基于Linux视频驱动接口V4L2视频采集编程
- Linux 2.6.32系统中基于dm6467平台ASOC架构的音频驱动
- Linux2.6内核下简单的字符设备驱动及测试
- Linux 2.6.32系统中基于dm6467平台ASOC架构的音频驱动
- 基于S3C2440的嵌入式Linux驱动——AT24C02(EEPROM I2C接口)驱动解读