| /* |
| * |
| * Copyright (c) 2022 Project CHIP Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * Includes |
| */ |
| |
| #include "em_cmu.h" |
| #ifdef RSI_WITH_OS |
| /* FreeRTOS includes. */ |
| #include "FreeRTOS.h" |
| #include "event_groups.h" |
| #include "task.h" |
| #include "timers.h" |
| #if defined(SysTick) |
| #undef SysTick_Handler |
| /* FreeRTOS SysTick interrupt handler prototype */ |
| extern void SysTick_Handler(void); |
| /* FreeRTOS tick timer interrupt handler prototype */ |
| extern void xPortSysTickHandler(void); |
| #endif /* SysTick */ |
| #endif /* RSI_WITH_OS */ |
| #include "wfx_host_events.h" |
| |
| /* RSI Driver include file */ |
| #include "rsi_driver.h" |
| /* RSI WLAN Config include file */ |
| #include "rsi_bootup_config.h" |
| #include "rsi_common_apis.h" |
| #include "rsi_data_types.h" |
| #include "rsi_error.h" |
| #include "rsi_nwk.h" |
| #include "rsi_socket.h" |
| #include "rsi_utils.h" |
| #include "rsi_wlan.h" |
| #include "rsi_wlan_apis.h" |
| #include "rsi_wlan_config.h" |
| #include "wfx_rsi.h" |
| |
| #ifndef _use_the_rsi_defined_functions |
| |
| StaticTimer_t sRsiTimerBuffer; |
| |
| /* |
| * We (Matter port) need a few functions out of this file |
| * They are at the top |
| */ |
| uint32_t rsi_hal_gettickcount(void) |
| { |
| return xTaskGetTickCount(); |
| } |
| void rsi_delay_ms(uint32_t delay_ms) |
| { |
| #ifndef RSI_WITH_OS |
| uint32_t start; |
| #endif |
| if (delay_ms == 0) // Check if delay is 0msec |
| return; |
| |
| #ifdef RSI_WITH_OS |
| vTaskDelay(pdMS_TO_TICKS(delay_ms)); |
| #else |
| start = rsi_hal_gettickcount(); |
| do |
| { |
| } while (rsi_hal_gettickcount() - start < delay_ms); |
| #endif |
| } |
| static struct rsi_timer |
| { |
| void (*func)(void); |
| TimerHandle_t handle; |
| uint8_t id; |
| uint8_t name[3]; |
| } rsi_timer[WFX_RSI_NUM_TIMERS]; |
| static void timer_cb(TimerHandle_t thandle) |
| { |
| int x; |
| for (x = 0; x < WFX_RSI_NUM_TIMERS; x++) |
| { |
| if (rsi_timer[x].handle == thandle) |
| { |
| (*rsi_timer[x].func)(); |
| break; |
| } |
| } |
| } |
| |
| /* |
| * Run a one-shot/periodic timer |
| */ |
| int32_t rsi_timer_start(uint8_t timer_node, uint8_t mode, uint8_t type, uint32_t duration, void (*rsi_timer_cb)(void)) |
| { |
| int x; |
| struct rsi_timer * tp; |
| |
| if (mode == RSI_HAL_TIMER_MODE_MILLI) |
| return RSI_ERROR_INVALID_OPTION; /* Not supported for now - Fix this later */ |
| for (x = 0; x < WFX_RSI_NUM_TIMERS; x++) |
| { |
| tp = &rsi_timer[x]; |
| if (tp->handle == NULL) |
| { |
| goto found; |
| } |
| } |
| /* No space */ |
| return RSI_ERROR_INSUFFICIENT_BUFFER; |
| found: |
| tp->name[0] = 'r'; |
| tp->name[1] = timer_node; |
| tp->name[2] = 0; |
| tp->func = rsi_timer_cb; |
| tp->handle = |
| xTimerCreateStatic((char *) &tp->name[0], pdMS_TO_TICKS(duration), |
| ((mode == RSI_HAL_TIMER_TYPE_SINGLE_SHOT) ? pdFALSE : pdTRUE), NULL, timer_cb, &sRsiTimerBuffer); |
| |
| if (tp->handle == NULL) |
| { |
| return RSI_ERROR_INSUFFICIENT_BUFFER; |
| } |
| |
| (void) xTimerStart(tp->handle, TIMER_TICKS_TO_WAIT_0); |
| |
| return RSI_ERROR_NONE; |
| } |
| #else /* _use_the_rsi_defined_functions */ |
| |
| /* Counts 1ms timeTicks */ |
| volatile uint32_t msTicks = 0; |
| |
| /*===================================================*/ |
| /** |
| * @fn int32_t rsi_timer_start(uint8_t timer_no, uint8_t mode,uint8_t type,uint32_t duration,void (* |
| * rsi_timer_expiry_handler)()) |
| * @brief Starts and configures timer |
| * @param[in] timer_node, timer node to be configured. |
| * @param[in] mode , mode of the timer |
| * 0 - Micro seconds mode |
| * 1 - Milli seconds mode |
| * @param[in] type, type of the timer |
| * 0 - single shot type |
| * 1 - periodic type |
| * @param[in] duration, timer duration |
| * @param[in] rsi_timer_expiry_handler() ,call back function to handle timer interrupt |
| * @param[out] none |
| * @return 0 - success |
| * !0 - Failure |
| * @description This HAL API should contain the code to initialize the timer and start the timer |
| * |
| */ |
| |
| int32_t rsi_timer_start(uint8_t timer_node, uint8_t mode, uint8_t type, uint32_t duration, void (*rsi_timer_expiry_handler)(void)) |
| { |
| |
| // Initialise the timer |
| |
| // register the call back |
| |
| // Start timer |
| |
| return 0; |
| } |
| |
| /*===================================================*/ |
| /** |
| * @fn int32_t rsi_timer_stop(uint8_t timer_no) |
| * @brief Stops timer |
| * @param[in] timer_node, timer node to stop |
| * @param[out] none |
| * @return 0 - success |
| * !0 - Failure |
| * @description This HAL API should contain the code to stop the timer |
| * |
| */ |
| |
| int32_t rsi_timer_stop(uint8_t timer_node) |
| { |
| |
| // Stop the timer |
| |
| return 0; |
| } |
| |
| /*===================================================*/ |
| /** |
| * @fn uint32_t rsi_timer_read(uint8_t timer_node) |
| * @brief read timer |
| * @param[in] timer_node, timer node to read |
| * @param[out] none |
| * @return timer value |
| * @description This HAL API should contain API to read the timer |
| * |
| */ |
| uint32_t rsi_timer_read(uint8_t timer_node) |
| { |
| |
| volatile uint32_t timer_val = 0; |
| |
| // read the timer and return timer value |
| |
| return timer_val; |
| } |
| |
| /*===================================================*/ |
| /** |
| * @fn void rsi_delay_us(uint32_t delay) |
| * @brief create delay in micro seconds |
| * @param[in] delay_us, timer delay in micro seconds |
| * @param[out] none |
| * @return none |
| * @description This HAL API should contain the code to create delay in micro seconds |
| * |
| */ |
| void rsi_delay_us(uint32_t delay_us) |
| { |
| |
| // call the API for delay in micro seconds |
| |
| return; |
| } |
| |
| #ifdef RSI_M4_INTERFACE |
| |
| extern void SysTick_Handler(void); |
| |
| void SysTick_Handler(void) |
| { |
| _dwTickCount++; |
| } |
| |
| uint32_t GetTickCount(void) |
| { |
| return _dwTickCount; // gets the tick count from systic ISR |
| } |
| #endif |
| |
| /*===================================================*/ |
| /** |
| * @fn void rsi_delay_ms(uint32_t delay) |
| * @brief create delay in milli seconds |
| * @param[in] delay, timer delay in milli seconds |
| * @param[out] none |
| * @return none |
| * @description This HAL API should contain the code to create delay in milli seconds |
| */ |
| void rsi_delay_ms(uint32_t delay_ms) |
| { |
| #ifndef RSI_WITH_OS |
| uint32_t start; |
| #endif |
| if (delay_ms == DELAY0) |
| return; |
| |
| #ifdef RSI_WITH_OS |
| vTaskDelay(delay_ms); |
| #else |
| start = rsi_hal_gettickcount(); |
| do |
| { |
| } while (rsi_hal_gettickcount() - start < delay_ms); |
| #endif |
| } |
| |
| /*===================================================*/ |
| /** |
| * @fn uint32_t rsi_hal_gettickcount() |
| * @brief provides a tick value in milliseconds |
| * @return tick value |
| * @description This HAL API should contain the code to read the timer tick count value in milliseconds |
| * |
| */ |
| |
| #ifndef RSI_HAL_USE_RTOS_SYSTICK |
| /* |
| SysTick handler implementation that also clears overflow flag. |
| */ |
| void SysTick_Handler(void) |
| { |
| /* Increment counter necessary in Delay()*/ |
| msTicks++; |
| #ifdef RSI_WITH_OS |
| if (xTaskGetSchedulerState() != taskSCHEDULER_NOT_STARTED) |
| { |
| xPortSysTickHandler(); |
| } |
| #endif |
| } |
| |
| uint32_t rsi_hal_gettickcount(void) |
| { |
| return msTicks; |
| |
| #ifdef LINUX_PLATFORM |
| // Define your API to get the tick count delay in milli seconds from systic ISR and return the resultant value |
| struct rsi_timeval tv1; |
| gettimeofday(&tv1, NULL); |
| return (tv1.tv_sec * CONVERT_SEC_TO_MSEC + tv1.tv_usec * CONVERT_USEC_TO_MSEC); |
| #endif |
| } |
| |
| #else |
| uint32_t rsi_hal_gettickcount(void) |
| { |
| return xTaskGetTickCount(); |
| } |
| #endif /* RSI_HAL_USE_RTOS_SYSTICK */ |
| #endif /* _use_the_rsi_defined_functions */ |