dac_driver.c~

S3C2410 DAC驱动程序

#include <linux/fs.h>   
#include <linux/major.h>
#include <asm/uaccess.h> 
#include <asm/hardware.h> 
#include <asm/arch-s3c2410/regs-gpio.h> 
#include <asm/io.h> 
#include <linux/vmalloc.h> 
#include <linux/config.h> 
#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>

#include <linux/kernel.h>  
#include <linux/delay.h>

#include "dac_driver.h"

MODULE_LICENSE("Dual BSD/GPL");

struct dac_dev *dac_devices;
static unsigned char dac_inc = 0;
int dac_data;
static void *DAC_CON;	//control
static void *DAC_DAT;		//data

void dac_init(void)
{
	dac_data = 0x7d00;
	DAC_CON = ioremap(0x3900f0e4,0x04);
	DAC_DAT = ioremap(0x3900f0ec,0x04);

/*	
	__raw_writel(dac_data, DAC_DAT);
	mdelay(1); 

	__raw_writel(0x7400, DAC_CON);	//dacs1:0111
	mdelay(10); 
	__raw_writel(0x5400, DAC_CON);	//dacs1:0101
	mdelay(80); 
	__raw_writel(0x7400, DAC_CON);	//dacs1:0111
	mdelay(10); 
	__raw_writel(0x0f400, DAC_CON); 
	
	__raw_writel(dac_data, DAC_DAT);
	mdelay(1);
		
	__raw_writel(0x0b400, DAC_CON);	//dacs2:1011
	mdelay(10); 
	__raw_writel(0x9400, DAC_CON);	//dacs2:1001
	mdelay(80); 
	__raw_writel(0x0b400, DAC_CON);	//dacs2:1011
	mdelay(10); 
	__raw_writel(0x0f400, DAC_CON);
*/
}

int dac_open(struct inode *inode, struct file *filp)
{	
	struct dac_dev *dev;
	
	if (dac_inc>0) return -ERESTARTSYS;

	dac_inc++;

	dev = container_of(inode->i_cdev, struct dac_dev, cdev);
	filp->private_data = dev;
	
	printk("DAC driver open OK\n");
	return 0;
}

int dac_release(struct inode *inode, struct file *filp)
{
	dac_inc--;

	printk("release OK\n");
	return 0;
}

ssize_t dac_read(struct file *filp, char __user *buf, size_t count,
                   loff_t *f_pos)
{
	printk("DAC open successful!\n");
	
	return 0;
}

ssize_t dac_write(struct file *filp, const char __user *buf, size_t count,
                    loff_t *f_pos)
{
	dac_data = buf[0] << 8;
	printk("dac_data = 0x%x\n", dac_data);

	//if (command==1)
	//{
		__raw_writel(dac_data, DAC_DAT);
		mdelay(1); 

		__raw_writel(0x7400, DAC_CON);	//dacs1:0111
		mdelay(10); 
		__raw_writel(0x5400, DAC_CON);	//dacs1:0101
		mdelay(80); 
		__raw_writel(0x7400, DAC_CON);	//dacs1:0111
		mdelay(10); 
		__raw_writel(0x0f400, DAC_CON); 
	
	//}
	//if (command==2)
	//{
		__raw_writel(dac_data, DAC_DAT);
		mdelay(1);
		
		__raw_writel(0x0b400, DAC_CON);	//dacs2:1011
		mdelay(10); 
		__raw_writel(0x9400, DAC_CON);	//dacs2:1001
		mdelay(80); 
		__raw_writel(0x0b400, DAC_CON);	//dacs2:1011
		mdelay(10); 
		__raw_writel(0x0f400, DAC_CON);
	//}

	return 0;
}

struct file_operations dac_fops = {
	.owner =		THIS_MODULE,
	.open =		dac_open,
	.release =		dac_release,
	.read =		dac_read,
	.write =		dac_write,
};

/*******************************************************
                MODULE ROUTINE
*******************************************************/

int __init dac_init_module(void)
{
	dac_init();
	
	int result = 0;
	dev_t dev = 0;

	dev = MKDEV(DAC_MAJOR, DAC_MINOR);
	result = register_chrdev_region(dev, 1, "dac");

	if (result < 0) 
	{
		printk(KERN_WARNING "dac: can't get major %d\n", DAC_MAJOR);
		return result;
	}

	dac_devices = kmalloc(sizeof(struct dac_dev), GFP_KERNEL);
	if (!dac_devices)
	{
		printk(KERN_NOTICE "Error %d", result);
		result = -ENOMEM;
		goto fail;
	}
	memset(dac_devices, 0, sizeof(struct dac_dev));

	cdev_init(&dac_devices->cdev, &dac_fops);
	dac_devices->cdev.owner = THIS_MODULE;
	dac_devices->cdev.ops = &dac_fops;
	result = cdev_add (&dac_devices->cdev, dev, 1);
	if(result) {
		printk(KERN_NOTICE "Error %d adding dac\n", result);
		goto fail;
	}
	
	printk("register dac driver seccessful!");
	
	return 0;

fail:
	dac_cleanup_module();
	return result;
}

void __exit dac_cleanup_module(void)
{
	dev_t devno = MKDEV(DAC_MAJOR, DAC_MINOR);

	if (dac_devices) 
	{
		cdev_del(&dac_devices->cdev);
		kfree(dac_devices);
	}		
	unregister_chrdev_region(devno,1);
	
	printk("unregister dac driver seccessful!\n");
}

module_init(dac_init_module);           
module_exit(dac_cleanup_module);