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"
 
#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  
#define MW__PRG     UART_MCR__OUT2  
#define MW__PD      UART_MCR__DTR   
#define MW__DAT     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(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 /*_MEGAWIFI_H_*/