mmagic_controller.h

/*
 * Copyright 2026 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 <stdint.h>
#include <memory.h>
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#ifndef MM_PACKED
#define MM_PACKED __attribute__((packed))
#endif
 
enum MM_PACKED mmagic_security_type
{
    MMAGIC_SECURITY_TYPE_SAE = 0,
    MMAGIC_SECURITY_TYPE_OWE = 1,
    MMAGIC_SECURITY_TYPE_OPEN = 2,
};
 
enum MM_PACKED mmagic_pmf_mode
{
    MMAGIC_PMF_MODE_REQUIRED = 0,
    MMAGIC_PMF_MODE_DISABLED = 1,
};
 
enum MM_PACKED mmagic_power_save_mode
{
    MMAGIC_POWER_SAVE_MODE_DISABLED = 0,
    MMAGIC_POWER_SAVE_MODE_ENABLED = 1,
};
 
enum MM_PACKED mmagic_mcs10_mode
{
    MMAGIC_MCS10_MODE_DISABLED = 0,
    MMAGIC_MCS10_MODE_FORCED = 1,
    MMAGIC_MCS10_MODE_AUTO = 2,
};
 
enum MM_PACKED mmagic_duty_cycle_mode
{
    MMAGIC_DUTY_CYCLE_MODE_SPREAD = 0,
    MMAGIC_DUTY_CYCLE_MODE_BURST = 1,
};
 
enum MM_PACKED mmagic_station_type
{
    MMAGIC_STATION_TYPE_SENSOR = 0,
    MMAGIC_STATION_TYPE_NON_SENSOR = 1,
};
 
enum MM_PACKED 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_NOT_INITIALIZED = 31,
    MMAGIC_STATUS_BAD_VERSION = 32,
    MMAGIC_STATUS_DPP_PB_ERROR = 33,
    MMAGIC_STATUS_DPP_PB_SESSION_OVERLAP = 34,
};
 
enum MM_PACKED 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 MM_PACKED 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 MM_PACKED mmagic_ip_link_state
{
    MMAGIC_IP_LINK_STATE_DOWN = 0,
    MMAGIC_IP_LINK_STATE_UP = 1,
};
 
enum MM_PACKED mmagic_deep_sleep_mode
{
    MMAGIC_DEEP_SLEEP_MODE_DISABLED = 0,
    MMAGIC_DEEP_SLEEP_MODE_ONE_SHOT = 1,
    MMAGIC_DEEP_SLEEP_MODE_HARDWARE = 2,
};
 
enum MM_PACKED mmagic_sta_state
{
    MMAGIC_STA_STATE_DISCONNECTED = 1,
    MMAGIC_STA_STATE_CONNECTING = 2,
    MMAGIC_STA_STATE_CONNECTED = 3,
};
 
enum MM_PACKED 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,
};
 
enum MM_PACKED mmagic_socket_proto
{
    MMAGIC_SOCKET_PROTO_TCP = 0,
    MMAGIC_SOCKET_PROTO_UDP = 1,
};
 
enum MM_PACKED mmagic_subsystem_id
{
    MMAGIC_SUBSYSTEM_ID_HOST = 0,
    MMAGIC_SUBSYSTEM_ID_MAC = 1,
    MMAGIC_SUBSYSTEM_ID_PHY = 2,
    MMAGIC_SUBSYSTEM_ID_UMAC = 3,
};
 
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 raw1600
{
    uint16_t len;
 
    uint8_t data[1600];
};
 
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;
    int16_t noise_dbm;
    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_SOCKET = 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
 
#define MMAGIC_CONTROLLER_DEFAULT_COMMIT_RESPONSE_TIMEOUT_MS 12000
 
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_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,
    MMAGIC_WLAN_VAR_CONNECT_ON_BOOT = 29,
};
 
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_GET_STA_STATUS = 21,
    MMAGIC_WLAN_CMD_DPP_PUSH_BUTTON_START = 22,
    MMAGIC_WLAN_CMD_DPP_STOP = 23,
};
 
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_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,
};
 
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,
    MMAGIC_SYS_CMD_GET_STATS = 11,
};
 
enum mmagic_socket_cmd
{
    MMAGIC_SOCKET_CMD_GET = 0,
    MMAGIC_SOCKET_CMD_SET = 1,
    MMAGIC_SOCKET_CMD_LOAD = 2,
    MMAGIC_SOCKET_CMD_COMMIT = 3,
    MMAGIC_SOCKET_CMD_CONNECT = 8,
    MMAGIC_SOCKET_CMD_BIND = 9,
    MMAGIC_SOCKET_CMD_RECV = 10,
    MMAGIC_SOCKET_CMD_SEND = 11,
    MMAGIC_SOCKET_CMD_READ_POLL = 12,
    MMAGIC_SOCKET_CMD_WRITE_POLL = 13,
    MMAGIC_SOCKET_CMD_ACCEPT = 14,
    MMAGIC_SOCKET_CMD_CLOSE = 15,
    MMAGIC_SOCKET_CMD_SET_RX_READY_EVT_ENABLED = 16,
};
 
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_var
{
    MMAGIC_MQTT_VAR_KEEPALIVE_S = 0,
};
 
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_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_get_wlan_connect_on_boot(
    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_CONNECT_ON_BOOT,
                                  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_CONNECT_ON_BOOT,
                                  (uint8_t *)var,
                                  sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_wlan_connect_on_boot(
    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_CONNECT_ON_BOOT,
                                  (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_CONNECT_ON_BOOT,
                                  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_COMMIT_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;
}
 
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 = 3000;
 
    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;
}
 
static inline enum mmagic_status mmagic_controller_wlan_dpp_push_button_start(
    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_DPP_PUSH_BUTTON_START,
                                  0,
                                  NULL,
                                  0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller,
                                stream_id,
                                MMAGIC_WLAN,
                                MMAGIC_WLAN_CMD_DPP_PUSH_BUTTON_START,
                                0,
                                NULL,
                                0,
                                response_timeout_ms);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_wlan_dpp_stop(
    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_DPP_STOP,
                                  0,
                                  NULL,
                                  0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    return mmagic_controller_rx(controller,
                                stream_id,
                                MMAGIC_WLAN,
                                MMAGIC_WLAN_CMD_DPP_STOP,
                                0,
                                NULL,
                                0,
                                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_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_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_COMMIT_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_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_COMMIT_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 = -1;
 
    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_COMMIT_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 = -1;
 
    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_sys_get_stats_cmd_args
{
    enum mmagic_subsystem_id subsystem;
    bool reset;
};
 
struct MM_PACKED mmagic_core_sys_get_stats_rsp_args
{
    struct raw1600 buffer;
};
 
static inline enum mmagic_status mmagic_controller_sys_get_stats(
    struct mmagic_controller *controller,
    struct mmagic_core_sys_get_stats_cmd_args *cmd_args,
    struct mmagic_core_sys_get_stats_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_STATS,
                                  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_GET_STATS,
                                  0,
                                  (uint8_t *)rsp_args,
                                  sizeof(*rsp_args),
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_socket_connect_cmd_args
{
    struct string254 url;
    uint16_t port;
    enum mmagic_socket_proto protocol;
    bool enable_tls;
};
 
struct MM_PACKED mmagic_core_socket_connect_rsp_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_socket_connect(
    struct mmagic_controller *controller,
    struct mmagic_core_socket_connect_cmd_args *cmd_args,
    struct mmagic_core_socket_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_SOCKET,
                                  MMAGIC_SOCKET_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_SOCKET,
                                  MMAGIC_SOCKET_CMD_CONNECT,
                                  0,
                                  (uint8_t *)rsp_args,
                                  sizeof(*rsp_args),
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_socket_bind_cmd_args
{
    uint16_t port;
    enum mmagic_socket_proto protocol;
};
 
struct MM_PACKED mmagic_core_socket_bind_rsp_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_socket_bind(
    struct mmagic_controller *controller,
    struct mmagic_core_socket_bind_cmd_args *cmd_args,
    struct mmagic_core_socket_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_SOCKET,
                                  MMAGIC_SOCKET_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_SOCKET,
                                  MMAGIC_SOCKET_CMD_BIND,
                                  0,
                                  (uint8_t *)rsp_args,
                                  sizeof(*rsp_args),
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_socket_recv_cmd_args
{
    uint8_t stream_id;
    uint16_t len;
    uint32_t timeout;
};
 
struct MM_PACKED mmagic_core_socket_recv_rsp_args
{
    struct raw1536 buffer;
};
 
static inline enum mmagic_status mmagic_controller_socket_recv(
    struct mmagic_controller *controller,
    struct mmagic_core_socket_recv_cmd_args *cmd_args,
    struct mmagic_core_socket_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_SOCKET,
                                  MMAGIC_SOCKET_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_SOCKET,
                                  MMAGIC_SOCKET_CMD_RECV,
                                  0,
                                  (uint8_t *)rsp_args,
                                  sizeof(*rsp_args),
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_socket_send_cmd_args
{
    uint8_t stream_id;
    struct raw1536 buffer;
};
 
static inline enum mmagic_status mmagic_controller_socket_send(
    struct mmagic_controller *controller,
    struct mmagic_core_socket_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_SOCKET,
                                  MMAGIC_SOCKET_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_SOCKET,
                                  MMAGIC_SOCKET_CMD_SEND,
                                  0,
                                  NULL,
                                  0,
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_socket_read_poll_cmd_args
{
    uint8_t stream_id;
    uint32_t timeout;
};
 
static inline enum mmagic_status mmagic_controller_socket_read_poll(
    struct mmagic_controller *controller,
    struct mmagic_core_socket_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_SOCKET,
                                  MMAGIC_SOCKET_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_SOCKET,
                                  MMAGIC_SOCKET_CMD_READ_POLL,
                                  0,
                                  NULL,
                                  0,
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_socket_write_poll_cmd_args
{
    uint8_t stream_id;
    uint32_t timeout;
};
 
static inline enum mmagic_status mmagic_controller_socket_write_poll(
    struct mmagic_controller *controller,
    struct mmagic_core_socket_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_SOCKET,
                                  MMAGIC_SOCKET_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_SOCKET,
                                  MMAGIC_SOCKET_CMD_WRITE_POLL,
                                  0,
                                  NULL,
                                  0,
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_socket_accept_cmd_args
{
    uint8_t stream_id;
};
 
struct MM_PACKED mmagic_core_socket_accept_rsp_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_socket_accept(
    struct mmagic_controller *controller,
    struct mmagic_core_socket_accept_cmd_args *cmd_args,
    struct mmagic_core_socket_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_SOCKET,
                                  MMAGIC_SOCKET_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_SOCKET,
                                  MMAGIC_SOCKET_CMD_ACCEPT,
                                  0,
                                  (uint8_t *)rsp_args,
                                  sizeof(*rsp_args),
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_socket_close_cmd_args
{
    uint8_t stream_id;
};
 
static inline enum mmagic_status mmagic_controller_socket_close(
    struct mmagic_controller *controller,
    struct mmagic_core_socket_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_SOCKET,
                                  MMAGIC_SOCKET_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_SOCKET,
                                  MMAGIC_SOCKET_CMD_CLOSE,
                                  0,
                                  NULL,
                                  0,
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_core_socket_set_rx_ready_evt_enabled_cmd_args
{
    uint8_t stream_id;
    bool enabled;
};
 
static inline enum mmagic_status mmagic_controller_socket_set_rx_ready_evt_enabled(
    struct mmagic_controller *controller,
    struct mmagic_core_socket_set_rx_ready_evt_enabled_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_SOCKET,
                                  MMAGIC_SOCKET_CMD_SET_RX_READY_EVT_ENABLED,
                                  0,
                                  (uint8_t *)cmd_args,
                                  sizeof(*cmd_args));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller,
                                  stream_id,
                                  MMAGIC_SOCKET,
                                  MMAGIC_SOCKET_CMD_SET_RX_READY_EVT_ENABLED,
                                  0,
                                  NULL,
                                  0,
                                  response_timeout_ms);
    return status;
}
 
struct MM_PACKED mmagic_socket_rx_ready_event_args
{
    uint8_t stream_id;
};
 
typedef void (*mmagic_socket_rx_ready_event_handler_t)(
    const struct mmagic_socket_rx_ready_event_args *event_args,
    void *arg);
 
void mmagic_controller_register_socket_rx_ready_handler(
    struct mmagic_controller *controller,
    mmagic_socket_rx_ready_event_handler_t handler,
    void *arg);
 
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_COMMIT_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_COMMIT_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;
}
 
static inline enum mmagic_status mmagic_controller_get_mqtt_keepalive_s(
    struct mmagic_controller *controller,
    uint16_t *var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller,
                                  CONTROL_STREAM,
                                  MMAGIC_MQTT,
                                  MMAGIC_MQTT_CMD_GET,
                                  MMAGIC_MQTT_VAR_KEEPALIVE_S,
                                  NULL,
                                  0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller,
                                  CONTROL_STREAM,
                                  MMAGIC_MQTT,
                                  MMAGIC_MQTT_CMD_GET,
                                  MMAGIC_MQTT_VAR_KEEPALIVE_S,
                                  (uint8_t *)var,
                                  sizeof(*var),
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_set_mqtt_keepalive_s(
    struct mmagic_controller *controller,
    uint16_t var)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller,
                                  CONTROL_STREAM,
                                  MMAGIC_MQTT,
                                  MMAGIC_MQTT_CMD_SET,
                                  MMAGIC_MQTT_VAR_KEEPALIVE_S,
                                  (uint8_t *)&var,
                                  sizeof(var));
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller,
                                  CONTROL_STREAM,
                                  MMAGIC_MQTT,
                                  MMAGIC_MQTT_CMD_SET,
                                  MMAGIC_MQTT_VAR_KEEPALIVE_S,
                                  NULL,
                                  0,
                                  MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
    return status;
}
 
static inline enum mmagic_status mmagic_controller_mqtt_commit_all(
    struct mmagic_controller *controller)
{
    enum mmagic_status status;
    status = mmagic_controller_tx(controller,
                                  CONTROL_STREAM,
                                  MMAGIC_MQTT,
                                  MMAGIC_MQTT_CMD_COMMIT,
                                  0,
                                  NULL,
                                  0);
    if (status != MMAGIC_STATUS_OK)
    {
        return status;
    }
    status = mmagic_controller_rx(controller,
                                  CONTROL_STREAM,
                                  MMAGIC_MQTT,
                                  MMAGIC_MQTT_CMD_COMMIT,
                                  0,
                                  NULL,
                                  0,
                                  MMAGIC_CONTROLLER_DEFAULT_COMMIT_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 = 5000;
 
    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