cyw43.h

Go to the documentation of this file.

/*
 * This file is part of the cyw43-driver
 *
 * Copyright (C) 2019-2022 George Robotics Pty Ltd
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 * 3. Any redistribution, use, or modification in source or binary form is done
 *    solely for personal benefit and not for any commercial purpose or for
 *    monetary gain.
 *
 * THIS SOFTWARE IS PROVIDED BY THE LICENSOR AND COPYRIGHT OWNER "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE LICENSOR OR COPYRIGHT OWNER BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software is also available for use with certain devices under different
 * terms, as set out in the top level LICENSE file.  For commercial licensing
 * options please email contact@georgerobotics.com.au.
 */
 
#ifndef CYW43_INCLUDED_CYW43_H
#define CYW43_INCLUDED_CYW43_H
 
#include "cyw43_config.h"
 
#if CYW43_LWIP
#include "lwip/netif.h"
#include "lwip/dhcp.h"
#endif
 
#if CYW43_NETUTILS
#include "shared/netutils/dhcpserver.h"
#endif
 
#include "cyw43_ll.h"
#include <string.h>



#define CYW43_VERSION_MAJOR 1
#define CYW43_VERSION_MINOR 1
#define CYW43_VERSION_MICRO 0

#define CYW43_VERSION (CYW43_VERSION_MAJOR << 16 | CYW43_VERSION_MINOR << 8 | CYW43_VERSION_MICRO)

#define CYW43_TRACE_ASYNC_EV    (0x0001)
#define CYW43_TRACE_ETH_TX      (0x0002)
#define CYW43_TRACE_ETH_RX      (0x0004)
#define CYW43_TRACE_ETH_FULL    (0x0008)
#define CYW43_TRACE_MAC         (0x0010)

#define CYW43_LINK_DOWN         (0)     
#define CYW43_LINK_JOIN         (1)     
#define CYW43_LINK_NOIP         (2)     
#define CYW43_LINK_UP           (3)     
#define CYW43_LINK_FAIL         (-1)    
#define CYW43_LINK_NONET        (-2)    
#define CYW43_LINK_BADAUTH      (-3)    
 
typedef struct _cyw43_t {
    cyw43_ll_t cyw43_ll;
 
    uint8_t itf_state;
    uint32_t trace_flags;
 
    // State for async events
    volatile uint32_t wifi_scan_state;
    uint32_t wifi_join_state;
    void *wifi_scan_env;
    int (*wifi_scan_cb)(void *, const cyw43_ev_scan_result_t *);
 
    bool initted;
    // Pending things to do
    bool pend_disassoc;
    bool pend_rejoin;
    bool pend_rejoin_wpa;
 
    // AP settings
    uint32_t ap_auth;
    uint8_t ap_channel;
    uint8_t ap_ssid_len;
    uint8_t ap_key_len;
    uint8_t ap_ssid[32];
    uint8_t ap_key[64];
 
    #if CYW43_LWIP
    // lwIP data
    struct netif netif[2];
    #if LWIP_IPV4 && LWIP_DHCP
    struct dhcp dhcp_client;
    #endif
    #endif
 
    #if CYW43_NETUTILS
    dhcp_server_t dhcp_server;
    #endif
 
    // mac from otp (or from cyw43_hal_generate_laa_mac if not set)
    uint8_t mac[6];
 
    #if CYW43_ENABLE_BLUETOOTH
    bool bt_loaded;
    #endif
} cyw43_t;
 
extern cyw43_t cyw43_state;
extern void (*cyw43_poll)(void);
extern uint32_t cyw43_sleep;

void cyw43_init(cyw43_t *self);

void cyw43_deinit(cyw43_t *self);

int cyw43_ioctl(cyw43_t *self, uint32_t cmd, size_t len, uint8_t *buf, uint32_t iface);

int cyw43_send_ethernet(cyw43_t *self, int itf, size_t len, const void *buf, bool is_pbuf);

int cyw43_wifi_pm(cyw43_t *self, uint32_t pm);

int cyw43_wifi_get_pm(cyw43_t *self, uint32_t *pm);

int cyw43_wifi_link_status(cyw43_t *self, int itf);

void cyw43_wifi_set_up(cyw43_t *self, int itf, bool up, uint32_t country);

int cyw43_wifi_get_mac(cyw43_t *self, int itf, uint8_t mac[6]);

int cyw43_wifi_update_multicast_filter(cyw43_t *self, uint8_t *addr, bool add);

int cyw43_wifi_scan(cyw43_t *self, cyw43_wifi_scan_options_t *opts, void *env, int (*result_cb)(void *, const cyw43_ev_scan_result_t *));

static inline bool cyw43_wifi_scan_active(cyw43_t *self) {
    return self->wifi_scan_state == 1;
}

int cyw43_wifi_join(cyw43_t *self, size_t ssid_len, const uint8_t *ssid, size_t key_len, const uint8_t *key, uint32_t auth_type, const uint8_t *bssid, uint32_t channel);

int cyw43_wifi_leave(cyw43_t *self, int itf);

int cyw43_wifi_get_rssi(cyw43_t *self, int32_t *rssi);

int cyw43_wifi_get_bssid(cyw43_t *self, uint8_t bssid[6]);

static inline void cyw43_wifi_ap_get_ssid(cyw43_t *self, size_t *len, const uint8_t **buf) {
    *len = self->ap_ssid_len;
    *buf = self->ap_ssid;
}

static inline uint32_t cyw43_wifi_ap_get_auth(cyw43_t *self) {
    return self->ap_auth;
}

static inline void cyw43_wifi_ap_set_channel(cyw43_t *self, uint32_t channel) {
    self->ap_channel = (uint8_t)channel;
}

static inline void cyw43_wifi_ap_set_ssid(cyw43_t *self, size_t len, const uint8_t *buf) {
    self->ap_ssid_len = (uint8_t)MIN(len, sizeof(self->ap_ssid));
    memcpy(self->ap_ssid, buf, self->ap_ssid_len);
}

static inline void cyw43_wifi_ap_set_password(cyw43_t *self, size_t len, const uint8_t *buf) {
    self->ap_key_len = (uint8_t)MIN(len, sizeof(self->ap_key));
    memcpy(self->ap_key, buf, self->ap_key_len);
}

static inline void cyw43_wifi_ap_set_auth(cyw43_t *self, uint32_t auth) {
    self->ap_auth = auth;
}

void cyw43_wifi_ap_get_max_stas(cyw43_t *self, int *max_stas);

void cyw43_wifi_ap_get_stas(cyw43_t *self, int *num_stas, uint8_t *macs);

static inline bool cyw43_is_initialized(cyw43_t *self) {
    return self->initted;
}

void cyw43_cb_tcpip_init(cyw43_t *self, int itf);

void cyw43_cb_tcpip_deinit(cyw43_t *self, int itf);

void cyw43_cb_tcpip_set_link_up(cyw43_t *self, int itf);

void cyw43_cb_tcpip_set_link_down(cyw43_t *self, int itf);

int cyw43_tcpip_link_status(cyw43_t *self, int itf);
 
#if CYW43_GPIO
int cyw43_gpio_set(cyw43_t *self, int gpio, bool val);

int cyw43_gpio_get(cyw43_t *self, int gpio, bool *val);
#endif

static inline uint32_t cyw43_pm_value(uint8_t pm_mode, uint16_t pm2_sleep_ret_ms, uint8_t li_beacon_period, uint8_t li_dtim_period, uint8_t li_assoc) {
    return li_assoc << 20 // listen interval sent to ap
           | li_dtim_period << 16
           | li_beacon_period << 12
           | (pm2_sleep_ret_ms / 10) << 4 // cyw43_ll_wifi_pm multiplies this by 10
           | pm_mode; // CYW43_PM2_POWERSAVE_MODE etc
}

#define CYW43_DEFAULT_PM (CYW43_PERFORMANCE_PM)

#define CYW43_NONE_PM (cyw43_pm_value(CYW43_NO_POWERSAVE_MODE, 10, 0, 0, 0))

#define CYW43_AGGRESSIVE_PM (cyw43_pm_value(CYW43_PM1_POWERSAVE_MODE, 10, 0, 0, 0))

#define CYW43_PERFORMANCE_PM (cyw43_pm_value(CYW43_PM2_POWERSAVE_MODE, 200, 1, 1, 10))
 
#if CYW43_ENABLE_BLUETOOTH

int cyw43_bluetooth_hci_init(void);

int cyw43_bluetooth_hci_read(uint8_t *buf, uint32_t max_size, uint32_t *len);

int cyw43_bluetooth_hci_write(uint8_t *buf, size_t len);

void cyw43_bluetooth_hci_process(void);
 
#endif // CYW43_ENABLE_BLUETOOTH
 
#if CYW43_ENABLE_BLUETOOTH_OVER_UART

int cyw43_bluetooth_controller_init(void);

int cyw43_bluetooth_controller_deinit(void);

int cyw43_bluetooth_controller_sleep_maybe(void);

bool cyw43_bluetooth_controller_woken(void);

int cyw43_bluetooth_controller_wakeup(void);
 
#endif // CYW43_ENABLE_BLUETOOTH_OVER_UART

 
#endif // CYW43_INCLUDED_CYW43_H