megawifi.h

Go to the documentation of this file.

/************************************************************************/
 
#ifndef _MEGAWIFI_H_
#define _MEGAWIFI_H_
 
#if (MODULE_EVERDRIVE != 0)
        // use the everdrive uart 
        #include "ext/mw/ssf.h"
#else
        // use the default 16c550 uart
        #include "ext/mw/16c550.h"
#endif
#include "ext/mw/mw-msg.h"
#include "ext/mw/lsd.h"

#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_PING_TOUT_MS 30000
#define MW_STAT_POLL_MS         250
 
#if (MODULE_EVERDRIVE != 0)
        #define MW_BUFLEN       1436
#else
        #define MW_BUFLEN       1460
#endif

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__DTR   
#define MW__PRG   UART_MCR__RTS   
#define MW__DCD   UART_MSR__DSR   

#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(uint16_t *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_list_upgrades(uint8_t page, uint8_t size, uint8_t offset, char **listUpgrades, uint8_t *len, uint8_t *total);
 
/************************************************************************/
enum mw_err mw_fw_upgrade(const char *name);
 
/************************************************************************/
struct mw_ping_response *mw_ping(const char* domain, u8 retries);
 
/****** 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 /*_MEGAWIFI_H_*/