| /***************************************************************************** |
| * Copyright Statement: |
| * -------------------- |
| * This software is protected by Copyright and the information contained |
| * herein is confidential. The software may not be copied and the information |
| * contained herein may not be used or disclosed except with the written |
| * permission of MediaTek Inc. (C) 2012 |
| * |
| * BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES |
| * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE") |
| * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON |
| * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES, |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT. |
| * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE |
| * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR |
| * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH |
| * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO |
| * NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S |
| * SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM. |
| * |
| * BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE |
| * LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE, |
| * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE, |
| * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO |
| * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. |
| * |
| * THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE |
| * WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF |
| * LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND |
| * RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER |
| * THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC). |
| * |
| *****************************************************************************/ |
| |
| |
| /***************************************************************************** |
| * |
| * Filename: |
| * --------- |
| * dcl_gpt.c |
| * |
| * Project: |
| * -------- |
| * TATAKA |
| * |
| * Description: |
| * ------------ |
| * This Module defines DCL (Driver Common Layer) of the GPT driver. |
| * |
| * Author: |
| * ------- |
| * ------- |
| * |
| *============================================================================ |
| * HISTORY |
| * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!! |
| *------------------------------------------------------------------------------ |
| * |
| * |
| *------------------------------------------------------------------------------ |
| * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!! |
| *============================================================================ |
| ****************************************************************************/ |
| |
| #include "drv_features_gpt.h" |
| #include "drv_comm.h" |
| #include "drv_gpt.h" |
| #include "intrCtrl.h" |
| #include "us_timer.h" |
| |
| |
| #include "dcl_gpt.h" |
| #include "dcl_gpt_hw.h" |
| #include "dcl.h" |
| #include "devdrv_ls.h" |
| #include "kal_general_types.h" |
| #include "kal_public_api.h" |
| #include "drvpdn.h" |
| #include "init_comm.h" |
| #include "kal_hrt_api.h" |
| |
| #if defined(__LP_SCHEDULE_HMU_RESCHEDULE__) |
| #include "tg_hisr.h" |
| #endif /* __LP_SCHEDULE_HMU_RESCHEDULE__ */ |
| |
| |
| //#define DCL_GPT_INTERFACE |
| //#ifdef DCL_GPT_INTERFACE |
| |
| #if !defined(DRV_GPT_OFF) |
| |
| /***************************************************************************** |
| * Symbol/Type Definition * |
| *****************************************************************************/ |
| //DCL_GPT_CB this software gpt provide register callback function. |
| #if !defined(__MD93__) |
| #define DCL_GPT_9_MAGIC_NUM (0x01000000) |
| #endif |
| #define DCL_GPT_CB_MAGIC_NUM (0x02000000) |
| |
| #if defined(__MD93__) || defined(__MD95__) |
| #define DCL_GPT_C2KOS_MAGIC_NUM (0x04000000) |
| #else |
| #define DCL_GPT_6_MAGIC_NUM (0x04000000) |
| #endif |
| |
| #define DCL_GPT_C2KAR_MAGIC_NUM (0x08000000) |
| |
| #define DCL_GPT_CBUS_MAGIC_NUM (0x10000000) |
| |
| #define DCL_GPT_3_MAGIC_NUM (0x20000000) |
| |
| #define DCL_GPT_DSP_MAGIC_NUM (0x40000000) |
| |
| #define DCL_GPT_LOGGING_MAGIC_NUM (0x80000000) |
| |
| #define DCL_GPT_CB_TICK2US (10000U) |
| #define DCL_GPT_CBUS_TICK2US (1U) |
| #define DCL_GPT_LOGGING_TICK2US (1000U) |
| #define DCL_GPT_C2K_TICK2US (1000U) |
| |
| #define MDGPTM_PDN_SET() PDN_SET(PDN_GPT); |
| #define MDGPTM_PDN_CLR() PDN_CLR(PDN_GPT); |
| |
| /***************************************************************************** |
| * Macro Function Definition * |
| *****************************************************************************/ |
| |
| #define DCL_GPT_CB_IS_HANDLE_MAGIC(handl_) ((handl_)& DCL_GPT_CB_MAGIC_NUM) |
| #define DCL_GPT_CB_GET_DEV(handle_) ((handle_) & (~DCL_GPT_CB_MAGIC_NUM)) |
| #define DCL_GPT_CBUS_IS_HANDLE_MAGIC(handl_) ((handl_)& DCL_GPT_CBUS_MAGIC_NUM) |
| #define DCL_GPT_3_IS_HANDLE_MAGIC(handl_) ((handl_)& DCL_GPT_3_MAGIC_NUM) |
| #define DCL_GPT_3_GET_DEV(handle_) ((handle_) & (~DCL_GPT_3_MAGIC_NUM)) |
| #if !defined(__MD93__) |
| #define DCL_GPT_9_IS_HANDLE_MAGIC(handl_) ((handl_)& DCL_GPT_9_MAGIC_NUM) |
| #endif |
| #if defined(__MD93__) || defined(__MD95__) |
| #define DCL_GPT_C2KOS_IS_HANDLE_MAGIC(handl_) ((handl_)& DCL_GPT_C2KOS_MAGIC_NUM) |
| #else |
| #define DCL_GPT_6_IS_HANDLE_MAGIC(handl_) ((handl_)& DCL_GPT_6_MAGIC_NUM) |
| #endif |
| #define DCL_GPT_LOGGING_IS_HANDLE_MAGIC(handl_) ((handl_)& DCL_GPT_LOGGING_MAGIC_NUM) |
| #define DCL_GPT_DSP_IS_HANDLE_MAGIC(handl_) ((handl_)& DCL_GPT_DSP_MAGIC_NUM) |
| #define DCL_GPT_C2KAR_IS_HANDLE_MAGIC(handl_) ((handl_)& DCL_GPT_C2KAR_MAGIC_NUM) |
| |
| |
| /***************************************************************************** |
| * Structure/Type Definition * |
| *****************************************************************************/ |
| typedef struct gptimer_instance{ |
| kal_uint32 ticks; |
| void (*gptimer_func)(void *parameter); |
| void *param; |
| struct gptimer_instance *next; |
| }gpt_inst; |
| |
| /***************************************************************************** |
| * Global/External Variable * |
| *****************************************************************************/ |
| kal_uint32 gpt_clock_status = 0; |
| |
| /* For mini-second Callback Function */ |
| static kal_uint32 gptCB_status; /* 1,activated ,0:de-activated */ |
| static kal_uint32 gptCB_ticks; /* CB gpt current ticks number */ |
| static kal_uint32 gptCB_users; /* Indicate the current registered GPT users */ |
| static kal_uint8 gptCB_used[MAX_GPT_ITEMS]; /* 0: Not registered by user, 1: Registerd by used */ |
| static gptimer_item gptCB_items[MAX_GPT_ITEMS]; /* gpt callback function instance */ |
| |
| |
| /* For micro-second Callback Function */ |
| static kal_bool gptCBUS_used = KAL_FALSE; |
| static kal_bool gptCBUS_running = KAL_FALSE; |
| #if !defined(__LP_SCHEDULE_HMU_RESCHEDULE__) |
| static gptimer_item gptCBUS_instance; |
| static kal_uint32 gptCBUS_usr_trig = 0; |
| #endif /* __LP_SCHEDULE_HMU_RESCHEDULE__ */ |
| static kal_uint32 gptCBUS_lisr_trig = 0; |
| |
| #if defined(__LP_SCHEDULE_HMU_RESCHEDULE__) |
| static DCL_UINT32 gpt_cbus_on = 0; |
| #endif |
| |
| #if defined(__MD93__) || defined(__MD95__) |
| /* For micro-second Callback Function */ |
| static kal_bool gptC2KOS_used = KAL_FALSE; |
| static kal_bool gptC2KOS_running = KAL_FALSE; |
| static gptimer_item gptC2KOS_instance; |
| #endif |
| |
| /* For mini-second Callback Function */ |
| static kal_bool gptC2KAR_used = KAL_FALSE; |
| static kal_bool gptC2KAR_running = KAL_FALSE; |
| static gptimer_item gptC2KAR_instance; |
| |
| /* For micro-second Callback Function */ |
| static kal_bool gptLogging_used = KAL_FALSE; |
| static kal_bool gptLogging_running = KAL_FALSE; |
| static gptimer_item gptLogging_instance; |
| |
| #if defined(__MD93__) |
| /* For micro-second Callback Function */ |
| static kal_bool gptDSP_used = KAL_FALSE; |
| static kal_bool gptDSP_running = KAL_FALSE; |
| static gptimer_multiple gptDSP_instance[DSP_USER_NUM]; |
| #else |
| static kal_bool gptDSCC0_used = KAL_FALSE; |
| static kal_bool gptDSCC0_running = KAL_FALSE; |
| static gptimer_item gptDSCC0_instance; |
| |
| static kal_bool gptDSCC1_used = KAL_FALSE; |
| static kal_bool gptDSCC1_running = KAL_FALSE; |
| static gptimer_item gptDSCC1_instance; |
| |
| #endif |
| |
| #if defined(__MD93__) || defined(__MD95__) |
| /* For micro-second Debug Callback Function */ |
| static kal_uint32 gpt_DEBUG_users; /* Indicate the current registered GPT users */ |
| static gpt_inst gpt_DEBUG_head; /* BSS section, default field value == 0 */ |
| static kal_uint8 gpt_DEBUG_used[MAX_GPT_ITEMS]; /* 0: Not registered by user, 1: Registerd by used */ |
| static gpt_inst gpt_DEBUG_items[MAX_GPT_ITEMS]; /* gpt callback function instance */ |
| #endif |
| |
| #if defined(__MD97__) |
| static kal_bool gptDPCOPRO_used = KAL_FALSE; |
| static kal_bool gptDPCOPRO_running = KAL_FALSE; |
| static gptimer_item gptDPCOPRO_instance; |
| #endif |
| |
| static kal_spinlockid gpt_10ms_spinlock; |
| static kal_spinlockid gpt_us_spinlock; |
| |
| #if defined(__MD93__) || defined(__MD95__) |
| static kal_spinlockid gpt_3_spinlock; |
| static kal_spinlockid gpt_6_spinlock; |
| #endif |
| static kal_spinlockid gpt_logging_spinlock; |
| |
| #if defined(__FPGA__) |
| #define gpt_get_current_time() (DRV_Reg32((kal_uint32) USCNTI_VAL)) |
| #else |
| #define gpt_get_current_time() ust_get_current_time() |
| #endif |
| |
| #define UT_GPT_GET_32BIT_COUNTER_DURATION(start, end) \ |
| (((end) >= (start))? ((end) - (start)): ((0xFFFFFFFF - (start) + (end) + 1))) |
| |
| |
| /***************************************************************************** |
| * function declaration * |
| *****************************************************************************/ |
| void GPTCB_10MS_HISR(void); |
| #if !defined(__LP_SCHEDULE_HMU_RESCHEDULE__) |
| void GPTCB_US_HISR(void); |
| #endif |
| void GPTCB_LOGGING_HISR(void); |
| |
| #if defined(__MD93__) || defined(__MD95__) |
| void GPTCB_C2KOS_HISR(void); |
| void GPTCB_DEBUG_HISR(void); |
| static void GPT_DEBUG_Insert(kal_uint32 indx, kal_uint32 tick,void (*gptimer_func)(void *),void *parameter); |
| static void GPT_DEBUG_Stop(kal_uint32 indx); |
| #endif |
| |
| static kal_bool GPTCB_StartItem(DCL_HANDLE module,kal_uint16 tick,void (*gptimer_func)(void *),void *parameter); |
| static void GPTCB_StopItem(DCL_HANDLE module); |
| |
| |
| static void gpt_clk_operation(kal_bool op, kal_uint32 num); |
| void gpt_clk_operation_wo_itc(kal_bool op, kal_uint32 num); |
| |
| |
| void GPT_ERROR_CB(void *p) |
| { |
| kal_uint32 CANNOT_FIND_GPT_CB_HANDLER = 0; |
| ASSERT(CANNOT_FIND_GPT_CB_HANDLER); |
| } |
| |
| /*-----------------------------------------------------------------------* |
| * |
| * GPT 10ms LISR function, |
| * pass to gpt_hw layer as a function pointer |
| * |
| *------------------------------------------------------------------------*/ |
| void GPTCB_Lisr(kal_uint32 vector) |
| { |
| /*ASSERT( (MDGPT_INTR_ID(DRV_GPT_CALLBACK_TIMER) == vector) || \ |
| (MDGPT_INTR_ID(DRV_GPT_CBUS_TIMER) == vector) );*/ |
| #ifndef __MD93__ |
| DRV_WriteReg32(GPT_INT_STATUS_REG(0),GPT_INT_STATUS_MASK_BIT(DRV_GPT_CALLBACK_TIMER)); |
| #endif |
| |
| kal_activate_hisr_index(GPT1_HISR); |
| } |
| |
| /*-----------------------------------------------------------------------* |
| * |
| * GPT 1us LISR function, |
| * pass to gpt_hw layer as a function pointer |
| * |
| *------------------------------------------------------------------------*/ |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_US_Lisr(kal_uint32 vector) |
| { |
| /*ASSERT( (MDGPT_INTR_ID(DRV_GPT_CALLBACK_TIMER) == vector) || \ |
| (MDGPT_INTR_ID(DRV_GPT_CBUS_TIMER) == vector) );*/ |
| #if !defined(__MD93__) |
| DRV_WriteReg32(GPT_INT_STATUS_REG(0),GPT_INT_STATUS_MASK_BIT(DRV_GPT_CBUS_TIMER)); |
| #endif |
| |
| |
| gptCBUS_lisr_trig++; |
| #if defined(__LP_SCHEDULE_HMU_RESCHEDULE__) |
| tg_group2_trigger(TG_TRIGGER_GPT); |
| #else /* __LP_SCHEDULE_HMU_RESCHEDULE__ */ |
| kal_activate_hisr_index(GPT2_HISR); |
| #endif /* __LP_SCHEDULE_HMU_RESCHEDULE__ */ |
| } |
| |
| #if defined(__MD93__) || defined(__MD95__) |
| /*-----------------------------------------------------------------------* |
| * |
| * C2K GPT 1us LISR function, |
| * pass to gpt_hw layer as a function pointer |
| * |
| *------------------------------------------------------------------------*/ |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_C2KOS_Lisr(kal_uint32 vector) |
| { |
| #if !defined(__MD93__) |
| DRV_WriteReg32(GPT_INT_STATUS_REG(0),GPT_INT_STATUS_MASK_BIT(DRV_GPT_6_TIMER)); |
| #endif |
| |
| kal_hrt_activate_hisr_index(GPT6_HISR); |
| |
| gptC2KOS_instance.gptimer_func(gptC2KOS_instance.parameter); |
| |
| } |
| #endif |
| |
| /*-----------------------------------------------------------------------* |
| * |
| * C2K GPT 1ms LISR function, |
| * pass to gpt_hw layer as a function pointer |
| * |
| *------------------------------------------------------------------------*/ |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_C2KAR_Lisr(kal_uint32 vector) |
| { |
| |
| #if !defined(__MD93__) |
| DRV_WriteReg32(GPT_INT_STATUS_REG(0),GPT_INT_STATUS_MASK_BIT(DRV_GPT_C2KAR_TIMER)); |
| #endif |
| gptC2KAR_instance.gptimer_func(gptC2KAR_instance.parameter); |
| } |
| |
| #if defined(__MD93__) |
| |
| /*-----------------------------------------------------------------------* |
| * |
| * GPT DSP 1us LISR function, |
| * pass to gpt_hw layer as a function pointer |
| * |
| *------------------------------------------------------------------------*/ |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_DSP_Lisr(kal_uint32 vector) |
| { |
| kal_uint32 items = 0; |
| #if !defined(__MD93__) |
| DRV_WriteReg32(GPT_INT_STATUS_REG(0),GPT_INT_STATUS_MASK_BIT(DRV_GPT_DSP_TIMER)); |
| #endif |
| |
| /*Todo, add HW ITC to sync*/ |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DRIVER, KAL_INFINITE_WAIT); |
| |
| ASSERT(KAL_TRUE == gptDSP_running); |
| |
| /*Todo, add HW ITC to sync clock*/ |
| gpt_clk_operation_wo_itc(KAL_TRUE, DRV_GPT_DSP_TIMER); |
| |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DRIVER); |
| |
| for(items = 0; items < DSP_USER_NUM; items++) |
| { |
| if(KAL_TRUE == gptDSP_instance[items].execute) |
| { |
| gptDSP_instance[items].gptimer_func(gptDSP_instance[items].parameter); |
| |
| gptDSP_instance[items].execute = KAL_FALSE; |
| } |
| } |
| |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DRIVER, KAL_INFINITE_WAIT); |
| gptDSP_running = KAL_FALSE; |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DRIVER); |
| /*Todo, add HW ITC to sync*/ |
| } |
| #endif |
| |
| /*-----------------------------------------------------------------------* |
| * |
| * GPT 1ms LISR function, |
| * pass to gpt_hw layer as a function pointer |
| * |
| *------------------------------------------------------------------------*/ |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_LOGGING_Lisr(kal_uint32 vector) |
| { |
| /*ASSERT( (MDGPT_INTR_ID(DRV_GPT_CALLBACK_TIMER) == vector) || \ |
| (MDGPT_INTR_ID(DRV_GPT_CBUS_TIMER) == vector) );*/ |
| #if !defined(__MD93__) |
| DRV_WriteReg32(GPT_INT_STATUS_REG(0),GPT_INT_STATUS_MASK_BIT(DRV_GPT_LOGGING_TIMER)); |
| #endif |
| |
| kal_activate_hisr_index(GPT5_HISR); |
| } |
| |
| /*-----------------------------------------------------------------------* |
| * |
| * GPT 1us LISR function, |
| * pass to gpt_hw layer as a function pointer |
| * |
| *------------------------------------------------------------------------*/ |
| #if defined(__MD93__) || defined(__MD95__) |
| void GPT_Debug_Lisr(kal_uint32 vector) |
| { |
| /*ASSERT( (MDGPT_INTR_ID(DRV_GPT_CALLBACK_TIMER) == vector) || \ |
| (MDGPT_INTR_ID(DRV_GPT_CBUS_TIMER) == vector) );*/ |
| kal_activate_hisr_index(GPT_DEBUG_HISR); |
| } |
| |
| #endif |
| |
| #if !defined(__MD93__) |
| |
| void GPT_DSCC0_Lisr(kal_uint32 vector) |
| { |
| DRV_WriteReg32(GPT_INT_STATUS_REG(0),GPT_INT_STATUS_MASK_BIT(DRV_GPT_DSP_TIMER)); |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC1, KAL_INFINITE_WAIT); |
| if(KAL_TRUE == gptDSCC0_running) |
| { |
| gptDSCC0_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_DSP_TIMER); |
| } |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC1); |
| |
| gptDSCC0_instance.gptimer_func(gptDSCC0_instance.parameter); |
| |
| } |
| |
| void GPT_DSCC1_Lisr(kal_uint32 vector) |
| { |
| DRV_WriteReg32(GPT_INT_STATUS_REG(0),GPT_INT_STATUS_MASK_BIT(DRV_GPT_9_TIMER)); |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC2, KAL_INFINITE_WAIT); |
| if(KAL_TRUE == gptDSCC1_running) |
| { |
| gptDSCC1_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_9_TIMER); |
| } |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC2); |
| gptDSCC1_instance.gptimer_func(gptDSCC1_instance.parameter); |
| |
| } |
| |
| #endif |
| |
| #if defined(__MD97__) |
| void GPT_DPCOPRO_Lisr(kal_uint32 vector) |
| { |
| DRV_WriteReg32(GPT_INT_STATUS_REG(0),GPT_INT_STATUS_MASK_BIT(DRV_GPT_6_TIMER)); |
| if(DRV_Reg32(MDGPT_CTRL_REG(DRV_GPT_6_TIMER)) & MDGPT_CTRL_MODE_ENABLE) //[MOLY00455727] |
| gptDPCOPRO_instance.gptimer_func(gptDPCOPRO_instance.parameter); |
| } |
| #endif |
| |
| |
| /*----------------------------------------------------------------------- |
| |
| * FUNCTION |
| * DclSGPT_Initialize |
| * |
| * DESCRIPTION |
| * This function is to initialize SW GPT module. |
| * |
| * PARAMETERS |
| * DCL_STATUS_OK |
| * |
| * RETURNS |
| * none |
| * |
| *------------------------------------------------------------------------*/ |
| DCL_STATUS DclSGPT_Initialize(void) |
| { |
| //#ifndef GPT_LP_TEST |
| kal_uint8 index; |
| |
| /*Create spinlock for every timer*/ |
| gpt_10ms_spinlock = kal_create_spinlock("GPT 10ms Timer"); |
| gpt_us_spinlock = kal_create_spinlock("GPT 1ms HMU Timer"); |
| gpt_logging_spinlock = kal_create_spinlock("GPT 1ms Logging Timer"); |
| #if defined(__MD93__) || defined(__MD95__) |
| gpt_3_spinlock = kal_create_spinlock("GPT3 Timer"); |
| gpt_6_spinlock = kal_create_spinlock("GPT6 Timer"); |
| #endif |
| |
| PDN_CLR(PDN_MDGPTM_26M); |
| MDGPTM_PDN_CLR(); |
| |
| /* GPT hardware reset */ |
| drv_gpt_reset(); |
| |
| /* set gpt CB timer(GPT1) */ |
| drv_gpt_set_timer(DRV_GPT_CALLBACK_TIMER, DCL_GPT_CB_TICK2US, MDGPT_CTRL_MODE_REPEAT); |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| drv_gpt_set_timer(DRV_GPT_CALLBACK_TIMER, DCL_GPT_CB_TICK2US/10, MDGPT_CTRL_MODE_REPEAT); |
| } |
| #endif |
| |
| /* set gpt CBUS timer (GPT2)*/ |
| drv_gpt_set_timer(DRV_GPT_CBUS_TIMER, DCL_GPT_CBUS_TICK2US, MDGPT_CTRL_MODE_REPEAT); |
| #if defined(__MD93__) || defined(__MD95__) |
| /* set gpt C2KOS timer */ |
| drv_gpt_set_timer(DRV_GPT_6_TIMER, DCL_GPT_C2K_TICK2US, MDGPT_CTRL_MODE_ONESHOT); |
| #else |
| drv_gpt_set_timer(DRV_GPT_6_TIMER, DCL_GPT_CBUS_TICK2US, MDGPT_CTRL_MODE_REPEAT); |
| #endif |
| /* set gpt C2KAR timer (GPT7)*/ |
| drv_gpt_set_timer(DRV_GPT_C2KAR_TIMER, DCL_GPT_C2K_TICK2US, MDGPT_CTRL_MODE_REPEAT); |
| |
| /* set gpt CBMS timer (GPT5)*/ |
| drv_gpt_set_timer(DRV_GPT_LOGGING_TIMER, DCL_GPT_LOGGING_TICK2US, MDGPT_CTRL_MODE_REPEAT); |
| |
| /* set gpt Debug timer, tick unit = us */ |
| drv_gpt_set_timer(DRV_GPT_3_TIMER, DCL_GPT_CBUS_TICK2US, MDGPT_CTRL_MODE_ONESHOT); |
| |
| /* set OS timer (GPT4)*/ |
| drv_gpt_set_timer(DRV_GPT_SYSTEM_TIMER, KAL_MICROSECS_PER_TICK, MDGPT_CTRL_MODE_REPEAT); |
| #if defined(__MD93__) |
| /* set gpt DSP timer (GPT8)*/ |
| drv_gpt_set_timer(DRV_GPT_DSP_TIMER, DCL_GPT_CBUS_TICK2US, MDGPT_CTRL_MODE_ONESHOT); |
| #else |
| drv_gpt_set_timer(DRV_GPT_DSP_TIMER, DCL_GPT_CBUS_TICK2US, MDGPT_CTRL_MODE_REPEAT); |
| drv_gpt_set_timer(DRV_GPT_9_TIMER, DCL_GPT_CBUS_TICK2US, MDGPT_CTRL_MODE_ONESHOT); |
| #endif |
| |
| /* gptCB variables are initialized in BSS reset procedure */ |
| |
| for (index = 0; index < MAX_GPT_ITEMS; index++) |
| { |
| gptCB_items[index].gptimer_func = GPT_ERROR_CB; |
| #ifdef __MD93__ |
| gpt_DEBUG_items[index].gptimer_func = GPT_ERROR_CB; |
| #endif |
| } |
| |
| IRQUnmask(MDGPT_INTR_ID(DRV_GPT_CALLBACK_TIMER)); |
| IRQUnmask(MDGPT_INTR_ID(DRV_GPT_CBUS_TIMER)); |
| IRQUnmask(MDGPT_INTR_ID(DRV_GPT_LOGGING_TIMER)); |
| IRQUnmask(MDGPT_INTR_ID(DRV_GPT_3_TIMER)); |
| #if !defined(__MD93__) |
| IRQUnmask(MDGPT_INTR_ID(DRV_GPT_9_TIMER)); |
| #endif |
| IRQUnmask(MDGPT_INTR_ID(DRV_GPT_6_TIMER)); |
| IRQUnmask(MDGPT_INTR_ID(DRV_GPT_C2KAR_TIMER)); |
| IRQUnmask(MDGPT_INTR_ID(DRV_GPT_SYSTEM_TIMER)); |
| IRQUnmask(MDGPT_INTR_ID(DRV_GPT_DSP_TIMER)); |
| |
| PDN_SET(PDN_MDGPTM_26M); |
| MDGPTM_PDN_SET(); |
| //#endif |
| return STATUS_OK; |
| } |
| |
| /*----------------------------------------------------------------------- |
| * FUNCTION |
| * DclSGPT_Open |
| * |
| * DESCRIPTION |
| * This function is to open the SW GPT module and get a handle. Note that |
| * multiple opens are allowed. |
| * |
| * PARAMETERS |
| * eDev - only valid for DCL_GPT1 |
| * flags - no sepcial flags is needed. Please use FLAGS_NONE |
| * |
| * RETURNS |
| * DCL_HANDLE_INVALID - Open failed. |
| * other value - a valid handle |
| * |
| *------------------------------------------------------------------------*/ |
| DCL_HANDLE DclSGPT_Open(DCL_DEV eDev, DCL_FLAGS flags) |
| { |
| kal_int32 i; |
| if (DCL_GPT_CB==eDev) |
| { |
| kal_take_spinlock(gpt_10ms_spinlock, KAL_INFINITE_WAIT); |
| for (i=0; i < MAX_GPT_ITEMS; i++) |
| { |
| if (gptCB_used[i] == 0) |
| { |
| gptCB_used[i] = 1; |
| gptCB_users++; |
| |
| kal_give_spinlock(gpt_10ms_spinlock); |
| |
| return DCL_GPT_CB_MAGIC_NUM|i; |
| } |
| } |
| kal_give_spinlock(gpt_10ms_spinlock); |
| // The case that we do NOT return in the loop: |
| // Indicate there is NO GPT handle!!!!! |
| ASSERT(i < MAX_GPT_ITEMS); |
| // return invalid handle |
| return DCL_HANDLE_OCCUPIED; |
| } |
| #if defined(__MD93__) |
| else if (DCL_GPT_DSP==eDev) |
| { |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DRIVER, KAL_INFINITE_WAIT); |
| |
| ASSERT(KAL_FALSE == gptDSP_used); |
| gptDSP_used = KAL_TRUE; |
| |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DRIVER); |
| |
| return DCL_GPT_DSP_MAGIC_NUM; |
| |
| } |
| #endif |
| #if defined(__MD93__) || defined(__MD95__) |
| else if (DCL_GPT_C2K_OS==eDev) |
| { |
| kal_take_spinlock(gpt_6_spinlock, KAL_INFINITE_WAIT); |
| if( KAL_FALSE == gptC2KOS_used ) |
| { |
| gptC2KOS_used = KAL_TRUE; |
| |
| kal_give_spinlock(gpt_6_spinlock); |
| |
| return DCL_GPT_C2KOS_MAGIC_NUM; |
| } |
| kal_give_spinlock(gpt_6_spinlock); |
| |
| return DCL_HANDLE_OCCUPIED; |
| } |
| #endif |
| #if defined(__MD97__) |
| else if (DCL_GPT_DPCOPRO==eDev) |
| { |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DPCOPRO, KAL_INFINITE_WAIT); |
| if( KAL_FALSE == gptDPCOPRO_used ) |
| { |
| gptDPCOPRO_used = KAL_TRUE; |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DPCOPRO); |
| return DCL_GPT_6_MAGIC_NUM; |
| } |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DPCOPRO); |
| return DCL_HANDLE_OCCUPIED; |
| } |
| #endif |
| else if (DCL_GPT_C2K_AR==eDev) |
| { |
| if( KAL_FALSE == gptC2KAR_used ) |
| { |
| gptC2KAR_used = KAL_TRUE; |
| |
| return DCL_GPT_C2KAR_MAGIC_NUM; |
| } |
| return DCL_HANDLE_OCCUPIED; |
| } |
| else if (DCL_GPT_CB_MS==eDev) |
| { |
| kal_take_spinlock(gpt_us_spinlock, KAL_INFINITE_WAIT); |
| if( KAL_FALSE == gptCBUS_used ) |
| { |
| gptCBUS_used = KAL_TRUE; |
| |
| kal_give_spinlock(gpt_us_spinlock); |
| |
| return DCL_GPT_CBUS_MAGIC_NUM; |
| } |
| kal_give_spinlock(gpt_us_spinlock); |
| |
| return DCL_HANDLE_OCCUPIED; |
| } |
| |
| else if (DCL_GPT_CB_LOGGING==eDev) |
| { |
| kal_take_spinlock(gpt_logging_spinlock, KAL_INFINITE_WAIT); |
| if( KAL_FALSE == gptLogging_used ) |
| { |
| gptLogging_used = KAL_TRUE; |
| kal_give_spinlock(gpt_logging_spinlock); |
| return DCL_GPT_LOGGING_MAGIC_NUM; |
| } |
| kal_give_spinlock(gpt_logging_spinlock); |
| |
| return DCL_HANDLE_OCCUPIED; |
| } |
| #if defined(__MD93__) || defined(__MD95__) |
| else if (DCL_GPT_DEBUG==eDev) |
| { |
| kal_take_spinlock(gpt_3_spinlock, KAL_INFINITE_WAIT); |
| for (i=0; i < MAX_GPT_ITEMS; i++) |
| { |
| if (gpt_DEBUG_used[i] == 0) |
| { |
| gpt_DEBUG_used[i] = 1; |
| gpt_DEBUG_users++; |
| kal_give_spinlock(gpt_3_spinlock); |
| return DCL_GPT_3_MAGIC_NUM|i; |
| } |
| } |
| kal_give_spinlock(gpt_3_spinlock); |
| ASSERT( gpt_DEBUG_users < MAX_GPT_ITEMS ); |
| // return invalid handle |
| return DCL_HANDLE_OCCUPIED; |
| } |
| #endif |
| #if !defined(__MD93__) |
| else if (DCL_GPT_DSCC_0==eDev) |
| { |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC1, KAL_INFINITE_WAIT); |
| if( KAL_FALSE == gptDSCC0_used ) |
| { |
| gptDSCC0_used = KAL_TRUE; |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC1); |
| return DCL_GPT_DSP_MAGIC_NUM; |
| } |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC1); |
| return DCL_HANDLE_OCCUPIED; |
| } |
| else if (DCL_GPT_DSCC_1==eDev) |
| { |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC2, KAL_INFINITE_WAIT); |
| if( KAL_FALSE == gptDSCC1_used ) |
| { |
| gptDSCC1_used = KAL_TRUE; |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC2); |
| return DCL_GPT_9_MAGIC_NUM; |
| } |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC2); |
| |
| return DCL_HANDLE_OCCUPIED; |
| } |
| #endif |
| else |
| { |
| kal_uint32 Invaild_GPT_DEV_Type = 0; |
| |
| ASSERT(Invaild_GPT_DEV_Type); |
| return DCL_HANDLE_INVALID; |
| } |
| } |
| |
| /*----------------------------------------------------------------------- |
| |
| * FUNCTION |
| * DclSGPT_ReadData |
| * |
| * DESCRIPTION |
| * This function is not supported for the SW GPT module now. |
| * |
| * PARAMETERS |
| * N/A |
| * |
| * RETURNS |
| * STATUS_UNSUPPORTED |
| * |
| *------------------------------------------------------------------------*/ |
| |
| DCL_STATUS DclSGPT_ReadData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| /*----------------------------------------------------------------------- |
| |
| * FUNCTION |
| * DclSGPT_WriteData |
| * |
| * DESCRIPTION |
| * This function is not supported for the SW GPT module now. |
| * |
| * PARAMETERS |
| * N/A |
| * |
| * RETURNS |
| * STATUS_UNSUPPORTED |
| * |
| *------------------------------------------------------------------------*/ |
| |
| DCL_STATUS DclSGPT_WriteData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| /*----------------------------------------------------------------------- |
| |
| * FUNCTION |
| * DclSGPT_Configure |
| * |
| * DESCRIPTION |
| * This function is not supported for the SW GPT module now. |
| * |
| * PARAMETERS |
| * N/A |
| * |
| * RETURNS |
| * STATUS_UNSUPPORTED |
| * |
| *------------------------------------------------------------------------*/ |
| |
| DCL_STATUS DclSGPT_Configure(DCL_HANDLE handle, DCL_CONFIGURE_T *configure) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| |
| * FUNCTION |
| * DclSGPT_RegisterCallback |
| * |
| * DESCRIPTION |
| * This function is not supported for the SW GPT module now. |
| * |
| * PARAMETERS |
| * N/A |
| * |
| * RETURNS |
| * STATUS_UNSUPPORTED |
| * |
| *------------------------------------------------------------------------*/ |
| |
| DCL_STATUS DclSGPT_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| |
| * FUNCTION |
| * DclSGPT_Control |
| * |
| * DESCRIPTION |
| * This function is to send command to control the SW GPT module. |
| * |
| * PARAMETERS |
| * handle - a valid handle return by DclSGPT_Open() |
| * cmd - a control command for GPT module |
| * 1. SGPT_CMD_START: to start a GPT timer |
| * 2. SGPT_CMD_STOP: to stop a GPT timer |
| * data - for 1. SGPT_CMD_START: pointer to a SGPT_CTRL_START_T structure |
| * 2. SGPT_CMD_STOP: a NULL pointer |
| * |
| * RETURNS |
| * STATUS_OK - command is executed successfully. |
| * STATUS_FAIL - command is failed. |
| * STATUS_INVALID_CMD - It's a invalid command. |
| * |
| *------------------------------------------------------------------------*/ |
| |
| DCL_STATUS DclSGPT_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data) |
| { |
| DCL_UINT32 gpt_unknown_command = 0; |
| DCL_UINT8 gpt_handle = 0; |
| gpt_handle = DCL_GPT_CB_GET_DEV(handle) & 0x1F; |
| |
| if(DCL_GPT_CB_IS_HANDLE_MAGIC(handle)) |
| { |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| kal_bool ret_b; |
| SGPT_CTRL_START_T *prStart; |
| |
| prStart = &(data->rSGPTStart); |
| |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| kal_take_spinlock(gpt_10ms_spinlock, KAL_INFINITE_WAIT); |
| |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_CALLBACK_TIMER); |
| |
| |
| ret_b = GPTCB_StartItem(gpt_handle, prStart->u2Tick, prStart->pfCallback, prStart->vPara); |
| |
| kal_give_spinlock(gpt_10ms_spinlock); |
| |
| if (ret_b == KAL_TRUE) |
| { |
| return STATUS_OK; |
| } |
| else |
| { |
| return STATUS_FAIL; |
| } |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| |
| kal_take_spinlock(gpt_10ms_spinlock, KAL_INFINITE_WAIT); |
| GPTCB_StopItem(gpt_handle); |
| kal_give_spinlock(gpt_10ms_spinlock); |
| |
| return STATUS_OK; |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| #if defined(__MD93__) |
| else if(DCL_GPT_DSP_IS_HANDLE_MAGIC(handle)) |
| { |
| kal_uint32 items =0; |
| ASSERT( KAL_TRUE == gptDSP_used ); |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DRIVER, KAL_INFINITE_WAIT); |
| |
| //ASSERT( KAL_FALSE == gptDSP_running );//dsp user may multiple |
| |
| for(items = 0; items < DSP_USER_NUM; items++) |
| { |
| if(KAL_FALSE == gptDSP_instance[items].execute) |
| { |
| gptDSP_instance[items].execute = KAL_TRUE; |
| gptDSP_instance[items].tick = prStart->u4Tick; |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| gptDSP_instance[items].tick = gptDSP_instance[items].tick/10; |
| } |
| #endif |
| |
| gptDSP_instance[items].gptimer_func = prStart->pfCallback; |
| gptDSP_instance[items].parameter = prStart->vPara; |
| break; |
| } |
| } |
| #if defined(ATEST_DRV_GPT) |
| if(items == DSP_USER_NUM) |
| { |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DRIVER); |
| return STATUS_FAIL; |
| } |
| #else |
| ASSERT( items < DSP_USER_NUM ); |
| #endif |
| |
| if(KAL_FALSE == gptDSP_running) |
| { |
| gpt_clk_operation_wo_itc(KAL_FALSE, DRV_GPT_DSP_TIMER); |
| drv_gpt_set_timer(DRV_GPT_DSP_TIMER, gptDSP_instance[items].tick, MDGPT_CTRL_MODE_ONESHOT); |
| drv_gpt_start_timer(DRV_GPT_DSP_TIMER); |
| |
| gptDSP_running = KAL_TRUE; |
| } |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DRIVER); |
| |
| return STATUS_OK; |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DRIVER, KAL_INFINITE_WAIT); |
| |
| drv_gpt_stop_timer(DRV_GPT_DSP_TIMER); |
| for(items = 0; items < DSP_USER_NUM; items++) |
| { |
| gptDSP_instance[items].execute = KAL_FALSE; |
| } |
| gptDSP_running = KAL_FALSE; |
| gpt_clk_operation_wo_itc(KAL_TRUE, DRV_GPT_DSP_TIMER); |
| |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DRIVER); |
| |
| return STATUS_OK; |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| #endif |
| else if(DCL_GPT_CBUS_IS_HANDLE_MAGIC(handle)) |
| { |
| ASSERT( KAL_TRUE == gptCBUS_used ); |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| #if !defined(__LP_SCHEDULE_HMU_RESCHEDULE__) |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| kal_take_spinlock(gpt_us_spinlock, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptCBUS_running ) |
| { |
| kal_give_spinlock(gpt_us_spinlock); |
| return STATUS_FAIL; |
| } |
| gptCBUS_instance.tick = prStart->u2Tick*1000; // 1 ms duration |
| gptCBUS_instance.gptimer_func = prStart->pfCallback; |
| gptCBUS_instance.parameter = prStart->vPara; |
| gptCBUS_running = KAL_TRUE; |
| |
| gptCBUS_usr_trig++; |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| gptCBUS_instance.tick = gptCBUS_instance.tick/10; |
| } |
| #endif |
| |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_CBUS_TIMER); |
| drv_gpt_set_timer(DRV_GPT_CBUS_TIMER, gptCBUS_instance.tick, MDGPT_CTRL_MODE_ONESHOT); |
| drv_gpt_start_timer(DRV_GPT_CBUS_TIMER); |
| |
| kal_give_spinlock(gpt_us_spinlock); |
| #else /* !__LP_SCHEDULE_HMU_RESCHEDULE__ */ |
| //only tg_hisr control this gpt |
| if(0 == gpt_cbus_on) |
| { |
| // kal_take_spinlock(gpt_us_spinlock, KAL_INFINITE_WAIT); |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_CBUS_TIMER); |
| gpt_cbus_on = 1; |
| // kal_give_spinlock(gpt_us_spinlock); |
| } |
| /* drv_gpt_set/start_timer are thread-save functions */ |
| drv_gpt_set_timer(DRV_GPT_CBUS_TIMER, prStart->u2Tick*1000, MDGPT_CTRL_MODE_ONESHOT); |
| drv_gpt_start_timer(DRV_GPT_CBUS_TIMER); |
| #endif /* !__LP_SCHEDULE_HMU_RESCHEDULE__ */ |
| |
| return STATUS_OK; |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| |
| #if !defined(__LP_SCHEDULE_HMU_RESCHEDULE__) |
| kal_take_spinlock(gpt_us_spinlock, KAL_INFINITE_WAIT); |
| |
| drv_gpt_stop_timer(DRV_GPT_CBUS_TIMER); |
| gptCBUS_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_CBUS_TIMER); |
| |
| kal_give_spinlock(gpt_us_spinlock); |
| #else /* !__LP_SCHEDULE_HMU_RESCHEDULE__ */ |
| //only tg_hisr control this gpt |
| /* drv_gpt_stop_timer is thread-save function */ |
| drv_gpt_stop_timer(DRV_GPT_CBUS_TIMER); |
| if(1 == gpt_cbus_on) |
| { |
| // kal_take_spinlock(gpt_us_spinlock, KAL_INFINITE_WAIT); |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_CBUS_TIMER); |
| gpt_cbus_on = 0; |
| // kal_give_spinlock(gpt_us_spinlock); |
| } |
| #endif /* !__LP_SCHEDULE_HMU_RESCHEDULE__ */ |
| |
| return STATUS_OK; |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| #if defined(__MD93__) || defined(__MD95__) |
| else if(DCL_GPT_C2KOS_IS_HANDLE_MAGIC(handle)) |
| { |
| ASSERT( KAL_TRUE == gptC2KOS_used ); |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| kal_take_spinlock(gpt_6_spinlock, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptC2KOS_running ) |
| { |
| kal_give_spinlock(gpt_6_spinlock); |
| return STATUS_FAIL; |
| } |
| gptC2KOS_instance.tick = prStart->u4Tick; // 1 us duration |
| gptC2KOS_instance.gptimer_func = prStart->pfCallback; |
| gptC2KOS_instance.parameter = prStart->vPara; |
| gptC2KOS_running = KAL_TRUE; |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| gptC2KOS_instance.tick = gptC2KOS_instance.tick/10; |
| } |
| #endif |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_6_TIMER); |
| drv_gpt_set_timer(DRV_GPT_6_TIMER, gptC2KOS_instance.tick, MDGPT_CTRL_MODE_ONESHOT); |
| drv_gpt_start_timer(DRV_GPT_6_TIMER); |
| |
| kal_give_spinlock(gpt_6_spinlock); |
| |
| return STATUS_OK; |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| |
| kal_take_spinlock(gpt_6_spinlock, KAL_INFINITE_WAIT); |
| |
| drv_gpt_stop_timer(DRV_GPT_6_TIMER); |
| gptC2KOS_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_6_TIMER); |
| |
| kal_give_spinlock(gpt_6_spinlock); |
| |
| return STATUS_OK; |
| |
| case SGPT_CMD_RUNNING_TICK: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| prStart->u4Tick = drv_gpt_get_data(DRV_GPT_6_TIMER); |
| |
| return STATUS_OK; |
| } |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| #elif defined(__MD97__) |
| else if(DCL_GPT_6_IS_HANDLE_MAGIC(handle)) |
| { |
| ASSERT( KAL_TRUE == gptDPCOPRO_used ); |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DPCOPRO, KAL_INFINITE_WAIT); |
| if( KAL_TRUE == gptDPCOPRO_running ) |
| { |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DPCOPRO); |
| return STATUS_FAIL; |
| } |
| gptDPCOPRO_instance.tick = prStart->u4Tick; // 1 us duration |
| gptDPCOPRO_instance.gptimer_func = prStart->pfCallback; |
| gptDPCOPRO_instance.parameter = prStart->vPara; |
| gptDPCOPRO_running = KAL_TRUE; |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| gptDPCOPRO_instance.tick = gptDPCOPRO_instance.tick/10; |
| } |
| #endif |
| |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_6_TIMER); |
| Data_Sync_Barrier(); |
| //drv_gpt_set_timer(DRV_GPT_6_TIMER, gptDPCOPRO_instance.tick, MDGPT_CTRL_MODE_REPEAT); |
| DRV_WriteReg32(MDGPT_CNT_REG(DRV_GPT_6_TIMER), gptDPCOPRO_instance.tick); |
| DRV_WriteReg32(MDGPT_CTRL_REG(DRV_GPT_6_TIMER), MDGPT_CTRL_MODE_REPEAT); //1<<1 enable timer |
| //drv_gpt_start_timer(DRV_GPT_6_TIMER); |
| DRV_WriteReg32(MDGPT_CTRL_REG(DRV_GPT_6_TIMER), DRV_Reg32(MDGPT_CTRL_REG(DRV_GPT_6_TIMER))| MDGPT_CTRL_MODE_ENABLE); |
| Data_Sync_Barrier(); |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DPCOPRO); |
| return STATUS_OK; |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DPCOPRO, KAL_INFINITE_WAIT); |
| //drv_gpt_stop_timer(DRV_GPT_6_TIMER); |
| DRV_WriteReg32(MDGPT_CTRL_REG(DRV_GPT_6_TIMER), DRV_Reg32(MDGPT_CTRL_REG(DRV_GPT_6_TIMER)) & (~MDGPT_CTRL_MODE_ENABLE)); |
| gptDPCOPRO_running = KAL_FALSE; |
| Data_Sync_Barrier(); |
| //IRQClearInt(MDGPT_INTR_ID(DRV_GPT_6_TIMER)); [MOLY00455727] |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_6_TIMER); |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DPCOPRO); |
| return STATUS_OK; |
| |
| case SGPT_CMD_RUNNING_TICK: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| prStart->u4Tick = drv_gpt_get_data(DRV_GPT_6_TIMER); |
| |
| return STATUS_OK; |
| } |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| #endif |
| else if(DCL_GPT_C2KAR_IS_HANDLE_MAGIC(handle)) |
| { |
| ASSERT( KAL_TRUE == gptC2KAR_used ); |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| //savedMask = SaveAndSetIRQMask(); |
| |
| if( KAL_TRUE == gptC2KAR_running ) |
| { |
| //RestoreIRQMask(savedMask); |
| return STATUS_FAIL; |
| } |
| gptC2KAR_instance.tick = prStart->u4Tick; // 1 us duration |
| gptC2KAR_instance.gptimer_func = prStart->pfCallback; |
| gptC2KAR_instance.parameter = prStart->vPara; |
| gptC2KAR_running = KAL_TRUE; |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| gptC2KAR_instance.tick = gptC2KAR_instance.tick/10; |
| } |
| #endif |
| |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_C2KAR_TIMER); |
| drv_gpt_set_timer(DRV_GPT_C2KAR_TIMER, gptC2KAR_instance.tick, MDGPT_CTRL_MODE_REPEAT); |
| drv_gpt_start_timer(DRV_GPT_C2KAR_TIMER); |
| |
| return STATUS_OK; |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| |
| drv_gpt_stop_timer(DRV_GPT_C2KAR_TIMER); |
| gptC2KAR_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_C2KAR_TIMER); |
| |
| return STATUS_OK; |
| |
| case SGPT_CMD_RUNNING_TICK: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| prStart->u4Tick = drv_gpt_get_data(DRV_GPT_C2KAR_TIMER); |
| |
| return STATUS_OK; |
| } |
| |
| case SGPT_CMD_MODIFY_CNT: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| if( KAL_FALSE == gptC2KAR_running ) //Only Running case to modify GPT count |
| { |
| ASSERT(0); |
| } |
| gptC2KAR_instance.tick = prStart->u4Tick; // 1 us duration |
| //gptC2KAR_instance.gptimer_func = prStart->pfCallback; |
| //gptC2KAR_instance.parameter = prStart->vPara; |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| gptC2KAR_instance.tick = gptC2KAR_instance.tick/10; |
| } |
| #endif |
| |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_C2KAR_TIMER); |
| drv_gpt_set_data(DRV_GPT_C2KAR_TIMER, gptC2KAR_instance.tick); |
| |
| return STATUS_OK; |
| } |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| |
| else if(DCL_GPT_LOGGING_IS_HANDLE_MAGIC(handle)) |
| { |
| ASSERT( KAL_TRUE == gptLogging_used ); |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| kal_take_spinlock(gpt_logging_spinlock, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptLogging_running ) |
| { |
| kal_give_spinlock(gpt_logging_spinlock); |
| return STATUS_FAIL; |
| } |
| gptLogging_instance.tick = prStart->u2Tick*1000; // 1 ms duration |
| gptLogging_instance.gptimer_func = prStart->pfCallback; |
| gptLogging_instance.parameter = prStart->vPara; |
| gptLogging_running = KAL_TRUE; |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| gptLogging_instance.tick = gptLogging_instance.tick/10; |
| } |
| #endif |
| |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_LOGGING_TIMER); |
| drv_gpt_set_timer(DRV_GPT_LOGGING_TIMER, gptLogging_instance.tick, MDGPT_CTRL_MODE_ONESHOT); |
| drv_gpt_start_timer(DRV_GPT_LOGGING_TIMER); |
| |
| kal_give_spinlock(gpt_logging_spinlock); |
| |
| return STATUS_OK; |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| |
| kal_take_spinlock(gpt_logging_spinlock, KAL_INFINITE_WAIT); |
| |
| drv_gpt_stop_timer(DRV_GPT_LOGGING_TIMER); |
| gptLogging_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_LOGGING_TIMER); |
| |
| kal_give_spinlock(gpt_logging_spinlock); |
| |
| return STATUS_OK; |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| #if defined(__MD93__) || defined(__MD95__) |
| else if(DCL_GPT_3_IS_HANDLE_MAGIC(handle)) |
| { |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| kal_take_spinlock(gpt_3_spinlock, KAL_INFINITE_WAIT); |
| |
| GPT_DEBUG_Insert(DCL_GPT_3_GET_DEV(handle), prStart->u4Tick, prStart->pfCallback, prStart->vPara); |
| |
| kal_give_spinlock(gpt_3_spinlock); |
| |
| return STATUS_OK; |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| |
| kal_take_spinlock(gpt_3_spinlock, KAL_INFINITE_WAIT); |
| |
| GPT_DEBUG_Stop(DCL_GPT_3_GET_DEV(handle)); |
| |
| kal_give_spinlock(gpt_3_spinlock); |
| |
| return STATUS_OK; |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| #endif |
| #if !defined(__MD93__) |
| else if(DCL_GPT_DSP_IS_HANDLE_MAGIC(handle)) |
| { |
| ASSERT( KAL_TRUE == gptDSCC0_used ); |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC1, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptDSCC0_running ) |
| { |
| drv_gpt_stop_timer(DRV_GPT_DSP_TIMER); |
| } |
| else |
| { |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_DSP_TIMER); |
| } |
| gptDSCC0_instance.tick = prStart->u4Tick; // 1 us duration |
| gptDSCC0_instance.gptimer_func = prStart->pfCallback; |
| gptDSCC0_instance.parameter = prStart->vPara; |
| gptDSCC0_running = KAL_TRUE; |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| gptDSCC0_instance.tick = gptDSCC0_instance.tick/10; |
| } |
| #endif |
| drv_gpt_set_timer(DRV_GPT_DSP_TIMER, gptDSCC0_instance.tick, MDGPT_CTRL_MODE_ONESHOT); |
| drv_gpt_start_timer(DRV_GPT_DSP_TIMER); |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC1); |
| return STATUS_OK; |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC1, KAL_INFINITE_WAIT); |
| |
| drv_gpt_stop_timer(DRV_GPT_DSP_TIMER); |
| gptDSCC0_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_DSP_TIMER); |
| |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC1); |
| |
| return STATUS_OK; |
| |
| case SGPT_CMD_RUNNING_TICK: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| prStart->u4Tick = drv_gpt_get_data(DRV_GPT_DSP_TIMER); |
| |
| return STATUS_OK; |
| } |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| |
| else if(DCL_GPT_9_IS_HANDLE_MAGIC(handle)) |
| { |
| ASSERT( KAL_TRUE == gptDSCC1_used ); |
| switch(cmd) |
| { |
| case SGPT_CMD_START: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| //test if callback function is null. |
| ASSERT( NULL!=prStart->pfCallback ); |
| |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC2, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptDSCC1_running ) |
| { |
| drv_gpt_stop_timer(DRV_GPT_9_TIMER); |
| } |
| else |
| { |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_9_TIMER); |
| } |
| |
| gptDSCC1_instance.tick = prStart->u4Tick; // 1 us duration |
| gptDSCC1_instance.gptimer_func = prStart->pfCallback; |
| gptDSCC1_instance.parameter = prStart->vPara; |
| gptDSCC1_running = KAL_TRUE; |
| |
| #if defined(__FPGA__) |
| if(0x20160617 == drv_gpt_get_version())//Check GPT version is 0x20160617 |
| { |
| gptDSCC1_instance.tick = gptDSCC1_instance.tick/10; |
| } |
| #endif |
| drv_gpt_set_timer(DRV_GPT_9_TIMER, gptDSCC1_instance.tick, MDGPT_CTRL_MODE_ONESHOT); |
| drv_gpt_start_timer(DRV_GPT_9_TIMER); |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC2); |
| |
| return STATUS_OK; |
| } |
| //break; we can return in any case. |
| case SGPT_CMD_STOP: |
| |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC2, KAL_INFINITE_WAIT); |
| |
| drv_gpt_stop_timer(DRV_GPT_9_TIMER); |
| gptDSCC1_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_9_TIMER); |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC2); |
| return STATUS_OK; |
| |
| case SGPT_CMD_RUNNING_TICK: |
| { |
| SGPT_CTRL_START_T *prStart; |
| prStart = &(data->rSGPTStart); |
| |
| prStart->u4Tick = drv_gpt_get_data(DRV_GPT_9_TIMER); |
| |
| return STATUS_OK; |
| } |
| default: |
| ASSERT(gpt_unknown_command); |
| return STATUS_INVALID_CMD; |
| } |
| } |
| |
| #endif |
| else |
| { |
| kal_uint32 Error_DCL_HANDLE = 0; |
| //if assert happen here, that means DCL_HANDLE pass in is wrong! |
| ASSERT(Error_DCL_HANDLE); |
| return DCL_HANDLE_INVALID; |
| } |
| } |
| |
| /*----------------------------------------------------------------------- |
| |
| * FUNCTION |
| * DclSGPT_Close |
| * |
| * DESCRIPTION |
| * This function is to close the SW GPT module. |
| * |
| * PARAMETERS |
| * handle - hanlde previous got from DclSGPT_Open() |
| * |
| * RETURNS |
| * DCL_STATUS_OK - successfully close the SW GPT module. |
| * DCL_STATUS_fail - fails to close the SW GPT module. |
| * |
| *------------------------------------------------------------------------*/ |
| |
| DCL_STATUS DclSGPT_Close(DCL_HANDLE *handle) |
| { |
| DCL_UINT8 gpt_handle; |
| gpt_handle=DCL_GPT_CB_GET_DEV(*handle) & 0x1F; |
| |
| if(DCL_GPT_CB_IS_HANDLE_MAGIC(*handle)) |
| { |
| // Make sure the GPT handle is activated |
| ASSERT(gptCB_used[gpt_handle]); |
| |
| kal_take_spinlock(gpt_10ms_spinlock, KAL_INFINITE_WAIT); |
| |
| if( gptCB_status & (1<<gpt_handle) ) |
| { |
| GPTCB_StopItem(gpt_handle); |
| } |
| |
| gptCB_used[gpt_handle] = 0; |
| gptCB_users--; |
| |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_CALLBACK_TIMER); |
| |
| kal_give_spinlock(gpt_10ms_spinlock); |
| |
| *handle = EMPTY_GPT_CB_HANDLER; |
| return STATUS_OK; |
| } |
| #if defined(__MD93__) |
| if(DCL_GPT_DSP_IS_HANDLE_MAGIC(*handle)) |
| { |
| kal_uint32 items = 0; |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DRIVER, KAL_INFINITE_WAIT); |
| |
| drv_gpt_stop_timer(DRV_GPT_DSP_TIMER); |
| |
| if( KAL_TRUE == gptDSP_running ) |
| { |
| for(items = 0; items < DSP_USER_NUM; items++) |
| { |
| gptDSP_instance[items].execute = KAL_FALSE; |
| } |
| gptDSP_running = KAL_FALSE; |
| } |
| gptDSP_used = KAL_FALSE; |
| *handle = EMPTY_GPT_CB_HANDLER; |
| gpt_clk_operation_wo_itc(KAL_TRUE, DRV_GPT_DSP_TIMER); |
| |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DRIVER); |
| |
| return STATUS_OK; |
| } |
| #endif |
| else if(DCL_GPT_CBUS_IS_HANDLE_MAGIC(*handle)) |
| { |
| kal_take_spinlock(gpt_us_spinlock, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptCBUS_running ) |
| { |
| drv_gpt_stop_timer(DRV_GPT_CBUS_TIMER); |
| gptCBUS_running = KAL_FALSE; |
| } |
| gptCBUS_used = KAL_FALSE; |
| *handle = EMPTY_GPT_CB_HANDLER; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_CBUS_TIMER); |
| |
| kal_give_spinlock(gpt_us_spinlock); |
| |
| return STATUS_OK; |
| } |
| #if defined(__MD93__) || defined(__MD95__) |
| else if(DCL_GPT_C2KOS_IS_HANDLE_MAGIC(*handle)) |
| { |
| kal_take_spinlock(gpt_6_spinlock, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptC2KOS_running ) |
| { |
| drv_gpt_stop_timer(DRV_GPT_6_TIMER); |
| gptC2KOS_running = KAL_FALSE; |
| } |
| gptC2KOS_used = KAL_FALSE; |
| *handle = EMPTY_GPT_CB_HANDLER; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_6_TIMER); |
| |
| kal_give_spinlock(gpt_6_spinlock); |
| |
| return STATUS_OK; |
| } |
| #elif defined(__MD97__) |
| else if(DCL_GPT_6_IS_HANDLE_MAGIC(*handle)) |
| { |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DPCOPRO, KAL_INFINITE_WAIT); |
| if( KAL_TRUE == gptDPCOPRO_running ) |
| { |
| drv_gpt_stop_timer(DRV_GPT_6_TIMER); |
| gptDPCOPRO_running = KAL_FALSE; |
| } |
| gptDPCOPRO_used = KAL_FALSE; |
| *handle = EMPTY_GPT_CB_HANDLER; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_6_TIMER); |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DPCOPRO); |
| return STATUS_OK; |
| } |
| #endif |
| else if(DCL_GPT_C2KAR_IS_HANDLE_MAGIC(*handle)) |
| { |
| if( KAL_TRUE == gptC2KAR_running ) |
| { |
| drv_gpt_stop_timer(DRV_GPT_C2KAR_TIMER); |
| gptC2KAR_running = KAL_FALSE; |
| } |
| gptC2KAR_used = KAL_FALSE; |
| *handle = EMPTY_GPT_CB_HANDLER; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_C2KAR_TIMER); |
| |
| return STATUS_OK; |
| } |
| else if(DCL_GPT_LOGGING_IS_HANDLE_MAGIC(*handle)) |
| { |
| kal_take_spinlock(gpt_logging_spinlock, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptLogging_running ) |
| { |
| drv_gpt_stop_timer(DRV_GPT_LOGGING_TIMER); |
| gptLogging_running = KAL_FALSE; |
| } |
| gptLogging_used = KAL_FALSE; |
| *handle = EMPTY_GPT_CB_HANDLER; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_LOGGING_TIMER); |
| |
| kal_give_spinlock(gpt_logging_spinlock); |
| |
| return STATUS_OK; |
| } |
| #if defined(__MD93__) || defined(__MD95__) |
| else if(DCL_GPT_3_IS_HANDLE_MAGIC(*handle)) |
| { |
| gpt_inst *iter; |
| |
| kal_take_spinlock(gpt_3_spinlock, KAL_INFINITE_WAIT); |
| |
| iter = gpt_DEBUG_head.next; |
| while(NULL!=iter) |
| { |
| if(iter == &gpt_DEBUG_items[gpt_handle]) |
| { |
| GPT_DEBUG_Stop(gpt_handle); |
| break; |
| } |
| } |
| gpt_DEBUG_used[gpt_handle] = 0; |
| gpt_DEBUG_users--; |
| *handle = EMPTY_GPT_CB_HANDLER; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_3_TIMER); |
| |
| kal_give_spinlock(gpt_3_spinlock); |
| |
| return STATUS_OK; |
| } |
| #endif |
| #if !defined(__MD93__) |
| else if(DCL_GPT_DSP_IS_HANDLE_MAGIC(*handle)) |
| { |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC1, KAL_INFINITE_WAIT); |
| if( KAL_TRUE == gptDSCC0_running ) |
| { |
| drv_gpt_stop_timer(DRV_GPT_DSP_TIMER); |
| gptDSCC0_running = KAL_FALSE; |
| } |
| gptDSCC0_used = KAL_FALSE; |
| *handle = EMPTY_GPT_CB_HANDLER; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_DSP_TIMER); |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC1); |
| return STATUS_OK; |
| } |
| else if(DCL_GPT_9_IS_HANDLE_MAGIC(*handle)) |
| { |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DSCC2, KAL_INFINITE_WAIT); |
| if( KAL_TRUE == gptDSCC1_running ) |
| { |
| drv_gpt_stop_timer(DRV_GPT_9_TIMER); |
| gptDSCC1_running = KAL_FALSE; |
| } |
| gptDSCC1_used = KAL_FALSE; |
| *handle = EMPTY_GPT_CB_HANDLER; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_9_TIMER); |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DSCC2); |
| return STATUS_OK; |
| } |
| |
| #endif |
| else |
| { |
| kal_uint32 Invalid_DCL_GPT_HANDLE = 0; |
| ASSERT(Invalid_DCL_GPT_HANDLE); |
| return STATUS_INVALID_DCL_HANDLE; |
| } |
| } |
| |
| |
| void gpt_clk_operation(kal_bool op, kal_uint32 num) |
| { |
| kal_hrt_take_itc_lock(KAL_ITC_GPT_DRIVER, KAL_INFINITE_WAIT); |
| if (KAL_TRUE == op) //clock off |
| { |
| gpt_clock_status &= ~(1<<num); |
| if(0 == gpt_clock_status) |
| { |
| PDN_SET(PDN_MDGPTM_26M); |
| MDGPTM_PDN_SET(); |
| } |
| } |
| else //clock on |
| { |
| if(0 == gpt_clock_status) |
| { |
| PDN_CLR(PDN_MDGPTM_26M); |
| MDGPTM_PDN_CLR(); |
| } |
| gpt_clock_status |= (1<<num); |
| } |
| kal_hrt_give_itc_lock(KAL_ITC_GPT_DRIVER); |
| } |
| |
| void gpt_clk_operation_wo_itc(kal_bool op, kal_uint32 num) |
| { |
| if (KAL_TRUE == op) //clock off |
| { |
| gpt_clock_status &= ~(1<<num); |
| if(0 == gpt_clock_status) |
| { |
| PDN_SET(PDN_MDGPTM_26M); |
| MDGPTM_PDN_SET(); |
| } |
| } |
| else //clock on |
| { |
| if(0 == gpt_clock_status) |
| { |
| PDN_CLR(PDN_MDGPTM_26M); |
| MDGPTM_PDN_CLR(); |
| } |
| gpt_clock_status |= (1<<num); |
| } |
| } |
| |
| /*----------------------------------------------------------------------- |
| |
| * FUNCTION |
| * GPTCB_StartItem |
| * |
| * DESCRIPTION |
| * GPT CB start a item. |
| * |
| * CALLS |
| * |
| * PARAMETERS |
| * handler = instance number |
| * tick = the delay(the unit is 10ms) |
| * gptimer_func = the callback function when the tick is reached. |
| * parameter = the parameter inputed into gptimer_func |
| * |
| * RETURNS |
| * KAL_TRUE, start item successfully |
| * KAL_FALSE, start item fail |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| *------------------------------------------------------------------------*/ |
| static kal_bool GPTCB_StartItem(DCL_HANDLE handler,kal_uint16 tick,void (*gptimer_func)(void *),void *parameter) |
| { |
| |
| if (gptCB_status & (1<<handler)) |
| { |
| return KAL_FALSE; |
| } |
| |
| //savedMask = SaveAndSetIRQMask(); |
| |
| gptCB_items[handler].tick = gptCB_ticks + tick; |
| gptCB_items[handler].gptimer_func = gptimer_func; |
| gptCB_items[handler].parameter = parameter; |
| |
| if(0 == gptCB_status) |
| { |
| drv_gpt_start_timer(DRV_GPT_CALLBACK_TIMER); |
| } |
| gptCB_status |= (1<<handler); |
| |
| //RestoreIRQMask(savedMask); |
| |
| return KAL_TRUE; |
| } |
| |
| /*----------------------------------------------------------------------- |
| |
| * FUNCTION |
| * GPTCB_StopItem |
| * |
| * DESCRIPTION |
| * GPT CB stop a item. |
| * |
| * CALLS |
| * |
| * PARAMETERS |
| * handler = instance number |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| *------------------------------------------------------------------------*/ |
| static void GPTCB_StopItem(DCL_HANDLE handler) |
| { |
| ASSERT(gptCB_used[handler]); |
| |
| gptCB_status &= ~(1<<handler); |
| |
| if(0==gptCB_status) |
| { |
| gptCB_ticks = 0; |
| drv_gpt_stop_timer(DRV_GPT_CALLBACK_TIMER); |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_CALLBACK_TIMER); |
| } |
| } |
| #if defined(__MD93__) || defined(__MD95__) |
| static void GPT_DEBUG_Insert(kal_uint32 indx, kal_uint32 tick, void (*fp)(void *) ,void *parameter) |
| { |
| kal_uint32 elapsed, time; /* elapsed: current - start time; time: eariest time-out setting */ |
| gpt_inst *iter = gpt_DEBUG_head.next; |
| |
| ASSERT( NULL!=fp ); |
| gpt_DEBUG_items[indx].gptimer_func = fp; |
| gpt_DEBUG_items[indx].param = parameter; |
| |
| //savedMask = SaveAndSetIRQMask(); |
| |
| elapsed = drv_gpt_get_data(DRV_GPT_3_TIMER); |
| drv_gpt_stop_timer(DRV_GPT_3_TIMER); |
| |
| if( (NULL == gpt_DEBUG_head.next)) |
| { |
| gpt_DEBUG_head.next = &gpt_DEBUG_items[indx]; |
| time = tick; |
| gpt_clk_operation(KAL_FALSE, DRV_GPT_3_TIMER); |
| } |
| else if((iter->ticks-elapsed) > tick) |
| { |
| gpt_DEBUG_items[indx].next = iter; |
| gpt_DEBUG_head.next = &gpt_DEBUG_items[indx]; |
| iter->ticks -= elapsed + tick; |
| time = tick; |
| } |
| else |
| { |
| time = iter->ticks - elapsed; |
| tick -= time; |
| iter->ticks = time; |
| while( NULL != iter->next ) |
| { |
| if(iter->next->ticks > tick) |
| { |
| gpt_DEBUG_items[indx].next = iter->next; |
| gpt_DEBUG_items[indx].next->ticks -= tick; |
| iter->next = &gpt_DEBUG_items[indx]; |
| break; |
| } |
| iter = iter->next; |
| tick -= iter->ticks; |
| } |
| if(NULL == iter->next) |
| { |
| gpt_DEBUG_items[indx].next = NULL; |
| iter->next = &gpt_DEBUG_items[indx]; |
| } |
| } |
| gpt_DEBUG_items[indx].ticks = tick; |
| |
| //test if callback function is null. |
| drv_gpt_set_timer(DRV_GPT_3_TIMER, time, MDGPT_CTRL_MODE_ONESHOT); |
| drv_gpt_start_timer(DRV_GPT_3_TIMER); |
| |
| //RestoreIRQMask(savedMask); |
| } |
| |
| /*----------------------------------------------------------------------- |
| * FUNCTION |
| * GPT_DEBUG_Stop |
| * |
| * DESCRIPTION |
| * Remove Debug Timer Instance from queue |
| * |
| * CALLS |
| * |
| * PARAMETERS |
| * indx = instance number |
| * |
| * RETURNS |
| * None |
| * |
| *------------------------------------------------------------------------*/ |
| static void GPT_DEBUG_Stop(kal_uint32 indx) |
| { |
| gpt_inst *iter = &gpt_DEBUG_head; |
| |
| //savedMask = SaveAndSetIRQMask(); |
| |
| while( (iter->next!=&gpt_DEBUG_items[indx]) && (NULL!=iter->next) ) |
| { |
| iter = iter->next; |
| } |
| ASSERT(NULL!=iter->next); |
| |
| if(iter == &gpt_DEBUG_head) |
| { |
| kal_uint32 elapsed; |
| elapsed = drv_gpt_get_data(DRV_GPT_3_TIMER); |
| drv_gpt_stop_timer(DRV_GPT_3_TIMER); |
| IRQClearInt(MDGPT_INTR_ID(DRV_GPT_3_TIMER)); |
| |
| gpt_DEBUG_head.next = gpt_DEBUG_items[indx].next; |
| if(NULL != gpt_DEBUG_head.next) |
| { |
| gpt_DEBUG_head.next->ticks = gpt_DEBUG_head.next->ticks - elapsed + gpt_DEBUG_items[indx].ticks ; |
| drv_gpt_set_timer(DRV_GPT_3_TIMER, gpt_DEBUG_head.next->ticks, MDGPT_CTRL_MODE_ONESHOT); |
| drv_gpt_start_timer(DRV_GPT_3_TIMER); |
| } |
| else |
| { |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_3_TIMER); |
| } |
| } |
| else |
| { |
| if(NULL != gpt_DEBUG_items[indx].next) |
| { |
| gpt_DEBUG_items[indx].next->ticks += gpt_DEBUG_items[indx].ticks; |
| } |
| iter->next = iter->next->next; |
| } |
| gpt_DEBUG_items[indx].next = NULL; |
| //RestoreIRQMask(savedMask); |
| } |
| #endif |
| /*----------------------------------------------------------------------- |
| * FUNCTION |
| * GPTCB_10MS_HISR |
| * |
| * DESCRIPTION |
| * GPT Callback HISR : 10ms |
| * |
| * CALLS |
| * |
| * PARAMETERS |
| * void |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| *------------------------------------------------------------------------*/ |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_10MS_HISR(void) |
| { |
| kal_uint8 index; |
| kal_uint32 checkMask = 0xFFFFFFFF; |
| |
| kal_take_spinlock(gpt_10ms_spinlock, KAL_INFINITE_WAIT); |
| |
| gptCB_ticks++; |
| |
| kal_give_spinlock(gpt_10ms_spinlock); |
| |
| // Bit matched method to check if a GPT items is activated |
| // Search whole GPT items |
| for (index = 0; (index < MAX_GPT_ITEMS)&&(gptCB_status&checkMask); index++) |
| { |
| kal_take_spinlock(gpt_10ms_spinlock, KAL_INFINITE_WAIT); |
| if( (gptCB_status & (1 << index)) && (gptCB_ticks >= gptCB_items[index].tick) ) |
| { |
| gptCB_status &= ~(1<<index); |
| kal_give_spinlock(gpt_10ms_spinlock); |
| gptCB_items[index].gptimer_func(gptCB_items[index].parameter); |
| |
| } |
| else |
| { |
| kal_give_spinlock(gpt_10ms_spinlock); |
| } |
| checkMask ^= (1 << index); |
| } |
| |
| |
| kal_take_spinlock(gpt_10ms_spinlock, KAL_INFINITE_WAIT); |
| |
| if (gptCB_status == 0) |
| { |
| // UT Test road test. |
| gptCB_ticks = 0; |
| drv_gpt_stop_timer(DRV_GPT_CALLBACK_TIMER); |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_CALLBACK_TIMER); |
| } |
| kal_give_spinlock(gpt_10ms_spinlock); |
| } |
| |
| |
| /*----------------------------------------------------------------------- |
| * FUNCTION |
| * GPTCB_Debug_HISR |
| * |
| * DESCRIPTION |
| * GPT Callback HISR : 1us |
| * |
| * CALLS |
| * |
| * PARAMETERS |
| * void |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| *------------------------------------------------------------------------*/ |
| #if defined(__MD93__) || defined(__MD95__) |
| void GPTCB_DEBUG_HISR(void) |
| { |
| // if(NULL != gpt_DEBUG_head.next->gptimer_func) |
| { |
| gpt_DEBUG_head.next->gptimer_func(gpt_DEBUG_head.next->param); |
| } |
| #if !defined(ATEST_DRV_ENABLE) && !defined(DSPFNC_DSP_SWTRACER) |
| ASSERT(0); |
| #endif /* !ATEST_DRV_ENABLE */ |
| } |
| #else |
| void GPTCB_DEBUG_HISR(void) |
| { |
| return; |
| } |
| #endif |
| /*----------------------------------------------------------------------- |
| * FUNCTION |
| * GPTCB_US_HISR |
| * |
| * DESCRIPTION |
| * GPT Callback HISR : 10ms |
| * |
| * CALLS |
| * |
| * PARAMETERS |
| * void |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| *------------------------------------------------------------------------*/ |
| #if !defined(__LP_SCHEDULE_HMU_RESCHEDULE__) |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_US_HISR(void) |
| { |
| kal_take_spinlock(gpt_us_spinlock, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptCBUS_running ) |
| { |
| gptCBUS_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_CBUS_TIMER); |
| |
| kal_give_spinlock(gpt_us_spinlock); |
| gptCBUS_instance.gptimer_func(gptCBUS_instance.parameter); |
| } |
| else |
| { |
| kal_give_spinlock(gpt_us_spinlock); |
| } |
| |
| } |
| #endif |
| |
| #if defined(__MD93__) || defined(__MD95__) |
| |
| /*----------------------------------------------------------------------- |
| * FUNCTION |
| * GPTCB_C2KOS_HISR |
| * |
| * DESCRIPTION |
| * C2K GPT Callback HISR : 1us |
| * |
| * CALLS |
| * |
| * PARAMETERS |
| * void |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| *------------------------------------------------------------------------*/ |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_C2KOS_HISR(void) |
| { |
| kal_take_spinlock(gpt_6_spinlock, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptC2KOS_running ) |
| { |
| gptC2KOS_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_6_TIMER); |
| |
| kal_give_spinlock(gpt_6_spinlock); |
| } |
| else |
| { |
| kal_give_spinlock(gpt_6_spinlock); |
| ASSERT(0); |
| } |
| } |
| #else |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_C2KOS_HISR(void) |
| { |
| return; |
| } |
| #endif |
| |
| /*----------------------------------------------------------------------- |
| * FUNCTION |
| * GPTCB_US_HISR |
| * |
| * DESCRIPTION |
| * GPT Callback HISR : 10ms |
| * |
| * CALLS |
| * |
| * PARAMETERS |
| * void |
| * |
| * RETURNS |
| * None |
| * |
| * GLOBALS AFFECTED |
| * external_global |
| *------------------------------------------------------------------------*/ |
| DEVDRV_LS_INTSRAM_ROCODE void GPTCB_LOGGING_HISR(void) |
| { |
| kal_take_spinlock(gpt_logging_spinlock, KAL_INFINITE_WAIT); |
| |
| if( KAL_TRUE == gptLogging_running ) |
| { |
| gptLogging_running = KAL_FALSE; |
| gpt_clk_operation(KAL_TRUE, DRV_GPT_LOGGING_TIMER); |
| |
| kal_give_spinlock(gpt_logging_spinlock); |
| gptLogging_instance.gptimer_func(gptLogging_instance.parameter); |
| } |
| else |
| { |
| kal_give_spinlock(gpt_logging_spinlock); |
| } |
| } |
| |
| #else /* else of !defined(DRV_GPT_OFF) */ |
| |
| DCL_STATUS DclSGPT_Initialize(void) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_HANDLE DclSGPT_Open(DCL_DEV dev, DCL_FLAGS flags) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclSGPT_ReadData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclSGPT_WriteData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclSGPT_Configure(DCL_HANDLE handle, DCL_CONFIGURE_T *configure) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclSGPT_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclSGPT_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclSGPT_Close(DCL_HANDLE *handle) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclFGPT_Initialize(void) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_HANDLE DclFGPT_Open(DCL_DEV dev, DCL_FLAGS flags) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclFGPT_ReadData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclFGPT_WriteData(DCL_HANDLE handle, DCL_BUFF *buff, DCL_BUFF_LEN *buf_len, DCL_OPTIONS options) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclFGPT_Configure(DCL_HANDLE handle, DCL_CONFIGURE_T *configure) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclFGPT_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclFGPT_Control(DCL_HANDLE handle, DCL_CTRL_CMD cmd, DCL_CTRL_DATA_T *data) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| |
| DCL_STATUS DclFGPT_Close(DCL_HANDLE handle) |
| { |
| return STATUS_UNSUPPORTED; |
| } |
| #if defined (__ESL_COSIM_LTE__) || defined(__MASE__) |
| #if defined(__MD93__) || defined(__MD95__) |
| void GPTCB_DEBUG_HISR(void) |
| { |
| } |
| #endif |
| |
| void GPTCB_10MS_HISR(void) |
| { |
| } |
| |
| void GPTCB_US_HISR(void) |
| { |
| } |
| |
| void GPTCB_LOGGING_HISR(void) |
| { |
| } |
| |
| void LITEGPT_ETMR_HISR(void) |
| { |
| } |
| |
| void GPTCB_C2KOS_HISR(void) |
| { |
| } |
| |
| #endif /* __ESL_COSIM_LTE__ */ |
| #endif /* end of else of !defined(DRV_GPT_OFF) */ |
| |
| DCL_HANDLE DclHGPT_Open(DCL_DEV dev, DCL_FLAGS flags){return STATUS_UNSUPPORTED;} |
| DCL_STATUS DclHGPT_Control(DCL_HANDLE handle, HGPT_CMD cmd, HGPT_CTRL *data){return STATUS_UNSUPPORTED;} |
| DCL_STATUS DclHGPT_RegisterCallback(DCL_HANDLE handle, DCL_EVENT event, PFN_DCL_CALLBACK callback){return STATUS_UNSUPPORTED;} |
| DCL_STATUS DclHGPT_Close(DCL_HANDLE handle){return STATUS_UNSUPPORTED;} |
| |
| //#endif |
| |