sed_drv.c~

Linux kernel driver for Epson s1d13700 LCD controller.

    }
    if (x > d)
    {
      x = x + 1;
      d = d + 2*x + 1;
    }
  }
  pixel(xc+x, yc+y, c);
  pixel(xc+x, yc-y, c);
  pixel(xc-x, yc+y, c);
  pixel(xc-x, yc-y, c);
}

//-----------------------------------------------------------
//****************************
//
void hor_line(int x1,int x2, int y,BYTE c)// ПХЯСЕЛ ЦНПХГНМРЮКЭМСЧ КХМХЧ ЯКЕБЮ МЮОПЮБН => x2>x1
{
BYTE ct,bt;
//	for(i=x1;i<=x2;i++)pixel(i,y,c);
int addr;

  addr = SAD2 + (WIDTH/8)*y + (x1/8);
  bt = GRAPH_MEM_REGION[addr];
  rmb();
  if ((c&1)==1)
  {
  	ct=0xff>>(x1%8); 
 	bt|=ct;
	GRAPH_MEM_REGION[addr]=bt;
	wmb();
	memset_io(GRAPH_MEM_REGION+addr+1,0xFF,(x2/8)-(x1/8)-1);
	bt = GRAPH_MEM_REGION[addr+(x2/8)-(x1/8)];
	rmb();
	ct=0xff<<(7-(x2%8));
	bt|=ct;
	GRAPH_MEM_REGION[addr+((x2/8)-(x1/8))]=bt;
	wmb();
  }
  else 
  {
  	ct=0xff<<(7-(x1%8));
  	bt&=ct;
	GRAPH_MEM_REGION[addr]=bt;
	wmb();	
	memset_io(GRAPH_MEM_REGION+addr+1,0,(x2/8)-(x1/8)-1);
	bt = GRAPH_MEM_REGION[addr+(x2/8)-(x1/8)];
	rmb();
	ct=0xff>>(x2%8);
	bt&=ct;
	GRAPH_MEM_REGION[addr+((x2/8)-(x1/8))]=bt;
	wmb();
  }
  
}

//****************************
//
void vert_line(int x,int y1,int y2,BYTE c)//ПХЯСЕР БЕПРХЙХКЭМСЧ КХМХЧ ЯБЕПУС БМХГ => y2>y1
{
int i,addr;
BYTE ct,bt;
	for(i=0;i<y2-y1;i++)
	{
		addr=SAD2+(WIDTH/8)*(y1+i)+x/8;
		bt = GRAPH_MEM_REGION[addr];
		rmb();
		ct=c&1;
		ct=ct<<(7-(x % 8));
  		bt = (bt & (~ct)) | ct;
		GRAPH_MEM_REGION[addr] = bt;
		wmb();
	 }
}

//****************************
//
void vert_line_xor(int x,int y1,int y2)//ПХЯСЕР БЕПРХЙХКЭМСЧ КХМХЧ ЯБЕПУС БМХГ => y2>y1
{
int i,addr;
BYTE ct,bt;
	for(i=0;i<y2-y1;i++)
	{
		addr=SAD2+(WIDTH/8)*(y1+i)+x/8;
		bt = GRAPH_MEM_REGION[addr];
		rmb();
		ct=i&1;
		ct=ct<<(7-(x % 8));
  		bt = bt ^ ct;
		GRAPH_MEM_REGION[addr] = bt;
		wmb();
	 }
}
//********************************
// 
void rect(int x1, int y1, int x2, int y2, BYTE c)
{
  hor_line(x1, x2, y1, c);
  hor_line(x1, x2, y2, c);
  vert_line(x1, y1, y2, c);
  vert_line(x2, y1, y2, c);
}
//********************************
// 
void fill_rect(int x1, int y1, int x2, int y2, BYTE c)
{
int i;
BYTE ct;
	if ((c&1)==1)ct=171;
	else ct=0x20;
	
	for(i=0;i<(y2-y1);i++)
	{
		memset_io(GRAPH_MEM_REGION+SAD1+(y1*COL+x1)+i*COL,ct,x2-x1);
	}
}
//********************************
// 
void fill_rect_gr(int x1, int y1, int x2, int y2, BYTE c)
{
int i;
BYTE ct;
	if ((c&1)==1)ct=0xff;
	else ct=0x0;
	
	for(i=0;i<(y2-y1);i++)
	{
		memset_io(GRAPH_MEM_REGION+SAD2+(WIDTH/8)*(y1+i)+x1/8,ct,(x2-x1)/8);
	}
}

//********************************
// 
void SetCursorP(int x, int y)
{
  WriteCursorAddress(y*COL+x);
}

void GetCursorP(int *x, int *y)
{
  long int addr;
  addr = ReadCursorAddress();
  *x = addr % COL;
  *y = addr / COL;
}

//****************************
//
void OutCharXY(char ch, int x, int y)
{
	GRAPH_MEM_REGION[SAD1+y*COL+x] = ch;
	wmb();
}
//********************************
// 
void OutChar(char ch)
{
	  DWORD addr;
	  addr = ReadCursorAddress();
	  GRAPH_MEM_REGION[addr] = ch;
	  wmb();
}
//********************************
// 
void OutString(char* text)
{
	int i=0;
	while(text[i]!=0)
	{
		OutChar(text[i]);
		i++;
	}
}
//********************************
// 
void OutStringXY(char* text,int x,int y)
{
	SetCursorP(x,y);
	OutString(text);
}

//****************************
//
int device_ioctl (struct inode *inode, struct file *file, unsigned int ioctl_num, unsigned long ioctl_param)
{  
	
   int x1,x2,y1,y2;
   int ix,jx;
   int rt;
   BYTE tmp[40];
   static struct M7IoControlStruct mIO;
   static struct GraphControlStruct GCtl;
   int ret = 0;
   static struct SavedRegionStruct SRgn;
#ifdef DEBUG_MSG
   printk("%s ioctl invoked \n",DEVICE_NAME);
#endif   
   switch(ioctl_num)
	{	
	//initialization   
//**************************************************************
	case IOCTL_INIT_LCD:
#ifdef DEBUG_MSG
		printk("%s init_lcd invoked \n",DEVICE_NAME);
#endif		
		Display(0,CUR_OFF);
#ifdef DEBUG_MSG
		printk("%s Display off() \n",DEVICE_NAME);
#endif	
		SystemSet();
#ifdef DEBUG_MSG		
		printk("%s SystemSet() \n",DEVICE_NAME);
#endif	
		Scroll(SAD1, SAD2, SAD3, SAD4);
#ifdef DEBUG_MSG		
		printk("%s Scroll() \n",DEVICE_NAME);
#endif	
		CursorForm(6,7,0);
#ifdef DEBUG_MSG		
		printk("%s CursorForm \n",DEVICE_NAME);
#endif	
		CursorDir(CUR_RIGHT);
#ifdef DEBUG_MSG		
		printk("%s CursorDir \n",DEVICE_NAME);
#endif	
		HScroll();
#ifdef DEBUG_MSG		
		printk("%s HScroll() \n",DEVICE_NAME);
#endif	
		Overlay();
#ifdef DEBUG_MSG		
		printk("%s Overlay() \n",DEVICE_NAME);
#endif	
		LoadFont();
#ifdef DEBUG_MSG		
		printk("%s LoadFont() \n",DEVICE_NAME);
#endif	
		CleanLCD();
#ifdef DEBUG_MSG		
		printk("%s CleanLCD \n",DEVICE_NAME);
#endif	
		WriteCursorAddress(0);
#ifdef DEBUG_MSG		
		printk("%s WriteCursorAddress \n",DEVICE_NAME);
#endif	
		Display(1,CUR_OFF);
#ifdef DEBUG_MSG		
		printk("%s Display on() \n",DEVICE_NAME);
#endif			
	   break;

//**************************************************************
	   case IOCTL_TEST_OUT:
		CleanLCD();
#ifdef DEBUG_MSG		
	    printk("%s TEST_OUT invoked \n",DEVICE_NAME);
#endif	 
		BYTE bt;
		for( bt = 0; bt < 255 ; bt++ )
		{
		  GRAPH_MEM_REGION[bt] = bt;
		  wmb();
		}
	   break;
//**************************************************************	   
	   case IOCTL_CLEAN_LCD:
#ifdef DEBUG_MSG		
	    printk("%s clean lcd invoked \n",DEVICE_NAME);
#endif	 		   
		   CleanLCD();
		   udelay(5);
	   break;

//**************************************************************
	   case IOCTL_SHOW_LOGO:
		#ifdef DEBUG_MSG			   
	    	printk("%s Show Logo invoked \n",DEVICE_NAME);
		#endif	   
		CleanLCD(); 	
		ShowLogo();
	   break;
	   
		//**************************************************************	
		//--------------------
		case IOCTL_GET_REGION:
#ifdef DEBUG_MSG		
	    printk("%s GET REGION invoked \n",DEVICE_NAME);
#endif	 
			rt = copy_from_user((BYTE*) &mIO, (BYTE*) ioctl_param, sizeof(mIO));
			if (rt!=0) {ret = SED_ERR_FROM_USER; break;}
			rt = copy_from_user(&GCtl,(void *) mIO.lpInBuffer, mIO.nInBufferSize);
			if (rt!=0) {ret = SED_ERR_FROM_USER; break;}
			x1 = GCtl.param[0];
			y1 = GCtl.param[1];
			x2 = GCtl.param[2];
			y2 = GCtl.param[3];
			for(ix=0;ix<(y2-y1);ix++)
			{
				memcpy_fromio(tmp,GRAPH_MEM_REGION+SAD1+(y1+ix)*COL+x1,x2-x1);
				for(jx=0;jx<(x2-x1);jx++)SRgn.text[ix][jx]=tmp[jx];
			}	
			for(ix=0;ix<((y2-y1)*8);ix++)
			{
				memcpy_fromio(tmp,GRAPH_MEM_REGION+SAD2+(WIDTH/8)*(y1*8+ix)+x1,x2-x1);
				for(jx=0;jx<(x2-x1);jx++)SRgn.graph[ix][jx]=tmp[jx];
			}	
			rt = copy_to_user((void*) mIO.lpOutBuffer, (void*) &SRgn, mIO.nOutBufferSize);
			if (rt!=0) {ret = SED_ERR_TO_USER; break; }
			udelay(5);
#ifdef DEBUG_MSG				
			printk("------------%s GRAPH_REGION SIZE = %ld \n",DEVICE_NAME,mIO.nOutBufferSize);
#endif
			break;
//************************************************************************************	
//--------------------
			case IOCTL_PUT_REGION:
				rt = copy_from_user((BYTE*) &mIO, (BYTE*) ioctl_param, sizeof(mIO));
				if (rt!=0) {ret = SED_ERR_FROM_USER; break; }
				rt = copy_from_user(&GCtl,(void *) mIO.lpInBuffer, mIO.nInBufferSize);
				if (rt!=0) {ret = SED_ERR_FROM_USER; break; }
				x1 = GCtl.param[0];
				y1 = GCtl.param[1];
				x2 = GCtl.param[2];
				y2 = GCtl.param[3];
				memcpy(&SRgn,(void*)GCtl.param[4],sizeof(SRgn));
										
				for(ix=0;ix<(y2-y1);ix++)
				{
					memcpy_toio(GRAPH_MEM_REGION+SAD1+(y1+ix)*COL+x1,SRgn.text[ix],x2-x1);
				}
				for(ix=0;ix<((y2-y1)*8);ix++)
				{
					memcpy_toio(GRAPH_MEM_REGION+SAD2+(WIDTH/8)*(y1*8+ix)+x1,SRgn.graph[ix],x2-x1);
				}
				udelay(5);
			break;
								
//**************************************************************
			case IOCTL_BUF_WRITE:
#ifdef DEBUG_MSG		
	    printk("%s BUF WRITE invoked \n",DEVICE_NAME);
#endif	 	
				rt = copy_from_user((BYTE*) &mIO, (BYTE*) ioctl_param, sizeof(mIO));
				if (rt!=0) {ret = SED_ERR_FROM_USER; break; }
				rt = copy_from_user(&GCtl,(void *) mIO.lpInBuffer, mIO.nInBufferSize);
				if (rt!=0) {ret = SED_ERR_FROM_USER; break; }
				memcpy_toio(GRAPH_MEM_REGION+GCtl.param[0],(void*)GCtl.param[2],GCtl.param[1]);
				udelay(5);
			break;
//**************************************************************			
			case IOCTL_BUF_READ:
#ifdef DEBUG_MSG		
	    printk("%s BUF READ invoked \n",DEVICE_NAME);
#endif					
				rt = copy_from_user((BYTE*) &mIO, (BYTE*) ioctl_param, sizeof(mIO));
				if (rt!=0) {ret = SED_ERR_FROM_USER; break; }
				rt = copy_from_user(&GCtl,(void *) mIO.lpInBuffer, mIO.nInBufferSize);
				if (rt!=0) {ret = SED_ERR_FROM_USER; break; }
				rt = copy_to_user((void*) mIO.lpOutBuffer, GRAPH_MEM_REGION+GCtl.param[0], GCtl.param[1]);
				if (rt!=0) {ret = SED_ERR_TO_USER; break; }
				udelay(5);
			break;
//**************************************************************
		case IOCTL_COPY_LCD:
			#ifdef DEBUG_MSG		
				printk("%s BUF READ invoked \n",DEVICE_NAME);
			#endif
		memcpy(GRAPH_MEM_REGION+SAD1,GRAPH_MEM_REGION+40*COL,COL*ROW);	
		break;
		case IOCTL_GRAPH_CTL:
#ifdef DEBUG_MSG		
	    printk("%s GRAPH CTL invoked \n",DEVICE_NAME);
#endif				
			rt = copy_from_user((BYTE*) &mIO, (BYTE*) ioctl_param, sizeof(mIO));
			if (rt!=0) {ret = SED_ERR_FROM_USER; break; }
			rt = copy_from_user(&GCtl,(void *) mIO.lpInBuffer, mIO.nInBufferSize);
			if (rt!=0) {ret = SED_ERR_FROM_USER; break; }
#ifdef DEBUG_MSG		
	    printk("%s GRAPH CTL TYPE = %d\n",DEVICE_NAME,GCtl.type);
#endif				
		switch (GCtl.type)
		{
			case GRAPH_DISPLAY:
				Display(GCtl.param[0],(BYTE)GCtl.param[1]);
			break;
		
//************************************************************************************	
			case GRAPH_PIXEL:
				pixel(GCtl.param[0],GCtl.param[1],(BYTE)GCtl.param[2]);
				udelay(5);
			break;	
//**************************************************************
			case GRAPH_LINE:
  		           line(GCtl.param[0],GCtl.param[1],GCtl.param[2],
					GCtl.param[3],(BYTE)GCtl.param[4]);
			   udelay(5);
			break;		
//**************************************************************
			case GRAPH_DOT_LINE:
  		           dotline(GCtl.param[0],GCtl.param[1],GCtl.param[2],
					GCtl.param[3],(BYTE)GCtl.param[4]);
			   udelay(5);
			break;		
//**************************************************************
			case GRAPH_CIRCLE:
  		           circle(GCtl.param[0],GCtl.param[1],GCtl.param[2],(BYTE)GCtl.param[3]);
			break;		
//**************************************************************
			case GRAPH_HOR_LINE:
  		           hor_line(GCtl.param[0],GCtl.param[1],GCtl.param[2],(BYTE)GCtl.param[3]);
			break;		
//**************************************************************
			case GRAPH_XOR_LINE:
  		           vert_line_xor(GCtl.param[0],GCtl.param[1],GCtl.param[2]);
			   udelay(5);
			break;	
//**************************************************************
			case GRAPH_VERT_LINE:
  		           vert_line(GCtl.param[0],GCtl.param[1],GCtl.param[2],(BYTE)GCtl.param[3]);
			break;
//**************************************************************
			case GRAPH_RECT:
  		           rect(GCtl.param[0],GCtl.param[1],GCtl.param[2],
					GCtl.param[3],(BYTE)GCtl.param[4]);
			break;
//**************************************************************
			case GRAPH_FILL_RECT:
  		           fill_rect(GCtl.param[0],GCtl.param[1],GCtl.param[2],
					GCtl.param[3],(BYTE)GCtl.param[4]);
			break;
//**************************************************************
			case GRAPH_FILL_RECT_GR:
  		           fill_rect_gr(GCtl.param[0],GCtl.param[1],GCtl.param[2],
					GCtl.param[3],(BYTE)GCtl.param[4]);
			break;
//**************************************************************
			case GRAPH_OUT_CHARXY:
				OutCharXY((BYTE)GCtl.param[0],GCtl.param[1],GCtl.param[2]);
			break;
//**************************************************************
			case GRAPH_OUT_CHAR:
				OutChar((BYTE)GCtl.param[0]);
			break;
//**************************************************************			
			case GRAPH_OUT_STRINGXY:
				OutStringXY((BYTE*)GCtl.param[0],GCtl.param[1],GCtl.param[2]);
			break;
//**************************************************************			
			case GRAPH_OUT_STRING:
				OutString((BYTE*)GCtl.param[0]);
			break;
//**************************************************************			
			case GRAPH_SET_CUR:
				 SetCursorP(GCtl.param[0],GCtl.param[1]);
			break;
//**************************************************************		
			case GRAPH_SET_BYTE:
				GRAPH_MEM_REGION[GCtl.param[0]]=(BYTE)GCtl.param[1];
				wmb();
			break;
//************************************************************************************
			
		}
	   break;
//**************************************************************	   
	   default: 
#ifdef DEBUG_MSG
		   printk("%s Unsupported function \n",DEVICE_NAME); 
#endif
		   ret = SED_ERR_UNSUPPORTED;
		   break;
		   
	}
   return ret;
}

static int hello_init(void) 
{
	int ret;
	//long int i;
	printk("Starting %s IO driver...\n", DEVICE_NAME);
	printk("Trying to register %s device: ", DEVICE_NAME);
	ret = register_chrdev(MAJOR_NUM, DEVICE_NAME, &fops);
	if (ret < 0)
	{
		printk ("Registering the character device failed with %d\n", ret);
	    return -1;
	};
	printk("ok\n");
	printk("Remaping region: ");
	GRAPH_MEM_REGION = (char*) ioremap(BASE_ADDR, ADDR_LEN);
	if (GRAPH_MEM_REGION == NULL) {
			printk("cannot remap memory region. exit.");
			return -1;
	}	
	printk("ok\n");
	printk("Request memory region: ");
	p = (char*) request_mem_region(BASE_ADDR, ADDR_LEN, "M7_SED_drv");
	if (p == NULL) {
		printk("cannot request memory region. exit.");
		return -1;
	}
	printk("ok\n");
	printk("%s Setting up peripherial...\n", DEVICE_NAME);
	at91_set_A_periph(AT91_PIN_PC8, 1);
	/* Initialization of the Static Memory Controller for Chip Select 5 */
	at91_sys_write(AT91_SMC_SETUP(4),
			AT91_SMC_NWESETUP_(0x8)|
			AT91_SMC_NCS_WRSETUP_(0x4)|
			AT91_SMC_NRDSETUP_(0x8)|
			AT91_SMC_NCS_RDSETUP_(0x4)					
			); 
	
	at91_sys_write(AT91_SMC_PULSE(4), AT91_SMC_NWEPULSE_(0x8)|
				AT91_SMC_NCS_WRPULSE_(0x10)|
				AT91_SMC_NRDPULSE_(0x8)|
				AT91_SMC_NCS_RDPULSE_(0x10)
			);
	
	at91_sys_write(AT91_SMC_CYCLE(4),AT91_SMC_NWECYCLE_(0x18)|
				AT91_SMC_NRDCYCLE_(0x18)
			);
	
	at91_sys_write(AT91_SMC_MODE(4), AT91_SMC_DBW_8);
	pRegAddr = (BYTE *)GRAPH_MEM_REGION + 0x8000;	
	pRegAddr[aS1DRegs[8].Index] = 0; 			//power safe off
	wmb();
	memset_io(GRAPH_MEM_REGION,0,0x7FFF);		// full clearance for graphical memory

	
	printk("%s Driver started...\n", DEVICE_NAME);    
    return 0;
} 
static void hello_exit(void) 
{  	pRegAddr[aS1DRegs[8].Index] = 1; //power safe on
	wmb();
	unregister_chrdev(MAJOR_NUM, DEVICE_NAME);
	iounmap(GRAPH_MEM_REGION);
	release_mem_region(BASE_ADDR, ADDR_LEN);
    	printk("%s Driver unloaded\n", DEVICE_NAME); 
}

module_init(hello_init); 
module_exit(hello_exit);