romdev-mcp 0.1.1

package/src/platforms/genesis/lib/sgdk/src/ext/mw/megawifi.c

@@ -0,0 +1,1501 @@
+/************************************************************************//**
+ * \brief MeGaWiFi API implementation.
+ *
+ * \author Jesus Alonso (doragasu)
+ * \author Juan Antonio (PaCHoN)
+ * \date 2025
+ *
+ * \note Module is not reentrant.
+ *
+ * \todo Missing a lot of integrity checks, also module should track used
+ *       channels, and is not currently doing it
+ ****************************************************************************/
+
+#include "config.h"
+#include "types.h"
+
+#include "string.h"
+#include "memory.h"
+#include "maths.h"
+#include "task.h"
+
+#if (MODULE_MEGAWIFI == 1)
+
+#include "ext/mw/megawifi.h"
+
+/// Remove compiler warnings when not using a function parameter
+#define UNUSED_PARAM(x)		(void)x
+
+// Should consider if console is PAL or NTSC
+
+#define MW_COMMAND_TOUT		MW_MS_TO_FRAMES(MW_COMMAND_TOUT_MS)
+#define MW_CONNECT_TOUT		MW_MS_TO_FRAMES(MW_CONNECT_TOUT_MS)
+#define MW_SCAN_TOUT		MW_MS_TO_FRAMES(MW_SCAN_TOUT_MS)
+#define MW_ASSOC_TOUT		MW_MS_TO_FRAMES(MW_ASSOC_TOUT_MS)
+#define MW_ASSOC_WAIT_SLEEP	MW_MS_TO_FRAMES(MW_ASSOC_WAIT_SLEEP_MS)
+#define MW_STAT_POLL_TOUT	MW_MS_TO_FRAMES(MW_STAT_POLL_MS)
+#define MW_HTTP_OPEN_TOUT	MW_MS_TO_FRAMES(MW_HTTP_OPEN_TOUT_MS)
+#define MW_UPGRADE_TOUT		MW_MS_TO_FRAMES(MW_UPGRADE_TOUT_MS)
+/*
+ * The module assumes that once started, sending always succeeds, but uses
+ * timers (when defined) for data reception.
+ */
+
+enum cmd_stat {
+	CMD_ERR_PROTO = -1,
+	CMD_ERR_TIMEOUT = 0,
+	CMD_OK = 1
+};
+
+struct recv_metadata {
+	uint16_t len;
+	uint8_t ch;
+};
+
+/// Data required by the module
+struct mw_data {
+	mw_cmd *cmd;
+	// TODO This callback is never set!
+	lsd_recv_cb cmd_data_cb;
+	uint16_t buf_len;
+	union {
+		uint8_t flags;
+		struct {
+			uint8_t mw_ready:1;
+		};
+	};
+} d = {};
+
+static uint16_t concat_strings(const char **str, uint8_t num_strs,
+		char *output, uint16_t max_len)
+{
+	uint16_t pos = 0;
+	int str_len;
+
+	for (uint8_t i = 0; i < num_strs; i++) {
+		if (!str[i]) {
+			return 0;
+		}
+		str_len = strlen(str[i]) + 1;
+		if ((pos + str_len) > max_len) {
+			return 0;
+		}
+		memcpy(output + pos, str[i], str_len);
+		pos += str_len;
+	}
+
+	return pos;
+}
+
+static uint16_t concat_kv_pairs(const char **key, const char **value,
+		uint8_t num_pairs, char *output, uint16_t max_len)
+{
+	uint16_t pos = 0;
+	int key_len, value_len;
+
+	for (uint8_t i = 0; i < num_pairs; i++) {
+		if (!key[i] || !value[i]) {
+			return 0;
+		}
+		key_len = strlen(key[i]) + 1;
+		value_len = strlen(value[i]) + 1;
+		if ((pos + key_len + value_len) > max_len) {
+			return 0;
+		}
+		memcpy(output + pos, key[i], key_len);
+		pos += key_len;
+		memcpy(output + pos, value[i], value_len);
+		pos += value_len;
+	}
+
+	return pos;
+}
+
+int16_t mw_init(uint16_t *cmd_buf, uint16_t buf_len)
+{
+	if (!cmd_buf || buf_len < MW_CMD_MIN_BUFLEN) {
+		return MW_ERR_BUFFER_TOO_SHORT;
+	}
+
+	memset(&d, 0, sizeof(struct mw_data));
+	d.cmd = (mw_cmd*)cmd_buf;
+	d.buf_len = buf_len;
+
+	lsd_init();
+
+	// Enable control channel
+	lsd_ch_enable(MW_CTRL_CH);
+
+	d.mw_ready = TRUE;
+
+	return MW_ERR_NONE;
+}
+
+static void cmd_send_cb(enum lsd_status err, void *ctx)
+{
+	UNUSED_PARAM(ctx);
+	UNUSED_PARAM(err);
+
+	// FIXME: Treat errors!
+	if (!err) {
+		// TODO: Do we always want to force a context switch
+		TSK_superPost(TRUE);
+	}
+}
+
+static void cmd_recv_cb(enum lsd_status err, uint8_t ch,
+		char *data, uint16_t len, void *ctx)
+{
+	UNUSED_PARAM(data);
+	struct recv_metadata *md = (struct recv_metadata*)ctx;
+
+	// FIXME: Treat errors!
+	if (!err) {
+		md->ch = ch;
+		md->len = len;
+		TSK_superPost(TRUE);
+	}
+}
+
+static enum mw_err mw_command(int16_t timeout_frames)
+{
+	struct recv_metadata md;
+	bool tout;
+	bool done = FALSE;
+
+	// Optimization: we do not wait until the command is sent
+	mw_cmd_send(d.cmd, NULL, NULL);
+
+	while (!done) {
+		mw_cmd_recv(d.cmd, &md, cmd_recv_cb);
+		tout = TSK_superPend(timeout_frames);
+		if (tout) {
+			return MW_ERR_RECV;
+		}
+		// We might receive network data while waiting
+		// for a command reply
+		if (MW_CTRL_CH == md.ch) {
+			if (d.cmd->cmd != MW_CMD_OK) {
+				return MW_ERR_RECV;
+			}
+			done = TRUE;
+		} else if (d.cmd_data_cb) {
+			d.cmd_data_cb(LSD_STAT_COMPLETE, md.ch,
+					(char*)d.cmd, md.len, NULL);
+		}
+	}
+
+	return MW_ERR_NONE;
+}
+
+static enum mw_err string_based_cmd(enum mw_command cmd, const char *payload,
+		int16_t timeout_frames)
+{
+	enum mw_err err;
+	int16_t len;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	if (!payload || !(len = strlen(payload))) {
+		return MW_ERR_PARAM;
+	}
+
+	d.cmd->cmd = cmd;
+	d.cmd->data_len = len + 1;
+	memcpy(d.cmd->data, payload, len + 1);
+	err = mw_command(timeout_frames);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_recv_sync(uint8_t *ch, char *buf, int16_t *buf_len,
+		int16_t tout_frames)
+{
+	struct recv_metadata md;
+	bool tout;
+
+	lsd_recv(buf, *buf_len, &md, cmd_recv_cb);
+	tout = TSK_superPend(tout_frames);
+	if (tout) {
+		return MW_ERR_RECV;
+	}
+
+	*ch = md.ch;
+	*buf_len = md.len;
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_send_sync(uint8_t ch, const char *data, uint16_t len,
+		int16_t tout_frames)
+{
+	uint16_t to_send;
+	int16_t tout;
+	uint16_t sent = 0;
+
+	while (sent < len) {
+		to_send = min(len - sent, d.buf_len);
+		lsd_send(ch, data + sent, to_send, NULL, cmd_send_cb);
+		tout = TSK_superPend(tout_frames);
+		if (tout) {
+			return MW_ERR_SEND;
+		}
+		sent += to_send;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_detect(uint8_t *major, uint8_t *minor, char **variant)
+{
+	int16_t retries = 5;
+	enum mw_err err;
+	uint8_t version[3];
+
+	do {
+		retries--;
+		err = mw_version_get(version, variant);
+	} while (err != MW_ERR_NONE && retries);
+
+	if (MW_ERR_NONE == err) {
+		if (major) {
+			*major = version[0];
+		}
+		if (minor) {
+			*minor = version[1];
+		}
+	}
+
+	return err;
+}
+
+enum mw_err mw_version_get(uint8_t version[3], char **variant)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_VERSION;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return err;
+	}
+	if (version) {
+		version[0] = d.cmd->data[0];
+		version[1] = d.cmd->data[1];
+		version[2] = d.cmd->data[2];
+	}
+	if (variant) {
+		// Version string is NULL terminated
+		*variant = (char*)(d.cmd->data + 3);
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_default_cfg_set(void)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_DEF_CFG_SET;
+	d.cmd->data_len = 4;
+	d.cmd->dw_data[0] = 0xFEAA5501;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_ap_cfg_set(uint8_t slot, const char *ssid, const char *pass,
+		 enum mw_phy_type phy_type)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+	if (!ssid) {
+		// At least SSID is required.
+		return MW_ERR_PARAM;
+	}
+	if (slot >= MW_NUM_CFG_SLOTS) {
+		return MW_ERR_PARAM;
+	}
+
+	d.cmd->cmd = MW_CMD_AP_CFG;
+	d.cmd->data_len = sizeof(struct mw_msg_ap_cfg);
+
+	memset(&d.cmd->ap_cfg, 0, sizeof(struct mw_msg_ap_cfg));
+	d.cmd->ap_cfg.cfg_num = slot;
+	d.cmd->ap_cfg.phy_type = phy_type;
+	// Note: *NOT* NULL terminated strings are allowed on cmd.ap_cfg.ssid
+	// and cmd.ap_cfg.pass
+	memcpy(d.cmd->ap_cfg.ssid, ssid, strnlen(ssid, MW_SSID_MAXLEN));
+	if (pass) {
+		memcpy(d.cmd->ap_cfg.pass, pass, strnlen(pass, MW_PASS_MAXLEN));
+	}
+
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_ap_cfg_get(uint8_t slot, char **ssid, char **pass,
+		enum mw_phy_type *phy_type)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+	if (slot >= MW_NUM_CFG_SLOTS) {
+		return MW_ERR_PARAM;
+	}
+
+	d.cmd->cmd = MW_CMD_AP_CFG_GET;
+	d.cmd->data_len = 1;
+	d.cmd->data[0] = slot;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	if (ssid) {
+		*ssid = d.cmd->ap_cfg.ssid;
+	}
+	if (pass) {
+		*pass = d.cmd->ap_cfg.pass;
+	}
+	if (phy_type) {
+		*phy_type = d.cmd->ap_cfg.phy_type;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_ip_cfg_set(uint8_t slot, const struct mw_ip_cfg *ip)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+	if (slot >= MW_NUM_CFG_SLOTS) {
+		return MW_ERR_PARAM;
+	}
+
+	d.cmd->cmd = MW_CMD_IP_CFG;
+	d.cmd->data_len = sizeof(struct mw_msg_ip_cfg);
+	d.cmd->ip_cfg.cfg_slot = slot;
+	d.cmd->ip_cfg.reserved[0] = 0;
+	d.cmd->ip_cfg.reserved[1] = 0;
+	d.cmd->ip_cfg.reserved[2] = 0;
+	d.cmd->ip_cfg.ip = *ip;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_ip_cfg_get(uint8_t slot, struct mw_ip_cfg **ip)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_IP_CFG_GET;
+	d.cmd->data_len = 1;
+	d.cmd->data[0] = slot;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	*ip = &d.cmd->ip_cfg.ip;
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_ip_current(struct mw_ip_cfg **ip)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_IP_CURRENT;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	*ip = &d.cmd->ip_cfg.ip;
+
+	return MW_ERR_NONE;
+}
+
+int16_t mw_ap_scan(enum mw_phy_type phy_type, char **ap_data, uint8_t *aps)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return -1;
+	}
+
+	d.cmd->cmd = MW_CMD_AP_SCAN;
+	d.cmd->data[0] = phy_type;
+	d.cmd->data_len = 1;
+	err = mw_command(MW_SCAN_TOUT);
+	if (err) {
+		return -1;
+	}
+
+	// Fill number of APs and skip it for the apData array
+	*aps = *d.cmd->data;
+	*ap_data = ((char*)d.cmd->data) + 1;
+
+	return d.cmd->data_len - 1;
+}
+
+int16_t mw_ap_fill_next(const char *ap_data, uint16_t pos,
+		struct mw_ap_data *apd, uint16_t data_len)
+{
+	if (pos >= data_len) {
+		return 0;	// End reached
+	}
+	if ((pos + ap_data[pos + 3] + 4) > data_len) {
+		return -1;
+	}
+	apd->auth = ap_data[pos++];
+	apd->channel = ap_data[pos++];
+	apd->rssi = ap_data[pos++];
+	apd->ssid_len = ap_data[pos++];
+	apd->ssid = (char*)ap_data + pos;
+
+	// Return updated position
+	return pos + apd->ssid_len;
+}
+
+enum mw_err mw_ap_assoc(uint8_t slot)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_AP_JOIN;
+	d.cmd->data_len = 1;
+	d.cmd->data[0] = slot;
+	err = mw_command(MW_ASSOC_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_ap_assoc_wait(int16_t tout_frames)
+{
+	union mw_msg_sys_stat *stat;
+
+	// Workaround: When the MW_CMD_AP_JOIN is run, module seems to freeze
+	// communications for ~3 seconds. This can cause mw_sys_stat_get() to
+	// timeout and this function to fail. Workaround this by sleeping
+	// before trying to poll module for status
+	mw_sleep(MW_ASSOC_WAIT_SLEEP);
+	while (tout_frames > 0) {
+		// FIXME: timing is not accurate because of the time this
+		// command gets to complete
+		stat = mw_sys_stat_get();
+		if (!stat) {
+			// Command failed
+			return MW_ERR_NOT_READY;
+		}
+		if (stat->sys_stat >= MW_ST_READY) {
+			return MW_ERR_NONE;
+		}
+		// Sleep for MW_STAT_POLL_TOUT frames
+		TSK_superPend(MW_STAT_POLL_TOUT);
+		tout_frames -= MW_STAT_POLL_TOUT;
+	}
+
+	return MW_ERR_NOT_READY;
+}
+
+enum mw_err mw_ap_disassoc(void)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_AP_LEAVE;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_def_ap_cfg(uint8_t slot)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->data_len = 1;
+	d.cmd->cmd = MW_CMD_DEF_AP_CFG;
+	d.cmd->data[0] = slot;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+int16_t mw_def_ap_cfg_get(void)
+{
+	enum mw_err err;
+
+	d.cmd->data_len = 0;
+	d.cmd->cmd = MW_CMD_DEF_AP_CFG_GET;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return -1;
+	}
+
+	return d.cmd->data[0];
+}
+
+static int16_t fill_addr(const char *dst_addr, const char *dst_port,
+		const char *src_port, struct mw_msg_in_addr *in_addr)
+{
+	// Zero structure data
+	memset(in_addr, 0, sizeof(struct mw_msg_in_addr));
+	in_addr->dst_addr[0] = '\0';
+	strcpy(in_addr->dst_port, dst_port);
+	if (src_port) {
+		strcpy(in_addr->src_port, src_port);
+	}
+	if (dst_addr && dst_port) {
+		strcpy(in_addr->dst_addr, dst_addr);
+		strcpy(in_addr->dst_port, dst_port);
+	}
+
+	// Length is the length of both ports, the channel and the address.
+	return 6 + 6 + 1 + strlen(in_addr->dst_addr) + 1;
+}
+
+enum mw_err mw_tcp_connect(uint8_t ch, const char *dst_addr,
+		const char *dst_port, const char *src_port)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+	if (ch > MW_MAX_SOCK) {
+		return MW_ERR_PARAM;
+	}
+
+	// Configure TCP socket
+	d.cmd->cmd = MW_CMD_TCP_CON;
+	d.cmd->data_len = fill_addr(dst_addr, dst_port, src_port,
+			&d.cmd->in_addr);
+	d.cmd->in_addr.channel = ch;
+	err = mw_command(MW_CONNECT_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	// Enable channel
+	lsd_ch_enable(ch);
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_close(uint8_t ch)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_CLOSE;
+	d.cmd->data_len = 1;
+	d.cmd->data[0] = ch;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	// Disable channel
+	lsd_ch_disable(ch);
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_tcp_bind(uint8_t ch, uint16_t port)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_TCP_BIND;
+	d.cmd->data_len = 7;
+	d.cmd->bind.reserved = 0;
+	d.cmd->bind.port = port;
+	d.cmd->bind.channel = ch;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	lsd_ch_enable(ch);
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_udp_set(uint8_t ch, const char *dst_addr, const char *dst_port,
+		const char *src_port)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+	if (ch > MW_MAX_SOCK) {
+		return MW_ERR_PARAM;
+	}
+
+	// Configure UDP socket
+	d.cmd->cmd = MW_CMD_UDP_SET;
+	d.cmd->data_len = fill_addr(dst_addr, dst_port, src_port,
+			&d.cmd->in_addr);
+	d.cmd->in_addr.channel = ch;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	// Enable channel
+	lsd_ch_enable(ch);
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_sock_conn_wait(uint8_t ch, int16_t tout_frames)
+{
+	enum mw_sock_stat stat;
+
+	while (tout_frames > 0) {
+		// FIXME: timing is not accurate because of the time this
+		// command gets to complete
+		stat = mw_sock_stat_get(ch);
+		if (stat < 0) {
+			// Command failed
+			return MW_ERR_NOT_READY;
+		}
+		if (stat >= MW_SOCK_TCP_EST) {
+			return MW_ERR_NONE;
+		}
+		// Sleep for MW_STAT_POLL_TOUT frames
+		TSK_superPend(MW_STAT_POLL_TOUT);
+		tout_frames -= MW_STAT_POLL_MS;
+	}
+
+	return MW_ERR_NOT_READY;
+}
+
+union mw_msg_sys_stat *mw_sys_stat_get(void)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return NULL;
+	}
+
+	d.cmd->cmd = MW_CMD_SYS_STAT;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return NULL;
+	}
+
+	return &d.cmd->sys_stat;
+}
+
+enum mw_sock_stat mw_sock_stat_get(uint8_t ch)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return -1;
+	}
+
+	d.cmd->cmd = MW_CMD_SOCK_STAT;
+	d.cmd->data_len = 1;
+	d.cmd->data[0] = ch;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return -1;
+	}
+
+	return d.cmd->data[0];
+}
+
+// TODO Check for overflows when copying server data.
+enum mw_err mw_sntp_cfg_set(const char *tz_str, const char *server[3])
+{
+	enum mw_err err;
+	int16_t offset;
+	int16_t len;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_SNTP_CFG;
+	offset = 1 + strlen(tz_str);
+	memcpy(d.cmd->data, tz_str, offset);
+
+	for (int16_t i = 0; i < 3 && server[i] && *server[i]; i++) {
+		len = 1 + strlen(server[i]);
+		memcpy(&d.cmd->data[offset], server[i], len);
+		offset += len;
+	}
+	d.cmd->data[offset++] = '\0';
+	d.cmd->data_len = offset;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+static int16_t tokens_get(const char *in, char *token[], int16_t token_max)
+{
+	int16_t i;
+	int16_t len;
+
+	token[0] = (char*)in;
+	for (i = 0; i < (token_max - 1) && *token[i]; i++) {
+		len = strlen(token[i]);
+		token[i + 1] = token[i] + len + 1;
+	}
+
+	if (*token[i]) {
+		i++;
+	}
+
+	return i;
+}
+
+enum mw_err mw_sntp_cfg_get(char **tz_str, char *server[3])
+{
+	enum mw_err err;
+	char *token[4] = {0};
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_SNTP_CFG_GET;
+	d.cmd->data_len = 0;
+
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	tokens_get((char*)d.cmd->data, token, 4);
+	*tz_str = token[0];
+	for (int16_t i = 0; i < 3; i++) {
+		server[i] = token[i + 1];
+	}
+
+	return MW_ERR_NONE;
+}
+
+char *mw_date_time_get(uint32_t dt_bin[2])
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return NULL;
+	}
+
+	d.cmd->cmd = MW_CMD_DATETIME;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return NULL;
+	}
+
+	if (dt_bin) {
+		dt_bin[0] = d.cmd->date_time.dt_bin[0];
+		dt_bin[1] = d.cmd->date_time.dt_bin[1];
+	}
+	// Set NULL termination of the string
+	d.cmd->data[d.cmd->data_len] = '\0';
+
+	return d.cmd->date_time.dt_str;
+}
+
+enum mw_err mw_flash_id_get(uint8_t *man_id, uint16_t *dev_id)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_FLASH_ID;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	if (man_id) {
+		*man_id = d.cmd->flash_id.manufacturer;
+	}
+	if (dev_id) {
+		*dev_id = d.cmd->flash_id.device;
+	}
+
+	return MW_ERR_NONE;
+}
+
+// sect = 0 corresponds to flash sector 0x80
+enum mw_err mw_flash_sector_erase(uint16_t sect)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_FLASH_ERASE;
+	d.cmd->data_len = sizeof(uint16_t);
+	d.cmd->fl_sect = sect;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+// Address 0 corresponds to flash address 0x80000
+enum mw_err mw_flash_write(uint32_t addr, uint8_t *data, uint16_t data_len)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_FLASH_WRITE;
+	d.cmd->data_len = data_len + sizeof(uint32_t);
+	d.cmd->fl_data.addr = addr;
+	memcpy(d.cmd->fl_data.data, data, data_len);
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+// Address 0 corresponds to flash address 0x80000
+uint8_t *mw_flash_read(uint32_t addr, uint16_t data_len)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready || data_len > d.buf_len) {
+		return NULL;
+	}
+
+	d.cmd->cmd = MW_CMD_FLASH_READ;
+	d.cmd->fl_range.addr = addr;
+	d.cmd->fl_range.len = data_len;
+	d.cmd->data_len = sizeof(struct mw_msg_flash_range);
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return NULL;
+	}
+
+	return d.cmd->data;
+}
+
+uint8_t *mw_hrng_get(uint16_t rnd_len) {
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return NULL;
+	}
+
+	d.cmd->cmd = MW_CMD_HRNG_GET;
+	d.cmd->data_len = sizeof(uint16_t);
+	d.cmd->rnd_len = rnd_len;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return NULL;
+	}
+
+	return d.cmd->data;
+}
+
+uint8_t *mw_bssid_get(enum mw_if_type interface_type)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready || interface_type >= MW_IF_MAX) {
+		return NULL;
+	}
+
+	d.cmd->cmd = MW_CMD_BSSID_GET;
+	d.cmd->data_len = 1;
+	d.cmd->data[0] = interface_type;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return NULL;
+	}
+
+	return d.cmd->data;
+}
+
+enum mw_err mw_gamertag_set(uint8_t slot, const struct mw_gamertag *gamertag)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_GAMERTAG_SET;
+	d.cmd->gamertag_set.slot = slot;
+	d.cmd->gamertag_set.reserved[0] = 0;
+	d.cmd->gamertag_set.reserved[1] = 0;
+	d.cmd->gamertag_set.reserved[2] = 0;
+	d.cmd->data_len = sizeof(struct mw_gamertag_set_msg);
+	memcpy(&d.cmd->gamertag_set.gamertag, gamertag,
+			sizeof(struct mw_gamertag));
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+struct mw_gamertag *mw_gamertag_get(uint8_t slot)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return NULL;
+	}
+
+	d.cmd->cmd = MW_CMD_GAMERTAG_GET;
+	d.cmd->data_len = 1;
+	d.cmd->data[0] = slot;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return NULL;
+	}
+
+	return &d.cmd->gamertag_get;
+}
+
+enum mw_err mw_http_url_set(const char *url)
+{
+	return string_based_cmd(MW_CMD_HTTP_URL_SET, url, MW_COMMAND_TOUT);
+}
+
+enum mw_err mw_http_method_set(enum mw_http_method method)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	if (method >= MW_HTTP_METHOD_MAX) {
+		return MW_ERR_PARAM;
+	}
+
+	d.cmd->cmd = MW_CMD_HTTP_METHOD_SET;
+	d.cmd->data_len = 1;
+	d.cmd->data[0] = method;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_http_header_add(const char *key, const char *value)
+{
+	int16_t key_len;
+	int16_t value_len;
+
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	if (!key || !value || !(key_len = strlen(key)) ||
+			!(value_len = strlen(value))) {
+		return MW_ERR_PARAM;
+	}
+
+	key_len++;
+	value_len++;
+	d.cmd->cmd = MW_CMD_HTTP_HDR_ADD;
+	d.cmd->data_len = key_len + value_len;
+	memcpy(d.cmd->data, key, key_len);
+	memcpy(d.cmd->data + key_len, value, value_len);
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_http_header_del(const char *key)
+{
+	return string_based_cmd(MW_CMD_HTTP_HDR_DEL, key, MW_COMMAND_TOUT);
+}
+
+enum mw_err mw_http_open(uint32_t content_len)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_HTTP_OPEN;
+	d.cmd->data_len = 4;
+	d.cmd->dw_data[0] = content_len;
+	err = mw_command(MW_HTTP_OPEN_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	lsd_ch_enable(MW_HTTP_CH);
+	return MW_ERR_NONE;
+}
+
+int16_t mw_http_finish(uint32_t *content_len, int16_t tout_frames)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	if (!content_len) {
+		return MW_ERR_PARAM;
+	}
+
+	d.cmd->cmd = MW_CMD_HTTP_FINISH;
+	d.cmd->data_len = 0;
+	err = mw_command(tout_frames);
+	if (err) {
+		return MW_ERR;
+	}
+
+	*content_len = d.cmd->dw_data[0];
+	return d.cmd->w_data[2];
+}
+
+uint32_t mw_http_cert_query(void)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return 0xFFFFFFFF;
+	}
+
+	d.cmd->cmd = MW_CMD_HTTP_CERT_QUERY;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return 0xFFFFFFF;
+	}
+
+	return d.cmd->dw_data[0];
+}
+
+enum mw_err mw_http_cert_set(uint32_t cert_hash, const char *cert,
+		uint16_t cert_len)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	if (cert_len && !cert) {
+		return MW_ERR_PARAM;
+	}
+	d.cmd->cmd = MW_CMD_HTTP_CERT_SET;
+	d.cmd->data_len = 6;
+	d.cmd->dw_data[0] = cert_hash;
+	d.cmd->w_data[2] = cert_len;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	lsd_ch_enable(MW_HTTP_CH);
+	// Command succeeded, now send the certificate using MW_CH_HTTP
+	err = mw_send_sync(MW_HTTP_CH, cert, cert_len, TSK_PEND_FOREVER);
+	lsd_ch_disable(MW_HTTP_CH);
+
+	return MW_ERR_NONE;
+}
+
+int16_t mw_http_cleanup(void)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_HTTP_FINISH;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	lsd_ch_disable(MW_HTTP_CH);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+char *mw_def_server_get(void)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return NULL;
+	}
+
+	d.cmd->cmd = MW_CMD_SERVER_URL_GET;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return NULL;
+	}
+
+	return (char*)d.cmd->data;
+}
+
+enum mw_err mw_def_server_set(const char *server_url)
+{
+	return string_based_cmd(MW_CMD_SERVER_URL_SET, server_url,
+			MW_COMMAND_TOUT);
+}
+
+enum mw_err mw_log(const char *msg)
+{
+	return string_based_cmd(MW_CMD_LOG, msg, MW_COMMAND_TOUT);
+}
+
+enum mw_err mw_factory_settings(void)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_FACTORY_RESET;
+	d.cmd->data_len = 0;
+
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+void mw_power_off(void)
+{
+	d.cmd->cmd = MW_CMD_SLEEP;
+	d.cmd->data_len = 0;
+
+	mw_cmd_send(d.cmd, NULL, NULL);
+}
+
+void mw_sleep(int16_t frames)
+{
+	TSK_superPend(frames);
+}
+
+enum mw_err mw_cfg_save(void)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_NV_CFG_SAVE;
+	d.cmd->data_len = 0;
+
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+struct mw_wifi_adv_cfg *mw_wifi_adv_cfg_get(void)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return NULL;
+	}
+
+	d.cmd->cmd = MW_CMD_WIFI_ADV_GET;
+	d.cmd->data_len = 0;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return NULL;
+	}
+
+	return &d.cmd->wifi_adv_cfg;
+}
+
+enum mw_err mw_wifi_adv_cfg_set(const struct mw_wifi_adv_cfg *wifi)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_WIFI_ADV_SET;
+	d.cmd->data_len = sizeof(struct mw_wifi_adv_cfg);
+	d.cmd->wifi_adv_cfg = *wifi;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_ga_endpoint_set(const char *endpoint, const char *priv_key)
+{
+	const char * strings[2] = {endpoint, priv_key};
+	enum mw_err err;
+	uint16_t pos;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	pos = concat_strings(strings, 2, (char*)d.cmd->data,
+			MW_CMD_MAX_BUFLEN - 1);
+
+	if (!pos) {
+		return MW_ERR_PARAM;
+	}
+
+	d.cmd->data[pos++] = '\0';
+	d.cmd->cmd = MW_CMD_GAME_ENDPOINT_SET;
+	d.cmd->data_len = pos;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_ga_key_value_add(const char **key, const char **value,
+		uint16_t num_pairs)
+{
+	uint16_t pos;
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	pos = concat_kv_pairs(key, value, num_pairs, (char*)d.cmd->data,
+			MW_CMD_MAX_BUFLEN - 1);
+	if (!pos && num_pairs) {
+		return MW_ERR_PARAM;
+	}
+
+	d.cmd->data[pos++] = '\0';
+	d.cmd->cmd = MW_CMD_GAME_KEYVAL_ADD;
+	d.cmd->data_len = pos;
+	err = mw_command(MW_COMMAND_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+int16_t mw_ga_request(enum mw_http_method method, const char **path,
+		uint8_t num_paths, const char **key, const char **value,
+		uint8_t num_kv_pairs, uint32_t *content_len,
+		int16_t tout_frames)
+{
+	enum mw_err err;
+	uint16_t pos;
+	uint16_t added;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	added = concat_strings(path, num_paths, d.cmd->ga_request.req,
+			MW_CMD_MAX_BUFLEN - 4);
+	if (!added) {
+		return MW_ERR_PARAM;
+	}
+
+	pos = added;
+	added = concat_kv_pairs(key, value, num_kv_pairs, d.cmd->ga_request.req + pos,
+			MW_CMD_MAX_BUFLEN - 4 - pos);
+	if (!added && num_kv_pairs) {
+		return MW_ERR_PARAM;
+	}
+	pos += added;
+	d.cmd->ga_request.req[pos++] = '\0';
+
+	d.cmd->ga_request.method = method;
+	d.cmd->ga_request.num_paths = num_paths;
+	d.cmd->ga_request.num_kv_pairs = num_kv_pairs;
+	d.cmd->cmd = MW_CMD_GAME_REQUEST;
+	d.cmd->data_len = pos + 3;
+	err = mw_command(tout_frames);
+	if (err) {
+		return MW_ERR;
+	}
+
+	lsd_ch_enable(MW_HTTP_CH);
+
+	*content_len = d.cmd->dw_data[0];
+	return d.cmd->w_data[2];
+}
+
+enum mw_err mw_fw_upgrade(const char *name)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_UPGRADE_PERFORM;
+	d.cmd->data_len = strlen(name) + 1;
+	memcpy(d.cmd->data, name, d.cmd->data_len);
+	err = mw_command(MW_UPGRADE_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	return MW_ERR_NONE;
+}
+
+enum mw_err mw_fw_list_upgrades(uint8_t page, uint8_t size, uint8_t offset, char **listUpgrades, uint8_t *len, uint8_t *total)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return MW_ERR_NOT_READY;
+	}
+
+	d.cmd->cmd = MW_CMD_UPGRADE_LIST;
+	d.cmd->data[0] = page;
+	d.cmd->data[1] = size;
+	d.cmd->data[2] = offset;
+	d.cmd->data_len = 3;
+	err = mw_command(MW_UPGRADE_TOUT);
+	if (err) {
+		return MW_ERR;
+	}
+
+	*listUpgrades = (char*)d.cmd->data+4;
+	*len = d.cmd->ug_list_response.len;
+	*total = d.cmd->ug_list_response.total;
+	return MW_ERR_NONE;
+}
+
+struct mw_ping_response *mw_ping(const char* domain, u8 retries)
+{
+	enum mw_err err;
+
+	if (!d.mw_ready) {
+		return NULL;
+	}
+
+	if (!domain) {
+		return NULL;
+	}
+
+	d.cmd->cmd = MW_CMD_PING;
+	d.cmd->data_len = sizeof(struct mw_ping_request);
+	strcpy(d.cmd->ping.domain, domain);
+	d.cmd->ping.retries = retries;
+	err = mw_command(MW_CONNECT_TOUT * retries);
+	if (err) {
+		return NULL;
+	}
+
+	return &d.cmd->ping_response;
+}
+
+#endif // MODULE_MEGAWIFI