fs44b0mu110.c

uClinux基于S3C44B0X打印机驱动

		Mdelay826US();
	}		
	for (i = Right_limit; i < 209; i++)
	{			
		CR_Motor_B_Step();
		CPLD_M110_PrintDat_Addr = PrintBuf[1][2*n];
		PrintTriggerPulse();
		Mdelay826US();
		CPLD_M110_PrintDat_Addr = 0xff;	
		n++;
	}	
	CR_Deleration_B();
	MdelayTime(CR_Lash);
	
	//CR_Acceleration_A();
	//CR_ConstSpeed_A(209);//209
	//CR_Deleration_A();
	CR_Acceleration_A();
	//CR_Motor_A_Step();
		
	for (i = Right_limit; i < 209; i++)
	{					
		//Mdelay200US();
		CR_Motor_A_Step();
		Mdelay413US();
		CPLD_M110_PrintDat_Addr = PrintBuf[1][2*n - 1];
		PrintTriggerPulse();
		//CR_Motor_A_Step();
		Mdelay413US();
		//Mdelay626US();
		CPLD_M110_PrintDat_Addr = 0xff;	
		n--;
	}	
	//Mdelay200US();
	for(i = 0; i < Right_limit; i++)
	{
		CR_Motor_A_Step();
		Mdelay826US();
	}	
	CR_Motor_A_Step();		
	CR_Deleration_A();
	Motor_Off(CR_MOTOR);
	restore_flags(flags);
}

//*******************************************
//*******************************************
static int mu110_open(struct inode *inode, struct file *file) 
{
		u_int32_t tmod;
		if(mu110_device_open) return -EBUSY;	
			  
  	MOD_INC_USE_COUNT;
		//PrinterInit();
  	/* And my own counter too */
  	mu110_device_open++;
  	
  	//printk("%s :mu110 open\n",__file__);
		outl(0xf1555555,S3C44B0X_PCONC);
		//rPCONC = 0xf1555555;	// rxd1 as input; txd1 as output
								// pc12 is txd1; pc13 is rxd1
		outl(0xF9FF,S3C44B0X_PDATC);						
		//rPDATC = 0xF9FF;
		tmod = inl(S3C44B0X_PCONE);
		tmod &= ~(0x03<<6);
		tmod |= 0x01<<6;
		tmod &= ~(0x03<<16);
		tmod |= 0x01<<16;
				
		outl(tmod,S3C44B0X_PCONE);
		
		outl((inl(S3C44B0X_PDATE) & 0x0f7),S3C44B0X_PDATE);
		
		tmod = inl(S3C44B0X_PCONG);
		tmod &= ~(0x03<<12);
		tmod |= 0x01<<12;
				
		outl(tmod,S3C44B0X_PCONG);
		
		outl((inl(S3C44B0X_PDATG) | 0x40),S3C44B0X_PDATG);
		
		// zhp add 20060608 for GPF6
		outl(0X8040A,S3C44B0X_PCONF);
		outl(0X14F,S3C44B0X_PDATF);
		
		outl((inl(S3C44B0X_PDATE) | 0x08),S3C44B0X_PDATE);
		
		
  	return 0;
}
//*******************************************
//*******************************************
static ssize_t mu110_read (struct file *file,
                        char *buff,       /* the buffer to fill with data */
			size_t len,       /* the length of the buffer.    */
			loff_t *offset) 
{ /* Our offset in the file       */
	  int retval = 0;
		printer_ststus.blackmark = BlackMarkCheck();
		printer_ststus.temperature = HeadTempCheck();
		printer_ststus.paper = PapeCheck();
		printer_ststus.status = state;
		retval = sizeof(printer_ststus);
		if ( copy_to_user (buff, &printer_ststus, sizeof(printer_ststus))) 
			retval = -EFAULT;
		
		return retval;
}
//*******************************************
//*******************************************
static ssize_t mu110_write (struct file *file,
                        char *buff,       /* the buffer to fill with data */
			size_t len,       /* the length of the buffer.    */
			loff_t *offset)   /* Our offset in the file       */
{ 
		int Tlen ;
		memset(print_img,0,50);
		if(len <= 50)
		{
				Tlen = len;
		}
		else
		{
				Tlen = 50;
		}
		if( copy_from_user( print_img, buff, Tlen ) )
				return -1;
		TurnLeft();
		//OutPape1Line();
		PF_Line_spack(ram_spack);
		PrintLine(print_img);
	  return 0;
}
//*******************************************
//*******************************************
static int mu110_ioctl(struct inode *inode, struct file *file,
		    unsigned int cmd,     /* the command to the ioctl */
		    unsigned long arg) /* the parameter to it      */
{  
	int i ;
	unsigned int time_count = 0;
	int flag_test = 0;
	char line = 0;
	if(_IOC_TYPE(cmd) != MU110_IOC_MAGIC)
	{
			return -ENOTTY;
	}
	if(_IOC_NR(cmd) >= MU110_MAXNR)
	{
			return -ENOTTY;
	}
	switch(cmd)
	{
			case MU110_FF:
				line = 200;
				SetWorkCurrent(PF_MOTOR,NORMAL_CURRENT);
				for (i = 0; i< 14; i++)
				{
					PF_Motor_B_Step();
					MdelayTime(PF_Acceleration[i]);
				}				
				//Constant Speed
				for (i = 0; i< 14; i++)
				{
					PF_Motor_B_Step();
					MdelayTime(PF_ConstSpeed);
				}
				while(line--)
			  {
					PF_Motor_B_Step();
					MdelayTime(PF_Lash);
			  }
			  Motor_Off(PF_MOTOR);
			break;			
			case MU110_SF:
				
			break;			
			case MU110_LF:
				
			break;		
			case MU110_LL:
				
			break;			
			case MU110_ESCJ:  //Feed the paper arg*0.176mm
				//printk("Feed the paper arg*0.176\n");
				for(i = 0; i<arg;i++)
				    PF_OUT_HalfDot_B();
			break;			
			case MU110_ESCK:  //Reverse feed paper arg*0.176mm
				//printk("Reverse Feed the paper arg*0.176\n");
				for(i = 0; i<arg;i++)
				    PF_IN_HalfDot_A();
			break;			
			case MU110_ESCd:  //feed paper Line
				//printk("feed paper Line\n");
				InPapeTest();
			break;			
			case MU110_ESCe:
				//printk("Reverse feed paper Line\n");
				OutPape1Line(); //Reverse feed paper  lines
			break;
			case MU110_MTR:   //move to right
				//printk("move to right\n");
				TurnRight();
			break;			
			case MU110_MTL:
				//printk("move to left\n");
				TurnLeft();    //move to left
			break;			
			case MU110_ESC2: //Select default line spacing (24*0.176mm)
				ram_spack = 24;
			break;			
			case MU110_ESC3: //Set line spacing of arg*0.176mm
				//if(arg < 14)ram_spack = 14;
				//else ram_spack = (u8)arg;
				ram_spack = (u8)arg;				
			break;			
			case MU110_ESCat: //Initialize printer
				if(PrinterInit() < 0)return -1;
			break;			
			case MU110_ESCGSA:
				
			break;			
			case MU110_ESCSP: //Set charactor right spacing of arg*0.1512mm,
				if(arg <= 32) Right_limit = arg;
				else Right_limit = 0;
			break;			
			case MU110_RWMODE:
				
			break;			
			case MU110_ESCASCII: //release printer, no arg
				
			break;			
			case MU110_RELEASE:
				MoveToHome();
				Motor_Off(ALL_MOTOR);
			break;			
			case MU110_1:
				/*
				switch (arg)
				{
					case 0:
						printk("delay 0us\n");
						CPLD_Flash_CMD_Addr  =  0x04;
					break;
					case 1:
						printk("delay 0us\n");
						CPLD_Flash_CMD_Addr =   0;
					break;
					case 2:
						 CPLD_Flash_CMD_Addr  |=  (0x02|0x04);
					break;
					case 3:
						 CPLD_Flash_CMD_Addr  &= (~0x02&~0x04);
					break;
					case 4:
						 CPLD_Flash_CMD_Addr  &= ~0x01;
					break;
					case 5:
					  	CPLD_Flash_CMD_Addr  |=  0x01; 
					break;					
				}
				*/
				switch (arg)
				{                      		
           case 3:
           		printk("delay 5us\n");
           		time_count = 0x400000;
           	 while(1)
				     {
							 time_count--;
							 if(time_count<=0)break;
							 if(flag_test==0)
							 {
							 		flag_test = 1;
							 		outl(inl(S3C44B0X_PDATC) & (~(1<<12)),S3C44B0X_PDATC);
							 }
							 else
							 {
							 		flag_test = 0;
							 		outl(inl(S3C44B0X_PDATC) | (1<<12),S3C44B0X_PDATC);
							 }
							 Mdelay5US();	
				     }
				     printk("test end\n");
           break;	
           case 4:
           		printk("delay 10us\n");
           		time_count = 0x200000;
           	 while(1)
				     {
							 time_count--;
							 if(time_count<=0)break;
							 if(flag_test==0)
							 {
							 		flag_test=1;
							 		outl(inl(S3C44B0X_PDATC) & (~(1<<12)),S3C44B0X_PDATC);
							 }
							 else
							 {
							 		flag_test=0;
							 		outl(inl(S3C44B0X_PDATC) | (1<<12),S3C44B0X_PDATC);
							 }
							 Mdelay10US();	
				     }
				     printk("test end\n");
           break;
           break;	
           case 6:
           		printk("delay 20us\n");
           		time_count = 0x100000;
           	 while(1)
				     {
							 time_count--;
							 if(time_count<=0)break;
							 if(flag_test==0)
							 {
							 		flag_test=1;
							 		outl(inl(S3C44B0X_PDATC) & (~(1<<12)),S3C44B0X_PDATC);
							 }
							 else
							 {
							 		flag_test=0;
							 		outl(inl(S3C44B0X_PDATC) | (1<<12),S3C44B0X_PDATC);
							 }
							 Mdelay20US();	
				     }
				     printk("test end\n");
           break;
           case 7:
           		printk("delay 50us\n");
           		time_count = 0x40000;
           	 while(1)
				     {
							 time_count--;
							 if(time_count<=0)break;
							 if(flag_test==0)
							 {
							 		flag_test=1;
							 		outl(inl(S3C44B0X_PDATC) & (~(1<<12)),S3C44B0X_PDATC);
							 }
							 else
							 {
							 		flag_test=0;
							 		outl(inl(S3C44B0X_PDATC) | (1<<12),S3C44B0X_PDATC);
							 }
							 Mdelay50US();	
				     }
				     printk("test end\n");
           break;	
           case 8:
           		printk("delay 100us\n");
           		time_count = 0x20000;
           	 while(1)
				     {
							 time_count--;
							 if(time_count<=0)break;
							 if(flag_test==0)
							 {
							 		flag_test=1;
							 		outl(inl(S3C44B0X_PDATC) & (~(1<<12)),S3C44B0X_PDATC);
							 }
							 else
							 {
							 		flag_test=0;
							 		outl(inl(S3C44B0X_PDATC) | (1<<12),S3C44B0X_PDATC);
							 }
							 Mdelay100US();	
				     }
				     printk("test end\n");
           break;
           case 10:
           	printk("delay 1mus\n");
           	time_count = 0x2000;
           	 while(1)
				     {
							 time_count--;
							 if(time_count<=0)break;
							 if(flag_test==0)
							 {
							 		flag_test=1;
							 		outl(inl(S3C44B0X_PDATC) & (~(1<<12)),S3C44B0X_PDATC);
							 }
							 else
							 {
							 		flag_test=0;
							 		outl(inl(S3C44B0X_PDATC) | (1<<12),S3C44B0X_PDATC);
							 }
							 Mdelay1MS(1);	
				     }
				     printk("test end\n");
           break;
           case 11:
           	 printk("delay 413us\n");
           	 time_count = 0x4200;
           	 while(1)
				     {
							 time_count--;
							 if(time_count<=0)break;
							 if(flag_test==0)
							 {
							 		flag_test=1;
							 		outl(inl(S3C44B0X_PDATC) & (~(1<<12)),S3C44B0X_PDATC);
							 }
							 else
							 {
							 		flag_test=0;
							 		outl(inl(S3C44B0X_PDATC) | (1<<12),S3C44B0X_PDATC);
							 }
							 Mdelay413US();	
				     }
				     printk("test end\n");
           break;	
           case 12:
           	 printk("delay 826us\n");
           	 time_count = 0x7000;
           	 while(1)
				     {
							 time_count--;
							 if(time_count<=0)break;
							 if(flag_test==0)
							 {
							 		flag_test=1;
							 		outl(inl(S3C44B0X_PDATC) & (~(1<<12)),S3C44B0X_PDATC);
							 }
							 else
							 {
							 		flag_test=0;
							 		outl(inl(S3C44B0X_PDATC) | (1<<12),S3C44B0X_PDATC);
							 }
							 Mdelay826US();	
				     }
				     printk("test end\n");
           break;					
				} 
				
			break;
		
			default :
			break;
	}
	return 0;
}
//*******************************************
//*******************************************
static int mu110_release(struct inode *inode, struct file *file)
{

  	MOD_DEC_USE_COUNT;

  	/* And my own counter too */
  	mu110_device_open--;
	
  	return 0;

}
//*******************************************
//*******************************************
static struct file_operations mu110_fops={
		owner:    THIS_MODULE,
		write:		mu110_write,
		ioctl:    mu110_ioctl,
		open :    mu110_open,	
		read :    mu110_read,		
		release:  mu110_release,	
};
//*********************************************
//*********************************************
static int __init mu110_init(void) {
  	int err;
  	mu110_port_init();
  	ram_spack = 16;		
		//PrintBuf = (u8 *)kmalloc(PrintBuf_len,GFP_KERNEL);
		DestFont16 = (u8 *)kmalloc(DestFont16_len,GFP_KERNEL);
		print_img = (u8 *)kmalloc(50,GFP_KERNEL);
		g_auc_HZK16_Dot = (U8 *)mHZK16_ADDR;
  	/* Register the misc device driver */
  	err = register_chrdev(MU110_MAJOR,DEVICE_NAME,&mu110_fops);
  	if(err<0)
    		printk("%s: Error registering the device\n", __file__);
  	else
    		printk("%s: Device register with name: %s and number: %d %d\n",
			   __file__, DEVICE_NAME, MU110_MAJOR, MU110_MINOR);
    #ifdef CONFIG_DEVFS_FS
	  devfs_mu110raw=devfs_register(NULL,"mu110II",
	               DEVFS_FL_DEFAULT,MU110_MAJOR,MU110_MINOR,
	               S_IFCHR|S_IRUSR|S_IWUSR,&mu110_fops,NULL);
  	#endif
		printk("%s initialized\n",DEVICE_NAME);
		if(HomeCheck() == 0)CR_Step = 241;
		else CR_Step = 22;
		return 0;			
}

/*
 * Cleanup - undid whatever init did.
 */
static void mu110_cleanup(void) 
{
	/* Unregister device driver */
  //PrinterInit();
#ifdef CONFIG_DEVFS_FS
	devfs_unregister(devfs_mu110raw);
	devfs_unregister(devfs_mu110_dir);
#endif
  unregister_chrdev(MU110_MAJOR,DEVICE_NAME);
  //kfree(PrintBuf);
	kfree(DestFont16);
}  

module_init(mu110_init);
module_exit(mu110_cleanup);
MODULE_LICENSE("GPL");