led_io.c

2440 ARM9 采集gpio的输入电平值的简单驱动

#include <linux/module.h>
#include <linux/version.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/delay.h>
#include <linux/poll.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/fcntl.h>
//#include <linux/interrupt.h>
//#include <linux/ptrace.h>
//#include <linux/ioport.h>
//#include <linux/in.h>
//#include <linux/slab.h>
//#include <linux/vmalloc.h>
//#include <linux/string.h>
//#include <linux/tqueue.h>
#include <linux/wait.h>
#include <asm/bitops.h>
#include <asm/io.h>
#include <linux/errno.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/arch/hardware.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/arch/regs-gpio.h>
#include <asm/arch/regs-clock.h> 
#include <linux/device.h>
#include "led_io.h"
//#include <stdio.h> 

#define LED_IO_MAJOR 102     //
#define DEVICE_NAME "led_io_driver"
#define BUFFER_SIZE 1

static led_io_major = LED_IO_MAJOR;


struct led_io_dev
{
	struct cdev cdev;				/*cdev结构体*/
	//s16 Temp_Value,Humi_Value;			//温湿度值，可与外围接口
	unsigned char buffer[BUFFER_SIZE];
	struct semaphore sem;
};
struct led_io_dev *led_io_devp;				/*结构体指针*/

int io_open(struct inode *inode,struct file *filp)/* 文件打开函数*/
{
	/*设备结构体指针赋值给文件私有数据指针*/
	struct led_io_dev *dev;
	dev = container_of(inode->i_cdev,struct led_io_dev,cdev);
	filp->private_data = dev;
	
	if(down_interruptible(&dev->sem))
	{
		return -ERESTARTSYS;
	}
	return 0;
}

int io_release(struct inode * inode, struct file * filp)/*文件释放函数*/
{
	struct led_io_dev *dev=filp->private_data;/*获取设备结构体指针*/
	up(&dev->sem);
	return 0;
}

static ssize_t io_read(struct file *filp,char __user *buf,size_t size,loff_t *ppos)
{	
	struct led_io_dev *dev=filp->private_data;/*获取设备结构体指针*/
	int result=0;
	//printk("4:%d\n",result);
	unsigned long p = *ppos;
	unsigned int count = size;
	int index=0;

	if(p >= BUFFER_SIZE)
	{return count ? - ENXIO : 0;}
	if(count > BUFFER_SIZE)
	{count = 1;}

	index=MINOR(dev->cdev.dev);
	switch(index)
	{
		case 0:
			dev->buffer[0]=READ_LED0();
			break;
		case 1:
			dev->buffer[0]=READ_LED1();
			break;
		case 2:
			dev->buffer[0]=READ_LED2();
			break;
		case 3:
			dev->buffer[0]=READ_LED3();
			break;
		default:
			return -ENXIO;
			break;
	}

	if(copy_to_user(buf,(void*)(dev->buffer+p),count))
	{
		result = - EFAULT;
		//printk("2:%d\n",result);
		printk("error:EFAULT\n");
	}
	else
	{
		*ppos += count;
		result = count;
		//printk("1:%d\n",result);
		//printk("read\n");
	}
	return result;
}

static ssize_t io_write(struct file *filp,char __user *buf,size_t size,
						loff_t *ppos)
{

}

int io_ioctl(struct inode *inode,struct file * filp,unsigned int cmd,unsigned long arg)
{
	
}

struct file_operations led_io_fops = {
	.owner = THIS_MODULE,
	.open = io_open,
	.ioctl = io_ioctl,
	.release = io_release,
	.read = io_read,
	.write = io_write,
};

/* ³õÊŒ»¯²¢×¢²ácdev*/
static void led_io_setup_cdev(struct led_io_dev *dev,int index)
{
	int err,devno = MKDEV(led_io_major,index);
	cdev_init(&dev->cdev,&led_io_fops);
	dev->cdev.owner = THIS_MODULE;
	dev->cdev.ops = &led_io_fops;
	err = cdev_add(&dev->cdev,devno,1);
	if(err)
	{printk(KERN_NOTICE "error %d adding led_io%d",err,index);}
}

int led_io_init(void)
{
	int result;
	dev_t devno = MKDEV(led_io_major,0);
	if(led_io_major)
		{result = register_chrdev_region(devno,4,"led_io");}
	else
	{
		result = alloc_chrdev_region(&devno,0,4,"led_io");
		led_io_major = MAJOR(devno);
	}
	if(result<0)
		return result;
		
	led_io_devp = kmalloc(4*sizeof(struct led_io_dev),GFP_KERNEL);
	if(!led_io_devp)
	{
		result = - ENOMEM;
		goto fail_malloc;
	}
	memset(led_io_devp,0,4*sizeof(struct led_io_dev));
	led_io_setup_cdev(&led_io_devp[0],0);
	init_MUTEX(&led_io_devp[0].sem);
	led_io_setup_cdev(&led_io_devp[1],1);
	init_MUTEX(&led_io_devp[1].sem);
	led_io_setup_cdev(&led_io_devp[2],2);
	init_MUTEX(&led_io_devp[2].sem);
	led_io_setup_cdev(&led_io_devp[3],3);
	init_MUTEX(&led_io_devp[3].sem);
	return 0;
fail_malloc:unregister_chrdev_region(devno,1);
	return result;
}

void led_io_exit(void)
{
	cdev_del(&led_io_devp[0].cdev);/*×¢Ïúcdev*/
	cdev_del(&led_io_devp[1].cdev);
	cdev_del(&led_io_devp[2].cdev);
	cdev_del(&led_io_devp[3].cdev);
	kfree(led_io_devp);
	unregister_chrdev_region(MKDEV(led_io_major,0),4);
}

MODULE_AUTHOR("EMA");
MODULE_LICENSE("Dual BSD/GPL");
module_init(led_io_init);
module_exit(led_io_exit);