sed_drv.c

Linux kernel driver for Epson s1d13700 LCD controller.

		printk(KERN_DEBUG "%s HScroll() \n",DEVICE_NAME);
#endif
		Overlay();
#ifdef DEBUG_MSG
		printk(KERN_DEBUG "%s Overlay() \n",DEVICE_NAME);
#endif
		LoadFont();
#ifdef DEBUG_MSG
		printk(KERN_DEBUG "%s LoadFont() \n",DEVICE_NAME);
#endif
		CleanLCD();
#ifdef DEBUG_MSG
		printk(KERN_DEBUG "%s CleanLCD \n",DEVICE_NAME);
#endif
		WriteCursorAddress(0);
#ifdef DEBUG_MSG
		printk(KERN_DEBUG "%s WriteCursorAddress \n",DEVICE_NAME);
#endif
		Display(1,CUR_OFF);
#ifdef DEBUG_MSG
		printk(KERN_DEBUG "%s Display on() \n",DEVICE_NAME);
#endif
}
//****************************
//
int device_ioctl (struct inode *inode, struct file *file, unsigned int ioctl_num, unsigned long ioctl_param)
{
	int timeout = 1000;
   int x1,x2,y1,y2;
   int ix,jx;
   int rt;
   BYTE c;
   BYTE tmp[40];
   static struct M7IoControlStruct mIO;
   static struct GraphControlStruct GCtl;
   int ret = 0;
   static struct SavedRegionStruct SRgn;

#ifdef DEBUG_MSG
   printk(KERN_DEBUG "%s ioctl invoked = %d \n",DEVICE_NAME,ioctl_num);
#endif
   switch(ioctl_num)
	{
	//initialization
//**************************************************************
	case IOCTL_INIT_LCD:
		InitLCD();
    break;

//**************************************************************
	   case IOCTL_TEST_OUT:
		CleanLCD();
#ifdef DEBUG_MSG
	    printk(KERN_DEBUG "%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(KERN_DEBUG "%s clean lcd invoked \n",DEVICE_NAME);
#endif
		   CleanLCD();
		  // udelay(5);
	   break;

//**************************************************************
	   case IOCTL_SHOW_LOGO:
		#ifdef DEBUG_MSG
	    	printk(KERN_DEBUG "%s Show Logo invoked \n",DEVICE_NAME);
		#endif
		CleanLCD();
		ShowLogo();
	   break;

		//**************************************************************
		//--------------------
		case IOCTL_GET_REGION:
#ifdef DEBUG_MSG
	    printk(KERN_DEBUG "%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);
				rmb();
				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);
				rmb();
				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(KERN_DEBUG "------------%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);
					wmb();
				}
				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);
					wmb();
				}
			//	udelay(5);
			break;

//**************************************************************
			case IOCTL_BUF_WRITE:
#ifdef DEBUG_MSG
	    printk(KERN_DEBUG "%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]);
				wmb();
				//udelay(5);
			break;
//**************************************************************
			case IOCTL_BUF_READ:
#ifdef DEBUG_MSG
	    printk(KERN_DEBUG "%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(KERN_DEBUG "%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(KERN_DEBUG "%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(KERN_DEBUG "%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:
#ifdef DEBUG_MSG
				printk(KERN_DEBUG "pixel!");
#endif
				//printk(" p ");
				//lock_kernel();
				pixel(GCtl.param[0],GCtl.param[1],(BYTE)GCtl.param[2]);
				//while(timeout--);
				//unlock_kernel();
	//			udelay(5);
			break;
//**************************************************************
			case GRAPH_LINE:
#ifdef DEBUG_MSG
				printk(KERN_DEBUG "blyaaaaaaaaaaaaaaaaaaAAAaaaaa!");
				printk(KERN_DEBUG " line: %s: p0 = %ld; p1 = %ld; p2 = %ld; p3 = %ld; p4 = %d; \n",DEVICE_NAME, GCtl.param[0],GCtl.param[1],GCtl.param[2],GCtl.param[3],(BYTE)GCtl.param[4]);
#endif
				x1 = GCtl.param[0];
				x2 = GCtl.param[2];
				y1 = GCtl.param[1];
				y2 = GCtl.param[3];
				c = (BYTE)GCtl.param[4];
				line(x1,y1,x2,y2,c);

				//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:
#ifdef DEBUG_MSG
				printk(KERN_DEBUG " %s: RECT \np0 = %ld; p1 = %ld; p2 = %ld; p3 = %ld; p4 = %d; \n",DEVICE_NAME, GCtl.param[0],GCtl.param[1],GCtl.param[2],GCtl.param[3],(BYTE)GCtl.param[4]);
#endif
  		           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]);
  		        //   udelay(5);
			break;
//**************************************************************
			case GRAPH_FILL_RECT_GR:
#ifdef DEBUG_MSG
				printk(KERN_DEBUG " %s: FILL_RECT \np0 = %ld; p1 = %ld; p2 = %ld; p3 = %ld; p4 = %d; \n",DEVICE_NAME, GCtl.param[0],GCtl.param[1],GCtl.param[2],GCtl.param[3],(BYTE)GCtl.param[4]);
#endif
  		        //lock_kernel();
				fill_rect_gr(GCtl.param[0],GCtl.param[1],GCtl.param[2],GCtl.param[3],(BYTE)GCtl.param[4]);
				//unlock_kernel();
  		       //    udelay(5);
			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(KERN_DEBUG "%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("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("Remaping region: ");
	GRAPH_MEM_REGION = (unsigned char*) ioremap_nocache(BASE_ADDR, ADDR_LEN);
	if (GRAPH_MEM_REGION == NULL) {
			printk("cannot remap memory region. exit.");
			release_mem_region(BASE_ADDR,ADDR_LEN);
			return -1;
	}
	printk("ok\n");
//------------------------------------------------------------------------
	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);
	    iounmap(GRAPH_MEM_REGION);
		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 4 */
	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_SETUP(4),
				AT91_SMC_NWESETUP_(0xC)|
				AT91_SMC_NCS_WRSETUP_(0x8)|
				AT91_SMC_NRDSETUP_(0xC)|
				AT91_SMC_NCS_RDSETUP_(0x8)
				);

		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_(0x28)|
					AT91_SMC_NRDCYCLE_(0x28)
				);*/

	int a = at91_sys_read(AT91_SMC_MODE(4));
	printk("a = 0x%04X \n",a);
	at91_sys_write(AT91_SMC_MODE(4), AT91_SMC_DBW_8);
	a = at91_sys_read(AT91_SMC_MODE(4));
	printk("a = 0x%04X \n",a);
	pRegAddr = (BYTE *)GRAPH_MEM_REGION + 0x8000;
	pRegAddr[aS1DRegs[8].Index] = 0; 			//power safe off
	InitLCD();
	wmb();
	memset_io(GRAPH_MEM_REGION,0,0x7FFF);		// full clearance for graphical memory
	ShowLogo();
	wmb();
	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 bugagaga\n", DEVICE_NAME);
}
//--------------------------------------------------------
module_init(hello_init);
module_exit(hello_exit);