host/linux/host_driver/esp32/sdio/esp_sdio.c

   1 /*
   2  * Espressif Systems Wireless LAN device driver
   3  *
   4  * Copyright (C) 2015-2021 Espressif Systems (Shanghai) PTE LTD
   5  *
   6  * This software file (the "File") is distributed by Espressif Systems (Shanghai)
   7  * PTE LTD under the terms of the GNU General Public License Version 2, June 1991
   8  * (the "License").  You may use, redistribute and/or modify this File in
   9  * accordance with the terms and conditions of the License, a copy of which
  10  * is available by writing to the Free Software Foundation, Inc.,
  11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
  12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
  13  *
  14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
  17  * this warranty disclaimer.
  18  */
  19
  20 #include <linux/mutex.h>
  21 #include <linux/mmc/sdio.h>
  22 #include <linux/mmc/sdio_func.h>
  23 #include <linux/mmc/sdio_ids.h>
  24 #include <linux/mmc/card.h>
  25 #include <linux/mmc/host.h>
  26 #include "esp_if.h"
  27 #include "esp_sdio_api.h"
  28 #include "esp_api.h"
  29 #include "esp_bt_api.h"
  30 #ifdef CONFIG_SUPPORT_ESP_SERIAL
  31 #include "esp_serial.h"
  32 #endif
  33 #include <linux/kthread.h>
  34 #include <linux/printk.h>
  35
  36 #define MAX_WRITE_RETRIES       2
  37 #define TX_MAX_PENDING_COUNT    200
  38 #define TX_RESUME_THRESHOLD     (TX_MAX_PENDING_COUNT/5)
  39
  40 #define CHECK_SDIO_RW_ERROR(ret) do {                   \
  41         if (ret)                                                \
  42         printk(KERN_ERR "%s: CMD53 read/write error at %d\n", __func__, __LINE__);      \
  43 } while (0);
  44
  45 struct esp_sdio_context sdio_context;
  46 static atomic_t tx_pending;
  47 static atomic_t queue_items[MAX_PRIORITY_QUEUES];
  48
  49 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
  50 struct task_struct *monitor_thread;
  51 #endif
  52 struct task_struct *tx_thread;
  53
  54 static int init_context(struct esp_sdio_context *context);
  55 static struct sk_buff * read_packet(struct esp_adapter *adapter);
  56 static int write_packet(struct esp_adapter *adapter, struct sk_buff *skb);
  57 /*int deinit_context(struct esp_adapter *adapter);*/
  58
  59 static const struct sdio_device_id esp_devices[] = {
  60         { SDIO_DEVICE(ESP_VENDOR_ID, ESP_DEVICE_ID_1) },
  61         { SDIO_DEVICE(ESP_VENDOR_ID, ESP_DEVICE_ID_2) },
  62         {}
  63 };
  64
  65 static void print_capabilities(u32 cap)
  66 {
  67         printk(KERN_INFO "Features supported are:\n");
  68         if (cap & ESP_WLAN_SDIO_SUPPORT)
  69                 printk(KERN_INFO "\t * WLAN\n");
  70         if ((cap & ESP_BT_UART_SUPPORT) || (cap & ESP_BT_SDIO_SUPPORT)) {
  71                 printk(KERN_INFO "\t * BT/BLE\n");
  72                 if (cap & ESP_BT_UART_SUPPORT)
  73                         printk(KERN_INFO "\t   - HCI over UART\n");
  74                 if (cap & ESP_BT_SDIO_SUPPORT)
  75                         printk(KERN_INFO "\t   - HCI over SDIO\n");
  76
  77                 if ((cap & ESP_BLE_ONLY_SUPPORT) && (cap & ESP_BR_EDR_ONLY_SUPPORT))
  78                         printk(KERN_INFO "\t   - BT/BLE dual mode\n");
  79                 else if (cap & ESP_BLE_ONLY_SUPPORT)
  80                         printk(KERN_INFO "\t   - BLE only\n");
  81                 else if (cap & ESP_BR_EDR_ONLY_SUPPORT)
  82                         printk(KERN_INFO "\t   - BR EDR only\n");
  83         }
  84 }
  85
  86 static void esp_process_interrupt(struct esp_sdio_context *context, u32 int_status)
  87 {
  88         if (!context) {
  89                 return;
  90         }
  91
  92         if (int_status & ESP_SLAVE_RX_NEW_PACKET_INT) {
  93                 esp_process_new_packet_intr(context->adapter);
  94         }
  95 }
  96
  97 static void esp_handle_isr(struct sdio_func *func)
  98 {
  99         struct esp_sdio_context *context = NULL;
 100         u32 *int_status;
 101         int ret;
 102
 103         if (!func) {
 104                 return;
 105         }
 106
 107         context = sdio_get_drvdata(func);
 108
 109         if (!context) {
 110                 return;
 111         }
 112
 113         int_status = kmalloc(sizeof(u32), GFP_ATOMIC);
 114
 115         if (!int_status) {
 116                 return;
 117         }
 118
 119         /* Read interrupt status register */
 120         ret = esp_read_reg(context, ESP_SLAVE_INT_ST_REG,
 121                         (u8 *) int_status, sizeof(* int_status), ACQUIRE_LOCK);
 122         CHECK_SDIO_RW_ERROR(ret);
 123
 124         esp_process_interrupt(context, *int_status);
 125
 126         /* Clear interrupt status */
 127         ret = esp_write_reg(context, ESP_SLAVE_INT_CLR_REG,
 128                         (u8 *) int_status, sizeof(* int_status), ACQUIRE_LOCK);
 129         CHECK_SDIO_RW_ERROR(ret);
 130
 131         kfree(int_status);
 132 }
 133
 134 int generate_slave_intr(struct esp_sdio_context *context, u8 data)
 135 {
 136         u8 *val;
 137         int ret = 0;
 138
 139         if (!context)
 140                 return -EINVAL;
 141
 142         val = kmalloc(sizeof(u8), GFP_KERNEL);
 143
 144         if (!val) {
 145                 return -ENOMEM;
 146         }
 147
 148         *val = data;
 149
 150         ret = esp_write_reg(context, ESP_SLAVE_SCRATCH_REG_7, val,
 151                         sizeof(*val), ACQUIRE_LOCK);
 152
 153         kfree(val);
 154
 155         return ret;
 156 }
 157
 158 static void deinit_sdio_func(struct sdio_func *func)
 159 {
 160         sdio_claim_host(func);
 161         /* Release IRQ */
 162         sdio_release_irq(func);
 163         /* Disable sdio function */
 164         sdio_disable_func(func);
 165         sdio_release_host(func);
 166         sdio_set_drvdata(func, NULL);
 167 }
 168
 169 static int esp_slave_get_tx_buffer_num(struct esp_sdio_context *context, u32 *tx_num, u8 is_lock_needed)
 170 {
 171         u32 *len = NULL;
 172         int ret = 0;
 173
 174         len = kmalloc(sizeof(u32), GFP_KERNEL);
 175
 176         if (!len) {
 177                 return -ENOMEM;
 178         }
 179
 180         ret = esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8*) len, sizeof(*len), is_lock_needed);
 181
 182         if (ret) {
 183                 kfree(len);
 184                 return ret;
 185         }
 186
 187         *len = (*len >> 16) & ESP_TX_BUFFER_MASK;
 188         *len = (*len + ESP_TX_BUFFER_MAX - context->tx_buffer_count) % ESP_TX_BUFFER_MAX;
 189
 190         *tx_num = *len;
 191
 192         kfree(len);
 193         return ret;
 194 }
 195
 196 static int esp_get_len_from_slave(struct esp_sdio_context *context, u32 *rx_size, u8 is_lock_needed)
 197 {
 198         u32 *len;
 199         u32 temp;
 200         int ret = 0;
 201
 202         len = kmalloc(sizeof(u32), GFP_KERNEL);
 203
 204         if (!len) {
 205                 return -ENOMEM;
 206         }
 207
 208         ret = esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
 209                         (u8 *) len, sizeof(*len), is_lock_needed);
 210
 211         if (ret) {
 212                 kfree (len);
 213                 return ret;
 214         }
 215
 216         *len &= ESP_SLAVE_LEN_MASK;
 217
 218         if (*len >= context->rx_byte_count)
 219                 *len = (*len + ESP_RX_BYTE_MAX - context->rx_byte_count) % ESP_RX_BYTE_MAX;
 220         else {
 221                 /* Handle a case of roll over */
 222                 temp = ESP_RX_BYTE_MAX - context->rx_byte_count;
 223                 *len = temp + *len;
 224
 225                 if (*len > ESP_RX_BUFFER_SIZE) {
 226                         printk(KERN_INFO "%s: Len from slave[%d] exceeds max [%d]\n",
 227                                         __func__, *len, ESP_RX_BUFFER_SIZE);
 228                 }
 229         }
 230         *rx_size = *len;
 231
 232         kfree (len);
 233         return 0;
 234 }
 235
 236
 237 static void flush_sdio(struct esp_sdio_context *context)
 238 {
 239         struct sk_buff *skb;
 240
 241         if (!context || !context->adapter)
 242                 return;
 243
 244         while (1) {
 245                 skb = read_packet(context->adapter);
 246
 247                 if (!skb) {
 248                         break;
 249                 }
 250
 251                 if (skb->len)
 252                         printk (KERN_INFO "%s: Flushed %d bytes\n", __func__, skb->len);
 253                 dev_kfree_skb(skb);
 254         }
 255 }
 256
 257 static void esp_remove(struct sdio_func *func)
 258 {
 259         struct esp_sdio_context *context;
 260         uint8_t prio_q_idx = 0;
 261         context = sdio_get_drvdata(func);
 262
 263         printk(KERN_INFO "%s -> Remove card", __func__);
 264
 265 #ifdef CONFIG_SUPPORT_ESP_SERIAL
 266         esp_serial_cleanup();
 267 #endif
 268
 269 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
 270         if (monitor_thread)
 271                 kthread_stop(monitor_thread);
 272 #endif
 273
 274         if (tx_thread)
 275                 kthread_stop(tx_thread);
 276
 277         if (context) {
 278                 generate_slave_intr(context, BIT(ESP_CLOSE_DATA_PATH));
 279                 msleep(100);
 280
 281                 flush_sdio(context);
 282
 283                 if (context->adapter) {
 284                         esp_remove_card(context->adapter);
 285
 286                         if (context->adapter->hcidev) {
 287                                 esp_deinit_bt(context->adapter);
 288                         }
 289
 290                 }
 291                 for (prio_q_idx=0; prio_q_idx<MAX_PRIORITY_QUEUES; prio_q_idx++) {
 292                         skb_queue_purge(&(sdio_context.tx_q[prio_q_idx]));
 293                 }
 294
 295                 memset(context, 0, sizeof(struct esp_sdio_context));
 296         }
 297
 298         deinit_sdio_func(func);
 299
 300         printk (KERN_INFO "%s: Context deinit %d - %d\n", __func__, context->rx_byte_count,
 301                         context->tx_buffer_count);
 302
 303 }
 304
 305 static struct esp_if_ops if_ops = {
 306         .read           = read_packet,
 307         .write          = write_packet,
 308 };
 309
 310 static int init_context(struct esp_sdio_context *context)
 311 {
 312         int ret = 0;
 313         u32 *val;
 314         uint8_t prio_q_idx = 0;
 315
 316         if (!context) {
 317                 return -EINVAL;
 318         }
 319
 320         val = kmalloc(sizeof(u32), GFP_KERNEL);
 321
 322         if (!val) {
 323                 return -ENOMEM;
 324         }
 325
 326         /* Initialize rx_byte_count */
 327         ret = esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
 328                         (u8 *) val, sizeof(* val), ACQUIRE_LOCK);
 329         if (ret) {
 330                 kfree(val);
 331                 return ret;
 332         }
 333
 334         context->rx_byte_count = *val & ESP_SLAVE_LEN_MASK;
 335
 336         /* Initialize tx_buffer_count */
 337         ret = esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8 *) val,
 338                         sizeof(* val), ACQUIRE_LOCK);
 339
 340         if (ret) {
 341                 kfree(val);
 342                 return ret;
 343         }
 344
 345         *val = ((*val >> 16) & ESP_TX_BUFFER_MASK);
 346
 347         if (*val >= ESP_MAX_BUF_CNT)
 348                 context->tx_buffer_count = (*val) - ESP_MAX_BUF_CNT;
 349         else
 350                 context->tx_buffer_count = 0;
 351
 352         context->adapter = esp_get_adapter();
 353
 354         if (unlikely(!context->adapter))
 355                 printk (KERN_ERR "%s: Failed to get adapter\n", __func__);
 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         kfree(val);
 365         return ret;
 366 }
 367
 368 static struct sk_buff * read_packet(struct esp_adapter *adapter)
 369 {
 370         u32 len_from_slave, data_left, len_to_read, size, num_blocks;
 371         int ret = 0;
 372         struct sk_buff *skb;
 373         u8 *pos;
 374         struct esp_sdio_context *context;
 375
 376         if (!adapter || !adapter->if_context) {
 377                 printk (KERN_ERR "%s: INVALID args\n", __func__);
 378                 return NULL;
 379         }
 380
 381         context = adapter->if_context;
 382
 383         sdio_claim_host(context->func);
 384
 385         data_left = len_to_read = len_from_slave = num_blocks = 0;
 386
 387         /* Read length */
 388         ret = esp_get_len_from_slave(context, &len_from_slave, LOCK_ALREADY_ACQUIRED);
 389
 390         if (ret || !len_from_slave) {
 391                 sdio_release_host(context->func);
 392                 return NULL;
 393         }
 394
 395         size = ESP_BLOCK_SIZE * 4;
 396
 397         if (len_from_slave > size) {
 398                 printk(KERN_INFO "Rx large packet: %d\n", len_from_slave);
 399         }
 400
 401         skb = esp_alloc_skb(len_from_slave);
 402
 403         if (!skb) {
 404                 printk (KERN_ERR "%s: SKB alloc failed\n", __func__);
 405                 sdio_release_host(context->func);
 406                 return NULL;
 407         }
 408
 409         skb_put(skb, len_from_slave);
 410         pos = skb->data;
 411
 412         data_left = len_from_slave;
 413
 414         do {
 415                 num_blocks = data_left/ESP_BLOCK_SIZE;
 416
 417 #if 0
 418                 if (!context->rx_byte_count) {
 419                         start_time = ktime_get_ns();
 420                 }
 421 #endif
 422
 423                 if (num_blocks) {
 424                         len_to_read = num_blocks * ESP_BLOCK_SIZE;
 425                         ret = esp_read_block(context,
 426                                         ESP_SLAVE_CMD53_END_ADDR - len_to_read,
 427                                         pos, len_to_read, LOCK_ALREADY_ACQUIRED);
 428                 } else {
 429                         len_to_read = data_left;
 430                         /* 4 byte aligned length */
 431                         ret = esp_read_block(context,
 432                                         ESP_SLAVE_CMD53_END_ADDR - len_to_read,
 433                                         pos, (len_to_read + 3) & (~3), LOCK_ALREADY_ACQUIRED);
 434                 }
 435
 436                 if (ret) {
 437                         printk (KERN_ERR "%s: Failed to read data - %d [%u - %d]\n", __func__, ret, num_blocks, len_to_read);
 438                         dev_kfree_skb(skb);
 439                         sdio_release_host(context->func);
 440                         return NULL;
 441                 }
 442
 443                 data_left -= len_to_read;
 444                 pos += len_to_read;
 445                 context->rx_byte_count += len_to_read;
 446                 context->rx_byte_count = context->rx_byte_count % ESP_RX_BYTE_MAX;
 447
 448         } while (data_left > 0);
 449
 450         sdio_release_host(context->func);
 451
 452         return skb;
 453 }
 454
 455 static int write_packet(struct esp_adapter *adapter, struct sk_buff *skb)
 456 {
 457         u32 max_pkt_size = ESP_RX_BUFFER_SIZE;
 458         struct esp_payload_header *payload_header = (struct esp_payload_header *) skb->data;
 459
 460         if (!adapter || !adapter->if_context || !skb || !skb->data || !skb->len) {
 461                 printk(KERN_ERR "%s: Invalid args\n", __func__);
 462                 if(skb)
 463                         dev_kfree_skb(skb);
 464
 465                 return -EINVAL;
 466         }
 467
 468         if (skb->len > max_pkt_size) {
 469                 printk(KERN_ERR "%s: Drop pkt of len[%u] > max SDIO transport len[%u]\n",
 470                                 __func__, skb->len, max_pkt_size);
 471                 dev_kfree_skb(skb);
 472                 return -EPERM;
 473         }
 474
 475         if (atomic_read(&tx_pending) >= TX_MAX_PENDING_COUNT) {
 476                 esp_tx_pause();
 477                 dev_kfree_skb(skb);
 478                 return -EBUSY;
 479         }
 480
 481         /* Enqueue SKB in tx_q */
 482         atomic_inc(&tx_pending);
 483
 484         /* Notify to process queue */
 485         if (payload_header->if_type == ESP_SERIAL_IF) {
 486                 atomic_inc(&queue_items[PRIO_Q_SERIAL]);
 487                 skb_queue_tail(&(sdio_context.tx_q[PRIO_Q_SERIAL]), skb);
 488         } else if (payload_header->if_type == ESP_HCI_IF) {
 489                 atomic_inc(&queue_items[PRIO_Q_BT]);
 490                 skb_queue_tail(&(sdio_context.tx_q[PRIO_Q_BT]), skb);
 491         } else {
 492                 atomic_inc(&queue_items[PRIO_Q_OTHERS]);
 493                 skb_queue_tail(&(sdio_context.tx_q[PRIO_Q_OTHERS]), skb);
 494         }
 495
 496         return 0;
 497 }
 498
 499 static int tx_process(void *data)
 500 {
 501         int ret = 0;
 502         u32 block_cnt = 0;
 503         u32 buf_needed = 0, buf_available = 0;
 504         u8 *pos = NULL;
 505         u32 data_left, len_to_send, pad;
 506         struct sk_buff *tx_skb = NULL;
 507         struct esp_adapter *adapter = (struct esp_adapter *) data;
 508         struct esp_sdio_context *context = NULL;
 509         u8 retry;
 510
 511         context = adapter->if_context;
 512
 513         while (!kthread_should_stop()) {
 514
 515                 if (context->state != ESP_CONTEXT_READY) {
 516                         msleep(10);
 517                         continue;
 518                 }
 519
 520                 if (atomic_read(&queue_items[PRIO_Q_SERIAL]) > 0) {
 521                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_SERIAL]));
 522                         if (!tx_skb) {
 523                                 continue;
 524                         }
 525                         atomic_dec(&queue_items[PRIO_Q_SERIAL]);
 526                 }else if (atomic_read(&queue_items[PRIO_Q_BT]) > 0) {
 527                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_BT]));
 528                         if (!tx_skb) {
 529                                 continue;
 530                         }
 531                         atomic_dec(&queue_items[PRIO_Q_BT]);
 532                 } else if (atomic_read(&queue_items[PRIO_Q_OTHERS]) > 0) {
 533                         tx_skb = skb_dequeue(&(context->tx_q[PRIO_Q_OTHERS]));
 534                         if (!tx_skb) {
 535                                 continue;
 536                         }
 537                         atomic_dec(&queue_items[PRIO_Q_OTHERS]);
 538                 } else {
 539                         msleep(1);
 540                         continue;
 541                 }
 542
 543                 if (atomic_read(&tx_pending))
 544                         atomic_dec(&tx_pending);
 545
 546                 retry = MAX_WRITE_RETRIES;
 547
 548                 /* resume network tx queue if bearable load */
 549                 if (atomic_read(&tx_pending) < TX_RESUME_THRESHOLD) {
 550                         esp_tx_resume();
 551                 }
 552
 553                 buf_needed = (tx_skb->len + ESP_RX_BUFFER_SIZE - 1) / ESP_RX_BUFFER_SIZE;
 554
 555                 while (retry) {
 556                         sdio_claim_host(context->func);
 557
 558                         ret = esp_slave_get_tx_buffer_num(context, &buf_available, LOCK_ALREADY_ACQUIRED);
 559
 560                         if (buf_available < buf_needed) {
 561                                 sdio_release_host(context->func);
 562
 563                                 /* Release SDIO and retry after delay*/
 564                                 retry--;
 565                                 usleep_range(10,50);
 566                                 continue;
 567                         }
 568
 569                         break;
 570                 }
 571
 572                 if (!retry) {
 573                         /* No buffer available at slave */
 574                         dev_kfree_skb(tx_skb);
 575                         continue;
 576                 }
 577
 578                 pos = tx_skb->data;
 579                 data_left = len_to_send = 0;
 580
 581                 data_left = tx_skb->len;
 582                 pad = ESP_BLOCK_SIZE - (data_left % ESP_BLOCK_SIZE);
 583                 data_left += pad;
 584
 585
 586                 do {
 587                         block_cnt = data_left / ESP_BLOCK_SIZE;
 588                         len_to_send = data_left;
 589                         ret = esp_write_block(context, ESP_SLAVE_CMD53_END_ADDR - len_to_send,
 590                                         pos, (len_to_send + 3) & (~3), LOCK_ALREADY_ACQUIRED);
 591
 592                         if (ret) {
 593                                 printk (KERN_ERR "%s: Failed to send data: %d %d %d\n", __func__, ret, len_to_send, data_left);
 594                                 sdio_release_host(context->func);
 595                                 break;
 596                         }
 597
 598                         data_left -= len_to_send;
 599                         pos += len_to_send;
 600                 } while (data_left);
 601
 602                 if (ret) {
 603                         /* drop the packet */
 604                         dev_kfree_skb(tx_skb);
 605                         continue;
 606                 }
 607
 608                 context->tx_buffer_count += buf_needed;
 609                 context->tx_buffer_count = context->tx_buffer_count % ESP_TX_BUFFER_MAX;
 610
 611                 sdio_release_host(context->func);
 612                 dev_kfree_skb(tx_skb);
 613         }
 614
 615         do_exit(0);
 616         return 0;
 617 }
 618
 619 static struct esp_sdio_context * init_sdio_func(struct sdio_func *func)
 620 {
 621         struct esp_sdio_context *context = NULL;
 622         int ret = 0;
 623
 624         if (!func)
 625                 return NULL;
 626
 627         context = &sdio_context;
 628
 629         context->func = func;
 630
 631         sdio_claim_host(func);
 632
 633         /* Enable Function */
 634         ret = sdio_enable_func(func);
 635         if (ret) {
 636                 return NULL;
 637         }
 638
 639         /* Register IRQ */
 640         ret = sdio_claim_irq(func, esp_handle_isr);
 641         if (ret) {
 642                 sdio_disable_func(func);
 643                 return NULL;
 644         }
 645
 646         /* Set private data */
 647         sdio_set_drvdata(func, context);
 648
 649         context->state = ESP_CONTEXT_INIT;
 650
 651         sdio_release_host(func);
 652
 653         return context;
 654 }
 655
 656 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
 657 static int monitor_process(void *data)
 658 {
 659         u32 val, intr, len_reg, rdata, old_len = 0;
 660         struct esp_sdio_context *context = (struct esp_sdio_context *) data;
 661         struct sk_buff *skb;
 662
 663         while (!kthread_should_stop()) {
 664                 msleep(5000);
 665
 666                 val = intr = len_reg = rdata = 0;
 667
 668                 esp_read_reg(context, ESP_SLAVE_PACKET_LEN_REG,
 669                                 (u8 *) &val, sizeof(val), ACQUIRE_LOCK);
 670
 671                 len_reg = val & ESP_SLAVE_LEN_MASK;
 672
 673                 val = 0;
 674                 esp_read_reg(context, ESP_SLAVE_TOKEN_RDATA, (u8 *) &val,
 675                                 sizeof(val), ACQUIRE_LOCK);
 676
 677                 rdata = ((val >> 16) & ESP_TX_BUFFER_MASK);
 678
 679                 esp_read_reg(context, ESP_SLAVE_INT_ST_REG,
 680                                 (u8 *) &intr, sizeof(intr), ACQUIRE_LOCK);
 681
 682
 683                 if (len_reg > context->rx_byte_count) {
 684                         if (old_len && (context->rx_byte_count == old_len)) {
 685                                 printk (KERN_DEBUG "Monitor thread ----> [%d - %d] [%d - %d] %d\n",
 686                                                 len_reg, context->rx_byte_count,
 687                                                 rdata, context->tx_buffer_count, intr);
 688
 689                                 skb = read_packet(context->adapter);
 690
 691                                 if (!skb)
 692                                         continue;
 693
 694                                 if (skb->len)
 695                                         printk (KERN_DEBUG "%s: Flushed %d bytes\n", __func__, skb->len);
 696
 697                                 /* drop the packet */
 698                                 dev_kfree_skb(skb);
 699                         }
 700                 }
 701
 702                 old_len = context->rx_byte_count;
 703         }
 704
 705         do_exit(0);
 706         return 0;
 707 }
 708 #endif
 709
 710 static int esp_probe(struct sdio_func *func,
 711                                   const struct sdio_device_id *id)
 712 {
 713         struct esp_sdio_context *context = NULL;
 714         int ret = 0;
 715
 716         if (func->num != 1) {
 717                 return -EINVAL;
 718         }
 719
 720         printk(KERN_INFO "%s: ESP network device detected\n", __func__);
 721
 722         context = init_sdio_func(func);
 723
 724         if (!context) {
 725                 return -ENOMEM;
 726         }
 727
 728         atomic_set(&tx_pending, 0);
 729         ret = init_context(context);
 730         if (ret) {
 731                 deinit_sdio_func(func);
 732                 return ret;
 733         }
 734
 735         tx_thread = kthread_run(tx_process, context->adapter, "esp32_TX");
 736
 737         if (!tx_thread)
 738                 printk (KERN_ERR "Failed to create esp32_sdio TX thread\n");
 739
 740 #ifdef CONFIG_SUPPORT_ESP_SERIAL
 741         ret = esp_serial_init((void *) context->adapter);
 742         if (ret != 0) {
 743                 esp_remove(func);
 744                 printk(KERN_ERR "Error initialising serial interface\n");
 745                 return ret;
 746         }
 747 #endif
 748
 749         ret = esp_add_card(context->adapter);
 750         if (ret) {
 751                 esp_remove(func);
 752                 printk (KERN_ERR "Failed to add card\n");
 753                 deinit_sdio_func(func);
 754                 return ret;
 755         }
 756
 757
 758
 759         context->state = ESP_CONTEXT_READY;
 760
 761 #ifdef CONFIG_ENABLE_MONITOR_PROCESS
 762         monitor_thread = kthread_run(monitor_process, context, "Monitor process");
 763
 764         if (!monitor_thread)
 765                 printk (KERN_ERR "Failed to create monitor thread\n");
 766 #endif
 767
 768         generate_slave_intr(context, BIT(ESP_OPEN_DATA_PATH));
 769         return ret;
 770 }
 771
 772 /* SDIO driver structure to be registered with kernel */
 773 static struct sdio_driver esp_sdio_driver = {
 774         .name           = "esp_sdio",
 775         .id_table       = esp_devices,
 776         .probe          = esp_probe,
 777         .remove         = esp_remove,
 778 };
 779
 780 int esp_init_interface_layer(struct esp_adapter *adapter)
 781 {
 782         if (!adapter)
 783                 return -EINVAL;
 784
 785         adapter->if_context = &sdio_context;
 786         adapter->if_ops = &if_ops;
 787         sdio_context.adapter = adapter;
 788
 789         return sdio_register_driver(&esp_sdio_driver);
 790 }
 791
 792 void process_init_event(u8 *evt_buf, u8 len)
 793 {
 794         u8 len_left = len, tag_len;
 795         u8 *pos;
 796
 797         if (!evt_buf)
 798                 return;
 799
 800         pos = evt_buf;
 801
 802         while (len_left) {
 803                 tag_len = *(pos + 1);
 804                 printk(KERN_INFO "EVENT: %d\n", *pos);
 805                 if (*pos == ESP_PRIV_CAPABILITY) {
 806                         process_capabilities(*(pos + 2));
 807                         print_capabilities(*(pos + 2));
 808                 } else {
 809                         printk (KERN_WARNING "Unsupported tag in event");
 810                 }
 811                 pos += (tag_len+2);
 812                 len_left -= (tag_len+2);
 813         }
 814 }
 815
 816 void esp_deinit_interface_layer(void)
 817 {
 818         sdio_unregister_driver(&esp_sdio_driver);
 819 }