#ifndef __KERNEL__
# define __KERNEL__
#endif
#ifndef MODULE
# define MODULE
#endif
#include <Linux/config.h>
#include <Linux/module.h>
#include <Linux/kernel.h>                       /* printk() */
#include <Linux/slab.h>                        /* kmalloc() */
#include <Linux/fs.h>                          /* everything... */
#include <Linux/errno.h>                      /* error codes */
#include <Linux/types.h>                       /* size_t */
#include <Linux/init.h>
#include <Linux/delay.h>                        /* udelay() */
#include <asm/io.h>                             /* ioremap(), iounmap() */
#include <Linux/ioport.h>
#include <asm/irq.h>
#include <Linux/string.h>
#include <asm/uaccess.h>
#include <asm/arch/irqs.h>
#include "fps200.h"                             /*本地定義 */
#define FPS200_VR 0xfd000000
#define FPS_INDEX (*(volatile unsigned char *)FPS200_VR)
#define FPS_DATA (*(volatile unsigned char *)(FPS200_VR+1))
#define FPS200_MAJOR 240
#define FPS200_NR_DEVS 0
#define FPS200_IRQ IRQ_EINT2                     // irq = 6
#define FPS200_DATASIZE 76800
int fps200_major = FPS200_MAJOR;
int fps200_nr_devs = FPS200_NR_DEVS; 
                               /* number of bare fps200 devices (no use here) */
MODULE_PARM(fps200_major,"i");
MODULE_PARM(fps200_nr_devs,"i");
MODULE_AUTHOR("Nankai Unversity 5-304");
MODULE_LICENSE("GPL");
struct file_operations fps200_fops = {
	open: fps200_open,
	ioctl: fps200_ioctl,
	release: fps200_release
};
struct file_operations *fps200_fop_array[]={
	&fps200_fops,                                                /* type 0 */
                                                              
};
#define FPS200_MAX_TYPE 0
FPS200_Dev *fps200_device;
void fps200_interrupt(int irq, void *dev_id, struct pt_regs *regs) {
	disable_irq(irq);
//fps_get_image();
	fps200_device->flag = 1;
}
void fps_get_image(void) 
{
	int i = 0;
	int j = 0;
	FPS_INDEX = FPS_CTRLA;
	FPS_DATA = FPS_CTRLA_GETIMG;
	for(i=0; i<300; i++) {
		FPS_INDEX = FPS_CTRLB;
		while(!(FPS_CTRLB_RDY&FPS_DATA)){udelay(1);};
		for(j=0; j<256; j++) {
			FPS_INDEX = FPS_CTRLB;
			while(!(FPS_CTRLB_RDY&FPS_DATA)){udelay(1);};
			FPS_INDEX = FPS_CTRLA;
			*((unsigned char *)(fps200_device->data+i*256+j))=FPS_DATA;
		}
	}
}
int fps200_open(struct inode *inode, struct file *filp)
{
	MOD_INC_USE_COUNT;
	return(0);
}
int fps200_release(struct inode *inode, struct file *filp) 
{
	MOD_DEC_USE_COUNT;
	return(0);
}
int fps200_ioctl(struct inode *inode, struct file *filp,
unsigned int cmd, unsigned long arg) 
{
	int err = 0;
	int ret = 0;
	unsigned char tmp;
	if(_IOC_TYPE(cmd) != FPS200_IOC_MAGIC)
	return -ENOTTY;
	if(_IOC_NR(cmd) > FPS200_IOC_MAXNR)
	return -ENOTTY;
	if (_IOC_DIR(cmd) & _IOC_READ)
	err = verify_area(VERIFY_WRITE, (void *)arg,
	_IOC_SIZE(cmd));
	else if (_IOC_DIR(cmd) & _IOC_WRITE)
	err = verify_area(VERIFY_READ, (void *)arg,
	_IOC_SIZE(cmd));
	if (err)
	return err;
	switch(cmd) 
	{
	case FPS200_IOCSDTR:
		ret = __get_user(tmp, (unsigned char *)arg);
		if(tmp > 0x7f)
		tmp = 0x7f;
		FPS_INDEX = FPS_DTR;
		FPS_DATA = tmp;
		break;
	case FPS200_IOCSDCR:
		ret = __get_user(tmp, (unsigned char *)arg);
		if(tmp > 0x1f)
		tmp = 0x1f;
		FPS_INDEX = FPS_DCR;
		FPS_DATA = tmp;
		break;
	case FPS200_IOCSPGC:
		ret = __get_user(tmp, (unsigned char *)arg);
		if(tmp > 0x0f)
		tmp = 0x0f;
		FPS_INDEX = FPS_PGC;
		FPS_DATA = tmp;
		break;
	case FPS200_IOCGDTR:
		FPS_INDEX = FPS_DTR;
		tmp = FPS_DATA;
		ret = __put_user(tmp, (unsigned char *)arg);
		break;
	case FPS200_IOCGDCR:
		FPS_INDEX = FPS_DCR;
		tmp = FPS_DATA;
		ret = __put_user(tmp, (unsigned char *)arg);
		break;
	case FPS200_IOCGPGC:
		FPS_INDEX = FPS_PGC;
		tmp = FPS_DATA;
		ret = __put_user(tmp, (unsigned char *)arg);
		break;
	case FPS200_IOCEINT:
		enable_irq(FPS200_IRQ);
		break;
	case FPS200_IOCDINT:
		disable_irq(FPS200_IRQ);
		break;
	case FPS200_IOCFCAP:
		fps_get_image();
	case FPS200_IOCGDATA:
		copy_to_user((void *)arg, fps200_device->data,
		FPS200_DATASIZE);
		ret = 0;
		fps200_device->flag = 0;
		break;
	case FPS200_IOCCLR:
		memset(fps200_device->data, 0, FPS200_DATASIZE);
		fps200_device->flag = 0;
		break;
	case FPS200_IOCCINT:
		if(((clps_readw(INTSR1))&0x40) == 0)
		{
		udelay(100);
		if(((clps_readw(INTSR1))&0x40) == 0)
		ret = __put_user(0x01, (unsigned char *)arg);
		else
		ret = __put_user(0x0, (unsigned char *)arg);
	}
		else
		ret = __put_user(0x0, (unsigned char *)arg);
		break;
	case FPS200_IOCCRDY:
		ret = __put_user(fps200_device->flag, (unsigned char
		*)arg);
		break;
	default:
	return -ENOTTY;
	}
	return ret;
}
static int __init fps200_init_module(void)
{
	int result;
	char tmp;
	if((result = check_region (FPS200_VR,2))) 
	{
	printk ("<1> can't get I/O port address \n");
	return (result);
	}
	if (!request_region (FPS200_VR,2,"fps200"))
	return -EBUSY;
	SET_MODULE_OWNER(&fps200_fops);
	result = register_chrdev(fps200_major, "fps200",&fps200_fops);
	if(result < 0) 
	{
	printk("<1>fps200: can't get major %d\n",fps200_major);
	return result;
	}
	if(fps200_major == 0)
	fps200_major = result;                      /* 動(dòng)態(tài) */

/* read chip id first, if not equal 0x20xx, print error*/

	FPS_INDEX = FPS_CIDH;
	tmp = FPS_DATA;
	if(tmp != 0x20) 
	{
	printk("<1>wrong chip ID, insmod fail.\n");
	return -EIO;
	}
/* row auto inc. inner 12MHz vibrator. no low-power state*/

	FPS_INDEX = FPS_CTRLB;
	FPS_DATA = (FPS_CTRLB_AFDEN|FPS_CTRLB_AUTOINCEN|FPS_CTRLB_ENABLE);
														      /* 等待30us */
	udelay(35);                                            // 使時(shí)延大于 30us
													          /* 中斷 */
	FPS_INDEX = FPS_ICR;
	FPS_DATA = (FPS_ICR_IE0|FPS_ICR_IT0_LEVEL);
	FPS_INDEX = FPS_THR;
	FPS_DATA = ( FPS_THR_THV | FPS_THR_THC );
													          /* DTR, DCR, PGC */
	FPS_INDEX = FPS_DTR;
	FPS_DATA = 0x23;
	FPS_INDEX = FPS_DCR;
	FPS_DATA = 0x1;
	FPS_INDEX = FPS_PGC;
	FPS_DATA = 0;
													            /* 其他的初始化 */
	FPS_INDEX = FPS_RAL;                                       // raw 地址
	FPS_DATA = 0;
	FPS_INDEX = FPS_RAH;
	FPS_DATA = 0;
	FPS_INDEX = FPS_REL;
	FPS_DATA = 0;
	FPS_INDEX = FPS_REH;
	FPS_DATA = 0;
	FPS_INDEX = FPS_CAL;                                     // column 地址
	FPS_DATA = 0;
	FPS_INDEX = FPS_CEL;
	FPS_DATA = 0;
	FPS_INDEX = FPS_CTRLC;
	FPS_DATA = 0;
	FPS_INDEX = FPS_CTRLA;
	FPS_DATA = 0;// clear FPS_CTRLA_AINSEL
													             /* 設(shè)置 irq */
	if(result) 
	{
	printk("<1>can't get assigned irq.\n");
	return -EIO;
	}
	fps200_device = kmalloc(sizeof(FPS200_Dev),
	GFP_KERNEL);
	if(!fps200_device) 
	{
	FPS_INDEX = FPS_CTRLB;
	FPS_DATA = 0;
	return -ENOMEM;
	}
	memset(fps200_device, 0, sizeof(FPS200_Dev));
	fps200_device->data = kmalloc(FPS200_DATASIZE,
	GFP_KERNEL);
	if(!fps200_device) 
	{
	FPS_INDEX = FPS_CTRLB;
	FPS_DATA = 0;
	kfree(fps200_device);
	return -ENOMEM;
	}
	memset(fps200_device->data, 0, FPS200_DATASIZE);
													                /* 設(shè)置 irq */
	result = request_irq(FPS200_IRQ, fps200_interrupt,
	SA_INTERRUPT, "fps200", NULL);
	return(0);
}
static void __exit fps200_cleanup_module(void) 
{
	kfree(fps200_device->data);
	kfree(fps200_device);
	FPS_INDEX = FPS_CTRLB;
	FPS_DATA = 0;
	release_region (FPS200_VR,2);
	free_irq(FPS200_IRQ, NULL);
	unregister_chrdev(fps200_major, "fps200");
}
module_init(fps200_init_module);
module_exit(fps200_cleanup_module);