1 files changed, 148 insertions, 0 deletions
diff --git a/firmware/targets/furi_hal_include/furi_hal_irda.h b/firmware/targets/furi_hal_include/furi_hal_irda.h
new file mode 100644
index 00000000..551210b2
--- /dev/null
+++ b/firmware/targets/furi_hal_include/furi_hal_irda.h
@@ -0,0 +1,148 @@
+/**
+ * @file furi_hal_irda.h
+ * IRDA HAL API
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define IRDA_MAX_FREQUENCY 56000
+#define IRDA_MIN_FREQUENCY 10000
+
+typedef enum {
+    FuriHalIrdaTxGetDataStateOk, /**< New data obtained */
+    FuriHalIrdaTxGetDataStateDone, /**< New data obtained, and this is end of package */
+    FuriHalIrdaTxGetDataStateLastDone, /**< New data obtained, and this is end of package and no more data available */
+} FuriHalIrdaTxGetDataState;
+
+/** Callback type for providing data to IRDA DMA TX system. It is called every tim */
+typedef FuriHalIrdaTxGetDataState (
+    *FuriHalIrdaTxGetDataISRCallback)(void* context, uint32_t* duration, bool* level);
+
+/** Callback type called every time signal is sent by DMA to Timer.
+ *
+ * Actually, it means there are 2 timings left to send for this signal, which is
+ * almost end. Don't use this callback to stop transmission, as far as there are
+ * next signal is charged for transmission by DMA.
+ */
+typedef void (*FuriHalIrdaTxSignalSentISRCallback)(void* context);
+
+/** Signature of callback function for receiving continuous IRDA rx signal.
+ *
+ * @param      ctx[in]       context to pass to callback
+ * @param      level[in]     level of input IRDA rx signal
+ * @param      duration[in]  duration of continuous rx signal level in us
+ */
+typedef void (*FuriHalIrdaRxCaptureCallback)(void* ctx, bool level, uint32_t duration);
+
+/** Signature of callback function for reaching silence timeout on IRDA port.
+ *
+ * @param      ctx[in]  context to pass to callback
+ */
+typedef void (*FuriHalIrdaRxTimeoutCallback)(void* ctx);
+
+/** Initialize IRDA RX timer to receive interrupts.
+ *
+ * It provides interrupts for every RX-signal edge changing with its duration.
+ */
+void furi_hal_irda_async_rx_start(void);
+
+/** Deinitialize IRDA RX interrupt.
+ */
+void furi_hal_irda_async_rx_stop(void);
+
+/** Setup hal for receiving silence timeout.
+ *
+ * Should be used with 'furi_hal_irda_timeout_irq_set_callback()'.
+ *
+ * @param[in]  timeout_us  time to wait for silence on IRDA port before
+ *                         generating IRQ.
+ */
+void furi_hal_irda_async_rx_set_timeout(uint32_t timeout_us);
+
+/** Setup callback for previously initialized IRDA RX interrupt.
+ *
+ * @param[in]  callback  callback to call when RX signal edge changing occurs
+ * @param[in]  ctx       context for callback
+ */
+void furi_hal_irda_async_rx_set_capture_isr_callback(
+    FuriHalIrdaRxCaptureCallback callback,
+    void* ctx);
+
+/** Setup callback for reaching silence timeout on IRDA port.
+ *
+ * Should setup hal with 'furi_hal_irda_setup_rx_timeout_irq()' first.
+ *
+ * @param[in]  callback  callback for silence timeout
+ * @param[in]  ctx       context to pass to callback
+ */
+void furi_hal_irda_async_rx_set_timeout_isr_callback(
+    FuriHalIrdaRxTimeoutCallback callback,
+    void* ctx);
+
+/** Check if IRDA is in use now.
+ *
+ * @return     true if IRDA is busy, false otherwise.
+ */
+bool furi_hal_irda_is_busy(void);
+
+/** Set callback providing new data.
+ *
+ * This function has to be called before furi_hal_irda_async_tx_start().
+ *
+ * @param[in]  callback  function to provide new data
+ * @param[in]  context   context for callback
+ */
+void furi_hal_irda_async_tx_set_data_isr_callback(
+    FuriHalIrdaTxGetDataISRCallback callback,
+    void* context);
+
+/** Start IR asynchronous transmission.
+ *
+ * It can be stopped by 2 reasons:
+ * 1. implicit call for furi_hal_irda_async_tx_stop()
+ * 2. callback can provide FuriHalIrdaTxGetDataStateLastDone response which
+ *    means no more data available for transmission.
+ *
+ * Any func (furi_hal_irda_async_tx_stop() or
+ * furi_hal_irda_async_tx_wait_termination()) has to be called to wait end of
+ * transmission and free resources.
+ *
+ * @param[in]  freq        frequency for PWM
+ * @param[in]  duty_cycle  duty cycle for PWM
+ */
+void furi_hal_irda_async_tx_start(uint32_t freq, float duty_cycle);
+
+/** Stop IR asynchronous transmission and free resources.
+ *
+ * Transmission will stop as soon as transmission reaches end of package
+ * (FuriHalIrdaTxGetDataStateDone or FuriHalIrdaTxGetDataStateLastDone).
+ */
+void furi_hal_irda_async_tx_stop(void);
+
+/** Wait for end of IR asynchronous transmission and free resources.
+ *
+ * Transmission will stop as soon as transmission reaches end of transmission
+ * (FuriHalIrdaTxGetDataStateLastDone).
+ */
+void furi_hal_irda_async_tx_wait_termination(void);
+
+/** Set callback for end of signal transmission
+ *
+ * @param[in]  callback  function to call when signal is sent
+ * @param[in]  context   context for callback
+ */
+void furi_hal_irda_async_tx_set_signal_sent_isr_callback(
+    FuriHalIrdaTxSignalSentISRCallback callback,
+    void* context);
+
+#ifdef __cplusplus
+}
+#endif