mmagic_controller.h

/*
 * Copyright 2025 Morse Micro
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Warning: this file is autogenerated. Do not modify by hand.
 */
 
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
#include <memory.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef MM_PACKED
#define MM_PACKED __attribute__((packed))
#endif
 
enum mmagic_security_type
{
    MMAGIC_SECURITY_TYPE_SAE  = 0,
    MMAGIC_SECURITY_TYPE_OWE  = 1,
    MMAGIC_SECURITY_TYPE_OPEN = 2,
};
 
enum mmagic_pmf_mode
{
    MMAGIC_PMF_MODE_REQUIRED = 0,
    MMAGIC_PMF_MODE_DISABLED = 1,
};
 
enum mmagic_power_save_mode
{
    MMAGIC_POWER_SAVE_MODE_DISABLED = 0,
    MMAGIC_POWER_SAVE_MODE_ENABLED  = 1,
};
 
enum mmagic_mcs10_mode
{
    MMAGIC_MCS10_MODE_DISABLED = 0,
    MMAGIC_MCS10_MODE_FORCED   = 1,
    MMAGIC_MCS10_MODE_AUTO     = 2,
};
 
enum mmagic_duty_cycle_mode
{
    MMAGIC_DUTY_CYCLE_MODE_SPREAD = 0,
    MMAGIC_DUTY_CYCLE_MODE_BURST  = 1,
};
 
enum mmagic_station_type
{
    MMAGIC_STATION_TYPE_SENSOR     = 0,
    MMAGIC_STATION_TYPE_NON_SENSOR = 1,
};
 
enum mmagic_status
{
    MMAGIC_STATUS_OK                       = 0,
    MMAGIC_STATUS_ERROR                    = 1,
    MMAGIC_STATUS_INVALID_ARG              = 2,
    MMAGIC_STATUS_UNAVAILABLE              = 3,
    MMAGIC_STATUS_TIMEOUT                  = 4,
    MMAGIC_STATUS_INVALID_STREAM           = 5,
    MMAGIC_STATUS_NOT_FOUND                = 6,
    MMAGIC_STATUS_NOT_SUPPORTED            = 7,
    MMAGIC_STATUS_TX_ERROR                 = 8,
    MMAGIC_STATUS_NO_MEM                   = 9,
    MMAGIC_STATUS_CLOSED                   = 10,
    MMAGIC_STATUS_CHANNEL_LIST_NOT_SET     = 11,
    MMAGIC_STATUS_SHUTDOWN_BLOCKED         = 12,
    MMAGIC_STATUS_CHANNEL_INVALID          = 13,
    MMAGIC_STATUS_NOT_RUNNING              = 14,
    MMAGIC_STATUS_NO_LINK                  = 15,
    MMAGIC_STATUS_UNKNOWN_HOST             = 16,
    MMAGIC_STATUS_SOCKET_FAILED            = 17,
    MMAGIC_STATUS_SOCKET_CONNECT_FAILED    = 18,
    MMAGIC_STATUS_SOCKET_BIND_FAILED       = 19,
    MMAGIC_STATUS_SOCKET_LISTEN_FAILED     = 20,
    MMAGIC_STATUS_NTP_KOD_RECEIVED         = 21,
    MMAGIC_STATUS_NTP_KOD_BACKOFF_RECEIVED = 22,
    MMAGIC_STATUS_SOCKET_SEND_FAILED       = 23,
    MMAGIC_STATUS_INVALID_CREDENTIALS      = 24,
    MMAGIC_STATUS_HANDSHAKE_FAILED         = 25,
    MMAGIC_STATUS_AUTHENTICATION_FAILED    = 26,
    MMAGIC_STATUS_MISSING_CREDENTIALS      = 27,
    MMAGIC_STATUS_TIME_NOT_SYNCHRONIZED    = 28,
    MMAGIC_STATUS_MQTT_REFUSED             = 29,
    MMAGIC_STATUS_MQTT_KEEPALIVE_TIMEOUT   = 30,
    MMAGIC_STATUS_BAD_VERSION              = 32,
};
 
enum mmagic_iperf_mode
{
    MMAGIC_IPERF_MODE_UDP_SERVER = 0,
    MMAGIC_IPERF_MODE_TCP_SERVER = 1,
    MMAGIC_IPERF_MODE_UDP_CLIENT = 2,
    MMAGIC_IPERF_MODE_TCP_CLIENT = 3,
};
 
enum mmagic_iperf_state
{
    MMAGIC_IPERF_STATE_NOT_STARTED = 0,
    MMAGIC_IPERF_STATE_RUNNING     = 1,
    MMAGIC_IPERF_STATE_FINISHED    = 2,
    MMAGIC_IPERF_STATE_ABORTED     = 3,
};
 
enum mmagic_ip_link_state
{
    MMAGIC_IP_LINK_STATE_DOWN = 0,
    MMAGIC_IP_LINK_STATE_UP   = 1,
};
 
enum mmagic_deep_sleep_mode
{
    MMAGIC_DEEP_SLEEP_MODE_DISABLED = 0,
    MMAGIC_DEEP_SLEEP_MODE_ONE_SHOT = 1,
    MMAGIC_DEEP_SLEEP_MODE_HARDWARE = 2,
};
 
enum mmagic_standby_mode_exit_reason
{
    MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_NONE                    = 0,
    MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_WAKEUP_FRAME            = 1,
    MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_ASSOCIATE               = 2,
    MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_EXT_INPUT               = 3,
    MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_WHITELIST_PKT           = 4,
    MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_TCP_CONNECTION_LOST     = 5,
    MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_HW_SCAN_NOT_ENABLED     = 6,
    MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_HW_SCAN_FAILED_TO_START = 7,
};
 
enum mmagic_sta_state
{
    MMAGIC_STA_STATE_DISCONNECTED = 1,
    MMAGIC_STA_STATE_CONNECTING   = 2,
    MMAGIC_STA_STATE_CONNECTED    = 3,
};
 
enum mmagic_sta_event
{
    MMAGIC_STA_EVENT_SCAN_REQUEST     = 0,
    MMAGIC_STA_EVENT_SCAN_COMPLETE    = 1,
    MMAGIC_STA_EVENT_SCAN_ABORT       = 2,
    MMAGIC_STA_EVENT_AUTH_REQUEST     = 3,
    MMAGIC_STA_EVENT_ASSOC_REQUEST    = 4,
    MMAGIC_STA_EVENT_DEAUTH_TX        = 5,
    MMAGIC_STA_EVENT_CTRL_PORT_OPEN   = 6,
    MMAGIC_STA_EVENT_CTRL_PORT_CLOSED = 7,
};
 
struct MM_PACKED string32
{
    uint8_t len;
 
    char data[32 + 1];
};
 
struct MM_PACKED string100
{
    uint8_t len;
 
    char data[100 + 1];
};
 
struct MM_PACKED string254
{
    uint8_t len;
 
    char data[254 + 1];
};
 
struct MM_PACKED raw255
{
    uint8_t len;
 
    uint8_t data[255];
};
 
struct MM_PACKED raw1536
{
    uint16_t len;
 
    uint8_t data[1536];
};
 
struct MM_PACKED struct_mac_addr
{
    uint8_t addr[6];
};
 
struct MM_PACKED struct_country_code
{
    char country_code[3];
};
 
struct MM_PACKED struct_oui
{
    uint8_t oui[3];
};
 
struct MM_PACKED struct_oui_list
{
    uint8_t count;
    struct struct_oui ouis[5];
};
 
struct MM_PACKED struct_scan_result
{
    struct string32 ssid;
    struct struct_mac_addr bssid;
    int32_t rssi;
    struct raw255 ies;
    uint16_t received_ies_len;
    uint16_t beacon_interval;
    uint16_t capability_info;
    uint32_t channel_freq_hz;
    uint8_t bw_mhz;
    uint8_t op_bw_mhz;
    uint64_t tsf;
};
 
struct MM_PACKED struct_version_info
{
    struct string32 application_version;
    struct string32 bootloader_version;
    struct string32 user_hardware_version;
    struct string32 morse_firmware_version;
    struct string32 morselib_version;
    struct string32 morse_hardware_version;
};
 
struct MM_PACKED struct_scan_status
{
    struct struct_scan_result results[10];
    uint8_t num;
};
 
struct MM_PACKED struct_ip_addr
{
    char addr[48];
};
 
struct MM_PACKED struct_ip_status
{
    enum mmagic_ip_link_state link_state;
    bool dhcp_enabled;
    struct struct_ip_addr ip_addr;
    struct struct_ip_addr netmask;
    struct struct_ip_addr gateway;
    struct struct_ip_addr broadcast;
    struct struct_ip_addr dns_servers[2];
};
 
struct MM_PACKED struct_ping_status
{
    struct struct_ip_addr receiver_addr;
    uint32_t total_count;
    uint32_t recv_count;
    uint32_t min_time_ms;
    uint32_t avg_time_ms;
    uint32_t max_time_ms;
    uint16_t session_id;
};
 
struct MM_PACKED struct_iperf_status
{
    struct struct_ip_addr remote_addr;
    uint16_t remote_port;
    struct struct_ip_addr local_addr;
    uint16_t local_port;
    uint64_t bytes_transferred;
    uint32_t duration_ms;
    uint32_t bandwidth_kbitpsec;
};
 
struct MM_PACKED struct_buffer64
{
    uint8_t buffer[64];
    uint8_t len;
};
 
enum mmagic_subsystem
{
    MMAGIC_WLAN  = 1,
    MMAGIC_IP    = 2,
    MMAGIC_PING  = 3,
    MMAGIC_IPERF = 4,
    MMAGIC_SYS   = 5,
    MMAGIC_TCP   = 6,
    MMAGIC_TLS   = 7,
    MMAGIC_NTP   = 8,
    MMAGIC_MQTT  = 9,
};
 
struct mmagic_controller;
 
typedef void (*mmagic_controller_agent_start_cb_t)(struct mmagic_controller *controller, void *arg);
 
struct mmagic_controller_init_args
{
    mmagic_controller_agent_start_cb_t agent_start_cb;
    void *agent_start_arg;
};
 
#define MMAGIC_CONTROLLER_ARGS_INIT { 0 }
 
struct mmagic_controller *mmagic_controller_init(const struct mmagic_controller_init_args *args);
 
void mmagic_controller_deinit(struct mmagic_controller *controller);
 
#define CONTROL_STREAM  0
 
#define MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS 1000
 
enum mmagic_status mmagic_controller_tx(
    struct mmagic_controller *controller, uint8_t stream_id,
    uint8_t submodule_id, uint8_t command_id, uint8_t subcommand_id,
    const uint8_t *buffer, size_t buffer_length);
 
enum mmagic_status mmagic_controller_rx(struct mmagic_controller *controller, uint8_t stream_id,
                                        uint8_t submodule_id,
                                        uint8_t command_id, uint8_t subcommand_id,
                                        uint8_t *buffer, size_t buffer_length, uint32_t timeout_ms);
 
enum mmagic_status mmagic_controller_agent_sync(struct mmagic_controller *controller,
                                                uint32_t timeout_ms);
 
enum mmagic_status mmagic_controller_request_agent_reset(struct mmagic_controller *controller);
 
enum mmagic_wlan_var
{
    MMAGIC_WLAN_VAR_COUNTRY_CODE              = 0,
    MMAGIC_WLAN_VAR_SSID                      = 1,
    MMAGIC_WLAN_VAR_PASSWORD                  = 2,
    MMAGIC_WLAN_VAR_SECURITY                  = 3,
    MMAGIC_WLAN_VAR_RAW_PRIORITY              = 4,
    MMAGIC_WLAN_VAR_BSSID                     = 5,
    MMAGIC_WLAN_VAR_PMF_MODE                  = 6,
    MMAGIC_WLAN_VAR_STATION_TYPE              = 7,
    MMAGIC_WLAN_VAR_RTS_THRESHOLD             = 8,
    MMAGIC_WLAN_VAR_SGI_ENABLED               = 9,
    MMAGIC_WLAN_VAR_SUBBANDS_ENABLED          = 10,
    MMAGIC_WLAN_VAR_AMPDU_ENABLED             = 11,
    MMAGIC_WLAN_VAR_POWER_SAVE_MODE           = 12,
    MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD        = 13,
    MMAGIC_WLAN_VAR_CAC_ENABLED               = 14,
    MMAGIC_WLAN_VAR_OFFLOAD_ARP_RESPONSE      = 15,
    MMAGIC_WLAN_VAR_OFFLOAD_ARP_REFRESH_S     = 16,
    MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS = 17,
    MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS = 18,
    MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED         = 19,
    MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S  = 20,
    MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S = 21,
    MMAGIC_WLAN_VAR_QOS_0_PARAMS              = 22,
    MMAGIC_WLAN_VAR_QOS_1_PARAMS              = 23,
    MMAGIC_WLAN_VAR_QOS_2_PARAMS              = 24,
    MMAGIC_WLAN_VAR_QOS_3_PARAMS              = 25,
    MMAGIC_WLAN_VAR_MCS10_MODE                = 26,
    MMAGIC_WLAN_VAR_STA_EVT_EN                = 27,
    MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE           = 28,
};
 
enum mmagic_wlan_cmd
{
    MMAGIC_WLAN_CMD_GET                        = 0,
    MMAGIC_WLAN_CMD_SET                        = 1,
    MMAGIC_WLAN_CMD_LOAD                       = 2,
    MMAGIC_WLAN_CMD_COMMIT                     = 3,
    MMAGIC_WLAN_CMD_CONNECT                    = 8,
    MMAGIC_WLAN_CMD_DISCONNECT                 = 9,
    MMAGIC_WLAN_CMD_SCAN                       = 10,
    MMAGIC_WLAN_CMD_GET_RSSI                   = 11,
    MMAGIC_WLAN_CMD_GET_MAC_ADDR               = 12,
    MMAGIC_WLAN_CMD_WNM_SLEEP                  = 13,
    MMAGIC_WLAN_CMD_BEACON_MONITOR_ENABLE      = 14,
    MMAGIC_WLAN_CMD_BEACON_MONITOR_DISABLE     = 15,
    MMAGIC_WLAN_CMD_STANDBY_ENTER              = 16,
    MMAGIC_WLAN_CMD_STANDBY_EXIT               = 17,
    MMAGIC_WLAN_CMD_STANDBY_SET_STATUS_PAYLOAD = 18,
    MMAGIC_WLAN_CMD_STANDBY_SET_WAKE_FILTER    = 19,
    MMAGIC_WLAN_CMD_STANDBY_SET_CONFIG         = 20,
    MMAGIC_WLAN_CMD_GET_STA_STATUS             = 21,
};
 
enum mmagic_ip_var
{
    MMAGIC_IP_VAR_IP_ADDR            = 0,
    MMAGIC_IP_VAR_NETMASK            = 1,
    MMAGIC_IP_VAR_GATEWAY            = 2,
    MMAGIC_IP_VAR_DNS_SERVER0        = 3,
    MMAGIC_IP_VAR_DNS_SERVER1        = 4,
    MMAGIC_IP_VAR_DHCP_ENABLED       = 5,
    MMAGIC_IP_VAR_DHCP_OFFLOAD       = 6,
    MMAGIC_IP_VAR_LINK_STATUS_EVT_EN = 7,
};
 
enum mmagic_ip_cmd
{
    MMAGIC_IP_CMD_GET                           = 0,
    MMAGIC_IP_CMD_SET                           = 1,
    MMAGIC_IP_CMD_LOAD                          = 2,
    MMAGIC_IP_CMD_COMMIT                        = 3,
    MMAGIC_IP_CMD_STATUS                        = 8,
    MMAGIC_IP_CMD_RELOAD                        = 9,
    MMAGIC_IP_CMD_ENABLE_TCP_KEEPALIVE_OFFLOAD  = 10,
    MMAGIC_IP_CMD_DISABLE_TCP_KEEPALIVE_OFFLOAD = 11,
    MMAGIC_IP_CMD_SET_WHITELIST_FILTER          = 12,
    MMAGIC_IP_CMD_CLEAR_WHITELIST_FILTER        = 13,
};
 
enum mmagic_ping_var
{
    MMAGIC_PING_VAR_TARGET   = 0,
    MMAGIC_PING_VAR_INTERVAL = 1,
    MMAGIC_PING_VAR_COUNT    = 2,
};
 
enum mmagic_ping_cmd
{
    MMAGIC_PING_CMD_GET    = 0,
    MMAGIC_PING_CMD_SET    = 1,
    MMAGIC_PING_CMD_LOAD   = 2,
    MMAGIC_PING_CMD_COMMIT = 3,
    MMAGIC_PING_CMD_RUN    = 8,
};
 
enum mmagic_iperf_var
{
    MMAGIC_IPERF_VAR_MODE   = 0,
    MMAGIC_IPERF_VAR_SERVER = 1,
    MMAGIC_IPERF_VAR_PORT   = 2,
    MMAGIC_IPERF_VAR_AMOUNT = 3,
};
 
enum mmagic_iperf_cmd
{
    MMAGIC_IPERF_CMD_GET    = 0,
    MMAGIC_IPERF_CMD_SET    = 1,
    MMAGIC_IPERF_CMD_LOAD   = 2,
    MMAGIC_IPERF_CMD_COMMIT = 3,
    MMAGIC_IPERF_CMD_RUN    = 8,
};
 
enum mmagic_sys_cmd
{
    MMAGIC_SYS_CMD_GET         = 0,
    MMAGIC_SYS_CMD_SET         = 1,
    MMAGIC_SYS_CMD_LOAD        = 2,
    MMAGIC_SYS_CMD_COMMIT      = 3,
    MMAGIC_SYS_CMD_RESET       = 8,
    MMAGIC_SYS_CMD_DEEP_SLEEP  = 9,
    MMAGIC_SYS_CMD_GET_VERSION = 10,
};
 
enum mmagic_tcp_cmd
{
    MMAGIC_TCP_CMD_GET        = 0,
    MMAGIC_TCP_CMD_SET        = 1,
    MMAGIC_TCP_CMD_LOAD       = 2,
    MMAGIC_TCP_CMD_COMMIT     = 3,
    MMAGIC_TCP_CMD_CONNECT    = 8,
    MMAGIC_TCP_CMD_BIND       = 9,
    MMAGIC_TCP_CMD_RECV       = 10,
    MMAGIC_TCP_CMD_SEND       = 11,
    MMAGIC_TCP_CMD_READ_POLL  = 12,
    MMAGIC_TCP_CMD_WRITE_POLL = 13,
    MMAGIC_TCP_CMD_ACCEPT     = 14,
    MMAGIC_TCP_CMD_CLOSE      = 15,
};
 
enum mmagic_tls_var
{
    MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE = 0,
    MMAGIC_TLS_VAR_CLIENT_CERTIFICATE  = 1,
    MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY  = 2,
};
 
enum mmagic_tls_cmd
{
    MMAGIC_TLS_CMD_GET    = 0,
    MMAGIC_TLS_CMD_SET    = 1,
    MMAGIC_TLS_CMD_LOAD   = 2,
    MMAGIC_TLS_CMD_COMMIT = 3,
};
 
enum mmagic_ntp_var
{
    MMAGIC_NTP_VAR_SERVER = 0,
};
 
enum mmagic_ntp_cmd
{
    MMAGIC_NTP_CMD_GET      = 0,
    MMAGIC_NTP_CMD_SET      = 1,
    MMAGIC_NTP_CMD_LOAD     = 2,
    MMAGIC_NTP_CMD_COMMIT   = 3,
    MMAGIC_NTP_CMD_SYNC     = 8,
    MMAGIC_NTP_CMD_GET_TIME = 9,
};
 
enum mmagic_mqtt_cmd
{
    MMAGIC_MQTT_CMD_GET         = 0,
    MMAGIC_MQTT_CMD_SET         = 1,
    MMAGIC_MQTT_CMD_LOAD        = 2,
    MMAGIC_MQTT_CMD_COMMIT      = 3,
    MMAGIC_MQTT_CMD_START_AGENT = 8,
    MMAGIC_MQTT_CMD_PUBLISH     = 9,
    MMAGIC_MQTT_CMD_SUBSCRIBE   = 10,
    MMAGIC_MQTT_CMD_STOP_AGENT  = 11,
};
 
static inline enum mmagic_status mmagic_controller_get_wlan_country_code(
    struct mmagic_controller *controller, struct struct_country_code *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_COUNTRY_CODE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_COUNTRY_CODE, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_country_code(
    struct mmagic_controller *controller, struct struct_country_code *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_COUNTRY_CODE, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_COUNTRY_CODE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_ssid(
    struct mmagic_controller *controller, struct string32 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_SSID, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_SSID, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_ssid(
    struct mmagic_controller *controller, const char *var)
{
    struct string32 var_val;
    enum mmagic_status status;
    var_val.len = strlen(var);
    if (var_val.len > sizeof(var_val.data) - 1)
    {
        return MMAGIC_STATUS_INVALID_ARG;
    }
    memcpy(var_val.data, (const uint8_t *)var, var_val.len);
    memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_SSID, (uint8_t *)&var_val, sizeof(var_val));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_SSID, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_password(
    struct mmagic_controller *controller, struct string100 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_PASSWORD, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_PASSWORD, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_password(
    struct mmagic_controller *controller, const char *var)
{
    struct string100 var_val;
    enum mmagic_status status;
    var_val.len = strlen(var);
    if (var_val.len > sizeof(var_val.data) - 1)
    {
        return MMAGIC_STATUS_INVALID_ARG;
    }
    memcpy(var_val.data, (const uint8_t *)var, var_val.len);
    memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_PASSWORD, (uint8_t *)&var_val, sizeof(var_val));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_PASSWORD, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_security(
    struct mmagic_controller *controller, enum mmagic_security_type *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_SECURITY, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_SECURITY, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_security(
    struct mmagic_controller *controller, enum mmagic_security_type var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_SECURITY, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_SECURITY, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_raw_priority(
    struct mmagic_controller *controller, int16_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_RAW_PRIORITY, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_RAW_PRIORITY, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_raw_priority(
    struct mmagic_controller *controller, int16_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_RAW_PRIORITY, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_RAW_PRIORITY, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_bssid(
    struct mmagic_controller *controller, struct struct_mac_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_BSSID, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_BSSID, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_bssid(
    struct mmagic_controller *controller, struct struct_mac_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_BSSID, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_BSSID, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_pmf_mode(
    struct mmagic_controller *controller, enum mmagic_pmf_mode *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_PMF_MODE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_PMF_MODE, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_pmf_mode(
    struct mmagic_controller *controller, enum mmagic_pmf_mode var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_PMF_MODE, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_PMF_MODE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_station_type(
    struct mmagic_controller *controller, enum mmagic_station_type *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_STATION_TYPE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_STATION_TYPE, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_station_type(
    struct mmagic_controller *controller, enum mmagic_station_type var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_STATION_TYPE, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_STATION_TYPE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_rts_threshold(
    struct mmagic_controller *controller, uint32_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_RTS_THRESHOLD, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_RTS_THRESHOLD, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_rts_threshold(
    struct mmagic_controller *controller, uint32_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_RTS_THRESHOLD, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_RTS_THRESHOLD, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_sgi_enabled(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_SGI_ENABLED, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_SGI_ENABLED, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_sgi_enabled(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_SGI_ENABLED, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_SGI_ENABLED, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_subbands_enabled(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_SUBBANDS_ENABLED, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_SUBBANDS_ENABLED, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_subbands_enabled(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_SUBBANDS_ENABLED, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_SUBBANDS_ENABLED, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_ampdu_enabled(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_AMPDU_ENABLED, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_AMPDU_ENABLED, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_ampdu_enabled(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_AMPDU_ENABLED, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_AMPDU_ENABLED, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_power_save_mode(
    struct mmagic_controller *controller, enum mmagic_power_save_mode *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_POWER_SAVE_MODE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_POWER_SAVE_MODE, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_power_save_mode(
    struct mmagic_controller *controller, enum mmagic_power_save_mode var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_POWER_SAVE_MODE, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_POWER_SAVE_MODE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_fragment_threshold(
    struct mmagic_controller *controller, uint32_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_fragment_threshold(
    struct mmagic_controller *controller, uint32_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_cac_enabled(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_CAC_ENABLED, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_CAC_ENABLED, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_cac_enabled(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_CAC_ENABLED, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_CAC_ENABLED, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_offload_arp_response(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_OFFLOAD_ARP_RESPONSE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_OFFLOAD_ARP_RESPONSE, (uint8_t *)var,
                                  sizeof(*var), MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_offload_arp_response(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_OFFLOAD_ARP_RESPONSE, (uint8_t *)&var,
                                  sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_OFFLOAD_ARP_RESPONSE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_offload_arp_refresh_s(
    struct mmagic_controller *controller, uint32_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_OFFLOAD_ARP_REFRESH_S, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_OFFLOAD_ARP_REFRESH_S, (uint8_t *)var,
                                  sizeof(*var), MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_offload_arp_refresh_s(
    struct mmagic_controller *controller, uint32_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_OFFLOAD_ARP_REFRESH_S, (uint8_t *)&var,
                                  sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_OFFLOAD_ARP_REFRESH_S, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_min_health_check_intvl_ms(
    struct mmagic_controller *controller, uint32_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS, (uint8_t *)var,
                                  sizeof(*var), MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_min_health_check_intvl_ms(
    struct mmagic_controller *controller, uint32_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS, (uint8_t *)&var,
                                  sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_max_health_check_intvl_ms(
    struct mmagic_controller *controller, uint32_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS, (uint8_t *)var,
                                  sizeof(*var), MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_max_health_check_intvl_ms(
    struct mmagic_controller *controller, uint32_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS, (uint8_t *)&var,
                                  sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_ndp_probe_enabled(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_ndp_probe_enabled(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_sta_scan_interval_base_s(
    struct mmagic_controller *controller, uint16_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S, (uint8_t *)var,
                                  sizeof(*var), MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_sta_scan_interval_base_s(
    struct mmagic_controller *controller, uint16_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S, (uint8_t *)&var,
                                  sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_sta_scan_interval_limit_s(
    struct mmagic_controller *controller, uint16_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S, (uint8_t *)var,
                                  sizeof(*var), MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_sta_scan_interval_limit_s(
    struct mmagic_controller *controller, uint16_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S, (uint8_t *)&var,
                                  sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_qos_0_params(
    struct mmagic_controller *controller, struct string32 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_QOS_0_PARAMS, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_QOS_0_PARAMS, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_qos_0_params(
    struct mmagic_controller *controller, const char *var)
{
    struct string32 var_val;
    enum mmagic_status status;
    var_val.len = strlen(var);
    if (var_val.len > sizeof(var_val.data) - 1)
    {
        return MMAGIC_STATUS_INVALID_ARG;
    }
    memcpy(var_val.data, (const uint8_t *)var, var_val.len);
    memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_QOS_0_PARAMS, (uint8_t *)&var_val,
                                  sizeof(var_val));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_QOS_0_PARAMS, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_qos_1_params(
    struct mmagic_controller *controller, struct string32 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_QOS_1_PARAMS, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_QOS_1_PARAMS, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_qos_1_params(
    struct mmagic_controller *controller, const char *var)
{
    struct string32 var_val;
    enum mmagic_status status;
    var_val.len = strlen(var);
    if (var_val.len > sizeof(var_val.data) - 1)
    {
        return MMAGIC_STATUS_INVALID_ARG;
    }
    memcpy(var_val.data, (const uint8_t *)var, var_val.len);
    memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_QOS_1_PARAMS, (uint8_t *)&var_val,
                                  sizeof(var_val));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_QOS_1_PARAMS, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_qos_2_params(
    struct mmagic_controller *controller, struct string32 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_QOS_2_PARAMS, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_QOS_2_PARAMS, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_qos_2_params(
    struct mmagic_controller *controller, const char *var)
{
    struct string32 var_val;
    enum mmagic_status status;
    var_val.len = strlen(var);
    if (var_val.len > sizeof(var_val.data) - 1)
    {
        return MMAGIC_STATUS_INVALID_ARG;
    }
    memcpy(var_val.data, (const uint8_t *)var, var_val.len);
    memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_QOS_2_PARAMS, (uint8_t *)&var_val,
                                  sizeof(var_val));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_QOS_2_PARAMS, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_qos_3_params(
    struct mmagic_controller *controller, struct string32 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_QOS_3_PARAMS, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_QOS_3_PARAMS, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_qos_3_params(
    struct mmagic_controller *controller, const char *var)
{
    struct string32 var_val;
    enum mmagic_status status;
    var_val.len = strlen(var);
    if (var_val.len > sizeof(var_val.data) - 1)
    {
        return MMAGIC_STATUS_INVALID_ARG;
    }
    memcpy(var_val.data, (const uint8_t *)var, var_val.len);
    memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_QOS_3_PARAMS, (uint8_t *)&var_val,
                                  sizeof(var_val));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_QOS_3_PARAMS, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_mcs10_mode(
    struct mmagic_controller *controller, enum mmagic_mcs10_mode *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_MCS10_MODE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_MCS10_MODE, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_mcs10_mode(
    struct mmagic_controller *controller, enum mmagic_mcs10_mode var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_MCS10_MODE, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_MCS10_MODE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_sta_evt_en(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_STA_EVT_EN, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_STA_EVT_EN, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_sta_evt_en(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_STA_EVT_EN, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_STA_EVT_EN, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_wlan_duty_cycle_mode(
    struct mmagic_controller *controller, enum mmagic_duty_cycle_mode *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET,
                                  MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_duty_cycle_mode(
    struct mmagic_controller *controller, enum mmagic_duty_cycle_mode var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SET,
                                  MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_wlan_commit_all(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_COMMIT,
                                  0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_WLAN, MMAGIC_WLAN_CMD_COMMIT,
                                  0, NULL, 0, MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_connect_cmd_args
{
    uint32_t timeout;
};
 
static inline enum mmagic_status mmagic_controller_wlan_connect(
    struct mmagic_controller *controller,
    struct
    mmagic_core_wlan_connect_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    /* Account for the timeout argument when waiting for the response and make sure no overflow. */
    if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
    {
        response_timeout_ms += cmd_args->timeout;
    }
    else
    {
        response_timeout_ms = UINT32_MAX;
    }
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_CONNECT, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_CONNECT, 0,
                                  NULL, 0, response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_wlan_disconnect(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_DISCONNECT, 0,
                                  NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_DISCONNECT, 0,
                                NULL, 0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_scan_cmd_args
{
    struct string32 ssid;
    uint32_t timeout;
};
 
struct MM_PACKED mmagic_core_wlan_scan_rsp_args
{
    struct struct_scan_status results;
};
 
static inline enum mmagic_status mmagic_controller_wlan_scan(struct mmagic_controller *controller,
                                                             struct mmagic_core_wlan_scan_cmd_args *
                                                             cmd_args,
                                                             struct mmagic_core_wlan_scan_rsp_args *
                                                             rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    /* Account for the timeout argument when waiting for the response and make sure no overflow. */
    if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
    {
        response_timeout_ms += cmd_args->timeout;
    }
    else
    {
        response_timeout_ms = UINT32_MAX;
    }
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SCAN, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_SCAN, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_get_rssi_rsp_args
{
    int32_t rssi;
};
 
static inline enum mmagic_status mmagic_controller_wlan_get_rssi(
    struct mmagic_controller *controller,
    struct
    mmagic_core_wlan_get_rssi_rsp_args *rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET_RSSI, 0,
                                  NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET_RSSI, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_get_mac_addr_rsp_args
{
    struct struct_mac_addr mac_addr;
};
 
static inline enum mmagic_status mmagic_controller_wlan_get_mac_addr(
    struct mmagic_controller *controller,
    struct
    mmagic_core_wlan_get_mac_addr_rsp_args *rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET_MAC_ADDR,
                                  0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_GET_MAC_ADDR,
                                  0, (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_wnm_sleep_cmd_args
{
    bool wnm_sleep_enabled;
};
 
static inline enum mmagic_status mmagic_controller_wlan_wnm_sleep(
    struct mmagic_controller *controller,
    struct
    mmagic_core_wlan_wnm_sleep_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_WNM_SLEEP, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_WNM_SLEEP, 0,
                                  NULL, 0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_beacon_monitor_enable_cmd_args
{
    struct struct_oui_list oui_filter;
};
 
static inline enum mmagic_status mmagic_controller_wlan_beacon_monitor_enable(
    struct mmagic_controller *controller,
    struct
    mmagic_core_wlan_beacon_monitor_enable_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_BEACON_MONITOR_ENABLE, 0, (uint8_t *)cmd_args,
                                  sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_BEACON_MONITOR_ENABLE, 0, NULL, 0,
                                  response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_wlan_beacon_monitor_disable(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_BEACON_MONITOR_DISABLE, 0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN,
                                MMAGIC_WLAN_CMD_BEACON_MONITOR_DISABLE, 0, NULL, 0,
                                response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_wlan_standby_enter(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_STANDBY_ENTER,
                                  0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_STANDBY_ENTER,
                                0, NULL, 0, response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_wlan_standby_exit(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_STANDBY_EXIT,
                                  0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN, MMAGIC_WLAN_CMD_STANDBY_EXIT, 0,
                                NULL, 0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_standby_set_status_payload_cmd_args
{
    struct struct_buffer64 payload;
};
 
static inline enum mmagic_status mmagic_controller_wlan_standby_set_status_payload(
    struct mmagic_controller *controller,
    struct
    mmagic_core_wlan_standby_set_status_payload_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_STANDBY_SET_STATUS_PAYLOAD, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_STANDBY_SET_STATUS_PAYLOAD, 0, NULL, 0,
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_standby_set_wake_filter_cmd_args
{
    struct struct_buffer64 filter;
    uint32_t offset;
};
 
static inline enum mmagic_status mmagic_controller_wlan_standby_set_wake_filter(
    struct mmagic_controller *controller,
    struct
    mmagic_core_wlan_standby_set_wake_filter_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_STANDBY_SET_WAKE_FILTER, 0, (uint8_t *)cmd_args,
                                  sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_STANDBY_SET_WAKE_FILTER, 0, NULL, 0,
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_standby_set_config_cmd_args
{
    uint32_t notify_period_s;
    struct struct_ip_addr src_ip;
    struct struct_ip_addr dst_ip;
    uint16_t dst_port;
    uint32_t bss_inactivity_s;
    uint32_t snooze_period_s;
    uint32_t snooze_increment_s;
    uint32_t snooze_max_s;
};
 
static inline enum mmagic_status mmagic_controller_wlan_standby_set_config(
    struct mmagic_controller *controller,
    struct
    mmagic_core_wlan_standby_set_config_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_STANDBY_SET_CONFIG, 0, (uint8_t *)cmd_args,
                                  sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_STANDBY_SET_CONFIG, 0, NULL, 0,
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_wlan_get_sta_status_rsp_args
{
    enum mmagic_sta_state sta_status;
};
 
static inline enum mmagic_status mmagic_controller_wlan_get_sta_status(
    struct mmagic_controller *controller,
    struct
    mmagic_core_wlan_get_sta_status_rsp_args *rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_GET_STA_STATUS, 0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_WLAN,
                                  MMAGIC_WLAN_CMD_GET_STA_STATUS, 0, (uint8_t *)rsp_args,
                                  sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_wlan_beacon_rx_event_args
{
    struct raw1536 vendor_ies;
};
 
typedef void (*mmagic_wlan_beacon_rx_event_handler_t)(
    const struct mmagic_wlan_beacon_rx_event_args *event_args, void *arg);
 
void mmagic_controller_register_wlan_beacon_rx_handler(
    struct mmagic_controller *controller,
    mmagic_wlan_beacon_rx_event_handler_t handler, void *arg);
 
struct MM_PACKED mmagic_wlan_standby_exit_event_args
{
    enum mmagic_standby_mode_exit_reason reason;
};
 
typedef void (*mmagic_wlan_standby_exit_event_handler_t)(
    const struct mmagic_wlan_standby_exit_event_args *event_args, void *arg);
 
void mmagic_controller_register_wlan_standby_exit_handler(
    struct mmagic_controller *controller,
    mmagic_wlan_standby_exit_event_handler_t handler, void *arg);
 
struct MM_PACKED mmagic_wlan_sta_event_event_args
{
    enum mmagic_sta_event event;
};
 
typedef void (*mmagic_wlan_sta_event_event_handler_t)(
    const struct mmagic_wlan_sta_event_event_args *event_args, void *arg);
 
void mmagic_controller_register_wlan_sta_event_handler(
    struct mmagic_controller *controller,
    mmagic_wlan_sta_event_event_handler_t handler, void *arg);
 
static inline enum mmagic_status mmagic_controller_get_ip_ip_addr(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_IP_ADDR, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_IP_ADDR, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ip_ip_addr(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_IP_ADDR, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_IP_ADDR, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ip_netmask(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_NETMASK, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_NETMASK, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ip_netmask(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_NETMASK, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_NETMASK, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ip_gateway(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_GATEWAY, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_GATEWAY, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ip_gateway(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_GATEWAY, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_GATEWAY, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ip_dns_server0(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_DNS_SERVER0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_DNS_SERVER0, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ip_dns_server0(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_DNS_SERVER0, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_DNS_SERVER0, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ip_dns_server1(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_DNS_SERVER1, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_DNS_SERVER1, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ip_dns_server1(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_DNS_SERVER1, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_DNS_SERVER1, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ip_dhcp_enabled(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_DHCP_ENABLED, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_DHCP_ENABLED, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ip_dhcp_enabled(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_DHCP_ENABLED, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_DHCP_ENABLED, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ip_dhcp_offload(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_DHCP_OFFLOAD, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_DHCP_OFFLOAD, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ip_dhcp_offload(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_DHCP_OFFLOAD, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_DHCP_OFFLOAD, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ip_link_status_evt_en(
    struct mmagic_controller *controller, bool *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_LINK_STATUS_EVT_EN, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_GET,
                                  MMAGIC_IP_VAR_LINK_STATUS_EVT_EN, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ip_link_status_evt_en(
    struct mmagic_controller *controller, bool var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_LINK_STATUS_EVT_EN, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_SET,
                                  MMAGIC_IP_VAR_LINK_STATUS_EVT_EN, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_ip_commit_all(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_COMMIT, 0,
                                  NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IP, MMAGIC_IP_CMD_COMMIT, 0,
                                  NULL, 0, MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
struct MM_PACKED mmagic_core_ip_status_rsp_args
{
    struct struct_ip_status status;
};
 
static inline enum mmagic_status mmagic_controller_ip_status(struct mmagic_controller *controller,
                                                             struct mmagic_core_ip_status_rsp_args *
                                                             rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_IP, MMAGIC_IP_CMD_STATUS, 0, NULL,
                                  0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_IP, MMAGIC_IP_CMD_STATUS, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_ip_reload(struct mmagic_controller *controller)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_IP, MMAGIC_IP_CMD_RELOAD, 0, NULL,
                                  0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller, stream_id, MMAGIC_IP, MMAGIC_IP_CMD_RELOAD, 0, NULL, 0,
                                response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_ip_enable_tcp_keepalive_offload_cmd_args
{
    uint16_t period_s;
    uint8_t retry_count;
    uint8_t retry_interval_s;
};
 
static inline enum mmagic_status mmagic_controller_ip_enable_tcp_keepalive_offload(
    struct mmagic_controller *controller,
    struct
    mmagic_core_ip_enable_tcp_keepalive_offload_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_IP,
                                  MMAGIC_IP_CMD_ENABLE_TCP_KEEPALIVE_OFFLOAD, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_IP,
                                  MMAGIC_IP_CMD_ENABLE_TCP_KEEPALIVE_OFFLOAD, 0, NULL, 0,
                                  response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_ip_disable_tcp_keepalive_offload(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_IP,
                                  MMAGIC_IP_CMD_DISABLE_TCP_KEEPALIVE_OFFLOAD, 0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller, stream_id, MMAGIC_IP,
                                MMAGIC_IP_CMD_DISABLE_TCP_KEEPALIVE_OFFLOAD, 0, NULL, 0,
                                response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_ip_set_whitelist_filter_cmd_args
{
    struct struct_ip_addr src_ip;
    struct struct_ip_addr dest_ip;
    struct struct_ip_addr netmask;
    uint16_t src_port;
    uint16_t dest_port;
    uint8_t ip_protocol;
    uint16_t llc_protocol;
};
 
static inline enum mmagic_status mmagic_controller_ip_set_whitelist_filter(
    struct mmagic_controller *controller,
    struct
    mmagic_core_ip_set_whitelist_filter_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_IP,
                                  MMAGIC_IP_CMD_SET_WHITELIST_FILTER, 0, (uint8_t *)cmd_args,
                                  sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_IP,
                                  MMAGIC_IP_CMD_SET_WHITELIST_FILTER, 0, NULL, 0,
                                  response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_ip_clear_whitelist_filter(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_IP,
                                  MMAGIC_IP_CMD_CLEAR_WHITELIST_FILTER, 0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller, stream_id, MMAGIC_IP,
                                MMAGIC_IP_CMD_CLEAR_WHITELIST_FILTER, 0, NULL, 0,
                                response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_ip_link_status_event_args
{
    struct struct_ip_status ip_link_status;
};
 
typedef void (*mmagic_ip_link_status_event_handler_t)(
    const struct mmagic_ip_link_status_event_args *event_args, void *arg);
 
void mmagic_controller_register_ip_link_status_handler(
    struct mmagic_controller *controller,
    mmagic_ip_link_status_event_handler_t handler, void *arg);
 
static inline enum mmagic_status mmagic_controller_get_ping_target(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_GET,
                                  MMAGIC_PING_VAR_TARGET, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_GET,
                                  MMAGIC_PING_VAR_TARGET, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ping_target(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_SET,
                                  MMAGIC_PING_VAR_TARGET, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_SET,
                                  MMAGIC_PING_VAR_TARGET, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ping_interval(
    struct mmagic_controller *controller, uint32_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_GET,
                                  MMAGIC_PING_VAR_INTERVAL, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_GET,
                                  MMAGIC_PING_VAR_INTERVAL, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ping_interval(
    struct mmagic_controller *controller, uint32_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_SET,
                                  MMAGIC_PING_VAR_INTERVAL, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_SET,
                                  MMAGIC_PING_VAR_INTERVAL, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ping_count(
    struct mmagic_controller *controller, uint32_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_GET,
                                  MMAGIC_PING_VAR_COUNT, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_GET,
                                  MMAGIC_PING_VAR_COUNT, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ping_count(
    struct mmagic_controller *controller, uint32_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_SET,
                                  MMAGIC_PING_VAR_COUNT, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_SET,
                                  MMAGIC_PING_VAR_COUNT, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_ping_commit_all(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_COMMIT,
                                  0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_PING, MMAGIC_PING_CMD_COMMIT,
                                  0, NULL, 0, MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
struct MM_PACKED mmagic_core_ping_run_rsp_args
{
    struct struct_ping_status status;
};
 
static inline enum mmagic_status mmagic_controller_ping_run(struct mmagic_controller *controller,
                                                            struct mmagic_core_ping_run_rsp_args *
                                                            rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_PING, MMAGIC_PING_CMD_RUN, 0, NULL,
                                  0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_PING, MMAGIC_PING_CMD_RUN, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_iperf_mode(
    struct mmagic_controller *controller, enum mmagic_iperf_mode *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_GET,
                                  MMAGIC_IPERF_VAR_MODE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_GET,
                                  MMAGIC_IPERF_VAR_MODE, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_iperf_mode(
    struct mmagic_controller *controller, enum mmagic_iperf_mode var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_SET,
                                  MMAGIC_IPERF_VAR_MODE, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_SET,
                                  MMAGIC_IPERF_VAR_MODE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_iperf_server(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_GET,
                                  MMAGIC_IPERF_VAR_SERVER, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_GET,
                                  MMAGIC_IPERF_VAR_SERVER, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_iperf_server(
    struct mmagic_controller *controller, struct struct_ip_addr *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_SET,
                                  MMAGIC_IPERF_VAR_SERVER, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_SET,
                                  MMAGIC_IPERF_VAR_SERVER, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_iperf_port(
    struct mmagic_controller *controller, uint16_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_GET,
                                  MMAGIC_IPERF_VAR_PORT, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_GET,
                                  MMAGIC_IPERF_VAR_PORT, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_iperf_port(
    struct mmagic_controller *controller, uint16_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_SET,
                                  MMAGIC_IPERF_VAR_PORT, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_SET,
                                  MMAGIC_IPERF_VAR_PORT, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_iperf_amount(
    struct mmagic_controller *controller, int32_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_GET,
                                  MMAGIC_IPERF_VAR_AMOUNT, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_GET,
                                  MMAGIC_IPERF_VAR_AMOUNT, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_iperf_amount(
    struct mmagic_controller *controller, int32_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_SET,
                                  MMAGIC_IPERF_VAR_AMOUNT, (uint8_t *)&var, sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_SET,
                                  MMAGIC_IPERF_VAR_AMOUNT, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_iperf_commit_all(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_COMMIT,
                                  0, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_IPERF, MMAGIC_IPERF_CMD_COMMIT,
                                  0, NULL, 0, MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
struct MM_PACKED mmagic_core_iperf_run_rsp_args
{
    struct struct_iperf_status status;
};
 
static inline enum mmagic_status mmagic_controller_iperf_run(struct mmagic_controller *controller,
                                                             struct mmagic_core_iperf_run_rsp_args *
                                                             rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_IPERF, MMAGIC_IPERF_CMD_RUN, 0,
                                  NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_IPERF, MMAGIC_IPERF_CMD_RUN, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_sys_reset(struct mmagic_controller *controller)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_SYS,
                                  MMAGIC_SYS_CMD_RESET, 0, NULL, 0);
    return status;
}
 
struct MM_PACKED mmagic_core_sys_deep_sleep_cmd_args
{
    enum mmagic_deep_sleep_mode mode;
};
 
static inline enum mmagic_status mmagic_controller_sys_deep_sleep(
    struct mmagic_controller *controller,
    struct
    mmagic_core_sys_deep_sleep_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_SYS, MMAGIC_SYS_CMD_DEEP_SLEEP, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_SYS, MMAGIC_SYS_CMD_DEEP_SLEEP, 0,
                                  NULL, 0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_sys_get_version_rsp_args
{
    struct struct_version_info results;
};
 
static inline enum mmagic_status mmagic_controller_sys_get_version(
    struct mmagic_controller *controller,
    struct
    mmagic_core_sys_get_version_rsp_args *rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_SYS, MMAGIC_SYS_CMD_GET_VERSION, 0,
                                  NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_SYS, MMAGIC_SYS_CMD_GET_VERSION, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_tcp_connect_cmd_args
{
    struct string254 url;
    uint16_t port;
    bool enable_tls;
};
 
struct MM_PACKED mmagic_core_tcp_connect_rsp_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_tcp_connect(struct mmagic_controller *controller,
                                                               struct
                                                               mmagic_core_tcp_connect_cmd_args *
                                                               cmd_args,
                                                               struct
                                                               mmagic_core_tcp_connect_rsp_args *
                                                               rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = 15000;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_CONNECT, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_CONNECT, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_tcp_bind_cmd_args
{
    uint16_t port;
};
 
struct MM_PACKED mmagic_core_tcp_bind_rsp_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_tcp_bind(struct mmagic_controller *controller,
                                                            struct mmagic_core_tcp_bind_cmd_args *
                                                            cmd_args,
                                                            struct mmagic_core_tcp_bind_rsp_args *
                                                            rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_BIND, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_BIND, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_tcp_recv_cmd_args
{
    uint8_t stream_id;
    uint16_t len;
    uint32_t timeout;
};
 
struct MM_PACKED mmagic_core_tcp_recv_rsp_args
{
    struct raw1536 buffer;
};
 
static inline enum mmagic_status mmagic_controller_tcp_recv(struct mmagic_controller *controller,
                                                            struct mmagic_core_tcp_recv_cmd_args *
                                                            cmd_args,
                                                            struct mmagic_core_tcp_recv_rsp_args *
                                                            rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = cmd_args->stream_id;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    /* Account for the timeout argument when waiting for the response and make sure no overflow. */
    if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
    {
        response_timeout_ms += cmd_args->timeout;
    }
    else
    {
        response_timeout_ms = UINT32_MAX;
    }
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_RECV, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_RECV, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_tcp_send_cmd_args
{
    uint8_t stream_id;
    struct raw1536 buffer;
};
 
static inline enum mmagic_status mmagic_controller_tcp_send(struct mmagic_controller *controller,
                                                            struct mmagic_core_tcp_send_cmd_args *
                                                            cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = cmd_args->stream_id;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_SEND, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_SEND, 0, NULL,
                                  0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_tcp_read_poll_cmd_args
{
    uint8_t stream_id;
    uint32_t timeout;
};
 
static inline enum mmagic_status mmagic_controller_tcp_read_poll(
    struct mmagic_controller *controller,
    struct
    mmagic_core_tcp_read_poll_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = cmd_args->stream_id;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    /* Account for the timeout argument when waiting for the response and make sure no overflow. */
    if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
    {
        response_timeout_ms += cmd_args->timeout;
    }
    else
    {
        response_timeout_ms = UINT32_MAX;
    }
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_READ_POLL, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_READ_POLL, 0,
                                  NULL, 0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_tcp_write_poll_cmd_args
{
    uint8_t stream_id;
    uint32_t timeout;
};
 
static inline enum mmagic_status mmagic_controller_tcp_write_poll(
    struct mmagic_controller *controller,
    struct
    mmagic_core_tcp_write_poll_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = cmd_args->stream_id;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    /* Account for the timeout argument when waiting for the response and make sure no overflow. */
    if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
    {
        response_timeout_ms += cmd_args->timeout;
    }
    else
    {
        response_timeout_ms = UINT32_MAX;
    }
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_WRITE_POLL, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_WRITE_POLL, 0,
                                  NULL, 0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_tcp_accept_cmd_args
{
    uint8_t stream_id;
};
 
struct MM_PACKED mmagic_core_tcp_accept_rsp_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_tcp_accept(struct mmagic_controller *controller,
                                                              struct mmagic_core_tcp_accept_cmd_args
                                                              *cmd_args,
                                                              struct mmagic_core_tcp_accept_rsp_args
                                                              *rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = cmd_args->stream_id;
    uint32_t response_timeout_ms = -1;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_ACCEPT, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_ACCEPT, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_tcp_close_cmd_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_tcp_close(struct mmagic_controller *controller,
                                                             struct mmagic_core_tcp_close_cmd_args *
                                                             cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_CLOSE, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_TCP, MMAGIC_TCP_CMD_CLOSE, 0, NULL,
                                  0, response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_tls_root_ca_certificate(
    struct mmagic_controller *controller, struct raw1536 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_GET,
                                  MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_GET,
                                  MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_tls_root_ca_certificate(
    struct mmagic_controller *controller, struct raw1536 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_SET,
                                  MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_SET,
                                  MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_tls_client_certificate(
    struct mmagic_controller *controller, struct raw1536 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_GET,
                                  MMAGIC_TLS_VAR_CLIENT_CERTIFICATE, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_GET,
                                  MMAGIC_TLS_VAR_CLIENT_CERTIFICATE, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_tls_client_certificate(
    struct mmagic_controller *controller, struct raw1536 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_SET,
                                  MMAGIC_TLS_VAR_CLIENT_CERTIFICATE, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_SET,
                                  MMAGIC_TLS_VAR_CLIENT_CERTIFICATE, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_tls_client_private_key(
    struct mmagic_controller *controller, struct raw1536 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_GET,
                                  MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_GET,
                                  MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_tls_client_private_key(
    struct mmagic_controller *controller, struct raw1536 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_SET,
                                  MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY, (uint8_t *)var, sizeof(*var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_SET,
                                  MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_tls_commit_all(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_COMMIT, 0,
                                  NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_TLS, MMAGIC_TLS_CMD_COMMIT, 0,
                                  NULL, 0, MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_get_ntp_server(
    struct mmagic_controller *controller, struct string254 *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_NTP, MMAGIC_NTP_CMD_GET,
                                  MMAGIC_NTP_VAR_SERVER, NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_NTP, MMAGIC_NTP_CMD_GET,
                                  MMAGIC_NTP_VAR_SERVER, (uint8_t *)var, sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_ntp_server(
    struct mmagic_controller *controller, const char *var)
{
    struct string254 var_val;
    enum mmagic_status status;
    var_val.len = strlen(var);
    if (var_val.len > sizeof(var_val.data) - 1)
    {
        return MMAGIC_STATUS_INVALID_ARG;
    }
    memcpy(var_val.data, (const uint8_t *)var, var_val.len);
    memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_NTP, MMAGIC_NTP_CMD_SET,
                                  MMAGIC_NTP_VAR_SERVER, (uint8_t *)&var_val, sizeof(var_val));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_NTP, MMAGIC_NTP_CMD_SET,
                                  MMAGIC_NTP_VAR_SERVER, NULL, 0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_ntp_commit_all(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller, CONTROL_STREAM, MMAGIC_NTP, MMAGIC_NTP_CMD_COMMIT, 0,
                                  NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, CONTROL_STREAM, MMAGIC_NTP, MMAGIC_NTP_CMD_COMMIT, 0,
                                  NULL, 0, MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_ntp_sync(struct mmagic_controller *controller)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_NTP, MMAGIC_NTP_CMD_SYNC, 0, NULL,
                                  0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller, stream_id, MMAGIC_NTP, MMAGIC_NTP_CMD_SYNC, 0, NULL, 0,
                                response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_ntp_get_time_rsp_args
{
    uint64_t timestamp;
};
 
static inline enum mmagic_status mmagic_controller_ntp_get_time(
    struct mmagic_controller *controller,
    struct
    mmagic_core_ntp_get_time_rsp_args *rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_NTP, MMAGIC_NTP_CMD_GET_TIME, 0,
                                  NULL, 0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_NTP, MMAGIC_NTP_CMD_GET_TIME, 0,
                                  (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_mqtt_start_agent_cmd_args
{
    struct string254 url;
    uint16_t port;
    struct string100 username;
    struct string100 password;
    bool secure;
};
 
struct MM_PACKED mmagic_core_mqtt_start_agent_rsp_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_mqtt_start_agent(
    struct mmagic_controller *controller,
    struct
    mmagic_core_mqtt_start_agent_cmd_args *cmd_args,
    struct
    mmagic_core_mqtt_start_agent_rsp_args *rsp_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_MQTT, MMAGIC_MQTT_CMD_START_AGENT,
                                  0, (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_MQTT, MMAGIC_MQTT_CMD_START_AGENT,
                                  0, (uint8_t *)rsp_args, sizeof(*rsp_args), response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_mqtt_publish_cmd_args
{
    uint8_t stream_id;
    struct string254 topic;
    struct raw1536 payload;
    uint8_t qos;
};
 
static inline enum mmagic_status mmagic_controller_mqtt_publish(
    struct mmagic_controller *controller,
    struct
    mmagic_core_mqtt_publish_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_MQTT, MMAGIC_MQTT_CMD_PUBLISH, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_MQTT, MMAGIC_MQTT_CMD_PUBLISH, 0,
                                  NULL, 0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_mqtt_subscribe_cmd_args
{
    uint8_t stream_id;
    struct string254 topic;
    uint8_t qos;
};
 
static inline enum mmagic_status mmagic_controller_mqtt_subscribe(
    struct mmagic_controller *controller,
    struct
    mmagic_core_mqtt_subscribe_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_MQTT, MMAGIC_MQTT_CMD_SUBSCRIBE, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_MQTT, MMAGIC_MQTT_CMD_SUBSCRIBE, 0,
                                  NULL, 0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_mqtt_stop_agent_cmd_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_mqtt_stop_agent(
    struct mmagic_controller *controller,
    struct
    mmagic_core_mqtt_stop_agent_cmd_args *cmd_args)
{
    enum mmagic_status status;
    const uint8_t stream_id = CONTROL_STREAM;
    uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
 
    status = mmagic_controller_tx(controller, stream_id, MMAGIC_MQTT, MMAGIC_MQTT_CMD_STOP_AGENT, 0,
                                  (uint8_t *)cmd_args, sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller, stream_id, MMAGIC_MQTT, MMAGIC_MQTT_CMD_STOP_AGENT, 0,
                                  NULL, 0, response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_mqtt_message_received_event_args
{
    uint8_t stream_id;
    struct string254 topic;
    struct raw1536 payload;
};
 
typedef void (*mmagic_mqtt_message_received_event_handler_t)(
    const struct mmagic_mqtt_message_received_event_args *event_args, void *arg);
 
void mmagic_controller_register_mqtt_message_received_handler(
    struct mmagic_controller *controller,
    mmagic_mqtt_message_received_event_handler_t handler, void *arg);
 
struct MM_PACKED mmagic_mqtt_broker_connection_event_args
{
    uint8_t stream_id;
    enum mmagic_status connection_state;
};
 
typedef void (*mmagic_mqtt_broker_connection_event_handler_t)(
    const struct mmagic_mqtt_broker_connection_event_args *event_args, void *arg);
 
void mmagic_controller_register_mqtt_broker_connection_handler(
    struct mmagic_controller *controller,
    mmagic_mqtt_broker_connection_event_handler_t handler, void *arg);
 
#ifdef __cplusplus
}
#endif