k.c

键盘驱动程序Based on xtkbd.c/locomkbd.c

			IICStop();

			// 等待写完毕
			while(!IICCompleteBuf(IIC_ADDR_RADIO));
		}
	}

	return 1;

}

//读FM五个字节
unsigned char IICREAD_FM(void)
{
	int i;
	BYTE buf;

	dpk_iic("IICREAD_FM\n");

	// 给一个起始信号
	IICStart();

	IICSendByte(IIC_ADDR_RADIO | IIC_CTL_BYTE_R);


	// 器件是否应答
	if(IICHasRecvAck())
	{			
		for(i=0;i<5;i++)
		{
			buf = IICRecvByte();
			IICSendAck();
			printk("%x ",buf);

			fm_rx[i] = buf;
		}
		// 停止
		IICStop();

		// 等待写完毕
		while(!IICCompleteBuf(IIC_ADDR_RADIO));
	}


	IICSendNoAck();
	IICStop();

	return 1;

}

//读 NEC
static irqreturn_t IIC_READ_NEC(int irq, void *dev_id)
{
	BYTE i,count;
	BYTE buf;
	dpk_iic("IICREAD_NEC\n");

			
				IICStop();

			
			/////////////////////
			// 器件寻址	
				
			// 给一个起始信号，发地址
			IICStart();

			IICSendByte(IIC_ADDR_NEC | IIC_CTL_BYTE_R);

			// 器件是否应答
			if(IICHasRecvAck())
			{			
				mdelay(10);

				buf = IICRecvByte();
				IICSendAck();
				printk("%x ",buf);

/*				buf = IICRecvByte();
OUTP_SDA;
				IICSendAck();
mdelay(10);
				printk("%x ",buf);

INP_SDA;
				count = buf;
				// 接收
				for (i=0;i<count;i++)
*/
//			switch (buf << 3)
			{
//			case default:
				//KM62,再接收1B数据长度、1B的键盘数据、1B样验字节
/*				buf = IICRecvByte();
				printk("%x ",buf);

				IICSendAck();
*/
				buf = IICRecvByte();
				printk("%x ",buf);

//				IICSendAck();

//				buf = 0;
				input_report_key(km62kbd->input, km62kbd->keycode[((buf>>4) -1) * 8 + ((buf & 0xf) -1)], 1);
				input_report_key(km62kbd->input, km62kbd->keycode[((buf>>4) -1) * 8 + ((buf & 0xf) -1)], 0);

				input_sync(km62kbd->input);
/*
				buf = IICRecvByte();
				printk("%x ",buf);

				IICSendAck();
*/
			}
		}

				IICSendNoAck();
				IICStop();
	printk("\n");

	return IRQ_HANDLED;

}

//写DSP
unsigned char IICWRITE_NEC_DSP(char *dsp_str,size_t count)
{
	int i,j;

	dpk_iic("IICWRITE_NEC_DSP\n");

	
	dsp_tx[2] = 0;
	dsp_tx[3] = 0;
	dsp_tx[4] = 0;
	dsp_tx[5] = 0x80;
	dsp_tx[6] = 0;
	dsp_tx[7] = 0;
printk("dsp_str = %s\n",dsp_str);

	i=0;
	while(i<count)
	{
		j= *dsp_str - 48 ;
		if (j >= 0 && j <=9)
		{
			dsp_tx[2 + (6 - count) + i + 1] += dsp_digi_data[j];

			printk("*dsp_str =%d ,dsp_tx[%d] = %x \n",j,2 + (6 - count) + i + 1,dsp_digi_data[j]);
		}

		dsp_str ++;
		i++;
	}

	for(i=0;i<8;i++)
	{
		dsp_tx[8] += dsp_tx[i];
	}

	IICStop();

	// 给一个起始信号
	IICStart();

	IICSendByte(IIC_ADDR_NEC | IIC_CTL_BYTE_W);


	// 器件是否应答
	if(IICHasRecvAck())
	{			
//		IICSendByte(IIC_ADDR_RADIO);

		// 应答
//		if(IICHasRecvAck())
		{
			for(i=0;i<9;i++)
			{
				IICSendByte(dsp_tx[i]);

				// 应答，如果没有应答则退出
				if(!IICHasRecvAck())
					return 0;
			}
			// 停止
			IICStop();

			// 等待写完毕
//			while(!IICCompleteBuf(IIC_ADDR_NEC));
		}
	}

	return 1;

}

static void kick_drawer()
{
	printk("Kicking drawer ...");
		s3c2410_gpio_setpin(CASH_PORT,1);
		mdelay(CASH_MS);
		s3c2410_gpio_setpin(CASH_PORT,0);
	printk("Done \n");
}

/*

static int __init i2c_dev_init(void)
{
	BYTE * data="e";

	dpk_iic("i2c /dev entries driver\n");


	OUTP_SDA;
	OUTP_SCL;
	s3c2410_gpio_pullup(S3C2410_GPE15 ,0);
	s3c2410_gpio_pullup(S3C2410_GPE14 ,0);

	s3c2410_gpio_cfgpin(S3C2410_GPF6, S3C2410_GPF6_INP);
	mdelay(1);
//	IICWRITE_EEPROM_BYTE(data,15,IIC_ADDR_EEPROM);
	IICWRITE_FM();

//	IICWRITE_NEC_DSP();

//	IICREAD_NEC();

	return 0;

}


static void __exit i2c_dev_exit(void)
{
	BYTE * data="          ";

//	IICREAD_EEPROM_BYTE(data,10,IIC_ADDR_EEPROM);
//	dpk_iic("0x%x %s\n",*data,data);

//	IICREAD_EEPROM_STR(data,10,10,IIC_ADDR_EEPROM);
	printk("IICREAD_EEPROM_STR: %s\n",data);
}

MODULE_AUTHOR("Frodo Looijaard <[e-mail]> and "
		"Simon G. Vogl <[e-mail]>");
MODULE_DESCRIPTION("i2c /dev entries driver");
MODULE_LICENSE("GPL");


module_init(i2c_dev_init);
module_exit(i2c_dev_exit);






static irqreturn_t key_down(int irq, void *dev_id)
{
	unsigned int li_row=1, li_col=1;
	printk(" keydown... \n");

			input_report_key(km62kbd->input, km62kbd->keycode[(li_col -1) * 8  + (li_row -1 )], 1);
			input_report_key(km62kbd->input, km62kbd->keycode[(li_col -1) * 8  + (li_row -1 )], 0);

			input_sync(km62kbd->input);

	return IRQ_HANDLED;
}
*/
static int __init km62kbd_probe(struct platform_device *pdev)
{
//	struct km62kbd *km62kbd;
	struct input_dev *input_dev;
	int i, err = -ENOMEM;
	BYTE * data="e";

//printk("km62 probing.\n");

	km62kbd = kzalloc(sizeof(struct km62kbd), GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!km62kbd || !input_dev)
		goto fail;

	platform_set_drvdata(pdev, km62kbd);

	km62kbd->input = input_dev;
	spin_lock_init(&km62kbd->lock);

	/* Init Keyboard rescan timer */
/*	init_timer(&km62kbd->timer);
	km62kbd->timer.function = km62kbd_timer_callback;
	km62kbd->timer.data = (unsigned long) km62kbd;


	km62kbd->suspend_jiffies=jiffies + msecs_to_jiffies(SCAN_INTERVAL);
*/
	memcpy(km62kbd->keycode, km62kbd_keycode, sizeof(km62kbd->keycode));

	input_dev->name = "Km62 Keyboard";
	input_dev->phys = "input/input1";
	input_dev->id.bustype = BUS_HOST;
	input_dev->id.vendor = 0x0001;
	input_dev->id.product = 0x0001;
	input_dev->id.version = 0x0100;
	input_dev->cdev.dev = &pdev->dev;
	input_dev->private = km62kbd;

	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_SYN);
	input_dev->keycode = km62kbd->keycode;
	input_dev->keycodesize = sizeof(unsigned char);
	input_dev->keycodemax = ARRAY_SIZE(km62kbd_keycode);

	for (i = 0; i < ARRAY_SIZE(km62kbd_keycode); i++)
		set_bit(km62kbd->keycode[i], input_dev->keybit);
	clear_bit(0, input_dev->keybit);
	
	err = input_register_device(km62kbd->input);
	if (err)
		goto fail;


	//IIC - SCL/SDA	
	OUTP_SDA;
	OUTP_SCL;
	s3c2410_gpio_pullup(S3C2410_GPE15 ,0);
	s3c2410_gpio_pullup(S3C2410_GPE14 ,0);
	SDA(1);
	SCL(1);
	
	/* Get irqs */
	if (request_irq(IRQ_EINT6, IIC_READ_NEC, SA_INTERRUPT,"Km62_kbd", NULL))
	{
		printk(KERN_ERR "k.c: Could not allocate IRQ !\n");
		goto fail;
	}

	set_irq_type(IRQ_EINT6,IRQ_TYPE_EDGE_FALLING);


	s3c2410_gpio_cfgpin(CASH_PORT, S3C2410_GPB9_OUTP);
	s3c2410_gpio_pullup(CASH_PORT, 0);
	s3c2410_gpio_setpin(CASH_PORT, 0);


	IICWRITE_EEPROM_BYTE(data,0);
	IICWRITE_EEPROM_BYTE(data,1);
	IICWRITE_EEPROM_BYTE(data,2);
	IICWRITE_EEPROM_BYTE(data,3);
	IICWRITE_EEPROM_BYTE(data,4);
	IICWRITE_EEPROM_BYTE(data,5);
	IICWRITE_EEPROM_BYTE(data,6);
	IICWRITE_EEPROM_BYTE(data,7);
	IICWRITE_EEPROM_BYTE(data,8);
	IICWRITE_EEPROM_BYTE(data,9);
	IICWRITE_EEPROM_BYTE(data,10);

	IICWRITE_FM();

mdelay(100);

	IICREAD_FM();

//	IICWRITE_FM();
	return 0;

 fail:	input_free_device(input_dev);
	kfree(km62kbd);
	printk("input_register_device failed.\n");
	return err;
}

static int km62kbd_remove(struct platform_device *pdev)
{
//	struct km62kbd *km62kbd = platform_get_drvdata(pdev);


//	del_timer_sync(&km62kbd->timer);

	input_unregister_device(km62kbd->input);

	kfree(km62kbd);

	return 0;
}

static struct platform_driver km62kbd_driver = {
	.probe		= km62kbd_probe,
	.remove		= km62kbd_remove,
	.driver		= {
	       .name   = "s3c2410-kb",
	       .owner  = THIS_MODULE,
	},
};

static ssize_t pherial_read  (struct file *filp, char __user *buf, size_t count, loff_t *offset)
{
	char *tmp;
//	char read_data[256];


//	tmp = "I Love you";
	switch(OPERATING_PHERIAL)
	{
		case DEV_RF:
			break;
		case DEV_4442:
			break;
		case DEV_DSP:
			break;
		case DEV_KM62:
			break;
		case DEV_PS2:
			break;
		case DEV_MAG:
			break;
		case DEV_FM:
			break;
		case DEV_E2PROM:
			printk("EEPROM Reading : %d,%d\n",*offset,count);
//			IICREAD_EEPROM_STR(tmp,offset,count);
			IICREAD_EEPROM_STR(tmp,0,10);
			printk("pherial_read: %s",tmp);
			break;
	}


	copy_to_user(buf, tmp, 10);

//	kfree(tmp);

	return sizeof(tmp);

}

static ssize_t pherial_write (struct file *file, const char __user *buf, size_t count,
                             loff_t *offset)
{
	char *tmp,*s;
	int i;
	char write_data[256];

	if (count > 256)
	{
		count = 256;
	}

	tmp = kmalloc(count,GFP_KERNEL);
	if (tmp==NULL)
		return -ENOMEM;
	if (copy_from_user(tmp,buf,count)) {
		kfree(tmp);
		return -EFAULT;
	}


	printk("pherial_write: buf[%d]=%s\n       ",count,tmp);

	s=tmp;
	i=0;
	while (i<count)
	{
		write_data[i] = *s;

		i++;
		s++;
	}

	kfree(tmp);

	write_data[i] = '\0';

	printk("   write_data = %s\n",write_data);

	switch(OPERATING_PHERIAL)
	{
		case DEV_RF:
			break;
		case DEV_4442:
			break;
		case DEV_DSP:
			IICWRITE_NEC_DSP(write_data,count);
			break;
		case DEV_KM62:
			break;
		case DEV_PS2:
			break;
		case DEV_CASH:
			kick_drawer();
			break;
		case DEV_MAG:
			break;
		case DEV_FM:
			IICWRITE_FM();
			break;
		case DEV_E2PROM:
			break;
	}

	return 1;
}

static int pherial_ioctl(struct inode *inode, struct file *file,
		unsigned int cmd, unsigned long arg)
{
printk("cmd=%d,arg=%d\n",cmd,arg);
	switch(cmd)
	{
		case DEV_RF:
			OPERATING_PHERIAL = DEV_RF;
			break;
		case DEV_4442:
			OPERATING_PHERIAL = DEV_4442;
			break;
		case DEV_DSP:
			OPERATING_PHERIAL = DEV_DSP;
			break;
		case DEV_KM62:
			OPERATING_PHERIAL = DEV_KM62;
			break;
		case DEV_PS2:
			OPERATING_PHERIAL = DEV_PS2;
			break;
		case DEV_CASH:
			OPERATING_PHERIAL = DEV_CASH;
			CASH_MS = arg;
			break;
		case DEV_MAG:
			OPERATING_PHERIAL = DEV_MAG;
			break;
		case DEV_FM:
			OPERATING_PHERIAL = DEV_FM;
			break;
		case DEV_E2PROM:
			OPERATING_PHERIAL = DEV_E2PROM;
			break;
	}

	return 0;
}

static int pherial_open(struct inode *inode, struct file *file)
{
	printk("pherial.open()\n");

	
	return 0;
}

static int pherial_close(struct inode *inode, struct file *file)
{
	printk("pherial.close()\n");


	return 0;
}


static struct file_operations pherial_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.read		= pherial_read,
	.write		= pherial_write,
	.ioctl		= pherial_ioctl,
	.open		= pherial_open,
	.release		= pherial_close,
};


static int __devinit km62kbd_init(void)
{
	int res;

	platform_driver_register(&km62kbd_driver);

	res = register_chrdev(PHERIAL_MAJOR, "pherial", &pherial_fops);
	if (res)
		goto out;



	return 0;

out:
	unregister_chrdev(PHERIAL_MAJOR, "pherial");
	printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
	return res;

}

static void __exit km62kbd_exit(void)
{
	platform_driver_unregister(&km62kbd_driver);
	unregister_chrdev(PHERIAL_MAJOR,"pherial");
	free_irq(IRQ_EINT6,NULL);
}

module_init(km62kbd_init);
module_exit(km62kbd_exit);

MODULE_AUTHOR("Richard Purdie <[e-mail]>");
MODULE_DESCRIPTION("Corgi Keyboard Driver");
MODULE_LICENSE("GPL");