void drv_idc_init_gpio(void) { EINT_Mask(TDM_REQ_HI_EINT_NO); // disable TDM_REQ_HI interrupt EINT_Mask(TDM_REQ_LO_EINT_NO); // disable TDM_REQ_LO interrupt // Level trigger EINT_Set_Sensitivity(TDM_REQ_HI_EINT_NO, KAL_FALSE); EINT_Set_Sensitivity(TDM_REQ_LO_EINT_NO, KAL_FALSE); EINT_Set_HW_Debounce(TDM_REQ_HI_EINT_NO, 0); EINT_Set_HW_Debounce(TDM_REQ_LO_EINT_NO, 0); #if !defined(ATEST_DRV_ENABLE) dhl_trace(TRACE_INFO, 0, IDC_TDM_INIT_MSG); #else kal_sprintf(idc_dbg_str, "drv_idc: TDM_REQ Init\n\r"); DT_IDC_PRINTF(idc_dbg_str); #endif EINT_Registration_and_mask(TDM_REQ_HI_EINT_NO, KAL_TRUE, 1, TDM_REQ_HI_Entry, KAL_FALSE); EINT_Registration_and_mask(TDM_REQ_LO_EINT_NO, KAL_TRUE, 0, TDM_REQ_LO_Entry, KAL_FALSE); EINT_UnMask(TDM_REQ_HI_EINT_NO); // enable TDM_REQ_HI interrupt EINT_UnMask(TDM_REQ_LO_EINT_NO); // enable TDM_REQ_LO interrupt return; }
/************************************************************************* * FUNCTION * EINT_HISR_Entry * * DESCRIPTION * This function implements main external interrupt HISR registered in * global ISR jump table, eint_hisr_func. * * CALLS * * PARAMETERS * * RETURNS * No return * * GLOBALS AFFECTED * *************************************************************************/ void EINT_HISR_Entry(void) { kal_uint8 index; for(index=0;index<EINT_TOTAL_CHANNEL;index++) { if ( !(eint_is_dedicated & (1 << index)) && (EINT_FUNC.eint_active[index] == KAL_TRUE) && (EINT_FUNC.eint_func[index]) ) { EINT_FUNC.eint_active[index] = KAL_FALSE; eint_trigger_src_log[eint_trigger_src_ptr] = index; eint_trigger_src_ptr = (eint_trigger_src_ptr + 1) % EINT_TRIGGER_SRC_LOG_MAX; EINT_FUNC.eint_func[index](); if (EINT_FUNC.eint_auto_umask[index] == KAL_TRUE) { EINT_UnMask(index); } } } }
/************************************************************************* * FUNCTION * EINT_HISR_Entry * * DESCRIPTION * This function implements main external interrupt HISR registered in * global ISR jump table, eint_hisr_func. * * CALLS * * PARAMETERS * * RETURNS * No return * * GLOBALS AFFECTED * *************************************************************************/ void EINT_HISR_Entry(void) { kal_uint8 index; for(index =0; index < EINT_TOTAL_CHANNEL; index++) { if ( (EINT_FUNC.eint_active[index] == KAL_TRUE) && (EINT_FUNC.eint_func[index]) ) { EINT_FUNC.eint_func[index](); EINT_FUNC.eint_active[index] = KAL_FALSE; if (EINT_FUNC.eint_auto_umask[index] == KAL_TRUE) { EINT_UnMask(index); } } } #if ( defined(MT6228) || defined(MT6229) || defined(MT6230) || defined(MT6238)) *IRQ_EOI2 = IRQCode2Line[IRQ_EIT_CODE]; #else *IRQ_EOI = (1 << IRQCode2Line[IRQ_EIT_CODE]); #endif }
/************************************************************************* * FUNCTION * EINT_TIMER_CALLBACK * * DESCRIPTION * This function implements main external interrupt LISR registered in * global ISR jump table. * * CALLS * * PARAMETERS * * RETURNS * No return * * GLOBALS AFFECTED * *************************************************************************/ void DEINT_TIMER_CALLBACK(void *data) { EINT_SW_DEBOUNCE_STRUCT *sw_debounce = (EINT_SW_DEBOUNCE_STRUCT *)data; EINT_Mask(sw_debounce->eint_no); if(sw_debounce->eint_sw_debounce_handle != 0x7f) { DclSGPT_Control(sw_debounce->eint_sw_debounce_handle,SGPT_CMD_STOP,0); DclSGPT_Close(&(sw_debounce->eint_sw_debounce_handle)); } sw_debounce->eint_intr_allow = (sw_debounce->eint_intr_allow == KAL_TRUE)? KAL_FALSE: KAL_TRUE; /* * This timer is to avoid if interrupt status is changed but * sw_debounce->eint_intr_allow is still in KAL_TRUE state * because of no interrupt */ if (sw_debounce->eint_intr_allow) { SGPT_CTRL_START_T start; start.u2Tick= eint_sw_debounce_time_delay[sw_debounce->eint_no]; start.pfCallback=DEINT_TIMER_CALLBACK; start.vPara=data; sw_debounce->eint_sw_debounce_handle=DclSGPT_Open(DCL_GPT_CB,0); DclSGPT_Control(sw_debounce->eint_sw_debounce_handle,SGPT_CMD_START,(DCL_CTRL_DATA_T*)&start); } EINT_UnMask(sw_debounce->eint_no); }
/****************************************************************************** * Function: * GPSLocateVibSensorStart * * Usage: * Start vibration sensor monitor * * Parameters: * None * * Return: * None ******************************************************************************/ void GPSLocateVibSensorStart(void) { if (gGPSVibSensorStart == KAL_TRUE) return; gGPSVibSensorStart = KAL_TRUE; /* * Enabling the eint to detect the vibration sensor status */ EINT_UnMask(GPS_VIBSENSOR_EINT_NO); if (gGPSVibSensorTimer != NULL) { GPSAppTimer_Reset(gGPSVibSensorTimer, GPSLocateVibSensorExpireProc, GPSLOCATE_VIBSENSOR_SILENCETHRESHOLD_DEFAULT*KAL_TICKS_1_MIN, GPSLOCATE_VIBSENSOR_SILENCETHRESHOLD_DEFAULT*KAL_TICKS_1_MIN, KAL_TRUE ); } else { gGPSVibSensorTimer = GPSAppTimer_Create( GENERAL_GPSAPP_TIMERID, GPSLocateVibSensorExpireProc, GPSLOCATE_VIBSENSOR_SILENCETHRESHOLD_DEFAULT*KAL_TICKS_1_MIN, GPSLOCATE_VIBSENSOR_SILENCETHRESHOLD_DEFAULT*KAL_TICKS_1_MIN, KAL_TRUE ); } }
kal_bool CHR_USB_EINT_UnMask(CHR_DET_EINT_OWNER Owner) { kal_uint32 savedMask; kal_uint32 eint; #if (!defined(DRV_MISC_CHR_USB_EINT_CENTRAL_UNMASK)) // If CENTRAL control is NOT enabled, we filter out USB owner control // ==> Just ignore USB request, the EINT unmask control is controlled by PMIC only if (Owner == CHR_DET_EINT_OWNER_USB){ return KAL_FALSE; }else{ EINT_UnMask(chr_usb_detect.chr_usb_eint); return KAL_TRUE; } #endif // #if defined(DRV_MISC_CHR_USB_EINT_CENTRAL_UNMASK) eint = (kal_uint32)chr_usb_detect.chr_usb_eint; // Force to unmask EINT // For some cases, our driver may trigger the EINT (Ex: OTG) // In this situation, we do NOT need central control // Because it is a false alarm trigger if (Owner == USB_DET_EINT_OWNER_FORCE_UNMASK){ savedMask = SaveAndSetIRQMask(); chr_usb_eint_mask = 0; EINT_UnMask((kal_uint8)eint); RestoreIRQMask(savedMask); return KAL_TRUE; } savedMask = SaveAndSetIRQMask(); chr_usb_eint_mask |= (kal_uint8)Owner; if (chr_usb_eint_mask == chr_usb_eint_owner_mask){ EINT_UnMask((kal_uint8)eint); // Reset the flag chr_usb_eint_mask = 0; } RestoreIRQMask(savedMask); return (chr_usb_eint_mask==0?KAL_TRUE:KAL_FALSE); }
/**************************************************************************** * FUNCTION * JogBall_RIGHT_HISR * DESCRIPTION * Register the call back functions * * * PARAMETERS * void * RETURNS * void *****************************************************************************/ void JogBall_RIGHT_HISR(void) { EINT_Mask(eint_chans_right); if(JBXY == KEY_RIGHT_EVENT) { kbd_SendKey(DEVICE_KEY_RIGHT); JBXY=KEY_DIRECTION_EVENT_NUll; } else { JBXY=KEY_RIGHT_EVENT; } EINT_UnMask(eint_chans_right); }
void JogBall_DOWN_HISR(void) { EINT_Mask(eint_chans_down); if(JBXY == KEY_DOWN_EVENT) { kbd_SendKey(DEVICE_KEY_DOWN); JBXY=KEY_DIRECTION_EVENT_NUll; } else { JBXY=KEY_DOWN_EVENT; } EINT_UnMask(eint_chans_down); }
void TDM_REQ_HI_Entry(void) { IDC_ILM_MSG_T tmp; tmp.type = 3; tmp.msg = 100; // send msg to EL2 that LTE_TX is not Allowed #if !defined(ATEST_DRV_ENABLE) dhl_trace(TRACE_INFO, 0, IDC_TDM_HI_MSG); #else kal_sprintf(idc_dbg_str, "TDM_REQ_HI_Entry\n\r"); DT_IDC_PRINTF(idc_dbg_str); #endif msg_send_inline6(DRV_IDC_HISR_ID, idc_port.owner_id, DRIVER_PS_SAP | INLINE_ILM_FLAG_SAP, MSG_ID_IDC_RX_DATA, (void *) &tmp, sizeof(IDC_ILM_MSG_T)); EINT_UnMask(TDM_REQ_LO_EINT_NO); }
/************************************************************************* * FUNCTION * EINT_TIMER_CALLBACK * * DESCRIPTION * This function implements main external interrupt LISR registered in * global ISR jump table. * * CALLS * * PARAMETERS * * RETURNS * No return * * GLOBALS AFFECTED * *************************************************************************/ void EINT_TIMER_CALLBACK(void *data) { EINT_SW_DEBOUNCE_STRUCT *sw_debounce = (EINT_SW_DEBOUNCE_STRUCT *)data; GPTI_StopItem(sw_debounce->eint_sw_debounce_handle); sw_debounce->eint_intr_allow = (sw_debounce->eint_intr_allow == KAL_TRUE)? KAL_FALSE: KAL_TRUE; /* * This timer is to avoid if interrupt status is changed but * sw_debounce->eint_intr_allow is still in KAL_TRUE state * because of no interrupt */ if (sw_debounce->eint_intr_allow) { GPTI_StartItem(sw_debounce->eint_sw_debounce_handle, eint_sw_debounce_time_delay[sw_debounce->eint_no], /*0.5 second*/ EINT_TIMER_CALLBACK, data); } EINT_UnMask(sw_debounce->eint_no); }
/************************************************************************* * FUNCTION * EINT_RestoreMask * * DESCRIPTION * This function restores the MASK of the specified external interrupt * * PARAMETERS * val - value to restore * * RETURNS * No return * *************************************************************************/ void EINT_RestoreMask(kal_uint8 eintno, kal_uint32 val) { kal_uint32 savedMask; /* lockout interrupt */ savedMask = SaveAndSetIRQMask(); /* * NoteXXX: The external interrup should already be masked here (via the * EINT_SaveAndMask() call). Only need to change the EINT_MASK * when the external interrupt is originally un-masked. */ if (val == 0) { EINT_UnMask(eintno); } /* un-lockout interrupt */ RestoreIRQMask(savedMask); }
/************************************************************************* * FUNCTION * DEINT_HISR_Entry * * DESCRIPTION * This function implements main dedicated external interrupt HISR registered in * global ISR jump table, eint_hisr_func. * * CALLS * * PARAMETERS * * RETURNS * No return * * GLOBALS AFFECTED * *************************************************************************/ void DEINT_HISR_Entry(void) { kal_uint8 index; for(index=0;index<EINT_TOTAL_CHANNEL;index++) { if (eint_is_dedicated & (1 << index)) { if ( (EINT_FUNC.eint_active[index] == KAL_TRUE) && (EINT_FUNC.eint_func[index]) ) { EINT_FUNC.eint_active[index] = KAL_FALSE; EINT_FUNC.eint_func[index](); if (EINT_FUNC.eint_auto_umask[index] == KAL_TRUE) { EINT_UnMask(index); } } } } }
/************************************************************************* * FUNCTION * CHRDET_USB_HISR * * DESCRIPTION * 1. HISR of charger and usb external interrupt * * PARAMETERS * None * * RETURNS * None * * GLOBALS AFFECTED * *************************************************************************/ static void CHR_USB_EINT_HISR(void) { #ifdef __OTG_ENABLE__ static kal_bool g_usb_host_turn_on_vbus = KAL_FALSE; #endif // #ifdef __OTG_ENABLE__ //#if defined(PMIC_6305_REG_API) || defined(PMIC_6318_REG_API) || defined(PMIC_6238_REG_API) || defined(PMIC_6326_REG_API) || defined(PMIC_6253_REG_API) || defined(PMIC_6236_REG_API) || defined(PMIC_6276_REG_API) || defined(PMIC_6255_REG_API) #if defined(PMIC_CHR_USB_DET_EINT_LEVEL_ACTIVE_HIGH) EINT_Set_Polarity(chr_usb_detect.chr_usb_eint, (kal_bool)(chr_usb_detect.chr_usb_state)); #endif // #if defined(PMIC_CHR_USB_DET_EINT_LEVEL_ACTIVE_HIGH) #if defined(PMIC_CHR_USB_DET_EINT_LEVEL_ACTIVE_LOW) EINT_Set_Polarity(chr_usb_detect.chr_usb_eint, (kal_bool)(!chr_usb_detect.chr_usb_state)); #endif // #if defined(PMIC_CHR_USB_DET_EINT_LEVEL_ACTIVE_LOW) #if defined(PMIC_6326_REG_API) //if (pmic_chrdet_status() == chr_usb_detect.chr_usb_state){ // ASSERT(0); // There is problem!!!! Because whenever the program goes here, we should get invert state // // In => Out => In => Out //} { PMU_CTRL_CHR_GET_CHR_DET_STATUS chrStatus; DclPMU_Control(chrDet_PmuHandler, CHR_GET_CHR_DET_STATUS, (DCL_CTRL_DATA_T *)&chrStatus); if (chrStatus.enable== chr_usb_detect.chr_usb_state) { // When the detected status is same as the current state, do nothing! //kal_prompt_trace(MOD_BMT,"CHRDet status is same as chr_usb_state"); EINT_UnMask(chr_usb_detect.chr_usb_eint); // unmask eint here, otherwise it never comes interrupt again. //CHR_USB_EINT_Owner_SetMask(CHR_DET_EINT_OWNER_BMT); // Set owner mask flag of BMT //CHR_USB_EINT_UnMask(CHR_DET_EINT_OWNER_BMT); // EINT_UnMask(chr_usb_detect.chr_usb_eint); return; } } #endif // #if defined(PMIC_6326_REG_API) chr_usb_detect.chr_usb_state = (kal_bool)(!((kal_uint8)chr_usb_detect.chr_usb_state)); if (chr_usb_detect.chr_usb_state) { //kal_prompt_trace(MOD_BMT,"CHR_USB IN"); kal_brief_trace( TRACE_STATE,BMT_CABLE_IN_TRC); #ifdef __USB_UART_MULTIPLEXED_WITH_EXT_SWITCH__ GPIO_WriteIO(1, gpio_usb_uart_switch_pin); //switch to usb mode #endif #ifdef __OTG_ENABLE__ { DCL_HANDLE otg_dcl_handle; DCL_BOOL dcl_data; kal_bool b_is_host_on_vbus; otg_dcl_handle = DclOTG_DRV_Open(DCL_USB, FLAGS_NONE); DclOTG_DRV_Control(otg_dcl_handle, OTG_DRV_CMD_IS_HOST_TURN_ON_VBUS, (DCL_CTRL_DATA_T *)&dcl_data); b_is_host_on_vbus = (kal_bool)dcl_data; DclOTG_DRV_Close(otg_dcl_handle); if (b_is_host_on_vbus== KAL_TRUE) { g_usb_host_turn_on_vbus = KAL_TRUE; // Force to unmask EINT for OTG case CHR_USB_EINT_UnMask(USB_DET_EINT_OWNER_FORCE_UNMASK); // EINT_UnMask(chr_usb_detect.chr_usb_eint); return; } } #endif // #ifdef __OTG_ENABLE__ // Clear EINT owner bit mask CHR_USB_EINT_Owner_ClrMask(); ASSERT(chr_usb_det_mgr.pw_is_charger_usb_det_eint != NULL); chr_usb_det_mgr.pw_is_charger_usb_det_eint(); } else { #ifdef __USB_UART_MULTIPLEXED_WITH_EXT_SWITCH__ GPIO_WriteIO(0, gpio_usb_uart_switch_pin); //switch to uart mode #endif #ifdef __OTG_ENABLE__ if (g_usb_host_turn_on_vbus == KAL_TRUE) { g_usb_host_turn_on_vbus = KAL_FALSE; // Force to unmask EINT for OTG case CHR_USB_EINT_UnMask(USB_DET_EINT_OWNER_FORCE_UNMASK); // EINT_UnMask(chr_usb_detect.chr_usb_eint); return; } #endif // #ifdef __OTG_ENABLE__ CHR_USB_PLUG_OUT(); } }
/* * FUNCTION * CHRDET_HISR * * DESCRIPTION * This function is the interrupt handler for EINT1 * * CALLS * * PARAMETERS * None * * RETURNS * None * * GLOBALS AFFECTED * None */ void CHRDET_HISR(void) { #ifndef __DRV_NO_USB_CHARGER__ extern void bmt_charger_action(kal_bool in); #endif /*__DRV_NO_USB_CHARGER__*/ kal_uint32 state; #if defined(PMIC_6326_REG_API) static kal_bool chr_status = KAL_FALSE; #endif // #if defined(PMIC_6326_REG_API) #if defined(PMIC_6326_REG_API) { PMU_CTRL_CHR_GET_CHR_DET_STATUS chrStatus; DclPMU_Control(chrDet_PmuHandler, CHR_GET_CHR_DET_STATUS, (DCL_CTRL_DATA_T *)&chrStatus); DclPMU_Close(chrDet_PmuHandler); if (chr_status == chrStatus.enable){ #if ( (!defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)) && defined(PMIC_6326_REG_API) ) #if (!defined(__DRV_EXT_CHARGER_DETECTION__)) EINT_UnMask(gCHRDET_EINT_NO); #endif // #if (!defined(__DRV_EXT_CHARGER_DETECTION__)) #endif // #if ( (!defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)) && defined(PMIC_6326_REG_API) ) return; } } chr_status =(kal_bool)(!((kal_uint8)chr_status)); if (chr_status == KAL_TRUE){ state = DETECTCHRIN; }else{ state = DETECTCHROUT; } // Should PMIC6326 update the flag? BMT.EINT2STATE = !state; #else // #if defined(PMIC_6326_REG_API) BMT.EINT2STATE = !BMT.EINT2STATE; #if (!defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__) ) #if (!defined(__DRV_EXT_CHARGER_DETECTION__)) chrdet_level_config(BMT.EINT2STATE); #endif // #if (!defined(__DRV_EXT_CHARGER_DETECTION__)) #endif // #if ( (!defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)) && ( defined(PMIC_6305_REG_API) || defined(PMIC_6223_REG_API)|| defined(PMIC_6238_REG_API) || defined(PMIC_6253_REG_API) || defined(PMIC_6236_REG_API) || defined(PMIC_6251_REG_API)) ) state = !BMT.EINT2STATE; #endif // #if defined(PMIC_6326_REG_API) if (state == DETECTCHRIN) { //DclPMU_Control(chrDet_PmuHandler, CHR_SET_CV_DETECTION_VOLTAGE_CALIBRATION, NULL); #ifdef BMT_DEBUG dbg_printWithTime("CHARGER_PLUGIN\r\n"); #endif // #ifdef BMT_DEBUG #if defined(__DRV_BMT_PRECHARGE_TO_FULL_DIRECTLY__) BMT_VbatInHISR(); //save current vbat, otherwise turn on LCD backlight may cause VBAT decrease. #endif //#if defined(__DRV_BMT_PRECHARGE_TO_FULL_DIRECTLY__) bmt_set_chr_status(bmt_chr_in); #ifndef __DRV_NO_USB_CHARGER__ bmt_charger_action(KAL_TRUE); #endif // #ifndef __DRV_NO_USB_CHARGER__ } else { #ifdef BMT_DEBUG dbg_printWithTime("CHARGER_PLUGOUT\r\n"); #endif // #ifdef BMT_DEBUG bmt_set_chr_status(bmt_chr_out); #ifndef __DRV_NO_USB_CHARGER__ bmt_charger_action(KAL_FALSE); #endif // #ifndef __DRV_NO_USB_CHARGER__ } #if ( (!defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)) ) #if (!defined(__DRV_EXT_CHARGER_DETECTION__)) EINT_UnMask(gCHRDET_EINT_NO); #endif // #if (!defined(__DRV_EXT_CHARGER_DETECTION__)) #endif // #if ( (!defined(__CHARGER_USB_DETECT_WIHT_ONE_EINT__)) ) }
/************************************************************************* * FUNCTION * Register_EINT * * DESCRIPTION * This function implements registration of external interrupts * * CALLS * * PARAMETERS * eintno - External interrupt vector number * Dbounce_En - Debounce control enable * ACT_Polarity - Interrupt polarity * reg_hisr - Registered hisr * auto_umask - A flag instruct the systerm to do unmask after * invoking the registered HISR * * RETURNS * No return * * GLOBALS AFFECTED * *************************************************************************/ void EINT_Registration(kal_uint8 eintno, kal_bool Dbounce_En, kal_bool ACT_Polarity, void (reg_hisr)(void), kal_bool auto_umask) { // PDN_CLR(PDN_GPIO); kal_uint32 savedMask; /* If EINT Number is out of range, get return address and send it to exception handler */ if(eintno >= EINT_TOTAL_CHANNEL) { kal_uint32 retaddr; GET_RETURN_ADDRESS(retaddr); kal_fatal_error_handler(KAL_ERROR_DRV_EINT_INVALID_INDEX, retaddr); } /*disable eint interrupt*/ eint_set_irqen(eintno, EINT_DISABLE); /*register LISR*/ /*dispatch for dedicated eint*/ if (eint_is_dedicated & (1<<eintno)) { switch(eint_is_dedicated_map[eintno]) { case DEDICATED_EINT0: { eint_set_l1_eint_enable(DEDICATED_EINT0, EINT_DISABLE); IRQ_Register_LISR(DEDICATED_EINT_IRQ0, DEINT0_LISR, "DEINT0 handler"); } break; case DEDICATED_EINT1: { eint_set_l1_eint_enable(DEDICATED_EINT1, EINT_DISABLE); IRQ_Register_LISR(DEDICATED_EINT_IRQ1, DEINT1_LISR, "DEINT1 handler"); } break; case DEDICATED_EINT2: { eint_set_l1_eint_enable(DEDICATED_EINT2, EINT_DISABLE); IRQ_Register_LISR(DEDICATED_EINT_IRQ2, DEINT2_LISR, "DEINT2 handler"); } break; case DEDICATED_EINT3: { eint_set_l1_eint_enable(DEDICATED_EINT3, EINT_DISABLE); IRQ_Register_LISR(DEDICATED_EINT_IRQ3, DEINT3_LISR, "DEINT3 handler"); } break; default: break; } } else { IRQ_Register_LISR(IRQ_EIT_CODE, EINT_LISR, "EINT handler"); } /* Save and set MCU's I,F bits to disable interrupts */ // savedMask = LockIRQ(); /* Set external interrupt polarity */ EINT_Set_Polarity(eintno,ACT_Polarity); #if !defined(MT6290) gpio_set_eint_src(eintno,eint_src_map[eintno]); #endif if (Dbounce_En) { //eint_set_debounce_duration(eintno,EINT_DB_DUR_DEFAULT); eint_set_debounce_enable(eintno,EINT_ENABLE); } else { /*disable debounce */ eint_set_debounce_enable(eintno,EINT_DISABLE); } /* Save and set MCU's I,F bits to disable interrupts */ savedMask = SaveAndSetIRQMask(); /* Register external interrupt's HISR */ EINT_FUNC.eint_func[eintno] = reg_hisr; EINT_FUNC.eint_active[eintno] = KAL_FALSE; EINT_FUNC.eint_auto_umask[eintno] = auto_umask; if (eint_is_dedicated & (1<<eintno)) { /* register HISR */ DRV_Register_HISR(DRV_DEINT_HISR_ID, DEINT_HISR_Entry); EINT_L2_ACK(eintno); EINT_UnMask(eintno); RestoreIRQMask(savedMask); } else { /* register HISR */ DRV_Register_HISR(DRV_EINT_HISR_ID, EINT_HISR_Entry); EINT_L2_ACK(eintno); EINT_UnMask(eintno); IRQSensitivity( IRQ_EIT_CODE, LEVEL_SENSITIVE ); /* Enable external interrupt */ IRQUnmask( IRQ_EIT_CODE ); RestoreIRQMask(savedMask); } }