tl16c554_linux.c

TL16C554在Linux2.4.18下的可运行驱动程序源代码

	restore_flags(flags);
}
*/





static int tl16c554_open(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_INC_USE_COUNT;
	return nRet;
}
static int tl16c554_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	int nRet = 0;
	
	switch(cmd) {
	default:
		return -EINVAL;
	}
	return nRet;
}
static int tl16c554_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
	int nRet = 0;
	
	return nRet;
}
static int tl16c554_release(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_DEC_USE_COUNT;
	return nRet;
}






static int TL0A_open(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_INC_USE_COUNT;
	return nRet;
}
static int TL0A_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	int nRet = 0;
	
	switch(cmd) {
	case TL_INIT:
		copy_from_user(&tl0A_init, (struct tagTL_INIT *)arg, sizeof(struct tagTL_INIT));
		Init_TL0A(tl0A_init.nBaud, tl0A_init.byMode);
		break;
	default:
		return -EINVAL;
	}
	return nRet;
}
static int TL0A_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
	int i;
	int nLen;
	unsigned char abyRecv[TL_RECV_LEN];
	nLen = get_TL0A_rxLen();
	nLen = nLen>count ? count : nLen;
	for(i=0; i<nLen; i++){
		abyRecv[i] = tl0A.abyRecvData[tl0A.sRecvHead];
		if(tl0A.sRecvHead != tl0A.sRecvTail){
			tl0A.sRecvHead++;
			tl0A.sRecvHead %= TL_RECV_LEN;
		}
		else
			break;
	}
	copy_to_user((void *)buf, &abyRecv, i);
	return i;
}
static int TL0A_write (struct file *file, const char *buf, size_t count, loff_t *ppos){
	int j,nRet;
	unsigned char abySend[TL_SEND_LEN];
	
	if (copy_from_user(abySend,buf,count)){
		return -EFAULT;
	}
	for(nRet=0; nRet<count; nRet++){
		TL0A_Txd(abySend[nRet]);
		for(j=0; j<90000; j++);//300000
//		printk("A:%02X\n", abySend[nRet]);
	}
	return nRet;
}
static int TL0A_release(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_DEC_USE_COUNT;
	return nRet;
}






static int TL0B_open(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_INC_USE_COUNT;
	return nRet;
}
static int TL0B_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	int nRet = 0;
	
	switch(cmd) {
	case TL_INIT:
		copy_from_user(&tl0B_init, (struct tagTL_INIT *)arg, sizeof(struct tagTL_INIT));
		Init_TL0B(tl0B_init.nBaud, tl0B_init.byMode);
		break;
	default:
		return -EINVAL;
	}
	return nRet;
}
static int TL0B_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
	int i;
	int nLen;
	unsigned char abyRecv[TL_RECV_LEN];
	nLen = get_TL0B_rxLen();
	nLen = nLen>count ? count : nLen;
	for(i=0; i<nLen; i++){
		abyRecv[i] = tl0B.abyRecvData[tl0B.sRecvHead];
		if(tl0B.sRecvHead != tl0B.sRecvTail){
			tl0B.sRecvHead++;
			tl0B.sRecvHead %= TL_RECV_LEN;
		}
		else
			break;
	}
	copy_to_user((void *)buf, &abyRecv, i);
	return i;
}
static int TL0B_write (struct file *file, const char *buf, size_t count, loff_t *ppos){
	int j,nRet;
	unsigned char abySend[TL_SEND_LEN];
	if (copy_from_user(abySend,buf,count)){
		return -EFAULT;
	}
	for(nRet=0; nRet<count; nRet++){
		TL0B_Txd(abySend[nRet]);
		for(j=0; j<90000; j++);//300000
//		printk("B:%02X\n", abySend[nRet]);
	}
	return nRet;
}
static int TL0B_release(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_DEC_USE_COUNT;
	return nRet;
}






static int TL0C_open(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_INC_USE_COUNT;
	return nRet;
}
static int TL0C_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	int nRet = 0;
	
	switch(cmd) {
	case TL_INIT:
		copy_from_user(&tl0C_init, (struct tagTL_INIT *)arg, sizeof(struct tagTL_INIT));
		Init_TL0C(tl0C_init.nBaud, tl0C_init.byMode);
		break;
	default:
		return -EINVAL;
	}
	return nRet;
}
static int TL0C_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
	int i;
	int nLen;
	unsigned char abyRecv[TL_RECV_LEN];
	nLen = get_TL0C_rxLen();
	nLen = nLen>count ? count : nLen;
	for(i=0; i<nLen; i++){
		abyRecv[i] = tl0C.abyRecvData[tl0C.sRecvHead];
		if(tl0C.sRecvHead != tl0C.sRecvTail){
			tl0C.sRecvHead++;
			tl0C.sRecvHead %= TL_RECV_LEN;
		}
		else
			break;
	}
	copy_to_user((void *)buf, &abyRecv, i);
	return i;
}
static int TL0C_write (struct file *file, const char *buf, size_t count, loff_t *ppos){
	int j,nRet;
	unsigned char abySend[TL_SEND_LEN];
	
	if (copy_from_user(abySend,buf,count)){
		return -EFAULT;
	}
	for(nRet=0; nRet<count; nRet++){
		TL0C_Txd(abySend[nRet]);
		for(j=0; j<90000; j++);//300000
//		printk("C:%02X\n", abySend[nRet]);
	}
	return nRet;
}
static int TL0C_release(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_DEC_USE_COUNT;
	return nRet;
}






static int TL0D_open(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_INC_USE_COUNT;
	return nRet;
}
static int TL0D_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
	int nRet = 0;
	
	switch(cmd) {
	case TL_INIT:
		copy_from_user(&tl0D_init, (struct tagTL_INIT *)arg, sizeof(struct tagTL_INIT));
		Init_TL0D(tl0D_init.nBaud, tl0D_init.byMode);
		break;
	
	case GPG2ON:
/*//		write_gpio_bit(GPIO_G2, 1);
		GPGDAT = 0x04;
		printk("\nGPG2 ON!\n");
*/
		GPGDAT |= 0x0004;
//		printk("GPGCON = 0x%08lx\n", GPGCON);
//		printk("GPGUP = 0x%08lx\n", GPGUP);
//		printk("GPGDAT = 0x%08lx\n", GPGDAT);
		break;
	
	case GPG2OFF:
/*//		write_gpio_bit(GPIO_G2, 0);
		GPGDAT = 0x00;
		printk("\nGPG2 OFF!\n");
*/
		GPGDAT &= ~0x0004;
//		printk("GPGCON = 0x%08lx\n", GPGCON);
//		printk("GPGUP = 0x%08lx\n", GPGUP);
//		printk("GPGDAT = 0x%08lx\n", GPGDAT);
		break;
	
	default:
		return -EINVAL;
	}
	return nRet;
}
static int TL0D_read(struct file *filp, char *buf, size_t count, loff_t *ppos)
{
	int i;
	int nLen;
	unsigned char abyRecv[TL_RECV_LEN];
	nLen = get_TL0D_rxLen();
	nLen = nLen>count ? count : nLen;
	for(i=0; i<nLen; i++){
		abyRecv[i] = tl0D.abyRecvData[tl0D.sRecvHead];
		if(tl0D.sRecvHead != tl0D.sRecvTail){
			tl0D.sRecvHead++;
			tl0D.sRecvHead %= TL_RECV_LEN;
		}
		else
			break;
//		printk("D-:%02X\n", abyRecv[i]);
	}
	copy_to_user((void *)buf, &abyRecv, i);
	return i;
}
static int TL0D_write (struct file *file, const char *buf, size_t count, loff_t *ppos){
	int j,nRet;
	unsigned char abySend[TL_SEND_LEN];
	if (copy_from_user(abySend,buf,count)){
		return -EFAULT;
	}
	for(nRet=0; nRet<count; nRet++){
		TL0D_Txd(abySend[nRet]);
		for(j=0; j<90000; j++);//300000
//		printk("D:%02X\n", abySend[nRet]);
	}
	return nRet;
}
static int TL0D_release(struct inode *inode, struct file *filp)
{
	int nRet = 0;
	
	MOD_DEC_USE_COUNT;
	return nRet;
}






static struct file_operations tl16c554_fops = {
	owner:	THIS_MODULE,
	open:	tl16c554_open,
	ioctl:	tl16c554_ioctl,
	read:	tl16c554_read,
	release:	tl16c554_release,
};

static struct file_operations TL0A_fops = {
	owner:	THIS_MODULE,
	open:	TL0A_open,
	ioctl:	TL0A_ioctl,
	read:	TL0A_read,
	write:	TL0A_write,
	release:	TL0A_release,
};

static struct file_operations TL0B_fops = {
	owner:	THIS_MODULE,
	open:	TL0B_open,
	ioctl:	TL0B_ioctl,
	read:	TL0B_read,
	write:	TL0B_write,
	release:	TL0B_release,
};

static struct file_operations TL0C_fops = {
	owner:	THIS_MODULE,
	open:	TL0C_open,
	ioctl:	TL0C_ioctl,
	read:	TL0C_read,
	write:	TL0C_write,
	release:	TL0C_release,
};

static struct file_operations TL0D_fops = {
	owner:	THIS_MODULE,
	open:	TL0D_open,
	ioctl:	TL0D_ioctl,
	read:	TL0D_read,
	write:	TL0D_write,
	release:	TL0D_release,
};

static devfs_handle_t devfs_tl_dir, devfs_TL0A, devfs_TL0B, devfs_TL0C, devfs_TL0D;

static int __init tl16c554_init(void)
{
	int ret;
	
	ret = register_chrdev(DEVICE_MAJOR, DEVICE_NAME, &tl16c554_fops);
	if (ret < 0) {
	  printk(DEVICE_NAME " can't get major number\n");
	  return ret;
	}
	tlMajor = ret;
	
	devfs_tl_dir = devfs_mk_dir(NULL, "tl16c554", NULL);
	devfs_TL0A = devfs_register(devfs_tl_dir, "0", DEVFS_FL_DEFAULT,     // dev/tl16c554/0 for TL0A
			tlMajor, TL0A, S_IFCHR | S_IRUSR | S_IWUSR,
			&TL0A_fops, NULL);
	devfs_TL0B = devfs_register(devfs_tl_dir, "1", DEVFS_FL_DEFAULT,     // dev/tl16c554/1 for TL0B
			tlMajor, TL0B, S_IFCHR | S_IRUSR | S_IWUSR,
			&TL0B_fops, NULL);
	devfs_TL0C = devfs_register(devfs_tl_dir, "2", DEVFS_FL_DEFAULT,     // dev/tl16c554/2 for TL0C
			tlMajor, TL0C, S_IFCHR | S_IRUSR | S_IWUSR,
			&TL0C_fops, NULL);
	devfs_TL0D = devfs_register(devfs_tl_dir, "3", DEVFS_FL_DEFAULT,     // dev/tl16c554/3 for TL0D
			tlMajor, TL0D, S_IFCHR | S_IRUSR | S_IWUSR,
			&TL0D_fops, NULL);
	
	set_external_irq(IRQ_EINT0, EXT_FALLING_EDGE, GPIO_MODE_IN | GPIO_PULLUP_DIS);//GPIO_PULLUP_DIS | GPIO_F0
//	set_external_irq(IRQ_EINT1, EXT_FALLING_EDGE, GPIO_MODE_IN);//GPIO_PULLUP_DIS 
	
	ret = request_irq(IRQ_EINT0, UART0_interrupt, SA_INTERRUPT, "TL16C554_0_RX Ready", UART0_interrupt);
	if(ret) {
		printk("TL16C554: failed to register IRQ_EINT0(%d)\n", IRQ_EINT0);
		goto UART0_failed;
	}
	/*
	ret = request_irq(IRQ_EINT1, UART1_interrupt, SA_INTERRUPT, "TL16C554_1_RX Ready", UART1_interrupt);
	if(ret) {
		printk("TL16C554: failed to register IRQ_EINT0(%d)\n", IRQ_EINT0);
		goto UART1_failed;
	}
	*/
//	BANKCON4 |= 0x00001FFC;//F60
//	BANKCON5 &= ~0x00007FFF;
//	BANKCON5 |= 0x00001FFC;//7FFC
//	GPGCON = 0xff95ff9a;
	GPGCON &= ~0x00000020;
	GPGCON |= 0x00000010;
	GPGUP = 0xff;
//	GPGDAT &= ~0x0004;
//	GPGDAT |= 0x0004;
//	printk("GPGCON = 0x%08lx\n", GPGCON);
//	printk("GPGUP = 0x%08lx\n", GPGUP);
//	printk("GPGDAT = 0x%08lx\n", GPGDAT);
	printk("GPHCON = 0x%08lx\n", GPHCON);
	printk("GPHUP = 0x%08lx\n", GPHUP);
	printk("GPHDAT = 0x%08lx\n", GPHDAT);
	printk("BANKCON4 = 0x%08lx\n", BANKCON4);
	printk("BANKCON5 = 0x%08lx\n", BANKCON5);
	return 0;

//UART1_failed:
//	free_irq(IRQ_EINT0, NULL);
UART0_failed:
	devfs_unregister(devfs_TL0D);
	devfs_unregister(devfs_TL0C);
	devfs_unregister(devfs_TL0B);
	devfs_unregister(devfs_TL0A);
	devfs_unregister(devfs_tl_dir);
	unregister_chrdev(tlMajor, DEVICE_NAME);
	return 0;
}

static void __exit tl16c554_exit(void)
{
	free_irq(IRQ_EINT0, NULL);
	free_irq(IRQ_EINT1, NULL);
	
	devfs_unregister(devfs_TL0D);
	devfs_unregister(devfs_TL0C);
	devfs_unregister(devfs_TL0B);
	devfs_unregister(devfs_TL0A);
	devfs_unregister(devfs_tl_dir);
	unregister_chrdev(tlMajor, DEVICE_NAME);

	iounmap((void *) (tl0A.pbyBase0));
	iounmap((void *) (tl0A.pbyBase1));
	iounmap((void *) (tl0B.pbyBase0));
	iounmap((void *) (tl0B.pbyBase1));
	iounmap((void *) (tl0C.pbyBase0));
	iounmap((void *) (tl0C.pbyBase1));
	iounmap((void *) (tl0D.pbyBase0));
	iounmap((void *) (tl0D.pbyBase1));
}

module_init(tl16c554_init);
module_exit(tl16c554_exit);