esp_hosted_ng/host/main.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Espressif Systems Wireless LAN device driver
   4  *
   5  * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
   6  *
   7  */
   8 #include "utils.h"
   9 #include <linux/init.h>
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/gpio.h>
  13 #include <linux/igmp.h>
  14
  15 #include "esp.h"
  16 #include "esp_if.h"
  17 #include "esp_bt_api.h"
  18 #include "esp_api.h"
  19 #include "esp_cmd.h"
  20 #include "esp_kernel_port.h"
  21
  22 #include "esp_cfg80211.h"
  23 #include "esp_stats.h"
  24
  25 #define RELEASE_VERSION "1.0.3"
  26 #define HOST_GPIO_PIN_INVALID -1
  27 #define CONFIG_ALLOW_MULTICAST_WAKEUP 1
  28 static int resetpin = HOST_GPIO_PIN_INVALID;
  29 static u32 clockspeed = 0;
  30 extern u8 ap_bssid[MAC_ADDR_LEN];
  31 extern volatile u8 host_sleep;
  32 u32 raw_tp_mode = 0;
  33 int log_level = ESP_INFO;
  34
  35 module_param(resetpin, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
  36 MODULE_PARM_DESC(resetpin, "Host's GPIO pin number which is connected to ESP32's EN to reset ESP32 device");
  37
  38 module_param(clockspeed, uint, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
  39 MODULE_PARM_DESC(clockspeed, "Hosts clock speed in MHz");
  40
  41 module_param(raw_tp_mode, uint, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
  42 MODULE_PARM_DESC(raw_tp_mode, "Mode choosed to test raw throughput");
  43
  44 static void deinit_adapter(void);
  45
  46
  47 struct multicast_list mcast_list = {0};
  48 struct esp_adapter adapter;
  49 /*struct esp_device esp_dev;*/
  50
  51 struct esp_adapter *esp_get_adapter(void)
  52 {
  53         return &adapter;
  54 }
  55
  56 void esp_process_new_packet_intr(struct esp_adapter *adapter)
  57 {
  58         if (adapter)
  59                 queue_work(adapter->if_rx_workqueue, &adapter->if_rx_work);
  60 }
  61
  62 static int process_tx_packet(struct sk_buff *skb)
  63 {
  64         struct esp_wifi_device *priv = NULL;
  65         struct esp_skb_cb *cb = NULL;
  66         struct esp_payload_header *payload_header = NULL;
  67         struct sk_buff *new_skb = NULL;
  68         int ret = 0;
  69         u8 pad_len = 0, realloc_skb = 0;
  70         u16 len = 0;
  71         u16 total_len = 0;
  72         static u8 c;
  73         u8 *pos = NULL;
  74
  75         c++;
  76         /* Get the priv */
  77         cb = (struct esp_skb_cb *) skb->cb;
  78         priv = cb->priv;
  79
  80         if (!priv) {
  81                 dev_kfree_skb(skb);
  82                 esp_info("No priv\n");
  83                 return NETDEV_TX_OK;
  84         }
  85
  86         if (netif_queue_stopped((const struct net_device *) priv->ndev)) {
  87                 esp_info("Netif queue stopped\n");
  88                 return NETDEV_TX_BUSY;
  89         }
  90
  91         if (host_sleep) {
  92                 return NETDEV_TX_BUSY;
  93         }
  94
  95         len = skb->len;
  96
  97         /* Create space for payload header */
  98         pad_len = sizeof(struct esp_payload_header);
  99
 100         total_len = len + pad_len;
 101
 102         /* Align buffer length */
 103         pad_len += SKB_DATA_ADDR_ALIGNMENT - (total_len % SKB_DATA_ADDR_ALIGNMENT);
 104
 105         if (skb_headroom(skb) < pad_len) {
 106                 /* Headroom is not sufficient */
 107                 realloc_skb = 1;
 108         }
 109
 110         if (realloc_skb || !IS_ALIGNED((unsigned long) skb->data, SKB_DATA_ADDR_ALIGNMENT)) {
 111                 /* Realloc SKB */
 112                 if (skb_linearize(skb)) {
 113                         priv->stats.tx_errors++;
 114                         dev_kfree_skb(skb);
 115                         esp_err("Failed to linearize SKB");
 116                         return NETDEV_TX_OK;
 117                 }
 118
 119                 new_skb = esp_alloc_skb(skb->len + pad_len);
 120
 121                 if (!new_skb) {
 122                         esp_err("Failed to allocate SKB");
 123                         priv->stats.tx_errors++;
 124                         dev_kfree_skb(skb);
 125                         return NETDEV_TX_OK;
 126                 }
 127
 128                 pos = new_skb->data;
 129                 pos += pad_len;
 130
 131                 /* Populate new SKB */
 132                 skb_copy_from_linear_data(skb, pos, skb->len);
 133                 skb_put(new_skb, skb->len + pad_len);
 134
 135                 /* Replace old SKB */
 136                 dev_kfree_skb_any(skb);
 137                 skb = new_skb;
 138         } else {
 139                 /* Realloc is not needed, Make space for interface header */
 140                 skb_push(skb, pad_len);
 141         }
 142
 143         /* Set payload header */
 144         payload_header = (struct esp_payload_header *) skb->data;
 145         memset(payload_header, 0, pad_len);
 146
 147         payload_header->if_type = priv->if_type;
 148         payload_header->if_num = priv->if_num;
 149         payload_header->len = cpu_to_le16(len);
 150         payload_header->offset = cpu_to_le16(pad_len);
 151         payload_header->packet_type = PACKET_TYPE_DATA;
 152
 153         if (adapter.capabilities & ESP_CHECKSUM_ENABLED)
 154                 payload_header->checksum = cpu_to_le16(compute_checksum(skb->data, (len + pad_len)));
 155
 156         if (!priv->stop_data) {
 157                 ret = esp_send_packet(priv->adapter, skb);
 158
 159                 if (ret) {
 160                         esp_verbose("Failed to send SKB");
 161                         priv->stats.tx_errors++;
 162                 } else {
 163                         priv->stats.tx_packets++;
 164                         priv->stats.tx_bytes += skb->len;
 165                 }
 166         } else {
 167                 dev_kfree_skb_any(skb);
 168                 priv->stats.tx_dropped++;
 169         }
 170
 171         return 0;
 172 }
 173
 174 void esp_port_open(struct esp_wifi_device *priv)
 175 {
 176         priv->port_open = 1;
 177         priv->stop_data = 0;
 178 }
 179
 180 void esp_port_close(struct esp_wifi_device *priv)
 181 {
 182         if (!priv)
 183                 return;
 184
 185         priv->port_open = 0;
 186         priv->stop_data = 1;
 187 }
 188
 189 void print_capabilities(u32 cap)
 190 {
 191         esp_info("Capabilities: 0x%x. Features supported are:\n", cap);
 192         if (cap & ESP_WLAN_SDIO_SUPPORT)
 193                 esp_info("\t * WLAN on SDIO\n");
 194         else if (cap & ESP_WLAN_SPI_SUPPORT)
 195                 esp_info("\t * WLAN on SPI\n");
 196
 197         if ((cap & ESP_BT_UART_SUPPORT) ||
 198                     (cap & ESP_BT_SDIO_SUPPORT) ||
 199                     (cap & ESP_BT_SPI_SUPPORT)) {
 200                 esp_info("\t * BT/BLE\n");
 201                 if (cap & ESP_BT_UART_SUPPORT)
 202                         esp_info("\t   - HCI over UART\n");
 203                 if (cap & ESP_BT_SDIO_SUPPORT)
 204                         esp_info("\t   - HCI over SDIO\n");
 205                 if (cap & ESP_BT_SPI_SUPPORT)
 206                         esp_info("\t   - HCI over SPI\n");
 207
 208                 if ((cap & ESP_BLE_ONLY_SUPPORT) && (cap & ESP_BR_EDR_ONLY_SUPPORT))
 209                         esp_info("\t   - BT/BLE dual mode\n");
 210                 else if (cap & ESP_BLE_ONLY_SUPPORT)
 211                         esp_info("\t   - BLE only\n");
 212                 else if (cap & ESP_BR_EDR_ONLY_SUPPORT)
 213                         esp_info("\t   - BR EDR only\n");
 214         }
 215 }
 216
 217 void init_bt(struct esp_adapter *adapter)
 218 {
 219
 220         if ((adapter->capabilities & ESP_BT_SPI_SUPPORT) ||
 221                 (adapter->capabilities & ESP_BT_SDIO_SUPPORT)) {
 222                 msleep(200);
 223                 esp_info("ESP Bluetooth init\n");
 224                 esp_init_bt(adapter);
 225         }
 226 }
 227
 228 static int check_esp_version(struct fw_version *ver)
 229 {
 230         esp_info("ESP Firmware version: %u.%u.%u\n",
 231                         ver->major1, ver->major2, ver->minor);
 232         if (!ver->major1) {
 233                 esp_err("Incompatible ESP firmware release detected, Please use correct ESP-Hosted branch/compatible release\n");
 234                 return -1;
 235         }
 236         return 0;
 237 }
 238
 239 static void print_reset_reason(uint32_t reason)
 240 {
 241         switch (reason)
 242         {
 243                 case 1: esp_info("POWERON_RESET\n"); break;          /**<1, Vbat power on reset*/
 244                 case 3: esp_info("SW_RESET\n"); break;               /**<3, Software reset digital core*/
 245                 case 4: esp_info("OWDT_RESET\n"); break;             /**<4, Legacy watch dog reset digital core*/
 246                 case 5: esp_info("DEEPSLEEP_RESET\n"); break;        /**<5, Deep Sleep reset digital core*/
 247                 case 6: esp_info("SDIO_RESET\n"); break;             /**<6, Reset by SLC module, reset digital core*/
 248                 case 7: esp_info("TG0WDT_SYS_RESET\n"); break;       /**<7, Timer Group0 Watch dog reset digital core*/
 249                 case 8: esp_info("TG1WDT_SYS_RESET\n"); break;       /**<8, Timer Group1 Watch dog reset digital core*/
 250                 case 9: esp_info("RTCWDT_SYS_RESET\n"); break;       /**<9, RTC Watch dog Reset digital core*/
 251                 case 10: esp_info("INTRUSION_RESET\n"); break;       /**<10, Instrusion tested to reset CPU*/
 252                 case 11: esp_info("TGWDT_CPU_RESET\n"); break;       /**<11, Time Group reset CPU*/
 253                 case 12: esp_info("SW_CPU_RESET\n"); break;          /**<12, Software reset CPU*/
 254                 case 13: esp_info("RTCWDT_CPU_RESET\n"); break;      /**<13, RTC Watch dog Reset CPU*/
 255                 case 14: esp_info("EXT_CPU_RESET\n"); break;         /**<14, for APP CPU, reseted by PRO CPU*/
 256                 case 15: esp_info("RTCWDT_BROWN_OUT_RESET\n"); break;/**<15, Reset when the vdd voltage is not stable*/
 257                 case 16: esp_info("RTCWDT_RTC_RESET\n"); break;      /**<16, RTC Watch dog reset digital core and rtc module*/
 258                 default: esp_info("Unknown[%u]\n", reason); break;
 259         }
 260 }
 261
 262 static int process_fw_data(struct fw_data *fw_p, int tag_len)
 263 {
 264         if (tag_len != sizeof(struct fw_data)) {
 265                 esp_err("Length not matching to firmware data size\n");
 266                 return -1;
 267         }
 268
 269         esp_info("ESP chipset's last reset cause:\n");
 270         print_reset_reason(le32_to_cpu(fw_p->last_reset_reason));
 271
 272         return check_esp_version(&fw_p->version);
 273 }
 274
 275 int process_event_esp_bootup(struct esp_adapter *adapter, u8 *evt_buf, u8 len)
 276 {
 277         int len_left = len, tag_len, ret = 0;
 278         u8 *pos;
 279
 280         if (!adapter || !evt_buf)
 281                 return -1;
 282
 283         if (len_left >= 64) {
 284                 esp_info("ESP init event len looks unexpected: %u (>=64)\n", len_left);
 285                 esp_info("You probably facing timing mismatch at transport layer\n");
 286         }
 287
 288         clear_bit(ESP_INIT_DONE, &adapter->state_flags);
 289         /* Deinit module if already initialized */
 290         esp_deinit_module(adapter);
 291
 292         pos = evt_buf;
 293
 294         while (len_left > 0) {
 295                 tag_len = *(pos + 1);
 296
 297                 esp_info("Bootup Event tag: %d\n", *pos);
 298
 299                 switch (*pos) {
 300                 case ESP_BOOTUP_CAPABILITY:
 301                         adapter->capabilities = *(pos + 2);
 302                         break;
 303                 case ESP_BOOTUP_FIRMWARE_CHIP_ID:
 304                         ret = esp_validate_chipset(adapter, *(pos + 2));
 305                         break;
 306                 case ESP_BOOTUP_FW_DATA:
 307                         ret = process_fw_data((struct fw_data *)(pos + 2), tag_len);
 308                         break;
 309                 case ESP_BOOTUP_SPI_CLK_MHZ:
 310                         ret = esp_adjust_spi_clock(adapter, *(pos + 2));
 311                         break;
 312                 default:
 313                         esp_warn("Unsupported tag=%x in bootup event\n", *pos);
 314                 }
 315
 316                 if (ret < 0) {
 317                         esp_err("failed to process tag=%x in bootup event\n", *pos);
 318                         return -1;
 319                 }
 320                 pos += (tag_len + 2);
 321                 len_left -= (tag_len + 2);
 322         }
 323
 324         if (esp_add_card(adapter)) {
 325                 esp_err("network iterface init failed\n");
 326                 return -1;
 327         }
 328         init_bt(adapter);
 329
 330         if (raw_tp_mode !=0) {
 331 #if TEST_RAW_TP
 332                 process_test_capabilities(raw_tp_mode);
 333                 esp_init_raw_tp(adapter);
 334 #else
 335                 esp_err("RAW TP mode selected but not enabled\n");
 336                 return -1;
 337 #endif
 338         }
 339         set_bit(ESP_INIT_DONE, &adapter->state_flags);
 340         print_capabilities(adapter->capabilities);
 341
 342         return 0;
 343 }
 344
 345 static int esp_open(struct net_device *ndev)
 346 {
 347         return 0;
 348 }
 349
 350 static int esp_stop(struct net_device *ndev)
 351 {
 352         return 0;
 353 }
 354
 355 static struct net_device_stats *esp_get_stats(struct net_device *ndev)
 356 {
 357         struct esp_wifi_device *priv = netdev_priv(ndev);
 358
 359         if (!priv)
 360                 return NULL;
 361
 362         return &priv->stats;
 363 }
 364
 365 static int esp_set_mac_address(struct net_device *ndev, void *data)
 366 {
 367         struct esp_wifi_device *priv = netdev_priv(ndev);
 368         struct sockaddr *sa = (struct sockaddr *)data;
 369         int ret;
 370
 371         if (!priv || !priv->adapter)
 372                 return -EINVAL;
 373
 374         esp_info("%u "MACSTR"\n", __LINE__, MAC2STR(sa->sa_data));
 375
 376         ret = cmd_set_mac(priv, sa->sa_data);
 377
 378         if (ret == 0)
 379                 eth_hw_addr_set(ndev, priv->mac_address/*mac_addr->sa_data*/);
 380
 381         return ret;
 382 }
 383
 384 static void esp_set_rx_mode(struct net_device *ndev)
 385 {
 386         struct esp_adapter *adapter = esp_get_adapter();
 387
 388         schedule_work(&adapter->mac_flter_work);
 389 }
 390
 391 static int esp_hard_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 392 {
 393         struct esp_wifi_device *priv = NULL;
 394         struct esp_skb_cb *cb = NULL;
 395
 396         if (!skb || !ndev)
 397                 return NETDEV_TX_OK;
 398
 399         priv = netdev_priv(ndev);
 400         if (!priv) {
 401                 dev_kfree_skb(skb);
 402                 return NETDEV_TX_OK;
 403         }
 404
 405         if (!priv->port_open) {
 406                 priv->stats.tx_dropped++;
 407                 esp_verbose("Port not yet open\n");
 408                 dev_kfree_skb(skb);
 409                 return NETDEV_TX_OK;
 410         }
 411
 412         if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
 413                 esp_err("Bad len %d\n", skb->len);
 414                 priv->stats.tx_dropped++;
 415                 dev_kfree_skb(skb);
 416                 return NETDEV_TX_OK;
 417         }
 418
 419         cb = (struct esp_skb_cb *) skb->cb;
 420         cb->priv = priv;
 421
 422         return process_tx_packet(skb);
 423 }
 424
 425 static const struct net_device_ops esp_netdev_ops = {
 426         .ndo_open = esp_open,
 427         .ndo_stop = esp_stop,
 428         .ndo_start_xmit = esp_hard_start_xmit,
 429         .ndo_set_mac_address = esp_set_mac_address,
 430         .ndo_validate_addr = eth_validate_addr,
 431         .ndo_get_stats = esp_get_stats,
 432         .ndo_set_rx_mode = esp_set_rx_mode,
 433 };
 434
 435
 436 void esp_init_priv(struct net_device *ndev)
 437 {
 438         ndev->netdev_ops = &esp_netdev_ops;
 439         ndev->needed_headroom = roundup(sizeof(struct esp_payload_header) +
 440                         INTERFACE_HEADER_PADDING, 4);
 441 }
 442
 443 static int esp_add_network_ifaces(struct esp_adapter *adapter)
 444 {
 445         struct wireless_dev *wdev = NULL;
 446
 447         if (!adapter) {
 448                 esp_info("adapter not yet init\n");
 449                 return -EINVAL;
 450         }
 451
 452         rtnl_lock();
 453         wdev = esp_cfg80211_add_iface(adapter->wiphy, "wlan%d", 1, NL80211_IFTYPE_STATION, NULL);
 454         rtnl_unlock();
 455
 456         /* Return success if network added successfully */
 457         if (wdev)
 458                 return 0;
 459
 460         return -1;
 461 }
 462
 463 int esp_init_raw_tp(struct esp_adapter *adapter)
 464 {
 465         RET_ON_FAIL(cmd_init_raw_tp_task_timer(adapter->priv[ESP_STA_NW_IF]));
 466         return 0;
 467 }
 468
 469 int esp_add_card(struct esp_adapter *adapter)
 470 {
 471         RET_ON_FAIL(esp_commands_setup(adapter));
 472         RET_ON_FAIL(esp_add_wiphy(adapter));
 473         RET_ON_FAIL(esp_add_network_ifaces(adapter));
 474         clear_bit(ESP_CLEANUP_IN_PROGRESS, &adapter->state_flags);
 475
 476         return 0;
 477 }
 478
 479 static int esp_remove_network_ifaces(struct esp_adapter *adapter)
 480 {
 481         uint8_t iface_idx = 0;
 482         struct net_device *ndev = NULL;
 483         struct esp_wifi_device *priv = NULL;
 484
 485         for (iface_idx = 0; iface_idx < ESP_MAX_INTERFACE; iface_idx++) {
 486
 487                 priv = adapter->priv[iface_idx];
 488                 if (!priv)
 489                         continue;
 490                 if (!test_bit(ESP_NETWORK_UP, &priv->priv_flags))
 491                         continue;
 492
 493                 ndev = priv->ndev;
 494 #if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 12, 0)
 495                 if (ndev)
 496                         ndev->needs_free_netdev = true;
 497                 rtnl_lock();
 498                 wiphy_lock(adapter->wiphy);
 499                 cfg80211_unregister_wdev(&priv->wdev);
 500                 wiphy_unlock(adapter->wiphy);
 501                 rtnl_unlock();
 502 #else
 503                 if (ndev && ndev->reg_state == NETREG_REGISTERED) {
 504                         unregister_netdev(ndev);
 505                         free_netdev(ndev);
 506                         ndev = NULL;
 507                 }
 508 #endif
 509                 adapter->priv[iface_idx] = NULL;
 510         }
 511
 512         return 0;
 513 }
 514
 515 static int stop_network_iface(struct esp_wifi_device *priv)
 516 {
 517         struct net_device *ndev;
 518
 519         if (!priv)
 520                 return 0;
 521
 522         if (!test_bit(ESP_NETWORK_UP, &priv->priv_flags))
 523                 return 0;
 524
 525         esp_mark_scan_done_and_disconnect(priv, false);
 526         esp_port_close(priv);
 527
 528         /* stop and unregister network */
 529         ndev = priv->ndev;
 530
 531         if (ndev) {
 532                 netif_carrier_off(ndev);
 533                 netif_device_detach(ndev);
 534
 535                 unregister_inetaddr_notifier(&(priv->nb));
 536         }
 537
 538         return 0;
 539 }
 540
 541 int esp_stop_network_ifaces(struct esp_adapter *adapter)
 542 {
 543         uint8_t iface_idx = 0;
 544
 545         for (iface_idx = 0; iface_idx < ESP_MAX_INTERFACE; iface_idx++) {
 546                 stop_network_iface(adapter->priv[iface_idx]);
 547         }
 548
 549         rtnl_lock();
 550         if (adapter->wiphy)
 551                 cfg80211_shutdown_all_interfaces(adapter->wiphy);
 552
 553         rtnl_unlock();
 554
 555         return 0;
 556 }
 557
 558 int esp_remove_card(struct esp_adapter *adapter)
 559 {
 560         if (!adapter) {
 561                 return 0;
 562         }
 563
 564         esp_stop_network_ifaces(adapter);
 565         esp_cfg_cleanup(adapter);
 566         /* BT may have been initialized after fw bootup event, deinit it */
 567         esp_deinit_bt(adapter);
 568         esp_commands_teardown(adapter);
 569         esp_remove_network_ifaces(adapter);
 570         esp_remove_wiphy(adapter);
 571
 572         return 0;
 573 }
 574
 575 struct esp_wifi_device *get_priv_from_payload_header(
 576                 struct esp_payload_header *header)
 577 {
 578         struct esp_wifi_device *priv = NULL;
 579         u8 i = 0;
 580
 581         if (!header)
 582                 return NULL;
 583
 584         for (i = 0; i < ESP_MAX_INTERFACE; i++) {
 585                 priv = adapter.priv[i];
 586
 587                 if (!priv)
 588                         continue;
 589
 590                 if (priv->if_type == header->if_type &&
 591                                 priv->if_num == header->if_num) {
 592                         return priv;
 593                 }
 594         }
 595         return NULL;
 596 }
 597
 598 static void process_esp_bootup_event(struct esp_adapter *adapter,
 599                 struct esp_internal_bootup_event *evt)
 600 {
 601         if (!adapter || !evt) {
 602                 esp_err("Invalid arguments\n");
 603                 return;
 604         }
 605
 606         if (evt->header.status) {
 607                 esp_err("Incorrect ESP bootup event\n");
 608                 return;
 609         }
 610
 611         esp_info("Received ESP bootup event\n");
 612         process_event_esp_bootup(adapter, evt->data, evt->len);
 613 }
 614
 615 static int process_internal_event(struct esp_adapter *adapter,
 616                 struct sk_buff *skb)
 617 {
 618         struct event_header *header = NULL;
 619
 620         if (!skb || !adapter) {
 621                 esp_err("Incorrect event data!\n");
 622                 return -1;
 623         }
 624
 625         header = (struct event_header *) (skb->data);
 626
 627         switch (header->event_code) {
 628
 629         case ESP_INTERNAL_BOOTUP_EVENT:
 630                 process_esp_bootup_event(adapter,
 631                         (struct esp_internal_bootup_event *)(skb->data));
 632                 break;
 633
 634         default:
 635                 esp_info("%u unhandled internal event[%u]\n",
 636                                 __LINE__, header->event_code);
 637                 break;
 638         }
 639
 640         return 0;
 641 }
 642
 643 static void process_rx_packet(struct esp_adapter *adapter, struct sk_buff *skb)
 644 {
 645         struct esp_wifi_device *priv = NULL;
 646         struct esp_payload_header *payload_header = NULL;
 647         u16 len = 0, offset = 0;
 648         u16 rx_checksum = 0, checksum = 0;
 649         struct hci_dev *hdev = adapter->hcidev;
 650         u8 *type = NULL;
 651
 652         if (!skb)
 653                 return;
 654
 655         /* get the paload header */
 656         payload_header = (struct esp_payload_header *) skb->data;
 657
 658         len = le16_to_cpu(payload_header->len);
 659         offset = le16_to_cpu(payload_header->offset);
 660
 661         if (payload_header->reserved2 == 0xFF) {
 662                 esp_hex_dump("Wake up packet: ", skb->data, len+offset);
 663         }
 664
 665         if (adapter->capabilities & ESP_CHECKSUM_ENABLED) {
 666                 rx_checksum = le16_to_cpu(payload_header->checksum);
 667                 payload_header->checksum = 0;
 668
 669                 checksum = compute_checksum(skb->data, (len + offset));
 670
 671                 if (checksum != rx_checksum) {
 672                         dev_kfree_skb_any(skb);
 673                         return;
 674                 }
 675         }
 676
 677         /* chop off the header from skb */
 678         skb_pull(skb, offset);
 679
 680         if (payload_header->if_type == ESP_STA_IF || payload_header->if_type == ESP_AP_IF) {
 681
 682                 /* retrieve priv based on payload header contents */
 683                 priv = get_priv_from_payload_header(payload_header);
 684
 685                 if (!priv) {
 686                         esp_err("Empty priv\n");
 687                         dev_kfree_skb_any(skb);
 688                         return;
 689                 }
 690
 691                 if (payload_header->packet_type == PACKET_TYPE_EAPOL) {
 692                         esp_dbg("Rx PACKET_TYPE_EAPOL!!!!\n");
 693                         esp_port_open(priv);
 694                         skb->dev = priv->ndev;
 695                         skb->protocol = eth_type_trans(skb, priv->ndev);
 696                         netif_rx(skb);
 697
 698                 } else if (payload_header->packet_type == PACKET_TYPE_DATA) {
 699
 700                         skb->dev = priv->ndev;
 701                         skb->protocol = eth_type_trans(skb, priv->ndev);
 702                         skb->ip_summed = CHECKSUM_NONE;
 703
 704                         priv->stats.rx_bytes += skb->len;
 705                         /* Forward skb to kernel */
 706                         NETIF_RX_NI(skb);
 707                         priv->stats.rx_packets++;
 708                 } else if (payload_header->packet_type == PACKET_TYPE_COMMAND_RESPONSE) {
 709                         process_cmd_resp(priv->adapter, skb);
 710                 } else if (payload_header->packet_type == PACKET_TYPE_EVENT) {
 711                         process_cmd_event(priv, skb);
 712                         dev_kfree_skb_any(skb);
 713                 }
 714
 715         } else if (payload_header->if_type == ESP_HCI_IF) {
 716                 if (hdev) {
 717
 718                         type = skb->data;
 719                         hci_skb_pkt_type(skb) = *type;
 720                         skb_pull(skb, 1);
 721
 722 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 13, 0))
 723                         if (hci_recv_frame(hdev, skb)) {
 724 #else
 725                         if (hci_recv_frame(skb)) {
 726 #endif
 727                                 hdev->stat.err_rx++;
 728                         } else {
 729                                 esp_hci_update_rx_counter(hdev, *type, skb->len);
 730                         }
 731                 }
 732         } else if (payload_header->if_type == ESP_INTERNAL_IF) {
 733
 734                 /* Queue event skb for processing in events workqueue */
 735                 skb_queue_tail(&adapter->events_skb_q, skb);
 736
 737                 if (adapter->events_wq)
 738                         queue_work(adapter->events_wq, &adapter->events_work);
 739                 else
 740                         dev_kfree_skb_any(skb);
 741
 742         } else if (payload_header->if_type == ESP_TEST_IF) {
 743 #if TEST_RAW_TP
 744                 if (raw_tp_mode != 0) {
 745                         update_test_raw_tp_rx_stats(len);
 746                 }
 747 #endif
 748                 dev_kfree_skb_any(skb);
 749         } else {
 750                 dev_kfree_skb_any(skb);
 751         }
 752 }
 753
 754 char *esp_get_hardware_name(int hardware_id)
 755 {
 756         if(hardware_id == ESP_FIRMWARE_CHIP_ESP32)
 757                 return "ESP32";
 758         else if(hardware_id == ESP_FIRMWARE_CHIP_ESP32S2)
 759                 return "ESP32S2";
 760         else if(hardware_id == ESP_FIRMWARE_CHIP_ESP32C3)
 761                 return "ESP32C3";
 762         else if(hardware_id == ESP_FIRMWARE_CHIP_ESP32S3)
 763                 return "ESP32S3";
 764         else if(hardware_id == ESP_FIRMWARE_CHIP_ESP32C2)
 765                 return "ESP32C2";
 766         else if(hardware_id == ESP_FIRMWARE_CHIP_ESP32C6)
 767                 return "ESP32C6";
 768         else
 769                 return "N/A";
 770 }
 771
 772 bool esp_is_valid_hardware_id(int hardware_id)
 773 {
 774         switch(hardware_id) {
 775         case ESP_FIRMWARE_CHIP_ESP32:
 776         case ESP_FIRMWARE_CHIP_ESP32S2:
 777         case ESP_FIRMWARE_CHIP_ESP32C3:
 778         case ESP_FIRMWARE_CHIP_ESP32S3:
 779         case ESP_FIRMWARE_CHIP_ESP32C2:
 780         case ESP_FIRMWARE_CHIP_ESP32C6:
 781                 return true;
 782         default:
 783                 return false;
 784         }
 785 }
 786
 787 int esp_is_tx_queue_paused(struct esp_wifi_device *priv)
 788 {
 789         if (!priv || !priv->ndev)
 790                 return 0;
 791
 792         if ((priv->ndev &&
 793                     !netif_queue_stopped((const struct net_device *)priv->ndev)))
 794                 return 1;
 795     return 0;
 796 }
 797
 798 void esp_tx_pause(struct esp_wifi_device *priv)
 799 {
 800         if (!priv || !priv->ndev)
 801                 return;
 802
 803         if (!netif_queue_stopped((const struct net_device *)priv->ndev)) {
 804                 netif_stop_queue(priv->ndev);
 805         }
 806 }
 807
 808 void esp_tx_resume(struct esp_wifi_device *priv)
 809 {
 810         if (!priv || !priv->ndev)
 811                 return;
 812
 813         if (netif_queue_stopped((const struct net_device *)priv->ndev)) {
 814                 netif_wake_queue(priv->ndev);
 815         }
 816 }
 817
 818 struct sk_buff *esp_alloc_skb(u32 len)
 819 {
 820         struct sk_buff *skb = NULL;
 821
 822         u8 offset;
 823
 824         skb = netdev_alloc_skb(NULL, len + INTERFACE_HEADER_PADDING);
 825
 826         if (skb) {
 827                 /* Align SKB data pointer */
 828                 offset = ((unsigned long)skb->data) & (SKB_DATA_ADDR_ALIGNMENT - 1);
 829
 830                 if (offset)
 831                         skb_reserve(skb, INTERFACE_HEADER_PADDING - offset);
 832         }
 833
 834         return skb;
 835 }
 836
 837
 838 static int esp_get_packets(struct esp_adapter *adapter)
 839 {
 840         struct sk_buff *skb = NULL;
 841
 842         if (!adapter || !adapter->if_ops || !adapter->if_ops->read)
 843                 return -EINVAL;
 844
 845         skb = adapter->if_ops->read(adapter);
 846
 847         if (!skb)
 848                 return -EFAULT;
 849
 850         process_rx_packet(adapter, skb);
 851
 852         return 0;
 853 }
 854
 855 int esp_send_packet(struct esp_adapter *adapter, struct sk_buff *skb)
 856 {
 857         if (!adapter || !adapter->if_ops || !adapter->if_ops->write) {
 858                 esp_err("%u adapter: %p\n", __LINE__, adapter);
 859                 return -EINVAL;
 860         }
 861
 862         return adapter->if_ops->write(adapter, skb);
 863 }
 864
 865 static void esp_if_rx_work(struct work_struct *work)
 866 {
 867         /* read inbound packet and forward it to network/serial interface */
 868         esp_get_packets(&adapter);
 869 }
 870
 871 static void update_mac_filter(struct work_struct *work)
 872 {
 873         struct esp_adapter *adapter = esp_get_adapter();
 874         struct esp_wifi_device *priv = adapter->priv[0];
 875         struct net_device *ndev;
 876         struct netdev_hw_addr *mac_addr;
 877         u32 count = 0;
 878
 879         if (!priv)
 880                 return;
 881
 882         ndev = priv->ndev;
 883         if (!ndev)
 884                 return;
 885
 886         if (!priv->port_open) {
 887                 esp_verbose("Port is not open yet, skipping mac filter update\n");
 888                 return;
 889         }
 890
 891 #if CONFIG_ALLOW_MULTICAST_WAKEUP
 892         netdev_for_each_mc_addr(mac_addr, ndev) {
 893                 if (count < MAX_MULTICAST_ADDR_COUNT) {
 894                         esp_verbose("%d: "MACSTR"\n", count+1, MAC2STR(mac_addr->addr));
 895                         memcpy(&mcast_list.mcast_addr[count++], mac_addr->addr, ETH_ALEN);
 896                 }
 897         }
 898
 899         mcast_list.priv = priv;
 900         mcast_list.addr_count = count;
 901
 902         esp_verbose("Setting Multicast list\n");
 903         cmd_set_mcast_mac_list(mcast_list.priv, &mcast_list);
 904 #else
 905   esp_info("Not setting FW multicast addresses\n");
 906 #endif
 907 }
 908
 909 static void esp_events_work(struct work_struct *work)
 910 {
 911         struct sk_buff *skb = NULL;
 912
 913         skb = skb_dequeue(&adapter.events_skb_q);
 914         if (!skb)
 915                 return;
 916
 917         process_internal_event(&adapter, skb);
 918         dev_kfree_skb_any(skb);
 919 }
 920
 921 static struct esp_adapter *init_adapter(void)
 922 {
 923         memset(&adapter, 0, sizeof(adapter));
 924
 925         /* Prepare interface RX work */
 926         adapter.if_rx_workqueue = alloc_workqueue("ESP_IF_RX_WORK_QUEUE", 0, 0);
 927
 928         if (!adapter.if_rx_workqueue) {
 929                 deinit_adapter();
 930                 return NULL;
 931         }
 932
 933         INIT_WORK(&adapter.if_rx_work, esp_if_rx_work);
 934
 935         skb_queue_head_init(&adapter.events_skb_q);
 936
 937         adapter.events_wq = alloc_workqueue("ESP_EVENTS_WORKQUEUE", WQ_HIGHPRI, 0);
 938
 939         if (!adapter.events_wq) {
 940                 deinit_adapter();
 941                 return NULL;
 942         }
 943
 944         INIT_WORK(&adapter.events_work, esp_events_work);
 945
 946         INIT_WORK(&adapter.mac_flter_work, update_mac_filter);
 947
 948         return &adapter;
 949 }
 950
 951 static void deinit_adapter(void)
 952 {
 953         skb_queue_purge(&adapter.events_skb_q);
 954
 955         if (adapter.events_wq)
 956                 destroy_workqueue(adapter.events_wq);
 957
 958         if (adapter.if_rx_workqueue)
 959                 destroy_workqueue(adapter.if_rx_workqueue);
 960 }
 961
 962 static void esp_reset(void)
 963 {
 964         if (resetpin != HOST_GPIO_PIN_INVALID) {
 965                 /* Check valid GPIO or not */
 966                 if (!gpio_is_valid(resetpin)) {
 967                         esp_warn("host resetpin (%d) configured is invalid GPIO\n", resetpin);
 968                         resetpin = HOST_GPIO_PIN_INVALID;
 969                 } else {
 970                         gpio_request(resetpin, "sysfs");
 971
 972                         /* HOST's resetpin set to OUTPUT, HIGH */
 973                         gpio_direction_output(resetpin, true);
 974
 975                         /* HOST's resetpin set to LOW */
 976                         gpio_set_value(resetpin, 0);
 977                         udelay(200);
 978
 979                         /* HOST's resetpin set to INPUT */
 980                         gpio_direction_input(resetpin);
 981
 982                         esp_dbg("Triggering ESP reset.\n");
 983                 }
 984         }
 985 }
 986
 987 static int __init esp_init(void)
 988 {
 989         int ret = 0;
 990         struct esp_adapter *adapter = NULL;
 991
 992         /* Reset ESP, Clean start ESP */
 993         esp_reset();
 994         msleep(200);
 995
 996         adapter = init_adapter();
 997
 998         if (!adapter)
 999                 return -EFAULT;
1000
1001         /* Init transport layer */
1002         ret = esp_init_interface_layer(adapter, clockspeed);
1003
1004         if (ret != 0) {
1005                 deinit_adapter();
1006         }
1007
1008         ret = debugfs_init();
1009         return ret;
1010 }
1011
1012 static void __exit esp_exit(void)
1013 {
1014         uint8_t iface_idx = 0;
1015 #if TEST_RAW_TP
1016         if (raw_tp_mode != 0) {
1017                 test_raw_tp_cleanup();
1018         }
1019 #endif
1020         for (iface_idx = 0; iface_idx < ESP_MAX_INTERFACE; iface_idx++) {
1021                 cmd_deinit_interface(adapter.priv[iface_idx]);
1022         }
1023         clear_bit(ESP_DRIVER_ACTIVE, &adapter.state_flags);
1024
1025         esp_deinit_interface_layer();
1026         deinit_adapter();
1027
1028         if (resetpin != HOST_GPIO_PIN_INVALID) {
1029                 gpio_free(resetpin);
1030         }
1031         debugfs_exit();
1032 }
1033 MODULE_LICENSE("GPL");
1034 MODULE_AUTHOR("Amey Inamdar <[email protected]>");
1035 MODULE_AUTHOR("Mangesh Malusare <[email protected]>");
1036 MODULE_AUTHOR("Yogesh Mantri <[email protected]>");
1037 MODULE_AUTHOR("Kapil Gupta <[email protected]>");
1038 MODULE_DESCRIPTION("Wifi driver for ESP-Hosted solution");
1039 MODULE_VERSION(RELEASE_VERSION);
1040 module_init(esp_init);
1041 module_exit(esp_exit);