esp_hosted_ng/host/sdio/esp_sdio.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/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;
  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
 236         context = sdio_get_drvdata(func);
 237
 238 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
 239         if (monitor_thread)
 240                 kthread_stop(monitor_thread);
 241 #endif
 242         if (context) {
 243                 context->state = ESP_CONTEXT_INIT;
 244                 for (prio_q_idx = 0; prio_q_idx < MAX_PRIORITY_QUEUES; prio_q_idx++)
 245                         skb_queue_purge(&(sdio_context.tx_q[prio_q_idx]));
 246         }
 247
 248         if (tx_thread)
 249                 kthread_stop(tx_thread);
 250
 251         if (context) {
 252                 generate_slave_intr(context, BIT(ESP_CLOSE_DATA_PATH));
 253                 msleep(100);
 254
 255                 context->state = ESP_CONTEXT_DISABLED;
 256
 257                 if (context->adapter) {
 258                         esp_remove_card(context->adapter);
 259
 260                         if (context->adapter->hcidev) {
 261                                 esp_deinit_bt(context->adapter);
 262                         }
 263                 }
 264
 265
 266                 if (context->func) {
 267                         deinit_sdio_func(context->func);
 268                         context->func = NULL;
 269                 }
 270                 memset(context, 0, sizeof(struct esp_sdio_context));
 271         }
 272 }
 273
 274 static struct esp_if_ops if_ops = {
 275         .read           = read_packet,
 276         .write          = write_packet,
 277 };
 278
 279 static int get_firmware_data(struct esp_sdio_context *context)
 280 {
 281         u32 *val;
 282         int ret = 0;
 283
 284         val = kmalloc(sizeof(u32), GFP_KERNEL);
 285
 286         if (!val) {
 287                 return -ENOMEM;
 288         }
 289
 290         /* Initialize rx_byte_count */
 291         ret = esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
 292                         (u8 *) val, sizeof(*val), ACQUIRE_LOCK);
 293         if (ret) {
 294                 kfree(val);
 295                 return ret;
 296         }
 297
 298         esp_info("Rx Pre ====== %d\n", context->rx_byte_count);
 299         context->rx_byte_count = *val & ESP_SLAVE_LEN_MASK;
 300         esp_info("Rx Pos ======  %d\n", context->rx_byte_count);
 301
 302         /* Initialize tx_buffer_count */
 303         ret = esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8 *) val,
 304                         sizeof(*val), ACQUIRE_LOCK);
 305
 306         if (ret) {
 307                 kfree(val);
 308                 return ret;
 309         }
 310
 311         *val = ((*val >> 16) & ESP_TX_BUFFER_MASK);
 312         esp_info("Tx Pre ======  %d\n", context->tx_buffer_count);
 313
 314         if (*val >= ESP_MAX_BUF_CNT)
 315                 context->tx_buffer_count = (*val) - ESP_MAX_BUF_CNT;
 316         else
 317                 context->tx_buffer_count = 0;
 318         esp_info("Tx Pos ======  %d\n", context->tx_buffer_count);
 319
 320         kfree(val);
 321         return ret;
 322 }
 323
 324 static int init_context(struct esp_sdio_context *context)
 325 {
 326         int ret = 0;
 327         uint8_t prio_q_idx = 0;
 328
 329         if (!context) {
 330                 return -EINVAL;
 331         }
 332
 333         ret = get_firmware_data(context);
 334         if (ret)
 335                 return ret;
 336
 337         context->adapter = esp_get_adapter();
 338
 339         if (unlikely(!context->adapter))
 340                 esp_err("Failed to get adapter\n");
 341
 342         for (prio_q_idx = 0; prio_q_idx < MAX_PRIORITY_QUEUES; prio_q_idx++) {
 343                 skb_queue_head_init(&(sdio_context.tx_q[prio_q_idx]));
 344                 atomic_set(&queue_items[prio_q_idx], 0);
 345         }
 346
 347         context->adapter->if_type = ESP_IF_TYPE_SDIO;
 348
 349         return ret;
 350 }
 351
 352 static struct sk_buff *read_packet(struct esp_adapter *adapter)
 353 {
 354         u32 len_from_slave, data_left, len_to_read, size, num_blocks;
 355         int ret = 0;
 356         struct sk_buff *skb;
 357         u8 *pos;
 358         struct esp_sdio_context *context;
 359
 360         if (!adapter || !adapter->if_context) {
 361                 esp_err("INVALID args\n");
 362                 return NULL;
 363         }
 364
 365         context = adapter->if_context;
 366
 367         if (!context ||  (context->state != ESP_CONTEXT_READY) || !context->func) {
 368                 esp_err("Invalid context/state\n");
 369                 return NULL;
 370         }
 371
 372         sdio_claim_host(context->func);
 373
 374         data_left = len_to_read = len_from_slave = num_blocks = 0;
 375
 376         /* Read length */
 377         ret = esp_get_len_from_slave(context, &len_from_slave, LOCK_ALREADY_ACQUIRED);
 378
 379         if (ret || !len_from_slave) {
 380                 sdio_release_host(context->func);
 381                 return NULL;
 382         }
 383
 384         size = ESP_BLOCK_SIZE * 4;
 385
 386         if (len_from_slave > size) {
 387                 esp_info("Rx large packet: %d\n", len_from_slave);
 388         }
 389
 390         skb = esp_alloc_skb(len_from_slave);
 391
 392         if (!skb) {
 393                 esp_err("SKB alloc failed\n");
 394                 sdio_release_host(context->func);
 395                 return NULL;
 396         }
 397
 398         skb_put(skb, len_from_slave);
 399         pos = skb->data;
 400
 401         data_left = len_from_slave;
 402
 403         do {
 404                 num_blocks = data_left/ESP_BLOCK_SIZE;
 405
 406 #if 0
 407                 if (!context->rx_byte_count) {
 408                         start_time = ktime_get_ns();
 409                 }
 410 #endif
 411
 412                 if (num_blocks) {
 413                         len_to_read = num_blocks * ESP_BLOCK_SIZE;
 414                         ret = esp_read_block(context,
 415                                         ESP_SLAVE_CMD53_END_ADDR - len_to_read,
 416                                         pos, len_to_read, LOCK_ALREADY_ACQUIRED);
 417                 } else {
 418                         len_to_read = data_left;
 419                         /* 4 byte aligned length */
 420                         ret = esp_read_block(context,
 421                                         ESP_SLAVE_CMD53_END_ADDR - len_to_read,
 422                                         pos, (len_to_read + 3) & (~3), LOCK_ALREADY_ACQUIRED);
 423                 }
 424
 425                 if (ret) {
 426                         esp_err("Failed to read data - %d [%u - %d]\n", ret, num_blocks, len_to_read);
 427                         dev_kfree_skb(skb);
 428                         skb = NULL;
 429                         sdio_release_host(context->func);
 430                         return NULL;
 431                 }
 432
 433                 data_left -= len_to_read;
 434                 pos += len_to_read;
 435                 context->rx_byte_count += len_to_read;
 436                 context->rx_byte_count = context->rx_byte_count % ESP_RX_BYTE_MAX;
 437
 438         } while (data_left > 0);
 439
 440         sdio_release_host(context->func);
 441
 442         return skb;
 443 }
 444
 445 static int write_packet(struct esp_adapter *adapter, struct sk_buff *skb)
 446 {
 447         u32 max_pkt_size = ESP_RX_BUFFER_SIZE - sizeof(struct esp_payload_header);
 448         struct esp_payload_header *payload_header = (struct esp_payload_header *) skb->data;
 449         struct esp_skb_cb *cb = NULL;
 450         uint8_t prio = PRIO_Q_LOW;
 451
 452         if (!adapter || !adapter->if_context || !skb || !skb->data || !skb->len) {
 453                 esp_err("Invalid args\n");
 454                 if (skb) {
 455                         dev_kfree_skb(skb);
 456                         skb = NULL;
 457                 }
 458
 459                 return -EINVAL;
 460         }
 461
 462         if (skb->len > max_pkt_size) {
 463                 esp_err("Drop pkt of len[%u] > max SDIO transport len[%u]\n",
 464                                 skb->len, max_pkt_size);
 465                 dev_kfree_skb(skb);
 466                 skb = NULL;
 467                 return -EPERM;
 468         }
 469
 470         cb = (struct esp_skb_cb *)skb->cb;
 471         if (cb && cb->priv && (atomic_read(&tx_pending) >= TX_MAX_PENDING_COUNT)) {
 472                 esp_tx_pause(cb->priv);
 473                 dev_kfree_skb(skb);
 474                 skb = NULL;
 475 /*              esp_err("TX Pause busy");*/
 476                 return -EBUSY;
 477         }
 478
 479         /* Enqueue SKB in tx_q */
 480         atomic_inc(&tx_pending);
 481
 482         /* Notify to process queue */
 483         if (payload_header->if_type == ESP_INTERNAL_IF)
 484                 prio = PRIO_Q_HIGH;
 485         else if (payload_header->if_type == ESP_HCI_IF)
 486                 prio = PRIO_Q_MID;
 487         else
 488                 prio = PRIO_Q_LOW;
 489
 490         atomic_inc(&queue_items[prio]);
 491         skb_queue_tail(&(sdio_context.tx_q[prio]), skb);
 492
 493         return 0;
 494 }
 495
 496 static int is_sdio_write_buffer_available(u32 buf_needed)
 497 {
 498 #define BUFFER_AVAILABLE        1
 499 #define BUFFER_UNAVAILABLE      0
 500
 501         int ret = 0;
 502         static u32 buf_available;
 503         struct esp_sdio_context *context = &sdio_context;
 504         u8 retry = MAX_WRITE_RETRIES;
 505
 506         /*If buffer needed are less than buffer available
 507           then only read for available buffer number from slave*/
 508         if (buf_available < buf_needed) {
 509                 while (retry) {
 510                         ret = esp_slave_get_tx_buffer_num(context, &buf_available, ACQUIRE_LOCK);
 511
 512                         if (buf_available < buf_needed) {
 513
 514                                 /* Release SDIO and retry after delay*/
 515                                 retry--;
 516                                 usleep_range(10, 50);
 517                                 continue;
 518                         }
 519
 520                         break;
 521                 }
 522         }
 523
 524         if (buf_available >= buf_needed)
 525                 buf_available -= buf_needed;
 526
 527         if (!retry) {
 528                 /* No buffer available at slave */
 529                 return BUFFER_UNAVAILABLE;
 530         }
 531
 532         return BUFFER_AVAILABLE;
 533 }
 534
 535 static int tx_process(void *data)
 536 {
 537         int ret = 0;
 538         u32 block_cnt = 0;
 539         u32 buf_needed = 0;
 540         u8 *pos = NULL;
 541         u32 data_left, len_to_send, pad;
 542         struct sk_buff *tx_skb = NULL;
 543         struct esp_adapter *adapter = (struct esp_adapter *) data;
 544         struct esp_sdio_context *context = NULL;
 545         struct esp_skb_cb *cb = NULL;
 546         u8 retry;
 547
 548         context = adapter->if_context;
 549
 550         while (!kthread_should_stop()) {
 551
 552                 if (context->state != ESP_CONTEXT_READY) {
 553                         msleep(10);
 554                         esp_err("not ready");
 555                         continue;
 556                 }
 557
 558                 if (host_sleep) {
 559                         /* TODO: Use wait_event_interruptible_timeout */
 560                         msleep(100);
 561                         continue;
 562                 }
 563
 564                 if (atomic_read(&queue_items[PRIO_Q_HIGH]) > 0) {
 565                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_HIGH]));
 566                         if (!tx_skb) {
 567                                 continue;
 568                         }
 569                         atomic_dec(&queue_items[PRIO_Q_HIGH]);
 570                 } else if (atomic_read(&queue_items[PRIO_Q_MID]) > 0) {
 571                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_MID]));
 572                         if (!tx_skb) {
 573                                 continue;
 574                         }
 575                         atomic_dec(&queue_items[PRIO_Q_MID]);
 576                 } else if (atomic_read(&queue_items[PRIO_Q_LOW]) > 0) {
 577                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_LOW]));
 578                         if (!tx_skb) {
 579                                 continue;
 580                         }
 581                         atomic_dec(&queue_items[PRIO_Q_LOW]);
 582                 } else {
 583 #if 0
 584                         esp_err("not ready 2 [%d %d]\n",
 585                                         atomic_read(&queue_items[PRIO_Q_OTHERS]),
 586                                         atomic_read(&queue_items[PRIO_Q_SERIAL]));
 587 #endif
 588                         msleep(1);
 589                         continue;
 590                 }
 591
 592                 if (atomic_read(&tx_pending))
 593                         atomic_dec(&tx_pending);
 594
 595                 retry = MAX_WRITE_RETRIES;
 596
 597                 /* resume network tx queue if bearable load */
 598                 cb = (struct esp_skb_cb *)tx_skb->cb;
 599                 if (cb && cb->priv && atomic_read(&tx_pending) < TX_RESUME_THRESHOLD) {
 600                         esp_tx_resume(cb->priv);
 601                         #if TEST_RAW_TP
 602                                 esp_raw_tp_queue_resume();
 603                         #endif
 604                 }
 605
 606                 buf_needed = (tx_skb->len + ESP_RX_BUFFER_SIZE - 1) / ESP_RX_BUFFER_SIZE;
 607
 608                 /*If SDIO slave buffer is available to write then only write data
 609                 else wait till buffer is available*/
 610                 ret = is_sdio_write_buffer_available(buf_needed);
 611                 if (!ret) {
 612                         dev_kfree_skb(tx_skb);
 613                         continue;
 614                 }
 615
 616                 pos = tx_skb->data;
 617                 data_left = len_to_send = 0;
 618
 619                 data_left = tx_skb->len;
 620                 pad = ESP_BLOCK_SIZE - (data_left % ESP_BLOCK_SIZE);
 621                 data_left += pad;
 622
 623
 624                 do {
 625                         block_cnt = data_left / ESP_BLOCK_SIZE;
 626                         len_to_send = data_left;
 627                         ret = esp_write_block(context, ESP_SLAVE_CMD53_END_ADDR - len_to_send,
 628                                         pos, (len_to_send + 3) & (~3), ACQUIRE_LOCK);
 629
 630                         if (ret) {
 631                                 esp_err("Failed to send data: %d %d %d\n", ret, len_to_send, data_left);
 632                                 break;
 633                         }
 634
 635                         data_left -= len_to_send;
 636                         pos += len_to_send;
 637                 } while (data_left);
 638
 639                 if (ret) {
 640                         /* drop the packet */
 641                         dev_kfree_skb(tx_skb);
 642                         continue;
 643                 }
 644
 645                 context->tx_buffer_count += buf_needed;
 646                 context->tx_buffer_count = context->tx_buffer_count % ESP_TX_BUFFER_MAX;
 647
 648                 dev_kfree_skb(tx_skb);
 649                 tx_skb = NULL;
 650         }
 651
 652         do_exit(0);
 653         return 0;
 654 }
 655
 656 static struct esp_sdio_context *init_sdio_func(struct sdio_func *func)
 657 {
 658         struct esp_sdio_context *context = NULL;
 659         int ret = 0;
 660
 661         if (!func)
 662                 return NULL;
 663
 664         context = &sdio_context;
 665
 666         context->func = func;
 667
 668         sdio_claim_host(func);
 669
 670         /* Enable Function */
 671         ret = sdio_enable_func(func);
 672         if (ret) {
 673                 return NULL;
 674         }
 675
 676         /* Register IRQ */
 677         ret = sdio_claim_irq(func, esp_handle_isr);
 678         if (ret) {
 679                 sdio_disable_func(func);
 680                 return NULL;
 681         }
 682
 683         /* Set private data */
 684         sdio_set_drvdata(func, context);
 685
 686         context->state = ESP_CONTEXT_INIT;
 687
 688         sdio_release_host(func);
 689
 690         return context;
 691 }
 692
 693 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
 694 static int monitor_process(void *data)
 695 {
 696         u32 val, intr, len_reg, rdata, old_len = 0;
 697         struct esp_sdio_context *context = (struct esp_sdio_context *) data;
 698         struct sk_buff *skb;
 699
 700         while (!kthread_should_stop()) {
 701                 msleep(5000);
 702
 703                 val = intr = len_reg = rdata = 0;
 704
 705                 esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
 706                                 (u8 *) &val, sizeof(val), ACQUIRE_LOCK);
 707
 708                 len_reg = val & ESP_SLAVE_LEN_MASK;
 709
 710                 val = 0;
 711                 esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8 *) &val,
 712                                 sizeof(val), ACQUIRE_LOCK);
 713
 714                 rdata = ((val >> 16) & ESP_TX_BUFFER_MASK);
 715
 716                 esp_read_reg(context, ESP_SLAVE_INT_ST_REG,
 717                                 (u8 *) &intr, sizeof(intr), ACQUIRE_LOCK);
 718
 719
 720                 if (len_reg > context->rx_byte_count) {
 721                         if (old_len && (context->rx_byte_count == old_len)) {
 722                                 esp_dbg("Monitor thread ----> [%d - %d] [%d - %d] %d\n",
 723                                                 len_reg, context->rx_byte_count,
 724                                                 rdata, context->tx_buffer_count, intr);
 725
 726                                 skb = read_packet(context->adapter);
 727
 728                                 if (!skb)
 729                                         continue;
 730
 731                                 if (skb->len)
 732                                         esp_dbg("Flushed %d bytes\n", skb->len);
 733
 734                                 /* drop the packet */
 735                                 dev_kfree_skb(skb);
 736                                 skb = NULL;
 737                         }
 738                 }
 739
 740                 old_len = context->rx_byte_count;
 741         }
 742
 743         do_exit(0);
 744         return 0;
 745 }
 746 #endif
 747
 748 static int esp_probe(struct sdio_func *func,
 749                                   const struct sdio_device_id *id)
 750 {
 751         struct esp_sdio_context *context = NULL;
 752         int ret = 0;
 753
 754         if (func->num != 1) {
 755                 return -EINVAL;
 756         }
 757
 758         esp_info("ESP network device detected\n");
 759
 760         context = init_sdio_func(func);
 761
 762         if (!context) {
 763                 return -EINVAL;
 764         }
 765
 766         if (sdio_context.sdio_clk_mhz) {
 767                 struct mmc_host *host = func->card->host;
 768                 u32 hz = sdio_context.sdio_clk_mhz * NUMBER_1M;
 769                 /* Expansion of mmc_set_clock that isnt exported */
 770                 if (hz < host->f_min)
 771                         hz = host->f_min;
 772                 if (hz > host->f_max)
 773                         hz = host->f_max;
 774                 host->ios.clock = hz;
 775                 host->ops->set_ios(host, &host->ios);
 776         }
 777
 778         context->state = ESP_CONTEXT_READY;
 779         atomic_set(&tx_pending, 0);
 780         ret = init_context(context);
 781         if (ret) {
 782                 deinit_sdio_func(func);
 783                 return ret;
 784         }
 785
 786         tx_thread = kthread_run(tx_process, context->adapter, "esp32_TX");
 787
 788         if (!tx_thread)
 789                 esp_err("Failed to create esp32_sdio TX thread\n");
 790
 791         context->adapter->dev = &func->dev;
 792         generate_slave_intr(context, BIT(ESP_OPEN_DATA_PATH));
 793
 794
 795 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
 796         monitor_thread = kthread_run(monitor_process, context, "Monitor process");
 797
 798         if (!monitor_thread)
 799                 esp_err("Failed to create monitor thread\n");
 800 #endif
 801
 802         return ret;
 803 }
 804
 805 static int esp_suspend(struct device *dev)
 806 {
 807         struct sdio_func *func = NULL;
 808         struct esp_sdio_context *context = NULL;
 809
 810         if (!dev) {
 811                 esp_info("Failed to inform ESP that host is suspending\n");
 812                 return -1;
 813         }
 814
 815         func = dev_to_sdio_func(dev);
 816
 817         esp_info("----> Host Suspend\n");
 818         msleep(1000);
 819
 820         context = sdio_get_drvdata(func);
 821
 822         if (!context) {
 823                 esp_info("Failed to inform ESP that host is suspending\n");
 824                 return -1;
 825         }
 826
 827         host_sleep = 1;
 828
 829         generate_slave_intr(context, BIT(ESP_POWER_SAVE_ON));
 830         msleep(10);
 831
 832         sdio_set_host_pm_flags(func, MMC_PM_KEEP_POWER);
 833 #if 0
 834         /* Enale OOB IRQ and host wake up */
 835         enable_irq(SDIO_OOB_IRQ);
 836         enable_irq_wake(SDIO_OOB_IRQ);
 837 #endif
 838         return 0;
 839 }
 840
 841 static int esp_resume(struct device *dev)
 842 {
 843         struct sdio_func *func = NULL;
 844         struct esp_sdio_context *context = NULL;
 845
 846         if (!dev) {
 847                 esp_info("Failed to inform ESP that host is awake\n");
 848                 return -1;
 849         }
 850
 851         func = dev_to_sdio_func(dev);
 852
 853         esp_info("-----> Host Awake\n");
 854 #if 0
 855         /* Host woke up.. Disable OOB IRQ */
 856         disable_irq_wake(SDIO_OOB_IRQ);
 857         disable_irq(SDIO_OOB_IRQ);
 858 #endif
 859
 860
 861         context = sdio_get_drvdata(func);
 862
 863         if (!context) {
 864                 esp_info("Failed to inform ESP that host is awake\n");
 865                 return -1;
 866         }
 867
 868         /*     generate_slave_intr(context, BIT(ESP_RESET));*/
 869         get_firmware_data(context);
 870         msleep(100);
 871         generate_slave_intr(context, BIT(ESP_POWER_SAVE_OFF));
 872         host_sleep = 0;
 873         return 0;
 874 }
 875
 876 static const struct dev_pm_ops esp_pm_ops = {
 877         .suspend = esp_suspend,
 878         .resume = esp_resume,
 879 };
 880
 881 static const struct of_device_id esp_sdio_of_match[] = {
 882         { .compatible = "espressif,esp_sdio", },
 883         { /* sentinel */ }
 884 };
 885 MODULE_DEVICE_TABLE(of, esp_sdio_of_match);
 886
 887 /* SDIO driver structure to be registered with kernel */
 888 static struct sdio_driver esp_sdio_driver = {
 889         .name           = "esp_sdio",
 890         .id_table       = esp_devices,
 891         .probe          = esp_probe,
 892         .remove         = esp_remove,
 893         .drv = {
 894                 .name = "esp_sdio",
 895                 .owner = THIS_MODULE,
 896                 .pm = &esp_pm_ops,
 897                 .of_match_table = esp_sdio_of_match,
 898         },
 899 };
 900
 901 int esp_init_interface_layer(struct esp_adapter *adapter, u32 speed)
 902 {
 903         if (!adapter)
 904                 return -EINVAL;
 905
 906         adapter->if_context = &sdio_context;
 907         adapter->if_ops = &if_ops;
 908         sdio_context.adapter = adapter;
 909         sdio_context.sdio_clk_mhz = speed;
 910
 911         return sdio_register_driver(&esp_sdio_driver);
 912 }
 913
 914 void process_event_esp_bootup(struct esp_adapter *adapter, u8 *evt_buf, u8 len)
 915 {
 916         u8 len_left = len, tag_len;
 917         u8 *pos;
 918         struct esp_sdio_context *context = &sdio_context;
 919
 920         if (!adapter)
 921                 return;
 922
 923         if (!evt_buf)
 924                 return;
 925
 926         pos = evt_buf;
 927
 928         while (len_left) {
 929                 tag_len = *(pos + 1);
 930
 931                 esp_info("EVENT: %d\n", *pos);
 932
 933                 if (*pos == ESP_BOOTUP_CAPABILITY) {
 934
 935                         adapter->capabilities = *(pos + 2);
 936                         process_capabilities(adapter);
 937                         print_capabilities(*(pos + 2));
 938
 939                 } else if (*pos == ESP_BOOTUP_FIRMWARE_CHIP_ID) {
 940
 941                         esp_info("ESP chipset detected [%s]\n",
 942                                 *(pos+2) == ESP_FIRMWARE_CHIP_ESP32 ? "esp32" :
 943                                 *(pos+2) == ESP_FIRMWARE_CHIP_ESP32S2 ? "esp32-s2" :
 944                                 *(pos+2) == ESP_FIRMWARE_CHIP_ESP32S3 ? "esp32-s3" :
 945                                 *(pos+2) == ESP_FIRMWARE_CHIP_ESP32C2 ? "esp32-c2" :
 946                                 *(pos+2) == ESP_FIRMWARE_CHIP_ESP32C3 ? "esp32-c3" :
 947                                 *(pos+2) == ESP_FIRMWARE_CHIP_ESP32C6 ? "esp32-c6" :
 948                                 "unknown");
 949
 950                         if ((*(pos+2) != ESP_FIRMWARE_CHIP_ESP32) && (*(pos+2) != ESP_FIRMWARE_CHIP_ESP32C6))
 951                                 esp_err("SDIO is only supported with ESP32/ESP32C6\n");
 952
 953                 } else if (*pos == ESP_BOOTUP_TEST_RAW_TP) {
 954                         process_test_capabilities(*(pos + 2));
 955
 956                 } else if (*pos == ESP_BOOTUP_FW_DATA) {
 957
 958                         if (tag_len != sizeof(struct fw_data))
 959                                 esp_info("Length not matching to firmware data size\n");
 960                         else
 961                                 if (process_fw_data((struct fw_data *)(pos + 2)))
 962                                         if (context->func) {
 963                                                 generate_slave_intr(context, BIT(ESP_CLOSE_DATA_PATH));
 964                                                 return;
 965                                         }
 966
 967                 } else {
 968                         esp_warn("Unsupported tag in event");
 969                 }
 970
 971                 pos += (tag_len+2);
 972                 len_left -= (tag_len+2);
 973         }
 974
 975         if (esp_add_card(adapter)) {
 976                 esp_err("network iterface init failed\n");
 977                 generate_slave_intr(context, BIT(ESP_CLOSE_DATA_PATH));
 978         }
 979 }
 980
 981 void esp_deinit_interface_layer(void)
 982 {
 983         sdio_unregister_driver(&esp_sdio_driver);
 984 }