ra8_c6link_wifi.c

Go to the documentation of this file.

 
#include "ra8_c6link_wifi.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_c6link.h"
#include "ra8_c6link_internal.h"

typedef enum : int32_t {
  k_ra8_c6link_mode_null = 0, 
  k_ra8_c6link_mode_sta  = 1, 
  k_ra8_c6link_mode_ap   = 2, 
} ra8_c6link_wifi_mode_t;

typedef enum : int32_t {
  k_ra8_c6link_wifi_magic = 0x1F2F3F4F,
  k_ra8_c6link_wifi_static_rx = 10,
  k_ra8_c6link_wifi_dynamic_rx = 32,
  k_ra8_c6link_wifi_tx_type = 1,
  k_ra8_c6link_wifi_static_tx = 0,
  k_ra8_c6link_wifi_dynamic_tx = 32,
  k_ra8_c6link_wifi_rx_mgmt_type = 0,
  k_ra8_c6link_wifi_rx_mgmt_num = 5,
  k_ra8_c6link_wifi_ampdu_on = 1,
  k_ra8_c6link_wifi_nvs_on = 1,
  k_ra8_c6link_wifi_ba_win = 6,
  k_ra8_c6link_wifi_beacon_max = 752,
  k_ra8_c6link_wifi_mgmt_sbuf = 32,
  k_ra8_c6link_wifi_feature_caps = 1,
  k_ra8_c6link_wifi_espnow_keys = 7,
  k_ra8_c6link_wifi_hetb_queues = 3,
} ra8_c6link_wifi_init_t;
 
RA8_PRIV ra8_err_t priv_c6link_take_resp(void* ctx, const void* msg_v)
{
  ra8_c6link_take_ctx_t* take = (ra8_c6link_take_ctx_t*)ctx;
  const Rpc*             msg  = (const Rpc*)msg_v;
  int32_t                resp = 0;
 
  switch ((int32_t)msg->msg_id) {
    case (int32_t)RPC_ID__Resp_WifiInit:
      resp = (msg->resp_wifi_init != nullptr) ? msg->resp_wifi_init->resp : -1;
      break;
    case (int32_t)RPC_ID__Resp_SetWifiMode:
      resp = (msg->resp_set_wifi_mode != nullptr) ? msg->resp_set_wifi_mode->resp : -1;
      break;
    case (int32_t)RPC_ID__Resp_WifiSetConfig:
      resp = (msg->resp_wifi_set_config != nullptr) ? msg->resp_wifi_set_config->resp : -1;
      break;
    case (int32_t)RPC_ID__Resp_WifiStart:
      resp = (msg->resp_wifi_start != nullptr) ? msg->resp_wifi_start->resp : -1;
      break;
    case (int32_t)RPC_ID__Resp_WifiStop:
      resp = (msg->resp_wifi_stop != nullptr) ? msg->resp_wifi_stop->resp : -1;
      break;
    case (int32_t)RPC_ID__Resp_WifiDeinit:
      resp = (msg->resp_wifi_deinit != nullptr) ? msg->resp_wifi_deinit->resp : -1;
      break;
    case (int32_t)RPC_ID__Resp_WifiConnect:
      resp = (msg->resp_wifi_connect != nullptr) ? msg->resp_wifi_connect->resp : -1;
      break;
    case (int32_t)RPC_ID__Resp_WifiDisconnect:
      resp = (msg->resp_wifi_disconnect != nullptr) ? msg->resp_wifi_disconnect->resp : -1;
      break;
    default:
      resp = -1;
      break;
  }
  return priv_c6link_resp(take->link, take->rpc_id, resp);
}

typedef struct ra8_c6link_bare_body {
  RpcReqWifiStart      start;      
  RpcReqWifiStop       stop;       
  RpcReqWifiDeinit     deinit;     
  RpcReqWifiConnect    connect;    
  RpcReqWifiDisconnect disconnect; 
} ra8_c6link_bare_body_t;

RA8_INTERNAL static bool internal_c6link_wifi_bare_body(Rpc*                    req,
                                                        ra8_c6link_bare_body_t* body,
                                                        uint32_t                req_id,
                                                        uint32_t*               resp_id)
{
  *resp_id = 0U;
  switch ((int32_t)req_id) {
    case (int32_t)RPC_ID__Req_WifiStart:
      rpc__req__wifi_start__init(&body->start);
      req->payload_case   = RPC__PAYLOAD_REQ_WIFI_START;
      req->req_wifi_start = &body->start;
      *resp_id            = (uint32_t)RPC_ID__Resp_WifiStart;
      break;
    case (int32_t)RPC_ID__Req_WifiStop:
      rpc__req__wifi_stop__init(&body->stop);
      req->payload_case  = RPC__PAYLOAD_REQ_WIFI_STOP;
      req->req_wifi_stop = &body->stop;
      *resp_id           = (uint32_t)RPC_ID__Resp_WifiStop;
      break;
    case (int32_t)RPC_ID__Req_WifiDeinit:
      rpc__req__wifi_deinit__init(&body->deinit);
      req->payload_case    = RPC__PAYLOAD_REQ_WIFI_DEINIT;
      req->req_wifi_deinit = &body->deinit;
      *resp_id             = (uint32_t)RPC_ID__Resp_WifiDeinit;
      break;
    case (int32_t)RPC_ID__Req_WifiConnect:
      rpc__req__wifi_connect__init(&body->connect);
      req->payload_case     = RPC__PAYLOAD_REQ_WIFI_CONNECT;
      req->req_wifi_connect = &body->connect;
      *resp_id              = (uint32_t)RPC_ID__Resp_WifiConnect;
      break;
    case (int32_t)RPC_ID__Req_WifiDisconnect:
      rpc__req__wifi_disconnect__init(&body->disconnect);
      req->payload_case        = RPC__PAYLOAD_REQ_WIFI_DISCONNECT;
      req->req_wifi_disconnect = &body->disconnect;
      *resp_id                 = (uint32_t)RPC_ID__Resp_WifiDisconnect;
      break;
    default:
      return false;
  }
  return true;
}
 
RA8_PRIV ra8_err_t priv_c6link_bare_req(ra8_c6link_t* link, uint32_t req_id)
{
  if (link == nullptr) {
    return k_ra8_err_null_ptr;
  }
 
  Rpc req;
  rpc__init(&req);
  req.msg_type = RPC_TYPE__Req;
  req.msg_id   = (RpcId)req_id;
 
  ra8_c6link_bare_body_t body;
  uint32_t               resp_id = 0U;
  if (!internal_c6link_wifi_bare_body(&req, &body, req_id, &resp_id)) {
    return k_ra8_err_not_supported;
  }
 
  ra8_c6link_take_ctx_t take = {.link = link, .out = nullptr, .rpc_id = req_id};
  return priv_c6link_rpc_call(link, &req, resp_id, priv_c6link_take_resp, &take);
}

RA8_INTERNAL static ra8_err_t internal_c6link_wifi_do_init(ra8_c6link_t* link)
{
  WifiInitConfig cfg;
  wifi_init_config__init(&cfg);
  cfg.static_rx_buf_num      = (int32_t)k_ra8_c6link_wifi_static_rx;
  cfg.dynamic_rx_buf_num     = (int32_t)k_ra8_c6link_wifi_dynamic_rx;
  cfg.tx_buf_type            = (int32_t)k_ra8_c6link_wifi_tx_type;
  cfg.static_tx_buf_num      = (int32_t)k_ra8_c6link_wifi_static_tx;
  cfg.dynamic_tx_buf_num     = (int32_t)k_ra8_c6link_wifi_dynamic_tx;
  cfg.rx_mgmt_buf_type       = (int32_t)k_ra8_c6link_wifi_rx_mgmt_type;
  cfg.rx_mgmt_buf_num        = (int32_t)k_ra8_c6link_wifi_rx_mgmt_num;
  cfg.ampdu_rx_enable        = (int32_t)k_ra8_c6link_wifi_ampdu_on;
  cfg.ampdu_tx_enable        = (int32_t)k_ra8_c6link_wifi_ampdu_on;
  cfg.nvs_enable             = (int32_t)k_ra8_c6link_wifi_nvs_on;
  cfg.rx_ba_win              = (int32_t)k_ra8_c6link_wifi_ba_win;
  cfg.beacon_max_len         = (int32_t)k_ra8_c6link_wifi_beacon_max;
  cfg.mgmt_sbuf_num          = (int32_t)k_ra8_c6link_wifi_mgmt_sbuf;
  cfg.feature_caps           = (uint64_t)k_ra8_c6link_wifi_feature_caps;
  cfg.sta_disconnected_pm    = true;
  cfg.espnow_max_encrypt_num = (int32_t)k_ra8_c6link_wifi_espnow_keys;
  cfg.tx_hetb_queue_num      = (int32_t)k_ra8_c6link_wifi_hetb_queues;
  cfg.magic                  = (int32_t)k_ra8_c6link_wifi_magic;
 
  RpcReqWifiInit body;
  rpc__req__wifi_init__init(&body);
  body.cfg = &cfg;
 
  Rpc req;
  rpc__init(&req);
  req.msg_type      = RPC_TYPE__Req;
  req.msg_id        = RPC_ID__Req_WifiInit;
  req.payload_case  = RPC__PAYLOAD_REQ_WIFI_INIT;
  req.req_wifi_init = &body;
 
  ra8_c6link_take_ctx_t take = {.link   = link,
                                .out    = nullptr,
                                .rpc_id = (uint32_t)RPC_ID__Req_WifiInit};
  return priv_c6link_rpc_call(link,
                              &req,
                              (uint32_t)RPC_ID__Resp_WifiInit,
                              priv_c6link_take_resp,
                              &take);
}

RA8_INTERNAL static ra8_err_t internal_c6link_wifi_do_mode(ra8_c6link_t* link)
{
  RpcReqSetMode body;
  rpc__req__set_mode__init(&body);
  body.mode = (int32_t)k_ra8_c6link_mode_sta;
 
  Rpc req;
  rpc__init(&req);
  req.msg_type          = RPC_TYPE__Req;
  req.msg_id            = RPC_ID__Req_SetWifiMode;
  req.payload_case      = RPC__PAYLOAD_REQ_SET_WIFI_MODE;
  req.req_set_wifi_mode = &body;
 
  ra8_c6link_take_ctx_t take = {.link   = link,
                                .out    = nullptr,
                                .rpc_id = (uint32_t)RPC_ID__Req_SetWifiMode};
  return priv_c6link_rpc_call(link,
                              &req,
                              (uint32_t)RPC_ID__Resp_SetWifiMode,
                              priv_c6link_take_resp,
                              &take);
}
 
ra8_err_t ra8_c6link_wifi_start(ra8_c6link_t* link)
{
  if (link == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!ra8_c6link_is_open(link)) {
    return k_ra8_err_not_initialized;
  }
 
  const ra8_err_t inited = internal_c6link_wifi_do_init(link);
  if (inited != k_ra8_ok) {
    return inited;
  }
  const ra8_err_t moded = internal_c6link_wifi_do_mode(link);
  if (moded != k_ra8_ok) {
    return moded;
  }
  return priv_c6link_bare_req(link, (uint32_t)RPC_ID__Req_WifiStart);
}
 
ra8_err_t ra8_c6link_wifi_stop(ra8_c6link_t* link)
{
  if (link == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!ra8_c6link_is_open(link)) {
    return k_ra8_err_not_initialized;
  }
 
  const ra8_err_t stopped = priv_c6link_bare_req(link, (uint32_t)RPC_ID__Req_WifiStop);
  const ra8_err_t deinit  = priv_c6link_bare_req(link, (uint32_t)RPC_ID__Req_WifiDeinit);
  return (stopped != k_ra8_ok) ? stopped : deinit;
}
 
ra8_err_t ra8_c6link_wifi_leave(ra8_c6link_t* link)
{
  if (link == nullptr) {
    return k_ra8_err_null_ptr;
  }
  if (!ra8_c6link_is_open(link)) {
    return k_ra8_err_not_initialized;
  }
  return priv_c6link_bare_req(link, (uint32_t)RPC_ID__Req_WifiDisconnect);
}