Morse Micro IoT SDK  2.10.4
mmagic_controller.h
1/*
2 * Copyright 2026 Morse Micro
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Warning: this file is autogenerated. Do not modify by hand.
7 */
8
9#pragma once
10
28#include <stdbool.h>
29#include <stddef.h>
30#include <stdint.h>
31#include <memory.h>
32
33#ifdef __cplusplus
34extern "C"
35{
36#endif
37
38#ifndef MM_PACKED
40#define MM_PACKED __attribute__((packed))
41#endif
42
50enum mmagic_security_type
51{
53 MMAGIC_SECURITY_TYPE_SAE = 0,
55 MMAGIC_SECURITY_TYPE_OWE = 1,
57 MMAGIC_SECURITY_TYPE_OPEN = 2,
58};
59
61enum mmagic_pmf_mode
62{
64 MMAGIC_PMF_MODE_REQUIRED = 0,
66 MMAGIC_PMF_MODE_DISABLED = 1,
67};
68
70enum mmagic_power_save_mode
71{
73 MMAGIC_POWER_SAVE_MODE_DISABLED = 0,
75 MMAGIC_POWER_SAVE_MODE_ENABLED = 1,
76};
77
79enum mmagic_mcs10_mode
80{
82 MMAGIC_MCS10_MODE_DISABLED = 0,
84 MMAGIC_MCS10_MODE_FORCED = 1,
86 MMAGIC_MCS10_MODE_AUTO = 2,
87};
88
90enum mmagic_duty_cycle_mode
91{
93 MMAGIC_DUTY_CYCLE_MODE_SPREAD = 0,
95 MMAGIC_DUTY_CYCLE_MODE_BURST = 1,
96};
97
99enum mmagic_station_type
100{
102 MMAGIC_STATION_TYPE_SENSOR = 0,
104 MMAGIC_STATION_TYPE_NON_SENSOR = 1,
105};
106
108enum mmagic_status
109{
111 MMAGIC_STATUS_OK = 0,
113 MMAGIC_STATUS_ERROR = 1,
115 MMAGIC_STATUS_INVALID_ARG = 2,
117 MMAGIC_STATUS_UNAVAILABLE = 3,
119 MMAGIC_STATUS_TIMEOUT = 4,
121 MMAGIC_STATUS_INVALID_STREAM = 5,
123 MMAGIC_STATUS_NOT_FOUND = 6,
125 MMAGIC_STATUS_NOT_SUPPORTED = 7,
127 MMAGIC_STATUS_TX_ERROR = 8,
129 MMAGIC_STATUS_NO_MEM = 9,
131 MMAGIC_STATUS_CLOSED = 10,
133 MMAGIC_STATUS_CHANNEL_LIST_NOT_SET = 11,
135 MMAGIC_STATUS_SHUTDOWN_BLOCKED = 12,
137 MMAGIC_STATUS_CHANNEL_INVALID = 13,
139 MMAGIC_STATUS_NOT_RUNNING = 14,
141 MMAGIC_STATUS_NO_LINK = 15,
143 MMAGIC_STATUS_UNKNOWN_HOST = 16,
145 MMAGIC_STATUS_SOCKET_FAILED = 17,
147 MMAGIC_STATUS_SOCKET_CONNECT_FAILED = 18,
149 MMAGIC_STATUS_SOCKET_BIND_FAILED = 19,
151 MMAGIC_STATUS_SOCKET_LISTEN_FAILED = 20,
153 MMAGIC_STATUS_NTP_KOD_RECEIVED = 21,
155 MMAGIC_STATUS_NTP_KOD_BACKOFF_RECEIVED = 22,
157 MMAGIC_STATUS_SOCKET_SEND_FAILED = 23,
160 MMAGIC_STATUS_INVALID_CREDENTIALS = 24,
162 MMAGIC_STATUS_HANDSHAKE_FAILED = 25,
164 MMAGIC_STATUS_AUTHENTICATION_FAILED = 26,
167 MMAGIC_STATUS_MISSING_CREDENTIALS = 27,
170 MMAGIC_STATUS_TIME_NOT_SYNCHRONIZED = 28,
172 MMAGIC_STATUS_MQTT_REFUSED = 29,
174 MMAGIC_STATUS_MQTT_KEEPALIVE_TIMEOUT = 30,
176 MMAGIC_STATUS_NOT_INITIALIZED = 31,
178 MMAGIC_STATUS_BAD_VERSION = 32,
179};
180
182enum mmagic_iperf_mode
183{
185 MMAGIC_IPERF_MODE_UDP_SERVER = 0,
187 MMAGIC_IPERF_MODE_TCP_SERVER = 1,
189 MMAGIC_IPERF_MODE_UDP_CLIENT = 2,
191 MMAGIC_IPERF_MODE_TCP_CLIENT = 3,
192};
193
195enum mmagic_iperf_state
196{
198 MMAGIC_IPERF_STATE_NOT_STARTED = 0,
200 MMAGIC_IPERF_STATE_RUNNING = 1,
202 MMAGIC_IPERF_STATE_FINISHED = 2,
204 MMAGIC_IPERF_STATE_ABORTED = 3,
205};
206
208enum mmagic_ip_link_state
209{
211 MMAGIC_IP_LINK_STATE_DOWN = 0,
213 MMAGIC_IP_LINK_STATE_UP = 1,
214};
215
217enum mmagic_deep_sleep_mode
218{
220 MMAGIC_DEEP_SLEEP_MODE_DISABLED = 0,
222 MMAGIC_DEEP_SLEEP_MODE_ONE_SHOT = 1,
224 MMAGIC_DEEP_SLEEP_MODE_HARDWARE = 2,
225};
226
228enum mmagic_standby_mode_exit_reason
229{
231 MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_NONE = 0,
233 MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_WAKEUP_FRAME = 1,
235 MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_ASSOCIATE = 2,
237 MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_EXT_INPUT = 3,
239 MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_WHITELIST_PKT = 4,
241 MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_TCP_CONNECTION_LOST = 5,
243 MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_HW_SCAN_NOT_ENABLED = 6,
245 MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_HW_SCAN_FAILED_TO_START = 7,
246};
247
249enum mmagic_sta_state
250{
252 MMAGIC_STA_STATE_DISCONNECTED = 1,
254 MMAGIC_STA_STATE_CONNECTING = 2,
256 MMAGIC_STA_STATE_CONNECTED = 3,
257};
258
260enum mmagic_sta_event
261{
263 MMAGIC_STA_EVENT_SCAN_REQUEST = 0,
265 MMAGIC_STA_EVENT_SCAN_COMPLETE = 1,
267 MMAGIC_STA_EVENT_SCAN_ABORT = 2,
269 MMAGIC_STA_EVENT_AUTH_REQUEST = 3,
271 MMAGIC_STA_EVENT_ASSOC_REQUEST = 4,
273 MMAGIC_STA_EVENT_DEAUTH_TX = 5,
275 MMAGIC_STA_EVENT_CTRL_PORT_OPEN = 6,
277 MMAGIC_STA_EVENT_CTRL_PORT_CLOSED = 7,
278};
279
281struct MM_PACKED string32
282{
284 uint8_t len;
285
287 char data[32 + 1];
288};
289
291struct MM_PACKED string100
292{
294 uint8_t len;
295
297 char data[100 + 1];
298};
299
301struct MM_PACKED string254
302{
304 uint8_t len;
305
307 char data[254 + 1];
308};
309
311struct MM_PACKED raw255
312{
314 uint8_t len;
315
317 uint8_t data[255];
318};
319
321struct MM_PACKED raw1536
322{
324 uint16_t len;
325
327 uint8_t data[1536];
328};
329
331struct MM_PACKED struct_mac_addr
332{
334 uint8_t addr[6];
335};
336
339struct MM_PACKED struct_country_code
340{
342 char country_code[3];
343};
344
346struct MM_PACKED struct_oui
347{
349 uint8_t oui[3];
350};
351
353struct MM_PACKED struct_oui_list
354{
356 uint8_t count;
358 struct struct_oui ouis[5];
359};
360
362struct MM_PACKED struct_scan_result
363{
365 struct string32 ssid;
367 struct struct_mac_addr bssid;
369 int32_t rssi;
371 struct raw255 ies;
374 uint16_t received_ies_len;
376 uint16_t beacon_interval;
378 uint16_t capability_info;
380 uint32_t channel_freq_hz;
382 uint8_t bw_mhz;
384 uint8_t op_bw_mhz;
387 int16_t noise_dbm;
389 uint64_t tsf;
390};
391
393struct MM_PACKED struct_version_info
394{
396 struct string32 application_version;
398 struct string32 bootloader_version;
400 struct string32 user_hardware_version;
402 struct string32 morse_firmware_version;
404 struct string32 morselib_version;
406 struct string32 morse_hardware_version;
407};
408
410struct MM_PACKED struct_scan_status
411{
413 struct struct_scan_result results[10];
415 uint8_t num;
416};
417
420struct MM_PACKED struct_ip_addr
421{
423 char addr[48];
424};
425
427struct MM_PACKED struct_ip_status
428{
430 enum mmagic_ip_link_state link_state;
432 bool dhcp_enabled;
434 struct struct_ip_addr ip_addr;
436 struct struct_ip_addr netmask;
438 struct struct_ip_addr gateway;
440 struct struct_ip_addr broadcast;
442 struct struct_ip_addr dns_servers[2];
443};
444
446struct MM_PACKED struct_ping_status
447{
449 struct struct_ip_addr receiver_addr;
451 uint32_t total_count;
453 uint32_t recv_count;
455 uint32_t min_time_ms;
457 uint32_t avg_time_ms;
459 uint32_t max_time_ms;
461 uint16_t session_id;
462};
463
465struct MM_PACKED struct_iperf_status
466{
468 struct struct_ip_addr remote_addr;
470 uint16_t remote_port;
472 struct struct_ip_addr local_addr;
474 uint16_t local_port;
476 uint64_t bytes_transferred;
478 uint32_t duration_ms;
480 uint32_t bandwidth_kbitpsec;
481};
482
484struct MM_PACKED struct_buffer64
485{
487 uint8_t buffer[64];
489 uint8_t len;
490};
491
495enum mmagic_subsystem
496{
498 MMAGIC_WLAN = 1,
500 MMAGIC_IP = 2,
502 MMAGIC_PING = 3,
504 MMAGIC_IPERF = 4,
506 MMAGIC_SYS = 5,
508 MMAGIC_TCP = 6,
510 MMAGIC_TLS = 7,
512 MMAGIC_NTP = 8,
514 MMAGIC_MQTT = 9,
515};
516
528struct mmagic_controller;
529
539typedef void (*mmagic_controller_agent_start_cb_t)(struct mmagic_controller *controller, void *arg);
540
544struct mmagic_controller_init_args
545{
547 mmagic_controller_agent_start_cb_t agent_start_cb;
549 void *agent_start_arg;
550};
551
555#define MMAGIC_CONTROLLER_ARGS_INIT { 0 }
556
565struct mmagic_controller *mmagic_controller_init(const struct mmagic_controller_init_args *args);
566
572void mmagic_controller_deinit(struct mmagic_controller *controller);
573
585#define CONTROL_STREAM 0
586
588#define MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS 1000
589
604enum mmagic_status mmagic_controller_tx(struct mmagic_controller *controller,
605 uint8_t stream_id,
606 uint8_t submodule_id,
607 uint8_t command_id,
608 uint8_t subcommand_id,
609 const uint8_t *buffer,
610 size_t buffer_length);
611
628enum mmagic_status mmagic_controller_rx(struct mmagic_controller *controller,
629 uint8_t stream_id,
630 uint8_t submodule_id,
631 uint8_t command_id,
632 uint8_t subcommand_id,
633 uint8_t *buffer,
634 size_t buffer_length,
635 uint32_t timeout_ms);
636
648enum mmagic_status mmagic_controller_agent_sync(struct mmagic_controller *controller,
649 uint32_t timeout_ms);
650
668enum mmagic_status mmagic_controller_request_agent_reset(struct mmagic_controller *controller);
669
671enum mmagic_wlan_var
672{
674 MMAGIC_WLAN_VAR_COUNTRY_CODE = 0,
676 MMAGIC_WLAN_VAR_SSID = 1,
678 MMAGIC_WLAN_VAR_PASSWORD = 2,
680 MMAGIC_WLAN_VAR_SECURITY = 3,
683 MMAGIC_WLAN_VAR_RAW_PRIORITY = 4,
685 MMAGIC_WLAN_VAR_BSSID = 5,
687 MMAGIC_WLAN_VAR_PMF_MODE = 6,
689 MMAGIC_WLAN_VAR_STATION_TYPE = 7,
691 MMAGIC_WLAN_VAR_RTS_THRESHOLD = 8,
693 MMAGIC_WLAN_VAR_SGI_ENABLED = 9,
695 MMAGIC_WLAN_VAR_SUBBANDS_ENABLED = 10,
697 MMAGIC_WLAN_VAR_AMPDU_ENABLED = 11,
699 MMAGIC_WLAN_VAR_POWER_SAVE_MODE = 12,
702 MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD = 13,
704 MMAGIC_WLAN_VAR_CAC_ENABLED = 14,
710 MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS = 17,
716 MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS = 18,
719 MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED = 19,
723 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S = 20,
727 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S = 21,
733 MMAGIC_WLAN_VAR_QOS_0_PARAMS = 22,
739 MMAGIC_WLAN_VAR_QOS_1_PARAMS = 23,
745 MMAGIC_WLAN_VAR_QOS_2_PARAMS = 24,
751 MMAGIC_WLAN_VAR_QOS_3_PARAMS = 25,
756 MMAGIC_WLAN_VAR_MCS10_MODE = 26,
759 MMAGIC_WLAN_VAR_STA_EVT_EN = 27,
763 MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE = 28,
764};
765
767enum mmagic_wlan_cmd
768{
770 MMAGIC_WLAN_CMD_GET = 0,
772 MMAGIC_WLAN_CMD_SET = 1,
774 MMAGIC_WLAN_CMD_LOAD = 2,
776 MMAGIC_WLAN_CMD_COMMIT = 3,
778 MMAGIC_WLAN_CMD_CONNECT = 8,
780 MMAGIC_WLAN_CMD_DISCONNECT = 9,
782 MMAGIC_WLAN_CMD_SCAN = 10,
784 MMAGIC_WLAN_CMD_GET_RSSI = 11,
786 MMAGIC_WLAN_CMD_GET_MAC_ADDR = 12,
788 MMAGIC_WLAN_CMD_WNM_SLEEP = 13,
791 MMAGIC_WLAN_CMD_BEACON_MONITOR_ENABLE = 14,
793 MMAGIC_WLAN_CMD_BEACON_MONITOR_DISABLE = 15,
797 MMAGIC_WLAN_CMD_STANDBY_ENTER = 16,
802 MMAGIC_WLAN_CMD_STANDBY_EXIT = 17,
808 MMAGIC_WLAN_CMD_STANDBY_SET_STATUS_PAYLOAD = 18,
814 MMAGIC_WLAN_CMD_STANDBY_SET_WAKE_FILTER = 19,
817 MMAGIC_WLAN_CMD_STANDBY_SET_CONFIG = 20,
819 MMAGIC_WLAN_CMD_GET_STA_STATUS = 21,
820};
821
823enum mmagic_ip_var
824{
827 MMAGIC_IP_VAR_IP_ADDR = 0,
830 MMAGIC_IP_VAR_NETMASK = 1,
833 MMAGIC_IP_VAR_GATEWAY = 2,
837 MMAGIC_IP_VAR_DNS_SERVER0 = 3,
841 MMAGIC_IP_VAR_DNS_SERVER1 = 4,
845 MMAGIC_IP_VAR_DHCP_ENABLED = 5,
849 MMAGIC_IP_VAR_DHCP_OFFLOAD = 6,
852 MMAGIC_IP_VAR_LINK_STATUS_EVT_EN = 7,
855 MMAGIC_IP_VAR_OFFLOAD_ARP_RESPONSE = 8,
858 MMAGIC_IP_VAR_OFFLOAD_ARP_REFRESH_S = 9,
859};
860
862enum mmagic_ip_cmd
863{
865 MMAGIC_IP_CMD_GET = 0,
867 MMAGIC_IP_CMD_SET = 1,
869 MMAGIC_IP_CMD_LOAD = 2,
871 MMAGIC_IP_CMD_COMMIT = 3,
873 MMAGIC_IP_CMD_STATUS = 8,
876 MMAGIC_IP_CMD_RELOAD = 9,
881 MMAGIC_IP_CMD_ENABLE_TCP_KEEPALIVE_OFFLOAD = 10,
883 MMAGIC_IP_CMD_DISABLE_TCP_KEEPALIVE_OFFLOAD = 11,
886 MMAGIC_IP_CMD_SET_WHITELIST_FILTER = 12,
888 MMAGIC_IP_CMD_CLEAR_WHITELIST_FILTER = 13,
889};
890
892enum mmagic_ping_var
893{
895 MMAGIC_PING_VAR_TARGET = 0,
897 MMAGIC_PING_VAR_INTERVAL = 1,
900 MMAGIC_PING_VAR_COUNT = 2,
901};
902
904enum mmagic_ping_cmd
905{
907 MMAGIC_PING_CMD_GET = 0,
909 MMAGIC_PING_CMD_SET = 1,
911 MMAGIC_PING_CMD_LOAD = 2,
913 MMAGIC_PING_CMD_COMMIT = 3,
915 MMAGIC_PING_CMD_RUN = 8,
916};
917
919enum mmagic_iperf_var
920{
923 MMAGIC_IPERF_VAR_MODE = 0,
925 MMAGIC_IPERF_VAR_SERVER = 1,
928 MMAGIC_IPERF_VAR_PORT = 2,
932 MMAGIC_IPERF_VAR_AMOUNT = 3,
933};
934
936enum mmagic_iperf_cmd
937{
939 MMAGIC_IPERF_CMD_GET = 0,
941 MMAGIC_IPERF_CMD_SET = 1,
943 MMAGIC_IPERF_CMD_LOAD = 2,
945 MMAGIC_IPERF_CMD_COMMIT = 3,
947 MMAGIC_IPERF_CMD_RUN = 8,
948};
949
951enum mmagic_sys_cmd
952{
954 MMAGIC_SYS_CMD_GET = 0,
956 MMAGIC_SYS_CMD_SET = 1,
958 MMAGIC_SYS_CMD_LOAD = 2,
960 MMAGIC_SYS_CMD_COMMIT = 3,
962 MMAGIC_SYS_CMD_RESET = 8,
964 MMAGIC_SYS_CMD_DEEP_SLEEP = 9,
966 MMAGIC_SYS_CMD_GET_VERSION = 10,
967};
968
970enum mmagic_tcp_cmd
971{
973 MMAGIC_TCP_CMD_GET = 0,
975 MMAGIC_TCP_CMD_SET = 1,
977 MMAGIC_TCP_CMD_LOAD = 2,
979 MMAGIC_TCP_CMD_COMMIT = 3,
981 MMAGIC_TCP_CMD_CONNECT = 8,
983 MMAGIC_TCP_CMD_BIND = 9,
985 MMAGIC_TCP_CMD_RECV = 10,
987 MMAGIC_TCP_CMD_SEND = 11,
989 MMAGIC_TCP_CMD_READ_POLL = 12,
991 MMAGIC_TCP_CMD_WRITE_POLL = 13,
993 MMAGIC_TCP_CMD_ACCEPT = 14,
995 MMAGIC_TCP_CMD_CLOSE = 15,
999 MMAGIC_TCP_CMD_SET_RX_READY_EVT_ENABLED = 16,
1000};
1001
1003enum mmagic_tls_var
1004{
1007 MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE = 0,
1010 MMAGIC_TLS_VAR_CLIENT_CERTIFICATE = 1,
1013 MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY = 2,
1014};
1015
1017enum mmagic_tls_cmd
1018{
1020 MMAGIC_TLS_CMD_GET = 0,
1022 MMAGIC_TLS_CMD_SET = 1,
1024 MMAGIC_TLS_CMD_LOAD = 2,
1026 MMAGIC_TLS_CMD_COMMIT = 3,
1027};
1028
1030enum mmagic_ntp_var
1031{
1033 MMAGIC_NTP_VAR_SERVER = 0,
1034};
1035
1037enum mmagic_ntp_cmd
1038{
1040 MMAGIC_NTP_CMD_GET = 0,
1042 MMAGIC_NTP_CMD_SET = 1,
1044 MMAGIC_NTP_CMD_LOAD = 2,
1046 MMAGIC_NTP_CMD_COMMIT = 3,
1048 MMAGIC_NTP_CMD_SYNC = 8,
1050 MMAGIC_NTP_CMD_GET_TIME = 9,
1051};
1052
1054enum mmagic_mqtt_cmd
1055{
1057 MMAGIC_MQTT_CMD_GET = 0,
1059 MMAGIC_MQTT_CMD_SET = 1,
1061 MMAGIC_MQTT_CMD_LOAD = 2,
1063 MMAGIC_MQTT_CMD_COMMIT = 3,
1067 MMAGIC_MQTT_CMD_START_AGENT = 8,
1069 MMAGIC_MQTT_CMD_PUBLISH = 9,
1071 MMAGIC_MQTT_CMD_SUBSCRIBE = 10,
1073 MMAGIC_MQTT_CMD_STOP_AGENT = 11,
1074};
1075
1098static inline enum mmagic_status mmagic_controller_get_wlan_country_code(
1099 struct mmagic_controller *controller,
1100 struct struct_country_code *var)
1101{
1102 enum mmagic_status status;
1103 status = mmagic_controller_tx(controller,
1104 CONTROL_STREAM,
1105 MMAGIC_WLAN,
1106 MMAGIC_WLAN_CMD_GET,
1107 MMAGIC_WLAN_VAR_COUNTRY_CODE,
1108 NULL,
1109 0);
1110 if (status != MMAGIC_STATUS_OK)
1111 {
1112 return status;
1113 }
1114 status = mmagic_controller_rx(controller,
1115 CONTROL_STREAM,
1116 MMAGIC_WLAN,
1117 MMAGIC_WLAN_CMD_GET,
1118 MMAGIC_WLAN_VAR_COUNTRY_CODE,
1119 (uint8_t *)var,
1120 sizeof(*var),
1121 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1122 return status;
1123}
1124
1135static inline enum mmagic_status mmagic_controller_set_wlan_country_code(
1136 struct mmagic_controller *controller,
1137 struct struct_country_code *var)
1138{
1139 enum mmagic_status status;
1140 status = mmagic_controller_tx(controller,
1141 CONTROL_STREAM,
1142 MMAGIC_WLAN,
1143 MMAGIC_WLAN_CMD_SET,
1144 MMAGIC_WLAN_VAR_COUNTRY_CODE,
1145 (uint8_t *)var,
1146 sizeof(*var));
1147 if (status != MMAGIC_STATUS_OK)
1148 {
1149 return status;
1150 }
1151 status = mmagic_controller_rx(controller,
1152 CONTROL_STREAM,
1153 MMAGIC_WLAN,
1154 MMAGIC_WLAN_CMD_SET,
1155 MMAGIC_WLAN_VAR_COUNTRY_CODE,
1156 NULL,
1157 0,
1158 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1159 return status;
1160}
1161
1172static inline enum mmagic_status mmagic_controller_get_wlan_ssid(
1173 struct mmagic_controller *controller,
1174 struct string32 *var)
1175{
1176 enum mmagic_status status;
1177 status = mmagic_controller_tx(controller,
1178 CONTROL_STREAM,
1179 MMAGIC_WLAN,
1180 MMAGIC_WLAN_CMD_GET,
1181 MMAGIC_WLAN_VAR_SSID,
1182 NULL,
1183 0);
1184 if (status != MMAGIC_STATUS_OK)
1185 {
1186 return status;
1187 }
1188 status = mmagic_controller_rx(controller,
1189 CONTROL_STREAM,
1190 MMAGIC_WLAN,
1191 MMAGIC_WLAN_CMD_GET,
1192 MMAGIC_WLAN_VAR_SSID,
1193 (uint8_t *)var,
1194 sizeof(*var),
1195 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1196 return status;
1197}
1198
1209static inline enum mmagic_status mmagic_controller_set_wlan_ssid(
1210 struct mmagic_controller *controller,
1211 const char *var)
1212{
1213 struct string32 var_val;
1214 enum mmagic_status status;
1215 var_val.len = strlen(var);
1216 if (var_val.len > sizeof(var_val.data) - 1)
1217 {
1218 return MMAGIC_STATUS_INVALID_ARG;
1219 }
1220 memcpy(var_val.data, (const uint8_t *)var, var_val.len);
1221 memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
1222 status = mmagic_controller_tx(controller,
1223 CONTROL_STREAM,
1224 MMAGIC_WLAN,
1225 MMAGIC_WLAN_CMD_SET,
1226 MMAGIC_WLAN_VAR_SSID,
1227 (uint8_t *)&var_val,
1228 sizeof(var_val));
1229 if (status != MMAGIC_STATUS_OK)
1230 {
1231 return status;
1232 }
1233 status = mmagic_controller_rx(controller,
1234 CONTROL_STREAM,
1235 MMAGIC_WLAN,
1236 MMAGIC_WLAN_CMD_SET,
1237 MMAGIC_WLAN_VAR_SSID,
1238 NULL,
1239 0,
1240 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1241 return status;
1242}
1243
1254static inline enum mmagic_status mmagic_controller_get_wlan_password(
1255 struct mmagic_controller *controller,
1256 struct string100 *var)
1257{
1258 enum mmagic_status status;
1259 status = mmagic_controller_tx(controller,
1260 CONTROL_STREAM,
1261 MMAGIC_WLAN,
1262 MMAGIC_WLAN_CMD_GET,
1263 MMAGIC_WLAN_VAR_PASSWORD,
1264 NULL,
1265 0);
1266 if (status != MMAGIC_STATUS_OK)
1267 {
1268 return status;
1269 }
1270 status = mmagic_controller_rx(controller,
1271 CONTROL_STREAM,
1272 MMAGIC_WLAN,
1273 MMAGIC_WLAN_CMD_GET,
1274 MMAGIC_WLAN_VAR_PASSWORD,
1275 (uint8_t *)var,
1276 sizeof(*var),
1277 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1278 return status;
1279}
1280
1291static inline enum mmagic_status mmagic_controller_set_wlan_password(
1292 struct mmagic_controller *controller,
1293 const char *var)
1294{
1295 struct string100 var_val;
1296 enum mmagic_status status;
1297 var_val.len = strlen(var);
1298 if (var_val.len > sizeof(var_val.data) - 1)
1299 {
1300 return MMAGIC_STATUS_INVALID_ARG;
1301 }
1302 memcpy(var_val.data, (const uint8_t *)var, var_val.len);
1303 memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
1304 status = mmagic_controller_tx(controller,
1305 CONTROL_STREAM,
1306 MMAGIC_WLAN,
1307 MMAGIC_WLAN_CMD_SET,
1308 MMAGIC_WLAN_VAR_PASSWORD,
1309 (uint8_t *)&var_val,
1310 sizeof(var_val));
1311 if (status != MMAGIC_STATUS_OK)
1312 {
1313 return status;
1314 }
1315 status = mmagic_controller_rx(controller,
1316 CONTROL_STREAM,
1317 MMAGIC_WLAN,
1318 MMAGIC_WLAN_CMD_SET,
1319 MMAGIC_WLAN_VAR_PASSWORD,
1320 NULL,
1321 0,
1322 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1323 return status;
1324}
1325
1336static inline enum mmagic_status mmagic_controller_get_wlan_security(
1337 struct mmagic_controller *controller,
1338 enum mmagic_security_type *var)
1339{
1340 enum mmagic_status status;
1341 status = mmagic_controller_tx(controller,
1342 CONTROL_STREAM,
1343 MMAGIC_WLAN,
1344 MMAGIC_WLAN_CMD_GET,
1345 MMAGIC_WLAN_VAR_SECURITY,
1346 NULL,
1347 0);
1348 if (status != MMAGIC_STATUS_OK)
1349 {
1350 return status;
1351 }
1352 status = mmagic_controller_rx(controller,
1353 CONTROL_STREAM,
1354 MMAGIC_WLAN,
1355 MMAGIC_WLAN_CMD_GET,
1356 MMAGIC_WLAN_VAR_SECURITY,
1357 (uint8_t *)var,
1358 sizeof(*var),
1359 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1360 return status;
1361}
1362
1373static inline enum mmagic_status mmagic_controller_set_wlan_security(
1374 struct mmagic_controller *controller,
1375 enum mmagic_security_type var)
1376{
1377 enum mmagic_status status;
1378 status = mmagic_controller_tx(controller,
1379 CONTROL_STREAM,
1380 MMAGIC_WLAN,
1381 MMAGIC_WLAN_CMD_SET,
1382 MMAGIC_WLAN_VAR_SECURITY,
1383 (uint8_t *)&var,
1384 sizeof(var));
1385 if (status != MMAGIC_STATUS_OK)
1386 {
1387 return status;
1388 }
1389 status = mmagic_controller_rx(controller,
1390 CONTROL_STREAM,
1391 MMAGIC_WLAN,
1392 MMAGIC_WLAN_CMD_SET,
1393 MMAGIC_WLAN_VAR_SECURITY,
1394 NULL,
1395 0,
1396 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1397 return status;
1398}
1399
1410static inline enum mmagic_status mmagic_controller_get_wlan_raw_priority(
1411 struct mmagic_controller *controller,
1412 int16_t *var)
1413{
1414 enum mmagic_status status;
1415 status = mmagic_controller_tx(controller,
1416 CONTROL_STREAM,
1417 MMAGIC_WLAN,
1418 MMAGIC_WLAN_CMD_GET,
1419 MMAGIC_WLAN_VAR_RAW_PRIORITY,
1420 NULL,
1421 0);
1422 if (status != MMAGIC_STATUS_OK)
1423 {
1424 return status;
1425 }
1426 status = mmagic_controller_rx(controller,
1427 CONTROL_STREAM,
1428 MMAGIC_WLAN,
1429 MMAGIC_WLAN_CMD_GET,
1430 MMAGIC_WLAN_VAR_RAW_PRIORITY,
1431 (uint8_t *)var,
1432 sizeof(*var),
1433 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1434 return status;
1435}
1436
1447static inline enum mmagic_status mmagic_controller_set_wlan_raw_priority(
1448 struct mmagic_controller *controller,
1449 int16_t var)
1450{
1451 enum mmagic_status status;
1452 status = mmagic_controller_tx(controller,
1453 CONTROL_STREAM,
1454 MMAGIC_WLAN,
1455 MMAGIC_WLAN_CMD_SET,
1456 MMAGIC_WLAN_VAR_RAW_PRIORITY,
1457 (uint8_t *)&var,
1458 sizeof(var));
1459 if (status != MMAGIC_STATUS_OK)
1460 {
1461 return status;
1462 }
1463 status = mmagic_controller_rx(controller,
1464 CONTROL_STREAM,
1465 MMAGIC_WLAN,
1466 MMAGIC_WLAN_CMD_SET,
1467 MMAGIC_WLAN_VAR_RAW_PRIORITY,
1468 NULL,
1469 0,
1470 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1471 return status;
1472}
1473
1484static inline enum mmagic_status mmagic_controller_get_wlan_bssid(
1485 struct mmagic_controller *controller,
1486 struct struct_mac_addr *var)
1487{
1488 enum mmagic_status status;
1489 status = mmagic_controller_tx(controller,
1490 CONTROL_STREAM,
1491 MMAGIC_WLAN,
1492 MMAGIC_WLAN_CMD_GET,
1493 MMAGIC_WLAN_VAR_BSSID,
1494 NULL,
1495 0);
1496 if (status != MMAGIC_STATUS_OK)
1497 {
1498 return status;
1499 }
1500 status = mmagic_controller_rx(controller,
1501 CONTROL_STREAM,
1502 MMAGIC_WLAN,
1503 MMAGIC_WLAN_CMD_GET,
1504 MMAGIC_WLAN_VAR_BSSID,
1505 (uint8_t *)var,
1506 sizeof(*var),
1507 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1508 return status;
1509}
1510
1521static inline enum mmagic_status mmagic_controller_set_wlan_bssid(
1522 struct mmagic_controller *controller,
1523 struct struct_mac_addr *var)
1524{
1525 enum mmagic_status status;
1526 status = mmagic_controller_tx(controller,
1527 CONTROL_STREAM,
1528 MMAGIC_WLAN,
1529 MMAGIC_WLAN_CMD_SET,
1530 MMAGIC_WLAN_VAR_BSSID,
1531 (uint8_t *)var,
1532 sizeof(*var));
1533 if (status != MMAGIC_STATUS_OK)
1534 {
1535 return status;
1536 }
1537 status = mmagic_controller_rx(controller,
1538 CONTROL_STREAM,
1539 MMAGIC_WLAN,
1540 MMAGIC_WLAN_CMD_SET,
1541 MMAGIC_WLAN_VAR_BSSID,
1542 NULL,
1543 0,
1544 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1545 return status;
1546}
1547
1558static inline enum mmagic_status mmagic_controller_get_wlan_pmf_mode(
1559 struct mmagic_controller *controller,
1560 enum mmagic_pmf_mode *var)
1561{
1562 enum mmagic_status status;
1563 status = mmagic_controller_tx(controller,
1564 CONTROL_STREAM,
1565 MMAGIC_WLAN,
1566 MMAGIC_WLAN_CMD_GET,
1567 MMAGIC_WLAN_VAR_PMF_MODE,
1568 NULL,
1569 0);
1570 if (status != MMAGIC_STATUS_OK)
1571 {
1572 return status;
1573 }
1574 status = mmagic_controller_rx(controller,
1575 CONTROL_STREAM,
1576 MMAGIC_WLAN,
1577 MMAGIC_WLAN_CMD_GET,
1578 MMAGIC_WLAN_VAR_PMF_MODE,
1579 (uint8_t *)var,
1580 sizeof(*var),
1581 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1582 return status;
1583}
1584
1595static inline enum mmagic_status mmagic_controller_set_wlan_pmf_mode(
1596 struct mmagic_controller *controller,
1597 enum mmagic_pmf_mode var)
1598{
1599 enum mmagic_status status;
1600 status = mmagic_controller_tx(controller,
1601 CONTROL_STREAM,
1602 MMAGIC_WLAN,
1603 MMAGIC_WLAN_CMD_SET,
1604 MMAGIC_WLAN_VAR_PMF_MODE,
1605 (uint8_t *)&var,
1606 sizeof(var));
1607 if (status != MMAGIC_STATUS_OK)
1608 {
1609 return status;
1610 }
1611 status = mmagic_controller_rx(controller,
1612 CONTROL_STREAM,
1613 MMAGIC_WLAN,
1614 MMAGIC_WLAN_CMD_SET,
1615 MMAGIC_WLAN_VAR_PMF_MODE,
1616 NULL,
1617 0,
1618 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1619 return status;
1620}
1621
1632static inline enum mmagic_status mmagic_controller_get_wlan_station_type(
1633 struct mmagic_controller *controller,
1634 enum mmagic_station_type *var)
1635{
1636 enum mmagic_status status;
1637 status = mmagic_controller_tx(controller,
1638 CONTROL_STREAM,
1639 MMAGIC_WLAN,
1640 MMAGIC_WLAN_CMD_GET,
1641 MMAGIC_WLAN_VAR_STATION_TYPE,
1642 NULL,
1643 0);
1644 if (status != MMAGIC_STATUS_OK)
1645 {
1646 return status;
1647 }
1648 status = mmagic_controller_rx(controller,
1649 CONTROL_STREAM,
1650 MMAGIC_WLAN,
1651 MMAGIC_WLAN_CMD_GET,
1652 MMAGIC_WLAN_VAR_STATION_TYPE,
1653 (uint8_t *)var,
1654 sizeof(*var),
1655 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1656 return status;
1657}
1658
1669static inline enum mmagic_status mmagic_controller_set_wlan_station_type(
1670 struct mmagic_controller *controller,
1671 enum mmagic_station_type var)
1672{
1673 enum mmagic_status status;
1674 status = mmagic_controller_tx(controller,
1675 CONTROL_STREAM,
1676 MMAGIC_WLAN,
1677 MMAGIC_WLAN_CMD_SET,
1678 MMAGIC_WLAN_VAR_STATION_TYPE,
1679 (uint8_t *)&var,
1680 sizeof(var));
1681 if (status != MMAGIC_STATUS_OK)
1682 {
1683 return status;
1684 }
1685 status = mmagic_controller_rx(controller,
1686 CONTROL_STREAM,
1687 MMAGIC_WLAN,
1688 MMAGIC_WLAN_CMD_SET,
1689 MMAGIC_WLAN_VAR_STATION_TYPE,
1690 NULL,
1691 0,
1692 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1693 return status;
1694}
1695
1706static inline enum mmagic_status mmagic_controller_get_wlan_rts_threshold(
1707 struct mmagic_controller *controller,
1708 uint32_t *var)
1709{
1710 enum mmagic_status status;
1711 status = mmagic_controller_tx(controller,
1712 CONTROL_STREAM,
1713 MMAGIC_WLAN,
1714 MMAGIC_WLAN_CMD_GET,
1715 MMAGIC_WLAN_VAR_RTS_THRESHOLD,
1716 NULL,
1717 0);
1718 if (status != MMAGIC_STATUS_OK)
1719 {
1720 return status;
1721 }
1722 status = mmagic_controller_rx(controller,
1723 CONTROL_STREAM,
1724 MMAGIC_WLAN,
1725 MMAGIC_WLAN_CMD_GET,
1726 MMAGIC_WLAN_VAR_RTS_THRESHOLD,
1727 (uint8_t *)var,
1728 sizeof(*var),
1729 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1730 return status;
1731}
1732
1743static inline enum mmagic_status mmagic_controller_set_wlan_rts_threshold(
1744 struct mmagic_controller *controller,
1745 uint32_t var)
1746{
1747 enum mmagic_status status;
1748 status = mmagic_controller_tx(controller,
1749 CONTROL_STREAM,
1750 MMAGIC_WLAN,
1751 MMAGIC_WLAN_CMD_SET,
1752 MMAGIC_WLAN_VAR_RTS_THRESHOLD,
1753 (uint8_t *)&var,
1754 sizeof(var));
1755 if (status != MMAGIC_STATUS_OK)
1756 {
1757 return status;
1758 }
1759 status = mmagic_controller_rx(controller,
1760 CONTROL_STREAM,
1761 MMAGIC_WLAN,
1762 MMAGIC_WLAN_CMD_SET,
1763 MMAGIC_WLAN_VAR_RTS_THRESHOLD,
1764 NULL,
1765 0,
1766 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1767 return status;
1768}
1769
1780static inline enum mmagic_status mmagic_controller_get_wlan_sgi_enabled(
1781 struct mmagic_controller *controller,
1782 bool *var)
1783{
1784 enum mmagic_status status;
1785 status = mmagic_controller_tx(controller,
1786 CONTROL_STREAM,
1787 MMAGIC_WLAN,
1788 MMAGIC_WLAN_CMD_GET,
1789 MMAGIC_WLAN_VAR_SGI_ENABLED,
1790 NULL,
1791 0);
1792 if (status != MMAGIC_STATUS_OK)
1793 {
1794 return status;
1795 }
1796 status = mmagic_controller_rx(controller,
1797 CONTROL_STREAM,
1798 MMAGIC_WLAN,
1799 MMAGIC_WLAN_CMD_GET,
1800 MMAGIC_WLAN_VAR_SGI_ENABLED,
1801 (uint8_t *)var,
1802 sizeof(*var),
1803 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1804 return status;
1805}
1806
1817static inline enum mmagic_status mmagic_controller_set_wlan_sgi_enabled(
1818 struct mmagic_controller *controller,
1819 bool var)
1820{
1821 enum mmagic_status status;
1822 status = mmagic_controller_tx(controller,
1823 CONTROL_STREAM,
1824 MMAGIC_WLAN,
1825 MMAGIC_WLAN_CMD_SET,
1826 MMAGIC_WLAN_VAR_SGI_ENABLED,
1827 (uint8_t *)&var,
1828 sizeof(var));
1829 if (status != MMAGIC_STATUS_OK)
1830 {
1831 return status;
1832 }
1833 status = mmagic_controller_rx(controller,
1834 CONTROL_STREAM,
1835 MMAGIC_WLAN,
1836 MMAGIC_WLAN_CMD_SET,
1837 MMAGIC_WLAN_VAR_SGI_ENABLED,
1838 NULL,
1839 0,
1840 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1841 return status;
1842}
1843
1854static inline enum mmagic_status mmagic_controller_get_wlan_subbands_enabled(
1855 struct mmagic_controller *controller,
1856 bool *var)
1857{
1858 enum mmagic_status status;
1859 status = mmagic_controller_tx(controller,
1860 CONTROL_STREAM,
1861 MMAGIC_WLAN,
1862 MMAGIC_WLAN_CMD_GET,
1863 MMAGIC_WLAN_VAR_SUBBANDS_ENABLED,
1864 NULL,
1865 0);
1866 if (status != MMAGIC_STATUS_OK)
1867 {
1868 return status;
1869 }
1870 status = mmagic_controller_rx(controller,
1871 CONTROL_STREAM,
1872 MMAGIC_WLAN,
1873 MMAGIC_WLAN_CMD_GET,
1874 MMAGIC_WLAN_VAR_SUBBANDS_ENABLED,
1875 (uint8_t *)var,
1876 sizeof(*var),
1877 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1878 return status;
1879}
1880
1891static inline enum mmagic_status mmagic_controller_set_wlan_subbands_enabled(
1892 struct mmagic_controller *controller,
1893 bool var)
1894{
1895 enum mmagic_status status;
1896 status = mmagic_controller_tx(controller,
1897 CONTROL_STREAM,
1898 MMAGIC_WLAN,
1899 MMAGIC_WLAN_CMD_SET,
1900 MMAGIC_WLAN_VAR_SUBBANDS_ENABLED,
1901 (uint8_t *)&var,
1902 sizeof(var));
1903 if (status != MMAGIC_STATUS_OK)
1904 {
1905 return status;
1906 }
1907 status = mmagic_controller_rx(controller,
1908 CONTROL_STREAM,
1909 MMAGIC_WLAN,
1910 MMAGIC_WLAN_CMD_SET,
1911 MMAGIC_WLAN_VAR_SUBBANDS_ENABLED,
1912 NULL,
1913 0,
1914 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1915 return status;
1916}
1917
1928static inline enum mmagic_status mmagic_controller_get_wlan_ampdu_enabled(
1929 struct mmagic_controller *controller,
1930 bool *var)
1931{
1932 enum mmagic_status status;
1933 status = mmagic_controller_tx(controller,
1934 CONTROL_STREAM,
1935 MMAGIC_WLAN,
1936 MMAGIC_WLAN_CMD_GET,
1937 MMAGIC_WLAN_VAR_AMPDU_ENABLED,
1938 NULL,
1939 0);
1940 if (status != MMAGIC_STATUS_OK)
1941 {
1942 return status;
1943 }
1944 status = mmagic_controller_rx(controller,
1945 CONTROL_STREAM,
1946 MMAGIC_WLAN,
1947 MMAGIC_WLAN_CMD_GET,
1948 MMAGIC_WLAN_VAR_AMPDU_ENABLED,
1949 (uint8_t *)var,
1950 sizeof(*var),
1951 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1952 return status;
1953}
1954
1965static inline enum mmagic_status mmagic_controller_set_wlan_ampdu_enabled(
1966 struct mmagic_controller *controller,
1967 bool var)
1968{
1969 enum mmagic_status status;
1970 status = mmagic_controller_tx(controller,
1971 CONTROL_STREAM,
1972 MMAGIC_WLAN,
1973 MMAGIC_WLAN_CMD_SET,
1974 MMAGIC_WLAN_VAR_AMPDU_ENABLED,
1975 (uint8_t *)&var,
1976 sizeof(var));
1977 if (status != MMAGIC_STATUS_OK)
1978 {
1979 return status;
1980 }
1981 status = mmagic_controller_rx(controller,
1982 CONTROL_STREAM,
1983 MMAGIC_WLAN,
1984 MMAGIC_WLAN_CMD_SET,
1985 MMAGIC_WLAN_VAR_AMPDU_ENABLED,
1986 NULL,
1987 0,
1988 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
1989 return status;
1990}
1991
2002static inline enum mmagic_status mmagic_controller_get_wlan_power_save_mode(
2003 struct mmagic_controller *controller,
2004 enum mmagic_power_save_mode *var)
2005{
2006 enum mmagic_status status;
2007 status = mmagic_controller_tx(controller,
2008 CONTROL_STREAM,
2009 MMAGIC_WLAN,
2010 MMAGIC_WLAN_CMD_GET,
2011 MMAGIC_WLAN_VAR_POWER_SAVE_MODE,
2012 NULL,
2013 0);
2014 if (status != MMAGIC_STATUS_OK)
2015 {
2016 return status;
2017 }
2018 status = mmagic_controller_rx(controller,
2019 CONTROL_STREAM,
2020 MMAGIC_WLAN,
2021 MMAGIC_WLAN_CMD_GET,
2022 MMAGIC_WLAN_VAR_POWER_SAVE_MODE,
2023 (uint8_t *)var,
2024 sizeof(*var),
2025 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2026 return status;
2027}
2028
2039static inline enum mmagic_status mmagic_controller_set_wlan_power_save_mode(
2040 struct mmagic_controller *controller,
2041 enum mmagic_power_save_mode var)
2042{
2043 enum mmagic_status status;
2044 status = mmagic_controller_tx(controller,
2045 CONTROL_STREAM,
2046 MMAGIC_WLAN,
2047 MMAGIC_WLAN_CMD_SET,
2048 MMAGIC_WLAN_VAR_POWER_SAVE_MODE,
2049 (uint8_t *)&var,
2050 sizeof(var));
2051 if (status != MMAGIC_STATUS_OK)
2052 {
2053 return status;
2054 }
2055 status = mmagic_controller_rx(controller,
2056 CONTROL_STREAM,
2057 MMAGIC_WLAN,
2058 MMAGIC_WLAN_CMD_SET,
2059 MMAGIC_WLAN_VAR_POWER_SAVE_MODE,
2060 NULL,
2061 0,
2062 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2063 return status;
2064}
2065
2077static inline enum mmagic_status mmagic_controller_get_wlan_fragment_threshold(
2078 struct mmagic_controller *controller,
2079 uint32_t *var)
2080{
2081 enum mmagic_status status;
2082 status = mmagic_controller_tx(controller,
2083 CONTROL_STREAM,
2084 MMAGIC_WLAN,
2085 MMAGIC_WLAN_CMD_GET,
2086 MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD,
2087 NULL,
2088 0);
2089 if (status != MMAGIC_STATUS_OK)
2090 {
2091 return status;
2092 }
2093 status = mmagic_controller_rx(controller,
2094 CONTROL_STREAM,
2095 MMAGIC_WLAN,
2096 MMAGIC_WLAN_CMD_GET,
2097 MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD,
2098 (uint8_t *)var,
2099 sizeof(*var),
2100 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2101 return status;
2102}
2103
2115static inline enum mmagic_status mmagic_controller_set_wlan_fragment_threshold(
2116 struct mmagic_controller *controller,
2117 uint32_t var)
2118{
2119 enum mmagic_status status;
2120 status = mmagic_controller_tx(controller,
2121 CONTROL_STREAM,
2122 MMAGIC_WLAN,
2123 MMAGIC_WLAN_CMD_SET,
2124 MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD,
2125 (uint8_t *)&var,
2126 sizeof(var));
2127 if (status != MMAGIC_STATUS_OK)
2128 {
2129 return status;
2130 }
2131 status = mmagic_controller_rx(controller,
2132 CONTROL_STREAM,
2133 MMAGIC_WLAN,
2134 MMAGIC_WLAN_CMD_SET,
2135 MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD,
2136 NULL,
2137 0,
2138 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2139 return status;
2140}
2141
2152static inline enum mmagic_status mmagic_controller_get_wlan_cac_enabled(
2153 struct mmagic_controller *controller,
2154 bool *var)
2155{
2156 enum mmagic_status status;
2157 status = mmagic_controller_tx(controller,
2158 CONTROL_STREAM,
2159 MMAGIC_WLAN,
2160 MMAGIC_WLAN_CMD_GET,
2161 MMAGIC_WLAN_VAR_CAC_ENABLED,
2162 NULL,
2163 0);
2164 if (status != MMAGIC_STATUS_OK)
2165 {
2166 return status;
2167 }
2168 status = mmagic_controller_rx(controller,
2169 CONTROL_STREAM,
2170 MMAGIC_WLAN,
2171 MMAGIC_WLAN_CMD_GET,
2172 MMAGIC_WLAN_VAR_CAC_ENABLED,
2173 (uint8_t *)var,
2174 sizeof(*var),
2175 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2176 return status;
2177}
2178
2189static inline enum mmagic_status mmagic_controller_set_wlan_cac_enabled(
2190 struct mmagic_controller *controller,
2191 bool var)
2192{
2193 enum mmagic_status status;
2194 status = mmagic_controller_tx(controller,
2195 CONTROL_STREAM,
2196 MMAGIC_WLAN,
2197 MMAGIC_WLAN_CMD_SET,
2198 MMAGIC_WLAN_VAR_CAC_ENABLED,
2199 (uint8_t *)&var,
2200 sizeof(var));
2201 if (status != MMAGIC_STATUS_OK)
2202 {
2203 return status;
2204 }
2205 status = mmagic_controller_rx(controller,
2206 CONTROL_STREAM,
2207 MMAGIC_WLAN,
2208 MMAGIC_WLAN_CMD_SET,
2209 MMAGIC_WLAN_VAR_CAC_ENABLED,
2210 NULL,
2211 0,
2212 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2213 return status;
2214}
2215
2230static inline enum mmagic_status mmagic_controller_get_wlan_min_health_check_intvl_ms(
2231 struct mmagic_controller *controller,
2232 uint32_t *var)
2233{
2234 enum mmagic_status status;
2235 status = mmagic_controller_tx(controller,
2236 CONTROL_STREAM,
2237 MMAGIC_WLAN,
2238 MMAGIC_WLAN_CMD_GET,
2239 MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS,
2240 NULL,
2241 0);
2242 if (status != MMAGIC_STATUS_OK)
2243 {
2244 return status;
2245 }
2246 status = mmagic_controller_rx(controller,
2247 CONTROL_STREAM,
2248 MMAGIC_WLAN,
2249 MMAGIC_WLAN_CMD_GET,
2250 MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS,
2251 (uint8_t *)var,
2252 sizeof(*var),
2253 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2254 return status;
2255}
2256
2271static inline enum mmagic_status mmagic_controller_set_wlan_min_health_check_intvl_ms(
2272 struct mmagic_controller *controller,
2273 uint32_t var)
2274{
2275 enum mmagic_status status;
2276 status = mmagic_controller_tx(controller,
2277 CONTROL_STREAM,
2278 MMAGIC_WLAN,
2279 MMAGIC_WLAN_CMD_SET,
2280 MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS,
2281 (uint8_t *)&var,
2282 sizeof(var));
2283 if (status != MMAGIC_STATUS_OK)
2284 {
2285 return status;
2286 }
2287 status = mmagic_controller_rx(controller,
2288 CONTROL_STREAM,
2289 MMAGIC_WLAN,
2290 MMAGIC_WLAN_CMD_SET,
2291 MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS,
2292 NULL,
2293 0,
2294 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2295 return status;
2296}
2297
2311static inline enum mmagic_status mmagic_controller_get_wlan_max_health_check_intvl_ms(
2312 struct mmagic_controller *controller,
2313 uint32_t *var)
2314{
2315 enum mmagic_status status;
2316 status = mmagic_controller_tx(controller,
2317 CONTROL_STREAM,
2318 MMAGIC_WLAN,
2319 MMAGIC_WLAN_CMD_GET,
2320 MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS,
2321 NULL,
2322 0);
2323 if (status != MMAGIC_STATUS_OK)
2324 {
2325 return status;
2326 }
2327 status = mmagic_controller_rx(controller,
2328 CONTROL_STREAM,
2329 MMAGIC_WLAN,
2330 MMAGIC_WLAN_CMD_GET,
2331 MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS,
2332 (uint8_t *)var,
2333 sizeof(*var),
2334 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2335 return status;
2336}
2337
2351static inline enum mmagic_status mmagic_controller_set_wlan_max_health_check_intvl_ms(
2352 struct mmagic_controller *controller,
2353 uint32_t var)
2354{
2355 enum mmagic_status status;
2356 status = mmagic_controller_tx(controller,
2357 CONTROL_STREAM,
2358 MMAGIC_WLAN,
2359 MMAGIC_WLAN_CMD_SET,
2360 MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS,
2361 (uint8_t *)&var,
2362 sizeof(var));
2363 if (status != MMAGIC_STATUS_OK)
2364 {
2365 return status;
2366 }
2367 status = mmagic_controller_rx(controller,
2368 CONTROL_STREAM,
2369 MMAGIC_WLAN,
2370 MMAGIC_WLAN_CMD_SET,
2371 MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS,
2372 NULL,
2373 0,
2374 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2375 return status;
2376}
2377
2389static inline enum mmagic_status mmagic_controller_get_wlan_ndp_probe_enabled(
2390 struct mmagic_controller *controller,
2391 bool *var)
2392{
2393 enum mmagic_status status;
2394 status = mmagic_controller_tx(controller,
2395 CONTROL_STREAM,
2396 MMAGIC_WLAN,
2397 MMAGIC_WLAN_CMD_GET,
2398 MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED,
2399 NULL,
2400 0);
2401 if (status != MMAGIC_STATUS_OK)
2402 {
2403 return status;
2404 }
2405 status = mmagic_controller_rx(controller,
2406 CONTROL_STREAM,
2407 MMAGIC_WLAN,
2408 MMAGIC_WLAN_CMD_GET,
2409 MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED,
2410 (uint8_t *)var,
2411 sizeof(*var),
2412 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2413 return status;
2414}
2415
2427static inline enum mmagic_status mmagic_controller_set_wlan_ndp_probe_enabled(
2428 struct mmagic_controller *controller,
2429 bool var)
2430{
2431 enum mmagic_status status;
2432 status = mmagic_controller_tx(controller,
2433 CONTROL_STREAM,
2434 MMAGIC_WLAN,
2435 MMAGIC_WLAN_CMD_SET,
2436 MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED,
2437 (uint8_t *)&var,
2438 sizeof(var));
2439 if (status != MMAGIC_STATUS_OK)
2440 {
2441 return status;
2442 }
2443 status = mmagic_controller_rx(controller,
2444 CONTROL_STREAM,
2445 MMAGIC_WLAN,
2446 MMAGIC_WLAN_CMD_SET,
2447 MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED,
2448 NULL,
2449 0,
2450 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2451 return status;
2452}
2453
2466static inline enum mmagic_status mmagic_controller_get_wlan_sta_scan_interval_base_s(
2467 struct mmagic_controller *controller,
2468 uint16_t *var)
2469{
2470 enum mmagic_status status;
2471 status = mmagic_controller_tx(controller,
2472 CONTROL_STREAM,
2473 MMAGIC_WLAN,
2474 MMAGIC_WLAN_CMD_GET,
2475 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S,
2476 NULL,
2477 0);
2478 if (status != MMAGIC_STATUS_OK)
2479 {
2480 return status;
2481 }
2482 status = mmagic_controller_rx(controller,
2483 CONTROL_STREAM,
2484 MMAGIC_WLAN,
2485 MMAGIC_WLAN_CMD_GET,
2486 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S,
2487 (uint8_t *)var,
2488 sizeof(*var),
2489 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2490 return status;
2491}
2492
2505static inline enum mmagic_status mmagic_controller_set_wlan_sta_scan_interval_base_s(
2506 struct mmagic_controller *controller,
2507 uint16_t var)
2508{
2509 enum mmagic_status status;
2510 status = mmagic_controller_tx(controller,
2511 CONTROL_STREAM,
2512 MMAGIC_WLAN,
2513 MMAGIC_WLAN_CMD_SET,
2514 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S,
2515 (uint8_t *)&var,
2516 sizeof(var));
2517 if (status != MMAGIC_STATUS_OK)
2518 {
2519 return status;
2520 }
2521 status = mmagic_controller_rx(controller,
2522 CONTROL_STREAM,
2523 MMAGIC_WLAN,
2524 MMAGIC_WLAN_CMD_SET,
2525 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S,
2526 NULL,
2527 0,
2528 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2529 return status;
2530}
2531
2544static inline enum mmagic_status mmagic_controller_get_wlan_sta_scan_interval_limit_s(
2545 struct mmagic_controller *controller,
2546 uint16_t *var)
2547{
2548 enum mmagic_status status;
2549 status = mmagic_controller_tx(controller,
2550 CONTROL_STREAM,
2551 MMAGIC_WLAN,
2552 MMAGIC_WLAN_CMD_GET,
2553 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S,
2554 NULL,
2555 0);
2556 if (status != MMAGIC_STATUS_OK)
2557 {
2558 return status;
2559 }
2560 status = mmagic_controller_rx(controller,
2561 CONTROL_STREAM,
2562 MMAGIC_WLAN,
2563 MMAGIC_WLAN_CMD_GET,
2564 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S,
2565 (uint8_t *)var,
2566 sizeof(*var),
2567 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2568 return status;
2569}
2570
2583static inline enum mmagic_status mmagic_controller_set_wlan_sta_scan_interval_limit_s(
2584 struct mmagic_controller *controller,
2585 uint16_t var)
2586{
2587 enum mmagic_status status;
2588 status = mmagic_controller_tx(controller,
2589 CONTROL_STREAM,
2590 MMAGIC_WLAN,
2591 MMAGIC_WLAN_CMD_SET,
2592 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S,
2593 (uint8_t *)&var,
2594 sizeof(var));
2595 if (status != MMAGIC_STATUS_OK)
2596 {
2597 return status;
2598 }
2599 status = mmagic_controller_rx(controller,
2600 CONTROL_STREAM,
2601 MMAGIC_WLAN,
2602 MMAGIC_WLAN_CMD_SET,
2603 MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S,
2604 NULL,
2605 0,
2606 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2607 return status;
2608}
2609
2624static inline enum mmagic_status mmagic_controller_get_wlan_qos_0_params(
2625 struct mmagic_controller *controller,
2626 struct string32 *var)
2627{
2628 enum mmagic_status status;
2629 status = mmagic_controller_tx(controller,
2630 CONTROL_STREAM,
2631 MMAGIC_WLAN,
2632 MMAGIC_WLAN_CMD_GET,
2633 MMAGIC_WLAN_VAR_QOS_0_PARAMS,
2634 NULL,
2635 0);
2636 if (status != MMAGIC_STATUS_OK)
2637 {
2638 return status;
2639 }
2640 status = mmagic_controller_rx(controller,
2641 CONTROL_STREAM,
2642 MMAGIC_WLAN,
2643 MMAGIC_WLAN_CMD_GET,
2644 MMAGIC_WLAN_VAR_QOS_0_PARAMS,
2645 (uint8_t *)var,
2646 sizeof(*var),
2647 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2648 return status;
2649}
2650
2665static inline enum mmagic_status mmagic_controller_set_wlan_qos_0_params(
2666 struct mmagic_controller *controller,
2667 const char *var)
2668{
2669 struct string32 var_val;
2670 enum mmagic_status status;
2671 var_val.len = strlen(var);
2672 if (var_val.len > sizeof(var_val.data) - 1)
2673 {
2674 return MMAGIC_STATUS_INVALID_ARG;
2675 }
2676 memcpy(var_val.data, (const uint8_t *)var, var_val.len);
2677 memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
2678 status = mmagic_controller_tx(controller,
2679 CONTROL_STREAM,
2680 MMAGIC_WLAN,
2681 MMAGIC_WLAN_CMD_SET,
2682 MMAGIC_WLAN_VAR_QOS_0_PARAMS,
2683 (uint8_t *)&var_val,
2684 sizeof(var_val));
2685 if (status != MMAGIC_STATUS_OK)
2686 {
2687 return status;
2688 }
2689 status = mmagic_controller_rx(controller,
2690 CONTROL_STREAM,
2691 MMAGIC_WLAN,
2692 MMAGIC_WLAN_CMD_SET,
2693 MMAGIC_WLAN_VAR_QOS_0_PARAMS,
2694 NULL,
2695 0,
2696 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2697 return status;
2698}
2699
2714static inline enum mmagic_status mmagic_controller_get_wlan_qos_1_params(
2715 struct mmagic_controller *controller,
2716 struct string32 *var)
2717{
2718 enum mmagic_status status;
2719 status = mmagic_controller_tx(controller,
2720 CONTROL_STREAM,
2721 MMAGIC_WLAN,
2722 MMAGIC_WLAN_CMD_GET,
2723 MMAGIC_WLAN_VAR_QOS_1_PARAMS,
2724 NULL,
2725 0);
2726 if (status != MMAGIC_STATUS_OK)
2727 {
2728 return status;
2729 }
2730 status = mmagic_controller_rx(controller,
2731 CONTROL_STREAM,
2732 MMAGIC_WLAN,
2733 MMAGIC_WLAN_CMD_GET,
2734 MMAGIC_WLAN_VAR_QOS_1_PARAMS,
2735 (uint8_t *)var,
2736 sizeof(*var),
2737 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2738 return status;
2739}
2740
2755static inline enum mmagic_status mmagic_controller_set_wlan_qos_1_params(
2756 struct mmagic_controller *controller,
2757 const char *var)
2758{
2759 struct string32 var_val;
2760 enum mmagic_status status;
2761 var_val.len = strlen(var);
2762 if (var_val.len > sizeof(var_val.data) - 1)
2763 {
2764 return MMAGIC_STATUS_INVALID_ARG;
2765 }
2766 memcpy(var_val.data, (const uint8_t *)var, var_val.len);
2767 memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
2768 status = mmagic_controller_tx(controller,
2769 CONTROL_STREAM,
2770 MMAGIC_WLAN,
2771 MMAGIC_WLAN_CMD_SET,
2772 MMAGIC_WLAN_VAR_QOS_1_PARAMS,
2773 (uint8_t *)&var_val,
2774 sizeof(var_val));
2775 if (status != MMAGIC_STATUS_OK)
2776 {
2777 return status;
2778 }
2779 status = mmagic_controller_rx(controller,
2780 CONTROL_STREAM,
2781 MMAGIC_WLAN,
2782 MMAGIC_WLAN_CMD_SET,
2783 MMAGIC_WLAN_VAR_QOS_1_PARAMS,
2784 NULL,
2785 0,
2786 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2787 return status;
2788}
2789
2804static inline enum mmagic_status mmagic_controller_get_wlan_qos_2_params(
2805 struct mmagic_controller *controller,
2806 struct string32 *var)
2807{
2808 enum mmagic_status status;
2809 status = mmagic_controller_tx(controller,
2810 CONTROL_STREAM,
2811 MMAGIC_WLAN,
2812 MMAGIC_WLAN_CMD_GET,
2813 MMAGIC_WLAN_VAR_QOS_2_PARAMS,
2814 NULL,
2815 0);
2816 if (status != MMAGIC_STATUS_OK)
2817 {
2818 return status;
2819 }
2820 status = mmagic_controller_rx(controller,
2821 CONTROL_STREAM,
2822 MMAGIC_WLAN,
2823 MMAGIC_WLAN_CMD_GET,
2824 MMAGIC_WLAN_VAR_QOS_2_PARAMS,
2825 (uint8_t *)var,
2826 sizeof(*var),
2827 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2828 return status;
2829}
2830
2845static inline enum mmagic_status mmagic_controller_set_wlan_qos_2_params(
2846 struct mmagic_controller *controller,
2847 const char *var)
2848{
2849 struct string32 var_val;
2850 enum mmagic_status status;
2851 var_val.len = strlen(var);
2852 if (var_val.len > sizeof(var_val.data) - 1)
2853 {
2854 return MMAGIC_STATUS_INVALID_ARG;
2855 }
2856 memcpy(var_val.data, (const uint8_t *)var, var_val.len);
2857 memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
2858 status = mmagic_controller_tx(controller,
2859 CONTROL_STREAM,
2860 MMAGIC_WLAN,
2861 MMAGIC_WLAN_CMD_SET,
2862 MMAGIC_WLAN_VAR_QOS_2_PARAMS,
2863 (uint8_t *)&var_val,
2864 sizeof(var_val));
2865 if (status != MMAGIC_STATUS_OK)
2866 {
2867 return status;
2868 }
2869 status = mmagic_controller_rx(controller,
2870 CONTROL_STREAM,
2871 MMAGIC_WLAN,
2872 MMAGIC_WLAN_CMD_SET,
2873 MMAGIC_WLAN_VAR_QOS_2_PARAMS,
2874 NULL,
2875 0,
2876 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2877 return status;
2878}
2879
2894static inline enum mmagic_status mmagic_controller_get_wlan_qos_3_params(
2895 struct mmagic_controller *controller,
2896 struct string32 *var)
2897{
2898 enum mmagic_status status;
2899 status = mmagic_controller_tx(controller,
2900 CONTROL_STREAM,
2901 MMAGIC_WLAN,
2902 MMAGIC_WLAN_CMD_GET,
2903 MMAGIC_WLAN_VAR_QOS_3_PARAMS,
2904 NULL,
2905 0);
2906 if (status != MMAGIC_STATUS_OK)
2907 {
2908 return status;
2909 }
2910 status = mmagic_controller_rx(controller,
2911 CONTROL_STREAM,
2912 MMAGIC_WLAN,
2913 MMAGIC_WLAN_CMD_GET,
2914 MMAGIC_WLAN_VAR_QOS_3_PARAMS,
2915 (uint8_t *)var,
2916 sizeof(*var),
2917 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2918 return status;
2919}
2920
2935static inline enum mmagic_status mmagic_controller_set_wlan_qos_3_params(
2936 struct mmagic_controller *controller,
2937 const char *var)
2938{
2939 struct string32 var_val;
2940 enum mmagic_status status;
2941 var_val.len = strlen(var);
2942 if (var_val.len > sizeof(var_val.data) - 1)
2943 {
2944 return MMAGIC_STATUS_INVALID_ARG;
2945 }
2946 memcpy(var_val.data, (const uint8_t *)var, var_val.len);
2947 memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
2948 status = mmagic_controller_tx(controller,
2949 CONTROL_STREAM,
2950 MMAGIC_WLAN,
2951 MMAGIC_WLAN_CMD_SET,
2952 MMAGIC_WLAN_VAR_QOS_3_PARAMS,
2953 (uint8_t *)&var_val,
2954 sizeof(var_val));
2955 if (status != MMAGIC_STATUS_OK)
2956 {
2957 return status;
2958 }
2959 status = mmagic_controller_rx(controller,
2960 CONTROL_STREAM,
2961 MMAGIC_WLAN,
2962 MMAGIC_WLAN_CMD_SET,
2963 MMAGIC_WLAN_VAR_QOS_3_PARAMS,
2964 NULL,
2965 0,
2966 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
2967 return status;
2968}
2969
2983static inline enum mmagic_status mmagic_controller_get_wlan_mcs10_mode(
2984 struct mmagic_controller *controller,
2985 enum mmagic_mcs10_mode *var)
2986{
2987 enum mmagic_status status;
2988 status = mmagic_controller_tx(controller,
2989 CONTROL_STREAM,
2990 MMAGIC_WLAN,
2991 MMAGIC_WLAN_CMD_GET,
2992 MMAGIC_WLAN_VAR_MCS10_MODE,
2993 NULL,
2994 0);
2995 if (status != MMAGIC_STATUS_OK)
2996 {
2997 return status;
2998 }
2999 status = mmagic_controller_rx(controller,
3000 CONTROL_STREAM,
3001 MMAGIC_WLAN,
3002 MMAGIC_WLAN_CMD_GET,
3003 MMAGIC_WLAN_VAR_MCS10_MODE,
3004 (uint8_t *)var,
3005 sizeof(*var),
3006 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
3007 return status;
3008}
3009
3023static inline enum mmagic_status mmagic_controller_set_wlan_mcs10_mode(
3024 struct mmagic_controller *controller,
3025 enum mmagic_mcs10_mode var)
3026{
3027 enum mmagic_status status;
3028 status = mmagic_controller_tx(controller,
3029 CONTROL_STREAM,
3030 MMAGIC_WLAN,
3031 MMAGIC_WLAN_CMD_SET,
3032 MMAGIC_WLAN_VAR_MCS10_MODE,
3033 (uint8_t *)&var,
3034 sizeof(var));
3035 if (status != MMAGIC_STATUS_OK)
3036 {
3037 return status;
3038 }
3039 status = mmagic_controller_rx(controller,
3040 CONTROL_STREAM,
3041 MMAGIC_WLAN,
3042 MMAGIC_WLAN_CMD_SET,
3043 MMAGIC_WLAN_VAR_MCS10_MODE,
3044 NULL,
3045 0,
3046 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
3047 return status;
3048}
3049
3061static inline enum mmagic_status mmagic_controller_get_wlan_sta_evt_en(
3062 struct mmagic_controller *controller,
3063 bool *var)
3064{
3065 enum mmagic_status status;
3066 status = mmagic_controller_tx(controller,
3067 CONTROL_STREAM,
3068 MMAGIC_WLAN,
3069 MMAGIC_WLAN_CMD_GET,
3070 MMAGIC_WLAN_VAR_STA_EVT_EN,
3071 NULL,
3072 0);
3073 if (status != MMAGIC_STATUS_OK)
3074 {
3075 return status;
3076 }
3077 status = mmagic_controller_rx(controller,
3078 CONTROL_STREAM,
3079 MMAGIC_WLAN,
3080 MMAGIC_WLAN_CMD_GET,
3081 MMAGIC_WLAN_VAR_STA_EVT_EN,
3082 (uint8_t *)var,
3083 sizeof(*var),
3084 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
3085 return status;
3086}
3087
3099static inline enum mmagic_status mmagic_controller_set_wlan_sta_evt_en(
3100 struct mmagic_controller *controller,
3101 bool var)
3102{
3103 enum mmagic_status status;
3104 status = mmagic_controller_tx(controller,
3105 CONTROL_STREAM,
3106 MMAGIC_WLAN,
3107 MMAGIC_WLAN_CMD_SET,
3108 MMAGIC_WLAN_VAR_STA_EVT_EN,
3109 (uint8_t *)&var,
3110 sizeof(var));
3111 if (status != MMAGIC_STATUS_OK)
3112 {
3113 return status;
3114 }
3115 status = mmagic_controller_rx(controller,
3116 CONTROL_STREAM,
3117 MMAGIC_WLAN,
3118 MMAGIC_WLAN_CMD_SET,
3119 MMAGIC_WLAN_VAR_STA_EVT_EN,
3120 NULL,
3121 0,
3122 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
3123 return status;
3124}
3125
3138static inline enum mmagic_status mmagic_controller_get_wlan_duty_cycle_mode(
3139 struct mmagic_controller *controller,
3140 enum mmagic_duty_cycle_mode *var)
3141{
3142 enum mmagic_status status;
3143 status = mmagic_controller_tx(controller,
3144 CONTROL_STREAM,
3145 MMAGIC_WLAN,
3146 MMAGIC_WLAN_CMD_GET,
3147 MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE,
3148 NULL,
3149 0);
3150 if (status != MMAGIC_STATUS_OK)
3151 {
3152 return status;
3153 }
3154 status = mmagic_controller_rx(controller,
3155 CONTROL_STREAM,
3156 MMAGIC_WLAN,
3157 MMAGIC_WLAN_CMD_GET,
3158 MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE,
3159 (uint8_t *)var,
3160 sizeof(*var),
3161 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
3162 return status;
3163}
3164
3177static inline enum mmagic_status mmagic_controller_set_wlan_duty_cycle_mode(
3178 struct mmagic_controller *controller,
3179 enum mmagic_duty_cycle_mode var)
3180{
3181 enum mmagic_status status;
3182 status = mmagic_controller_tx(controller,
3183 CONTROL_STREAM,
3184 MMAGIC_WLAN,
3185 MMAGIC_WLAN_CMD_SET,
3186 MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE,
3187 (uint8_t *)&var,
3188 sizeof(var));
3189 if (status != MMAGIC_STATUS_OK)
3190 {
3191 return status;
3192 }
3193 status = mmagic_controller_rx(controller,
3194 CONTROL_STREAM,
3195 MMAGIC_WLAN,
3196 MMAGIC_WLAN_CMD_SET,
3197 MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE,
3198 NULL,
3199 0,
3200 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
3201 return status;
3202}
3203
3211static inline enum mmagic_status mmagic_controller_wlan_commit_all(
3212 struct mmagic_controller *controller)
3213{
3214 enum mmagic_status status;
3215 status = mmagic_controller_tx(controller,
3216 CONTROL_STREAM,
3217 MMAGIC_WLAN,
3218 MMAGIC_WLAN_CMD_COMMIT,
3219 0,
3220 NULL,
3221 0);
3222 if (status != MMAGIC_STATUS_OK)
3223 {
3224 return status;
3225 }
3226 status = mmagic_controller_rx(controller,
3227 CONTROL_STREAM,
3228 MMAGIC_WLAN,
3229 MMAGIC_WLAN_CMD_COMMIT,
3230 0,
3231 NULL,
3232 0,
3233 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
3234 return status;
3235}
3236
3240struct MM_PACKED mmagic_core_wlan_connect_cmd_args
3241{
3244 uint32_t timeout;
3245};
3246
3255static inline enum mmagic_status mmagic_controller_wlan_connect(
3256 struct mmagic_controller *controller,
3257 struct mmagic_core_wlan_connect_cmd_args *cmd_args)
3258{
3259 enum mmagic_status status;
3260 const uint8_t stream_id = CONTROL_STREAM;
3261 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3262
3263 /* Account for the timeout argument when waiting for the response and make sure no overflow. */
3264 if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
3265 {
3266 response_timeout_ms += cmd_args->timeout;
3267 }
3268 else
3269 {
3270 response_timeout_ms = UINT32_MAX;
3271 }
3272
3273 status = mmagic_controller_tx(controller,
3274 stream_id,
3275 MMAGIC_WLAN,
3276 MMAGIC_WLAN_CMD_CONNECT,
3277 0,
3278 (uint8_t *)cmd_args,
3279 sizeof(*cmd_args));
3280 if (status != MMAGIC_STATUS_OK)
3281 {
3282 return status;
3283 }
3284 status = mmagic_controller_rx(controller,
3285 stream_id,
3286 MMAGIC_WLAN,
3287 MMAGIC_WLAN_CMD_CONNECT,
3288 0,
3289 NULL,
3290 0,
3291 response_timeout_ms);
3292 return status;
3293}
3294
3302static inline enum mmagic_status mmagic_controller_wlan_disconnect(
3303 struct mmagic_controller *controller)
3304{
3305 enum mmagic_status status;
3306 const uint8_t stream_id = CONTROL_STREAM;
3307 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3308
3309 status = mmagic_controller_tx(controller,
3310 stream_id,
3311 MMAGIC_WLAN,
3312 MMAGIC_WLAN_CMD_DISCONNECT,
3313 0,
3314 NULL,
3315 0);
3316 if (status != MMAGIC_STATUS_OK)
3317 {
3318 return status;
3319 }
3320 return mmagic_controller_rx(controller,
3321 stream_id,
3322 MMAGIC_WLAN,
3323 MMAGIC_WLAN_CMD_DISCONNECT,
3324 0,
3325 NULL,
3326 0,
3327 response_timeout_ms);
3328 return status;
3329}
3330
3332struct MM_PACKED mmagic_core_wlan_scan_cmd_args
3333{
3335 struct string32 ssid;
3338 uint32_t timeout;
3339};
3340
3342struct MM_PACKED mmagic_core_wlan_scan_rsp_args
3343{
3345 struct struct_scan_status results;
3346};
3347
3359static inline enum mmagic_status mmagic_controller_wlan_scan(
3360 struct mmagic_controller *controller,
3361 struct mmagic_core_wlan_scan_cmd_args *cmd_args,
3362 struct mmagic_core_wlan_scan_rsp_args *rsp_args)
3363{
3364 enum mmagic_status status;
3365 const uint8_t stream_id = CONTROL_STREAM;
3366 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3367
3368 /* Account for the timeout argument when waiting for the response and make sure no overflow. */
3369 if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
3370 {
3371 response_timeout_ms += cmd_args->timeout;
3372 }
3373 else
3374 {
3375 response_timeout_ms = UINT32_MAX;
3376 }
3377
3378 status = mmagic_controller_tx(controller,
3379 stream_id,
3380 MMAGIC_WLAN,
3381 MMAGIC_WLAN_CMD_SCAN,
3382 0,
3383 (uint8_t *)cmd_args,
3384 sizeof(*cmd_args));
3385 if (status != MMAGIC_STATUS_OK)
3386 {
3387 return status;
3388 }
3389 status = mmagic_controller_rx(controller,
3390 stream_id,
3391 MMAGIC_WLAN,
3392 MMAGIC_WLAN_CMD_SCAN,
3393 0,
3394 (uint8_t *)rsp_args,
3395 sizeof(*rsp_args),
3396 response_timeout_ms);
3397 return status;
3398}
3399
3401struct MM_PACKED mmagic_core_wlan_get_rssi_rsp_args
3402{
3404 int32_t rssi;
3405};
3406
3417static inline enum mmagic_status mmagic_controller_wlan_get_rssi(
3418 struct mmagic_controller *controller,
3419 struct mmagic_core_wlan_get_rssi_rsp_args *rsp_args)
3420{
3421 enum mmagic_status status;
3422 const uint8_t stream_id = CONTROL_STREAM;
3423 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3424
3425 status = mmagic_controller_tx(controller,
3426 stream_id,
3427 MMAGIC_WLAN,
3428 MMAGIC_WLAN_CMD_GET_RSSI,
3429 0,
3430 NULL,
3431 0);
3432 if (status != MMAGIC_STATUS_OK)
3433 {
3434 return status;
3435 }
3436 status = mmagic_controller_rx(controller,
3437 stream_id,
3438 MMAGIC_WLAN,
3439 MMAGIC_WLAN_CMD_GET_RSSI,
3440 0,
3441 (uint8_t *)rsp_args,
3442 sizeof(*rsp_args),
3443 response_timeout_ms);
3444 return status;
3445}
3446
3448struct MM_PACKED mmagic_core_wlan_get_mac_addr_rsp_args
3449{
3451 struct struct_mac_addr mac_addr;
3452};
3453
3464static inline enum mmagic_status mmagic_controller_wlan_get_mac_addr(
3465 struct mmagic_controller *controller,
3466 struct mmagic_core_wlan_get_mac_addr_rsp_args *rsp_args)
3467{
3468 enum mmagic_status status;
3469 const uint8_t stream_id = CONTROL_STREAM;
3470 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3471
3472 status = mmagic_controller_tx(controller,
3473 stream_id,
3474 MMAGIC_WLAN,
3475 MMAGIC_WLAN_CMD_GET_MAC_ADDR,
3476 0,
3477 NULL,
3478 0);
3479 if (status != MMAGIC_STATUS_OK)
3480 {
3481 return status;
3482 }
3483 status = mmagic_controller_rx(controller,
3484 stream_id,
3485 MMAGIC_WLAN,
3486 MMAGIC_WLAN_CMD_GET_MAC_ADDR,
3487 0,
3488 (uint8_t *)rsp_args,
3489 sizeof(*rsp_args),
3490 response_timeout_ms);
3491 return status;
3492}
3493
3495struct MM_PACKED mmagic_core_wlan_wnm_sleep_cmd_args
3496{
3498 bool wnm_sleep_enabled;
3499};
3500
3509static inline enum mmagic_status mmagic_controller_wlan_wnm_sleep(
3510 struct mmagic_controller *controller,
3511 struct mmagic_core_wlan_wnm_sleep_cmd_args *cmd_args)
3512{
3513 enum mmagic_status status;
3514 const uint8_t stream_id = CONTROL_STREAM;
3515 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3516
3517 status = mmagic_controller_tx(controller,
3518 stream_id,
3519 MMAGIC_WLAN,
3520 MMAGIC_WLAN_CMD_WNM_SLEEP,
3521 0,
3522 (uint8_t *)cmd_args,
3523 sizeof(*cmd_args));
3524 if (status != MMAGIC_STATUS_OK)
3525 {
3526 return status;
3527 }
3528 status = mmagic_controller_rx(controller,
3529 stream_id,
3530 MMAGIC_WLAN,
3531 MMAGIC_WLAN_CMD_WNM_SLEEP,
3532 0,
3533 NULL,
3534 0,
3535 response_timeout_ms);
3536 return status;
3537}
3538
3540struct MM_PACKED mmagic_core_wlan_beacon_monitor_enable_cmd_args
3541{
3543 struct struct_oui_list oui_filter;
3544};
3545
3555static inline enum mmagic_status mmagic_controller_wlan_beacon_monitor_enable(
3556 struct mmagic_controller *controller,
3557 struct mmagic_core_wlan_beacon_monitor_enable_cmd_args *cmd_args)
3558{
3559 enum mmagic_status status;
3560 const uint8_t stream_id = CONTROL_STREAM;
3561 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3562
3563 status = mmagic_controller_tx(controller,
3564 stream_id,
3565 MMAGIC_WLAN,
3566 MMAGIC_WLAN_CMD_BEACON_MONITOR_ENABLE,
3567 0,
3568 (uint8_t *)cmd_args,
3569 sizeof(*cmd_args));
3570 if (status != MMAGIC_STATUS_OK)
3571 {
3572 return status;
3573 }
3574 status = mmagic_controller_rx(controller,
3575 stream_id,
3576 MMAGIC_WLAN,
3577 MMAGIC_WLAN_CMD_BEACON_MONITOR_ENABLE,
3578 0,
3579 NULL,
3580 0,
3581 response_timeout_ms);
3582 return status;
3583}
3584
3592static inline enum mmagic_status mmagic_controller_wlan_beacon_monitor_disable(
3593 struct mmagic_controller *controller)
3594{
3595 enum mmagic_status status;
3596 const uint8_t stream_id = CONTROL_STREAM;
3597 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3598
3599 status = mmagic_controller_tx(controller,
3600 stream_id,
3601 MMAGIC_WLAN,
3602 MMAGIC_WLAN_CMD_BEACON_MONITOR_DISABLE,
3603 0,
3604 NULL,
3605 0);
3606 if (status != MMAGIC_STATUS_OK)
3607 {
3608 return status;
3609 }
3610 return mmagic_controller_rx(controller,
3611 stream_id,
3612 MMAGIC_WLAN,
3613 MMAGIC_WLAN_CMD_BEACON_MONITOR_DISABLE,
3614 0,
3615 NULL,
3616 0,
3617 response_timeout_ms);
3618 return status;
3619}
3620
3630static inline enum mmagic_status mmagic_controller_wlan_standby_enter(
3631 struct mmagic_controller *controller)
3632{
3633 enum mmagic_status status;
3634 const uint8_t stream_id = CONTROL_STREAM;
3635 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3636
3637 status = mmagic_controller_tx(controller,
3638 stream_id,
3639 MMAGIC_WLAN,
3640 MMAGIC_WLAN_CMD_STANDBY_ENTER,
3641 0,
3642 NULL,
3643 0);
3644 if (status != MMAGIC_STATUS_OK)
3645 {
3646 return status;
3647 }
3648 return mmagic_controller_rx(controller,
3649 stream_id,
3650 MMAGIC_WLAN,
3651 MMAGIC_WLAN_CMD_STANDBY_ENTER,
3652 0,
3653 NULL,
3654 0,
3655 response_timeout_ms);
3656 return status;
3657}
3658
3669static inline enum mmagic_status mmagic_controller_wlan_standby_exit(
3670 struct mmagic_controller *controller)
3671{
3672 enum mmagic_status status;
3673 const uint8_t stream_id = CONTROL_STREAM;
3674 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3675
3676 status = mmagic_controller_tx(controller,
3677 stream_id,
3678 MMAGIC_WLAN,
3679 MMAGIC_WLAN_CMD_STANDBY_EXIT,
3680 0,
3681 NULL,
3682 0);
3683 if (status != MMAGIC_STATUS_OK)
3684 {
3685 return status;
3686 }
3687 return mmagic_controller_rx(controller,
3688 stream_id,
3689 MMAGIC_WLAN,
3690 MMAGIC_WLAN_CMD_STANDBY_EXIT,
3691 0,
3692 NULL,
3693 0,
3694 response_timeout_ms);
3695 return status;
3696}
3697
3699struct MM_PACKED mmagic_core_wlan_standby_set_status_payload_cmd_args
3700{
3702 struct struct_buffer64 payload;
3703};
3704
3716static inline enum mmagic_status mmagic_controller_wlan_standby_set_status_payload(
3717 struct mmagic_controller *controller,
3718 struct mmagic_core_wlan_standby_set_status_payload_cmd_args *cmd_args)
3719{
3720 enum mmagic_status status;
3721 const uint8_t stream_id = CONTROL_STREAM;
3722 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3723
3724 status = mmagic_controller_tx(controller,
3725 stream_id,
3726 MMAGIC_WLAN,
3727 MMAGIC_WLAN_CMD_STANDBY_SET_STATUS_PAYLOAD,
3728 0,
3729 (uint8_t *)cmd_args,
3730 sizeof(*cmd_args));
3731 if (status != MMAGIC_STATUS_OK)
3732 {
3733 return status;
3734 }
3735 status = mmagic_controller_rx(controller,
3736 stream_id,
3737 MMAGIC_WLAN,
3738 MMAGIC_WLAN_CMD_STANDBY_SET_STATUS_PAYLOAD,
3739 0,
3740 NULL,
3741 0,
3742 response_timeout_ms);
3743 return status;
3744}
3745
3747struct MM_PACKED mmagic_core_wlan_standby_set_wake_filter_cmd_args
3748{
3750 struct struct_buffer64 filter;
3752 uint32_t offset;
3753};
3754
3767static inline enum mmagic_status mmagic_controller_wlan_standby_set_wake_filter(
3768 struct mmagic_controller *controller,
3769 struct mmagic_core_wlan_standby_set_wake_filter_cmd_args *cmd_args)
3770{
3771 enum mmagic_status status;
3772 const uint8_t stream_id = CONTROL_STREAM;
3773 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3774
3775 status = mmagic_controller_tx(controller,
3776 stream_id,
3777 MMAGIC_WLAN,
3778 MMAGIC_WLAN_CMD_STANDBY_SET_WAKE_FILTER,
3779 0,
3780 (uint8_t *)cmd_args,
3781 sizeof(*cmd_args));
3782 if (status != MMAGIC_STATUS_OK)
3783 {
3784 return status;
3785 }
3786 status = mmagic_controller_rx(controller,
3787 stream_id,
3788 MMAGIC_WLAN,
3789 MMAGIC_WLAN_CMD_STANDBY_SET_WAKE_FILTER,
3790 0,
3791 NULL,
3792 0,
3793 response_timeout_ms);
3794 return status;
3795}
3796
3798struct MM_PACKED mmagic_core_wlan_standby_set_config_cmd_args
3799{
3801 uint32_t notify_period_s;
3803 struct struct_ip_addr src_ip;
3805 struct struct_ip_addr dst_ip;
3808 uint16_t dst_port;
3810 uint32_t bss_inactivity_s;
3814 uint32_t snooze_period_s;
3817 uint32_t snooze_increment_s;
3819 uint32_t snooze_max_s;
3820};
3821
3831static inline enum mmagic_status mmagic_controller_wlan_standby_set_config(
3832 struct mmagic_controller *controller,
3833 struct mmagic_core_wlan_standby_set_config_cmd_args *cmd_args)
3834{
3835 enum mmagic_status status;
3836 const uint8_t stream_id = CONTROL_STREAM;
3837 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3838
3839 status = mmagic_controller_tx(controller,
3840 stream_id,
3841 MMAGIC_WLAN,
3842 MMAGIC_WLAN_CMD_STANDBY_SET_CONFIG,
3843 0,
3844 (uint8_t *)cmd_args,
3845 sizeof(*cmd_args));
3846 if (status != MMAGIC_STATUS_OK)
3847 {
3848 return status;
3849 }
3850 status = mmagic_controller_rx(controller,
3851 stream_id,
3852 MMAGIC_WLAN,
3853 MMAGIC_WLAN_CMD_STANDBY_SET_CONFIG,
3854 0,
3855 NULL,
3856 0,
3857 response_timeout_ms);
3858 return status;
3859}
3860
3862struct MM_PACKED mmagic_core_wlan_get_sta_status_rsp_args
3863{
3865 enum mmagic_sta_state sta_status;
3866};
3867
3878static inline enum mmagic_status mmagic_controller_wlan_get_sta_status(
3879 struct mmagic_controller *controller,
3880 struct mmagic_core_wlan_get_sta_status_rsp_args *rsp_args)
3881{
3882 enum mmagic_status status;
3883 const uint8_t stream_id = CONTROL_STREAM;
3884 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
3885
3886 status = mmagic_controller_tx(controller,
3887 stream_id,
3888 MMAGIC_WLAN,
3889 MMAGIC_WLAN_CMD_GET_STA_STATUS,
3890 0,
3891 NULL,
3892 0);
3893 if (status != MMAGIC_STATUS_OK)
3894 {
3895 return status;
3896 }
3897 status = mmagic_controller_rx(controller,
3898 stream_id,
3899 MMAGIC_WLAN,
3900 MMAGIC_WLAN_CMD_GET_STA_STATUS,
3901 0,
3902 (uint8_t *)rsp_args,
3903 sizeof(*rsp_args),
3904 response_timeout_ms);
3905 return status;
3906}
3907
3909struct MM_PACKED mmagic_wlan_beacon_rx_event_args
3910{
3916 struct raw1536 vendor_ies;
3917};
3918
3932typedef void (*mmagic_wlan_beacon_rx_event_handler_t)(
3933 const struct mmagic_wlan_beacon_rx_event_args *event_args,
3934 void *arg);
3935
3950void mmagic_controller_register_wlan_beacon_rx_handler(
3951 struct mmagic_controller *controller,
3952 mmagic_wlan_beacon_rx_event_handler_t handler,
3953 void *arg);
3954
3956struct MM_PACKED mmagic_wlan_standby_exit_event_args
3957{
3960 enum mmagic_standby_mode_exit_reason reason;
3961};
3962
3976typedef void (*mmagic_wlan_standby_exit_event_handler_t)(
3977 const struct mmagic_wlan_standby_exit_event_args *event_args,
3978 void *arg);
3979
3994void mmagic_controller_register_wlan_standby_exit_handler(
3995 struct mmagic_controller *controller,
3996 mmagic_wlan_standby_exit_event_handler_t handler,
3997 void *arg);
3998
4000struct MM_PACKED mmagic_wlan_sta_event_event_args
4001{
4003 enum mmagic_sta_event event;
4004};
4005
4019typedef void (*mmagic_wlan_sta_event_event_handler_t)(
4020 const struct mmagic_wlan_sta_event_event_args *event_args,
4021 void *arg);
4022
4037void mmagic_controller_register_wlan_sta_event_handler(
4038 struct mmagic_controller *controller,
4039 mmagic_wlan_sta_event_event_handler_t handler,
4040 void *arg);
4041
4065static inline enum mmagic_status mmagic_controller_get_ip_ip_addr(
4066 struct mmagic_controller *controller,
4067 struct struct_ip_addr *var)
4068{
4069 enum mmagic_status status;
4070 status = mmagic_controller_tx(controller,
4071 CONTROL_STREAM,
4072 MMAGIC_IP,
4073 MMAGIC_IP_CMD_GET,
4074 MMAGIC_IP_VAR_IP_ADDR,
4075 NULL,
4076 0);
4077 if (status != MMAGIC_STATUS_OK)
4078 {
4079 return status;
4080 }
4081 status = mmagic_controller_rx(controller,
4082 CONTROL_STREAM,
4083 MMAGIC_IP,
4084 MMAGIC_IP_CMD_GET,
4085 MMAGIC_IP_VAR_IP_ADDR,
4086 (uint8_t *)var,
4087 sizeof(*var),
4088 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4089 return status;
4090}
4091
4103static inline enum mmagic_status mmagic_controller_set_ip_ip_addr(
4104 struct mmagic_controller *controller,
4105 struct struct_ip_addr *var)
4106{
4107 enum mmagic_status status;
4108 status = mmagic_controller_tx(controller,
4109 CONTROL_STREAM,
4110 MMAGIC_IP,
4111 MMAGIC_IP_CMD_SET,
4112 MMAGIC_IP_VAR_IP_ADDR,
4113 (uint8_t *)var,
4114 sizeof(*var));
4115 if (status != MMAGIC_STATUS_OK)
4116 {
4117 return status;
4118 }
4119 status = mmagic_controller_rx(controller,
4120 CONTROL_STREAM,
4121 MMAGIC_IP,
4122 MMAGIC_IP_CMD_SET,
4123 MMAGIC_IP_VAR_IP_ADDR,
4124 NULL,
4125 0,
4126 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4127 return status;
4128}
4129
4141static inline enum mmagic_status mmagic_controller_get_ip_netmask(
4142 struct mmagic_controller *controller,
4143 struct struct_ip_addr *var)
4144{
4145 enum mmagic_status status;
4146 status = mmagic_controller_tx(controller,
4147 CONTROL_STREAM,
4148 MMAGIC_IP,
4149 MMAGIC_IP_CMD_GET,
4150 MMAGIC_IP_VAR_NETMASK,
4151 NULL,
4152 0);
4153 if (status != MMAGIC_STATUS_OK)
4154 {
4155 return status;
4156 }
4157 status = mmagic_controller_rx(controller,
4158 CONTROL_STREAM,
4159 MMAGIC_IP,
4160 MMAGIC_IP_CMD_GET,
4161 MMAGIC_IP_VAR_NETMASK,
4162 (uint8_t *)var,
4163 sizeof(*var),
4164 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4165 return status;
4166}
4167
4179static inline enum mmagic_status mmagic_controller_set_ip_netmask(
4180 struct mmagic_controller *controller,
4181 struct struct_ip_addr *var)
4182{
4183 enum mmagic_status status;
4184 status = mmagic_controller_tx(controller,
4185 CONTROL_STREAM,
4186 MMAGIC_IP,
4187 MMAGIC_IP_CMD_SET,
4188 MMAGIC_IP_VAR_NETMASK,
4189 (uint8_t *)var,
4190 sizeof(*var));
4191 if (status != MMAGIC_STATUS_OK)
4192 {
4193 return status;
4194 }
4195 status = mmagic_controller_rx(controller,
4196 CONTROL_STREAM,
4197 MMAGIC_IP,
4198 MMAGIC_IP_CMD_SET,
4199 MMAGIC_IP_VAR_NETMASK,
4200 NULL,
4201 0,
4202 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4203 return status;
4204}
4205
4217static inline enum mmagic_status mmagic_controller_get_ip_gateway(
4218 struct mmagic_controller *controller,
4219 struct struct_ip_addr *var)
4220{
4221 enum mmagic_status status;
4222 status = mmagic_controller_tx(controller,
4223 CONTROL_STREAM,
4224 MMAGIC_IP,
4225 MMAGIC_IP_CMD_GET,
4226 MMAGIC_IP_VAR_GATEWAY,
4227 NULL,
4228 0);
4229 if (status != MMAGIC_STATUS_OK)
4230 {
4231 return status;
4232 }
4233 status = mmagic_controller_rx(controller,
4234 CONTROL_STREAM,
4235 MMAGIC_IP,
4236 MMAGIC_IP_CMD_GET,
4237 MMAGIC_IP_VAR_GATEWAY,
4238 (uint8_t *)var,
4239 sizeof(*var),
4240 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4241 return status;
4242}
4243
4255static inline enum mmagic_status mmagic_controller_set_ip_gateway(
4256 struct mmagic_controller *controller,
4257 struct struct_ip_addr *var)
4258{
4259 enum mmagic_status status;
4260 status = mmagic_controller_tx(controller,
4261 CONTROL_STREAM,
4262 MMAGIC_IP,
4263 MMAGIC_IP_CMD_SET,
4264 MMAGIC_IP_VAR_GATEWAY,
4265 (uint8_t *)var,
4266 sizeof(*var));
4267 if (status != MMAGIC_STATUS_OK)
4268 {
4269 return status;
4270 }
4271 status = mmagic_controller_rx(controller,
4272 CONTROL_STREAM,
4273 MMAGIC_IP,
4274 MMAGIC_IP_CMD_SET,
4275 MMAGIC_IP_VAR_GATEWAY,
4276 NULL,
4277 0,
4278 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4279 return status;
4280}
4281
4294static inline enum mmagic_status mmagic_controller_get_ip_dns_server0(
4295 struct mmagic_controller *controller,
4296 struct struct_ip_addr *var)
4297{
4298 enum mmagic_status status;
4299 status = mmagic_controller_tx(controller,
4300 CONTROL_STREAM,
4301 MMAGIC_IP,
4302 MMAGIC_IP_CMD_GET,
4303 MMAGIC_IP_VAR_DNS_SERVER0,
4304 NULL,
4305 0);
4306 if (status != MMAGIC_STATUS_OK)
4307 {
4308 return status;
4309 }
4310 status = mmagic_controller_rx(controller,
4311 CONTROL_STREAM,
4312 MMAGIC_IP,
4313 MMAGIC_IP_CMD_GET,
4314 MMAGIC_IP_VAR_DNS_SERVER0,
4315 (uint8_t *)var,
4316 sizeof(*var),
4317 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4318 return status;
4319}
4320
4333static inline enum mmagic_status mmagic_controller_set_ip_dns_server0(
4334 struct mmagic_controller *controller,
4335 struct struct_ip_addr *var)
4336{
4337 enum mmagic_status status;
4338 status = mmagic_controller_tx(controller,
4339 CONTROL_STREAM,
4340 MMAGIC_IP,
4341 MMAGIC_IP_CMD_SET,
4342 MMAGIC_IP_VAR_DNS_SERVER0,
4343 (uint8_t *)var,
4344 sizeof(*var));
4345 if (status != MMAGIC_STATUS_OK)
4346 {
4347 return status;
4348 }
4349 status = mmagic_controller_rx(controller,
4350 CONTROL_STREAM,
4351 MMAGIC_IP,
4352 MMAGIC_IP_CMD_SET,
4353 MMAGIC_IP_VAR_DNS_SERVER0,
4354 NULL,
4355 0,
4356 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4357 return status;
4358}
4359
4372static inline enum mmagic_status mmagic_controller_get_ip_dns_server1(
4373 struct mmagic_controller *controller,
4374 struct struct_ip_addr *var)
4375{
4376 enum mmagic_status status;
4377 status = mmagic_controller_tx(controller,
4378 CONTROL_STREAM,
4379 MMAGIC_IP,
4380 MMAGIC_IP_CMD_GET,
4381 MMAGIC_IP_VAR_DNS_SERVER1,
4382 NULL,
4383 0);
4384 if (status != MMAGIC_STATUS_OK)
4385 {
4386 return status;
4387 }
4388 status = mmagic_controller_rx(controller,
4389 CONTROL_STREAM,
4390 MMAGIC_IP,
4391 MMAGIC_IP_CMD_GET,
4392 MMAGIC_IP_VAR_DNS_SERVER1,
4393 (uint8_t *)var,
4394 sizeof(*var),
4395 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4396 return status;
4397}
4398
4411static inline enum mmagic_status mmagic_controller_set_ip_dns_server1(
4412 struct mmagic_controller *controller,
4413 struct struct_ip_addr *var)
4414{
4415 enum mmagic_status status;
4416 status = mmagic_controller_tx(controller,
4417 CONTROL_STREAM,
4418 MMAGIC_IP,
4419 MMAGIC_IP_CMD_SET,
4420 MMAGIC_IP_VAR_DNS_SERVER1,
4421 (uint8_t *)var,
4422 sizeof(*var));
4423 if (status != MMAGIC_STATUS_OK)
4424 {
4425 return status;
4426 }
4427 status = mmagic_controller_rx(controller,
4428 CONTROL_STREAM,
4429 MMAGIC_IP,
4430 MMAGIC_IP_CMD_SET,
4431 MMAGIC_IP_VAR_DNS_SERVER1,
4432 NULL,
4433 0,
4434 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4435 return status;
4436}
4437
4450static inline enum mmagic_status mmagic_controller_get_ip_dhcp_enabled(
4451 struct mmagic_controller *controller,
4452 bool *var)
4453{
4454 enum mmagic_status status;
4455 status = mmagic_controller_tx(controller,
4456 CONTROL_STREAM,
4457 MMAGIC_IP,
4458 MMAGIC_IP_CMD_GET,
4459 MMAGIC_IP_VAR_DHCP_ENABLED,
4460 NULL,
4461 0);
4462 if (status != MMAGIC_STATUS_OK)
4463 {
4464 return status;
4465 }
4466 status = mmagic_controller_rx(controller,
4467 CONTROL_STREAM,
4468 MMAGIC_IP,
4469 MMAGIC_IP_CMD_GET,
4470 MMAGIC_IP_VAR_DHCP_ENABLED,
4471 (uint8_t *)var,
4472 sizeof(*var),
4473 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4474 return status;
4475}
4476
4489static inline enum mmagic_status mmagic_controller_set_ip_dhcp_enabled(
4490 struct mmagic_controller *controller,
4491 bool var)
4492{
4493 enum mmagic_status status;
4494 status = mmagic_controller_tx(controller,
4495 CONTROL_STREAM,
4496 MMAGIC_IP,
4497 MMAGIC_IP_CMD_SET,
4498 MMAGIC_IP_VAR_DHCP_ENABLED,
4499 (uint8_t *)&var,
4500 sizeof(var));
4501 if (status != MMAGIC_STATUS_OK)
4502 {
4503 return status;
4504 }
4505 status = mmagic_controller_rx(controller,
4506 CONTROL_STREAM,
4507 MMAGIC_IP,
4508 MMAGIC_IP_CMD_SET,
4509 MMAGIC_IP_VAR_DHCP_ENABLED,
4510 NULL,
4511 0,
4512 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4513 return status;
4514}
4515
4528static inline enum mmagic_status mmagic_controller_get_ip_dhcp_offload(
4529 struct mmagic_controller *controller,
4530 bool *var)
4531{
4532 enum mmagic_status status;
4533 status = mmagic_controller_tx(controller,
4534 CONTROL_STREAM,
4535 MMAGIC_IP,
4536 MMAGIC_IP_CMD_GET,
4537 MMAGIC_IP_VAR_DHCP_OFFLOAD,
4538 NULL,
4539 0);
4540 if (status != MMAGIC_STATUS_OK)
4541 {
4542 return status;
4543 }
4544 status = mmagic_controller_rx(controller,
4545 CONTROL_STREAM,
4546 MMAGIC_IP,
4547 MMAGIC_IP_CMD_GET,
4548 MMAGIC_IP_VAR_DHCP_OFFLOAD,
4549 (uint8_t *)var,
4550 sizeof(*var),
4551 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4552 return status;
4553}
4554
4567static inline enum mmagic_status mmagic_controller_set_ip_dhcp_offload(
4568 struct mmagic_controller *controller,
4569 bool var)
4570{
4571 enum mmagic_status status;
4572 status = mmagic_controller_tx(controller,
4573 CONTROL_STREAM,
4574 MMAGIC_IP,
4575 MMAGIC_IP_CMD_SET,
4576 MMAGIC_IP_VAR_DHCP_OFFLOAD,
4577 (uint8_t *)&var,
4578 sizeof(var));
4579 if (status != MMAGIC_STATUS_OK)
4580 {
4581 return status;
4582 }
4583 status = mmagic_controller_rx(controller,
4584 CONTROL_STREAM,
4585 MMAGIC_IP,
4586 MMAGIC_IP_CMD_SET,
4587 MMAGIC_IP_VAR_DHCP_OFFLOAD,
4588 NULL,
4589 0,
4590 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4591 return status;
4592}
4593
4605static inline enum mmagic_status mmagic_controller_get_ip_link_status_evt_en(
4606 struct mmagic_controller *controller,
4607 bool *var)
4608{
4609 enum mmagic_status status;
4610 status = mmagic_controller_tx(controller,
4611 CONTROL_STREAM,
4612 MMAGIC_IP,
4613 MMAGIC_IP_CMD_GET,
4614 MMAGIC_IP_VAR_LINK_STATUS_EVT_EN,
4615 NULL,
4616 0);
4617 if (status != MMAGIC_STATUS_OK)
4618 {
4619 return status;
4620 }
4621 status = mmagic_controller_rx(controller,
4622 CONTROL_STREAM,
4623 MMAGIC_IP,
4624 MMAGIC_IP_CMD_GET,
4625 MMAGIC_IP_VAR_LINK_STATUS_EVT_EN,
4626 (uint8_t *)var,
4627 sizeof(*var),
4628 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4629 return status;
4630}
4631
4643static inline enum mmagic_status mmagic_controller_set_ip_link_status_evt_en(
4644 struct mmagic_controller *controller,
4645 bool var)
4646{
4647 enum mmagic_status status;
4648 status = mmagic_controller_tx(controller,
4649 CONTROL_STREAM,
4650 MMAGIC_IP,
4651 MMAGIC_IP_CMD_SET,
4652 MMAGIC_IP_VAR_LINK_STATUS_EVT_EN,
4653 (uint8_t *)&var,
4654 sizeof(var));
4655 if (status != MMAGIC_STATUS_OK)
4656 {
4657 return status;
4658 }
4659 status = mmagic_controller_rx(controller,
4660 CONTROL_STREAM,
4661 MMAGIC_IP,
4662 MMAGIC_IP_CMD_SET,
4663 MMAGIC_IP_VAR_LINK_STATUS_EVT_EN,
4664 NULL,
4665 0,
4666 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4667 return status;
4668}
4669
4681static inline enum mmagic_status mmagic_controller_get_ip_offload_arp_response(
4682 struct mmagic_controller *controller,
4683 bool *var)
4684{
4685 enum mmagic_status status;
4686 status = mmagic_controller_tx(controller,
4687 CONTROL_STREAM,
4688 MMAGIC_IP,
4689 MMAGIC_IP_CMD_GET,
4690 MMAGIC_IP_VAR_OFFLOAD_ARP_RESPONSE,
4691 NULL,
4692 0);
4693 if (status != MMAGIC_STATUS_OK)
4694 {
4695 return status;
4696 }
4697 status = mmagic_controller_rx(controller,
4698 CONTROL_STREAM,
4699 MMAGIC_IP,
4700 MMAGIC_IP_CMD_GET,
4701 MMAGIC_IP_VAR_OFFLOAD_ARP_RESPONSE,
4702 (uint8_t *)var,
4703 sizeof(*var),
4704 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4705 return status;
4706}
4707
4719static inline enum mmagic_status mmagic_controller_set_ip_offload_arp_response(
4720 struct mmagic_controller *controller,
4721 bool var)
4722{
4723 enum mmagic_status status;
4724 status = mmagic_controller_tx(controller,
4725 CONTROL_STREAM,
4726 MMAGIC_IP,
4727 MMAGIC_IP_CMD_SET,
4728 MMAGIC_IP_VAR_OFFLOAD_ARP_RESPONSE,
4729 (uint8_t *)&var,
4730 sizeof(var));
4731 if (status != MMAGIC_STATUS_OK)
4732 {
4733 return status;
4734 }
4735 status = mmagic_controller_rx(controller,
4736 CONTROL_STREAM,
4737 MMAGIC_IP,
4738 MMAGIC_IP_CMD_SET,
4739 MMAGIC_IP_VAR_OFFLOAD_ARP_RESPONSE,
4740 NULL,
4741 0,
4742 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4743 return status;
4744}
4745
4757static inline enum mmagic_status mmagic_controller_get_ip_offload_arp_refresh_s(
4758 struct mmagic_controller *controller,
4759 uint32_t *var)
4760{
4761 enum mmagic_status status;
4762 status = mmagic_controller_tx(controller,
4763 CONTROL_STREAM,
4764 MMAGIC_IP,
4765 MMAGIC_IP_CMD_GET,
4766 MMAGIC_IP_VAR_OFFLOAD_ARP_REFRESH_S,
4767 NULL,
4768 0);
4769 if (status != MMAGIC_STATUS_OK)
4770 {
4771 return status;
4772 }
4773 status = mmagic_controller_rx(controller,
4774 CONTROL_STREAM,
4775 MMAGIC_IP,
4776 MMAGIC_IP_CMD_GET,
4777 MMAGIC_IP_VAR_OFFLOAD_ARP_REFRESH_S,
4778 (uint8_t *)var,
4779 sizeof(*var),
4780 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4781 return status;
4782}
4783
4795static inline enum mmagic_status mmagic_controller_set_ip_offload_arp_refresh_s(
4796 struct mmagic_controller *controller,
4797 uint32_t var)
4798{
4799 enum mmagic_status status;
4800 status = mmagic_controller_tx(controller,
4801 CONTROL_STREAM,
4802 MMAGIC_IP,
4803 MMAGIC_IP_CMD_SET,
4804 MMAGIC_IP_VAR_OFFLOAD_ARP_REFRESH_S,
4805 (uint8_t *)&var,
4806 sizeof(var));
4807 if (status != MMAGIC_STATUS_OK)
4808 {
4809 return status;
4810 }
4811 status = mmagic_controller_rx(controller,
4812 CONTROL_STREAM,
4813 MMAGIC_IP,
4814 MMAGIC_IP_CMD_SET,
4815 MMAGIC_IP_VAR_OFFLOAD_ARP_REFRESH_S,
4816 NULL,
4817 0,
4818 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4819 return status;
4820}
4821
4829static inline enum mmagic_status mmagic_controller_ip_commit_all(
4830 struct mmagic_controller *controller)
4831{
4832 enum mmagic_status status;
4833 status = mmagic_controller_tx(controller,
4834 CONTROL_STREAM,
4835 MMAGIC_IP,
4836 MMAGIC_IP_CMD_COMMIT,
4837 0,
4838 NULL,
4839 0);
4840 if (status != MMAGIC_STATUS_OK)
4841 {
4842 return status;
4843 }
4844 status = mmagic_controller_rx(controller,
4845 CONTROL_STREAM,
4846 MMAGIC_IP,
4847 MMAGIC_IP_CMD_COMMIT,
4848 0,
4849 NULL,
4850 0,
4851 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
4852 return status;
4853}
4854
4858struct MM_PACKED mmagic_core_ip_status_rsp_args
4859{
4861 struct struct_ip_status status;
4862};
4863
4874static inline enum mmagic_status mmagic_controller_ip_status(
4875 struct mmagic_controller *controller,
4876 struct mmagic_core_ip_status_rsp_args *rsp_args)
4877{
4878 enum mmagic_status status;
4879 const uint8_t stream_id = CONTROL_STREAM;
4880 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
4881
4882 status =
4883 mmagic_controller_tx(controller, stream_id, MMAGIC_IP, MMAGIC_IP_CMD_STATUS, 0, NULL, 0);
4884 if (status != MMAGIC_STATUS_OK)
4885 {
4886 return status;
4887 }
4888 status = mmagic_controller_rx(controller,
4889 stream_id,
4890 MMAGIC_IP,
4891 MMAGIC_IP_CMD_STATUS,
4892 0,
4893 (uint8_t *)rsp_args,
4894 sizeof(*rsp_args),
4895 response_timeout_ms);
4896 return status;
4897}
4898
4906static inline enum mmagic_status mmagic_controller_ip_reload(struct mmagic_controller *controller)
4907{
4908 enum mmagic_status status;
4909 const uint8_t stream_id = CONTROL_STREAM;
4910 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
4911
4912 status =
4913 mmagic_controller_tx(controller, stream_id, MMAGIC_IP, MMAGIC_IP_CMD_RELOAD, 0, NULL, 0);
4914 if (status != MMAGIC_STATUS_OK)
4915 {
4916 return status;
4917 }
4918 return mmagic_controller_rx(controller,
4919 stream_id,
4920 MMAGIC_IP,
4921 MMAGIC_IP_CMD_RELOAD,
4922 0,
4923 NULL,
4924 0,
4925 response_timeout_ms);
4926 return status;
4927}
4928
4930struct MM_PACKED mmagic_core_ip_enable_tcp_keepalive_offload_cmd_args
4931{
4933 uint16_t period_s;
4935 uint8_t retry_count;
4937 uint8_t retry_interval_s;
4938};
4939
4951static inline enum mmagic_status mmagic_controller_ip_enable_tcp_keepalive_offload(
4952 struct mmagic_controller *controller,
4953 struct mmagic_core_ip_enable_tcp_keepalive_offload_cmd_args *cmd_args)
4954{
4955 enum mmagic_status status;
4956 const uint8_t stream_id = CONTROL_STREAM;
4957 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
4958
4959 status = mmagic_controller_tx(controller,
4960 stream_id,
4961 MMAGIC_IP,
4962 MMAGIC_IP_CMD_ENABLE_TCP_KEEPALIVE_OFFLOAD,
4963 0,
4964 (uint8_t *)cmd_args,
4965 sizeof(*cmd_args));
4966 if (status != MMAGIC_STATUS_OK)
4967 {
4968 return status;
4969 }
4970 status = mmagic_controller_rx(controller,
4971 stream_id,
4972 MMAGIC_IP,
4973 MMAGIC_IP_CMD_ENABLE_TCP_KEEPALIVE_OFFLOAD,
4974 0,
4975 NULL,
4976 0,
4977 response_timeout_ms);
4978 return status;
4979}
4980
4988static inline enum mmagic_status mmagic_controller_ip_disable_tcp_keepalive_offload(
4989 struct mmagic_controller *controller)
4990{
4991 enum mmagic_status status;
4992 const uint8_t stream_id = CONTROL_STREAM;
4993 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
4994
4995 status = mmagic_controller_tx(controller,
4996 stream_id,
4997 MMAGIC_IP,
4998 MMAGIC_IP_CMD_DISABLE_TCP_KEEPALIVE_OFFLOAD,
4999 0,
5000 NULL,
5001 0);
5002 if (status != MMAGIC_STATUS_OK)
5003 {
5004 return status;
5005 }
5006 return mmagic_controller_rx(controller,
5007 stream_id,
5008 MMAGIC_IP,
5009 MMAGIC_IP_CMD_DISABLE_TCP_KEEPALIVE_OFFLOAD,
5010 0,
5011 NULL,
5012 0,
5013 response_timeout_ms);
5014 return status;
5015}
5016
5018struct MM_PACKED mmagic_core_ip_set_whitelist_filter_cmd_args
5019{
5021 struct struct_ip_addr src_ip;
5023 struct struct_ip_addr dest_ip;
5025 struct struct_ip_addr netmask;
5027 uint16_t src_port;
5029 uint16_t dest_port;
5031 uint8_t ip_protocol;
5034 uint16_t llc_protocol;
5035};
5036
5045static inline enum mmagic_status mmagic_controller_ip_set_whitelist_filter(
5046 struct mmagic_controller *controller,
5047 struct mmagic_core_ip_set_whitelist_filter_cmd_args *cmd_args)
5048{
5049 enum mmagic_status status;
5050 const uint8_t stream_id = CONTROL_STREAM;
5051 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
5052
5053 status = mmagic_controller_tx(controller,
5054 stream_id,
5055 MMAGIC_IP,
5056 MMAGIC_IP_CMD_SET_WHITELIST_FILTER,
5057 0,
5058 (uint8_t *)cmd_args,
5059 sizeof(*cmd_args));
5060 if (status != MMAGIC_STATUS_OK)
5061 {
5062 return status;
5063 }
5064 status = mmagic_controller_rx(controller,
5065 stream_id,
5066 MMAGIC_IP,
5067 MMAGIC_IP_CMD_SET_WHITELIST_FILTER,
5068 0,
5069 NULL,
5070 0,
5071 response_timeout_ms);
5072 return status;
5073}
5074
5082static inline enum mmagic_status mmagic_controller_ip_clear_whitelist_filter(
5083 struct mmagic_controller *controller)
5084{
5085 enum mmagic_status status;
5086 const uint8_t stream_id = CONTROL_STREAM;
5087 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
5088
5089 status = mmagic_controller_tx(controller,
5090 stream_id,
5091 MMAGIC_IP,
5092 MMAGIC_IP_CMD_CLEAR_WHITELIST_FILTER,
5093 0,
5094 NULL,
5095 0);
5096 if (status != MMAGIC_STATUS_OK)
5097 {
5098 return status;
5099 }
5100 return mmagic_controller_rx(controller,
5101 stream_id,
5102 MMAGIC_IP,
5103 MMAGIC_IP_CMD_CLEAR_WHITELIST_FILTER,
5104 0,
5105 NULL,
5106 0,
5107 response_timeout_ms);
5108 return status;
5109}
5110
5112struct MM_PACKED mmagic_ip_link_status_event_args
5113{
5116 struct struct_ip_status ip_link_status;
5117};
5118
5132typedef void (*mmagic_ip_link_status_event_handler_t)(
5133 const struct mmagic_ip_link_status_event_args *event_args,
5134 void *arg);
5135
5150void mmagic_controller_register_ip_link_status_handler(
5151 struct mmagic_controller *controller,
5152 mmagic_ip_link_status_event_handler_t handler,
5153 void *arg);
5154
5177static inline enum mmagic_status mmagic_controller_get_ping_target(
5178 struct mmagic_controller *controller,
5179 struct struct_ip_addr *var)
5180{
5181 enum mmagic_status status;
5182 status = mmagic_controller_tx(controller,
5183 CONTROL_STREAM,
5184 MMAGIC_PING,
5185 MMAGIC_PING_CMD_GET,
5186 MMAGIC_PING_VAR_TARGET,
5187 NULL,
5188 0);
5189 if (status != MMAGIC_STATUS_OK)
5190 {
5191 return status;
5192 }
5193 status = mmagic_controller_rx(controller,
5194 CONTROL_STREAM,
5195 MMAGIC_PING,
5196 MMAGIC_PING_CMD_GET,
5197 MMAGIC_PING_VAR_TARGET,
5198 (uint8_t *)var,
5199 sizeof(*var),
5200 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5201 return status;
5202}
5203
5214static inline enum mmagic_status mmagic_controller_set_ping_target(
5215 struct mmagic_controller *controller,
5216 struct struct_ip_addr *var)
5217{
5218 enum mmagic_status status;
5219 status = mmagic_controller_tx(controller,
5220 CONTROL_STREAM,
5221 MMAGIC_PING,
5222 MMAGIC_PING_CMD_SET,
5223 MMAGIC_PING_VAR_TARGET,
5224 (uint8_t *)var,
5225 sizeof(*var));
5226 if (status != MMAGIC_STATUS_OK)
5227 {
5228 return status;
5229 }
5230 status = mmagic_controller_rx(controller,
5231 CONTROL_STREAM,
5232 MMAGIC_PING,
5233 MMAGIC_PING_CMD_SET,
5234 MMAGIC_PING_VAR_TARGET,
5235 NULL,
5236 0,
5237 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5238 return status;
5239}
5240
5251static inline enum mmagic_status mmagic_controller_get_ping_interval(
5252 struct mmagic_controller *controller,
5253 uint32_t *var)
5254{
5255 enum mmagic_status status;
5256 status = mmagic_controller_tx(controller,
5257 CONTROL_STREAM,
5258 MMAGIC_PING,
5259 MMAGIC_PING_CMD_GET,
5260 MMAGIC_PING_VAR_INTERVAL,
5261 NULL,
5262 0);
5263 if (status != MMAGIC_STATUS_OK)
5264 {
5265 return status;
5266 }
5267 status = mmagic_controller_rx(controller,
5268 CONTROL_STREAM,
5269 MMAGIC_PING,
5270 MMAGIC_PING_CMD_GET,
5271 MMAGIC_PING_VAR_INTERVAL,
5272 (uint8_t *)var,
5273 sizeof(*var),
5274 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5275 return status;
5276}
5277
5288static inline enum mmagic_status mmagic_controller_set_ping_interval(
5289 struct mmagic_controller *controller,
5290 uint32_t var)
5291{
5292 enum mmagic_status status;
5293 status = mmagic_controller_tx(controller,
5294 CONTROL_STREAM,
5295 MMAGIC_PING,
5296 MMAGIC_PING_CMD_SET,
5297 MMAGIC_PING_VAR_INTERVAL,
5298 (uint8_t *)&var,
5299 sizeof(var));
5300 if (status != MMAGIC_STATUS_OK)
5301 {
5302 return status;
5303 }
5304 status = mmagic_controller_rx(controller,
5305 CONTROL_STREAM,
5306 MMAGIC_PING,
5307 MMAGIC_PING_CMD_SET,
5308 MMAGIC_PING_VAR_INTERVAL,
5309 NULL,
5310 0,
5311 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5312 return status;
5313}
5314
5326static inline enum mmagic_status mmagic_controller_get_ping_count(
5327 struct mmagic_controller *controller,
5328 uint32_t *var)
5329{
5330 enum mmagic_status status;
5331 status = mmagic_controller_tx(controller,
5332 CONTROL_STREAM,
5333 MMAGIC_PING,
5334 MMAGIC_PING_CMD_GET,
5335 MMAGIC_PING_VAR_COUNT,
5336 NULL,
5337 0);
5338 if (status != MMAGIC_STATUS_OK)
5339 {
5340 return status;
5341 }
5342 status = mmagic_controller_rx(controller,
5343 CONTROL_STREAM,
5344 MMAGIC_PING,
5345 MMAGIC_PING_CMD_GET,
5346 MMAGIC_PING_VAR_COUNT,
5347 (uint8_t *)var,
5348 sizeof(*var),
5349 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5350 return status;
5351}
5352
5364static inline enum mmagic_status mmagic_controller_set_ping_count(
5365 struct mmagic_controller *controller,
5366 uint32_t var)
5367{
5368 enum mmagic_status status;
5369 status = mmagic_controller_tx(controller,
5370 CONTROL_STREAM,
5371 MMAGIC_PING,
5372 MMAGIC_PING_CMD_SET,
5373 MMAGIC_PING_VAR_COUNT,
5374 (uint8_t *)&var,
5375 sizeof(var));
5376 if (status != MMAGIC_STATUS_OK)
5377 {
5378 return status;
5379 }
5380 status = mmagic_controller_rx(controller,
5381 CONTROL_STREAM,
5382 MMAGIC_PING,
5383 MMAGIC_PING_CMD_SET,
5384 MMAGIC_PING_VAR_COUNT,
5385 NULL,
5386 0,
5387 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5388 return status;
5389}
5390
5398static inline enum mmagic_status mmagic_controller_ping_commit_all(
5399 struct mmagic_controller *controller)
5400{
5401 enum mmagic_status status;
5402 status = mmagic_controller_tx(controller,
5403 CONTROL_STREAM,
5404 MMAGIC_PING,
5405 MMAGIC_PING_CMD_COMMIT,
5406 0,
5407 NULL,
5408 0);
5409 if (status != MMAGIC_STATUS_OK)
5410 {
5411 return status;
5412 }
5413 status = mmagic_controller_rx(controller,
5414 CONTROL_STREAM,
5415 MMAGIC_PING,
5416 MMAGIC_PING_CMD_COMMIT,
5417 0,
5418 NULL,
5419 0,
5420 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5421 return status;
5422}
5423
5427struct MM_PACKED mmagic_core_ping_run_rsp_args
5428{
5430 struct struct_ping_status status;
5431};
5432
5443static inline enum mmagic_status mmagic_controller_ping_run(
5444 struct mmagic_controller *controller,
5445 struct mmagic_core_ping_run_rsp_args *rsp_args)
5446{
5447 enum mmagic_status status;
5448 const uint8_t stream_id = CONTROL_STREAM;
5449 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
5450
5451 status =
5452 mmagic_controller_tx(controller, stream_id, MMAGIC_PING, MMAGIC_PING_CMD_RUN, 0, NULL, 0);
5453 if (status != MMAGIC_STATUS_OK)
5454 {
5455 return status;
5456 }
5457 status = mmagic_controller_rx(controller,
5458 stream_id,
5459 MMAGIC_PING,
5460 MMAGIC_PING_CMD_RUN,
5461 0,
5462 (uint8_t *)rsp_args,
5463 sizeof(*rsp_args),
5464 response_timeout_ms);
5465 return status;
5466}
5467
5491static inline enum mmagic_status mmagic_controller_get_iperf_mode(
5492 struct mmagic_controller *controller,
5493 enum mmagic_iperf_mode *var)
5494{
5495 enum mmagic_status status;
5496 status = mmagic_controller_tx(controller,
5497 CONTROL_STREAM,
5498 MMAGIC_IPERF,
5499 MMAGIC_IPERF_CMD_GET,
5500 MMAGIC_IPERF_VAR_MODE,
5501 NULL,
5502 0);
5503 if (status != MMAGIC_STATUS_OK)
5504 {
5505 return status;
5506 }
5507 status = mmagic_controller_rx(controller,
5508 CONTROL_STREAM,
5509 MMAGIC_IPERF,
5510 MMAGIC_IPERF_CMD_GET,
5511 MMAGIC_IPERF_VAR_MODE,
5512 (uint8_t *)var,
5513 sizeof(*var),
5514 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5515 return status;
5516}
5517
5529static inline enum mmagic_status mmagic_controller_set_iperf_mode(
5530 struct mmagic_controller *controller,
5531 enum mmagic_iperf_mode var)
5532{
5533 enum mmagic_status status;
5534 status = mmagic_controller_tx(controller,
5535 CONTROL_STREAM,
5536 MMAGIC_IPERF,
5537 MMAGIC_IPERF_CMD_SET,
5538 MMAGIC_IPERF_VAR_MODE,
5539 (uint8_t *)&var,
5540 sizeof(var));
5541 if (status != MMAGIC_STATUS_OK)
5542 {
5543 return status;
5544 }
5545 status = mmagic_controller_rx(controller,
5546 CONTROL_STREAM,
5547 MMAGIC_IPERF,
5548 MMAGIC_IPERF_CMD_SET,
5549 MMAGIC_IPERF_VAR_MODE,
5550 NULL,
5551 0,
5552 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5553 return status;
5554}
5555
5566static inline enum mmagic_status mmagic_controller_get_iperf_server(
5567 struct mmagic_controller *controller,
5568 struct struct_ip_addr *var)
5569{
5570 enum mmagic_status status;
5571 status = mmagic_controller_tx(controller,
5572 CONTROL_STREAM,
5573 MMAGIC_IPERF,
5574 MMAGIC_IPERF_CMD_GET,
5575 MMAGIC_IPERF_VAR_SERVER,
5576 NULL,
5577 0);
5578 if (status != MMAGIC_STATUS_OK)
5579 {
5580 return status;
5581 }
5582 status = mmagic_controller_rx(controller,
5583 CONTROL_STREAM,
5584 MMAGIC_IPERF,
5585 MMAGIC_IPERF_CMD_GET,
5586 MMAGIC_IPERF_VAR_SERVER,
5587 (uint8_t *)var,
5588 sizeof(*var),
5589 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5590 return status;
5591}
5592
5603static inline enum mmagic_status mmagic_controller_set_iperf_server(
5604 struct mmagic_controller *controller,
5605 struct struct_ip_addr *var)
5606{
5607 enum mmagic_status status;
5608 status = mmagic_controller_tx(controller,
5609 CONTROL_STREAM,
5610 MMAGIC_IPERF,
5611 MMAGIC_IPERF_CMD_SET,
5612 MMAGIC_IPERF_VAR_SERVER,
5613 (uint8_t *)var,
5614 sizeof(*var));
5615 if (status != MMAGIC_STATUS_OK)
5616 {
5617 return status;
5618 }
5619 status = mmagic_controller_rx(controller,
5620 CONTROL_STREAM,
5621 MMAGIC_IPERF,
5622 MMAGIC_IPERF_CMD_SET,
5623 MMAGIC_IPERF_VAR_SERVER,
5624 NULL,
5625 0,
5626 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5627 return status;
5628}
5629
5641static inline enum mmagic_status mmagic_controller_get_iperf_port(
5642 struct mmagic_controller *controller,
5643 uint16_t *var)
5644{
5645 enum mmagic_status status;
5646 status = mmagic_controller_tx(controller,
5647 CONTROL_STREAM,
5648 MMAGIC_IPERF,
5649 MMAGIC_IPERF_CMD_GET,
5650 MMAGIC_IPERF_VAR_PORT,
5651 NULL,
5652 0);
5653 if (status != MMAGIC_STATUS_OK)
5654 {
5655 return status;
5656 }
5657 status = mmagic_controller_rx(controller,
5658 CONTROL_STREAM,
5659 MMAGIC_IPERF,
5660 MMAGIC_IPERF_CMD_GET,
5661 MMAGIC_IPERF_VAR_PORT,
5662 (uint8_t *)var,
5663 sizeof(*var),
5664 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5665 return status;
5666}
5667
5679static inline enum mmagic_status mmagic_controller_set_iperf_port(
5680 struct mmagic_controller *controller,
5681 uint16_t var)
5682{
5683 enum mmagic_status status;
5684 status = mmagic_controller_tx(controller,
5685 CONTROL_STREAM,
5686 MMAGIC_IPERF,
5687 MMAGIC_IPERF_CMD_SET,
5688 MMAGIC_IPERF_VAR_PORT,
5689 (uint8_t *)&var,
5690 sizeof(var));
5691 if (status != MMAGIC_STATUS_OK)
5692 {
5693 return status;
5694 }
5695 status = mmagic_controller_rx(controller,
5696 CONTROL_STREAM,
5697 MMAGIC_IPERF,
5698 MMAGIC_IPERF_CMD_SET,
5699 MMAGIC_IPERF_VAR_PORT,
5700 NULL,
5701 0,
5702 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5703 return status;
5704}
5705
5718static inline enum mmagic_status mmagic_controller_get_iperf_amount(
5719 struct mmagic_controller *controller,
5720 int32_t *var)
5721{
5722 enum mmagic_status status;
5723 status = mmagic_controller_tx(controller,
5724 CONTROL_STREAM,
5725 MMAGIC_IPERF,
5726 MMAGIC_IPERF_CMD_GET,
5727 MMAGIC_IPERF_VAR_AMOUNT,
5728 NULL,
5729 0);
5730 if (status != MMAGIC_STATUS_OK)
5731 {
5732 return status;
5733 }
5734 status = mmagic_controller_rx(controller,
5735 CONTROL_STREAM,
5736 MMAGIC_IPERF,
5737 MMAGIC_IPERF_CMD_GET,
5738 MMAGIC_IPERF_VAR_AMOUNT,
5739 (uint8_t *)var,
5740 sizeof(*var),
5741 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5742 return status;
5743}
5744
5757static inline enum mmagic_status mmagic_controller_set_iperf_amount(
5758 struct mmagic_controller *controller,
5759 int32_t var)
5760{
5761 enum mmagic_status status;
5762 status = mmagic_controller_tx(controller,
5763 CONTROL_STREAM,
5764 MMAGIC_IPERF,
5765 MMAGIC_IPERF_CMD_SET,
5766 MMAGIC_IPERF_VAR_AMOUNT,
5767 (uint8_t *)&var,
5768 sizeof(var));
5769 if (status != MMAGIC_STATUS_OK)
5770 {
5771 return status;
5772 }
5773 status = mmagic_controller_rx(controller,
5774 CONTROL_STREAM,
5775 MMAGIC_IPERF,
5776 MMAGIC_IPERF_CMD_SET,
5777 MMAGIC_IPERF_VAR_AMOUNT,
5778 NULL,
5779 0,
5780 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5781 return status;
5782}
5783
5791static inline enum mmagic_status mmagic_controller_iperf_commit_all(
5792 struct mmagic_controller *controller)
5793{
5794 enum mmagic_status status;
5795 status = mmagic_controller_tx(controller,
5796 CONTROL_STREAM,
5797 MMAGIC_IPERF,
5798 MMAGIC_IPERF_CMD_COMMIT,
5799 0,
5800 NULL,
5801 0);
5802 if (status != MMAGIC_STATUS_OK)
5803 {
5804 return status;
5805 }
5806 status = mmagic_controller_rx(controller,
5807 CONTROL_STREAM,
5808 MMAGIC_IPERF,
5809 MMAGIC_IPERF_CMD_COMMIT,
5810 0,
5811 NULL,
5812 0,
5813 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
5814 return status;
5815}
5816
5820struct MM_PACKED mmagic_core_iperf_run_rsp_args
5821{
5823 struct struct_iperf_status status;
5824};
5825
5836static inline enum mmagic_status mmagic_controller_iperf_run(
5837 struct mmagic_controller *controller,
5838 struct mmagic_core_iperf_run_rsp_args *rsp_args)
5839{
5840 enum mmagic_status status;
5841 const uint8_t stream_id = CONTROL_STREAM;
5842 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
5843
5844 status =
5845 mmagic_controller_tx(controller, stream_id, MMAGIC_IPERF, MMAGIC_IPERF_CMD_RUN, 0, NULL, 0);
5846 if (status != MMAGIC_STATUS_OK)
5847 {
5848 return status;
5849 }
5850 status = mmagic_controller_rx(controller,
5851 stream_id,
5852 MMAGIC_IPERF,
5853 MMAGIC_IPERF_CMD_RUN,
5854 0,
5855 (uint8_t *)rsp_args,
5856 sizeof(*rsp_args),
5857 response_timeout_ms);
5858 return status;
5859}
5860
5875static inline enum mmagic_status mmagic_controller_sys_reset(struct mmagic_controller *controller)
5876{
5877 enum mmagic_status status;
5878 const uint8_t stream_id = CONTROL_STREAM;
5879 status =
5880 mmagic_controller_tx(controller, stream_id, MMAGIC_SYS, MMAGIC_SYS_CMD_RESET, 0, NULL, 0);
5881 return status;
5882}
5883
5885struct MM_PACKED mmagic_core_sys_deep_sleep_cmd_args
5886{
5888 enum mmagic_deep_sleep_mode mode;
5889};
5890
5899static inline enum mmagic_status mmagic_controller_sys_deep_sleep(
5900 struct mmagic_controller *controller,
5901 struct mmagic_core_sys_deep_sleep_cmd_args *cmd_args)
5902{
5903 enum mmagic_status status;
5904 const uint8_t stream_id = CONTROL_STREAM;
5905 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
5906
5907 status = mmagic_controller_tx(controller,
5908 stream_id,
5909 MMAGIC_SYS,
5910 MMAGIC_SYS_CMD_DEEP_SLEEP,
5911 0,
5912 (uint8_t *)cmd_args,
5913 sizeof(*cmd_args));
5914 if (status != MMAGIC_STATUS_OK)
5915 {
5916 return status;
5917 }
5918 status = mmagic_controller_rx(controller,
5919 stream_id,
5920 MMAGIC_SYS,
5921 MMAGIC_SYS_CMD_DEEP_SLEEP,
5922 0,
5923 NULL,
5924 0,
5925 response_timeout_ms);
5926 return status;
5927}
5928
5930struct MM_PACKED mmagic_core_sys_get_version_rsp_args
5931{
5933 struct struct_version_info results;
5934};
5935
5946static inline enum mmagic_status mmagic_controller_sys_get_version(
5947 struct mmagic_controller *controller,
5948 struct mmagic_core_sys_get_version_rsp_args *rsp_args)
5949{
5950 enum mmagic_status status;
5951 const uint8_t stream_id = CONTROL_STREAM;
5952 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
5953
5954 status = mmagic_controller_tx(controller,
5955 stream_id,
5956 MMAGIC_SYS,
5957 MMAGIC_SYS_CMD_GET_VERSION,
5958 0,
5959 NULL,
5960 0);
5961 if (status != MMAGIC_STATUS_OK)
5962 {
5963 return status;
5964 }
5965 status = mmagic_controller_rx(controller,
5966 stream_id,
5967 MMAGIC_SYS,
5968 MMAGIC_SYS_CMD_GET_VERSION,
5969 0,
5970 (uint8_t *)rsp_args,
5971 sizeof(*rsp_args),
5972 response_timeout_ms);
5973 return status;
5974}
5975
5984struct MM_PACKED mmagic_core_tcp_connect_cmd_args
5985{
5987 struct string254 url;
5989 uint16_t port;
5991 bool enable_tls;
5992};
5993
5995struct MM_PACKED mmagic_core_tcp_connect_rsp_args
5996{
5998 uint8_t stream_id;
5999};
6000
6012static inline enum mmagic_status mmagic_controller_tcp_connect(
6013 struct mmagic_controller *controller,
6014 struct mmagic_core_tcp_connect_cmd_args *cmd_args,
6015 struct mmagic_core_tcp_connect_rsp_args *rsp_args)
6016{
6017 enum mmagic_status status;
6018 const uint8_t stream_id = CONTROL_STREAM;
6019 uint32_t response_timeout_ms = 15000;
6020
6021 status = mmagic_controller_tx(controller,
6022 stream_id,
6023 MMAGIC_TCP,
6024 MMAGIC_TCP_CMD_CONNECT,
6025 0,
6026 (uint8_t *)cmd_args,
6027 sizeof(*cmd_args));
6028 if (status != MMAGIC_STATUS_OK)
6029 {
6030 return status;
6031 }
6032 status = mmagic_controller_rx(controller,
6033 stream_id,
6034 MMAGIC_TCP,
6035 MMAGIC_TCP_CMD_CONNECT,
6036 0,
6037 (uint8_t *)rsp_args,
6038 sizeof(*rsp_args),
6039 response_timeout_ms);
6040 return status;
6041}
6042
6044struct MM_PACKED mmagic_core_tcp_bind_cmd_args
6045{
6047 uint16_t port;
6048};
6049
6051struct MM_PACKED mmagic_core_tcp_bind_rsp_args
6052{
6054 uint8_t stream_id;
6055};
6056
6068static inline enum mmagic_status mmagic_controller_tcp_bind(
6069 struct mmagic_controller *controller,
6070 struct mmagic_core_tcp_bind_cmd_args *cmd_args,
6071 struct mmagic_core_tcp_bind_rsp_args *rsp_args)
6072{
6073 enum mmagic_status status;
6074 const uint8_t stream_id = CONTROL_STREAM;
6075 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
6076
6077 status = mmagic_controller_tx(controller,
6078 stream_id,
6079 MMAGIC_TCP,
6080 MMAGIC_TCP_CMD_BIND,
6081 0,
6082 (uint8_t *)cmd_args,
6083 sizeof(*cmd_args));
6084 if (status != MMAGIC_STATUS_OK)
6085 {
6086 return status;
6087 }
6088 status = mmagic_controller_rx(controller,
6089 stream_id,
6090 MMAGIC_TCP,
6091 MMAGIC_TCP_CMD_BIND,
6092 0,
6093 (uint8_t *)rsp_args,
6094 sizeof(*rsp_args),
6095 response_timeout_ms);
6096 return status;
6097}
6098
6100struct MM_PACKED mmagic_core_tcp_recv_cmd_args
6101{
6103 uint8_t stream_id;
6105 uint16_t len;
6107 uint32_t timeout;
6108};
6109
6111struct MM_PACKED mmagic_core_tcp_recv_rsp_args
6112{
6114 struct raw1536 buffer;
6115};
6116
6128static inline enum mmagic_status mmagic_controller_tcp_recv(
6129 struct mmagic_controller *controller,
6130 struct mmagic_core_tcp_recv_cmd_args *cmd_args,
6131 struct mmagic_core_tcp_recv_rsp_args *rsp_args)
6132{
6133 enum mmagic_status status;
6134 const uint8_t stream_id = cmd_args->stream_id;
6135 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
6136
6137 /* Account for the timeout argument when waiting for the response and make sure no overflow. */
6138 if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
6139 {
6140 response_timeout_ms += cmd_args->timeout;
6141 }
6142 else
6143 {
6144 response_timeout_ms = UINT32_MAX;
6145 }
6146
6147 status = mmagic_controller_tx(controller,
6148 stream_id,
6149 MMAGIC_TCP,
6150 MMAGIC_TCP_CMD_RECV,
6151 0,
6152 (uint8_t *)cmd_args,
6153 sizeof(*cmd_args));
6154 if (status != MMAGIC_STATUS_OK)
6155 {
6156 return status;
6157 }
6158 status = mmagic_controller_rx(controller,
6159 stream_id,
6160 MMAGIC_TCP,
6161 MMAGIC_TCP_CMD_RECV,
6162 0,
6163 (uint8_t *)rsp_args,
6164 sizeof(*rsp_args),
6165 response_timeout_ms);
6166 return status;
6167}
6168
6170struct MM_PACKED mmagic_core_tcp_send_cmd_args
6171{
6173 uint8_t stream_id;
6175 struct raw1536 buffer;
6176};
6177
6186static inline enum mmagic_status mmagic_controller_tcp_send(
6187 struct mmagic_controller *controller,
6188 struct mmagic_core_tcp_send_cmd_args *cmd_args)
6189{
6190 enum mmagic_status status;
6191 const uint8_t stream_id = cmd_args->stream_id;
6192 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
6193
6194 status = mmagic_controller_tx(controller,
6195 stream_id,
6196 MMAGIC_TCP,
6197 MMAGIC_TCP_CMD_SEND,
6198 0,
6199 (uint8_t *)cmd_args,
6200 sizeof(*cmd_args));
6201 if (status != MMAGIC_STATUS_OK)
6202 {
6203 return status;
6204 }
6205 status = mmagic_controller_rx(controller,
6206 stream_id,
6207 MMAGIC_TCP,
6208 MMAGIC_TCP_CMD_SEND,
6209 0,
6210 NULL,
6211 0,
6212 response_timeout_ms);
6213 return status;
6214}
6215
6217struct MM_PACKED mmagic_core_tcp_read_poll_cmd_args
6218{
6220 uint8_t stream_id;
6222 uint32_t timeout;
6223};
6224
6233static inline enum mmagic_status mmagic_controller_tcp_read_poll(
6234 struct mmagic_controller *controller,
6235 struct mmagic_core_tcp_read_poll_cmd_args *cmd_args)
6236{
6237 enum mmagic_status status;
6238 const uint8_t stream_id = cmd_args->stream_id;
6239 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
6240
6241 /* Account for the timeout argument when waiting for the response and make sure no overflow. */
6242 if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
6243 {
6244 response_timeout_ms += cmd_args->timeout;
6245 }
6246 else
6247 {
6248 response_timeout_ms = UINT32_MAX;
6249 }
6250
6251 status = mmagic_controller_tx(controller,
6252 stream_id,
6253 MMAGIC_TCP,
6254 MMAGIC_TCP_CMD_READ_POLL,
6255 0,
6256 (uint8_t *)cmd_args,
6257 sizeof(*cmd_args));
6258 if (status != MMAGIC_STATUS_OK)
6259 {
6260 return status;
6261 }
6262 status = mmagic_controller_rx(controller,
6263 stream_id,
6264 MMAGIC_TCP,
6265 MMAGIC_TCP_CMD_READ_POLL,
6266 0,
6267 NULL,
6268 0,
6269 response_timeout_ms);
6270 return status;
6271}
6272
6274struct MM_PACKED mmagic_core_tcp_write_poll_cmd_args
6275{
6277 uint8_t stream_id;
6279 uint32_t timeout;
6280};
6281
6290static inline enum mmagic_status mmagic_controller_tcp_write_poll(
6291 struct mmagic_controller *controller,
6292 struct mmagic_core_tcp_write_poll_cmd_args *cmd_args)
6293{
6294 enum mmagic_status status;
6295 const uint8_t stream_id = cmd_args->stream_id;
6296 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
6297
6298 /* Account for the timeout argument when waiting for the response and make sure no overflow. */
6299 if (UINT32_MAX - response_timeout_ms >= cmd_args->timeout)
6300 {
6301 response_timeout_ms += cmd_args->timeout;
6302 }
6303 else
6304 {
6305 response_timeout_ms = UINT32_MAX;
6306 }
6307
6308 status = mmagic_controller_tx(controller,
6309 stream_id,
6310 MMAGIC_TCP,
6311 MMAGIC_TCP_CMD_WRITE_POLL,
6312 0,
6313 (uint8_t *)cmd_args,
6314 sizeof(*cmd_args));
6315 if (status != MMAGIC_STATUS_OK)
6316 {
6317 return status;
6318 }
6319 status = mmagic_controller_rx(controller,
6320 stream_id,
6321 MMAGIC_TCP,
6322 MMAGIC_TCP_CMD_WRITE_POLL,
6323 0,
6324 NULL,
6325 0,
6326 response_timeout_ms);
6327 return status;
6328}
6329
6331struct MM_PACKED mmagic_core_tcp_accept_cmd_args
6332{
6334 uint8_t stream_id;
6335};
6336
6338struct MM_PACKED mmagic_core_tcp_accept_rsp_args
6339{
6341 uint8_t stream_id;
6342};
6343
6355static inline enum mmagic_status mmagic_controller_tcp_accept(
6356 struct mmagic_controller *controller,
6357 struct mmagic_core_tcp_accept_cmd_args *cmd_args,
6358 struct mmagic_core_tcp_accept_rsp_args *rsp_args)
6359{
6360 enum mmagic_status status;
6361 const uint8_t stream_id = cmd_args->stream_id;
6362 uint32_t response_timeout_ms = -1;
6363
6364 status = mmagic_controller_tx(controller,
6365 stream_id,
6366 MMAGIC_TCP,
6367 MMAGIC_TCP_CMD_ACCEPT,
6368 0,
6369 (uint8_t *)cmd_args,
6370 sizeof(*cmd_args));
6371 if (status != MMAGIC_STATUS_OK)
6372 {
6373 return status;
6374 }
6375 status = mmagic_controller_rx(controller,
6376 stream_id,
6377 MMAGIC_TCP,
6378 MMAGIC_TCP_CMD_ACCEPT,
6379 0,
6380 (uint8_t *)rsp_args,
6381 sizeof(*rsp_args),
6382 response_timeout_ms);
6383 return status;
6384}
6385
6387struct MM_PACKED mmagic_core_tcp_close_cmd_args
6388{
6390 uint8_t stream_id;
6391};
6392
6401static inline enum mmagic_status mmagic_controller_tcp_close(
6402 struct mmagic_controller *controller,
6403 struct mmagic_core_tcp_close_cmd_args *cmd_args)
6404{
6405 enum mmagic_status status;
6406 const uint8_t stream_id = CONTROL_STREAM;
6407 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
6408
6409 status = mmagic_controller_tx(controller,
6410 stream_id,
6411 MMAGIC_TCP,
6412 MMAGIC_TCP_CMD_CLOSE,
6413 0,
6414 (uint8_t *)cmd_args,
6415 sizeof(*cmd_args));
6416 if (status != MMAGIC_STATUS_OK)
6417 {
6418 return status;
6419 }
6420 status = mmagic_controller_rx(controller,
6421 stream_id,
6422 MMAGIC_TCP,
6423 MMAGIC_TCP_CMD_CLOSE,
6424 0,
6425 NULL,
6426 0,
6427 response_timeout_ms);
6428 return status;
6429}
6430
6432struct MM_PACKED mmagic_core_tcp_set_rx_ready_evt_enabled_cmd_args
6433{
6435 uint8_t stream_id;
6437 bool enabled;
6438};
6439
6449static inline enum mmagic_status mmagic_controller_tcp_set_rx_ready_evt_enabled(
6450 struct mmagic_controller *controller,
6451 struct mmagic_core_tcp_set_rx_ready_evt_enabled_cmd_args *cmd_args)
6452{
6453 enum mmagic_status status;
6454 const uint8_t stream_id = CONTROL_STREAM;
6455 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
6456
6457 status = mmagic_controller_tx(controller,
6458 stream_id,
6459 MMAGIC_TCP,
6460 MMAGIC_TCP_CMD_SET_RX_READY_EVT_ENABLED,
6461 0,
6462 (uint8_t *)cmd_args,
6463 sizeof(*cmd_args));
6464 if (status != MMAGIC_STATUS_OK)
6465 {
6466 return status;
6467 }
6468 status = mmagic_controller_rx(controller,
6469 stream_id,
6470 MMAGIC_TCP,
6471 MMAGIC_TCP_CMD_SET_RX_READY_EVT_ENABLED,
6472 0,
6473 NULL,
6474 0,
6475 response_timeout_ms);
6476 return status;
6477}
6478
6480struct MM_PACKED mmagic_tcp_rx_ready_event_args
6481{
6483 uint8_t stream_id;
6484};
6485
6499typedef void (*mmagic_tcp_rx_ready_event_handler_t)(
6500 const struct mmagic_tcp_rx_ready_event_args *event_args,
6501 void *arg);
6502
6517void mmagic_controller_register_tcp_rx_ready_handler(struct mmagic_controller *controller,
6518 mmagic_tcp_rx_ready_event_handler_t handler,
6519 void *arg);
6520
6544static inline enum mmagic_status mmagic_controller_get_tls_root_ca_certificate(
6545 struct mmagic_controller *controller,
6546 struct raw1536 *var)
6547{
6548 enum mmagic_status status;
6549 status = mmagic_controller_tx(controller,
6550 CONTROL_STREAM,
6551 MMAGIC_TLS,
6552 MMAGIC_TLS_CMD_GET,
6553 MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE,
6554 NULL,
6555 0);
6556 if (status != MMAGIC_STATUS_OK)
6557 {
6558 return status;
6559 }
6560 status = mmagic_controller_rx(controller,
6561 CONTROL_STREAM,
6562 MMAGIC_TLS,
6563 MMAGIC_TLS_CMD_GET,
6564 MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE,
6565 (uint8_t *)var,
6566 sizeof(*var),
6567 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6568 return status;
6569}
6570
6582static inline enum mmagic_status mmagic_controller_set_tls_root_ca_certificate(
6583 struct mmagic_controller *controller,
6584 struct raw1536 *var)
6585{
6586 enum mmagic_status status;
6587 status = mmagic_controller_tx(controller,
6588 CONTROL_STREAM,
6589 MMAGIC_TLS,
6590 MMAGIC_TLS_CMD_SET,
6591 MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE,
6592 (uint8_t *)var,
6593 sizeof(*var));
6594 if (status != MMAGIC_STATUS_OK)
6595 {
6596 return status;
6597 }
6598 status = mmagic_controller_rx(controller,
6599 CONTROL_STREAM,
6600 MMAGIC_TLS,
6601 MMAGIC_TLS_CMD_SET,
6602 MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE,
6603 NULL,
6604 0,
6605 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6606 return status;
6607}
6608
6620static inline enum mmagic_status mmagic_controller_get_tls_client_certificate(
6621 struct mmagic_controller *controller,
6622 struct raw1536 *var)
6623{
6624 enum mmagic_status status;
6625 status = mmagic_controller_tx(controller,
6626 CONTROL_STREAM,
6627 MMAGIC_TLS,
6628 MMAGIC_TLS_CMD_GET,
6629 MMAGIC_TLS_VAR_CLIENT_CERTIFICATE,
6630 NULL,
6631 0);
6632 if (status != MMAGIC_STATUS_OK)
6633 {
6634 return status;
6635 }
6636 status = mmagic_controller_rx(controller,
6637 CONTROL_STREAM,
6638 MMAGIC_TLS,
6639 MMAGIC_TLS_CMD_GET,
6640 MMAGIC_TLS_VAR_CLIENT_CERTIFICATE,
6641 (uint8_t *)var,
6642 sizeof(*var),
6643 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6644 return status;
6645}
6646
6658static inline enum mmagic_status mmagic_controller_set_tls_client_certificate(
6659 struct mmagic_controller *controller,
6660 struct raw1536 *var)
6661{
6662 enum mmagic_status status;
6663 status = mmagic_controller_tx(controller,
6664 CONTROL_STREAM,
6665 MMAGIC_TLS,
6666 MMAGIC_TLS_CMD_SET,
6667 MMAGIC_TLS_VAR_CLIENT_CERTIFICATE,
6668 (uint8_t *)var,
6669 sizeof(*var));
6670 if (status != MMAGIC_STATUS_OK)
6671 {
6672 return status;
6673 }
6674 status = mmagic_controller_rx(controller,
6675 CONTROL_STREAM,
6676 MMAGIC_TLS,
6677 MMAGIC_TLS_CMD_SET,
6678 MMAGIC_TLS_VAR_CLIENT_CERTIFICATE,
6679 NULL,
6680 0,
6681 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6682 return status;
6683}
6684
6695static inline enum mmagic_status mmagic_controller_get_tls_client_private_key(
6696 struct mmagic_controller *controller,
6697 struct raw1536 *var)
6698{
6699 enum mmagic_status status;
6700 status = mmagic_controller_tx(controller,
6701 CONTROL_STREAM,
6702 MMAGIC_TLS,
6703 MMAGIC_TLS_CMD_GET,
6704 MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY,
6705 NULL,
6706 0);
6707 if (status != MMAGIC_STATUS_OK)
6708 {
6709 return status;
6710 }
6711 status = mmagic_controller_rx(controller,
6712 CONTROL_STREAM,
6713 MMAGIC_TLS,
6714 MMAGIC_TLS_CMD_GET,
6715 MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY,
6716 (uint8_t *)var,
6717 sizeof(*var),
6718 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6719 return status;
6720}
6721
6732static inline enum mmagic_status mmagic_controller_set_tls_client_private_key(
6733 struct mmagic_controller *controller,
6734 struct raw1536 *var)
6735{
6736 enum mmagic_status status;
6737 status = mmagic_controller_tx(controller,
6738 CONTROL_STREAM,
6739 MMAGIC_TLS,
6740 MMAGIC_TLS_CMD_SET,
6741 MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY,
6742 (uint8_t *)var,
6743 sizeof(*var));
6744 if (status != MMAGIC_STATUS_OK)
6745 {
6746 return status;
6747 }
6748 status = mmagic_controller_rx(controller,
6749 CONTROL_STREAM,
6750 MMAGIC_TLS,
6751 MMAGIC_TLS_CMD_SET,
6752 MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY,
6753 NULL,
6754 0,
6755 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6756 return status;
6757}
6758
6766static inline enum mmagic_status mmagic_controller_tls_commit_all(
6767 struct mmagic_controller *controller)
6768{
6769 enum mmagic_status status;
6770 status = mmagic_controller_tx(controller,
6771 CONTROL_STREAM,
6772 MMAGIC_TLS,
6773 MMAGIC_TLS_CMD_COMMIT,
6774 0,
6775 NULL,
6776 0);
6777 if (status != MMAGIC_STATUS_OK)
6778 {
6779 return status;
6780 }
6781 status = mmagic_controller_rx(controller,
6782 CONTROL_STREAM,
6783 MMAGIC_TLS,
6784 MMAGIC_TLS_CMD_COMMIT,
6785 0,
6786 NULL,
6787 0,
6788 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6789 return status;
6790}
6791
6816static inline enum mmagic_status mmagic_controller_get_ntp_server(
6817 struct mmagic_controller *controller,
6818 struct string254 *var)
6819{
6820 enum mmagic_status status;
6821 status = mmagic_controller_tx(controller,
6822 CONTROL_STREAM,
6823 MMAGIC_NTP,
6824 MMAGIC_NTP_CMD_GET,
6825 MMAGIC_NTP_VAR_SERVER,
6826 NULL,
6827 0);
6828 if (status != MMAGIC_STATUS_OK)
6829 {
6830 return status;
6831 }
6832 status = mmagic_controller_rx(controller,
6833 CONTROL_STREAM,
6834 MMAGIC_NTP,
6835 MMAGIC_NTP_CMD_GET,
6836 MMAGIC_NTP_VAR_SERVER,
6837 (uint8_t *)var,
6838 sizeof(*var),
6839 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6840 return status;
6841}
6842
6853static inline enum mmagic_status mmagic_controller_set_ntp_server(
6854 struct mmagic_controller *controller,
6855 const char *var)
6856{
6857 struct string254 var_val;
6858 enum mmagic_status status;
6859 var_val.len = strlen(var);
6860 if (var_val.len > sizeof(var_val.data) - 1)
6861 {
6862 return MMAGIC_STATUS_INVALID_ARG;
6863 }
6864 memcpy(var_val.data, (const uint8_t *)var, var_val.len);
6865 memset(var_val.data + var_val.len, 0, sizeof(var_val.data) - var_val.len);
6866 status = mmagic_controller_tx(controller,
6867 CONTROL_STREAM,
6868 MMAGIC_NTP,
6869 MMAGIC_NTP_CMD_SET,
6870 MMAGIC_NTP_VAR_SERVER,
6871 (uint8_t *)&var_val,
6872 sizeof(var_val));
6873 if (status != MMAGIC_STATUS_OK)
6874 {
6875 return status;
6876 }
6877 status = mmagic_controller_rx(controller,
6878 CONTROL_STREAM,
6879 MMAGIC_NTP,
6880 MMAGIC_NTP_CMD_SET,
6881 MMAGIC_NTP_VAR_SERVER,
6882 NULL,
6883 0,
6884 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6885 return status;
6886}
6887
6895static inline enum mmagic_status mmagic_controller_ntp_commit_all(
6896 struct mmagic_controller *controller)
6897{
6898 enum mmagic_status status;
6899 status = mmagic_controller_tx(controller,
6900 CONTROL_STREAM,
6901 MMAGIC_NTP,
6902 MMAGIC_NTP_CMD_COMMIT,
6903 0,
6904 NULL,
6905 0);
6906 if (status != MMAGIC_STATUS_OK)
6907 {
6908 return status;
6909 }
6910 status = mmagic_controller_rx(controller,
6911 CONTROL_STREAM,
6912 MMAGIC_NTP,
6913 MMAGIC_NTP_CMD_COMMIT,
6914 0,
6915 NULL,
6916 0,
6917 MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS);
6918 return status;
6919}
6920
6930static inline enum mmagic_status mmagic_controller_ntp_sync(struct mmagic_controller *controller)
6931{
6932 enum mmagic_status status;
6933 const uint8_t stream_id = CONTROL_STREAM;
6934 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
6935
6936 status =
6937 mmagic_controller_tx(controller, stream_id, MMAGIC_NTP, MMAGIC_NTP_CMD_SYNC, 0, NULL, 0);
6938 if (status != MMAGIC_STATUS_OK)
6939 {
6940 return status;
6941 }
6942 return mmagic_controller_rx(controller,
6943 stream_id,
6944 MMAGIC_NTP,
6945 MMAGIC_NTP_CMD_SYNC,
6946 0,
6947 NULL,
6948 0,
6949 response_timeout_ms);
6950 return status;
6951}
6952
6954struct MM_PACKED mmagic_core_ntp_get_time_rsp_args
6955{
6957 uint64_t timestamp;
6958};
6959
6970static inline enum mmagic_status mmagic_controller_ntp_get_time(
6971 struct mmagic_controller *controller,
6972 struct mmagic_core_ntp_get_time_rsp_args *rsp_args)
6973{
6974 enum mmagic_status status;
6975 const uint8_t stream_id = CONTROL_STREAM;
6976 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
6977
6978 status = mmagic_controller_tx(controller,
6979 stream_id,
6980 MMAGIC_NTP,
6981 MMAGIC_NTP_CMD_GET_TIME,
6982 0,
6983 NULL,
6984 0);
6985 if (status != MMAGIC_STATUS_OK)
6986 {
6987 return status;
6988 }
6989 status = mmagic_controller_rx(controller,
6990 stream_id,
6991 MMAGIC_NTP,
6992 MMAGIC_NTP_CMD_GET_TIME,
6993 0,
6994 (uint8_t *)rsp_args,
6995 sizeof(*rsp_args),
6996 response_timeout_ms);
6997 return status;
6998}
6999
7008struct MM_PACKED mmagic_core_mqtt_start_agent_cmd_args
7009{
7011 struct string254 url;
7013 uint16_t port;
7015 struct string100 username;
7017 struct string100 password;
7019 bool secure;
7020};
7021
7023struct MM_PACKED mmagic_core_mqtt_start_agent_rsp_args
7024{
7026 uint8_t stream_id;
7027};
7028
7042static inline enum mmagic_status mmagic_controller_mqtt_start_agent(
7043 struct mmagic_controller *controller,
7044 struct mmagic_core_mqtt_start_agent_cmd_args *cmd_args,
7045 struct mmagic_core_mqtt_start_agent_rsp_args *rsp_args)
7046{
7047 enum mmagic_status status;
7048 const uint8_t stream_id = CONTROL_STREAM;
7049 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
7050
7051 status = mmagic_controller_tx(controller,
7052 stream_id,
7053 MMAGIC_MQTT,
7054 MMAGIC_MQTT_CMD_START_AGENT,
7055 0,
7056 (uint8_t *)cmd_args,
7057 sizeof(*cmd_args));
7058 if (status != MMAGIC_STATUS_OK)
7059 {
7060 return status;
7061 }
7062 status = mmagic_controller_rx(controller,
7063 stream_id,
7064 MMAGIC_MQTT,
7065 MMAGIC_MQTT_CMD_START_AGENT,
7066 0,
7067 (uint8_t *)rsp_args,
7068 sizeof(*rsp_args),
7069 response_timeout_ms);
7070 return status;
7071}
7072
7074struct MM_PACKED mmagic_core_mqtt_publish_cmd_args
7075{
7077 uint8_t stream_id;
7079 struct string254 topic;
7081 struct raw1536 payload;
7083 uint8_t qos;
7084};
7085
7094static inline enum mmagic_status mmagic_controller_mqtt_publish(
7095 struct mmagic_controller *controller,
7096 struct mmagic_core_mqtt_publish_cmd_args *cmd_args)
7097{
7098 enum mmagic_status status;
7099 const uint8_t stream_id = CONTROL_STREAM;
7100 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
7101
7102 status = mmagic_controller_tx(controller,
7103 stream_id,
7104 MMAGIC_MQTT,
7105 MMAGIC_MQTT_CMD_PUBLISH,
7106 0,
7107 (uint8_t *)cmd_args,
7108 sizeof(*cmd_args));
7109 if (status != MMAGIC_STATUS_OK)
7110 {
7111 return status;
7112 }
7113 status = mmagic_controller_rx(controller,
7114 stream_id,
7115 MMAGIC_MQTT,
7116 MMAGIC_MQTT_CMD_PUBLISH,
7117 0,
7118 NULL,
7119 0,
7120 response_timeout_ms);
7121 return status;
7122}
7123
7125struct MM_PACKED mmagic_core_mqtt_subscribe_cmd_args
7126{
7128 uint8_t stream_id;
7130 struct string254 topic;
7132 uint8_t qos;
7133};
7134
7143static inline enum mmagic_status mmagic_controller_mqtt_subscribe(
7144 struct mmagic_controller *controller,
7145 struct mmagic_core_mqtt_subscribe_cmd_args *cmd_args)
7146{
7147 enum mmagic_status status;
7148 const uint8_t stream_id = CONTROL_STREAM;
7149 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
7150
7151 status = mmagic_controller_tx(controller,
7152 stream_id,
7153 MMAGIC_MQTT,
7154 MMAGIC_MQTT_CMD_SUBSCRIBE,
7155 0,
7156 (uint8_t *)cmd_args,
7157 sizeof(*cmd_args));
7158 if (status != MMAGIC_STATUS_OK)
7159 {
7160 return status;
7161 }
7162 status = mmagic_controller_rx(controller,
7163 stream_id,
7164 MMAGIC_MQTT,
7165 MMAGIC_MQTT_CMD_SUBSCRIBE,
7166 0,
7167 NULL,
7168 0,
7169 response_timeout_ms);
7170 return status;
7171}
7172
7174struct MM_PACKED mmagic_core_mqtt_stop_agent_cmd_args
7175{
7177 uint8_t stream_id;
7178};
7179
7188static inline enum mmagic_status mmagic_controller_mqtt_stop_agent(
7189 struct mmagic_controller *controller,
7190 struct mmagic_core_mqtt_stop_agent_cmd_args *cmd_args)
7191{
7192 enum mmagic_status status;
7193 const uint8_t stream_id = CONTROL_STREAM;
7194 uint32_t response_timeout_ms = MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS;
7195
7196 status = mmagic_controller_tx(controller,
7197 stream_id,
7198 MMAGIC_MQTT,
7199 MMAGIC_MQTT_CMD_STOP_AGENT,
7200 0,
7201 (uint8_t *)cmd_args,
7202 sizeof(*cmd_args));
7203 if (status != MMAGIC_STATUS_OK)
7204 {
7205 return status;
7206 }
7207 status = mmagic_controller_rx(controller,
7208 stream_id,
7209 MMAGIC_MQTT,
7210 MMAGIC_MQTT_CMD_STOP_AGENT,
7211 0,
7212 NULL,
7213 0,
7214 response_timeout_ms);
7215 return status;
7216}
7217
7219struct MM_PACKED mmagic_mqtt_message_received_event_args
7220{
7222 uint8_t stream_id;
7224 struct string254 topic;
7226 struct raw1536 payload;
7227};
7228
7242typedef void (*mmagic_mqtt_message_received_event_handler_t)(
7243 const struct mmagic_mqtt_message_received_event_args *event_args,
7244 void *arg);
7245
7260void mmagic_controller_register_mqtt_message_received_handler(
7261 struct mmagic_controller *controller,
7262 mmagic_mqtt_message_received_event_handler_t handler,
7263 void *arg);
7264
7266struct MM_PACKED mmagic_mqtt_broker_connection_event_args
7267{
7269 uint8_t stream_id;
7271 enum mmagic_status connection_state;
7272};
7273
7287typedef void (*mmagic_mqtt_broker_connection_event_handler_t)(
7288 const struct mmagic_mqtt_broker_connection_event_args *event_args,
7289 void *arg);
7290
7305void mmagic_controller_register_mqtt_broker_connection_handler(
7306 struct mmagic_controller *controller,
7307 mmagic_mqtt_broker_connection_event_handler_t handler,
7308 void *arg);
7309
7312#ifdef __cplusplus
7313}
7314#endif
7315
filter
struct mmwlan_beacon_vendor_ie_filter filter
Filter structure used when calling mmwlan_update_beacon_vendor_ie_filter().
Definition: beacon_stuffing.c:109
mmagic_ip_link_state
mmagic_ip_link_state
Status of the IP link.
Definition: mmagic_controller.h:209
mmagic_iperf_state
mmagic_iperf_state
Current state of iperf session.
Definition: mmagic_controller.h:196
mmagic_station_type
mmagic_station_type
Enumeration of S1G non-AP STA types.
Definition: mmagic_controller.h:100
mmagic_sta_event
mmagic_sta_event
Station connection events.
Definition: mmagic_controller.h:261
mmagic_deep_sleep_mode
mmagic_deep_sleep_mode
Deep sleep modes for the agent MCU.
Definition: mmagic_controller.h:218
mmagic_sta_state
mmagic_sta_state
Station states.
Definition: mmagic_controller.h:250
mmagic_duty_cycle_mode
mmagic_duty_cycle_mode
Enumeration of duty cycle modes.
Definition: mmagic_controller.h:91
mmagic_standby_mode_exit_reason
mmagic_standby_mode_exit_reason
Reasons for exiting standby mode.
Definition: mmagic_controller.h:229
mmagic_power_save_mode
mmagic_power_save_mode
Enumeration of supported 802.11 power save modes.
Definition: mmagic_controller.h:71
mmagic_security_type
mmagic_security_type
Connection security type.
Definition: mmagic_controller.h:51
mmagic_mcs10_mode
mmagic_mcs10_mode
Enumeration of MCS10 modes.
Definition: mmagic_controller.h:80
mmagic_status
mmagic_status
Enumeration of return status codes.
Definition: mmagic_controller.h:109
mmagic_iperf_mode
mmagic_iperf_mode
Mode to use when running the iperf.
Definition: mmagic_controller.h:183
mmagic_subsystem
mmagic_subsystem
Subsytem IDs.
Definition: mmagic_controller.h:496
mmagic_pmf_mode
mmagic_pmf_mode
Protected management frame mode.
Definition: mmagic_controller.h:62
MMAGIC_IP_LINK_STATE_DOWN
@ MMAGIC_IP_LINK_STATE_DOWN
Link is down because the interface is down or DHCP has not yet completed.
Definition: mmagic_controller.h:211
MMAGIC_IP_LINK_STATE_UP
@ MMAGIC_IP_LINK_STATE_UP
Link is up.
Definition: mmagic_controller.h:213
MMAGIC_IPERF_STATE_RUNNING
@ MMAGIC_IPERF_STATE_RUNNING
Iperf session is in progress.
Definition: mmagic_controller.h:200
MMAGIC_IPERF_STATE_NOT_STARTED
@ MMAGIC_IPERF_STATE_NOT_STARTED
Iperf session not started.
Definition: mmagic_controller.h:198
MMAGIC_IPERF_STATE_FINISHED
@ MMAGIC_IPERF_STATE_FINISHED
Iperf session has completed.
Definition: mmagic_controller.h:202
MMAGIC_IPERF_STATE_ABORTED
@ MMAGIC_IPERF_STATE_ABORTED
Iperf session has been aborted.
Definition: mmagic_controller.h:204
MMAGIC_STATION_TYPE_NON_SENSOR
@ MMAGIC_STATION_TYPE_NON_SENSOR
Non-Sensor type.
Definition: mmagic_controller.h:104
MMAGIC_STATION_TYPE_SENSOR
@ MMAGIC_STATION_TYPE_SENSOR
Sensor type.
Definition: mmagic_controller.h:102
MMAGIC_STA_EVENT_SCAN_COMPLETE
@ MMAGIC_STA_EVENT_SCAN_COMPLETE
The STA has finished a scan.
Definition: mmagic_controller.h:265
MMAGIC_STA_EVENT_CTRL_PORT_OPEN
@ MMAGIC_STA_EVENT_CTRL_PORT_OPEN
The Supplicant IEEE 802.1X Controlled Port is now open.
Definition: mmagic_controller.h:275
MMAGIC_STA_EVENT_SCAN_ABORT
@ MMAGIC_STA_EVENT_SCAN_ABORT
The STA has aborted a scan early.
Definition: mmagic_controller.h:267
MMAGIC_STA_EVENT_AUTH_REQUEST
@ MMAGIC_STA_EVENT_AUTH_REQUEST
The STA is sending an authentication request to the AP.
Definition: mmagic_controller.h:269
MMAGIC_STA_EVENT_SCAN_REQUEST
@ MMAGIC_STA_EVENT_SCAN_REQUEST
The STA is starting a scan.
Definition: mmagic_controller.h:263
MMAGIC_STA_EVENT_ASSOC_REQUEST
@ MMAGIC_STA_EVENT_ASSOC_REQUEST
The STA is sending an association request to the AP.
Definition: mmagic_controller.h:271
MMAGIC_STA_EVENT_CTRL_PORT_CLOSED
@ MMAGIC_STA_EVENT_CTRL_PORT_CLOSED
The Supplicant IEEE 802.1X Controlled Port is now closed.
Definition: mmagic_controller.h:277
MMAGIC_STA_EVENT_DEAUTH_TX
@ MMAGIC_STA_EVENT_DEAUTH_TX
The STA is sending an de-authorization request to the AP.
Definition: mmagic_controller.h:273
MMAGIC_DEEP_SLEEP_MODE_HARDWARE
@ MMAGIC_DEEP_SLEEP_MODE_HARDWARE
The datalink layer is responsible for waking the agent.
Definition: mmagic_controller.h:224
MMAGIC_DEEP_SLEEP_MODE_ONE_SHOT
@ MMAGIC_DEEP_SLEEP_MODE_ONE_SHOT
Deep sleep is enabled until activity occurs on the datalink.
Definition: mmagic_controller.h:222
MMAGIC_DEEP_SLEEP_MODE_DISABLED
@ MMAGIC_DEEP_SLEEP_MODE_DISABLED
Deep sleep is disabled.
Definition: mmagic_controller.h:220
MMAGIC_STA_STATE_CONNECTING
@ MMAGIC_STA_STATE_CONNECTING
Connecting to the AP.
Definition: mmagic_controller.h:254
MMAGIC_STA_STATE_DISCONNECTED
@ MMAGIC_STA_STATE_DISCONNECTED
Disconnected from the AP.
Definition: mmagic_controller.h:252
MMAGIC_STA_STATE_CONNECTED
@ MMAGIC_STA_STATE_CONNECTED
Connected to the AP.
Definition: mmagic_controller.h:256
MMAGIC_DUTY_CYCLE_MODE_SPREAD
@ MMAGIC_DUTY_CYCLE_MODE_SPREAD
Duty cycle air time is evenly spread.
Definition: mmagic_controller.h:93
MMAGIC_DUTY_CYCLE_MODE_BURST
@ MMAGIC_DUTY_CYCLE_MODE_BURST
Duty cycle air time available in burst.
Definition: mmagic_controller.h:95
MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_EXT_INPUT
@ MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_EXT_INPUT
We were woken up by an external input trigger.
Definition: mmagic_controller.h:237
MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_TCP_CONNECTION_LOST
@ MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_TCP_CONNECTION_LOST
An open TCP connection was lost.
Definition: mmagic_controller.h:241
MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_ASSOCIATE
@ MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_ASSOCIATE
We just reassociated with the AP.
Definition: mmagic_controller.h:235
MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_HW_SCAN_FAILED_TO_START
@ MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_HW_SCAN_FAILED_TO_START
Hardware scan failed to start.
Definition: mmagic_controller.h:245
MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_WAKEUP_FRAME
@ MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_WAKEUP_FRAME
We were woken up by a wakeup frame.
Definition: mmagic_controller.h:233
MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_WHITELIST_PKT
@ MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_WHITELIST_PKT
We received a packet from a whitelist source.
Definition: mmagic_controller.h:239
MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_NONE
@ MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_NONE
Standby mode was exited manually through a call to standby_exit.
Definition: mmagic_controller.h:231
MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_HW_SCAN_NOT_ENABLED
@ MMAGIC_STANDBY_MODE_EXIT_REASON_STANDBY_EXIT_HW_SCAN_NOT_ENABLED
Hardware scan was not enabled.
Definition: mmagic_controller.h:243
MMAGIC_POWER_SAVE_MODE_ENABLED
@ MMAGIC_POWER_SAVE_MODE_ENABLED
Power save enabled.
Definition: mmagic_controller.h:75
MMAGIC_POWER_SAVE_MODE_DISABLED
@ MMAGIC_POWER_SAVE_MODE_DISABLED
Power save disabled.
Definition: mmagic_controller.h:73
MMAGIC_SECURITY_TYPE_OPEN
@ MMAGIC_SECURITY_TYPE_OPEN
No security enabled at all.
Definition: mmagic_controller.h:57
MMAGIC_SECURITY_TYPE_SAE
@ MMAGIC_SECURITY_TYPE_SAE
Simultaneous Authentication of Equals (password-based authentication).
Definition: mmagic_controller.h:53
MMAGIC_SECURITY_TYPE_OWE
@ MMAGIC_SECURITY_TYPE_OWE
Opportunistic Wireless Encryption (encrypted, passwordless).
Definition: mmagic_controller.h:55
MMAGIC_MCS10_MODE_AUTO
@ MMAGIC_MCS10_MODE_AUTO
MCS10 is used on retries instead of MCS0 when the bandwidth is 1 MHz.
Definition: mmagic_controller.h:86
MMAGIC_MCS10_MODE_FORCED
@ MMAGIC_MCS10_MODE_FORCED
MCS10 is always used instead of MCS0 when the bandwidth is 1 MHz.
Definition: mmagic_controller.h:84
MMAGIC_MCS10_MODE_DISABLED
@ MMAGIC_MCS10_MODE_DISABLED
MCS10 is not used.
Definition: mmagic_controller.h:82
MMAGIC_STATUS_CHANNEL_LIST_NOT_SET
@ MMAGIC_STATUS_CHANNEL_LIST_NOT_SET
WLAN operation failed because the channel list has not been set.
Definition: mmagic_controller.h:133
MMAGIC_STATUS_NOT_FOUND
@ MMAGIC_STATUS_NOT_FOUND
Specified operation was not found.
Definition: mmagic_controller.h:123
MMAGIC_STATUS_MQTT_KEEPALIVE_TIMEOUT
@ MMAGIC_STATUS_MQTT_KEEPALIVE_TIMEOUT
Timed out while waiting for PINGRESP.
Definition: mmagic_controller.h:174
MMAGIC_STATUS_OK
@ MMAGIC_STATUS_OK
Operation was successful.
Definition: mmagic_controller.h:111
MMAGIC_STATUS_SOCKET_LISTEN_FAILED
@ MMAGIC_STATUS_SOCKET_LISTEN_FAILED
Socket listen failed.
Definition: mmagic_controller.h:151
MMAGIC_STATUS_TIMEOUT
@ MMAGIC_STATUS_TIMEOUT
The operation timed out.
Definition: mmagic_controller.h:119
MMAGIC_STATUS_SOCKET_BIND_FAILED
@ MMAGIC_STATUS_SOCKET_BIND_FAILED
Socket bind failed.
Definition: mmagic_controller.h:149
MMAGIC_STATUS_NO_LINK
@ MMAGIC_STATUS_NO_LINK
Operation failed because the link was not up.
Definition: mmagic_controller.h:141
MMAGIC_STATUS_TIME_NOT_SYNCHRONIZED
@ MMAGIC_STATUS_TIME_NOT_SYNCHRONIZED
Internal time has not been synchronized.
Definition: mmagic_controller.h:170
MMAGIC_STATUS_NOT_INITIALIZED
@ MMAGIC_STATUS_NOT_INITIALIZED
Operation failed because the MMWLAN subsystem was not initialized.
Definition: mmagic_controller.h:176
MMAGIC_STATUS_AUTHENTICATION_FAILED
@ MMAGIC_STATUS_AUTHENTICATION_FAILED
Credentials provided by the server were not valid.
Definition: mmagic_controller.h:164
MMAGIC_STATUS_MISSING_CREDENTIALS
@ MMAGIC_STATUS_MISSING_CREDENTIALS
Missing certificate or key to open TLS connection.
Definition: mmagic_controller.h:167
MMAGIC_STATUS_CHANNEL_INVALID
@ MMAGIC_STATUS_CHANNEL_INVALID
Attempted to tune to a channel that was not available.
Definition: mmagic_controller.h:137
MMAGIC_STATUS_ERROR
@ MMAGIC_STATUS_ERROR
The operation failed with an unspecified error.
Definition: mmagic_controller.h:113
MMAGIC_STATUS_NTP_KOD_RECEIVED
@ MMAGIC_STATUS_NTP_KOD_RECEIVED
NTP server returned Kiss-o'-Death.
Definition: mmagic_controller.h:153
MMAGIC_STATUS_NOT_SUPPORTED
@ MMAGIC_STATUS_NOT_SUPPORTED
Specified operation is not supported.
Definition: mmagic_controller.h:125
MMAGIC_STATUS_UNKNOWN_HOST
@ MMAGIC_STATUS_UNKNOWN_HOST
Failed to get an IP address for the given hostname.
Definition: mmagic_controller.h:143
MMAGIC_STATUS_TX_ERROR
@ MMAGIC_STATUS_TX_ERROR
An error occured during transmission.
Definition: mmagic_controller.h:127
MMAGIC_STATUS_SOCKET_SEND_FAILED
@ MMAGIC_STATUS_SOCKET_SEND_FAILED
Socket send failed.
Definition: mmagic_controller.h:157
MMAGIC_STATUS_INVALID_STREAM
@ MMAGIC_STATUS_INVALID_STREAM
An invalid stream was specified.
Definition: mmagic_controller.h:121
MMAGIC_STATUS_CLOSED
@ MMAGIC_STATUS_CLOSED
Failed due to stream being closed from the other side.
Definition: mmagic_controller.h:131
MMAGIC_STATUS_UNAVAILABLE
@ MMAGIC_STATUS_UNAVAILABLE
Functionality is temporarily unavailable.
Definition: mmagic_controller.h:117
MMAGIC_STATUS_MQTT_REFUSED
@ MMAGIC_STATUS_MQTT_REFUSED
The server refused a CONNECT or SUBSCRIBE.
Definition: mmagic_controller.h:172
MMAGIC_STATUS_SOCKET_CONNECT_FAILED
@ MMAGIC_STATUS_SOCKET_CONNECT_FAILED
Socket connection failed.
Definition: mmagic_controller.h:147
MMAGIC_STATUS_NOT_RUNNING
@ MMAGIC_STATUS_NOT_RUNNING
Operation failed because the WLAN device was not booted.
Definition: mmagic_controller.h:139
MMAGIC_STATUS_NO_MEM
@ MMAGIC_STATUS_NO_MEM
Failed due to memory allocation failure.
Definition: mmagic_controller.h:129
MMAGIC_STATUS_HANDSHAKE_FAILED
@ MMAGIC_STATUS_HANDSHAKE_FAILED
Error during TLS handshake.
Definition: mmagic_controller.h:162
MMAGIC_STATUS_NTP_KOD_BACKOFF_RECEIVED
@ MMAGIC_STATUS_NTP_KOD_BACKOFF_RECEIVED
NTP server returned Kiss-o'-Death with rate code.
Definition: mmagic_controller.h:155
MMAGIC_STATUS_SOCKET_FAILED
@ MMAGIC_STATUS_SOCKET_FAILED
Failed to open the socket.
Definition: mmagic_controller.h:145
MMAGIC_STATUS_INVALID_CREDENTIALS
@ MMAGIC_STATUS_INVALID_CREDENTIALS
Credentials provided were invalid.
Definition: mmagic_controller.h:160
MMAGIC_STATUS_SHUTDOWN_BLOCKED
@ MMAGIC_STATUS_SHUTDOWN_BLOCKED
WLAN shutdown failed.
Definition: mmagic_controller.h:135
MMAGIC_STATUS_INVALID_ARG
@ MMAGIC_STATUS_INVALID_ARG
The operation failed due to an invalid argument.
Definition: mmagic_controller.h:115
MMAGIC_STATUS_BAD_VERSION
@ MMAGIC_STATUS_BAD_VERSION
Operation failed due to a version mismatch.
Definition: mmagic_controller.h:178
MMAGIC_IPERF_MODE_TCP_CLIENT
@ MMAGIC_IPERF_MODE_TCP_CLIENT
Iperf TCP client (TX).
Definition: mmagic_controller.h:191
MMAGIC_IPERF_MODE_UDP_CLIENT
@ MMAGIC_IPERF_MODE_UDP_CLIENT
Iperf UDP client (TX).
Definition: mmagic_controller.h:189
MMAGIC_IPERF_MODE_TCP_SERVER
@ MMAGIC_IPERF_MODE_TCP_SERVER
Iperf TCP server (RX).
Definition: mmagic_controller.h:187
MMAGIC_IPERF_MODE_UDP_SERVER
@ MMAGIC_IPERF_MODE_UDP_SERVER
Iperf UDP server (RX).
Definition: mmagic_controller.h:185
MMAGIC_TLS
@ MMAGIC_TLS
Subsystem ID for Module tls: TLS support..
Definition: mmagic_controller.h:510
MMAGIC_WLAN
@ MMAGIC_WLAN
Subsystem ID for Module wlan: Wireless LAN management..
Definition: mmagic_controller.h:498
MMAGIC_IP
@ MMAGIC_IP
Subsystem ID for Module ip: IP Stack Management.
Definition: mmagic_controller.h:500
MMAGIC_IPERF
@ MMAGIC_IPERF
Subsystem ID for Module iperf: Iperf application..
Definition: mmagic_controller.h:504
MMAGIC_SYS
@ MMAGIC_SYS
Subsystem ID for Module sys: System management..
Definition: mmagic_controller.h:506
MMAGIC_TCP
@ MMAGIC_TCP
Subsystem ID for Module tcp: TCP Socket IO, supports secure connections using TLS....
Definition: mmagic_controller.h:508
MMAGIC_PING
@ MMAGIC_PING
Subsystem ID for Module ping: Ping application..
Definition: mmagic_controller.h:502
MMAGIC_NTP
@ MMAGIC_NTP
Subsystem ID for Module ntp: Network Time Protocol..
Definition: mmagic_controller.h:512
MMAGIC_MQTT
@ MMAGIC_MQTT
Subsystem ID for Module mqtt: MQTT agent..
Definition: mmagic_controller.h:514
MMAGIC_PMF_MODE_DISABLED
@ MMAGIC_PMF_MODE_DISABLED
No protected management frames.
Definition: mmagic_controller.h:66
MMAGIC_PMF_MODE_REQUIRED
@ MMAGIC_PMF_MODE_REQUIRED
Protected management frames must be used.
Definition: mmagic_controller.h:64
mmagic_controller_init
struct mmagic_controller * mmagic_controller_init(const struct mmagic_controller_init_args *args)
Initialize the Controller.
mmagic_controller_deinit
void mmagic_controller_deinit(struct mmagic_controller *controller)
Deinitialize the Controller.
mmagic_controller_agent_start_cb_t
void(* mmagic_controller_agent_start_cb_t)(struct mmagic_controller *controller, void *arg)
Prototype for callback function invoked whenever any time a event that the agent has started is recei...
Definition: mmagic_controller.h:539
CONTROL_STREAM
#define CONTROL_STREAM
The stream ID of the control stream.
Definition: mmagic_controller.h:585
mmagic_controller_rx
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)
Waits for a response from the agent.
mmagic_mqtt_cmd
mmagic_mqtt_cmd
mqtt configuration command IDs
Definition: mmagic_controller.h:1055
mmagic_ip_var
mmagic_ip_var
ip configuration variable IDs
Definition: mmagic_controller.h:824
mmagic_ping_cmd
mmagic_ping_cmd
ping configuration command IDs
Definition: mmagic_controller.h:905
mmagic_tcp_cmd
mmagic_tcp_cmd
tcp configuration command IDs
Definition: mmagic_controller.h:971
mmagic_wlan_var
mmagic_wlan_var
wlan configuration variable IDs
Definition: mmagic_controller.h:672
mmagic_iperf_cmd
mmagic_iperf_cmd
iperf configuration command IDs
Definition: mmagic_controller.h:937
mmagic_ntp_cmd
mmagic_ntp_cmd
ntp configuration command IDs
Definition: mmagic_controller.h:1038
mmagic_ping_var
mmagic_ping_var
ping configuration variable IDs
Definition: mmagic_controller.h:893
mmagic_iperf_var
mmagic_iperf_var
iperf configuration variable IDs
Definition: mmagic_controller.h:920
mmagic_wlan_cmd
mmagic_wlan_cmd
wlan configuration command IDs
Definition: mmagic_controller.h:768
mmagic_controller_agent_sync
enum mmagic_status mmagic_controller_agent_sync(struct mmagic_controller *controller, uint32_t timeout_ms)
Sends a sync request to the agent and waits for a sync response.
mmagic_tls_var
mmagic_tls_var
tls configuration variable IDs
Definition: mmagic_controller.h:1004
mmagic_controller_request_agent_reset
enum mmagic_status mmagic_controller_request_agent_reset(struct mmagic_controller *controller)
Sends a reset request to the agent.
mmagic_ntp_var
mmagic_ntp_var
ntp configuration variable IDs
Definition: mmagic_controller.h:1031
mmagic_controller_tx
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)
Sends a command to the agent.
mmagic_sys_cmd
mmagic_sys_cmd
sys configuration command IDs
Definition: mmagic_controller.h:952
MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS
#define MMAGIC_CONTROLLER_DEFAULT_RESPONSE_TIMEOUT_MS
The default timeout when waiting for a response from a command sent to the agent in ms.
Definition: mmagic_controller.h:588
mmagic_tls_cmd
mmagic_tls_cmd
tls configuration command IDs
Definition: mmagic_controller.h:1018
mmagic_ip_cmd
mmagic_ip_cmd
ip configuration command IDs
Definition: mmagic_controller.h:863
MMAGIC_MQTT_CMD_PUBLISH
@ MMAGIC_MQTT_CMD_PUBLISH
Publishes a message on a topic.
Definition: mmagic_controller.h:1069
MMAGIC_MQTT_CMD_COMMIT
@ MMAGIC_MQTT_CMD_COMMIT
Commit the current configuration to flash.
Definition: mmagic_controller.h:1063
MMAGIC_MQTT_CMD_START_AGENT
@ MMAGIC_MQTT_CMD_START_AGENT
Starts the MQTT agent.
Definition: mmagic_controller.h:1067
MMAGIC_MQTT_CMD_SET
@ MMAGIC_MQTT_CMD_SET
Set the value of a configuration variable.
Definition: mmagic_controller.h:1059
MMAGIC_MQTT_CMD_LOAD
@ MMAGIC_MQTT_CMD_LOAD
Reserved (unused)
Definition: mmagic_controller.h:1061
MMAGIC_MQTT_CMD_SUBSCRIBE
@ MMAGIC_MQTT_CMD_SUBSCRIBE
Subscribes to a topic.
Definition: mmagic_controller.h:1071
MMAGIC_MQTT_CMD_STOP_AGENT
@ MMAGIC_MQTT_CMD_STOP_AGENT
Stops the MQTT agent.
Definition: mmagic_controller.h:1073
MMAGIC_MQTT_CMD_GET
@ MMAGIC_MQTT_CMD_GET
Retrieve the value of a configuration variable.
Definition: mmagic_controller.h:1057
MMAGIC_IP_VAR_NETMASK
@ MMAGIC_IP_VAR_NETMASK
Netmask to use for a static network connection.
Definition: mmagic_controller.h:830
MMAGIC_IP_VAR_DNS_SERVER0
@ MMAGIC_IP_VAR_DNS_SERVER0
Primary DNS server IP address.
Definition: mmagic_controller.h:837
MMAGIC_IP_VAR_OFFLOAD_ARP_REFRESH_S
@ MMAGIC_IP_VAR_OFFLOAD_ARP_REFRESH_S
If non zero, enables ARP refresh offload with the specified interval in seconds.
Definition: mmagic_controller.h:858
MMAGIC_IP_VAR_DHCP_OFFLOAD
@ MMAGIC_IP_VAR_DHCP_OFFLOAD
If true, enables DHCP offload which allows the Morse chip to directly handle DHCP discovery and lease...
Definition: mmagic_controller.h:849
MMAGIC_IP_VAR_OFFLOAD_ARP_RESPONSE
@ MMAGIC_IP_VAR_OFFLOAD_ARP_RESPONSE
If true, enables ARP response offload which allows the Morse chip to directly respond to ARP requests...
Definition: mmagic_controller.h:855
MMAGIC_IP_VAR_IP_ADDR
@ MMAGIC_IP_VAR_IP_ADDR
IP address to use for a static network connection.
Definition: mmagic_controller.h:827
MMAGIC_IP_VAR_GATEWAY
@ MMAGIC_IP_VAR_GATEWAY
Gateway to use for a static network connection.
Definition: mmagic_controller.h:833
MMAGIC_IP_VAR_DHCP_ENABLED
@ MMAGIC_IP_VAR_DHCP_ENABLED
True to enable DHCP for IP address configuration, or false to use the static configuration given by i...
Definition: mmagic_controller.h:845
MMAGIC_IP_VAR_LINK_STATUS_EVT_EN
@ MMAGIC_IP_VAR_LINK_STATUS_EVT_EN
When set to true, IP link status notifications will be provided.
Definition: mmagic_controller.h:852
MMAGIC_IP_VAR_DNS_SERVER1
@ MMAGIC_IP_VAR_DNS_SERVER1
Secondary DNS server IP address.
Definition: mmagic_controller.h:841
MMAGIC_PING_CMD_RUN
@ MMAGIC_PING_CMD_RUN
Commences a ping session using the current values in the the subsystem config.
Definition: mmagic_controller.h:915
MMAGIC_PING_CMD_LOAD
@ MMAGIC_PING_CMD_LOAD
Reserved (unused)
Definition: mmagic_controller.h:911
MMAGIC_PING_CMD_SET
@ MMAGIC_PING_CMD_SET
Set the value of a configuration variable.
Definition: mmagic_controller.h:909
MMAGIC_PING_CMD_GET
@ MMAGIC_PING_CMD_GET
Retrieve the value of a configuration variable.
Definition: mmagic_controller.h:907
MMAGIC_PING_CMD_COMMIT
@ MMAGIC_PING_CMD_COMMIT
Commit the current configuration to flash.
Definition: mmagic_controller.h:913
MMAGIC_TCP_CMD_GET
@ MMAGIC_TCP_CMD_GET
Retrieve the value of a configuration variable.
Definition: mmagic_controller.h:973
MMAGIC_TCP_CMD_ACCEPT
@ MMAGIC_TCP_CMD_ACCEPT
Waits for an incoming socket connection and returns a new stream ID.
Definition: mmagic_controller.h:993
MMAGIC_TCP_CMD_COMMIT
@ MMAGIC_TCP_CMD_COMMIT
Commit the current configuration to flash.
Definition: mmagic_controller.h:979
MMAGIC_TCP_CMD_LOAD
@ MMAGIC_TCP_CMD_LOAD
Reserved (unused)
Definition: mmagic_controller.h:977
MMAGIC_TCP_CMD_SET
@ MMAGIC_TCP_CMD_SET
Set the value of a configuration variable.
Definition: mmagic_controller.h:975
MMAGIC_TCP_CMD_WRITE_POLL
@ MMAGIC_TCP_CMD_WRITE_POLL
Polls the socket till it is ready for writing.
Definition: mmagic_controller.h:991
MMAGIC_TCP_CMD_SET_RX_READY_EVT_ENABLED
@ MMAGIC_TCP_CMD_SET_RX_READY_EVT_ENABLED
Sets whether the RX ready event should be enabled for the given socket.
Definition: mmagic_controller.h:999
MMAGIC_TCP_CMD_READ_POLL
@ MMAGIC_TCP_CMD_READ_POLL
Polls the socket till it is ready for reading.
Definition: mmagic_controller.h:989
MMAGIC_TCP_CMD_BIND
@ MMAGIC_TCP_CMD_BIND
Opens a server TCP socket and returns its stream ID.
Definition: mmagic_controller.h:983
MMAGIC_TCP_CMD_SEND
@ MMAGIC_TCP_CMD_SEND
Writes to a socket.
Definition: mmagic_controller.h:987
MMAGIC_TCP_CMD_CONNECT
@ MMAGIC_TCP_CMD_CONNECT
Opens a client TCP socket and returns its stream ID.
Definition: mmagic_controller.h:981
MMAGIC_TCP_CMD_CLOSE
@ MMAGIC_TCP_CMD_CLOSE
Closes and frees the socket.
Definition: mmagic_controller.h:995
MMAGIC_TCP_CMD_RECV
@ MMAGIC_TCP_CMD_RECV
Reads from a socket.
Definition: mmagic_controller.h:985
MMAGIC_WLAN_VAR_BSSID
@ MMAGIC_WLAN_VAR_BSSID
BSSID of the ap to associate to, all 0x00 for any.
Definition: mmagic_controller.h:685
MMAGIC_WLAN_VAR_QOS_2_PARAMS
@ MMAGIC_WLAN_VAR_QOS_2_PARAMS
The default QoS queue configuration for Access Category 2 (AC_VI) that is active while the station is...
Definition: mmagic_controller.h:745
MMAGIC_WLAN_VAR_COUNTRY_CODE
@ MMAGIC_WLAN_VAR_COUNTRY_CODE
Two character country code used to identify the regulatory domain.
Definition: mmagic_controller.h:674
MMAGIC_WLAN_VAR_SECURITY
@ MMAGIC_WLAN_VAR_SECURITY
Security type to used when associating.
Definition: mmagic_controller.h:680
MMAGIC_WLAN_VAR_PASSWORD
@ MMAGIC_WLAN_VAR_PASSWORD
Password used when associating, 1-100 characters long.
Definition: mmagic_controller.h:678
MMAGIC_WLAN_VAR_QOS_1_PARAMS
@ MMAGIC_WLAN_VAR_QOS_1_PARAMS
The default QoS queue configuration for Access Category 1 (AC_BK) that is active while the station is...
Definition: mmagic_controller.h:739
MMAGIC_WLAN_VAR_PMF_MODE
@ MMAGIC_WLAN_VAR_PMF_MODE
Protected Management Frame mode to use (802.11w).
Definition: mmagic_controller.h:687
MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS
@ MMAGIC_WLAN_VAR_MAX_HEALTH_CHECK_INTVL_MS
The maximum interval to wait after the last health check before triggering another.
Definition: mmagic_controller.h:716
MMAGIC_WLAN_VAR_SGI_ENABLED
@ MMAGIC_WLAN_VAR_SGI_ENABLED
Boolean value indicating whether SGI support should be enabled.
Definition: mmagic_controller.h:693
MMAGIC_WLAN_VAR_SUBBANDS_ENABLED
@ MMAGIC_WLAN_VAR_SUBBANDS_ENABLED
Boolean value indicating whether sub-band support should be enabled.
Definition: mmagic_controller.h:695
MMAGIC_WLAN_VAR_RAW_PRIORITY
@ MMAGIC_WLAN_VAR_RAW_PRIORITY
Priority to request if raw is supported by the AP.
Definition: mmagic_controller.h:683
MMAGIC_WLAN_VAR_STATION_TYPE
@ MMAGIC_WLAN_VAR_STATION_TYPE
S1G non-AP STA type.
Definition: mmagic_controller.h:689
MMAGIC_WLAN_VAR_MCS10_MODE
@ MMAGIC_WLAN_VAR_MCS10_MODE
The currently configured MCS10 behavior.
Definition: mmagic_controller.h:756
MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD
@ MMAGIC_WLAN_VAR_FRAGMENT_THRESHOLD
Sets the 802.11 fragmentation threshold.
Definition: mmagic_controller.h:702
MMAGIC_WLAN_VAR_SSID
@ MMAGIC_WLAN_VAR_SSID
SSID of the AP to connect to, can be 1-32 characters long.
Definition: mmagic_controller.h:676
MMAGIC_WLAN_VAR_RTS_THRESHOLD
@ MMAGIC_WLAN_VAR_RTS_THRESHOLD
The RTS threshold (in octets) to set, or 0 to disable.
Definition: mmagic_controller.h:691
MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S
@ MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_LIMIT_S
The maximum interval between scan attempts when (re)connecting.
Definition: mmagic_controller.h:727
MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED
@ MMAGIC_WLAN_VAR_NDP_PROBE_ENABLED
Boolean value indicating whether NDP probe support should be enabled.
Definition: mmagic_controller.h:719
MMAGIC_WLAN_VAR_QOS_0_PARAMS
@ MMAGIC_WLAN_VAR_QOS_0_PARAMS
The default QoS queue configuration for Access Category 0 (AC_BE) that is active while the station is...
Definition: mmagic_controller.h:733
MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE
@ MMAGIC_WLAN_VAR_DUTY_CYCLE_MODE
The duty cycle air time distribution mode.
Definition: mmagic_controller.h:763
MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS
@ MMAGIC_WLAN_VAR_MIN_HEALTH_CHECK_INTVL_MS
The minimum interval to wait after the last health check before triggering another.
Definition: mmagic_controller.h:710
MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S
@ MMAGIC_WLAN_VAR_STA_SCAN_INTERVAL_BASE_S
The base scan interval (in seconds) to use when (re)connecting.
Definition: mmagic_controller.h:723
MMAGIC_WLAN_VAR_STA_EVT_EN
@ MMAGIC_WLAN_VAR_STA_EVT_EN
When set to true, STA event notifications will be provided.
Definition: mmagic_controller.h:759
MMAGIC_WLAN_VAR_CAC_ENABLED
@ MMAGIC_WLAN_VAR_CAC_ENABLED
Whether Centralized Authentication Controlled is enabled on the STA.
Definition: mmagic_controller.h:704
MMAGIC_WLAN_VAR_QOS_3_PARAMS
@ MMAGIC_WLAN_VAR_QOS_3_PARAMS
The default QoS queue configuration for Access Category 3 (AC_VO) that is active while the station is...
Definition: mmagic_controller.h:751
MMAGIC_WLAN_VAR_POWER_SAVE_MODE
@ MMAGIC_WLAN_VAR_POWER_SAVE_MODE
Sets the 802.11 power save mode.
Definition: mmagic_controller.h:699
MMAGIC_WLAN_VAR_AMPDU_ENABLED
@ MMAGIC_WLAN_VAR_AMPDU_ENABLED
Boolean value indicating whether AMPDU support should be enabled.
Definition: mmagic_controller.h:697
MMAGIC_IPERF_CMD_COMMIT
@ MMAGIC_IPERF_CMD_COMMIT
Commit the current configuration to flash.
Definition: mmagic_controller.h:945
MMAGIC_IPERF_CMD_GET
@ MMAGIC_IPERF_CMD_GET
Retrieve the value of a configuration variable.
Definition: mmagic_controller.h:939
MMAGIC_IPERF_CMD_RUN
@ MMAGIC_IPERF_CMD_RUN
Starts an iperf session using the current values in the the subsystem config.
Definition: mmagic_controller.h:947
MMAGIC_IPERF_CMD_SET
@ MMAGIC_IPERF_CMD_SET
Set the value of a configuration variable.
Definition: mmagic_controller.h:941
MMAGIC_IPERF_CMD_LOAD
@ MMAGIC_IPERF_CMD_LOAD
Reserved (unused)
Definition: mmagic_controller.h:943
MMAGIC_NTP_CMD_COMMIT
@ MMAGIC_NTP_CMD_COMMIT
Commit the current configuration to flash.
Definition: mmagic_controller.h:1046
MMAGIC_NTP_CMD_GET
@ MMAGIC_NTP_CMD_GET
Retrieve the value of a configuration variable.
Definition: mmagic_controller.h:1040
MMAGIC_NTP_CMD_SYNC
@ MMAGIC_NTP_CMD_SYNC
Synchronizes internal time using the NTP server.
Definition: mmagic_controller.h:1048
MMAGIC_NTP_CMD_LOAD
@ MMAGIC_NTP_CMD_LOAD
Reserved (unused)
Definition: mmagic_controller.h:1044
MMAGIC_NTP_CMD_SET
@ MMAGIC_NTP_CMD_SET
Set the value of a configuration variable.
Definition: mmagic_controller.h:1042
MMAGIC_NTP_CMD_GET_TIME
@ MMAGIC_NTP_CMD_GET_TIME
Reads current internal time.
Definition: mmagic_controller.h:1050
MMAGIC_PING_VAR_COUNT
@ MMAGIC_PING_VAR_COUNT
This specifies the number of ping requests to send before terminating the session.
Definition: mmagic_controller.h:900
MMAGIC_PING_VAR_TARGET
@ MMAGIC_PING_VAR_TARGET
The IP address of the ping target.
Definition: mmagic_controller.h:895
MMAGIC_PING_VAR_INTERVAL
@ MMAGIC_PING_VAR_INTERVAL
The time interval between ping requests (in milliseconds).
Definition: mmagic_controller.h:897
MMAGIC_IPERF_VAR_SERVER
@ MMAGIC_IPERF_VAR_SERVER
IP address of server to connect to when in client mode.
Definition: mmagic_controller.h:925
MMAGIC_IPERF_VAR_PORT
@ MMAGIC_IPERF_VAR_PORT
Specifies the local port to listen on when in server mode or the server port to send data to when in ...
Definition: mmagic_controller.h:928
MMAGIC_IPERF_VAR_MODE
@ MMAGIC_IPERF_VAR_MODE
The iperf mode to use.
Definition: mmagic_controller.h:923
MMAGIC_IPERF_VAR_AMOUNT
@ MMAGIC_IPERF_VAR_AMOUNT
This specifies the duration for client transfers specified either in seconds or bytes.
Definition: mmagic_controller.h:932
MMAGIC_WLAN_CMD_LOAD
@ MMAGIC_WLAN_CMD_LOAD
Reserved (unused)
Definition: mmagic_controller.h:774
MMAGIC_WLAN_CMD_GET_MAC_ADDR
@ MMAGIC_WLAN_CMD_GET_MAC_ADDR
Retrieves the MAC address if the WLAN interface is up.
Definition: mmagic_controller.h:786
MMAGIC_WLAN_CMD_STANDBY_ENTER
@ MMAGIC_WLAN_CMD_STANDBY_ENTER
This puts the Morse chip into standby mode allowing the host processor to go to sleep while the Morse...
Definition: mmagic_controller.h:797
MMAGIC_WLAN_CMD_GET_STA_STATUS
@ MMAGIC_WLAN_CMD_GET_STA_STATUS
Retrieves the STA status of the WLAN interface.
Definition: mmagic_controller.h:819
MMAGIC_WLAN_CMD_BEACON_MONITOR_ENABLE
@ MMAGIC_WLAN_CMD_BEACON_MONITOR_ENABLE
Enable beacon monitoring with the given filter settings.
Definition: mmagic_controller.h:791
MMAGIC_WLAN_CMD_BEACON_MONITOR_DISABLE
@ MMAGIC_WLAN_CMD_BEACON_MONITOR_DISABLE
Disable beacon monitoring.
Definition: mmagic_controller.h:793
MMAGIC_WLAN_CMD_GET_RSSI
@ MMAGIC_WLAN_CMD_GET_RSSI
Retrieves the RSSI if the WLAN interface is up, else 0.
Definition: mmagic_controller.h:784
MMAGIC_WLAN_CMD_STANDBY_SET_STATUS_PAYLOAD
@ MMAGIC_WLAN_CMD_STANDBY_SET_STATUS_PAYLOAD
Sets the user payload for the standby status packet.
Definition: mmagic_controller.h:808
MMAGIC_WLAN_CMD_STANDBY_SET_WAKE_FILTER
@ MMAGIC_WLAN_CMD_STANDBY_SET_WAKE_FILTER
Configures the standby mode UDP wake packet filter.
Definition: mmagic_controller.h:814
MMAGIC_WLAN_CMD_STANDBY_SET_CONFIG
@ MMAGIC_WLAN_CMD_STANDBY_SET_CONFIG
Sets the standby mode configuration parameters.
Definition: mmagic_controller.h:817
MMAGIC_WLAN_CMD_WNM_SLEEP
@ MMAGIC_WLAN_CMD_WNM_SLEEP
Requests entry or exit from extended sleep (wnm sleep) if the WLAN interface is up.
Definition: mmagic_controller.h:788
MMAGIC_WLAN_CMD_COMMIT
@ MMAGIC_WLAN_CMD_COMMIT
Commit the current configuration to flash.
Definition: mmagic_controller.h:776
MMAGIC_WLAN_CMD_SET
@ MMAGIC_WLAN_CMD_SET
Set the value of a configuration variable.
Definition: mmagic_controller.h:772
MMAGIC_WLAN_CMD_GET
@ MMAGIC_WLAN_CMD_GET
Retrieve the value of a configuration variable.
Definition: mmagic_controller.h:770
MMAGIC_WLAN_CMD_DISCONNECT
@ MMAGIC_WLAN_CMD_DISCONNECT
Disconnects and brings down the WLAN interface.
Definition: mmagic_controller.h:780
MMAGIC_WLAN_CMD_SCAN
@ MMAGIC_WLAN_CMD_SCAN
Starts an undirected scan for available networks.
Definition: mmagic_controller.h:782
MMAGIC_WLAN_CMD_CONNECT
@ MMAGIC_WLAN_CMD_CONNECT
Brings up the WLAN interface and connects to the AP with configured parameters.
Definition: mmagic_controller.h:778
MMAGIC_WLAN_CMD_STANDBY_EXIT
@ MMAGIC_WLAN_CMD_STANDBY_EXIT
Forces the Morse chip to exit standby mode.
Definition: mmagic_controller.h:802
MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE
@ MMAGIC_TLS_VAR_ROOT_CA_CERTIFICATE
Root certificate authority certificate.
Definition: mmagic_controller.h:1007
MMAGIC_TLS_VAR_CLIENT_CERTIFICATE
@ MMAGIC_TLS_VAR_CLIENT_CERTIFICATE
Certificate to identify the client.
Definition: mmagic_controller.h:1010
MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY
@ MMAGIC_TLS_VAR_CLIENT_PRIVATE_KEY
Client private key.
Definition: mmagic_controller.h:1013
MMAGIC_NTP_VAR_SERVER
@ MMAGIC_NTP_VAR_SERVER
The hostname or IP of the NTP server.
Definition: mmagic_controller.h:1033
MMAGIC_SYS_CMD_DEEP_SLEEP
@ MMAGIC_SYS_CMD_DEEP_SLEEP
Enters deep sleep mode.
Definition: mmagic_controller.h:964
MMAGIC_SYS_CMD_GET
@ MMAGIC_SYS_CMD_GET
Retrieve the value of a configuration variable.
Definition: mmagic_controller.h:954
MMAGIC_SYS_CMD_RESET
@ MMAGIC_SYS_CMD_RESET
Performs a soft reset.
Definition: mmagic_controller.h:962
MMAGIC_SYS_CMD_SET
@ MMAGIC_SYS_CMD_SET
Set the value of a configuration variable.
Definition: mmagic_controller.h:956
MMAGIC_SYS_CMD_GET_VERSION
@ MMAGIC_SYS_CMD_GET_VERSION
Gets the device firmware and hardware versions.
Definition: mmagic_controller.h:966
MMAGIC_SYS_CMD_COMMIT
@ MMAGIC_SYS_CMD_COMMIT
Commit the current configuration to flash.
Definition: mmagic_controller.h:960
MMAGIC_SYS_CMD_LOAD
@ MMAGIC_SYS_CMD_LOAD
Reserved (unused)
Definition: mmagic_controller.h:958
MMAGIC_TLS_CMD_LOAD
@ MMAGIC_TLS_CMD_LOAD
Reserved (unused)
Definition: mmagic_controller.h:1024
MMAGIC_TLS_CMD_SET
@ MMAGIC_TLS_CMD_SET
Set the value of a configuration variable.
Definition: mmagic_controller.h:1022
MMAGIC_TLS_CMD_GET
@ MMAGIC_TLS_CMD_GET
Retrieve the value of a configuration variable.
Definition: mmagic_controller.h:1020
MMAGIC_TLS_CMD_COMMIT
@ MMAGIC_TLS_CMD_COMMIT
Commit the current configuration to flash.
Definition: mmagic_controller.h:1026
MMAGIC_IP_CMD_ENABLE_TCP_KEEPALIVE_OFFLOAD
@ MMAGIC_IP_CMD_ENABLE_TCP_KEEPALIVE_OFFLOAD
Enables sending periodic TCP keep-alive packets by the morse chip allowing the TCP connection to be m...
Definition: mmagic_controller.h:881
MMAGIC_IP_CMD_SET
@ MMAGIC_IP_CMD_SET
Set the value of a configuration variable.
Definition: mmagic_controller.h:867
MMAGIC_IP_CMD_DISABLE_TCP_KEEPALIVE_OFFLOAD
@ MMAGIC_IP_CMD_DISABLE_TCP_KEEPALIVE_OFFLOAD
Disables sending of TCP keepalive packets.
Definition: mmagic_controller.h:883
MMAGIC_IP_CMD_STATUS
@ MMAGIC_IP_CMD_STATUS
Gets the status of the IP stack.
Definition: mmagic_controller.h:873
MMAGIC_IP_CMD_LOAD
@ MMAGIC_IP_CMD_LOAD
Reserved (unused)
Definition: mmagic_controller.h:869
MMAGIC_IP_CMD_CLEAR_WHITELIST_FILTER
@ MMAGIC_IP_CMD_CLEAR_WHITELIST_FILTER
Clears any applied whitelist filters.
Definition: mmagic_controller.h:888
MMAGIC_IP_CMD_SET_WHITELIST_FILTER
@ MMAGIC_IP_CMD_SET_WHITELIST_FILTER
Sets the whitelist filter specifing which incoming packets can wake the system from standby mode.
Definition: mmagic_controller.h:886
MMAGIC_IP_CMD_GET
@ MMAGIC_IP_CMD_GET
Retrieve the value of a configuration variable.
Definition: mmagic_controller.h:865
MMAGIC_IP_CMD_RELOAD
@ MMAGIC_IP_CMD_RELOAD
Reloads the IP stack network configuration based on the current values in the subsystem config.
Definition: mmagic_controller.h:876
MMAGIC_IP_CMD_COMMIT
@ MMAGIC_IP_CMD_COMMIT
Commit the current configuration to flash.
Definition: mmagic_controller.h:871
mmagic_controller_set_iperf_amount
static enum mmagic_status mmagic_controller_set_iperf_amount(struct mmagic_controller *controller, int32_t var)
Sets amount setting for module iperf.
Definition: mmagic_controller.h:5757
mmagic_controller_set_iperf_server
static enum mmagic_status mmagic_controller_set_iperf_server(struct mmagic_controller *controller, struct struct_ip_addr *var)
Sets server setting for module iperf.
Definition: mmagic_controller.h:5603
mmagic_controller_get_iperf_server
static enum mmagic_status mmagic_controller_get_iperf_server(struct mmagic_controller *controller, struct struct_ip_addr *var)
Gets server setting for module iperf.
Definition: mmagic_controller.h:5566
mmagic_controller_set_iperf_mode
static enum mmagic_status mmagic_controller_set_iperf_mode(struct mmagic_controller *controller, enum mmagic_iperf_mode var)
Sets mode setting for module iperf.
Definition: mmagic_controller.h:5529
mmagic_controller_get_iperf_port
static enum mmagic_status mmagic_controller_get_iperf_port(struct mmagic_controller *controller, uint16_t *var)
Gets port setting for module iperf.
Definition: mmagic_controller.h:5641
mmagic_controller_set_iperf_port
static enum mmagic_status mmagic_controller_set_iperf_port(struct mmagic_controller *controller, uint16_t var)
Sets port setting for module iperf.
Definition: mmagic_controller.h:5679
mmagic_controller_iperf_commit_all
static enum mmagic_status mmagic_controller_iperf_commit_all(struct mmagic_controller *controller)
Saves all settings from persistent store.
Definition: mmagic_controller.h:5791
mmagic_controller_get_iperf_mode
static enum mmagic_status mmagic_controller_get_iperf_mode(struct mmagic_controller *controller, enum mmagic_iperf_mode *var)
Gets mode setting for module iperf.
Definition: mmagic_controller.h:5491
mmagic_controller_get_iperf_amount
static enum mmagic_status mmagic_controller_get_iperf_amount(struct mmagic_controller *controller, int32_t *var)
Gets amount setting for module iperf.
Definition: mmagic_controller.h:5718
mmagic_controller_iperf_run
static enum mmagic_status mmagic_controller_iperf_run(struct mmagic_controller *controller, struct mmagic_core_iperf_run_rsp_args *rsp_args)
Starts an iperf session using the current values in the the subsystem config.
Definition: mmagic_controller.h:5836
mmagic_controller_get_ip_ip_addr
static enum mmagic_status mmagic_controller_get_ip_ip_addr(struct mmagic_controller *controller, struct struct_ip_addr *var)
Gets ip_addr setting for module ip.
Definition: mmagic_controller.h:4065
mmagic_controller_get_ip_dhcp_enabled
static enum mmagic_status mmagic_controller_get_ip_dhcp_enabled(struct mmagic_controller *controller, bool *var)
Gets dhcp_enabled setting for module ip.
Definition: mmagic_controller.h:4450
mmagic_controller_get_ip_dhcp_offload
static enum mmagic_status mmagic_controller_get_ip_dhcp_offload(struct mmagic_controller *controller, bool *var)
Gets dhcp_offload setting for module ip.
Definition: mmagic_controller.h:4528
mmagic_controller_set_ip_dhcp_offload
static enum mmagic_status mmagic_controller_set_ip_dhcp_offload(struct mmagic_controller *controller, bool var)
Sets dhcp_offload setting for module ip.
Definition: mmagic_controller.h:4567
mmagic_controller_set_ip_dns_server1
static enum mmagic_status mmagic_controller_set_ip_dns_server1(struct mmagic_controller *controller, struct struct_ip_addr *var)
Sets dns_server1 setting for module ip.
Definition: mmagic_controller.h:4411
mmagic_controller_get_ip_offload_arp_response
static enum mmagic_status mmagic_controller_get_ip_offload_arp_response(struct mmagic_controller *controller, bool *var)
Gets offload_arp_response setting for module ip.
Definition: mmagic_controller.h:4681
mmagic_controller_get_ip_netmask
static enum mmagic_status mmagic_controller_get_ip_netmask(struct mmagic_controller *controller, struct struct_ip_addr *var)
Gets netmask setting for module ip.
Definition: mmagic_controller.h:4141
mmagic_controller_set_ip_link_status_evt_en
static enum mmagic_status mmagic_controller_set_ip_link_status_evt_en(struct mmagic_controller *controller, bool var)
Sets link_status_evt_en setting for module ip.
Definition: mmagic_controller.h:4643
mmagic_controller_set_ip_offload_arp_refresh_s
static enum mmagic_status mmagic_controller_set_ip_offload_arp_refresh_s(struct mmagic_controller *controller, uint32_t var)
Sets offload_arp_refresh_s setting for module ip.
Definition: mmagic_controller.h:4795
mmagic_controller_ip_commit_all
static enum mmagic_status mmagic_controller_ip_commit_all(struct mmagic_controller *controller)
Saves all settings from persistent store.
Definition: mmagic_controller.h:4829
mmagic_controller_get_ip_gateway
static enum mmagic_status mmagic_controller_get_ip_gateway(struct mmagic_controller *controller, struct struct_ip_addr *var)
Gets gateway setting for module ip.
Definition: mmagic_controller.h:4217
mmagic_controller_get_ip_link_status_evt_en
static enum mmagic_status mmagic_controller_get_ip_link_status_evt_en(struct mmagic_controller *controller, bool *var)
Gets link_status_evt_en setting for module ip.
Definition: mmagic_controller.h:4605
mmagic_controller_set_ip_netmask
static enum mmagic_status mmagic_controller_set_ip_netmask(struct mmagic_controller *controller, struct struct_ip_addr *var)
Sets netmask setting for module ip.
Definition: mmagic_controller.h:4179
mmagic_controller_set_ip_dhcp_enabled
static enum mmagic_status mmagic_controller_set_ip_dhcp_enabled(struct mmagic_controller *controller, bool var)
Sets dhcp_enabled setting for module ip.
Definition: mmagic_controller.h:4489
mmagic_controller_get_ip_offload_arp_refresh_s
static enum mmagic_status mmagic_controller_get_ip_offload_arp_refresh_s(struct mmagic_controller *controller, uint32_t *var)
Gets offload_arp_refresh_s setting for module ip.
Definition: mmagic_controller.h:4757
mmagic_controller_set_ip_offload_arp_response
static enum mmagic_status mmagic_controller_set_ip_offload_arp_response(struct mmagic_controller *controller, bool var)
Sets offload_arp_response setting for module ip.
Definition: mmagic_controller.h:4719
mmagic_controller_set_ip_ip_addr
static enum mmagic_status mmagic_controller_set_ip_ip_addr(struct mmagic_controller *controller, struct struct_ip_addr *var)
Sets ip_addr setting for module ip.
Definition: mmagic_controller.h:4103
mmagic_controller_get_ip_dns_server1
static enum mmagic_status mmagic_controller_get_ip_dns_server1(struct mmagic_controller *controller, struct struct_ip_addr *var)
Gets dns_server1 setting for module ip.
Definition: mmagic_controller.h:4372
mmagic_controller_set_ip_gateway
static enum mmagic_status mmagic_controller_set_ip_gateway(struct mmagic_controller *controller, struct struct_ip_addr *var)
Sets gateway setting for module ip.
Definition: mmagic_controller.h:4255
mmagic_controller_set_ip_dns_server0
static enum mmagic_status mmagic_controller_set_ip_dns_server0(struct mmagic_controller *controller, struct struct_ip_addr *var)
Sets dns_server0 setting for module ip.
Definition: mmagic_controller.h:4333
mmagic_controller_get_ip_dns_server0
static enum mmagic_status mmagic_controller_get_ip_dns_server0(struct mmagic_controller *controller, struct struct_ip_addr *var)
Gets dns_server0 setting for module ip.
Definition: mmagic_controller.h:4294
mmagic_controller_ip_clear_whitelist_filter
static enum mmagic_status mmagic_controller_ip_clear_whitelist_filter(struct mmagic_controller *controller)
Clears any applied whitelist filters.
Definition: mmagic_controller.h:5082
mmagic_controller_ip_disable_tcp_keepalive_offload
static enum mmagic_status mmagic_controller_ip_disable_tcp_keepalive_offload(struct mmagic_controller *controller)
Disables sending of TCP keepalive packets.
Definition: mmagic_controller.h:4988
mmagic_controller_ip_enable_tcp_keepalive_offload
static enum mmagic_status mmagic_controller_ip_enable_tcp_keepalive_offload(struct mmagic_controller *controller, struct mmagic_core_ip_enable_tcp_keepalive_offload_cmd_args *cmd_args)
Enables sending periodic TCP keep-alive packets by the morse chip allowing the TCP connection to be m...
Definition: mmagic_controller.h:4951
mmagic_controller_register_ip_link_status_handler
void mmagic_controller_register_ip_link_status_handler(struct mmagic_controller *controller, mmagic_ip_link_status_event_handler_t handler, void *arg)
Register a handler for the ip-link_status event.
mmagic_controller_ip_reload
static enum mmagic_status mmagic_controller_ip_reload(struct mmagic_controller *controller)
Reloads the IP stack network configuration based on the current values in the subsystem config.
Definition: mmagic_controller.h:4906
mmagic_ip_link_status_event_handler_t
void(* mmagic_ip_link_status_event_handler_t)(const struct mmagic_ip_link_status_event_args *event_args, void *arg)
Handler for the ip-link_status event.
Definition: mmagic_controller.h:5132
mmagic_controller_ip_status
static enum mmagic_status mmagic_controller_ip_status(struct mmagic_controller *controller, struct mmagic_core_ip_status_rsp_args *rsp_args)
Gets the status of the IP stack.
Definition: mmagic_controller.h:4874
mmagic_controller_ip_set_whitelist_filter
static enum mmagic_status mmagic_controller_ip_set_whitelist_filter(struct mmagic_controller *controller, struct mmagic_core_ip_set_whitelist_filter_cmd_args *cmd_args)
Sets the whitelist filter specifing which incoming packets can wake the system from standby mode.
Definition: mmagic_controller.h:5045
mmagic_mqtt_broker_connection_event_handler_t
void(* mmagic_mqtt_broker_connection_event_handler_t)(const struct mmagic_mqtt_broker_connection_event_args *event_args, void *arg)
Handler for the mqtt-broker_connection event.
Definition: mmagic_controller.h:7287
mmagic_controller_register_mqtt_broker_connection_handler
void mmagic_controller_register_mqtt_broker_connection_handler(struct mmagic_controller *controller, mmagic_mqtt_broker_connection_event_handler_t handler, void *arg)
Register a handler for the mqtt-broker_connection event.
mmagic_controller_register_mqtt_message_received_handler
void mmagic_controller_register_mqtt_message_received_handler(struct mmagic_controller *controller, mmagic_mqtt_message_received_event_handler_t handler, void *arg)
Register a handler for the mqtt-message_received event.
mmagic_controller_mqtt_stop_agent
static enum mmagic_status mmagic_controller_mqtt_stop_agent(struct mmagic_controller *controller, struct mmagic_core_mqtt_stop_agent_cmd_args *cmd_args)
Stops the MQTT agent.
Definition: mmagic_controller.h:7188
mmagic_mqtt_message_received_event_handler_t
void(* mmagic_mqtt_message_received_event_handler_t)(const struct mmagic_mqtt_message_received_event_args *event_args, void *arg)
Handler for the mqtt-message_received event.
Definition: mmagic_controller.h:7242
mmagic_controller_mqtt_publish
static enum mmagic_status mmagic_controller_mqtt_publish(struct mmagic_controller *controller, struct mmagic_core_mqtt_publish_cmd_args *cmd_args)
Publishes a message on a topic.
Definition: mmagic_controller.h:7094
mmagic_controller_mqtt_subscribe
static enum mmagic_status mmagic_controller_mqtt_subscribe(struct mmagic_controller *controller, struct mmagic_core_mqtt_subscribe_cmd_args *cmd_args)
Subscribes to a topic.
Definition: mmagic_controller.h:7143
mmagic_controller_mqtt_start_agent
static 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)
Starts the MQTT agent.
Definition: mmagic_controller.h:7042
mmagic_controller_ntp_commit_all
static enum mmagic_status mmagic_controller_ntp_commit_all(struct mmagic_controller *controller)
Saves all settings from persistent store.
Definition: mmagic_controller.h:6895
mmagic_controller_get_ntp_server
static enum mmagic_status mmagic_controller_get_ntp_server(struct mmagic_controller *controller, struct string254 *var)
Gets server setting for module ntp.
Definition: mmagic_controller.h:6816
mmagic_controller_set_ntp_server
static enum mmagic_status mmagic_controller_set_ntp_server(struct mmagic_controller *controller, const char *var)
Sets server setting for module ntp.
Definition: mmagic_controller.h:6853
mmagic_controller_ntp_sync
static enum mmagic_status mmagic_controller_ntp_sync(struct mmagic_controller *controller)
Synchronizes internal time using the NTP server.
Definition: mmagic_controller.h:6930
mmagic_controller_ntp_get_time
static enum mmagic_status mmagic_controller_ntp_get_time(struct mmagic_controller *controller, struct mmagic_core_ntp_get_time_rsp_args *rsp_args)
Reads current internal time.
Definition: mmagic_controller.h:6970
mmagic_controller_get_ping_target
static enum mmagic_status mmagic_controller_get_ping_target(struct mmagic_controller *controller, struct struct_ip_addr *var)
Gets target setting for module ping.
Definition: mmagic_controller.h:5177
mmagic_controller_get_ping_count
static enum mmagic_status mmagic_controller_get_ping_count(struct mmagic_controller *controller, uint32_t *var)
Gets count setting for module ping.
Definition: mmagic_controller.h:5326
mmagic_controller_set_ping_count
static enum mmagic_status mmagic_controller_set_ping_count(struct mmagic_controller *controller, uint32_t var)
Sets count setting for module ping.
Definition: mmagic_controller.h:5364
mmagic_controller_ping_commit_all
static enum mmagic_status mmagic_controller_ping_commit_all(struct mmagic_controller *controller)
Saves all settings from persistent store.
Definition: mmagic_controller.h:5398
mmagic_controller_set_ping_interval
static enum mmagic_status mmagic_controller_set_ping_interval(struct mmagic_controller *controller, uint32_t var)
Sets interval setting for module ping.
Definition: mmagic_controller.h:5288
mmagic_controller_get_ping_interval
static enum mmagic_status mmagic_controller_get_ping_interval(struct mmagic_controller *controller, uint32_t *var)
Gets interval setting for module ping.
Definition: mmagic_controller.h:5251
mmagic_controller_set_ping_target
static enum mmagic_status mmagic_controller_set_ping_target(struct mmagic_controller *controller, struct struct_ip_addr *var)
Sets target setting for module ping.
Definition: mmagic_controller.h:5214
mmagic_controller_ping_run
static enum mmagic_status mmagic_controller_ping_run(struct mmagic_controller *controller, struct mmagic_core_ping_run_rsp_args *rsp_args)
Commences a ping session using the current values in the the subsystem config.
Definition: mmagic_controller.h:5443
mmagic_controller_sys_deep_sleep
static enum mmagic_status mmagic_controller_sys_deep_sleep(struct mmagic_controller *controller, struct mmagic_core_sys_deep_sleep_cmd_args *cmd_args)
Enters deep sleep mode.
Definition: mmagic_controller.h:5899
mmagic_controller_sys_reset
static enum mmagic_status mmagic_controller_sys_reset(struct mmagic_controller *controller)
Performs a soft reset.
Definition: mmagic_controller.h:5875
mmagic_controller_sys_get_version
static enum mmagic_status mmagic_controller_sys_get_version(struct mmagic_controller *controller, struct mmagic_core_sys_get_version_rsp_args *rsp_args)
Gets the device firmware and hardware versions.
Definition: mmagic_controller.h:5946
mmagic_controller_tcp_connect
static enum mmagic_status mmagic_controller_tcp_connect(struct mmagic_controller *controller, struct mmagic_core_tcp_connect_cmd_args *cmd_args, struct mmagic_core_tcp_connect_rsp_args *rsp_args)
Opens a client TCP socket and returns its stream ID.
Definition: mmagic_controller.h:6012
mmagic_controller_tcp_accept
static enum mmagic_status mmagic_controller_tcp_accept(struct mmagic_controller *controller, struct mmagic_core_tcp_accept_cmd_args *cmd_args, struct mmagic_core_tcp_accept_rsp_args *rsp_args)
Waits for an incoming socket connection and returns a new stream ID.
Definition: mmagic_controller.h:6355
mmagic_controller_tcp_recv
static enum mmagic_status mmagic_controller_tcp_recv(struct mmagic_controller *controller, struct mmagic_core_tcp_recv_cmd_args *cmd_args, struct mmagic_core_tcp_recv_rsp_args *rsp_args)
Reads from a socket.
Definition: mmagic_controller.h:6128
mmagic_controller_register_tcp_rx_ready_handler
void mmagic_controller_register_tcp_rx_ready_handler(struct mmagic_controller *controller, mmagic_tcp_rx_ready_event_handler_t handler, void *arg)
Register a handler for the tcp-rx_ready event.
mmagic_controller_tcp_write_poll
static enum mmagic_status mmagic_controller_tcp_write_poll(struct mmagic_controller *controller, struct mmagic_core_tcp_write_poll_cmd_args *cmd_args)
Polls the socket till it is ready for writing.
Definition: mmagic_controller.h:6290
mmagic_controller_tcp_read_poll
static enum mmagic_status mmagic_controller_tcp_read_poll(struct mmagic_controller *controller, struct mmagic_core_tcp_read_poll_cmd_args *cmd_args)
Polls the socket till it is ready for reading.
Definition: mmagic_controller.h:6233
mmagic_tcp_rx_ready_event_handler_t
void(* mmagic_tcp_rx_ready_event_handler_t)(const struct mmagic_tcp_rx_ready_event_args *event_args, void *arg)
Handler for the tcp-rx_ready event.
Definition: mmagic_controller.h:6499
mmagic_controller_tcp_bind
static enum mmagic_status mmagic_controller_tcp_bind(struct mmagic_controller *controller, struct mmagic_core_tcp_bind_cmd_args *cmd_args, struct mmagic_core_tcp_bind_rsp_args *rsp_args)
Opens a server TCP socket and returns its stream ID.
Definition: mmagic_controller.h:6068
mmagic_controller_tcp_set_rx_ready_evt_enabled
static enum mmagic_status mmagic_controller_tcp_set_rx_ready_evt_enabled(struct mmagic_controller *controller, struct mmagic_core_tcp_set_rx_ready_evt_enabled_cmd_args *cmd_args)
Sets whether the RX ready event should be enabled for the given socket.
Definition: mmagic_controller.h:6449
mmagic_controller_tcp_send
static enum mmagic_status mmagic_controller_tcp_send(struct mmagic_controller *controller, struct mmagic_core_tcp_send_cmd_args *cmd_args)
Writes to a socket.
Definition: mmagic_controller.h:6186
mmagic_controller_tcp_close
static enum mmagic_status mmagic_controller_tcp_close(struct mmagic_controller *controller, struct mmagic_core_tcp_close_cmd_args *cmd_args)
Closes and frees the socket.
Definition: mmagic_controller.h:6401
mmagic_controller_set_tls_client_private_key
static enum mmagic_status mmagic_controller_set_tls_client_private_key(struct mmagic_controller *controller, struct raw1536 *var)
Sets client_private_key setting for module tls.
Definition: mmagic_controller.h:6732
mmagic_controller_tls_commit_all
static enum mmagic_status mmagic_controller_tls_commit_all(struct mmagic_controller *controller)
Saves all settings from persistent store.
Definition: mmagic_controller.h:6766
mmagic_controller_get_tls_client_certificate
static enum mmagic_status mmagic_controller_get_tls_client_certificate(struct mmagic_controller *controller, struct raw1536 *var)
Gets client_certificate setting for module tls.
Definition: mmagic_controller.h:6620
mmagic_controller_set_tls_root_ca_certificate
static enum mmagic_status mmagic_controller_set_tls_root_ca_certificate(struct mmagic_controller *controller, struct raw1536 *var)
Sets root_ca_certificate setting for module tls.
Definition: mmagic_controller.h:6582
mmagic_controller_set_tls_client_certificate
static enum mmagic_status mmagic_controller_set_tls_client_certificate(struct mmagic_controller *controller, struct raw1536 *var)
Sets client_certificate setting for module tls.
Definition: mmagic_controller.h:6658
mmagic_controller_get_tls_root_ca_certificate
static enum mmagic_status mmagic_controller_get_tls_root_ca_certificate(struct mmagic_controller *controller, struct raw1536 *var)
Gets root_ca_certificate setting for module tls.
Definition: mmagic_controller.h:6544
mmagic_controller_get_tls_client_private_key
static enum mmagic_status mmagic_controller_get_tls_client_private_key(struct mmagic_controller *controller, struct raw1536 *var)
Gets client_private_key setting for module tls.
Definition: mmagic_controller.h:6695
mmagic_controller_set_wlan_ampdu_enabled
static enum mmagic_status mmagic_controller_set_wlan_ampdu_enabled(struct mmagic_controller *controller, bool var)
Sets ampdu_enabled setting for module wlan.
Definition: mmagic_controller.h:1965
mmagic_controller_set_wlan_qos_1_params
static enum mmagic_status mmagic_controller_set_wlan_qos_1_params(struct mmagic_controller *controller, const char *var)
Sets qos_1_params setting for module wlan.
Definition: mmagic_controller.h:2755
mmagic_controller_get_wlan_sta_scan_interval_limit_s
static enum mmagic_status mmagic_controller_get_wlan_sta_scan_interval_limit_s(struct mmagic_controller *controller, uint16_t *var)
Gets sta_scan_interval_limit_s setting for module wlan.
Definition: mmagic_controller.h:2544
mmagic_controller_get_wlan_ampdu_enabled
static enum mmagic_status mmagic_controller_get_wlan_ampdu_enabled(struct mmagic_controller *controller, bool *var)
Gets ampdu_enabled setting for module wlan.
Definition: mmagic_controller.h:1928
mmagic_controller_set_wlan_max_health_check_intvl_ms
static enum mmagic_status mmagic_controller_set_wlan_max_health_check_intvl_ms(struct mmagic_controller *controller, uint32_t var)
Sets max_health_check_intvl_ms setting for module wlan.
Definition: mmagic_controller.h:2351
mmagic_controller_set_wlan_ssid
static enum mmagic_status mmagic_controller_set_wlan_ssid(struct mmagic_controller *controller, const char *var)
Sets ssid setting for module wlan.
Definition: mmagic_controller.h:1209
mmagic_controller_get_wlan_power_save_mode
static enum mmagic_status mmagic_controller_get_wlan_power_save_mode(struct mmagic_controller *controller, enum mmagic_power_save_mode *var)
Gets power_save_mode setting for module wlan.
Definition: mmagic_controller.h:2002
mmagic_controller_get_wlan_pmf_mode
static enum mmagic_status mmagic_controller_get_wlan_pmf_mode(struct mmagic_controller *controller, enum mmagic_pmf_mode *var)
Gets pmf_mode setting for module wlan.
Definition: mmagic_controller.h:1558
mmagic_controller_get_wlan_cac_enabled
static enum mmagic_status mmagic_controller_get_wlan_cac_enabled(struct mmagic_controller *controller, bool *var)
Gets cac_enabled setting for module wlan.
Definition: mmagic_controller.h:2152
mmagic_controller_set_wlan_password
static enum mmagic_status mmagic_controller_set_wlan_password(struct mmagic_controller *controller, const char *var)
Sets password setting for module wlan.
Definition: mmagic_controller.h:1291
mmagic_controller_get_wlan_qos_2_params
static enum mmagic_status mmagic_controller_get_wlan_qos_2_params(struct mmagic_controller *controller, struct string32 *var)
Gets qos_2_params setting for module wlan.
Definition: mmagic_controller.h:2804
mmagic_controller_set_wlan_min_health_check_intvl_ms
static enum mmagic_status mmagic_controller_set_wlan_min_health_check_intvl_ms(struct mmagic_controller *controller, uint32_t var)
Sets min_health_check_intvl_ms setting for module wlan.
Definition: mmagic_controller.h:2271
mmagic_controller_set_wlan_sta_scan_interval_base_s
static enum mmagic_status mmagic_controller_set_wlan_sta_scan_interval_base_s(struct mmagic_controller *controller, uint16_t var)
Sets sta_scan_interval_base_s setting for module wlan.
Definition: mmagic_controller.h:2505
mmagic_controller_set_wlan_bssid
static enum mmagic_status mmagic_controller_set_wlan_bssid(struct mmagic_controller *controller, struct struct_mac_addr *var)
Sets bssid setting for module wlan.
Definition: mmagic_controller.h:1521
mmagic_controller_get_wlan_security
static enum mmagic_status mmagic_controller_get_wlan_security(struct mmagic_controller *controller, enum mmagic_security_type *var)
Gets security setting for module wlan.
Definition: mmagic_controller.h:1336
mmagic_controller_set_wlan_qos_2_params
static enum mmagic_status mmagic_controller_set_wlan_qos_2_params(struct mmagic_controller *controller, const char *var)
Sets qos_2_params setting for module wlan.
Definition: mmagic_controller.h:2845
mmagic_controller_get_wlan_mcs10_mode
static enum mmagic_status mmagic_controller_get_wlan_mcs10_mode(struct mmagic_controller *controller, enum mmagic_mcs10_mode *var)
Gets mcs10_mode setting for module wlan.
Definition: mmagic_controller.h:2983
mmagic_controller_get_wlan_duty_cycle_mode
static enum mmagic_status mmagic_controller_get_wlan_duty_cycle_mode(struct mmagic_controller *controller, enum mmagic_duty_cycle_mode *var)
Gets duty_cycle_mode setting for module wlan.
Definition: mmagic_controller.h:3138
mmagic_controller_get_wlan_max_health_check_intvl_ms
static enum mmagic_status mmagic_controller_get_wlan_max_health_check_intvl_ms(struct mmagic_controller *controller, uint32_t *var)
Gets max_health_check_intvl_ms setting for module wlan.
Definition: mmagic_controller.h:2311
mmagic_controller_get_wlan_sta_scan_interval_base_s
static enum mmagic_status mmagic_controller_get_wlan_sta_scan_interval_base_s(struct mmagic_controller *controller, uint16_t *var)
Gets sta_scan_interval_base_s setting for module wlan.
Definition: mmagic_controller.h:2466
mmagic_controller_get_wlan_sta_evt_en
static enum mmagic_status mmagic_controller_get_wlan_sta_evt_en(struct mmagic_controller *controller, bool *var)
Gets sta_evt_en setting for module wlan.
Definition: mmagic_controller.h:3061
mmagic_controller_set_wlan_subbands_enabled
static enum mmagic_status mmagic_controller_set_wlan_subbands_enabled(struct mmagic_controller *controller, bool var)
Sets subbands_enabled setting for module wlan.
Definition: mmagic_controller.h:1891
mmagic_controller_set_wlan_pmf_mode
static enum mmagic_status mmagic_controller_set_wlan_pmf_mode(struct mmagic_controller *controller, enum mmagic_pmf_mode var)
Sets pmf_mode setting for module wlan.
Definition: mmagic_controller.h:1595
mmagic_controller_get_wlan_qos_3_params
static enum mmagic_status mmagic_controller_get_wlan_qos_3_params(struct mmagic_controller *controller, struct string32 *var)
Gets qos_3_params setting for module wlan.
Definition: mmagic_controller.h:2894
mmagic_controller_get_wlan_qos_1_params
static enum mmagic_status mmagic_controller_get_wlan_qos_1_params(struct mmagic_controller *controller, struct string32 *var)
Gets qos_1_params setting for module wlan.
Definition: mmagic_controller.h:2714
mmagic_controller_set_wlan_raw_priority
static enum mmagic_status mmagic_controller_set_wlan_raw_priority(struct mmagic_controller *controller, int16_t var)
Sets raw_priority setting for module wlan.
Definition: mmagic_controller.h:1447
mmagic_controller_get_wlan_station_type
static enum mmagic_status mmagic_controller_get_wlan_station_type(struct mmagic_controller *controller, enum mmagic_station_type *var)
Gets station_type setting for module wlan.
Definition: mmagic_controller.h:1632
mmagic_controller_get_wlan_ssid
static enum mmagic_status mmagic_controller_get_wlan_ssid(struct mmagic_controller *controller, struct string32 *var)
Gets ssid setting for module wlan.
Definition: mmagic_controller.h:1172
mmagic_controller_get_wlan_fragment_threshold
static enum mmagic_status mmagic_controller_get_wlan_fragment_threshold(struct mmagic_controller *controller, uint32_t *var)
Gets fragment_threshold setting for module wlan.
Definition: mmagic_controller.h:2077
mmagic_controller_set_wlan_qos_0_params
static enum mmagic_status mmagic_controller_set_wlan_qos_0_params(struct mmagic_controller *controller, const char *var)
Sets qos_0_params setting for module wlan.
Definition: mmagic_controller.h:2665
mmagic_controller_get_wlan_ndp_probe_enabled
static enum mmagic_status mmagic_controller_get_wlan_ndp_probe_enabled(struct mmagic_controller *controller, bool *var)
Gets ndp_probe_enabled setting for module wlan.
Definition: mmagic_controller.h:2389
mmagic_controller_set_wlan_sgi_enabled
static enum mmagic_status mmagic_controller_set_wlan_sgi_enabled(struct mmagic_controller *controller, bool var)
Sets sgi_enabled setting for module wlan.
Definition: mmagic_controller.h:1817
mmagic_controller_set_wlan_rts_threshold
static enum mmagic_status mmagic_controller_set_wlan_rts_threshold(struct mmagic_controller *controller, uint32_t var)
Sets rts_threshold setting for module wlan.
Definition: mmagic_controller.h:1743
mmagic_controller_set_wlan_sta_scan_interval_limit_s
static enum mmagic_status mmagic_controller_set_wlan_sta_scan_interval_limit_s(struct mmagic_controller *controller, uint16_t var)
Sets sta_scan_interval_limit_s setting for module wlan.
Definition: mmagic_controller.h:2583
mmagic_controller_set_wlan_duty_cycle_mode
static enum mmagic_status mmagic_controller_set_wlan_duty_cycle_mode(struct mmagic_controller *controller, enum mmagic_duty_cycle_mode var)
Sets duty_cycle_mode setting for module wlan.
Definition: mmagic_controller.h:3177
mmagic_controller_set_wlan_power_save_mode
static enum mmagic_status mmagic_controller_set_wlan_power_save_mode(struct mmagic_controller *controller, enum mmagic_power_save_mode var)
Sets power_save_mode setting for module wlan.
Definition: mmagic_controller.h:2039
mmagic_controller_set_wlan_ndp_probe_enabled
static enum mmagic_status mmagic_controller_set_wlan_ndp_probe_enabled(struct mmagic_controller *controller, bool var)
Sets ndp_probe_enabled setting for module wlan.
Definition: mmagic_controller.h:2427
mmagic_controller_get_wlan_raw_priority
static enum mmagic_status mmagic_controller_get_wlan_raw_priority(struct mmagic_controller *controller, int16_t *var)
Gets raw_priority setting for module wlan.
Definition: mmagic_controller.h:1410
mmagic_controller_set_wlan_cac_enabled
static enum mmagic_status mmagic_controller_set_wlan_cac_enabled(struct mmagic_controller *controller, bool var)
Sets cac_enabled setting for module wlan.
Definition: mmagic_controller.h:2189
mmagic_controller_get_wlan_qos_0_params
static enum mmagic_status mmagic_controller_get_wlan_qos_0_params(struct mmagic_controller *controller, struct string32 *var)
Gets qos_0_params setting for module wlan.
Definition: mmagic_controller.h:2624
mmagic_controller_set_wlan_fragment_threshold
static enum mmagic_status mmagic_controller_set_wlan_fragment_threshold(struct mmagic_controller *controller, uint32_t var)
Sets fragment_threshold setting for module wlan.
Definition: mmagic_controller.h:2115
mmagic_controller_wlan_commit_all
static enum mmagic_status mmagic_controller_wlan_commit_all(struct mmagic_controller *controller)
Saves all settings from persistent store.
Definition: mmagic_controller.h:3211
mmagic_controller_get_wlan_password
static enum mmagic_status mmagic_controller_get_wlan_password(struct mmagic_controller *controller, struct string100 *var)
Gets password setting for module wlan.
Definition: mmagic_controller.h:1254
mmagic_controller_set_wlan_mcs10_mode
static enum mmagic_status mmagic_controller_set_wlan_mcs10_mode(struct mmagic_controller *controller, enum mmagic_mcs10_mode var)
Sets mcs10_mode setting for module wlan.
Definition: mmagic_controller.h:3023
mmagic_controller_set_wlan_sta_evt_en
static enum mmagic_status mmagic_controller_set_wlan_sta_evt_en(struct mmagic_controller *controller, bool var)
Sets sta_evt_en setting for module wlan.
Definition: mmagic_controller.h:3099
mmagic_controller_get_wlan_rts_threshold
static enum mmagic_status mmagic_controller_get_wlan_rts_threshold(struct mmagic_controller *controller, uint32_t *var)
Gets rts_threshold setting for module wlan.
Definition: mmagic_controller.h:1706
mmagic_controller_get_wlan_country_code
static enum mmagic_status mmagic_controller_get_wlan_country_code(struct mmagic_controller *controller, struct struct_country_code *var)
Gets country_code setting for module wlan.
Definition: mmagic_controller.h:1098
mmagic_controller_get_wlan_sgi_enabled
static enum mmagic_status mmagic_controller_get_wlan_sgi_enabled(struct mmagic_controller *controller, bool *var)
Gets sgi_enabled setting for module wlan.
Definition: mmagic_controller.h:1780
mmagic_controller_get_wlan_bssid
static enum mmagic_status mmagic_controller_get_wlan_bssid(struct mmagic_controller *controller, struct struct_mac_addr *var)
Gets bssid setting for module wlan.
Definition: mmagic_controller.h:1484
mmagic_controller_get_wlan_min_health_check_intvl_ms
static enum mmagic_status mmagic_controller_get_wlan_min_health_check_intvl_ms(struct mmagic_controller *controller, uint32_t *var)
Gets min_health_check_intvl_ms setting for module wlan.
Definition: mmagic_controller.h:2230
mmagic_controller_get_wlan_subbands_enabled
static enum mmagic_status mmagic_controller_get_wlan_subbands_enabled(struct mmagic_controller *controller, bool *var)
Gets subbands_enabled setting for module wlan.
Definition: mmagic_controller.h:1854
mmagic_controller_set_wlan_station_type
static enum mmagic_status mmagic_controller_set_wlan_station_type(struct mmagic_controller *controller, enum mmagic_station_type var)
Sets station_type setting for module wlan.
Definition: mmagic_controller.h:1669
mmagic_controller_set_wlan_country_code
static enum mmagic_status mmagic_controller_set_wlan_country_code(struct mmagic_controller *controller, struct struct_country_code *var)
Sets country_code setting for module wlan.
Definition: mmagic_controller.h:1135
mmagic_controller_set_wlan_security
static enum mmagic_status mmagic_controller_set_wlan_security(struct mmagic_controller *controller, enum mmagic_security_type var)
Sets security setting for module wlan.
Definition: mmagic_controller.h:1373
mmagic_controller_set_wlan_qos_3_params
static enum mmagic_status mmagic_controller_set_wlan_qos_3_params(struct mmagic_controller *controller, const char *var)
Sets qos_3_params setting for module wlan.
Definition: mmagic_controller.h:2935
mmagic_controller_wlan_beacon_monitor_enable
static enum mmagic_status mmagic_controller_wlan_beacon_monitor_enable(struct mmagic_controller *controller, struct mmagic_core_wlan_beacon_monitor_enable_cmd_args *cmd_args)
Enable beacon monitoring with the given filter settings.
Definition: mmagic_controller.h:3555
mmagic_controller_wlan_standby_enter
static enum mmagic_status mmagic_controller_wlan_standby_enter(struct mmagic_controller *controller)
This puts the Morse chip into standby mode allowing the host processor to go to sleep while the Morse...
Definition: mmagic_controller.h:3630
mmagic_wlan_standby_exit_event_handler_t
void(* mmagic_wlan_standby_exit_event_handler_t)(const struct mmagic_wlan_standby_exit_event_args *event_args, void *arg)
Handler for the wlan-standby_exit event.
Definition: mmagic_controller.h:3976
mmagic_controller_wlan_get_rssi
static enum mmagic_status mmagic_controller_wlan_get_rssi(struct mmagic_controller *controller, struct mmagic_core_wlan_get_rssi_rsp_args *rsp_args)
Retrieves the RSSI if the WLAN interface is up, else 0.
Definition: mmagic_controller.h:3417
mmagic_controller_wlan_standby_exit
static enum mmagic_status mmagic_controller_wlan_standby_exit(struct mmagic_controller *controller)
Forces the Morse chip to exit standby mode.
Definition: mmagic_controller.h:3669
mmagic_controller_wlan_disconnect
static enum mmagic_status mmagic_controller_wlan_disconnect(struct mmagic_controller *controller)
Disconnects and brings down the WLAN interface.
Definition: mmagic_controller.h:3302
mmagic_controller_wlan_standby_set_config
static enum mmagic_status mmagic_controller_wlan_standby_set_config(struct mmagic_controller *controller, struct mmagic_core_wlan_standby_set_config_cmd_args *cmd_args)
Sets the standby mode configuration parameters.
Definition: mmagic_controller.h:3831
mmagic_controller_wlan_get_sta_status
static enum mmagic_status mmagic_controller_wlan_get_sta_status(struct mmagic_controller *controller, struct mmagic_core_wlan_get_sta_status_rsp_args *rsp_args)
Retrieves the STA status of the WLAN interface.
Definition: mmagic_controller.h:3878
mmagic_controller_wlan_wnm_sleep
static enum mmagic_status mmagic_controller_wlan_wnm_sleep(struct mmagic_controller *controller, struct mmagic_core_wlan_wnm_sleep_cmd_args *cmd_args)
Requests entry or exit from extended sleep (wnm sleep) if the WLAN interface is up.
Definition: mmagic_controller.h:3509
mmagic_controller_register_wlan_beacon_rx_handler
void mmagic_controller_register_wlan_beacon_rx_handler(struct mmagic_controller *controller, mmagic_wlan_beacon_rx_event_handler_t handler, void *arg)
Register a handler for the wlan-beacon_rx event.
mmagic_controller_wlan_get_mac_addr
static enum mmagic_status mmagic_controller_wlan_get_mac_addr(struct mmagic_controller *controller, struct mmagic_core_wlan_get_mac_addr_rsp_args *rsp_args)
Retrieves the MAC address if the WLAN interface is up.
Definition: mmagic_controller.h:3464
mmagic_controller_register_wlan_sta_event_handler
void mmagic_controller_register_wlan_sta_event_handler(struct mmagic_controller *controller, mmagic_wlan_sta_event_event_handler_t handler, void *arg)
Register a handler for the wlan-sta_event event.
mmagic_controller_wlan_beacon_monitor_disable
static enum mmagic_status mmagic_controller_wlan_beacon_monitor_disable(struct mmagic_controller *controller)
Disable beacon monitoring.
Definition: mmagic_controller.h:3592
mmagic_controller_wlan_connect
static enum mmagic_status mmagic_controller_wlan_connect(struct mmagic_controller *controller, struct mmagic_core_wlan_connect_cmd_args *cmd_args)
Brings up the WLAN interface and connects to the AP with configured parameters.
Definition: mmagic_controller.h:3255
mmagic_controller_wlan_standby_set_status_payload
static enum mmagic_status mmagic_controller_wlan_standby_set_status_payload(struct mmagic_controller *controller, struct mmagic_core_wlan_standby_set_status_payload_cmd_args *cmd_args)
Sets the user payload for the standby status packet.
Definition: mmagic_controller.h:3716
mmagic_controller_wlan_scan
static 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)
Starts an undirected scan for available networks.
Definition: mmagic_controller.h:3359
mmagic_controller_wlan_standby_set_wake_filter
static enum mmagic_status mmagic_controller_wlan_standby_set_wake_filter(struct mmagic_controller *controller, struct mmagic_core_wlan_standby_set_wake_filter_cmd_args *cmd_args)
Configures the standby mode UDP wake packet filter.
Definition: mmagic_controller.h:3767
mmagic_controller_register_wlan_standby_exit_handler
void mmagic_controller_register_wlan_standby_exit_handler(struct mmagic_controller *controller, mmagic_wlan_standby_exit_event_handler_t handler, void *arg)
Register a handler for the wlan-standby_exit event.
mmagic_wlan_sta_event_event_handler_t
void(* mmagic_wlan_sta_event_event_handler_t)(const struct mmagic_wlan_sta_event_event_args *event_args, void *arg)
Handler for the wlan-sta_event event.
Definition: mmagic_controller.h:4019
mmagic_wlan_beacon_rx_event_handler_t
void(* mmagic_wlan_beacon_rx_event_handler_t)(const struct mmagic_wlan_beacon_rx_event_args *event_args, void *arg)
Handler for the wlan-beacon_rx event.
Definition: mmagic_controller.h:3932
MM_PACKED
#define MM_PACKED
Macro for packed structs.
Definition: mmagic_controller.h:40
mmagic_controller_init_args
Initialization structure for mmagic_controller.
Definition: mmagic_controller.h:545
mmagic_controller_init_args::agent_start_cb
mmagic_controller_agent_start_cb_t agent_start_cb
Callback function to executed any time a event that the agent has started is received.
Definition: mmagic_controller.h:547
mmagic_controller_init_args::agent_start_arg
void * agent_start_arg
User argument that will be passed when the agent_start_cb is executed.
Definition: mmagic_controller.h:549
mmagic_core_ip_enable_tcp_keepalive_offload_cmd_args
Command arguments structure for ip_enable_tcp_keepalive_offload.
Definition: mmagic_controller.h:4931
mmagic_core_ip_enable_tcp_keepalive_offload_cmd_args::retry_count
uint8_t retry_count
The number of times to retry before giving up.
Definition: mmagic_controller.h:4935
mmagic_core_ip_enable_tcp_keepalive_offload_cmd_args::retry_interval_s
uint8_t retry_interval_s
The interval in seconds to wait between retries.
Definition: mmagic_controller.h:4937
mmagic_core_ip_enable_tcp_keepalive_offload_cmd_args::period_s
uint16_t period_s
Interval in seconds to send the keep-alive packets in.
Definition: mmagic_controller.h:4933
mmagic_core_ip_set_whitelist_filter_cmd_args
Command arguments structure for ip_set_whitelist_filter.
Definition: mmagic_controller.h:5019
mmagic_core_ip_set_whitelist_filter_cmd_args::src_port
uint16_t src_port
The source port to match, 0 for any.
Definition: mmagic_controller.h:5027
mmagic_core_ip_set_whitelist_filter_cmd_args::llc_protocol
uint16_t llc_protocol
The LLC protocol (or EtherType) to match - 0x0800 for IPv4 and 0x86DD for IPv6, 0 for any.
Definition: mmagic_controller.h:5034
mmagic_core_ip_set_whitelist_filter_cmd_args::dest_port
uint16_t dest_port
The destination port to match, 0 for any.
Definition: mmagic_controller.h:5029
mmagic_core_ip_set_whitelist_filter_cmd_args::ip_protocol
uint8_t ip_protocol
The IPv4 protocol number to match - 6 for TCP, 17 for UDP, 0 for any.
Definition: mmagic_controller.h:5031
mmagic_core_ip_status_rsp_args
Response arguments structure for ip_status.
Definition: mmagic_controller.h:4859
mmagic_core_iperf_run_rsp_args
Response arguments structure for iperf_run.
Definition: mmagic_controller.h:5821
mmagic_core_mqtt_publish_cmd_args
Command arguments structure for mqtt_publish.
Definition: mmagic_controller.h:7075
mmagic_core_mqtt_publish_cmd_args::stream_id
uint8_t stream_id
Stream ID of the MQTT connection.
Definition: mmagic_controller.h:7077
mmagic_core_mqtt_publish_cmd_args::qos
uint8_t qos
MQTT quality of service (0-2).
Definition: mmagic_controller.h:7083
mmagic_core_mqtt_start_agent_cmd_args
Command arguments structure for mqtt_start_agent.
Definition: mmagic_controller.h:7009
mmagic_core_mqtt_start_agent_cmd_args::secure
bool secure
Enables TLS for brokers that require it.
Definition: mmagic_controller.h:7019
mmagic_core_mqtt_start_agent_cmd_args::port
uint16_t port
Port of the broker to connect to.
Definition: mmagic_controller.h:7013
mmagic_core_mqtt_start_agent_rsp_args
Response arguments structure for mqtt_start_agent.
Definition: mmagic_controller.h:7024
mmagic_core_mqtt_start_agent_rsp_args::stream_id
uint8_t stream_id
Stream ID of the opened socket.
Definition: mmagic_controller.h:7026
mmagic_core_mqtt_stop_agent_cmd_args
Command arguments structure for mqtt_stop_agent.
Definition: mmagic_controller.h:7175
mmagic_core_mqtt_stop_agent_cmd_args::stream_id
uint8_t stream_id
Stream ID of the MQTT connection.
Definition: mmagic_controller.h:7177
mmagic_core_mqtt_subscribe_cmd_args
Command arguments structure for mqtt_subscribe.
Definition: mmagic_controller.h:7126
mmagic_core_mqtt_subscribe_cmd_args::qos
uint8_t qos
MQTT quality of service (0-2).
Definition: mmagic_controller.h:7132
mmagic_core_mqtt_subscribe_cmd_args::stream_id
uint8_t stream_id
Stream ID of the MQTT connection.
Definition: mmagic_controller.h:7128
mmagic_core_ntp_get_time_rsp_args
Response arguments structure for ntp_get_time.
Definition: mmagic_controller.h:6955
mmagic_core_ntp_get_time_rsp_args::timestamp
uint64_t timestamp
Current internal time (Seconds since epoch, UTC).
Definition: mmagic_controller.h:6957
mmagic_core_ping_run_rsp_args
Response arguments structure for ping_run.
Definition: mmagic_controller.h:5428
mmagic_core_sys_deep_sleep_cmd_args
Command arguments structure for sys_deep_sleep.
Definition: mmagic_controller.h:5886
mmagic_core_sys_deep_sleep_cmd_args::mode
enum mmagic_deep_sleep_mode mode
Deep sleep mode to enter.
Definition: mmagic_controller.h:5888
mmagic_core_sys_get_version_rsp_args
Response arguments structure for sys_get_version.
Definition: mmagic_controller.h:5931
mmagic_core_tcp_accept_cmd_args
Command arguments structure for tcp_accept.
Definition: mmagic_controller.h:6332
mmagic_core_tcp_accept_cmd_args::stream_id
uint8_t stream_id
Stream ID of the bound socket.
Definition: mmagic_controller.h:6334
mmagic_core_tcp_accept_rsp_args
Response arguments structure for tcp_accept.
Definition: mmagic_controller.h:6339
mmagic_core_tcp_accept_rsp_args::stream_id
uint8_t stream_id
Stream ID of the new incoming connection.
Definition: mmagic_controller.h:6341
mmagic_core_tcp_bind_cmd_args
Command arguments structure for tcp_bind.
Definition: mmagic_controller.h:6045
mmagic_core_tcp_bind_cmd_args::port
uint16_t port
TCP port to listen on.
Definition: mmagic_controller.h:6047
mmagic_core_tcp_bind_rsp_args
Response arguments structure for tcp_bind.
Definition: mmagic_controller.h:6052
mmagic_core_tcp_bind_rsp_args::stream_id
uint8_t stream_id
Stream ID of the opened socket.
Definition: mmagic_controller.h:6054
mmagic_core_tcp_close_cmd_args
Command arguments structure for tcp_close.
Definition: mmagic_controller.h:6388
mmagic_core_tcp_close_cmd_args::stream_id
uint8_t stream_id
Stream ID of the socket to close.
Definition: mmagic_controller.h:6390
mmagic_core_tcp_connect_cmd_args
Command arguments structure for tcp_connect.
Definition: mmagic_controller.h:5985
mmagic_core_tcp_connect_cmd_args::port
uint16_t port
TCP port to connect to.
Definition: mmagic_controller.h:5989
mmagic_core_tcp_connect_cmd_args::enable_tls
bool enable_tls
Enables TLS.
Definition: mmagic_controller.h:5991
mmagic_core_tcp_connect_rsp_args
Response arguments structure for tcp_connect.
Definition: mmagic_controller.h:5996
mmagic_core_tcp_connect_rsp_args::stream_id
uint8_t stream_id
Stream ID of the opened socket.
Definition: mmagic_controller.h:5998
mmagic_core_tcp_read_poll_cmd_args
Command arguments structure for tcp_read_poll.
Definition: mmagic_controller.h:6218
mmagic_core_tcp_read_poll_cmd_args::timeout
uint32_t timeout
Timeout in ms.
Definition: mmagic_controller.h:6222
mmagic_core_tcp_read_poll_cmd_args::stream_id
uint8_t stream_id
Stream ID of the socket to wait on.
Definition: mmagic_controller.h:6220
mmagic_core_tcp_recv_cmd_args
Command arguments structure for tcp_recv.
Definition: mmagic_controller.h:6101
mmagic_core_tcp_recv_cmd_args::timeout
uint32_t timeout
Timeout in ms.
Definition: mmagic_controller.h:6107
mmagic_core_tcp_recv_cmd_args::stream_id
uint8_t stream_id
Stream ID of the socket to receive from.
Definition: mmagic_controller.h:6103
mmagic_core_tcp_recv_cmd_args::len
uint16_t len
Maximum length of data.
Definition: mmagic_controller.h:6105
mmagic_core_tcp_recv_rsp_args
Response arguments structure for tcp_recv.
Definition: mmagic_controller.h:6112
mmagic_core_tcp_send_cmd_args
Command arguments structure for tcp_send.
Definition: mmagic_controller.h:6171
mmagic_core_tcp_send_cmd_args::stream_id
uint8_t stream_id
Stream ID of the socket to send on.
Definition: mmagic_controller.h:6173
mmagic_core_tcp_set_rx_ready_evt_enabled_cmd_args
Command arguments structure for tcp_set_rx_ready_evt_enabled.
Definition: mmagic_controller.h:6433
mmagic_core_tcp_set_rx_ready_evt_enabled_cmd_args::enabled
bool enabled
Whether the RX ready event should be enabled.
Definition: mmagic_controller.h:6437
mmagic_core_tcp_set_rx_ready_evt_enabled_cmd_args::stream_id
uint8_t stream_id
Stream ID of the socket to close.
Definition: mmagic_controller.h:6435
mmagic_core_tcp_write_poll_cmd_args
Command arguments structure for tcp_write_poll.
Definition: mmagic_controller.h:6275
mmagic_core_tcp_write_poll_cmd_args::stream_id
uint8_t stream_id
Stream ID of the socket to wait on.
Definition: mmagic_controller.h:6277
mmagic_core_tcp_write_poll_cmd_args::timeout
uint32_t timeout
Timeout in ms.
Definition: mmagic_controller.h:6279
mmagic_core_wlan_beacon_monitor_enable_cmd_args
Command arguments structure for wlan_beacon_monitor_enable.
Definition: mmagic_controller.h:3541
mmagic_core_wlan_connect_cmd_args
Command arguments structure for wlan_connect.
Definition: mmagic_controller.h:3241
mmagic_core_wlan_connect_cmd_args::timeout
uint32_t timeout
Duration in milliseconds to wait for connection establish, if connection does not get established an ...
Definition: mmagic_controller.h:3244
mmagic_core_wlan_get_mac_addr_rsp_args
Response arguments structure for wlan_get_mac_addr.
Definition: mmagic_controller.h:3449
mmagic_core_wlan_get_rssi_rsp_args
Response arguments structure for wlan_get_rssi.
Definition: mmagic_controller.h:3402
mmagic_core_wlan_get_rssi_rsp_args::rssi
int32_t rssi
The RSSI in dBm.
Definition: mmagic_controller.h:3404
mmagic_core_wlan_get_sta_status_rsp_args
Response arguments structure for wlan_get_sta_status.
Definition: mmagic_controller.h:3863
mmagic_core_wlan_get_sta_status_rsp_args::sta_status
enum mmagic_sta_state sta_status
The current STA status.
Definition: mmagic_controller.h:3865
mmagic_core_wlan_scan_cmd_args
Command arguments structure for wlan_scan.
Definition: mmagic_controller.h:3333
mmagic_core_wlan_scan_cmd_args::timeout
uint32_t timeout
Optional duration in milliseconds to wait for scan to complete, if scan does not complete by the time...
Definition: mmagic_controller.h:3338
mmagic_core_wlan_scan_rsp_args
Response arguments structure for wlan_scan.
Definition: mmagic_controller.h:3343
mmagic_core_wlan_standby_set_config_cmd_args
Command arguments structure for wlan_standby_set_config.
Definition: mmagic_controller.h:3799
mmagic_core_wlan_standby_set_config_cmd_args::snooze_max_s
uint32_t snooze_max_s
The maximum time in seconds to snooze for after increments (Default unlimited).
Definition: mmagic_controller.h:3819
mmagic_core_wlan_standby_set_config_cmd_args::bss_inactivity_s
uint32_t bss_inactivity_s
Deprecated.
Definition: mmagic_controller.h:3810
mmagic_core_wlan_standby_set_config_cmd_args::dst_port
uint16_t dst_port
Destination UDP Port for the standby status packets, also used the source port for outgoing UDP port ...
Definition: mmagic_controller.h:3808
mmagic_core_wlan_standby_set_config_cmd_args::snooze_period_s
uint32_t snooze_period_s
The interval in seconds to wake periodically from snooze mode and check for beacons.
Definition: mmagic_controller.h:3814
mmagic_core_wlan_standby_set_config_cmd_args::notify_period_s
uint32_t notify_period_s
Interval in seconds for transmitting Standby status packets (Default 15s).
Definition: mmagic_controller.h:3801
mmagic_core_wlan_standby_set_config_cmd_args::snooze_increment_s
uint32_t snooze_increment_s
The amount in seconds to increase successive snooze intervals.
Definition: mmagic_controller.h:3817
mmagic_core_wlan_standby_set_status_payload_cmd_args
Command arguments structure for wlan_standby_set_status_payload.
Definition: mmagic_controller.h:3700
mmagic_core_wlan_standby_set_wake_filter_cmd_args
Command arguments structure for wlan_standby_set_wake_filter.
Definition: mmagic_controller.h:3748
mmagic_core_wlan_standby_set_wake_filter_cmd_args::offset
uint32_t offset
Offset within wake packet payload to apply the filter.
Definition: mmagic_controller.h:3752
mmagic_core_wlan_wnm_sleep_cmd_args
Command arguments structure for wlan_wnm_sleep.
Definition: mmagic_controller.h:3496
mmagic_core_wlan_wnm_sleep_cmd_args::wnm_sleep_enabled
bool wnm_sleep_enabled
Boolean indicating whether WNM sleep is enabled.
Definition: mmagic_controller.h:3498
mmagic_ip_link_status_event_args
Event arguments structure for ip_link_status.
Definition: mmagic_controller.h:5113
mmagic_mqtt_broker_connection_event_args
Event arguments structure for mqtt_broker_connection.
Definition: mmagic_controller.h:7267
mmagic_mqtt_broker_connection_event_args::connection_state
enum mmagic_status connection_state
Current state of the connection to the broker.
Definition: mmagic_controller.h:7271
mmagic_mqtt_broker_connection_event_args::stream_id
uint8_t stream_id
Stream ID of the MQTT connection.
Definition: mmagic_controller.h:7269
mmagic_mqtt_message_received_event_args
Event arguments structure for mqtt_message_received.
Definition: mmagic_controller.h:7220
mmagic_mqtt_message_received_event_args::stream_id
uint8_t stream_id
Stream ID of the MQTT connection.
Definition: mmagic_controller.h:7222
mmagic_tcp_rx_ready_event_args
Event arguments structure for tcp_rx_ready.
Definition: mmagic_controller.h:6481
mmagic_tcp_rx_ready_event_args::stream_id
uint8_t stream_id
Stream ID of the TCP socket this applies to.
Definition: mmagic_controller.h:6483
mmagic_wlan_beacon_rx_event_args
Event arguments structure for wlan_beacon_rx.
Definition: mmagic_controller.h:3910
mmagic_wlan_sta_event_event_args
Event arguments structure for wlan_sta_event.
Definition: mmagic_controller.h:4001
mmagic_wlan_sta_event_event_args::event
enum mmagic_sta_event event
The reported WLAN STA evt.
Definition: mmagic_controller.h:4003
mmagic_wlan_standby_exit_event_args
Event arguments structure for wlan_standby_exit.
Definition: mmagic_controller.h:3957
mmagic_wlan_standby_exit_event_args::reason
enum mmagic_standby_mode_exit_reason reason
Reason why we exited standby mode.
Definition: mmagic_controller.h:3960
raw1536
Raw octet string type with maximum length of 1536.
Definition: mmagic_controller.h:322
raw1536::len
uint16_t len
Length of data.
Definition: mmagic_controller.h:324
raw255
Raw octet string type with maximum length of 255.
Definition: mmagic_controller.h:312
raw255::len
uint8_t len
Length of data.
Definition: mmagic_controller.h:314
string100
String type with maximum length of 100 (excluding null terminator).
Definition: mmagic_controller.h:292
string100::len
uint8_t len
Length of string contents (excluding null terminator).
Definition: mmagic_controller.h:294
string100::data
char data[100+1]
The string contents.
Definition: mmagic_controller.h:297
string254
String type with maximum length of 254 (excluding null terminator).
Definition: mmagic_controller.h:302
string254::len
uint8_t len
Length of string contents (excluding null terminator).
Definition: mmagic_controller.h:304
string254::data
char data[254+1]
The string contents.
Definition: mmagic_controller.h:307
string32
String type with maximum length of 32 (excluding null terminator).
Definition: mmagic_controller.h:282
string32::len
uint8_t len
Length of string contents (excluding null terminator).
Definition: mmagic_controller.h:284
string32::data
char data[32+1]
The string contents.
Definition: mmagic_controller.h:287
struct_buffer64
Generic 64 byte buffer.
Definition: mmagic_controller.h:485
struct_buffer64::len
uint8_t len
Length of data in the buffer.
Definition: mmagic_controller.h:489
struct_country_code
Data type to contain Two character country code (null-terminated) used to identify the regulatory dom...
Definition: mmagic_controller.h:340
struct_ip_addr
Data type for a string representation of an IP address.
Definition: mmagic_controller.h:421
struct_ip_status
Structure to contain the current IP status.
Definition: mmagic_controller.h:428
struct_ip_status::dhcp_enabled
bool dhcp_enabled
Whether or not dhcp is enabled.
Definition: mmagic_controller.h:432
struct_ip_status::link_state
enum mmagic_ip_link_state link_state
Current link state.
Definition: mmagic_controller.h:430
struct_iperf_status
Data structure to store iperf results.
Definition: mmagic_controller.h:466
struct_iperf_status::local_port
uint16_t local_port
Port number of the local device.
Definition: mmagic_controller.h:474
struct_iperf_status::bytes_transferred
uint64_t bytes_transferred
The number of bytes of data transferred during the iperf test.
Definition: mmagic_controller.h:476
struct_iperf_status::bandwidth_kbitpsec
uint32_t bandwidth_kbitpsec
The average throughput in kbps.
Definition: mmagic_controller.h:480
struct_iperf_status::remote_port
uint16_t remote_port
Port number of the remote device.
Definition: mmagic_controller.h:470
struct_iperf_status::duration_ms
uint32_t duration_ms
The duration of the iperf test in milliseconds.
Definition: mmagic_controller.h:478
struct_mac_addr
Data type to contain mac address byte array.
Definition: mmagic_controller.h:332
struct_oui_list
Data type to contain a list of three octet OUIs.
Definition: mmagic_controller.h:354
struct_oui_list::count
uint8_t count
The number of OUIs in the list.
Definition: mmagic_controller.h:356
struct_oui
Data type to contain a three octet OUI.
Definition: mmagic_controller.h:347
struct_ping_status
Data structure to store ping results.
Definition: mmagic_controller.h:447
struct_ping_status::min_time_ms
uint32_t min_time_ms
The minimum latency in ms between request sent and response received.
Definition: mmagic_controller.h:455
struct_ping_status::total_count
uint32_t total_count
Total number of requests sent.
Definition: mmagic_controller.h:451
struct_ping_status::session_id
uint16_t session_id
Stores non-zero session ID whilst ping session is running.
Definition: mmagic_controller.h:461
struct_ping_status::avg_time_ms
uint32_t avg_time_ms
The average latency in ms between request sent and response received.
Definition: mmagic_controller.h:457
struct_ping_status::recv_count
uint32_t recv_count
The number of ping responses received.
Definition: mmagic_controller.h:453
struct_ping_status::max_time_ms
uint32_t max_time_ms
The maximum latency in ms between request sent and response received.
Definition: mmagic_controller.h:459
struct_scan_result
Structure for holding a scan result.
Definition: mmagic_controller.h:363
struct_scan_result::received_ies_len
uint16_t received_ies_len
Length of the ies field in the received frame.
Definition: mmagic_controller.h:374
struct_scan_result::op_bw_mhz
uint8_t op_bw_mhz
Operating bandwidth, in MHz, of the access point.
Definition: mmagic_controller.h:384
struct_scan_result::capability_info
uint16_t capability_info
Value of the Capability Information field.
Definition: mmagic_controller.h:378
struct_scan_result::channel_freq_hz
uint32_t channel_freq_hz
Center frequency in Hz of the channel where the frame was received.
Definition: mmagic_controller.h:380
struct_scan_result::bw_mhz
uint8_t bw_mhz
Bandwidth, in MHz, where the frame was received.
Definition: mmagic_controller.h:382
struct_scan_result::rssi
int32_t rssi
RSSI of the AP in dBm.
Definition: mmagic_controller.h:369
struct_scan_result::beacon_interval
uint16_t beacon_interval
Value of the Beacon Interval field.
Definition: mmagic_controller.h:376
struct_scan_result::noise_dbm
int16_t noise_dbm
Background noise measured by the chip on the channel at the time the probe response was received.
Definition: mmagic_controller.h:387
struct_scan_result::tsf
uint64_t tsf
TSF timestamp in the Probe Response frame.
Definition: mmagic_controller.h:389
struct_scan_status
Structure for returning the scan status.
Definition: mmagic_controller.h:411
struct_scan_status::num
uint8_t num
Number of results retrieved.
Definition: mmagic_controller.h:415
struct_scan_status::results
struct struct_scan_result results[10]
Array of scan results.
Definition: mmagic_controller.h:413
struct_version_info
Structure for devise firmware and hardware versions.
Definition: mmagic_controller.h:394