slcdc.c

slcdc液晶屏的驱动

}
void slcdc_config_panel(void)
{
	int i;
#if 1
	//set data format
   	slcdc_config(8);
	slcdc_delay(0xffff);
	slcdc_reset(1);//pull reset signal high

	//set data format
	slcdc_delay(20000);
	slcdc_data_ctl();
	slcdc_delay(1000);
   	slcdc_config(16); 
	
	//sleep out
	slcdc_sleep_out();
	slcdc_delay(20000);
	
	for(i=0;i<8;i++)
	{
		slcdc_volctl();
		slcdc_delay(2000);
	}
	slcdc_delay(0xffff);
	slcdc_delay(0xffff);
	slcdc_delay(0xffff);

	slcdc_display_on();
	slcdc_delay(0xffff);
	//set col address
	slcdc_col_set();
	//set page address
	slcdc_page_set();
	//set area in screen to be used for scrolling
	slcdc_ascset();
	slcdc_delay(20000);
	//set top scroll page within the scroll area
	slcdc_scstart();
	slcdc_delay(0xffff);
#endif
#if 0

	//set data format
   	slcdc_config(8);
	slcdc_delay(0xffff);
	slcdc_reset(1);//pull reset signal high

	//set data format
	slcdc_delay(20000);
	slcdc_data_ctl();
	slcdc_delay(1000);
   	slcdc_config(16); 
	//sleep out
	slcdc_sleep_out();
	slcdc_delay(0xffff);
	//set col address
	slcdc_col_set();
	//set page address
	slcdc_page_set();
	//set area in screen to be used for scrolling
	slcdc_ascset();
	slcdc_delay(20000);
	//set top scroll page within the scroll area
	slcdc_scstart();
	slcdc_delay(0xffff);
	//turn on slcd display
	slcdc_display_on();
	slcdc_delay(0xffff);
	slcdc_delay(0xffff);
	

	for(i=0;i<8;i++)
	{
		slcdc_volctl();
		slcdc_delay(2000);
	}
#endif
}

/**
 *@brief slcdc ioctl routine
 *
 * Function Name: slcdc_ioctl
 * Description:This routine will implement driver-specific functions
 *
 *@param 		inode	:	the pointer to driver-related inode.
 *@param 		filp	:	the pointer to driver-related file structure.
 *@param		cmd	:	the command number.
 *@param		arg:	argument which depends on command.
 *
 *@return	int   return status
 *			@li 0  sucess
 *			@li 1  failure
 *
 * Modification History:
 * 	Dec,2003			Karen first version for MX21 TO2 
 *   
 **/

static int slcdc_ioctl(struct inode * inode, struct file *filp, u_int cmd, u_long arg)
{
	u16* databuffer = NULL;
	switch (cmd)
	{
		case SLCDC_CMD_DISON:
				slcdc_display_on();
				break;
					
		case SLCDC_CMD_DISOFF:
				slcdc_display_off();
				break;
		
		case SLCDC_CMD_DISNOR:
				slcdc_display_normal();
				break;
					
		case SLCDC_CMD_DISINV:
				//put cmd into cmd buffer
				databuffer = slcdc_par.v_screen_start_address;
				*databuffer = SLCDC_CMD_DISINV;
				//send cmd
				slcdc_send_cmd(1);
				slcdc_delay(100);
				break;
					
		case SLCDC_CMD_DATCTL:
				break;
					
		case SLCDC_CMD_RAMWR:
		//Causes the MPU to be a data entry mode,allowing it to serite data in the display memory.
		//Inputting any other cmds other than NOP cancels the data entry mode.
		
			_reg_SLCDC_DBADDR = (u32)g_slcdc_cbuffer_phyaddress;

			//put cmd into cmd buffer
			databuffer = g_slcdc_cbuffer_address;
			//put cmd into cmd buffer
			*databuffer = SLCDC_CMD_RAMWR;
			//send cmd
			slcdc_send_cmd(1);
			slcdc_delay(2000);

			//this is to display one data per time, it is ok.	
			slcdc_delay(0xffff);
			_reg_SLCDC_DBADDR=(u32)slcdc_par.screen_start_address;

			slcdc_delay(0xffff);
			slcdc_send_data(38720);
			slcdc_delay(0xffff);
			
			break;
		
		case SLCDC_CMD_RAMRD:
				break;		
								
		case SLCDC_CMD_PTLIN:
		//This command is used to display a partial screen for power saving.
				break;
						
		case SLCDC_CMD_PTLOUT:
		//This command is used to exit the partila diaplay mode.
				break;
				
		case SLCDC_CMD_GCP64:
		//make 63 pulse position settings of GCP for 64 gray scales.
				//send cmd into cmd buffer
				//send parameter into data buffer
				//send cmd
				//send data
				break;
				
		case SLCDC_CMD_GCP16:
				break;
						
		case SLCDC_CMD_GSSET:		
		    	break;
		    	
		case SLCDC_CMD_ASCSET:	
		//make partial screen scroll settings.
				//send cmd into cmd buffer
				//send parameter into data buffer
				//send cmd
				//delay
				//send data
				//delay
				break;
				    
		 case SLCDC_CMD_SCSTART:
		 //set a scroll starting page in the scrolling area.Be sure to send this cmd after ASCSET .
				//send cmd into cmd buffer
				//send parameter into data buffer
				//send cmd
				//delay
				//send data
				//delay
				break;
		 default:
				break;	
	}
	return 0;
}

/**
 *@brief slcdc close function
 *
 * Function Name: slcdc_release
 *
 *
 * Description: This is the release routine for the driver. And this function \n
 *		will be called while the module being closed. In this function, it will \n
 *		unregister the apm	
 *
 *@param	inode the pointer to the inode descripter
 *@param	filp  the pointer to the file descripter
 *
 *@return	int   return status
 *			@li 0  sucessful
 *			@li other failed
 * Modification History:
 * 	Dec,2003			Karen first version 
 *   
 **/

int slcdc_release(struct inode * inode, struct file * filp)
{
	TRACE("slcdc_release: ----\n");
	//Removed by Bill, it will be called by slcdc_cleanup(). Aug-18-04 
//	apmc_unregister(g_Slcdc_apmc);
	MOD_DEC_USE_COUNT;
	return 0;
}
/**
 *@brief slcdc open function
 *
 * Function Name: slcdc_open
 *
 *
 * Description: This is the open routine for the driver. And this function \n
 *		will be called while the module being opened. In this function, it will \n
 *			@li	configure GPIO for serial/parallel
 *			@li	slcdc reset
 *			@li init slcd registers 
 *			@li init waitqueue
 *			@li get rca, select the card
 *			@li send some command for panel configuration
 *
 *@param	inode the pointer to the inode descripter
 *@param	filp  the pointer to the file descripter
 *
 *@return	int   return status
 *			@li 0  sucessful
 *			@li other failed
 * Modification History:
 * 	Dec,2003,			Karen first version
 *  June,2004,			Shirley update for Parallel mode 
 *   
 **/

int slcdc_open(struct inode * inode, struct file * filp)
{
	TRACE("slcdc_open: ----\n");
    MOD_INC_USE_COUNT;
	//init dev
	#ifdef SLCDC_SERIAL_MODE
       	slcdc_gpio_serial();
	#else
	       slcdc_gpio_paralle();
	#endif

	//Now it is moved to slcdc_init(). --Bill, Aug-18-04
//	g_Slcdc_apmc = apmc_register(APMC_LEVEL_HIGHEST);
	apmc_set_level(g_Slcdc_apmc,APMC_LEVEL_LOWEST);

	slcdc_init_dev();

    slcdc_reset(0);//pull reset low

	//init slcd registers
	slcdc_init_reg();
     
 	//init waitqueue
	init_waitqueue_head(&slcdc_wait);
	
	//send some command for panel configuration
	slcdc_config_panel();
	TRACE("TRANS_CONFIG_REG=%x \n",_reg_SLCDC_LCD_TXCONFIG);

    return 0;
}

int slcdc_pm_handler(struct pm_dev *dev, pm_request_t rqst, void *data)
{
	switch(rqst){
//		case PM_STANDBY_RESUME:	//Added by Bill, May 10, 2004
		case PM_RESUME:
			if((g_slcdc_status & SLCDC_SUSPEND_STATUS)!=0)
			{
				//enable clk
				//sleep out
				slcdc_sleep_out();
				slcdc_delay(20000);
				slcdc_delay(0xffff);
				slcdc_display_on();
				g_slcdc_status &= ~SLCDC_SUSPEND_STATUS;
			}
			break;
//		case PM_STANDBY:	//Added by Bill, May 10, 2004
		case PM_SUSPEND:
			if((g_slcdc_status & SLCDC_OPEN_STATUS)!=0)
			{
				//disable clk
				slcdc_display_off();
				g_slcdc_status |= SLCDC_SUSPEND_STATUS;
			}
			break;
		default:
			break;
		}
	return 0;
}
/**
 *@brief slcdc init function
 *
 * Function Name: slcdc_init
 *
 *
 *@return	int   return status
 *			@li 0  sucess
 *			@li other failure
 *
 * Description: This is the initialization routine for the driver. And this function \n
 *		will be called while the module being installed. In this function, it will \n
 *		register char device,request slcdc irq, initialize the buffer,register to  \n
 *		power management. 
 *
 * Modification History:
 * 	Dec,2003,			Karen update for MX21 TO2 
 *   
 **/

signed short __init slcdc_init(void)
{
	int tmp;
	INFO("SLCDC Driver \n");
	INFO("Motorola SPS-SuZhou \n");
	
	g_slcdc_major = devfs_register_chrdev(0, MODULE_NAME, &g_slcdc_fops);
 	if ( g_slcdc_major < 0 )
 	{
		TRACE("%s driver: Unable to register driver\n",MODULE_NAME);
		return -ENODEV;
	}
	
	
	g_devfs_handle = devfs_register(NULL, MODULE_NAME, DEVFS_FL_DEFAULT,
				      g_slcdc_major, 0,
				      S_IFCHR | S_IRUSR | S_IWUSR,
				      &g_slcdc_fops, NULL);   	
				      
    //init interrupt
	tmp = request_irq(SLCDC_IRQ,
			(void * )slcdc_isr,
			SA_INTERRUPT|SA_SHIRQ,
			MODULE_NAME,
			MODULE_NAME);
	if (tmp)
	{
		printk("slcdc_init:cannot init major= %d irq=%d\n", g_slcdc_major, SLCDC_IRQ);
        devfs_unregister_chrdev(g_slcdc_major, MODULE_NAME);
        devfs_unregister(g_devfs_handle);
		return -1;
	}
	//init buffer
	//initialize buffer address
	g_slcdc_dbuffer_address = NULL;
    g_slcdc_dbuffer_phyaddress = NULL;
    g_slcdc_cbuffer_address = NULL;
    g_slcdc_cbuffer_phyaddress = NULL;
	slcdc_init_buffer();

	/* Modified by Bill, May 10, 2004 */
	g_slcdc_pm = pm_register(PM_SLCDC_DEV, PM_SYS_UNKNOWN, slcdc_pm_handler);
	g_Slcdc_apmc = apmc_register(APMC_LEVEL_HIGHEST);	//Added by Bill, Aug-18-04
	g_slcdc_status = 0;

	return 0;	
}

/**
 *@brief slcdc cleanup function
 *
 * Function Name: slcdc_cleanup
 *
 *@return	None
 *
 * Description: This is the cleanup routine for the driver. And this function \n
 *		will be called while the module being removed. In this function, it will \n
 *		cleanup all the registered entries 
 *
 * Modification History:
 * 	Dec 2003,			Karen update for MX21 TO2 
 *   
 **/

void __exit slcdc_cleanup(void)
{
	/*Do some cleanup work*/
	free_irq(SLCDC_IRQ, MODULE_NAME);
	slcdc_free_buffer();

    if(g_slcdc_major>0)
    {
        devfs_unregister_chrdev(g_slcdc_major, MODULE_NAME);
        devfs_unregister(g_devfs_handle);
    }	
    pm_unregister(g_slcdc_pm);
	apmc_unregister(g_Slcdc_apmc);

}

int init_module(void)
{
	return slcdc_init();
}

void cleanup_module(void)
{
	slcdc_cleanup();
}
/*\@}*/

MODULE_PARM(irq_mask, "i");
MODULE_PARM(irq_list, "1-4i");
MODULE_LICENSE("GPL");