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