CC3000.hh

Go to the documentation of this file.

#ifndef COSA_CC3000_HH
#define COSA_CC3000_HH

#include "Cosa/Types.h"

#if !defined(BOARD_ATTINY)
#include "HCI.hh"
#include "Cosa/Socket.hh"

class CC3000 : public HCI {
public:
  class Driver : public Socket {
    friend class CC3000;
  public:
    Driver() : Socket() {}

    virtual int available();

    virtual int room();

    using IOStream::Device::write;

    virtual int write(const void* buf, size_t size)
    {
      return (write(buf, size, false));
    }

    virtual int write_P(const void* buf, size_t size)
    {
      return (write(buf, size, true));
    }

    using IOStream::Device::read;

    virtual int read(void* buf, size_t size);

    virtual int flush();

    virtual int open(Protocol proto, uint16_t port, uint8_t flag);

    virtual int close();

    virtual int listen();

    virtual int accept();

    virtual int connect(uint8_t addr[4], uint16_t port);

    virtual int connect(const char* hostname, uint16_t port);

    virtual int is_connected();

    virtual int disconnect();

    virtual int datagram(uint8_t addr[4], uint16_t port);

    virtual int recv(void* buf, size_t len);

    virtual int recv(void* buf, size_t len, uint8_t src[4], uint16_t& port);

  protected:
    virtual int write(const void* buf, size_t size, bool progmem);

    virtual int send(const void* buf, size_t len, bool progmem);

    virtual int send(const void* buf, size_t len,
                     uint8_t dest[4], uint16_t port,
                     bool progmem);

    CC3000* m_dev;

    uint8_t m_hndl;

    uint8_t m_ip[4];

    int m_port;
  };

public:
  CC3000(Board::DigitalPin cs,
         Board::ExternalInterruptPin irq,
         Board::DigitalPin vbat,
         SPI::Clock rate = SPI::DEFAULT_CLOCK) :
    HCI(cs, irq, rate),
    m_vbat(vbat, 0),
    m_evnt_handler(this),
    m_active_set(0)
  {
    event_handler(&m_evnt_handler);
  }

  bool begin_P(str_P hostname, uint16_t timeout = 5000);

  Socket* socket(Socket::Protocol proto, uint16_t port = 0, uint8_t flag = 0);

  int service(uint16_t timeout = 100);

  bool end();

  void addr(uint8_t ip[4], uint8_t subnet[4])
  {
    memcpy(ip, m_ip, sizeof(m_ip));
    memcpy(subnet, m_subnet, sizeof(m_subnet));
  }

  void mac_addr(uint8_t mac[6])
  {
    memcpy(mac, m_mac, sizeof(m_mac));
  }

  void dns_addr(uint8_t ip[4])
  {
    memcpy(ip, m_dns, sizeof(m_dns));
  }

public:
  class UnsolicitedEvent : public HCI::Event::Handler {
  public:
    UnsolicitedEvent(CC3000* dev) :
      HCI::Event::Handler(),
      m_dev(dev)
    {}

    /*
     * @override{HCI::Event::Handler}
     * Handle unsolicited events; buffer free cound, socket close
     * wait, keepalive, etc.
     * @param[in] event operation code.
     * @param[in] args pointer to argument block.
     * @param[in] len number of bytes in argument block.
     */
    virtual void on_event(uint16_t event, void* args, size_t len);

  protected:
    CC3000* m_dev;
  };

  enum Security {
    NO_SECURITY_TYPE = 0x0,
    WEP_SECURITY_TYPE = 0x1,
    WPA_SECURITY_TYPE = 0x2,
    WPA2_SECURITY_TYPE = 0x3
  };

  int wlan_connect(Security type, str_P ssid, str_P bssid, str_P key);

  struct hci_cmnd_wlan_ioctl_set_scanparam_t {
    uint32_t magic;
    uint32_t intervall;
    uint32_t min_dwell_time;
    uint32_t max_dwell_time;
    uint32_t num_of_probe_requests;
    uint32_t channel_mask;
    int32_t rssi_threshold;
    uint32_t snr_threshold;
    uint32_t default_tx_power;
    uint32_t channel_scan_timeout[16];
  };

  static const uint32_t HCI_CMND_WLAN_IOCTL_SET_SCANPARAM_MAGIC = 0x00000024L;

  static const hci_cmnd_wlan_ioctl_set_scanparam_t DEFAULT_SCANPARAM PROGMEM;

  int wlan_ioctl_set_scanparam(const hci_cmnd_wlan_ioctl_set_scanparam_t* param = NULL);

  enum {
    WLAN_STATUS_DISCONNECTED = 0,
    WLAN_STATUS_SCANNING = 1,
    WLAN_STATUS_CONNECTING = 2,
    WLAN_STATUS_CONNECTED = 3
  };

  int wlan_ioctl_statusget();

  int wlan_ioctl_set_connection_policy(bool should_connect_to_open_ap,
                                       bool should_use_fast_connect,
                                       bool auto_start_use_profiles);

  struct hci_evnt_wlan_ioctl_get_scan_results_t {
    int8_t status;
    uint32_t network_id;
    uint32_t scan_status;
    uint8_t valid:1;
    uint8_t rssi:7;
    uint8_t wlan_security:2;
    uint8_t ssid_name_length:6;
    uint16_t entry_time;
    uint8_t ssid[32];
    uint8_t bssid[6];
    uint8_t reserved[2];
  };

  int wlan_ioctl_get_scan_results(hci_evnt_wlan_ioctl_get_scan_results_t& ret);

  int wlan_ioctl_del_profile(uint8_t index);

  int wlan_set_event_mask(uint16_t mask);

  enum {
    NVMEM_NVS_FILEID = 0,
    NVMEM_NVS_SHADOW_FILEID = 1,
    NVMEM_WLAN_CONFIG_FILEID = 2,
    NVMEM_WLAN_CONFIG_SHADOW_FILEID = 3,
    NVMEM_WLAN_DRIVER_SP_FILEID = 4,
    NVMEM_WLAN_FW_SP_FILEID = 5,
    NVMEM_MAC_FILEID = 6,
    NVMEM_FRONTEND_VARS_FILEID = 7,
    NVMEM_IP_CONFIG_FILEID = 8,
    NVMEM_IP_CONFIG_SHADOW_FILEID = 9,
    NVMEM_BOOTLOADER_SP_FILEID = 10,
    NVMEM_RM_FILEID = 11,
    NVMEM_AES128_KEY_FILEID = 12,
    NVMEM_SHARED_MEM_FILEID = 13,
    NVMEM_USER_FILE_1_FILEID = 14,
    NVMEM_USER_FILE_2_FILEID = 15,
    NVMEM_MAX_ENTRY = 16
  };

  int nvmem_read(uint8_t fileid, void* dst, uint32_t src, size_t n);

  int simple_link_start(uint8_t src);

  int read_buffer_size(uint8_t &count, uint16_t &size);

  int read_sp_version(uint8_t &package_id, uint8_t &package_build_nr);

  int socket(int domain, int type, int protocol);

  enum {
    SOL_SOCKET = 0xffff
  };
  enum {
    SOCKOPT_RECV_NONBLOCK = 0,
    SOCKOPT_RECV_TIMEOUT = 1,
    SOCKOPT_ACCEPT_NONBLOCK = 2
  };

  int setsockopt(int hndl, int level, int optname, const void* optval, size_t optlen);

  int connect(int hndl, uint8_t ip[4], int port);

  int select(int hndls,
             uint32_t &readhnds, uint32_t &writehndls, uint32_t &errorhndls,
             uint32_t sec = 0UL, uint32_t us = 0UL);

  int recv(int hndl, void* buf, size_t size);

  int send(int hndl, const void* buf, size_t size);

  int bind(int hndl, int port);

  int listen(int hndl);

  int accept(int hndl, uint8_t ip[4], int &port);

  int close(int hndl);

protected:
  OutputPin m_vbat;

  UnsolicitedEvent m_evnt_handler;

  uint8_t m_mac[6];

  uint8_t m_ip[4];

  uint8_t m_subnet[4];

  uint8_t m_gateway[4];

  uint8_t m_dns[4];

  static const uint16_t DEFAULT_TIMEOUT = 300;

  uint16_t BUFFER_MAX;

  uint8_t BUFFER_COUNT;

  uint8_t m_buffer_avail;

  static const int SOCKET_MAX = 8;

  Driver m_socket[SOCKET_MAX];

  uint16_t m_active_set;

  bool is_socket(int hndl)
  {
    return (hndl >= 0 && hndl < SOCKET_MAX);
  }

  bool is_active(int hndl)
  {
    if (!is_socket(hndl)) return (false);
    return (bit_get(m_active_set, hndl) != 0);
  }

  bool socket_state(int hndl, bool state)
  {
    if (!is_socket(hndl)) return (false);
    bit_write(state, m_active_set, hndl);
    return (true);
  }

  static const uint16_t HCI_CMND_WLAN_CONNECT = 0x0001;
  static const uint32_t HCI_CMND_WLAN_CONNECT_MAGIC = 0x0000001cL;
  static const size_t HCI_CMND_WLAN_CONNECT_BSSID_MAX = 6;
  static const size_t HCI_CMND_WLAN_CONNECT_SSID_MAX = 32;
  static const size_t HCI_CMND_WLAN_CONNECT_KEY_MAX = 32;
  static const size_t HCI_CMND_WLAN_CONNECT_DATA_MAX = 64;
  struct hci_cmnd_wlan_connect_t {
    uint32_t magic;
    uint32_t ssid_length;
    uint32_t wlan_security_type;
    uint32_t ssid_length_plus;
    uint32_t key_length;
    uint16_t reserved;
    uint8_t bssid[HCI_CMND_WLAN_CONNECT_BSSID_MAX];
    uint8_t data[HCI_CMND_WLAN_CONNECT_DATA_MAX];
    hci_cmnd_wlan_connect_t(uint8_t type, str_P ssid, str_P bssid, str_P key)
    {
      magic = HCI_CMND_WLAN_CONNECT_MAGIC;
      ssid_length = strlen_P(ssid);
      wlan_security_type = type;
      ssid_length_plus = ssid_length + 16;
      key_length = strlen_P(key);
      reserved = 0;
      if (bssid == NULL)
        memset(this->bssid, 0, sizeof(bssid));
      else
        memcpy_P(this->bssid, bssid, sizeof(bssid));
      memcpy_P(data, ssid, ssid_length);
      memcpy_P(data + ssid_length, key, key_length);
    }
  };

  static const uint16_t HCI_CMND_WLAN_DISCONNECT = 0x0002;

  static const uint16_t HCI_CMND_WLAN_IOCTL_SET_SCANPARAM = 0x0003;

  static const uint16_t HCI_CMND_WLAN_IOCTL_SET_CONNECTION_POLICY = 0x0004;
  struct hci_cmnd_wlan_ioctl_set_connection_policy_t {
    uint32_t should_connect_to_open_ap;
    uint32_t should_use_fast_connect;
    uint32_t auto_start_use_profiles;
    hci_cmnd_wlan_ioctl_set_connection_policy_t(uint32_t should_connect_to_open_ap,
                                                uint32_t should_use_fast_connect,
                                                uint32_t auto_start_use_profiles)
    {
      this->should_connect_to_open_ap = should_connect_to_open_ap;
      this->should_use_fast_connect = should_use_fast_connect;
      this->auto_start_use_profiles = auto_start_use_profiles;
    }
  };

  // Fix: Not yet implemented.
  static const uint16_t HCI_CMND_WLAN_IOCTL_ADD_PROFILE = 0x0005;

  static const uint16_t HCI_CMND_WLAN_IOCTL_DEL_PROFILE = 0x0006;
  struct hci_cmnd_wlan_ioctl_del_profile_t {
    uint32_t index;
    hci_cmnd_wlan_ioctl_del_profile_t(uint8_t index)
    {
      this->index = index;
    }
  };

  static const uint16_t HCI_CMND_WLAN_IOCTL_GET_SCAN_RESULTS = 0x0007;
  struct hci_cmnd_wlan_ioctl_get_scan_results_t {
    uint32_t scan_timeout;
    hci_cmnd_wlan_ioctl_get_scan_results_t(uint32_t scan_timeout = 0UL)
    {
      this->scan_timeout = scan_timeout;
    }
  };

  static const uint16_t HCI_CMND_WLAN_SET_EVENT_MASK = 0x0008;
  struct hci_cmnd_wlan_set_event_mask_t {
    uint32_t mask;
    hci_cmnd_wlan_set_event_mask_t(uint16_t mask = 0)
    {
      this->mask = mask;
    }
  };

  // Fix: Not yet implemented.
  static const uint16_t HCI_CMND_WLAN_IOCTL_STATUSGET = 0x0009;
  static const uint16_t HCI_CMND_WLAN_IOCTL_SMART_CONFIG_START = 0x000A;
  static const uint16_t HCI_CMND_WLAN_IOCTL_SMART_CONFIG_STOP = 0x000B;
  static const uint16_t HCI_CMND_WLAN_IOCTL_SMART_CONFIG_SET_PREFIX = 0x000C;

  static const uint16_t HCI_CMND_NVMEM_READ = 0x0201;
  struct hci_cmnd_nvmem_read_t {
    uint32_t fileid;
    uint32_t length;
    uint32_t offset;
    hci_cmnd_nvmem_read_t(uint8_t fileid, uint32_t offset, size_t length)
    {
      this->fileid = fileid;
      this->length = length;
      this->offset = offset;
    }
  };

  static const uint16_t HCI_CMND_NVMEM_CREATE_ENTRY = 0x0203;

  static const uint16_t HCI_CMND_READ_SP_VERSION = 0x0207;

  static const uint16_t HCI_CMND_SOCKET = 0x1001;
  struct hci_cmnd_socket_t {
    uint32_t protocol_family;
    uint32_t socket_type;
    uint32_t protocol_type;
    hci_cmnd_socket_t(int domain, int type, int protocol)
    {
      protocol_family = domain;
      socket_type = type;
      protocol_type = protocol;
    }
  };

  static const uint16_t HCI_CMND_BIND = 0x1002;
  struct hci_cmnd_bind_t {
    uint32_t handle;
    uint32_t reserved;
    uint32_t length;
    uint16_t protocol_family;
    uint16_t port;
    uint8_t ip[4];
    hci_cmnd_bind_t(int hndl, int port)
    {
      handle = hndl;
      reserved = 8;
      length = 8;
      protocol_family = AF_INET;
      this->port = swap(port);
      memset(ip, 0, sizeof(ip));
    }
  };

  static const uint16_t HCI_CMND_RECV = 0x1004;
  struct hci_cmnd_recv_t {
    uint32_t handle;
    uint32_t count;
    uint32_t flags;
    hci_cmnd_recv_t(int hndl, size_t size)
    {
      handle = hndl;
      count = size;
      flags = 0;
    }
  };

  static const uint16_t HCI_CMND_ACCEPT = 0x1005;
  struct hci_cmnd_accept_t {
    uint32_t handle;
    hci_cmnd_accept_t(int hndl)
    {
      handle = hndl;
    }
  };

  static const uint16_t HCI_CMND_LISTEN = 0x1006;
  static const uint32_t HCI_CMND_LISTEN_QUEUE_MAX = 4;
  struct hci_cmnd_listen_t {
    uint32_t handle;
    uint32_t queue_depth;
    hci_cmnd_listen_t(int hndl)
    {
      handle = hndl;
      queue_depth = 0UL;
    }
  };

  static const uint16_t HCI_CMND_CONNECT = 0x1007;
  struct hci_cmnd_connect_t {
    uint32_t handle;
    uint32_t reserved;
    uint32_t length;
    uint16_t protocol_family;
    uint16_t destination_port;
    uint8_t destination_ip[4];
    hci_cmnd_connect_t(int hndl, uint8_t ip[4], int port)
    {
      handle = hndl;
      reserved = 8;
      length = 8;
      protocol_family = AF_INET;
      destination_port = swap(port);
      memcpy(destination_ip, ip, sizeof(destination_ip));
    }
  };

  static const uint16_t HCI_CMND_SELECT = 0x1008;
  static const uint32_t HCI_CMND_SELECT_MAGIC = 0x00000014;
  struct hci_cmnd_select_t {
    uint32_t handle_max;
    uint32_t magic[4];
    uint32_t flags;
    uint32_t read_set;
    uint32_t write_set;
    uint32_t error_set;
    struct {
      uint32_t sec;
      uint32_t us;
    } timeout;
    hci_cmnd_select_t(uint32_t hndls,
                      uint32_t readhndls,
                      uint32_t writehndls,
                      uint32_t errorhndls,
                      uint32_t sec,
                      uint32_t us)
    {
      handle_max = hndls;
      for (uint8_t i = 0; i < membersof(magic); i++)
        magic[i] = HCI_CMND_SELECT_MAGIC;
      flags = (sec == 0) && (us == 0);
      read_set = readhndls;
      write_set = writehndls;
      error_set = errorhndls;
      timeout.sec = sec;
      timeout.us = us;
    }
  };

  static const uint16_t HCI_CMND_SETSOCKOPT = 0x1009;
  static const uint32_t HCI_CMND_SETSOCKOPT_MAGIC = 0x8;
  enum {
    OPTVAL_MAX = 4
  };
  struct hci_cmnd_setsockopt_t {
    uint32_t handle;
    uint32_t level;
    uint32_t optname;
    uint32_t magic;
    uint32_t optlen;
    uint8_t optval[OPTVAL_MAX];
    hci_cmnd_setsockopt_t(int hndl, int level, int optname,
                          const void* optval, size_t optlen)
    {
      this->handle = hndl;
      this->level = level;
      this->optname = optname;
      this->magic = HCI_CMND_SETSOCKOPT_MAGIC;
      this->optlen = optlen;
      memcpy(this->optval, optval, optlen);
    }
  };

  static const uint16_t HCI_CMND_GETSOCKOPT = 0x100A;
  struct hci_cmnd_getsockopt_t {
    uint32_t handle;
    uint32_t level;
    uint32_t optname;
  };

  static const uint16_t HCI_CMND_CLOSE_SOCKET = 0x100B;
  struct hci_cmnd_close_socket_t {
    uint32_t handle;
    hci_cmnd_close_socket_t(int hndl)
    {
      handle = hndl;
    }
  };

  static const uint16_t HCI_CMND_RECVFROM = 0x100D;
  struct hci_cmnd_recvfrom_t { // 12
    uint32_t handle;
  };

  static const uint16_t HCI_CMND_GETHOSTBYNAME = 0x100D;
  static const uint16_t HCI_CMND_GETHOSTBYNAME_MAGIC = 8;
  static const uint16_t HOSTNAME_MAX = 32;
  struct hci_cmnd_gethostbyname_t { // 9
    uint32_t magic;
    uint32_t len;
    char hostname[HOSTNAME_MAX];
  };

  // Fix: Not yet implemented
  static const uint16_t HCI_CMND_NETAPP_PING_SEND = 0x2002;
  static const uint16_t HCI_CMND_NETAPP_PING_REPORT = 0x2003;
  static const uint16_t HCI_CMND_NETAPP_PING_STOP = 0x2004;
  static const uint16_t HCI_CMND_NETAPP_GETIPCONFIG = 0x2005;
  static const uint16_t HCI_CMND_NETAPP_ARP_FLUSH = 0x2006;
  static const uint16_t HCI_CMND_NETAPP_SET_DEBUG_LEVEL = 0x2008;

  static const uint16_t HCI_CMND_SIMPLE_LINK_START = 0x4000;
  struct hci_cmnd_simple_link_start_t {
    uint8_t src;
  };

  static const uint16_t HCI_CMND_READ_BUFFER_SIZE = 0x400B;

  static const uint8_t HCI_DATA_SEND = 0x81;
  static const uint32_t HCI_DATA_SEND_MAGIC = 0x0000000C;
  struct hci_data_send_t {
    uint32_t handle;
    uint32_t magic;
    uint32_t tcp_data_length;
    uint32_t flags;
    hci_data_send_t(int hndl, size_t size)
    {
      handle = hndl;
      magic = HCI_DATA_SEND_MAGIC;
      tcp_data_length = size;
      flags = 0;
    }
  };

  // Fix: Not yet implemented.
  static const uint8_t HCI_DATA_SENDTO = 0x83;

  static const uint8_t HCI_DATA_RECV = 0x85;
  struct hci_data_recv_t {
    uint32_t handle;
    uint32_t magic;
    uint32_t tcp_data_length;
    uint32_t flags;
    uint32_t reserved[2];
  };

  // Fix: Not yet implemented.
  static const uint8_t HCI_DATA_NVMEM_WRITE = 0x90;

  static const uint8_t HCI_DATA_NVMEM_READ = 0x91;
  struct hci_data_nvmem_read_t {
    uint32_t fileid;
    uint32_t length;
    uint32_t offset;
    uint32_t reserved[3];
  };

  static const uint16_t HCI_EVNT_ANY = 0x0000;

  static const uint16_t HCI_EVNT_WLAN_CONNECT = 0x0001;
  struct hci_evnt_wlan_connect_t {
    int8_t status;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_WLAN_DISCONNECT = 0x0002;
  struct hci_evnt_wlan_disconnect_t {
    int8_t status;
    uint32_t result;
  };

  static const uint16_t HCI_EVNT_WLAN_IOCTL_SET_SCANPARAM = 0x0003;
  struct hci_evnt_wlan_ioctl_set_scanparam_t {
    int8_t status;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_WLAN_IOCTL_SET_CONNECTION_POLICY = 0x0004;
  struct hci_evnt_wlan_ioctl_set_connection_policy_t {
    int8_t status;
    int32_t result;
  };

  // Fix: Not yet implemented.
  static const uint16_t HCI_EVNT_WLAN_IOCTL_ADD_PROFILE = 0x0005;

  static const uint16_t HCI_EVNT_WLAN_IOCTL_DEL_PROFILE = 0x0006;
  struct hci_evnt_wlan_ioctl_del_profile_t {
    int8_t status;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_WLAN_IOCTL_GET_SCAN_RESULTS = 0x0007;

  static const uint16_t HCI_EVNT_WLAN_SET_EVENT_MASK = 0x0008;
  struct hci_evnt_wlan_set_event_mask_t {
    int8_t status;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_WLAN_IOCTL_STATUSGET = 0x0009;
  struct hci_evnt_wlan_ioctl_statusget_t {
    int8_t status;
    uint32_t wlan_status;
  };

  // Fix: Not yet implemented.
  static const uint16_t HCI_EVNT_WLAN_IOCTL_SMART_CONFIG_SET_PREFIX = 0x000C;

  static const uint16_t HCI_EVNT_NVMEM_READ = 0x0201;
  struct hci_evnt_nvmem_read_t {
    int8_t status;
  };

  static const uint16_t HCI_EVNT_READ_SP_VERSION = 0x0207;
  struct hci_evnt_read_sp_version_t {
    int8_t status;
    uint16_t dummy;
    uint8_t package_id;
    uint8_t package_build_nr;
  };

  static const uint16_t HCI_EVNT_PATCHES_REQ = 0x1000;

  static const uint16_t HCI_EVNT_SOCKET = 0x1001;
  struct hci_evnt_socket_t {
    int8_t status;
    int32_t handle;
  };

  static const uint16_t HCI_EVNT_BIND = 0x1002;
  struct hci_evnt_bind_t {
    int8_t status;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_SEND = 0x1003;
  struct hci_evnt_send_t {
    int8_t status;
    int32_t handle;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_RECV = 0x1004;
  struct hci_evnt_recv_t {
    int8_t status;
    int32_t handle;
    int32_t count;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_ACCEPT = 0x1005;
  struct hci_evnt_accept_t {
    int8_t status;
    int32_t result;
    int32_t handle;
    uint16_t protocol_family;
    uint16_t port;
    uint8_t ip[4];
  };

  static const uint16_t HCI_EVNT_LISTEN = 0x1006;
  struct hci_evnt_listen_t {
    int8_t status;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_CONNECT = 0x1007;
  struct hci_evnt_connect_t {
    int8_t status;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_SELECT = 0x1008;
  struct hci_evnt_select_t {
    int8_t status;
    int32_t result;
    uint32_t read_set;
    uint32_t write_set;
    uint32_t error_set;
  };

  static const uint16_t HCI_EVNT_SETSOCKOPT = 0x1009;
  struct hci_evnt_setsockopt_t {
    int8_t status;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_CLOSE_SOCKET = 0x100B;
  struct hci_evnt_close_socket_t {
    int8_t status;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_DATA_SENDTO = 0x100F;
  struct hci_evnt_sendto_t {
    int8_t status;
    int32_t handle;
    int32_t result;
  };

  static const uint16_t HCI_EVNT_NETAPP_PING_SEND = 0x2002;
  struct hci_evnt_netapp_ping_send_t {
    int8_t status;
  };

  static const uint16_t HCI_EVNT_NETAPP_PING_REPORT = 0x2003;
  struct hci_evnt_netapp_ping_report_t {
    int8_t status;
  };

  static const uint16_t HCI_EVNT_NETAPP_PING_STOP = 0x2004;
  struct hci_evnt_netapp_ping_stop_t {
    int8_t status;
  };

  static const uint16_t HCI_EVNT_NETAPP_GETIPCONFIG = 0x2005;
  struct hci_evnt_netapp_getipconfig_t {
    int8_t status;
    uint8_t ip[4];
    uint8_t subnet[4];
    uint8_t gateway[4];
    uint8_t dhcp[4];
    uint8_t dns[4];
    uint8_t mac[6];
    uint8_t ssid[32];
  };

  static const uint16_t HCI_EVNT_DATA_UNSOL_FREE_BUFF = 0x4100;
  struct hci_evnt_data_unsol_free_buff_t {
    int8_t status;
    uint16_t count;
    struct {
      uint16_t magic;
      uint16_t buffers_freed;
    } flow_control_event;
  };

  static const uint16_t HCI_EVNT_WLAN_UNSOL_CONNECT = 0x8001;
  struct hci_evnt_wlan_unsol_connect_t {
    int8_t status;
  };

  static const uint16_t HCI_EVNT_WLAN_UNSOL_DISCONNECT = 0x8002;
  struct hci_evnt_wlan_unsol_disconnect_t {
    int8_t status;
  };

  static const uint16_t HCI_EVNT_WLAN_UNSOL_DHCP = 0x8010;
  struct hci_evnt_wlan_unsol_dhcp_t {
    int8_t status;
    uint8_t ip[4];
    uint8_t subnet[4];
    uint8_t gateway[4];
    uint8_t dhcp[4];
    uint8_t dns[4];
  };

  static const uint16_t HCI_EVNT_WLAN_UNSOL_PING_REPORT = 0x8040;
  struct hci_evnt_wlan_unsol_ping_report_t {
    int8_t status;
    uint32_t echo_requests_sent;
    uint32_t echo_replies_recieved;
    uint32_t max_rtt;
    uint32_t min_rtt;
    uint32_t avg_rtt;
  };

  static const uint16_t HCI_EVNT_WLAN_UNSOL_SMART_CONFIG_DONE = 0x8080;
  struct hci_evnt_wlan_unsol_smart_config_done_t {
    int8_t status;
  };

  static const uint16_t HCI_EVNT_WLAN_UNSOL_KEEPALIVE = 0x8200;
  struct hci_evnt_wlan_unsol_keepalive_t {
    int8_t status;
  };

  static const uint16_t HCI_EVNT_WLAN_UNSOL_TCP_CLOSE_WAIT = 0x8800;
  struct hci_evnt_wlan_unsol_tcp_close_wait_t {
    int8_t status;
    uint32_t handle;
  };

  static const uint16_t HCI_EVNT_SIMPLE_LINK_START = 0x4000;
  struct hci_evnt_simple_link_start_t {
    int8_t status;
  };

  static const uint16_t HCI_EVNT_READ_BUFFER_SIZE = 0x400B;
  struct hci_evnt_read_buffer_size_t {
    int8_t status;
    uint8_t count;
    uint16_t bytes;
  };
};

#endif
#endif