xf86dmc.c

一份介绍在S3C2410上液晶屏驱动程序的实现

int def,sx,sy,ex,ey,rsx,rsy,rex,rey,a,b,c,orgx,orgy;
uRect *rp,*ap;
	if( priv->reporting_mode == TS_Raw )
	{
		tm = get_time();
		if( priv->reporting_time == 0 )
			priv->reporting_time = tm;
		else
		{
			if( !priv->pen_down )
			{
				if( diff_time(tm,priv->reporting_time) < 300 )
				{
					priv->reporting_time = 0;
					return(false);
				}
				priv->reporting_time = 0;
			}
		}
		return(true);
	}
	orgx = inx;
	orgy = iny;
	def = 1;
	if (priv->reporting_mode == TS_Scaled)
	{
		rp = priv->calib_run_raw_r;
		ap = priv->calib_run_adj_r;
	}
	else
	{
		rp = priv->calib_temp_run_raw_r;
		ap = priv->calib_temp_run_adj_r;
	}
	if( inx <= rp[0].rightbottom.x && iny <= rp[0].rightbottom.y )
	{
		dp = 0;
		rp = &rp[0];
		ap = &ap[0];
	}
	else if( inx <= rp[1].righttop.x && iny >= rp[1].righttop.y )
	{
		dp = 1;
		rp = &rp[1];
		ap = &ap[1];
	}
	else if( inx >= rp[2].leftbottom.x && iny <= rp[2].leftbottom.y )
	{
		dp = 2;
		rp = &rp[2];
		ap = &ap[2];
	}
	else
	{
		dp = 3;
		rp = &rp[3];
		ap = &ap[3];
	}
//xf86Msg(X_WARNING, "DMC : dp=%d %d,%d\n",dp,inx,iny);
	rsx = rp->lefttop.x;
	rex = rp->rightbottom.x;
	sx  = ap->lefttop.x;
	ex  = ap->rightbottom.x;
	rsy = rp->lefttop.y;
	rey = rp->rightbottom.y;
	sy  = ap->lefttop.y;
	ey  = ap->rightbottom.y;
	//
	a = (ex - sx);
	b = (rex - rsx);
	if( b == 0 )
		def = 0;
	else
	{
		*x = (((inx - rsx) * a) / b) + sx;
		if( *x >= priv->max_x )
			*x = priv->max_x - 1;
		if( *x < 0 )
			*x = 0;
	}
#if 0
	xf86Msg(X_WARNING, "DMC : ADJX %4d -> %4d -> %4d [%4d/%4d]\n",orgx,inx,*x,a,b);
#endif
	a = (ey - sy);
	b = (rey - rsy);
	if( b == 0 )
		def = 0;
	else
	{
		*y = (((iny - rsy) * a) / b) + sy;
		if( *y >= priv->max_y )
			*y = priv->max_y - 1;
		if( *y < 0 )
			*y = 0;
	}
#if 0
	xf86Msg(X_WARNING, "DMC : ADJY %4d -> %4d -> %4d [%4d/%4d]\n",orgy,iny,*y,a,b);
#endif
	if( def == 0 )
	{
		*x = inx;
		*y = iny;
	}
#if 0
	xf86Msg(X_WARNING, "DMC : %d = (%4d,%4d)\n",dp,*x,*y);
#endif
	return(true);
}

/* 
 * The SwitchMode function may need to be tailored for your device
 */
static int SwitchMode (ClientPtr client, DeviceIntPtr dev, int mode)
{
	InputInfoPtr pInfo = dev->public.devicePrivate;
	DMCPrivatePtr priv = (DMCPrivatePtr) (pInfo->private);

#if DEBUG_DMC
xf86Msg(X_WARNING, "DMC : SwitchMode mode=$%08x \n",mode);
#endif
	if ((mode == SendCoreEvents) || (mode == DontSendCoreEvents))
	{
		xf86XInputSetSendCoreEvents (pInfo, (mode == SendCoreEvents));
	}
	else if( mode >= (S_RATE_CMD+START_S_RATE) && mode <= (S_RATE_CMD+END_S_RATE) )
	{
		priv->samp_rate = mode & S_RATE_MASK;
		if( !specify_set(priv,pInfo->fd) )
			return (!Success);
	}
	else if( mode == BEEP_ON_DOWN_CMD )
	{
		priv->tp_state |= B_BELL_DOWN;
	}
	else if( mode == BEEP_OFF_DOWN_CMD )
	{
		priv->tp_state &= (~B_BELL_DOWN);
	}
	else if( mode == BEEP_ON_UP_CMD )
	{
		priv->tp_state |= B_BELL_UP;
	}
	else if( mode == BEEP_OFF_UP_CMD )
	{
		priv->tp_state &= (~B_BELL_UP);
	}
	else if( mode >= SELCT_CMD_start && mode <= SELCT_CMD_end )
	{
		switch( mode )
		{
		case SELCT_LEFT_CMD:
			priv->tp_state = (priv->tp_state & (~MASK_SELECT)) | B_SELECT_LEFT;
			break;
		case SELCT_MID_CMD:
			priv->tp_state = (priv->tp_state & (~MASK_SELECT)) | B_SELECT_MID;
			break;
		case SELCT_RIGHT_CMD:
			priv->tp_state = (priv->tp_state & (~MASK_SELECT)) | B_SELECT_RIGHT;
			break;
		case GET_SELCT_LEFT_CMD:
			return( priv->tp_state & B_SELECT_LEFT ? Success : !Success) ;
		case GET_SELCT_MID_CMD:
			return( priv->tp_state & B_SELECT_MID ? Success : !Success) ;
		case GET_SELCT_RIGHT_CMD:
			return( priv->tp_state & B_SELECT_RIGHT ? Success : !Success) ;
		}
	}
	else if( mode >= CALIB_CMD_RANGE_S && mode <= CALIB_CMD_RANGE_E )
		return( calib_cmd_exec(priv,mode,pInfo) );
	else if( mode == RESET_CMD )
	{
		DMCState st;
		st = priv->lex_mode;
		if( tx_specify_goto_idle(priv,true) )
			goto_xyp(priv);
		else
		{
			XisbBlockDuration (priv->buffer, -1);
			priv->lex_mode = st;
			return (!Success);
		}
		XisbBlockDuration (priv->buffer, -1);
		priv->lex_mode = st;
	}
	else
		return (!Success);
	return (Success);
}

/********************************************* calibration function start ***
 
 	Utiltiy 'tbcalib' Call.

		While input calibration point.
			--> CALIB_FIRST_CMD
					start calibration.
			--> CALIB_NEXT_CMD
					next calibration point.
					memory raw input touch data in this local driver's static.
		Input end.
			--> CALIB_END_CMD
		Push [OK] button
			--> CALIB_ADJ_DAT_CMD -> (CALIB_ADJ_DAT_CMD+MAX_CALIB_POINT-1)
					set adjsut calibration data.
			--> CALIB_OK_CMD
					end calibration & memory(=write eeprom) calibration data.
		Push [Cancel] button
			--> CALIB_CANCEL_CMD
					end calibration.
*/
static int calib_cmd_exec(DMCPrivatePtr priv,int mode,InputInfoPtr pInfo)
{
	if( mode == CALIB_PRE_FIRST_CMD )
	{
		calib_set(priv,10,(unsigned char)mode,pInfo->fd);
	}
	else if( mode == CALIB_FIRST_CMD )
	{
		priv->reporting_mode = TS_Raw;
		calib_set(priv,10,(unsigned char)mode,pInfo->fd);
	}
	else if( mode == CALIB_NEXT_CMD )
	{
		calib_set(priv,11,(unsigned char)mode,pInfo->fd);
	}
	else if( mode == CALIB_END_CMD )
	{
		calib_set(priv,3,(unsigned char)mode,pInfo->fd);
		priv->reporting_mode = 0;
	}
	else if( mode == CALIB_CANCEL_CMD )
	{
		calib_set(priv,10,(unsigned char)mode,pInfo->fd);
		priv->reporting_mode = TS_Scaled;
	}
	else if( mode == CALIB_OK_CMD )
	{
		if( !calib_set(priv,0,0,pInfo->fd) )
		{
			priv->reporting_mode = TS_Scaled;
			return (!Success);
		}
		priv->reporting_mode = TS_Scaled;
	}
	else if( mode >= CALIB_ADJ_DAT_CMD && mode < (CALIB_ADJ_DAT_CMD+MAX_CALIB_POINT) )
	{
		calib_set(priv,1,(unsigned char)mode,pInfo->fd);
	}
	else if( (mode & 0xf0) == CALIB_1_DAT )
	{
		calib_set(priv,2,(unsigned char)mode,pInfo->fd);
	}
	else
		return (!Success);
	return (Success);
}
static Bool calib_set(DMCPrivatePtr priv,int type,unsigned char a,int fd)
{
int pt,res,ofs;
DMCState st;
	switch( type )
	{
	case	0:	// data complete & set!!
		priv->calib_point = priv->do_calib;
		memcpy(priv->calib_data,priv->calib_temp_data,sizeof(priv->calib_data));
		set_calib_area(priv,false);
		write_save_file(priv);
		st = priv->lex_mode;
		if( (res = tx_xyp_exit_goto_idle(priv,false)) )
		{
			asleep(priv,1);
			xf86FlushInput(fd);
			res = priv->eeprom_read_ok ? write_eeprom(priv) : true;
			if( !goto_xyp(priv) )
				res = false;
		}
		XisbBlockDuration (priv->buffer, -1);
		priv->lex_mode = st;
		if( !res )
			return(false);
		break;
	case	1:	// set point in temporary
		pt = priv->calib_temp_point = a & CALIB_MASK;
		priv->calib_temp_nibble = 0;
		for( a=0 ; a < MAX_DATA ; a++ )
			priv->calib_temp_data[pt][a] = 0;
		break;
	case	2:	// set adjust(=refernce) data in temporary
		if( priv->calib_temp_nibble >= (MAX_DATA*4) )
			priv->calib_temp_nibble = 0;
		pt = priv->calib_temp_point;
		a &= CALIB_MASK;
		ofs = priv->calib_temp_nibble / 4;
		priv->calib_temp_data[pt][ofs] <<= 4;
		priv->calib_temp_data[pt][ofs] |= a;
		priv->calib_temp_nibble++;
		break;
	case	3:	// set end
		set_temp_data(priv,priv->do_calib,0,priv->calib_raw_data);
		set_calib_area(priv,true);
		break;
	case	10:	// init
		priv->do_calib = 0;
		priv->reporting_time = 0;
		break;
	case	11:	// set data
		if( (pt = priv->do_calib) >= MAX_CALIB_POINT )
			break;
		priv->calib_raw_data[pt][0] = priv->calib_raw_x;
		priv->calib_raw_data[pt][1] = priv->calib_raw_y;
		pt++;
		priv->do_calib = pt;
		priv->reporting_time = 0;
		break;
	}
	return(true);
}
static int set_calib_area(DMCPrivatePtr priv,BOOL use_temp)
{
uRect *rp,*ap;
int pt,i;
unsigned int (*dat)[MAX_DATA];
	if( use_temp )
	{
		rp = priv->calib_temp_run_raw_r;
		ap = priv->calib_temp_run_adj_r;
		pt = priv->calib_temp_point;
		dat = priv->calib_temp_data;
	}
	else
	{
		rp = priv->calib_run_raw_r;
		ap = priv->calib_run_adj_r;
		pt = priv->calib_point;
		dat = priv->calib_data;
	}
	// dat[]
	//  0  1  2
	//  3  4  5
	//  6  7  8
	rp[0].lefttop.x		= dat[0][0];	rp[0].lefttop.y		= dat[0][1];
	rp[0].leftbottom.x	= dat[3][0];	rp[0].leftbottom.y	= dat[3][1];
	rp[0].righttop.x	= dat[1][0];	rp[0].righttop.y	= dat[1][1];
	rp[0].rightbottom.x	= dat[4][0];	rp[0].rightbottom.y	= dat[4][1];

	rp[1].lefttop.x		= dat[3][0];	rp[1].lefttop.y		= dat[3][1];
	rp[1].leftbottom.x	= dat[6][0];	rp[1].leftbottom.y	= dat[6][1];
	rp[1].righttop.x	= dat[4][0];	rp[1].righttop.y	= dat[4][1];
	rp[1].rightbottom.x	= dat[7][0];	rp[1].rightbottom.y	= dat[7][1];

	rp[2].lefttop.x		= dat[1][0];	rp[2].lefttop.y		= dat[1][1];
	rp[2].leftbottom.x	= dat[4][0];	rp[2].leftbottom.y	= dat[4][1];
	rp[2].righttop.x	= dat[2][0];	rp[2].righttop.y	= dat[2][1];
	rp[2].rightbottom.x	= dat[5][0];	rp[2].rightbottom.y	= dat[5][1];

	rp[3].lefttop.x		= dat[4][0];	rp[3].lefttop.y		= dat[4][1];
	rp[3].leftbottom.x	= dat[7][0];	rp[3].leftbottom.y	= dat[7][1];
	rp[3].righttop.x	= dat[5][0];	rp[3].righttop.y	= dat[5][1];
	rp[3].rightbottom.x	= dat[8][0];	rp[3].rightbottom.y	= dat[8][1];

	ap[0].lefttop.x		= dat[0][2];	ap[0].lefttop.y		= dat[0][3];
	ap[0].leftbottom.x	= dat[3][2];	ap[0].leftbottom.y	= dat[3][3];
	ap[0].righttop.x	= dat[1][2];	ap[0].righttop.y	= dat[1][3];
	ap[0].rightbottom.x	= dat[4][2];	ap[0].rightbottom.y	= dat[4][3];

	ap[1].lefttop.x		= dat[3][2];	ap[1].lefttop.y		= dat[3][3];
	ap[1].leftbottom.x	= dat[6][2];	ap[1].leftbottom.y	= dat[6][3];
	ap[1].righttop.x	= dat[4][2];	ap[1].righttop.y	= dat[4][3];
	ap[1].rightbottom.x	= dat[7][2];	ap[1].rightbottom.y	= dat[7][3];

	ap[2].lefttop.x		= dat[1][2];	ap[2].lefttop.y		= dat[1][3];
	ap[2].leftbottom.x	= dat[4][2];	ap[2].leftbottom.y	= dat[4][3];
	ap[2].righttop.x	= dat[2][2];	ap[2].righttop.y	= dat[2][3];
	ap[2].rightbottom.x	= dat[5][2];	ap[2].rightbottom.y	= dat[5][3];

	ap[3].lefttop.x		= dat[4][2];	ap[3].lefttop.y		= dat[4][3];
	ap[3].leftbottom.x	= dat[7][2];	ap[3].leftbottom.y	= dat[7][3];
	ap[3].righttop.x	= dat[5][2];	ap[3].righttop.y	= dat[5][3];
	ap[3].rightbottom.x	= dat[8][2];	ap[3].rightbottom.y	= dat[8][3];
#if DEBUG_CALIB_AREA
	for( i=0 ; i < 4 ; i++ )
		xf86Msg(X_WARNING, "DMC : raw area3 (%3d,%3d)-(%3d,%3d)-(%3d,%3d)-(%3d,%3d)\n"
							,rp[i].lefttop.x,    rp[i].lefttop.y
							,rp[i].leftbottom.x, rp[i].leftbottom.y
							,rp[i].righttop.x,   rp[i].righttop.y
							,rp[i].rightbottom.x,rp[i].rightbottom.y);
	for( i=0 ; i < 4 ; i++ )
		xf86Msg(X_WARNING, "DMC : adj area3 (%3d,%3d)-(%3d,%3d)-(%3d,%3d)-(%3d,%3d)\n"
							,ap[i].lefttop.x,    ap[i].lefttop.y
							,ap[i].leftbottom.x, ap[i].leftbottom.y
							,ap[i].righttop.x,   ap[i].righttop.y
							,ap[i].rightbottom.x,ap[i].rightbottom.y);
#endif
	return(0);
}
static int set_temp_data(DMCPrivatePtr priv,int calib_point,int ofs,unsigned int a[][2])
{
int i;
unsigned int temp[16][2];
	memcpy(temp,a,sizeof(temp));
	switch( calib_point )
	{
	case	2:
		// 0  -  -2    -> 0  1  2
		// -  -  -     -> 3  4  5
		// -3 -  1     -> 6  7  8
		temp[2][0] = temp[1][0];
		temp[2][1] = temp[0][1];
		temp[3][0] = temp[0][0];
		temp[3][1] = temp[1][1];
		memcpy(&priv->calib_temp_data[0][ofs],temp[0],sizeof(int)*2);
		caldif(&priv->calib_temp_data[1][ofs],temp[0],temp[2]);
		memcpy(&priv->calib_temp_data[2][ofs],temp[2],sizeof(int)*2);
		caldif(&priv->calib_temp_data[3][ofs],temp[0],temp[3]);
		caldif(&priv->calib_temp_data[4][ofs],temp[0],temp[1]);
		caldif(&priv->calib_temp_data[5][ofs],temp[2],temp[1]);
		memcpy(&priv->calib_temp_data[6][ofs],temp[3],sizeof(int)*2);
		caldif(&priv->calib_temp_data[7][ofs],temp[3],temp[1]);
		memcpy(&priv->calib_temp_data[8][ofs],temp[1],sizeof(int)*2);
		break;
	case	3:
		// 0  -  -3    -> 0  1  2
		// -  1  -     -> 3  4  5
		// -4 -  2     -> 6  7  8
		temp[3][0] = temp[2][0];
		temp[3][1] = temp[0][1];
		temp[4][0] = temp[0][0];
		temp[4][1] = temp[2][1];
#if CALIB_PAT_A
		memcpy(&priv->calib_temp_data[0][ofs],temp[0],sizeof(int)*2);
		aaacpy(&priv->calib_temp_data[1][ofs],temp[1],temp[0]);
		memcpy(&priv->calib_temp_data[2][ofs],temp[3],sizeof(int)*2);
		aaacpy(&priv->calib_temp_data[3][ofs],temp[4],temp[1]);
		memcpy(&priv->calib_temp_data[4][ofs],temp[1],sizeof(int)*2);
		aaacpy(&priv->calib_temp_data[5][ofs],temp[3],temp[1]);
		memcpy(&priv->calib_temp_data[6][ofs],temp[4],sizeof(int)*2);
		aaacpy(&priv->calib_temp_data[7][ofs],temp[1],temp[4]);
		memcpy(&priv->calib_temp_data[8][ofs],temp[2],sizeof(int)*2);
#else
		memcpy(&priv->calib_temp_data[0][ofs],temp[0],sizeof(int)*2);
		caldif(&priv->calib_temp_data[1][ofs],temp[0],temp[3]);
		memcpy(&priv->calib_temp_data[2][ofs],temp[3],sizeof(int)*2);
		caldif(&priv->calib_temp_data[3][ofs],temp[0],temp[4]);
		memcpy(&priv->calib_temp_data[4][ofs],temp[1],sizeof(int)*2);
		caldif(&priv->calib_temp_data[5][ofs],temp[2],temp[3]);
		memcpy(&priv->calib_temp_data[6][ofs],temp[4],sizeof(int)*2);
		caldif(&priv->calib_temp_data[7][ofs],temp[2],temp[4]);
		memcpy(&priv->calib_temp_data[8][ofs],temp[2],sizeof(int)*2);
#endif
		break;
	case	4: