esp_hosted_ng/host/sdio/esp_sdio.c

   1 /*
   2  * Espressif Systems Wireless LAN device driver
   3  *
   4  * SPDX-FileCopyrightText: 2015-2023 Espressif Systems (Shanghai) CO LTD
   5  *
   6  * SPDX-License-Identifier: GPL-2.0-only
   7  */
   8 #include "utils.h"
   9 #include <linux/mutex.h>
  10 #include <linux/mmc/sdio.h>
  11 #include <linux/mmc/sdio_func.h>
  12 #include <linux/mmc/sdio_ids.h>
  13 #include <linux/mmc/card.h>
  14 #include <linux/mmc/host.h>
  15 #include "esp_if.h"
  16 #include "esp_sdio_api.h"
  17 #include "esp_api.h"
  18 #include "esp_bt_api.h"
  19 #include <linux/kthread.h>
  20 #include "esp_stats.h"
  21 #include "include/esp_kernel_port.h"
  22
  23 #define MAX_WRITE_RETRIES       2
  24 #define TX_MAX_PENDING_COUNT    200
  25 #define TX_RESUME_THRESHOLD     (TX_MAX_PENDING_COUNT/5)
  26
  27 #define CHECK_SDIO_RW_ERROR(ret) do {                   \
  28         if (ret)                                                \
  29         esp_err("CMD53 read/write error at %d\n", __LINE__);    \
  30 } while (0);
  31
  32 struct esp_sdio_context sdio_context;
  33 static atomic_t tx_pending;
  34 static atomic_t queue_items[MAX_PRIORITY_QUEUES];
  35
  36 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
  37 struct task_struct *monitor_thread;
  38 #endif
  39 struct task_struct *tx_thread;
  40
  41 volatile u8 host_sleep = 0;
  42
  43 static int init_context(struct esp_sdio_context *context);
  44 static struct sk_buff * read_packet(struct esp_adapter *adapter);
  45 static int write_packet(struct esp_adapter *adapter, struct sk_buff *skb);
  46 /*int deinit_context(struct esp_adapter *adapter);*/
  47
  48 static const struct sdio_device_id esp_devices[] = {
  49         { SDIO_DEVICE(ESP_VENDOR_ID, ESP_DEVICE_ID_1) },
  50         { SDIO_DEVICE(ESP_VENDOR_ID, ESP_DEVICE_ID_2) },
  51         {}
  52 };
  53
  54 static void esp_process_interrupt(struct esp_sdio_context *context, u32 int_status)
  55 {
  56         if (!context) {
  57                 return;
  58         }
  59
  60         if (int_status & ESP_SLAVE_RX_NEW_PACKET_INT) {
  61                 esp_process_new_packet_intr(context->adapter);
  62         }
  63 }
  64
  65 static void esp_handle_isr(struct sdio_func *func)
  66 {
  67         struct esp_sdio_context *context = NULL;
  68         u32 *int_status;
  69         int ret;
  70
  71         if (!func) {
  72                 return;
  73         }
  74
  75         if (host_sleep)
  76                 return;
  77
  78         context = sdio_get_drvdata(func);
  79
  80         if (!context) {
  81                 return;
  82         }
  83
  84         int_status = kmalloc(sizeof(u32), GFP_ATOMIC);
  85
  86         if (!int_status) {
  87                 return;
  88         }
  89
  90         /* Read interrupt status register */
  91         ret = esp_read_reg(context, ESP_SLAVE_INT_ST_REG,
  92                         (u8 *) int_status, sizeof(* int_status), ACQUIRE_LOCK);
  93         CHECK_SDIO_RW_ERROR(ret);
  94
  95         esp_process_interrupt(context, *int_status);
  96
  97         /* Clear interrupt status */
  98         ret = esp_write_reg(context, ESP_SLAVE_INT_CLR_REG,
  99                         (u8 *) int_status, sizeof(* int_status), ACQUIRE_LOCK);
 100         CHECK_SDIO_RW_ERROR(ret);
 101
 102         kfree(int_status);
 103 }
 104
 105 int generate_slave_intr(struct esp_sdio_context *context, u8 data)
 106 {
 107         u8 *val;
 108         int ret = 0;
 109
 110         if (!context)
 111                 return -EINVAL;
 112
 113         val = kmalloc(sizeof(u8), GFP_KERNEL);
 114
 115         if (!val) {
 116                 return -ENOMEM;
 117         }
 118
 119         *val = data;
 120
 121         ret = esp_write_reg(context, ESP_SLAVE_SCRATCH_REG_7, val,
 122                         sizeof(*val), ACQUIRE_LOCK);
 123
 124         kfree(val);
 125
 126         return ret;
 127 }
 128
 129 static void deinit_sdio_func(struct sdio_func *func)
 130 {
 131         sdio_claim_host(func);
 132         /* Release IRQ */
 133         sdio_release_irq(func);
 134         /* Disable sdio function */
 135         sdio_disable_func(func);
 136         sdio_release_host(func);
 137         sdio_set_drvdata(func, NULL);
 138 }
 139
 140 static int esp_slave_get_tx_buffer_num(struct esp_sdio_context *context, u32 *tx_num, u8 is_lock_needed)
 141 {
 142         u32 *len = NULL;
 143         int ret = 0;
 144
 145         len = kmalloc(sizeof(u32), GFP_KERNEL);
 146
 147         if (!len) {
 148                 return -ENOMEM;
 149         }
 150
 151         ret = esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8*) len, sizeof(*len), is_lock_needed);
 152
 153         if (ret) {
 154                 kfree(len);
 155                 return ret;
 156         }
 157
 158         *len = (*len >> 16) & ESP_TX_BUFFER_MASK;
 159         *len = (*len + ESP_TX_BUFFER_MAX - context->tx_buffer_count) % ESP_TX_BUFFER_MAX;
 160
 161         *tx_num = *len;
 162
 163         kfree(len);
 164         return ret;
 165 }
 166
 167 static int esp_get_len_from_slave(struct esp_sdio_context *context, u32 *rx_size, u8 is_lock_needed)
 168 {
 169         u32 *len;
 170         u32 temp;
 171         int ret = 0;
 172
 173         len = kmalloc(sizeof(u32), GFP_KERNEL);
 174
 175         if (!len) {
 176                 return -ENOMEM;
 177         }
 178
 179         ret = esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
 180                         (u8 *) len, sizeof(*len), is_lock_needed);
 181
 182         if (ret) {
 183                 kfree (len);
 184                 return ret;
 185         }
 186
 187         *len &= ESP_SLAVE_LEN_MASK;
 188
 189         if (*len >= context->rx_byte_count)
 190                 *len = (*len + ESP_RX_BYTE_MAX - context->rx_byte_count) % ESP_RX_BYTE_MAX;
 191         else {
 192                 /* Handle a case of roll over */
 193                 temp = ESP_RX_BYTE_MAX - context->rx_byte_count;
 194                 *len = temp + *len;
 195
 196                 if (*len > ESP_RX_BUFFER_SIZE) {
 197                         esp_info("Len from slave[%d] exceeds max [%d]\n",
 198                                         *len, ESP_RX_BUFFER_SIZE);
 199                 }
 200         }
 201         *rx_size = *len;
 202
 203         kfree (len);
 204         return 0;
 205 }
 206
 207
 208 #if 0
 209 static void flush_sdio(struct esp_sdio_context *context)
 210 {
 211         struct sk_buff *skb;
 212
 213         if (!context || !context->adapter)
 214                 return;
 215
 216         while (1) {
 217                 skb = read_packet(context->adapter);
 218
 219                 if (!skb) {
 220                         break;
 221                 }
 222
 223                 if (skb->len)
 224                         esp_info("Flushed %d bytes\n", skb->len);
 225                 dev_kfree_skb(skb);
 226                 skb = NULL;
 227         }
 228 }
 229 #endif
 230
 231 static void esp_remove(struct sdio_func *func)
 232 {
 233         struct esp_sdio_context *context;
 234         uint8_t prio_q_idx = 0;
 235         context = sdio_get_drvdata(func);
 236
 237 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
 238         if (monitor_thread)
 239                 kthread_stop(monitor_thread);
 240 #endif
 241         if (context) {
 242                 context->state = ESP_CONTEXT_INIT;
 243                 for (prio_q_idx=0; prio_q_idx<MAX_PRIORITY_QUEUES; prio_q_idx++)
 244                         skb_queue_purge(&(sdio_context.tx_q[prio_q_idx]));
 245         }
 246
 247         if (tx_thread)
 248                 kthread_stop(tx_thread);
 249
 250         if (context) {
 251                 generate_slave_intr(context, BIT(ESP_CLOSE_DATA_PATH));
 252                 msleep(100);
 253
 254                 context->state = ESP_CONTEXT_DISABLED;
 255
 256                 if (context->adapter) {
 257                         esp_remove_card(context->adapter);
 258
 259                         if (context->adapter->hcidev) {
 260                                 esp_deinit_bt(context->adapter);
 261                         }
 262                 }
 263
 264
 265                 if (context->func) {
 266                         deinit_sdio_func(context->func);
 267                         context->func = NULL;
 268                 }
 269                 memset(context, 0, sizeof(struct esp_sdio_context));
 270         }
 271 }
 272
 273 static struct esp_if_ops if_ops = {
 274         .read           = read_packet,
 275         .write          = write_packet,
 276 };
 277
 278 static int get_firmware_data(struct esp_sdio_context *context)
 279 {
 280         u32 *val;
 281         int ret = 0;
 282
 283         val = kmalloc(sizeof(u32), GFP_KERNEL);
 284
 285         if (!val) {
 286                 return -ENOMEM;
 287         }
 288
 289         /* Initialize rx_byte_count */
 290         ret = esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
 291                         (u8 *) val, sizeof(* val), ACQUIRE_LOCK);
 292         if (ret) {
 293                 kfree(val);
 294                 return ret;
 295         }
 296
 297         esp_info("Rx Pre ====== %d\n", context->rx_byte_count);
 298         context->rx_byte_count = *val & ESP_SLAVE_LEN_MASK;
 299         esp_info("Rx Pos ======  %d\n", context->rx_byte_count);
 300
 301         /* Initialize tx_buffer_count */
 302         ret = esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8 *) val,
 303                         sizeof(* val), ACQUIRE_LOCK);
 304
 305         if (ret) {
 306                 kfree(val);
 307                 return ret;
 308         }
 309
 310         *val = ((*val >> 16) & ESP_TX_BUFFER_MASK);
 311         esp_info("Tx Pre ======  %d\n", context->tx_buffer_count);
 312
 313         if (*val >= ESP_MAX_BUF_CNT)
 314                 context->tx_buffer_count = (*val) - ESP_MAX_BUF_CNT;
 315         else
 316                 context->tx_buffer_count = 0;
 317         esp_info("Tx Pos ======  %d\n", context->tx_buffer_count);
 318
 319         kfree(val);
 320         return ret;
 321 }
 322
 323 static int init_context(struct esp_sdio_context *context)
 324 {
 325         int ret = 0;
 326         uint8_t prio_q_idx = 0;
 327
 328         if (!context) {
 329                 return -EINVAL;
 330         }
 331
 332         ret = get_firmware_data(context);
 333         if(ret)
 334                 return ret;
 335
 336         context->adapter = esp_get_adapter();
 337
 338         if (unlikely(!context->adapter))
 339                 esp_err("Failed to get adapter\n");
 340
 341         for (prio_q_idx=0; prio_q_idx<MAX_PRIORITY_QUEUES; prio_q_idx++) {
 342                 skb_queue_head_init(&(sdio_context.tx_q[prio_q_idx]));
 343                 atomic_set(&queue_items[prio_q_idx], 0);
 344         }
 345
 346         context->adapter->if_type = ESP_IF_TYPE_SDIO;
 347
 348         return ret;
 349 }
 350
 351 static struct sk_buff * read_packet(struct esp_adapter *adapter)
 352 {
 353         u32 len_from_slave, data_left, len_to_read, size, num_blocks;
 354         int ret = 0;
 355         struct sk_buff *skb;
 356         u8 *pos;
 357         struct esp_sdio_context *context;
 358
 359         if (!adapter || !adapter->if_context) {
 360                 esp_err("INVALID args\n");
 361                 return NULL;
 362         }
 363
 364         context = adapter->if_context;
 365
 366         if(!context ||  (context->state != ESP_CONTEXT_READY) || !context->func) {
 367                 esp_err("Invalid context/state\n");
 368                 return NULL;
 369         }
 370
 371         sdio_claim_host(context->func);
 372
 373         data_left = len_to_read = len_from_slave = num_blocks = 0;
 374
 375         /* Read length */
 376         ret = esp_get_len_from_slave(context, &len_from_slave, LOCK_ALREADY_ACQUIRED);
 377
 378         if (ret || !len_from_slave) {
 379                 sdio_release_host(context->func);
 380                 return NULL;
 381         }
 382
 383         size = ESP_BLOCK_SIZE * 4;
 384
 385         if (len_from_slave > size) {
 386                 esp_info("Rx large packet: %d\n", len_from_slave);
 387         }
 388
 389         skb = esp_alloc_skb(len_from_slave);
 390
 391         if (!skb) {
 392                 esp_err("SKB alloc failed\n");
 393                 sdio_release_host(context->func);
 394                 return NULL;
 395         }
 396
 397         skb_put(skb, len_from_slave);
 398         pos = skb->data;
 399
 400         data_left = len_from_slave;
 401
 402         do {
 403                 num_blocks = data_left/ESP_BLOCK_SIZE;
 404
 405 #if 0
 406                 if (!context->rx_byte_count) {
 407                         start_time = ktime_get_ns();
 408                 }
 409 #endif
 410
 411                 if (num_blocks) {
 412                         len_to_read = num_blocks * ESP_BLOCK_SIZE;
 413                         ret = esp_read_block(context,
 414                                         ESP_SLAVE_CMD53_END_ADDR - len_to_read,
 415                                         pos, len_to_read, LOCK_ALREADY_ACQUIRED);
 416                 } else {
 417                         len_to_read = data_left;
 418                         /* 4 byte aligned length */
 419                         ret = esp_read_block(context,
 420                                         ESP_SLAVE_CMD53_END_ADDR - len_to_read,
 421                                         pos, (len_to_read + 3) & (~3), LOCK_ALREADY_ACQUIRED);
 422                 }
 423
 424                 if (ret) {
 425                         esp_err("Failed to read data - %d [%u - %d]\n", ret, num_blocks, len_to_read);
 426                         dev_kfree_skb(skb);
 427                         skb = NULL;
 428                         sdio_release_host(context->func);
 429                         return NULL;
 430                 }
 431
 432                 data_left -= len_to_read;
 433                 pos += len_to_read;
 434                 context->rx_byte_count += len_to_read;
 435                 context->rx_byte_count = context->rx_byte_count % ESP_RX_BYTE_MAX;
 436
 437         } while (data_left > 0);
 438
 439         sdio_release_host(context->func);
 440
 441         return skb;
 442 }
 443
 444 static int write_packet(struct esp_adapter *adapter, struct sk_buff *skb)
 445 {
 446         u32 max_pkt_size = ESP_RX_BUFFER_SIZE - sizeof(struct esp_payload_header);
 447         struct esp_payload_header *payload_header = (struct esp_payload_header *) skb->data;
 448         struct esp_skb_cb * cb = NULL;
 449         uint8_t prio = PRIO_Q_LOW;
 450
 451         if (!adapter || !adapter->if_context || !skb || !skb->data || !skb->len) {
 452                 esp_err("Invalid args\n");
 453                 if(skb) {
 454                         dev_kfree_skb(skb);
 455                         skb = NULL;
 456                 }
 457
 458                 return -EINVAL;
 459         }
 460
 461         if (skb->len > max_pkt_size) {
 462                 esp_err("Drop pkt of len[%u] > max SDIO transport len[%u]\n",
 463                                 skb->len, max_pkt_size);
 464                 dev_kfree_skb(skb);
 465                 skb = NULL;
 466                 return -EPERM;
 467         }
 468
 469         cb = (struct esp_skb_cb *)skb->cb;
 470         if (cb && cb->priv && (atomic_read(&tx_pending) >= TX_MAX_PENDING_COUNT)) {
 471                 esp_tx_pause(cb->priv);
 472                 dev_kfree_skb(skb);
 473                 skb = NULL;
 474 /*              esp_err("TX Pause busy");*/
 475                 return -EBUSY;
 476         }
 477
 478         /* Enqueue SKB in tx_q */
 479         atomic_inc(&tx_pending);
 480
 481         /* Notify to process queue */
 482         if (payload_header->if_type == ESP_INTERNAL_IF)
 483                 prio = PRIO_Q_HIGH;
 484         else if (payload_header->if_type == ESP_HCI_IF)
 485                 prio = PRIO_Q_MID;
 486         else
 487                 prio = PRIO_Q_LOW;
 488
 489         atomic_inc(&queue_items[prio]);
 490         skb_queue_tail(&(sdio_context.tx_q[prio]), skb);
 491
 492         return 0;
 493 }
 494
 495 static int is_sdio_write_buffer_available(u32 buf_needed)
 496 {
 497 #define BUFFER_AVAILABLE        1
 498 #define BUFFER_UNAVAILABLE      0
 499
 500         int ret = 0;
 501         static u32 buf_available = 0;
 502         struct esp_sdio_context *context = &sdio_context;
 503         u8 retry = MAX_WRITE_RETRIES;
 504
 505         /*If buffer needed are less than buffer available
 506           then only read for available buffer number from slave*/
 507         if (buf_available < buf_needed) {
 508                 while (retry) {
 509                         ret = esp_slave_get_tx_buffer_num(context, &buf_available, ACQUIRE_LOCK);
 510
 511                         if (buf_available < buf_needed) {
 512
 513                                 /* Release SDIO and retry after delay*/
 514                                 retry--;
 515                                 usleep_range(10,50);
 516                                 continue;
 517                         }
 518
 519                         break;
 520                 }
 521         }
 522
 523         if (buf_available >= buf_needed)
 524                 buf_available -= buf_needed;
 525
 526         if (!retry) {
 527                 /* No buffer available at slave */
 528                 return BUFFER_UNAVAILABLE;
 529         }
 530
 531         return BUFFER_AVAILABLE;
 532 }
 533
 534 static int tx_process(void *data)
 535 {
 536         int ret = 0;
 537         u32 block_cnt = 0;
 538         u32 buf_needed = 0;
 539         u8 *pos = NULL;
 540         u32 data_left, len_to_send, pad;
 541         struct sk_buff *tx_skb = NULL;
 542         struct esp_adapter *adapter = (struct esp_adapter *) data;
 543         struct esp_sdio_context *context = NULL;
 544         struct esp_skb_cb * cb = NULL;
 545         u8 retry;
 546
 547         context = adapter->if_context;
 548
 549         while (!kthread_should_stop()) {
 550
 551                 if (context->state != ESP_CONTEXT_READY) {
 552                         msleep(10);
 553                         esp_err("not ready");
 554                         continue;
 555                 }
 556
 557                 if (host_sleep) {
 558                         /* TODO: Use wait_event_interruptible_timeout */
 559                         msleep(100);
 560                         continue;
 561                 }
 562
 563                 if (atomic_read(&queue_items[PRIO_Q_HIGH]) > 0) {
 564                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_HIGH]));
 565                         if (!tx_skb) {
 566                                 continue;
 567                         }
 568                         atomic_dec(&queue_items[PRIO_Q_HIGH]);
 569                 } else if (atomic_read(&queue_items[PRIO_Q_MID]) > 0) {
 570                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_MID]));
 571                         if (!tx_skb) {
 572                                 continue;
 573                         }
 574                         atomic_dec(&queue_items[PRIO_Q_MID]);
 575                 } else if (atomic_read(&queue_items[PRIO_Q_LOW]) > 0) {
 576                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_LOW]));
 577                         if (!tx_skb) {
 578                                 continue;
 579                         }
 580                         atomic_dec(&queue_items[PRIO_Q_LOW]);
 581                 } else {
 582 #if 0
 583                         esp_err("not ready 2 [%d %d]\n",
 584                                         atomic_read(&queue_items[PRIO_Q_OTHERS]),
 585                                         atomic_read(&queue_items[PRIO_Q_SERIAL]));
 586 #endif
 587                         msleep(1);
 588                         continue;
 589                 }
 590
 591                 if (atomic_read(&tx_pending))
 592                         atomic_dec(&tx_pending);
 593
 594                 retry = MAX_WRITE_RETRIES;
 595
 596                 /* resume network tx queue if bearable load */
 597                 cb = (struct esp_skb_cb *)tx_skb->cb;
 598                 if (cb && cb->priv && atomic_read(&tx_pending) < TX_RESUME_THRESHOLD) {
 599                         esp_tx_resume(cb->priv);
 600                         #if TEST_RAW_TP
 601                                 esp_raw_tp_queue_resume();
 602                         #endif
 603                 }
 604
 605                 buf_needed = (tx_skb->len + ESP_RX_BUFFER_SIZE - 1) / ESP_RX_BUFFER_SIZE;
 606
 607                 /*If SDIO slave buffer is available to write then only write data
 608                 else wait till buffer is available*/
 609                 ret = is_sdio_write_buffer_available(buf_needed);
 610                 if(!ret) {
 611                         dev_kfree_skb(tx_skb);
 612                         continue;
 613                 }
 614
 615                 pos = tx_skb->data;
 616                 data_left = len_to_send = 0;
 617
 618                 data_left = tx_skb->len;
 619                 pad = ESP_BLOCK_SIZE - (data_left % ESP_BLOCK_SIZE);
 620                 data_left += pad;
 621
 622
 623                 do {
 624                         block_cnt = data_left / ESP_BLOCK_SIZE;
 625                         len_to_send = data_left;
 626                         ret = esp_write_block(context, ESP_SLAVE_CMD53_END_ADDR - len_to_send,
 627                                         pos, (len_to_send + 3) & (~3), ACQUIRE_LOCK);
 628
 629                         if (ret) {
 630                                 esp_err("Failed to send data: %d %d %d\n", ret, len_to_send, data_left);
 631                                 break;
 632                         }
 633
 634                         data_left -= len_to_send;
 635                         pos += len_to_send;
 636                 } while (data_left);
 637
 638                 if (ret) {
 639                         /* drop the packet */
 640                         dev_kfree_skb(tx_skb);
 641                         continue;
 642                 }
 643
 644                 context->tx_buffer_count += buf_needed;
 645                 context->tx_buffer_count = context->tx_buffer_count % ESP_TX_BUFFER_MAX;
 646
 647                 dev_kfree_skb(tx_skb);
 648                 tx_skb = NULL;
 649         }
 650
 651         do_exit(0);
 652         return 0;
 653 }
 654
 655 static struct esp_sdio_context * init_sdio_func(struct sdio_func *func)
 656 {
 657         struct esp_sdio_context *context = NULL;
 658         int ret = 0;
 659
 660         if (!func)
 661                 return NULL;
 662
 663         context = &sdio_context;
 664
 665         context->func = func;
 666
 667         sdio_claim_host(func);
 668
 669         /* Enable Function */
 670         ret = sdio_enable_func(func);
 671         if (ret) {
 672                 return NULL;
 673         }
 674
 675         /* Register IRQ */
 676         ret = sdio_claim_irq(func, esp_handle_isr);
 677         if (ret) {
 678                 sdio_disable_func(func);
 679                 return NULL;
 680         }
 681
 682         /* Set private data */
 683         sdio_set_drvdata(func, context);
 684
 685         context->state = ESP_CONTEXT_INIT;
 686
 687         sdio_release_host(func);
 688
 689         return context;
 690 }
 691
 692 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
 693 static int monitor_process(void *data)
 694 {
 695         u32 val, intr, len_reg, rdata, old_len = 0;
 696         struct esp_sdio_context *context = (struct esp_sdio_context *) data;
 697         struct sk_buff *skb;
 698
 699         while (!kthread_should_stop()) {
 700                 msleep(5000);
 701
 702                 val = intr = len_reg = rdata = 0;
 703
 704                 esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
 705                                 (u8 *) &val, sizeof(val), ACQUIRE_LOCK);
 706
 707                 len_reg = val & ESP_SLAVE_LEN_MASK;
 708
 709                 val = 0;
 710                 esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8 *) &val,
 711                                 sizeof(val), ACQUIRE_LOCK);
 712
 713                 rdata = ((val >> 16) & ESP_TX_BUFFER_MASK);
 714
 715                 esp_read_reg(context, ESP_SLAVE_INT_ST_REG,
 716                                 (u8 *) &intr, sizeof(intr), ACQUIRE_LOCK);
 717
 718
 719                 if (len_reg > context->rx_byte_count) {
 720                         if (old_len && (context->rx_byte_count == old_len)) {
 721                                 esp_dbg("Monitor thread ----> [%d - %d] [%d - %d] %d\n",
 722                                                 len_reg, context->rx_byte_count,
 723                                                 rdata, context->tx_buffer_count, intr);
 724
 725                                 skb = read_packet(context->adapter);
 726
 727                                 if (!skb)
 728                                         continue;
 729
 730                                 if (skb->len)
 731                                         esp_dbg("Flushed %d bytes\n", skb->len);
 732
 733                                 /* drop the packet */
 734                                 dev_kfree_skb(skb);
 735                                 skb = NULL;
 736                         }
 737                 }
 738
 739                 old_len = context->rx_byte_count;
 740         }
 741
 742         do_exit(0);
 743         return 0;
 744 }
 745 #endif
 746
 747 static int esp_probe(struct sdio_func *func,
 748                                   const struct sdio_device_id *id)
 749 {
 750         struct esp_sdio_context *context = NULL;
 751         int ret = 0;
 752
 753         if (func->num != 1) {
 754                 return -EINVAL;
 755         }
 756
 757         esp_info("ESP network device detected\n");
 758
 759         context = init_sdio_func(func);
 760
 761         if (!context) {
 762                 return -ENOMEM;
 763         }
 764
 765         context->state = ESP_CONTEXT_READY;
 766         atomic_set(&tx_pending, 0);
 767         ret = init_context(context);
 768         if (ret) {
 769                 deinit_sdio_func(func);
 770                 return ret;
 771         }
 772
 773         tx_thread = kthread_run(tx_process, context->adapter, "esp32_TX");
 774
 775         if (!tx_thread)
 776                 esp_err("Failed to create esp32_sdio TX thread\n");
 777
 778         context->adapter->dev = &func->dev;
 779         generate_slave_intr(context, BIT(ESP_OPEN_DATA_PATH));
 780
 781
 782 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
 783         monitor_thread = kthread_run(monitor_process, context, "Monitor process");
 784
 785         if (!monitor_thread)
 786                 esp_err("Failed to create monitor thread\n");
 787 #endif
 788
 789         return ret;
 790 }
 791
 792 static int esp_suspend(struct device *dev)
 793 {
 794         struct sdio_func *func = NULL;
 795         struct esp_sdio_context *context = NULL;
 796
 797         if (!dev) {
 798                 esp_info("Failed to inform ESP that host is suspending\n");
 799                 return -1;
 800         }
 801
 802         func = dev_to_sdio_func(dev);
 803
 804         esp_info("----> Host Suspend\n");
 805         msleep(1000);
 806
 807         context = sdio_get_drvdata(func);
 808
 809         if (!context) {
 810                 esp_info("Failed to inform ESP that host is suspending\n");
 811                 return -1;
 812         }
 813
 814         host_sleep = 1;
 815
 816         generate_slave_intr(context, BIT(ESP_POWER_SAVE_ON));
 817         msleep(10);
 818
 819         sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
 820 #if 0
 821         /* Enale OOB IRQ and host wake up */
 822         enable_irq(SDIO_OOB_IRQ);
 823         enable_irq_wake(SDIO_OOB_IRQ);
 824 #endif
 825         return 0;
 826 }
 827
 828 static int esp_resume(struct device *dev)
 829 {
 830         struct sdio_func *func = NULL;
 831         struct esp_sdio_context *context = NULL;
 832
 833         if (!dev) {
 834                 esp_info("Failed to inform ESP that host is awake\n");
 835                 return -1;
 836         }
 837
 838         func = dev_to_sdio_func(dev);
 839
 840         esp_info("-----> Host Awake\n");
 841 #if 0
 842         /* Host woke up.. Disable OOB IRQ */
 843         disable_irq_wake(SDIO_OOB_IRQ);
 844         disable_irq(SDIO_OOB_IRQ);
 845 #endif
 846
 847
 848         context = sdio_get_drvdata(func);
 849
 850         if (!context) {
 851                 esp_info("Failed to inform ESP that host is awake\n");
 852                 return -1;
 853         }
 854
 855         /*     generate_slave_intr(context, BIT(ESP_RESET));*/
 856         get_firmware_data(context);
 857         msleep(100);
 858         generate_slave_intr(context, BIT(ESP_POWER_SAVE_OFF));
 859         host_sleep = 0;
 860         return 0;
 861 }
 862
 863 static const struct dev_pm_ops esp_pm_ops = {
 864         .suspend = esp_suspend,
 865         .resume = esp_resume,
 866 };
 867
 868 /* SDIO driver structure to be registered with kernel */
 869 static struct sdio_driver esp_sdio_driver = {
 870         .name           = "esp_sdio",
 871         .id_table       = esp_devices,
 872         .probe          = esp_probe,
 873         .remove         = esp_remove,
 874         .drv = {
 875                 .owner = THIS_MODULE,
 876                 .pm = &esp_pm_ops,
 877         }
 878
 879 };
 880
 881 int esp_init_interface_layer(struct esp_adapter *adapter)
 882 {
 883         if (!adapter)
 884                 return -EINVAL;
 885
 886         adapter->if_context = &sdio_context;
 887         adapter->if_ops = &if_ops;
 888         sdio_context.adapter = adapter;
 889
 890         return sdio_register_driver(&esp_sdio_driver);
 891 }
 892
 893 void process_event_esp_bootup(struct esp_adapter *adapter, u8 *evt_buf, u8 len)
 894 {
 895         u8 len_left = len, tag_len;
 896         u8 *pos;
 897         struct esp_sdio_context *context = &sdio_context;
 898
 899         if (!adapter)
 900                 return;
 901
 902         if (!evt_buf)
 903                 return;
 904
 905         pos = evt_buf;
 906
 907         while (len_left) {
 908                 tag_len = *(pos + 1);
 909
 910                 esp_info("EVENT: %d\n", *pos);
 911
 912                 if (*pos == ESP_BOOTUP_CAPABILITY) {
 913
 914                         adapter->capabilities = *(pos + 2);
 915                         process_capabilities(adapter);
 916                         print_capabilities(*(pos + 2));
 917
 918                 } else if (*pos == ESP_BOOTUP_FIRMWARE_CHIP_ID){
 919
 920                         esp_info("ESP chipset detected [%s]\n",
 921                                 *(pos+2)==ESP_FIRMWARE_CHIP_ESP32 ? "esp32":
 922                                 *(pos+2)==ESP_FIRMWARE_CHIP_ESP32S2 ? "esp32-s2" :
 923                                 *(pos+2)==ESP_FIRMWARE_CHIP_ESP32C3 ? "esp32-c3" :
 924                                 *(pos+2)==ESP_FIRMWARE_CHIP_ESP32S3 ? "esp32-s3" :
 925                                 "unknown");
 926
 927                         if (*(pos+2)!=ESP_FIRMWARE_CHIP_ESP32)
 928                                 esp_err("SDIO is only supported with ESP32\n");
 929
 930                 } else if (*pos == ESP_BOOTUP_TEST_RAW_TP) {
 931                         process_test_capabilities(*(pos + 2));
 932
 933                 } else if (*pos == ESP_BOOTUP_FW_DATA) {
 934
 935                         if (tag_len != sizeof(struct fw_data))
 936                                 esp_info("Length not matching to firmware data size\n");
 937                         else
 938                                 if (process_fw_data((struct fw_data*)(pos + 2)))
 939                                         if (context->func) {
 940                                                 generate_slave_intr(context, BIT(ESP_CLOSE_DATA_PATH));
 941                                                 return;
 942                                         }
 943
 944                 } else {
 945                         esp_warn("Unsupported tag in event");
 946                 }
 947
 948                 pos += (tag_len+2);
 949                 len_left -= (tag_len+2);
 950         }
 951
 952         if (esp_add_card(adapter)) {
 953                 esp_err("network iterface init failed\n");
 954                 generate_slave_intr(context, BIT(ESP_CLOSE_DATA_PATH));
 955         }
 956 }
 957
 958 void esp_deinit_interface_layer(void)
 959 {
 960         sdio_unregister_driver(&esp_sdio_driver);
 961 }