megawifi.h

Go to the documentation of this file.

/************************************************************************/
#ifndef _MEGAWIFI_H_
#define _MEGAWIFI_H_

#include "16c550.h"
#include "mw-msg.h"
#include "lsd.h"

#if (MODULE_MEGAWIFI != 0)


#define MW_API_VERSION_MAJOR    1

#define MW_API_VERSION_MINOR    5

#define MW_COMMAND_TOUT_MS      1000

#define MW_CONNECT_TOUT_MS      10000

#define MW_HTTP_OPEN_TOUT_MS    10000

#define MW_SCAN_TOUT_MS         10000

#define MW_ASSOC_TOUT_MS        20000

#define MW_ASSOC_WAIT_SLEEP_MS  5000

#define MW_UPGRADE_TOUT_MS      180000

#define MW_STAT_POLL_MS         250

enum mw_err {
        MW_ERR_NONE = 0,                
        MW_ERR,                         
        MW_ERR_NOT_READY,               
        MW_ERR_BUFFER_TOO_SHORT,        
        MW_ERR_PARAM,                   
        MW_ERR_SEND,                    
        MW_ERR_RECV                     
};

enum mw_http_method {
    MW_HTTP_METHOD_GET = 0,    
    MW_HTTP_METHOD_POST,       
    MW_HTTP_METHOD_PUT,        
    MW_HTTP_METHOD_PATCH,      
    MW_HTTP_METHOD_DELETE,     
    MW_HTTP_METHOD_HEAD,       
    MW_HTTP_METHOD_NOTIFY,     
    MW_HTTP_METHOD_SUBSCRIBE,  
    MW_HTTP_METHOD_UNSUBSCRIBE,
    MW_HTTP_METHOD_OPTIONS,    
    MW_HTTP_METHOD_MAX,
};

#define MW__RESET       UART_MCR__OUT1  ///< Reset out.
#define MW__PRG         UART_MCR__OUT2  ///< Program out.
#define MW__PD          UART_MCR__DTR   ///< Power Down out.
#define MW__DAT         UART_MSR__DSR   ///< Data request in.


#define MW_SSID_MAXLEN          32

#define MW_PASS_MAXLEN          64

#define MW_NTP_POOL_MAXLEN      80

#define MW_NUM_CFG_SLOTS        3

#define MW_NUM_DNS_SERVERS      2

#define MW_FSM_QUEUE_LEN        8

#define MW_MAX_SOCK                     3

#define MW_CTRL_CH                      0

#define MW_HTTP_CH                      LSD_MAX_CH - 1

#define MW_CMD_MIN_BUFLEN       168

struct mw_ap_data {
        enum mw_security auth;  
        uint8_t channel;        
        int8_t rssi;            
        uint8_t ssid_len;       
        char *ssid;             
};

enum mw_if_type {
        MW_IF_STATION = 0,      
        MW_IF_SOFTAP,           
        MW_IF_MAX               
};

/************************************************************************/
int16_t mw_init(char *cmd_buf, uint16_t buf_len);

/************************************************************************/
static inline void mw_process(void)     {lsd_process();}

/************************************************************************/
void mw_cmd_data_cb_set(lsd_recv_cb cmd_recv_cb);

/************************************************************************/
enum mw_err mw_detect(uint8_t *major, uint8_t *minor, char **variant);

/************************************************************************/
enum mw_err mw_version_get(uint8_t version[3], char **variant);

/************************************************************************/
uint8_t *mw_bssid_get(enum mw_if_type interface_type);

/************************************************************************/
enum mw_err mw_default_cfg_set(void);

/************************************************************************/
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 mw_ap_cfg_get(uint8_t slot, char **ssid, char **pass,
                enum mw_phy_type *phy_type);

/************************************************************************/
enum mw_err mw_ip_cfg_set(uint8_t slot, const struct mw_ip_cfg *ip);

/************************************************************************/
enum mw_err mw_ip_cfg_get(uint8_t slot, struct mw_ip_cfg **ip);

/************************************************************************/
enum mw_err mw_wifi_adv_cfg_set(const struct mw_wifi_adv_cfg *wifi);

/************************************************************************/
struct mw_wifi_adv_cfg *mw_wifi_adv_cfg_get(void);

/************************************************************************/
enum mw_err mw_cfg_save(void);

/************************************************************************/
enum mw_err mw_ip_current(struct mw_ip_cfg **ip);

/************************************************************************/
int16_t mw_ap_scan(enum mw_phy_type phy_type, char **ap_data, uint8_t *aps);

/************************************************************************/
int16_t mw_ap_fill_next(const char *ap_data, uint16_t pos,
                struct mw_ap_data *apd, uint16_t data_len);

/************************************************************************/
enum mw_err mw_ap_assoc(uint8_t slot);

/************************************************************************/
enum mw_err mw_ap_assoc_wait(int16_t tout_frames);

/************************************************************************/
enum mw_err mw_def_ap_cfg(uint8_t slot);

/************************************************************************/
enum mw_err mw_ap_disassoc(void);

/************************************************************************/
int16_t mw_def_ap_cfg_get(void);

/************************************************************************/
enum mw_err mw_tcp_connect(uint8_t ch, const char *dst_addr,
                const char *dst_port, const char *src_port);

/************************************************************************/
enum mw_err mw_close(uint8_t ch);

#define mw_tcp_disconnect(ch)   mw_close(ch)

/************************************************************************/
enum mw_err mw_udp_set(uint8_t ch, const char *dst_addr, const char *dst_port,
                const char *src_port);

#define mw_udp_unset(ch)        mw_close(ch)

/************************************************************************/
enum mw_err mw_tcp_bind(uint8_t ch, uint16_t port);

/************************************************************************/
enum mw_err mw_sock_conn_wait(uint8_t ch, int16_t tout_frames);

/************************************************************************/
static inline enum lsd_status mw_recv(char *buf, int16_t len, void *ctx,
                lsd_recv_cb recv_cb)
{
        return lsd_recv(buf, len, ctx, recv_cb);
}

/************************************************************************/
static inline enum lsd_status mw_udp_reuse_recv(struct mw_reuse_payload *data,
                int16_t len, void *ctx, lsd_recv_cb recv_cb)
{
        return lsd_recv((char*)data, len, ctx, recv_cb);
}

/************************************************************************/
static inline enum lsd_status mw_udp_reuse_send(uint8_t ch,
                const struct mw_reuse_payload *data, int16_t len, void *ctx,
                lsd_send_cb send_cb)
{
        return lsd_send(ch, (const char*)data, len, ctx, send_cb);
}

/************************************************************************/
static inline enum lsd_status mw_send(uint8_t ch, const char *data, int16_t len,
                void *ctx, lsd_send_cb send_cb)
{
        return lsd_send(ch, data, len, ctx, send_cb);
}

/************************************************************************/
enum mw_err mw_recv_sync(uint8_t *ch, char *buf, int16_t *buf_len,
                int16_t tout_frames);

/************************************************************************/
enum mw_err mw_send_sync(uint8_t ch, const char *data, uint16_t len,
                int16_t tout_frames);

/************************************************************************/
union mw_msg_sys_stat *mw_sys_stat_get(void);

/************************************************************************/
enum mw_sock_stat mw_sock_stat_get(uint8_t ch);

/************************************************************************/
enum mw_err mw_sntp_cfg_set(const char *tz_str, const char *server[3]);

/************************************************************************/
enum mw_err mw_sntp_cfg_get(char **tz_str, char *server[3]);

/************************************************************************/
char *mw_date_time_get(uint32_t dt_bin[2]);

/************************************************************************/
enum mw_err mw_flash_id_get(uint8_t *man_id, uint16_t *dev_id);

/************************************************************************/
enum mw_err mw_flash_sector_erase(uint16_t sect);

/************************************************************************/
enum mw_err mw_flash_write(uint32_t addr, uint8_t *data, uint16_t data_len);

/************************************************************************/
uint8_t *mw_flash_read(uint32_t addr, uint16_t data_len);

/************************************************************************/
#define mw_module_reset()       do{uart_set_bits(MCR, MW__RESET);}while(0)

/************************************************************************/
#define mw_module_start()       do{uart_clr_bits(MCR, MW__RESET);}while(0)

/************************************************************************/
enum mw_err mw_gamertag_set(uint8_t slot, const struct mw_gamertag *gamertag);

/************************************************************************/
struct mw_gamertag *mw_gamertag_get(uint8_t slot);

/************************************************************************/
enum mw_err mw_log(const char *msg);

/************************************************************************/
enum mw_err mw_factory_settings(void);

/************************************************************************/
void mw_power_off(void);

/************************************************************************/
void mw_sleep(int16_t frames);

/************************************************************************/
enum mw_err mw_http_url_set(const char *url);

/************************************************************************/
enum mw_err mw_http_method_set(enum mw_http_method method);

/************************************************************************/
enum mw_err mw_http_header_add(const char *key, const char *value);

/************************************************************************/
enum mw_err mw_http_header_del(const char *key);

/************************************************************************/
enum mw_err mw_http_open(uint32_t content_len);

/************************************************************************/
int16_t mw_http_finish(uint32_t *content_len, int16_t tout_frames);

/************************************************************************/
uint32_t mw_http_cert_query(void);

/************************************************************************/
enum mw_err mw_http_cert_set(uint32_t cert_hash, const char *cert,
                uint16_t cert_len);

/************************************************************************/
int16_t mw_http_cleanup(void);

/************************************************************************/
char *mw_def_server_get(void);

/************************************************************************/
enum mw_err mw_def_server_set(const char *server_url);

/************************************************************************/
uint8_t *mw_hrng_get(uint16_t rnd_len);

/************************************************************************/
enum mw_err mw_ga_endpoint_set(const char *endpoint, const char *priv_key);

/************************************************************************/
enum mw_err mw_ga_key_value_add(const char **key, const char **value,
                uint16_t num_pairs);

/************************************************************************/
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 mw_fw_upgrade(const char *name);

/****** THE FOLLOWING COMMANDS ARE LOWER LEVEL AND USUALLY NOT NEEDED ******/

/************************************************************************/
static inline enum lsd_status mw_cmd_send(mw_cmd *cmd, void *ctx,
                lsd_send_cb send_cb)
{
        // Send data on control channel (0).
        return lsd_send(MW_CTRL_CH, cmd->packet, cmd->data_len + 4,
                        ctx, send_cb);
}

/************************************************************************/
static inline enum lsd_status mw_cmd_recv(mw_cmd *rep, void *ctx,
                lsd_recv_cb recv_cb) {
        return lsd_recv(rep->packet, sizeof(mw_cmd), ctx, recv_cb);
}

#endif // MODULE_MEGAWIFI

#endif /*_MEGAWIFI_H_*/