void USB_LOGGING_DSP_Drv_Create_ISR(void) { IRQ_Register_LISR(IRQ_IRDEBUG1_CODE, USB_LOGGING_DSP1_LISR, "USB_LOGGING_DSP1"); DRV_Register_HISR(DRV_USB_LOGGING_DSP1_HISR_ID, USB_LOGGING_DSP1_HISR); #if !defined(DRV_USB_LOGGING_V5_SINGLE_DSP) IRQ_Register_LISR(IRQ_IRDEBUG2_CODE, USB_LOGGING_DSP2_LISR, "USB_LOGGING_DSP2"); DRV_Register_HISR(DRV_USB_LOGGING_DSP2_HISR_ID, USB_LOGGING_DSP2_HISR); #endif }
void drv_idc_init_uart(void) { #if defined(MT6290) DRV_WriteReg32(BASE_ADDR_MDINFRAMISC + 0x114, DRV_Reg32(BASE_ADDR_MDINFRAMISC + 0x114) | 0x6); DRV_WriteReg32(BASE_ADDR_MDPERIMISC + 0x114, DRV_Reg32(BASE_ADDR_MDPERIMISC + 0x114) | 0x4); #if __FPGA__ #else // set GPIO as default output DRV_WriteReg32_NPW(BASE_ADDR_TOPMISC + 0x1D4, DRV_Reg32(BASE_ADDR_TOPMISC + 0x1D4) | 0x200); #endif #endif #if defined(MT6595) // Enable GPIO 29, 30 pull-up/pull-down DRV_WriteReg32(GPIO_base + 0x110, DRV_Reg32(GPIO_base + 0x110) | 0x6000); // Select GPIO 29, 30 pull-up DRV_WriteReg32(GPIO_base + 0x210, DRV_Reg32(GPIO_base + 0x210) | 0x6000); #endif #if !defined(ATEST_DRV_ENABLE) dhl_trace(TRACE_INFO, 0, IDC_UART_INIT_MSG); #else kal_sprintf(idc_dbg_str, "drv_idc: IDC UART Init\n\r"); DT_IDC_PRINTF(idc_dbg_str); #endif // register isr, enable RX data receive interrupt IRQMask(MD_IRQID_IDC2ARM); // Initialize IDC UART FIFO threshold drv_idc_set_fifo_trigger(1); DRV_WriteReg32(IDC_UART_FCR, IDC_UART_FCR_RXTRIG | IDC_UART_FCR_FIFOINI); DRV_WriteReg32(IDC_UART_IER, IDC_UART_IER_ERBFI); IRQ_Register_LISR(MD_IRQID_IDC2ARM, idc_uart_lisr, "IDC_UART"); DRV_Register_HISR(DRV_IDC_HISR_ID, idc_uart_hisr); IRQSensitivity(MD_IRQID_IDC2ARM, KAL_FALSE); IRQClearInt(MD_IRQID_IDC2ARM); IRQUnmask(MD_IRQID_IDC2ARM); idc_port.intr_en = KAL_TRUE; idc_port.schedule_state[0] = IDC_PLAN; idc_port.schedule_state[1] = IDC_PLAN; idc_port.event_cnt[0] = 0; idc_port.event_cnt[1] = 0; idc_port.sram_w_ptr = 3; // 2'b11 idc_port.sram_usage_bit_map[0] = 0; idc_port.sram_usage_bit_map[1] = 0; idc_port.rx_buf = 0; // Initialize baud rate drv_idc_set_baudrate(4000000); // initial flags/config of IDC driver idc_port.main_state = IDC_IN_USE; return; }
/*----------------------------------------------------------------------- * FUNCTION * DclSGPT_Initialize * * DESCRIPTION * This function is to initialize SW GPT module. * * PARAMETERS * DCL_STATUS_OK * * RETURNS * none * *------------------------------------------------------------------------*/ DCL_STATUS DclSGPT_Initialize(void) { kal_uint8 index; DCL_GPT_BUS_CLOCK_ON(); /* GPT hardware reset */ drv_gpt_reset(); IRQ_Register_LISR(MDGPT_INTR_ID(DRV_GPT_CALLBACK_TIMER), GPTCB_Lisr, "GPTCBMS"); IRQ_Register_LISR(MDGPT_INTR_ID(DRV_GPT_CBUS_TIMER), GPTCB_US_Lisr, "GPTCBUS"); IRQ_Register_LISR(MDGPT_INTR_ID(DRV_GPT_DEBUG_TIMER), GPT_DEBUG_Lisr, "GPTDEBUG"); #if defined (__MTK_TARGET__) && !defined(__GPTDEBUG_HISR_DISABLE__) && defined(__LTE_RAT__) gpt_debug_hisr = kal_init_hisr(GPT_DEBUG_HISR); #endif /* set gpt CB timer */ drv_gpt_set_timer(DRV_GPT_CALLBACK_TIMER, DCL_GPT_CB_TICK2US, MDGPT_CTRL_MODE_REPEAT); /* set gpt CBUS timer */ drv_gpt_set_timer(DRV_GPT_CBUS_TIMER, DCL_GPT_CBUS_TICK2US, MDGPT_CTRL_MODE_REPEAT); /* set gpt Debug timer, tick unit = us */ drv_gpt_set_timer(DRV_GPT_DEBUG_TIMER, DCL_GPT_CBUS_TICK2US, MDGPT_CTRL_MODE_ONESHOT); /* set OS timer */ drv_gpt_set_timer(DRV_GPT_SYSTEM_TIMER, KAL_MICROSECS_PER_TICK, MDGPT_CTRL_MODE_REPEAT); /* gptCB variables are initialized in BSS reset procedure */ /* Register the GPT CB HISR */ DRV_Register_HISR(DRV_GPT1_HISR_ID, GPTCB_10MS_HISR); DRV_Register_HISR(DRV_GPT2_HISR_ID, GPTCB_US_HISR); for (index = 0; index < MAX_GPT_ITEMS; index++) { gptCB_items[index].gptimer_func = GPT_ERROR_CB; gpt_DEBUG_items[index].gptimer_func = GPT_ERROR_CB; } IRQUnmask(MDGPT_INTR_ID(DRV_GPT_CALLBACK_TIMER)); IRQUnmask(MDGPT_INTR_ID(DRV_GPT_CBUS_TIMER)); IRQUnmask(MDGPT_INTR_ID(DRV_GPT_DEBUG_TIMER)); IRQUnmask(MDGPT_INTR_ID(DRV_GPT_SYSTEM_TIMER)); DCL_GPT_BUS_CLOCK_OFF(); return STATUS_OK; }
/* * FUNCTION * GPTI_init * * DESCRIPTION * Initialize the GPTI module with GPT * * CALLS * * PARAMETERS * None * * RETURNS * None * * GLOBALS AFFECTED * external_global */ void GPTI_init(void) { if (GPTTimer.hisr == NULL) { //GPTTimer.hisr = kal_create_hisr("GPTIMER",2,512,GPTI_HISR,NULL); GPTTimer.hisr= (void*)0x1234; DRV_Register_HISR(DRV_GPT_HISR_ID, GPTI_HISR); } GPT_init(gptimer_num,GPTI_Callback); GPT_ResetTimer(gptimer_num,gptimer_interval-1,KAL_TRUE); GPTTimer.GPT_TICK = 0; GPTTimer.MAX_GPTIMER_ITEMS = 0; GPTTimer.GPTSTOP = KAL_TRUE; GPTTimer.status =0; }
/************************************************************************* * FUNCTION * mdci_init * * DESCRIPTION * This function initialized MDIF. * * PARAMETERS * arb - arbitration mode flag * md_offset - modem side master offset address(in bytes). * * RETURNS * none * *************************************************************************/ void mdci_hw_init(kal_uint32 arb, kal_uint32 md_offset) { /* set arbitration mode */ if (arb == 1) { *MDIF_CON |= MDIF_CON_ARB; } /* initialize the MD side address offset */ mdci_md_offset = md_offset; /* register LISR */ #if defined(MDIF_FOR_AP_SIDE) IRQ_Register_LISR(IRQ_APMDIF_CODE, mdci_lisr, "MDIF LISR"); #else IRQ_Register_LISR(IRQ_MDIF_CODE, mdci_lisr, "MDIF LISR"); #endif #ifndef __IVP__ /* register HISR */ DRV_Register_HISR(DRV_MDIF_HISR_ID, mdci_hisr); #endif /* __IVP__ */ /* set IRQ sensitivity */ #if defined(MDIF_FOR_AP_SIDE) IRQSensitivity(IRQ_APMDIF_CODE, LEVEL_SENSITIVE); #else IRQSensitivity(IRQ_MDIF_CODE, LEVEL_SENSITIVE); #endif /* unmask MDIF */ #if defined(MDIF_FOR_AP_SIDE) IRQUnmask(IRQ_APMDIF_CODE); #else IRQUnmask(IRQ_MDIF_CODE); #endif }
void EINT_Registration(kal_uint8 eintno, kal_bool Dbounce_En, kal_bool ACT_Polarity, \ void (reg_hisr)(void), kal_bool auto_umask) { kal_uint32 savedMask; kal_uint16 count; EXT_ASSERT(eintno < EINT_TOTAL_CHANNEL, eintno, Dbounce_En, ACT_Polarity); 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 */ if (ACT_Polarity) EINTaddr(eintno) |= EINT_CON_HIGHLEVEL; else EINTaddr(eintno) &= ~(EINT_CON_HIGHLEVEL); /* * NoteXXX: Only EINT 0 ~ (EINT_MAX_CHANNLE - 1) support level trigger. * The de-bounce time is only for level trigger EINT. */ if (eintno < EINT_MAX_CHANNEL) { /* Set external interrupt debounce control enable or not */ if (Dbounce_En) { /* check if debounce is enabled */ if (EINTaddr(eintno) & EINT_CON_DEBOUNCE_EN) { /* debounce value is already set; NOP */ } else { EINTaddr(eintno) |= (EINT_CON_DEBOUNCE | EINT_CON_DEBOUNCE_EN); } } else { /*disable debounce */ EINTaddr(eintno) &= ~(EINT_CON_DEBOUNCE_EN); } } /* 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; /* register HISR */ DRV_Register_HISR(DRV_EINT_HISR_ID, EINT_HISR_Entry); /* Restore previous MCU's I,F bits setting */ RestoreIRQ(savedMask); /* * XXX!!!. Hardware bug * - must wait for 32khz/1 sec to write mask register, will be * fixed in future. */ for (count=0; count<250; count++) ; /*250:52M*/ savedMask = LockIRQ(); *EINT_INTACK = EINT_INTACK_EINT(eintno); #if defined(MT6205) || defined(MT6208) || defined(FPGA) *EINT_MASK &= ~(0x0001 << eintno); #else *EINT_MASK_CLR = (0x0001 << eintno); #endif RestoreIRQ(savedMask); /* Set external interrupt is level sensitive */ #if !defined(__DIRECTION_SENSOR_SUPPORT__) if( (0) #if defined(__DIRECTION_SENSOR_SUPPORT__) || eintno == MOTION_SENSOR_EINT_NO1 || eintno == MOTION_SENSOR_EINT_NO2 #endif ) { IRQSensitivity(IRQ_EIT_CODE,EDGE_SENSITIVE); }else{ IRQSensitivity(IRQ_EIT_CODE,LEVEL_SENSITIVE); } #endif /* Enable external interrupt */ IRQUnmask(IRQ_EIT_CODE); }
void EINT_Registration_and_mask(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); } }
void hif_init(void) { // Init structure. memset(hif_internal_handle, 0, sizeof(hif_internal_handle)); #if defined (HIF0_CHANNEL_SUPPORT) // Init HIF interrupr IRQ_Register_LISR(IRQ_HIF_CODE, hif0_lisr, "HIF0 ISR"); IRQSensitivity(IRQ_HIF_CODE, LEVEL_SENSITIVE); //hif_hisr_id[0] = kal_create_hisr("HIF0_HISR", 0, 1024, hif0_hisr, KAL_TRUE); DRV_Register_HISR(DRV_HIF0_HISR_ID, hif0_hisr); IRQUnmask(IRQ_HIF_CODE); #endif #if defined (HIF1_CHANNEL_SUPPORT) IRQ_Register_LISR(IRQ_HIF_1_CODE, hif1_lisr, "HIF1 ISR"); IRQSensitivity(IRQ_HIF_1_CODE, LEVEL_SENSITIVE); //hif_hisr_id[1] = kal_create_hisr("HIF1_HISR", 0, 1024, hif1_hisr, KAL_TRUE); DRV_Register_HISR(DRV_HIF1_HISR_ID, hif1_hisr); IRQUnmask(IRQ_HIF_1_CODE); #endif /* DMA initialization */ #if defined (HIF0_CHANNEL_SUPPORT) hif_sysdma_id[0] = DMA_GetChannel(DMA_HIF0); hif_dma_menu[0].TMOD.burst_mode = KAL_FALSE; hif_dma_menu[0].master = DMA_HIF0; hif_dma_menu[0].addr = 0; #endif #if defined (HIF1_CHANNEL_SUPPORT) hif_sysdma_id[1] = DMA_GetChannel(DMA_HIF1); hif_dma_menu[1].TMOD.burst_mode = KAL_FALSE; hif_dma_menu[1].master = DMA_HIF1; hif_dma_menu[1].addr = 0; #endif // Configure DMA //hif_dma_input.size = DMA_SHORT; hif_dma_input[0].count = 0; hif_dma_input[0].callback = NULL; hif_dma_input[1].count = 0; hif_dma_input[1].callback = NULL; //hif_dma_input.menu = (void*) &hif_dma_menu; //define ECO solution for MT6256E4,MT6575E2, MT6255E2 or MTK later chips #if defined(MT6255) || defined(MT6256)//MT6255 and MT6256 support query chip version chip_version = INT_SW_SecVersion(); //Query chip version #endif #if defined(__AST_TL1_TDD__) //HIF ECO only support for TDD project #if defined(MT6575_S01) hif_eco_support = KAL_FALSE; #elif defined(MT6752) hif_eco_support = KAL_TRUE; #elif defined(MT6255) //MT6255E2 support HIF ECO if(SW_SEC_0 != chip_version) { hif_eco_support = KAL_TRUE; } #elif defined(MT6256) //MT6256E4,MT6256E5 support HIF ECO if(SW_SEC_1 == chip_version) //SW_SEC_0: MT6256E2,E3,E4, SW_SEC_1: MT6256E5 { hif_eco_support = KAL_TRUE; } #endif #endif hif_events = kal_create_event_group("HIFDrv"); }