touch_panel.c

MTK6225

*	data: touch event
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
/*Get touch panel coord. value*/
kal_bool touch_panel_get_event(TouchPanelEventStruct *touch_data)
{
   kal_bool result;
   kal_uint8 hign_data=0, low_data=0;
   kal_int8 diff;
   kal_uint16 avail=0;
   //TouchPanelEventStruct data;

// kal_print("touch_panel_get_event");
   
   IRQMask(IRQ_GPT_CODE);
   /* only mask eint when it's unmasked. */
 if (tp_eint_mask == KAL_FALSE)		//xiong 07/06/06  //qsh 4-15
 EINT_Mask(TP.eint_chan);   
   
   if(TP.is_buff_full==KAL_TRUE)
   {
      touch_data->event=PEN_ABORT;
      touch_data->x_adc=0;
      touch_data->y_adc=0;
    if (tp_eint_mask == KAL_FALSE)	//xiong 07/06/06  //qsh 4-15
      EINT_UnMask(TP.eint_chan);  //qsh 4-15
     IRQUnmask(IRQ_GPT_CODE);//qsh 4-15
      return KAL_TRUE;
   }
   
   tp_get_buf_avail(avail); 
   if(touch_panel_data_buffer.touch_buffer_rindex != touch_panel_data_buffer.touch_buffer_windex)   	
   {            
      if(tp_decode_state==TP_UNKNOWN_EVENT)            
      {/*complete x and y*/         
         touch_pop_data_from_buffer(touch_data->event);          
         if(touch_data->event!=STROKE_UP)/*stroke end*/
         {
            touch_pop_data_from_buffer(hign_data);/*high*/
            touch_pop_data_from_buffer(low_data);/*low*/
            touch_data->x_adc=(hign_data<<8);     
            touch_data->x_adc|=low_data;     
            touch_pop_data_from_buffer(hign_data);/*high*/
            touch_pop_data_from_buffer(low_data);/*low*/
            touch_data->y_adc=(hign_data<<8);               
            touch_data->y_adc|=low_data;     
         }   
         if(touch_data->event==STROKE_DOWN)
         {
            tp_decode_state=STROKE_MOVE;
            tp_stroke_pre.x=touch_data->x_adc;
            tp_stroke_pre.y=touch_data->y_adc;
         }    
      }
      else if(tp_decode_state==STROKE_MOVE)    
      { 
         touch_pop_data_from_buffer(diff);
         if((kal_uint8)diff==STROKE_UP) 
         {
            touch_data->event=STROKE_UP;
            touch_data->x_adc=tp_stroke_pre.x;//0;
            touch_data->y_adc=tp_stroke_pre.y;//0;
            tp_decode_state=TP_UNKNOWN_EVENT;
            tp_stroke_pre.x=0;
            tp_stroke_pre.y=0;
         }                         
         else if((kal_uint8)diff==STROKE_LONGTAP) 
         {
            //touch_pop_data_from_buffer(diff);
            touch_data->x_adc=tp_stroke_pre.x;//0;
            touch_data->y_adc=tp_stroke_pre.y;//0;
            touch_data->event=STROKE_LONGTAP;
         }   
         else/*delta x, delta y*/
         {     
            /*x*/    
            touch_data->x_adc=(kal_int16)((kal_int16)tp_stroke_pre.x+(kal_int16)diff);
            tp_stroke_pre.x=touch_data->x_adc;
            /*y*/
            touch_pop_data_from_buffer(diff);         
            touch_data->y_adc=(kal_int16)((kal_int16)tp_stroke_pre.y+(kal_int16)diff);;
            tp_stroke_pre.y=touch_data->y_adc;
            touch_data->event=STROKE_MOVE;
         }
      } 
     result = KAL_TRUE;
   }
   else
   {
      send_touch_ilm = KAL_TRUE;
      result = KAL_FALSE;
   }      
   if (tp_eint_mask == KAL_FALSE)
    EINT_UnMask(TP.eint_chan);
    IRQUnmask(IRQ_GPT_CODE);
   return result;      
}   
/*************************************************************************
* FUNCTION
*	touch_panel_peek_event
*
* DESCRIPTION
*	This function is to peek event from ring buffer.
*
* PARAMETERS
*	data: touch event
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool touch_panel_peek_event(TouchPanelEventStruct *touch_data)
{
   kal_bool result;
   //kal_uint8 hign_data=0, low_data=0;
   kal_uint8 peek_data[5];
   //kal_int8 diff;
   //TouchPanelEventStruct data;
   IRQMask(IRQ_GPT_CODE);
   //  kal_print("touch_panel_peek_event");
   /* only mask eint when it's unmasked. */
   if (tp_eint_mask == KAL_FALSE)
  EINT_Mask(TP.eint_chan);   
   if (touch_panel_data_buffer.touch_buffer_rindex != touch_panel_data_buffer.touch_buffer_windex)
   {                  
      if(tp_decode_state==TP_UNKNOWN_EVENT)            
      {/*complete x and y*/         
         touch_peek_data_from_buffer(peek_data,5);   
         touch_data->event=peek_data[0];            
         if(peek_data[0]!=STROKE_UP)/*stroke end*/
         {
            touch_data->x_adc=(peek_data[1]<<8);     
            touch_data->x_adc|=peek_data[2];     
            touch_data->y_adc=(peek_data[3]<<8);               
            touch_data->y_adc|=peek_data[4];                       
         }            
      }
      else if(tp_decode_state==STROKE_MOVE)    
{
         touch_peek_data_from_buffer(peek_data,3);   
         if((kal_uint8)peek_data[0]==STROKE_UP) 
         {
            touch_data->event=STROKE_UP;
            touch_data->x_adc=0;
            touch_data->x_adc=0;            
         }                         
         else/*delta x, delta y*/
         {     
            /*x*/    
            touch_data->x_adc=(kal_int16)((kal_int16)tp_stroke_pre.x+(kal_int16)peek_data[1]);            
            /*y*/            
            touch_data->y_adc=(kal_int16)((kal_int16)tp_stroke_pre.y+(kal_int16)peek_data[2]);;                        
         }
      }       
     result = KAL_TRUE;
   }
   else   
   {
      send_touch_ilm = KAL_TRUE;
      result = KAL_FALSE;
   }
      
   if (tp_eint_mask == KAL_FALSE)
   EINT_UnMask(TP.eint_chan);
   IRQUnmask(IRQ_GPT_CODE);
   return result;      
}

/*************************************************************************
* FUNCTION
*	touch_panel_conf_move_offset
*
* DESCRIPTION
*	This function is to configure pen move offset and stroke move offset.
*
* PARAMETERS
*	pen_offset: pen move offset
*	stroke_offset: stroke move offset
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
void touch_panel_conf_move_offset(kal_uint16 pen_offset, kal_uint16 stroke_offset, 
                                  kal_uint16 longtap_pen_offset,
                                  kal_uint16 longtap_stroke_offset)
{
   TP.pen_offset=pen_offset;
   TP.storke_offset=stroke_offset;      
   TP.longtap_pen_offset=longtap_pen_offset;
   TP.longtap_stroke_offset=longtap_stroke_offset;
}  


/*************************************************************************
* FUNCTION
*	touch_panel_exceed_penmove
*
* DESCRIPTION
*	This function is pen move event filter.
*
* PARAMETERS
*	x: x coord.
*	y: y coord.
*
* RETURNS
*	exceed MIN_PEN_MOVE_OFFSET or not
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool touch_panel_exceed_penmove(kal_int16 x, kal_int16 y)
{
   kal_int16 x_diff, y_diff;
   
   if(x>TP.pre.x)   
      x_diff=x-TP.pre.x;
   else
      x_diff=TP.pre.x-x;   
   if(y>TP.pre.y)   
      y_diff=y-TP.pre.y;
   else
      y_diff=TP.pre.y-y;      
          
   if(TP.longtap_state==KAL_FALSE)/*normal*/
   {
   if((x_diff>=TP.pen_offset||y_diff>=TP.pen_offset)
       &&(x_diff<NONHAND_WRITING_MAX_OFFSET)&&(y_diff<NONHAND_WRITING_MAX_OFFSET))   
      return KAL_TRUE;          
   else
      return KAL_FALSE;   
}  
   else/*longtap*/
   {
      if((x_diff>=TP.longtap_pen_offset||y_diff>=TP.longtap_pen_offset)
          &&(x_diff<NONHAND_WRITING_MAX_OFFSET)&&(y_diff<NONHAND_WRITING_MAX_OFFSET))   
         return KAL_TRUE;          
      else
         return KAL_FALSE;   
      
   }         
}  

/*************************************************************************
* FUNCTION
*	touch_panel_longtap_handwriting_filter
*
* DESCRIPTION
*	This function is to check longtap event in handwriting area.
*
* PARAMETERS
*	x: x coord.
*	y: y coord.
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void touch_panel_longtap_handwriting_filter(kal_int16 x, kal_int16 y)
{
   kal_int16 x_diff, y_diff;      
   
   if(x>TP.begin.x)   
      x_diff=x-TP.begin.x;
   else
      x_diff=TP.begin.x-x;    
      
   if(y>TP.begin.y)    
      y_diff=y-TP.begin.y;
   else
      y_diff=TP.begin.y-y;    
      
   if(x_diff>TP.longtap_stroke_offset||y_diff>TP.longtap_stroke_offset)/*handwriting long tap*/   
   {
      GPTI_StopItem(touch_panel_repeat_handle);          
      TP.longtap_state=KAL_FALSE;

	   	  
   }   
}  
/*************************************************************************
* FUNCTION
*	touch_panel_stroke_filter
*
* DESCRIPTION
*	This function is stroke move event filter.
*
* PARAMETERS
*	x: x coord.
*	y: y coord.
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/
void touch_panel_stroke_filter(kal_int16 x, kal_int16 y)
{
   kal_int16 x_diff, y_diff;
   //TouchPanelCoordStruct diff;
   if(TP.longtap_state==KAL_TRUE)
      touch_panel_longtap_handwriting_filter(x, y);

	  
   if(x>TP.pre.x)   
      x_diff=x-TP.pre.x;
   else
      x_diff=TP.pre.x-x;    
      
   if(y>TP.pre.y)    
      y_diff=y-TP.pre.y;
   else
      y_diff=TP.pre.y-y;     
         
   if((x_diff>TP.storke_offset||y_diff>TP.storke_offset)
       &&(x_diff<HAND_WRITING_MAX_OFFSET)&&(y_diff<HAND_WRITING_MAX_OFFSET))
   {           
      if(TP.temp.x==0&&TP.temp.y==0)      
      {
         tp_data_pop(STROKE_MOVE,(x-TP.pre.x) ,(y-TP.pre.y));
         TP.pre.x=x;
         TP.pre.y=y;
      }   
      else
      {
         /*use the previous point*/
         tp_data_pop(STROKE_MOVE, (TP.temp.x-TP.pre.x), (TP.temp.y-TP.pre.y));
         TP.pre.x=TP.temp.x;
         TP.pre.y=TP.temp.y;
         if(x>TP.pre.x)   
            x_diff=x-TP.pre.x;
         else
            x_diff=TP.pre.x-x;   
      
         if(y>TP.pre.y)   
            y_diff=y-TP.pre.y;
         else         
            y_diff=TP.pre.y-y;          
            
         if((x_diff>TP.storke_offset||y_diff>TP.storke_offset))
         {
            tp_data_pop(STROKE_MOVE, (x-TP.pre.x), (y-TP.pre.y));
            TP.pre.x=x;
            TP.pre.y=y;
            TP.temp.x=0;
            TP.temp.y=0;
         }   
         else
         {
            TP.temp.x=x;
            TP.temp.y=y;
         }                                    
      }                        
   }
   else     
   {
      TP.temp.x=x;
      TP.temp.y=y;  
   }   
} 

/*************************************************************************
* FUNCTION
*	tp_data_pop
*
* DESCRIPTION
*	This function is to "push" data to buffer.
*
* PARAMETERS
*	x: x coord.
*	y: y coord.
*  event: event type
*
* RETURNS
*	None
*
* GLOBALS AFFECTED
*
*************************************************************************/  
kal_uint16 tp_roomleft_min=TOUCH_PANEL_BUFFER_SIZE;
void tp_data_pop(Touch_Panel_Event_enum event, kal_int16 x, kal_int16 y)
{


   kal_uint16 roomleft=0;
   tp_get_buf_roomleft(roomleft);   
   /*To get minimum roomleft*/
   if(roomleft<tp_roomleft_min)
      tp_roomleft_min=roomleft;
   
   if(TP.is_buff_full==KAL_TRUE)
      return;

   
   if(roomleft<=BASIC_EVENT_UNIT)
   {
       //if(roomleft>=1)
         //touhc_push_data_to_buffer(PEN_ABORT);         
       /*stop collect events until ring buffer is clean*/
       TP.is_buff_full=KAL_TRUE;
       return;
   }    
   
   if(event==STROKE_MOVE) 
   {
      kal_uint8 x_value;
      kal_uint8 y_value;

      /* Cast x, y to kal_uint8. */
      x_value = x;
      y_value = y;
      #ifdef TOUCH_PANEL_DEBUG
      dbg_printWithTime("Move %d,%d\r\n",(kal_int16)x,(kal_int16)y);
      #endif
      /*to avoid STROKE_UP and STROKE_LONGTAP data show in the packet*/
      if(x_value==STROKE_UP)
         x_value = STROKE_UP - 2;
      else if (x_value==STROKE_LONGTAP)
         x_value = STROKE_LONGTAP - 1;
      if(y_value==STROKE_UP)
         y_value = STROKE_UP - 2;   
      else if (y_value==STROKE_LONGTAP)
         y_value = STROKE_LONGTAP - 1;
      touhc_push_data_to_buffer(x_value,event);/*diff_x*/
      touhc_push_data_to_buffer(y_value,event);/*diff_y*/   
	 //     kal_print("SEND STROKE_MOVE");
   }   
   else if(event==STROKE_LONGTAP) 
   {
  //    kal_print("SEND STROKE_LONGTAP");
      touhc_push_data_to_buffer(event,event);/*diff_x*/
   }   
   else if(event==STROKE_UP) 
   {
  //    kal_print("SEND  STROKE_UP");
      touhc_push_data_to_buffer(event, event);         
   }
   else
   {
      //if(roomleft>=BASIC_EVENT_UNIT)
      {
    //     kal_print("SEND OTHER EVENT");
         touhc_push_data_to_buffer(event, event);   
         touhc_push_data_to_buffer(x>>8, event);