usim_drv.h

8032底层驱动部分。因为可以移植 所以单独来拿出来

#define ATR_TA1_64			0x94
#define ATR_TA1_32			0x95
#define ATR_TA1_16			0x96

#define USIM_RETRY			3
#define INDEX_COUNT			4		// the count of the wline and sline
#define MAX_BWI				9
#define MAX_CWI				16
#define SIM_TOTAL_FIFO_LEN	16		// excep 6208
#define HIST_FIRST_USIM				0x80	// the first of the historical character of USIM
#define HIST_SEC_USIM				0x31	// the second of the historical character of USIM
#define HIST_FOUR_USIM				0x73	// the fourth of the historical character of USIM
#define USIM_DMA_MAX_SIZE			260
#define USIM_GPT_TIMEOUT_PERIOD  500	// x 10ms

typedef enum{
	RESYNC_REQ = PCB_S_DEFAULT,
	IFS_REQ = (PCB_S_DEFAULT|1),
	ABORT_REQ = (PCB_S_DEFAULT|2),
	WTX_REQ = (PCB_S_DEFAULT|3),
	RESYNC_RESP = RESYNC_REQ|PCB_S_RESP,
	IFS_RESP = IFS_REQ|PCB_S_RESP,
	ABORT_RESP = ABORT_REQ|PCB_S_RESP,
	WTX_RESP = WTX_REQ|PCB_S_RESP
}usim_s_block_id_enum;


// macros
#define SIM_WARM_RST()		DRV_Reg(SIM_CTRL)|=SIM_CTRL_WRST

/*
	normally, wait event will before set event, but sometimes set event will before wait event.
	for instance, during wait event, an interrupt is generated and trigger another interrupt before
	the corresponding wait event.
*/

#define USIM_CLR_EVENT()\
	kal_set_eg_events(usim_dcb.event,0,KAL_AND)

#define USIM_POW_ON() DRV_Reg(SIM_CTRL) |= SIM_CTRL_SIMON
#define USIM_WRST()	DRV_Reg(SIM_CTRL) = (SIM_CTRL_WRST|SIM_CTRL_SIMON)
#define USIM_ENABLE_T0()	DRV_Reg(SIM_CONF)|= SIM_CONF_T0EN
#define USIM_ENABLE_T1()	DRV_Reg(SIM_CONF)|= SIM_CONF_T1EN
#define USIM_DISABLE_T1()	DRV_Reg(SIM_CONF)&= (~SIM_CONF_T1EN)
#define USIM_ENABLE_TXRX_HANSHAKE()	DRV_Reg(SIM_CONF)|= (SIM_CONF_TXHSK|SIM_CONF_RXHSK)
#define USIM_DISABLE_TXRX_HANSHAKE()	DRV_Reg(SIM_CONF)&= ~(SIM_CONF_TXHSK|SIM_CONF_RXHSK)
#define USIM_TX_START_T1()	DRV_WriteReg(SIM_INS, 1)
#define USIM_IS_IBLOCK(pcb)	((pcb&PCB_I_BIT8)==0)
#define USIM_IS_RBLOCK(pcb)	((pcb&PCB_R_DEFAULT) == 0x80)
#define USIM_IS_SBLOCK(pcb)	((pcb&PCB_S_DEFAULT) == PCB_S_DEFAULT)
#define USIM_IS_RESP(pcb)		(pcb&PCB_S_RESP)
#define USIM_INV_N(n)	n = (n)?0:PCB_I_SEQ
#define USIM_CLR_FIFO()	DRV_WriteReg(SIM_COUNT, 1)
#define USIM_RESET_T1()	USIM_DISABLE_T1();USIM_ENABLE_T1();
#define USIM_ENABLE_TOUT()	DRV_Reg(SIM_CONF)|=SIM_CONF_TOUTEN
#define USIM_DISABLE_TOUT()	DRV_Reg(SIM_CONF)&=(~SIM_CONF_TOUTEN)
//#define USIM_CLR_TX_TIDE()		DRV_Reg(SIM_TIDE)&=(~SIM_TIDE_TXMASK)
#define USIM_DMA_RX_TIDE()			DRV_Reg(SIM_TIDE) = 0;
#define USIM_CAL_TD_COUNT(a,b)	\
		{\
			if(a & TAMask) b++;\
   		if(a & TBMask) b++;\
   		if(a & TCMask) b++;\
   	}

// generate R-block header 
#define USIM_MAKE_R_BLOCK(e)	\
		{\
			kal_uint8 pcb;\
\
			if(usim_dcb.nr)\
				pcb = (PCB_R_N1|e);\
			else\
				pcb = (PCB_R_N0|e);\
			usim_dcb.header_tx[T1_PCB_INDEX] = pcb;\
			usim_dcb.header_tx[T1_LEN_INDEX] = 0;\
			usim_dcb.cmd_state = R_BLOCK_TX;\
		}

#define USIM_MAKE_S_RESYNC()\
{\
			usim_dcb.header_tx[T1_PCB_INDEX] = PCB_S_DEFAULT;\
			usim_dcb.header_tx[T1_LEN_INDEX] = 0;\
			usim_dcb.cmd_state = S_BlOCK_REQ_TX;\
}

//#define USIM_GET_PCB_I() 

////////////// temp definitions///////////////
#define error()
//////////////////////////////////////////////

typedef struct{
	usim_dir_enum dir;

}ATR_struct;

// specify the supported attributes  of the UICC
typedef struct{
	usim_power_enum power;	
	usim_protocol_enum protocol;
	usim_clock_stop_enum clock_stop;
	usim_speed_enum speed;		
}usim_info_struct;

typedef struct{
	// before reset
	kal_bool high_speed_en;		// control if high speed is enalbed
	usim_power_enum power_in;		// expected power class input form application layer	
	// after reset
	usim_clock_stop_enum clock_stop_type; 
}usim_config_struct;

typedef struct{
	// ATR info
	kal_uint8 ATR_data[36];		// used to store all ATR data string
	kal_uint8 ATR_index;			// index to the ATR_data
	kal_uint8 header_tx[4], header_tx_bak[4]; // header_tx_bak used to backup the previous command
	kal_uint8 header_rx[4];
	kal_uint8 dma_buffer[USIM_DMA_MAX_SIZE];
	
	// informations
	usim_dir_enum dir;	// convention of character frame
	sim_env sim_env;		// the voltage which MS can supply
	usim_power_enum power_in;		// expected power class input form application layer
	usim_power_enum power;			// power class used
	usim_power_enum power_class;		// supported power class indicated at ATR
	// usim_protocol_enum T;		
	usim_speed_enum speed;		// speed selected
	usim_speed_enum card_speed; // TA1, max speed card can support
	kal_bool high_speed_en;		// control if high speed is enalbed
	usim_clock_stop_enum clock_stop_type;
	kal_bool	clock_stop_en;		// clock_stop is enabled or not
	kal_uint16 etu_of_1860;
	kal_uint16 etu_of_700;
	usim_reset_type_enum reset_mode; // specific or negotiable mode
	kal_bool warm_rst;	// KAL_TRUE: it's a warm reset, KAL_FALSE: a cold reset
	kal_bool T0_support;	// if T0 is supported
	kal_bool T1_support;	// if T1 is supported
	kal_uint16 Fi;
	kal_uint8 Di;
		
	// state control
	volatile usim_main_state_enum main_state;
	volatile usim_status_enum ev_status;
	kal_uint8 retry;
	
	// time out control
	kal_uint32 WWT;	// work waiting time (T0)
	kal_uint32 CWT;	// character waiting time in etu(T1)
	kal_uint32 BWT;	// blcok waiting time in etu(T1)
	kal_uint32 timeout;	// etu
	
	// T=1 
	kal_uint8 ns;		// sequence # of sending
	kal_uint8 nr;		// sequence # of receiving
	kal_uint8 ifsd;	// information size of interface device
	kal_uint8 ifsc;	// information size of card
	usim_cmd_state_enum cmd_state;
	usim_cmd_state_enum cmd_state_bak;	
	kal_bool abort;
	kal_bool wtx;	// waiting time extension
	kal_bool resync;
  	kal_bool send_prev;	// send the previous block	
	kal_bool tx_chain;	
	kal_bool rx_chain;
	kal_uint16 tx_size;
	kal_uint16 rx_size;
	kal_uint16 tx_index;
	kal_uint16 rx_index;
	kal_uint8 *tx_buf;
	kal_uint8 *rx_buf;
	kal_uint8 sw[2];		// used to contain SW1 and SW2
	kal_uint8 wtx_m;		// multiplier of BWT

	// others
	kal_bool ts_hsk_en;	// enable handshake at TS byte (error signal and char repetition)
	kal_uint8 dma_port;
	DMA_INPUT dma_input;
	DMA_HWMENU dma_menu;
	kal_eventgrpid event;
	kal_uint32 ev_flag;
	kal_hisrid hisr; 
	kal_uint32 int_status;
  	sim_protocol_app_enum app_proto;	// application protocol (USIM, SIM) 	
  	sim_protocol_phy_enum phy_proto; // protocol type selected (physical layer)
  	kal_uint8 hist_index;		// index to the historical characters 
	usim_status_enum status;
  	usim_cmd_case_enum cmd_case;
	kal_uint8 gpt_handle;
	kal_bool present;
#if defined(USIM_DEBUG)
	kal_int32 sline[INDEX_COUNT];	// set event at the which line in usim_drv.c
	kal_uint32 sindex;	// index to the sline[4]
	kal_int32 wline[INDEX_COUNT];	// wait event at the which line in usim_drv.c
	kal_uint32 windex;	// index to the wline
#endif

}usim_dcb_struct;

#define sim_print(a,b)		dbg_print(a,b)
//#define sim_print(a,b)	kal_prompt_trace(MOD_SIM,a,b) 

extern usim_dcb_struct usim_dcb;
usim_status_enum L1sim_Reset_All(sim_power_enum ExpectVolt, sim_power_enum *ResultVolt, kal_bool warm);
void L1sim_Enable_Enhanced_Speed_All(kal_bool enable);
kal_bool L1sim_Set_ClockStopMode_All(sim_clock_stop_enum mode);
void L1sim_PowerOff_All(void);
void L1sim_Get_Card_Info_All(sim_info_struct *info);
sim_status L1sim_Cmd_All(kal_uint8  *txData,kal_uint32  *txSize,kal_uint8  *rxData, kal_uint32  *rxSize);
void usim_gpt_timeout_handler(void *parameter);


#if defined(USIM_DEBUG)
#define USIM_WAIT_EVENT() \
{\
	usim_dcb.wline[(usim_dcb.windex&(INDEX_COUNT-1))] = __LINE__;\
	dbg_print("wait event at line:%d\r\n",__LINE__);\
	usim_dcb.windex++;\
	GPTI_StartItem(usim_dcb.gpt_handle,\
                  USIM_GPT_TIMEOUT_PERIOD,\
                  usim_gpt_timeout_handler,\
                  NULL);\
	kal_retrieve_eg_events(usim_dcb.event,USIM_EVENT,KAL_AND_CONSUME,&usim_dcb.ev_flag,KAL_SUSPEND);\
	if(usim_dcb.status != USIM_GPT_TIMEOUT)\
		GPTI_StopItem(usim_dcb.gpt_handle);	\	
}
#define USIM_SET_EVENT()\
{\
	usim_dcb.sline[(usim_dcb.sindex&(INDEX_COUNT-1))] = __LINE__;\
	dbg_print("set event at line:%d\r\n",__LINE__);\
	usim_dcb.sindex++;\
	kal_set_eg_events(usim_dcb.event,USIM_EVENT,KAL_OR);\
}
#else
#define USIM_WAIT_EVENT()\
{\
	GPTI_StartItem(usim_dcb.gpt_handle,\
                  USIM_GPT_TIMEOUT_PERIOD,\
                  usim_gpt_timeout_handler,\
                  NULL);\
	kal_retrieve_eg_events(usim_dcb.event,USIM_EVENT,KAL_AND_CONSUME,&usim_dcb.ev_flag,KAL_SUSPEND);\
	if(usim_dcb.status != USIM_GPT_TIMEOUT)\
		GPTI_StopItem(usim_dcb.gpt_handle);	\
}
#define USIM_SET_EVENT()\
	kal_set_eg_events(usim_dcb.event,USIM_EVENT,KAL_OR)
#endif


#endif //__USIM_DRV__
#endif // _USIM_DRV_H_