1 files changed, 266 insertions, 0 deletions

diff --git a/lib/chibios-contrib/ext/mcux-sdk/devices/MIMX8QM6/drivers/fsl_sc_event.h b/lib/chibios-contrib/ext/mcux-sdk/devices/MIMX8QM6/drivers/fsl_sc_event.h
new file mode 100644
index 000000000..7aa4e2f5b
--- /dev/null
+++ b/lib/chibios-contrib/ext/mcux-sdk/devices/MIMX8QM6/drivers/fsl_sc_event.h
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2019 NXP
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#ifndef _FSL_SC_EVENT_H_
+#define _FSL_SC_EVENT_H_
+
+#include "fsl_common.h"
+#include "svc/irq/irq_api.h"
+#include "svc/pad/pad_api.h"
+
+/*!
+ * @addtogroup sc_event_driver
+ * @{
+ */
+
+/*******************************************************************************
+ * Definitions
+ ******************************************************************************/
+
+/*! @name Driver version */
+/*@{*/
+/*! @brief Group interrupt driver version for SDK */
+#define FSL_SC_EVENT_DRIVER_VERSION (MAKE_VERSION(2, 0, 1)) /*!< Version 2.0.1. */
+/*@}*/
+
+/*! @brief The SC Event handler memory pool size in bytes. */
+#ifndef SC_EVENT_HANDLER_MEM_POOL_SIZE
+#define SC_EVENT_HANDLER_MEM_POOL_SIZE (200U)
+#endif
+
+/*! 
+ * @brief The SYSCTR SC Event maybe used as wakeup source in low power applications.
+ * Such as in LPM module(lpm.c), the SYSCTR is used as wakeup source in tickless idle.
+ */
+#ifndef SC_EVENT_USE_SYSCTR
+#define SC_EVENT_USE_SYSCTR (0)
+#endif
+
+#define SC_EVENT_IRQ_DUMMY (0xFFFFFFFU)                         /* Dummy mask. */
+#define SC_EVENT_TYPE_TUPLE(group, irq) (((group) << 28) | (irq)) /* Marco to compose SC Event type. */
+#define SC_EVENT_GET_IRQ_GROUP(type) (((uint32_t)(type) >> 28) & 0xFU)      /* Marco to get SC IRQ group. */
+#define SC_EVENT_GET_IRQ(type) ((uint32_t)(type) & 0xFFFFFFFU)              /* Marco to get SC IRQ mask. */
+
+/*!
+ * @brief Get SC Event list object structure pointer.
+ */
+#define SC_EVENT_LIST_OBJ(type, field, list) (type)((uint32_t)(list) - (uint32_t)(&((type)0)->field))
+
+/*! @brief SC Event type. */
+typedef enum _sc_event
+{
+    kSCEvent_TempHigh = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_HIGH), /*!< Temp alarm interrupt */
+    kSCEvent_TempCpu0High =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_CPU0_HIGH), /*!< CPU0 temp alarm interrupt */
+    kSCEvent_TempCpu1High =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_CPU1_HIGH), /*!< CPU1 temp alarm interrupt */
+    kSCEvent_TempGpu0High =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_GPU0_HIGH), /*!< GPU0 temp alarm interrupt */
+    kSCEvent_TempGpu1High =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_GPU1_HIGH), /*!< GPU1 temp alarm interrupt */
+    kSCEvent_TempDrc0High =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_DRC0_HIGH), /*!< DRC0 temp alarm interrupt */
+    kSCEvent_TempDrc1High =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_DRC1_HIGH), /*!< DRC1 temp alarm interrupt */
+    kSCEvent_TempVpuHigh =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_VPU_HIGH), /*!< VPU temp alarm interrupt */
+    kSCEvent_TempPmic0High =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_PMIC0_HIGH), /*!< PMIC0 temp alarm interrupt */
+    kSCEvent_TempPmic1High =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_PMIC1_HIGH),         /*!< PMIC1 temp alarm interrupt */
+    kSCEvent_TempLow = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_LOW), /*!< Temp alarm interrupt */
+    kSCEvent_TempCpu0Low =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_CPU0_LOW), /*!< CPU0 temp alarm interrupt */
+    kSCEvent_TempCpu1Low =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_CPU1_LOW), /*!< CPU1 temp alarm interrupt */
+    kSCEvent_TempGpu0Low =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_GPU0_LOW), /*!< GPU0 temp alarm interrupt */
+    kSCEvent_TempGpu1Low =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_GPU1_LOW), /*!< GPU1 temp alarm interrupt */
+    kSCEvent_TempDrc0Low =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_DRC0_LOW), /*!< DRC0 temp alarm interrupt */
+    kSCEvent_TempDrc1Low =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_DRC1_LOW),                  /*!< DRC1 temp alarm interrupt */
+    kSCEvent_TempVpuLow = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_VPU_LOW), /*!< VPU temp alarm interrupt */
+    kSCEvent_TempPmic0Low =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_PMIC0_LOW), /*!< PMIC0 temp alarm interrupt */
+    kSCEvent_TempPmic1Low =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_PMIC1_LOW), /*!< PMIC1 temp alarm interrupt */
+    kSCEvent_TempPmic2High =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_PMIC2_HIGH), /*!< PMIC2 temp alarm interrupt */
+    kSCEvent_TempPmic2Low =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_TEMP, SC_IRQ_TEMP_PMIC2_LOW), /*!< PMIC2 temp alarm interrupt */
+
+    kSCEvent_Wdog = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_WDOG, SC_IRQ_WDOG), /*!< Watchdog interrupt */
+
+    kSCEvent_Rtc = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_RTC, SC_IRQ_RTC), /*!< RTC interrupt */
+
+    kSCEvent_Button = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_WAKE, SC_IRQ_BUTTON), /*!< Button interrupt */
+    kSCEvent_Pad    = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_WAKE, SC_IRQ_PAD),    /*!< Pad wakeup */
+    kSCEvent_User1  = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_WAKE, SC_IRQ_USR1),   /*!< User defined 1 */
+    kSCEvent_User2  = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_WAKE, SC_IRQ_USR2),   /*!< User defined 2 */
+    kSCEvent_BcPad =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_WAKE, SC_IRQ_BC_PAD), /*!< Pad wakeup (broadcast to all partitions) */
+#if (defined(SC_EVENT_USE_SYSCTR) && SC_EVENT_USE_SYSCTR)
+    kSCEvent_SysCtr = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_SYSCTR, SC_IRQ_SYSCTR), /*!< System counter interrupts */
+#endif
+    kSCEvent_Rebooted =
+        SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_REBOOTED, SC_EVENT_IRQ_DUMMY), /*!< Partition reboot complete */
+
+    kSCEvent_Reboot = SC_EVENT_TYPE_TUPLE(SC_IRQ_GROUP_REBOOT, SC_EVENT_IRQ_DUMMY) /*!< Partition reboot starting */
+} sc_event_t;
+
+/*! @brief SC Event callback function.
+ *
+ *  The SC Event callback returns a status from the underlying layer.
+ *  The status reflects the SC IRQ status got by sc_irq_status SCFW API. It's the bitmask of enabled IRQ in a group.
+ *  Such as for kSCEvent_Reboot/kSCEvent_Rebooted event, if more than one partition reboot event is enabled, this status
+ *  flag can be used to identify which partition the event comes from. Refer to SCFW API sc_irq_status for more details.
+ */
+typedef void (*sc_event_callback_t)(uint32_t status, void *userData);
+
+/*! @brief SC Event Semaphore Wait function.
+ *
+ *  The Semaphore Wait/Post function is used in RTOS envirnoment to pass Semaphore Wait/Post function into SC Event
+ *  driver. Unused in baremetal envirnonment. The task can wait the event by calling SCEvent_WaitEvent function.
+ */
+typedef status_t (*sc_event_sema4_wait_t)(void *sem, uint32_t timeout);
+
+/*! @brief SC Event Semaphore Post function.
+ *
+ *  The Semaphore Wait/Post function is used in RTOS envirnoment to pass Semaphore Wait/Post function into SC Event
+ *  driver. Unused in baremetal envirnonment. The post function is called to give semaphore if event triggered in IRQ.
+ */
+typedef void (*sc_event_sema4_post_t)(void *sem);
+
+/**
+ * @brief SC Event list fields
+ */
+typedef struct _sc_event_list
+{
+    struct _sc_event_list *prev; /*!< previous list node */
+    struct _sc_event_list *next; /*!< next list node */
+} sc_event_list_t;
+
+/*! @brief SC Event handler structure. */
+struct _sc_event_handler
+{
+    sc_event_list_t node;
+    sc_event_t event;             /*!< Event type. */
+    sc_event_callback_t callback; /*!< Event callback. */
+    void *data;                   /*!< User data. */
+};
+
+/*!
+ * @brief SC Event handler is a pointer to the SC Event handler instance
+ */
+typedef struct _sc_event_handler *sc_event_handler_t;
+/*******************************************************************************
+ * API
+ ******************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * @brief Initialize SC Event module.
+
+ * This function enable the IPC MU interrupt, setup to listen the event comes from SCU/SCFW.
+ *
+ * @param priority The SC IRQ interrupt priority. Once any SC IRQ enabled, the SCU will broadcast MU interrupt through
+ *  the IPC MU to M4 cores.
+ *
+ * @retval None.
+ */
+void SCEvent_Init(uint8_t priority);
+
+/*!
+ * @brief Deinitialize SC Event.
+ *
+ * This function disable the IPC MU interrupt.
+ *
+ */
+void SCEvent_Deinit(void);
+
+/*!
+ * @brief Register SC Event handler.
+
+ * This function register the handler for the specified event. When the event is enabled  by SCEvent_Config and happens,
+ * the callback will be called from SCEvent_process. More than one callback can be added for an event.
+ * But the total registered events are limited to
+ * SC_EVENT_HANDLER_MEM_POOL_SIZE/(sizeof(struct _sc_event_handler)).
+ *
+ * @param event The event to be registered with.
+ * @param callback The callback function. This function will be called from SCEvent_process.
+ * @param userData User defined callback function parameter.
+ *
+ * @retval SC Event handler.
+ */
+sc_event_handler_t SCEvent_RegisterEventHandler(sc_event_t event, sc_event_callback_t callback, void *userData);
+
+/*!
+ * @brief Unregister SC Event handler.
+
+ * This function unregister and delete the given event handler.
+ *
+ * @param handler The SC Event handler to unregister.
+ *
+ * @retval none.
+ */
+void SCEvent_UnregisterEventHandler(sc_event_handler_t handler);
+
+/*!
+ * @brief Configure SC Event.
+
+ * This function enables/disables response for the event comes from SCU/SCFW.
+ *
+ * @param event The event to be configured.
+ * @param enable Enable the event or not.
+ * @param pt Which partition the event comes from. Only applicable for partition reboot event: kSCEvent_Rebooted,
+ kSCEvent_Reboot.
+ *
+ * @retval kStatus_Success - Configure SC Event Successfully.
+ * @retval kStatus_Fail    - Failed to configure SC Event.
+ */
+status_t SCEvent_Config(sc_event_t event, bool enable, uint32_t pt);
+
+/*!
+ * @brief SCEvent Process function.
+ *
+ * This function is used to check SC event status and handle all the registered event handlers. The SCFW API call is
+ * a blocking call and used to check SC IRQ status, so this function should be executed in task context to make sure
+ * other event(interrupt) handled in time. In RTOS enviroment, application creats a task and wait for some events came
+ * using SCEvent_WaitEvent to run this function to handle the events. In baremetal enviroment, application need
+ * preiodically call this function to make sure the pending events handled.
+ */
+void SCEvent_Process(void);
+
+/*!
+ * @brief Set Semaphore and Semaphore wait/post funciton in RTOS environment.
+ *
+ *  The Semaphore Wait/Post function is used in RTOS envirnoment to pass Semaphore Wait/Post function into SC Event
+ * driver. Unused in baremetal envirnonment. The SCEvent_process will wait the Semaphore registered by
+ * SCEvent_SetWaitPostFunc until the event comes, and give the Semaphore, then it will handle the event and call the
+ * event handler's callback.
+ *
+ * @param wait Semaphore wait function.
+ * @param post Semaphore post function.
+ * @param sem Semaphore.
+ * @param timeout timeout.
+ *
+ * @retval kStatus_Success if succeed, kStatus_Timeout if timeout.
+ */
+status_t SCEvent_WaitEvent(sc_event_sema4_wait_t wait, sc_event_sema4_post_t post, void *sem, uint32_t timeout);
+
+#ifdef __cplusplus
+}
+#endif
+
+/*@}*/
+
+#endif /* _SC_EVENT_H_ */