drivers/staging/ks7010/ks7010_sdio.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *   Driver for KeyStream, KS7010 based SDIO cards.
   4  *
   5  *   Copyright (C) 2006-2008 KeyStream Corp.
   6  *   Copyright (C) 2009 Renesas Technology Corp.
   7  *   Copyright (C) 2016 Sang Engineering, Wolfram Sang
   8  */
   9
  10 #include <linux/atomic.h>
  11 #include <linux/firmware.h>
  12 #include <linux/jiffies.h>
  13 #include <linux/mmc/card.h>
  14 #include <linux/mmc/sdio_func.h>
  15 #include <linux/module.h>
  16 #include <linux/workqueue.h>
  17 #include "ks_wlan.h"
  18 #include "ks_hostif.h"
  19
  20 #define ROM_FILE "/*(DEBLOBBED)*/"
  21
  22 /*  SDIO KeyStream vendor and device */
  23 #define SDIO_VENDOR_ID_KS_CODE_A        0x005b
  24 #define SDIO_VENDOR_ID_KS_CODE_B        0x0023
  25
  26 /* Older sources suggest earlier versions were named 7910 or 79xx */
  27 #define SDIO_DEVICE_ID_KS_7010          0x7910
  28
  29 /* Read/Write Status Register */
  30 #define READ_STATUS_REG         0x000000
  31 #define WRITE_STATUS_REG        0x00000C
  32 enum reg_status_type {
  33         REG_STATUS_BUSY,
  34         REG_STATUS_IDLE
  35 };
  36
  37 /* Read Index Register */
  38 #define READ_INDEX_REG          0x000004
  39
  40 /* Read Data Size Register */
  41 #define READ_DATA_SIZE_REG      0x000008
  42
  43 /* Write Index Register */
  44 #define WRITE_INDEX_REG         0x000010
  45
  46 /*
  47  * Write Status/Read Data Size Register
  48  * for network packet (less than 2048 bytes data)
  49  */
  50 #define WSTATUS_RSIZE_REG       0x000014
  51
  52 /* Write Status Register value */
  53 #define WSTATUS_MASK            0x80
  54
  55 /* Read Data Size Register value [10:4] */
  56 #define RSIZE_MASK              0x7F
  57
  58 /* ARM to SD interrupt Enable */
  59 #define INT_ENABLE_REG          0x000020
  60 /* ARM to SD interrupt Pending */
  61 #define INT_PENDING_REG         0x000024
  62
  63 #define INT_GCR_B              BIT(7)
  64 #define INT_GCR_A              BIT(6)
  65 #define INT_WRITE_STATUS       BIT(5)
  66 #define INT_WRITE_INDEX        BIT(4)
  67 #define INT_WRITE_SIZE         BIT(3)
  68 #define INT_READ_STATUS        BIT(2)
  69 #define INT_READ_INDEX         BIT(1)
  70 #define INT_READ_SIZE          BIT(0)
  71
  72 /* General Communication Register A */
  73 #define GCR_A_REG               0x000028
  74 enum gen_com_reg_a {
  75         GCR_A_INIT,
  76         GCR_A_REMAP,
  77         GCR_A_RUN
  78 };
  79
  80 /* General Communication Register B */
  81 #define GCR_B_REG               0x00002C
  82 enum gen_com_reg_b {
  83         GCR_B_ACTIVE,
  84         GCR_B_DOZE
  85 };
  86
  87 /* Wakeup Register */
  88 #define WAKEUP_REG              0x008018
  89 #define WAKEUP_REQ              0x5a
  90
  91 /* AHB Data Window  0x010000-0x01FFFF */
  92 #define DATA_WINDOW             0x010000
  93 #define WINDOW_SIZE             (64 * 1024)
  94
  95 #define KS7010_IRAM_ADDRESS     0x06000000
  96
  97 #define KS7010_IO_BLOCK_SIZE 512
  98
  99 /**
 100  * struct ks_sdio_card - SDIO device data.
 101  *
 102  * Structure is used as the &struct sdio_func private data.
 103  *
 104  * @func: Pointer to the SDIO function device.
 105  * @priv: Pointer to the &struct net_device private data.
 106  */
 107 struct ks_sdio_card {
 108         struct sdio_func *func;
 109         struct ks_wlan_private *priv;
 110 };
 111
 112 static struct sdio_func *ks7010_to_func(struct ks_wlan_private *priv)
 113 {
 114         struct ks_sdio_card *ks_sdio = priv->if_hw;
 115
 116         return ks_sdio->func;
 117 }
 118
 119 /* Read single byte from device address into byte (CMD52) */
 120 static int ks7010_sdio_readb(struct ks_wlan_private *priv,
 121                              u32 address, u8 *byte)
 122 {
 123         struct sdio_func *func = ks7010_to_func(priv);
 124         int ret;
 125
 126         *byte = sdio_readb(func, address, &ret);
 127
 128         return ret;
 129 }
 130
 131 /* Read length bytes from device address into buffer (CMD53) */
 132 static int ks7010_sdio_read(struct ks_wlan_private *priv, u32 address,
 133                             u8 *buffer, unsigned int length)
 134 {
 135         struct sdio_func *func = ks7010_to_func(priv);
 136
 137         return sdio_memcpy_fromio(func, buffer, address, length);
 138 }
 139
 140 /* Write single byte to device address (CMD52) */
 141 static int ks7010_sdio_writeb(struct ks_wlan_private *priv,
 142                               u32 address, u8 byte)
 143 {
 144         struct sdio_func *func = ks7010_to_func(priv);
 145         int ret;
 146
 147         sdio_writeb(func, byte, address, &ret);
 148
 149         return ret;
 150 }
 151
 152 /* Write length bytes to device address from buffer (CMD53) */
 153 static int ks7010_sdio_write(struct ks_wlan_private *priv, u32 address,
 154                              u8 *buffer, unsigned int length)
 155 {
 156         struct sdio_func *func = ks7010_to_func(priv);
 157
 158         return sdio_memcpy_toio(func, address, buffer, length);
 159 }
 160
 161 static void ks_wlan_hw_sleep_doze_request(struct ks_wlan_private *priv)
 162 {
 163         int ret;
 164
 165         /* clear request */
 166         atomic_set(&priv->sleepstatus.doze_request, 0);
 167
 168         if (atomic_read(&priv->sleepstatus.status) == 0) {
 169                 ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE);
 170                 if (ret) {
 171                         netdev_err(priv->net_dev, "write GCR_B_REG\n");
 172                         goto set_sleep_mode;
 173                 }
 174                 atomic_set(&priv->sleepstatus.status, 1);
 175                 priv->last_doze = jiffies;
 176         }
 177
 178 set_sleep_mode:
 179         priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
 180 }
 181
 182 static void ks_wlan_hw_sleep_wakeup_request(struct ks_wlan_private *priv)
 183 {
 184         int ret;
 185
 186         /* clear request */
 187         atomic_set(&priv->sleepstatus.wakeup_request, 0);
 188
 189         if (atomic_read(&priv->sleepstatus.status) == 1) {
 190                 ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ);
 191                 if (ret) {
 192                         netdev_err(priv->net_dev, "write WAKEUP_REG\n");
 193                         goto set_sleep_mode;
 194                 }
 195                 atomic_set(&priv->sleepstatus.status, 0);
 196                 priv->last_wakeup = jiffies;
 197                 ++priv->wakeup_count;
 198         }
 199
 200 set_sleep_mode:
 201         priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
 202 }
 203
 204 void ks_wlan_hw_wakeup_request(struct ks_wlan_private *priv)
 205 {
 206         int ret;
 207
 208         if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 209                 ret = ks7010_sdio_writeb(priv, WAKEUP_REG, WAKEUP_REQ);
 210                 if (ret)
 211                         netdev_err(priv->net_dev, "write WAKEUP_REG\n");
 212
 213                 priv->last_wakeup = jiffies;
 214                 ++priv->wakeup_count;
 215         }
 216 }
 217
 218 static void _ks_wlan_hw_power_save(struct ks_wlan_private *priv)
 219 {
 220         u8 byte;
 221         int ret;
 222
 223         if (priv->reg.power_mgmt == POWER_MGMT_ACTIVE)
 224                 return;
 225
 226         if (priv->reg.operation_mode != MODE_INFRASTRUCTURE)
 227                 return;
 228
 229         if (!is_connect_status(priv->connect_status))
 230                 return;
 231
 232         if (priv->dev_state != DEVICE_STATE_SLEEP)
 233                 return;
 234
 235         if (atomic_read(&priv->psstatus.status) == PS_SNOOZE)
 236                 return;
 237
 238         netdev_dbg(priv->net_dev,
 239                    "STATUS:\n"
 240                    "- psstatus.status = %d\n"
 241                    "- psstatus.confirm_wait = %d\n"
 242                    "- psstatus.snooze_guard = %d\n"
 243                    "- txq_count = %d\n",
 244                    atomic_read(&priv->psstatus.status),
 245                    atomic_read(&priv->psstatus.confirm_wait),
 246                    atomic_read(&priv->psstatus.snooze_guard),
 247                    txq_count(priv));
 248
 249         if (atomic_read(&priv->psstatus.confirm_wait) ||
 250             atomic_read(&priv->psstatus.snooze_guard) ||
 251             txq_has_space(priv)) {
 252                 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
 253                 return;
 254         }
 255
 256         ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &byte);
 257         if (ret) {
 258                 netdev_err(priv->net_dev, "read INT_PENDING_REG\n");
 259                 goto queue_delayed_work;
 260         }
 261         if (byte)
 262                 goto queue_delayed_work;
 263
 264         ret = ks7010_sdio_writeb(priv, GCR_B_REG, GCR_B_DOZE);
 265         if (ret) {
 266                 netdev_err(priv->net_dev, "write GCR_B_REG\n");
 267                 goto queue_delayed_work;
 268         }
 269         atomic_set(&priv->psstatus.status, PS_SNOOZE);
 270
 271         return;
 272
 273 queue_delayed_work:
 274         queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 275 }
 276
 277 int ks_wlan_hw_power_save(struct ks_wlan_private *priv)
 278 {
 279         queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 280         return 0;
 281 }
 282
 283 static int enqueue_txdev(struct ks_wlan_private *priv, unsigned char *p,
 284                          unsigned long size,
 285                          void (*complete_handler)(struct ks_wlan_private *priv,
 286                                                   struct sk_buff *skb),
 287                          struct sk_buff *skb)
 288 {
 289         struct tx_device_buffer *sp;
 290         int ret;
 291
 292         if (priv->dev_state < DEVICE_STATE_BOOT) {
 293                 ret = -EPERM;
 294                 goto err_complete;
 295         }
 296
 297         if ((TX_DEVICE_BUFF_SIZE - 1) <= txq_count(priv)) {
 298                 netdev_err(priv->net_dev, "tx buffer overflow\n");
 299                 ret = -EOVERFLOW;
 300                 goto err_complete;
 301         }
 302
 303         sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail];
 304         sp->sendp = p;
 305         sp->size = size;
 306         sp->complete_handler = complete_handler;
 307         sp->skb = skb;
 308         inc_txqtail(priv);
 309
 310         return 0;
 311
 312 err_complete:
 313         kfree(p);
 314         if (complete_handler)
 315                 (*complete_handler)(priv, skb);
 316
 317         return ret;
 318 }
 319
 320 /* write data */
 321 static int write_to_device(struct ks_wlan_private *priv, u8 *buffer,
 322                            unsigned long size)
 323 {
 324         struct hostif_hdr *hdr;
 325         int ret;
 326
 327         hdr = (struct hostif_hdr *)buffer;
 328
 329         if (le16_to_cpu(hdr->event) < HIF_DATA_REQ ||
 330             le16_to_cpu(hdr->event) > HIF_REQ_MAX) {
 331                 netdev_err(priv->net_dev, "unknown event=%04X\n", hdr->event);
 332                 return 0;
 333         }
 334
 335         ret = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size);
 336         if (ret) {
 337                 netdev_err(priv->net_dev, "write DATA_WINDOW\n");
 338                 return ret;
 339         }
 340
 341         ret = ks7010_sdio_writeb(priv, WRITE_STATUS_REG, REG_STATUS_BUSY);
 342         if (ret) {
 343                 netdev_err(priv->net_dev, "write WRITE_STATUS_REG\n");
 344                 return ret;
 345         }
 346
 347         return 0;
 348 }
 349
 350 static void tx_device_task(struct ks_wlan_private *priv)
 351 {
 352         struct tx_device_buffer *sp;
 353         int ret;
 354
 355         if (!txq_has_space(priv) ||
 356             atomic_read(&priv->psstatus.status) == PS_SNOOZE)
 357                 return;
 358
 359         sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
 360         if (priv->dev_state >= DEVICE_STATE_BOOT) {
 361                 ret = write_to_device(priv, sp->sendp, sp->size);
 362                 if (ret) {
 363                         netdev_err(priv->net_dev,
 364                                    "write_to_device error !!(%d)\n", ret);
 365                         queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 366                         return;
 367                 }
 368         }
 369         kfree(sp->sendp);
 370         if (sp->complete_handler)       /* TX Complete */
 371                 (*sp->complete_handler)(priv, sp->skb);
 372         inc_txqhead(priv);
 373
 374         if (txq_has_space(priv))
 375                 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
 376 }
 377
 378 int ks_wlan_hw_tx(struct ks_wlan_private *priv, void *p, unsigned long size,
 379                   void (*complete_handler)(struct ks_wlan_private *priv,
 380                                            struct sk_buff *skb),
 381                   struct sk_buff *skb)
 382 {
 383         int result = 0;
 384         struct hostif_hdr *hdr;
 385
 386         hdr = (struct hostif_hdr *)p;
 387
 388         if (le16_to_cpu(hdr->event) < HIF_DATA_REQ ||
 389             le16_to_cpu(hdr->event) > HIF_REQ_MAX) {
 390                 netdev_err(priv->net_dev, "unknown event=%04X\n", hdr->event);
 391                 return 0;
 392         }
 393
 394         /* add event to hostt buffer */
 395         priv->hostt.buff[priv->hostt.qtail] = le16_to_cpu(hdr->event);
 396         priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE;
 397
 398         spin_lock(&priv->tx_dev.tx_dev_lock);
 399         result = enqueue_txdev(priv, p, size, complete_handler, skb);
 400         spin_unlock(&priv->tx_dev.tx_dev_lock);
 401
 402         if (txq_has_space(priv))
 403                 queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
 404
 405         return result;
 406 }
 407
 408 static void rx_event_task(unsigned long dev)
 409 {
 410         struct ks_wlan_private *priv = (struct ks_wlan_private *)dev;
 411         struct rx_device_buffer *rp;
 412
 413         if (rxq_has_space(priv) && priv->dev_state >= DEVICE_STATE_BOOT) {
 414                 rp = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qhead];
 415                 hostif_receive(priv, rp->data, rp->size);
 416                 inc_rxqhead(priv);
 417
 418                 if (rxq_has_space(priv))
 419                         tasklet_schedule(&priv->rx_bh_task);
 420         }
 421 }
 422
 423 static void ks_wlan_hw_rx(struct ks_wlan_private *priv, size_t size)
 424 {
 425         int ret;
 426         struct rx_device_buffer *rx_buffer;
 427         struct hostif_hdr *hdr;
 428         u16 event = 0;
 429
 430         /* receive data */
 431         if (rxq_count(priv) >= (RX_DEVICE_BUFF_SIZE - 1)) {
 432                 netdev_err(priv->net_dev, "rx buffer overflow\n");
 433                 return;
 434         }
 435         rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail];
 436
 437         ret = ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0],
 438                                hif_align_size(size));
 439         if (ret)
 440                 return;
 441
 442         /* length check */
 443         if (size > 2046 || size == 0) {
 444 #ifdef DEBUG
 445                 print_hex_dump_bytes("INVALID DATA dump: ",
 446                                      DUMP_PREFIX_OFFSET,
 447                                      rx_buffer->data, 32);
 448 #endif
 449                 ret = ks7010_sdio_writeb(priv, READ_STATUS_REG, REG_STATUS_IDLE);
 450                 if (ret)
 451                         netdev_err(priv->net_dev, "write READ_STATUS_REG\n");
 452
 453                 /* length check fail */
 454                 return;
 455         }
 456
 457         hdr = (struct hostif_hdr *)&rx_buffer->data[0];
 458         rx_buffer->size = le16_to_cpu(hdr->size) + sizeof(hdr->size);
 459         event = le16_to_cpu(hdr->event);
 460         inc_rxqtail(priv);
 461
 462         ret = ks7010_sdio_writeb(priv, READ_STATUS_REG, REG_STATUS_IDLE);
 463         if (ret)
 464                 netdev_err(priv->net_dev, "write READ_STATUS_REG\n");
 465
 466         if (atomic_read(&priv->psstatus.confirm_wait) && is_hif_conf(event)) {
 467                 netdev_dbg(priv->net_dev, "IS_HIF_CONF true !!\n");
 468                 atomic_dec(&priv->psstatus.confirm_wait);
 469         }
 470
 471         tasklet_schedule(&priv->rx_bh_task);
 472 }
 473
 474 static void ks7010_rw_function(struct work_struct *work)
 475 {
 476         struct ks_wlan_private *priv = container_of(work,
 477                                                     struct ks_wlan_private,
 478                                                     rw_dwork.work);
 479         struct sdio_func *func = ks7010_to_func(priv);
 480         u8 byte;
 481         int ret;
 482
 483         /* wait after DOZE */
 484         if (time_after(priv->last_doze + msecs_to_jiffies(30), jiffies)) {
 485                 netdev_dbg(priv->net_dev, "wait after DOZE\n");
 486                 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 487                 return;
 488         }
 489
 490         /* wait after WAKEUP */
 491         while (time_after(priv->last_wakeup + msecs_to_jiffies(30), jiffies)) {
 492                 netdev_dbg(priv->net_dev, "wait after WAKEUP\n");
 493                 dev_info(&func->dev, "wake: %lu %lu\n",
 494                          priv->last_wakeup + msecs_to_jiffies(30), jiffies);
 495                 msleep(30);
 496         }
 497
 498         sdio_claim_host(func);
 499
 500         /* power save wakeup */
 501         if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 502                 if (txq_has_space(priv)) {
 503                         ks_wlan_hw_wakeup_request(priv);
 504                         queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
 505                 }
 506                 goto release_host;
 507         }
 508
 509         /* sleep mode doze */
 510         if (atomic_read(&priv->sleepstatus.doze_request) == 1) {
 511                 ks_wlan_hw_sleep_doze_request(priv);
 512                 goto release_host;
 513         }
 514         /* sleep mode wakeup */
 515         if (atomic_read(&priv->sleepstatus.wakeup_request) == 1) {
 516                 ks_wlan_hw_sleep_wakeup_request(priv);
 517                 goto release_host;
 518         }
 519
 520         /* read (WriteStatus/ReadDataSize FN1:00_0014) */
 521         ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte);
 522         if (ret) {
 523                 netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG psstatus=%d\n",
 524                            atomic_read(&priv->psstatus.status));
 525                 goto release_host;
 526         }
 527
 528         if (byte & RSIZE_MASK) {        /* Read schedule */
 529                 ks_wlan_hw_rx(priv, (size_t)((byte & RSIZE_MASK) << 4));
 530         }
 531         if ((byte & WSTATUS_MASK))
 532                 tx_device_task(priv);
 533
 534         _ks_wlan_hw_power_save(priv);
 535
 536 release_host:
 537         sdio_release_host(func);
 538 }
 539
 540 static void ks_sdio_interrupt(struct sdio_func *func)
 541 {
 542         int ret;
 543         struct ks_sdio_card *card;
 544         struct ks_wlan_private *priv;
 545         u8 status, rsize, byte;
 546
 547         card = sdio_get_drvdata(func);
 548         priv = card->priv;
 549
 550         if (priv->dev_state < DEVICE_STATE_BOOT)
 551                 goto queue_delayed_work;
 552
 553         ret = ks7010_sdio_readb(priv, INT_PENDING_REG, &status);
 554         if (ret) {
 555                 netdev_err(priv->net_dev, "read INT_PENDING_REG\n");
 556                 goto queue_delayed_work;
 557         }
 558
 559         /* schedule task for interrupt status */
 560         /* bit7 -> Write General Communication B register */
 561         /* read (General Communication B register) */
 562         /* bit5 -> Write Status Idle */
 563         /* bit2 -> Read Status Busy  */
 564         if (status & INT_GCR_B ||
 565             atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 566                 ret = ks7010_sdio_readb(priv, GCR_B_REG, &byte);
 567                 if (ret) {
 568                         netdev_err(priv->net_dev, "read GCR_B_REG\n");
 569                         goto queue_delayed_work;
 570                 }
 571                 if (byte == GCR_B_ACTIVE) {
 572                         if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 573                                 atomic_set(&priv->psstatus.status, PS_WAKEUP);
 574                                 priv->wakeup_count = 0;
 575                         }
 576                         complete(&priv->psstatus.wakeup_wait);
 577                 }
 578         }
 579
 580         do {
 581                 /* read (WriteStatus/ReadDataSize FN1:00_0014) */
 582                 ret = ks7010_sdio_readb(priv, WSTATUS_RSIZE_REG, &byte);
 583                 if (ret) {
 584                         netdev_err(priv->net_dev, "read WSTATUS_RSIZE_REG\n");
 585                         goto queue_delayed_work;
 586                 }
 587                 rsize = byte & RSIZE_MASK;
 588                 if (rsize != 0)         /* Read schedule */
 589                         ks_wlan_hw_rx(priv, (size_t)(rsize << 4));
 590
 591                 if (byte & WSTATUS_MASK) {
 592                         if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
 593                                 if (txq_has_space(priv)) {
 594                                         ks_wlan_hw_wakeup_request(priv);
 595                                         queue_delayed_work(priv->wq,
 596                                                            &priv->rw_dwork, 1);
 597                                         return;
 598                                 }
 599                         } else {
 600                                 tx_device_task(priv);
 601                         }
 602                 }
 603         } while (rsize);
 604
 605 queue_delayed_work:
 606         queue_delayed_work(priv->wq, &priv->rw_dwork, 0);
 607 }
 608
 609 static int trx_device_init(struct ks_wlan_private *priv)
 610 {
 611         priv->tx_dev.qhead = 0;
 612         priv->tx_dev.qtail = 0;
 613
 614         priv->rx_dev.qhead = 0;
 615         priv->rx_dev.qtail = 0;
 616
 617         spin_lock_init(&priv->tx_dev.tx_dev_lock);
 618         spin_lock_init(&priv->rx_dev.rx_dev_lock);
 619
 620         tasklet_init(&priv->rx_bh_task, rx_event_task, (unsigned long)priv);
 621
 622         return 0;
 623 }
 624
 625 static void trx_device_exit(struct ks_wlan_private *priv)
 626 {
 627         struct tx_device_buffer *sp;
 628
 629         /* tx buffer clear */
 630         while (txq_has_space(priv)) {
 631                 sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
 632                 kfree(sp->sendp);
 633                 if (sp->complete_handler)       /* TX Complete */
 634                         (*sp->complete_handler)(priv, sp->skb);
 635                 inc_txqhead(priv);
 636         }
 637
 638         tasklet_kill(&priv->rx_bh_task);
 639 }
 640
 641 static int ks7010_sdio_update_index(struct ks_wlan_private *priv, u32 index)
 642 {
 643         int ret;
 644         unsigned char *data_buf;
 645
 646         data_buf = kmemdup(&index, sizeof(u32), GFP_KERNEL);
 647         if (!data_buf)
 648                 return -ENOMEM;
 649
 650         ret = ks7010_sdio_write(priv, WRITE_INDEX_REG, data_buf, sizeof(index));
 651         if (ret)
 652                 goto err_free_data_buf;
 653
 654         ret = ks7010_sdio_write(priv, READ_INDEX_REG, data_buf, sizeof(index));
 655         if (ret)
 656                 goto err_free_data_buf;
 657
 658         return 0;
 659
 660 err_free_data_buf:
 661         kfree(data_buf);
 662
 663         return ret;
 664 }
 665
 666 #define ROM_BUFF_SIZE (64 * 1024)
 667 static int ks7010_sdio_data_compare(struct ks_wlan_private *priv, u32 address,
 668                                     u8 *data, unsigned int size)
 669 {
 670         int ret;
 671         u8 *read_buf;
 672
 673         read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
 674         if (!read_buf)
 675                 return -ENOMEM;
 676
 677         ret = ks7010_sdio_read(priv, address, read_buf, size);
 678         if (ret)
 679                 goto err_free_read_buf;
 680
 681         if (memcmp(data, read_buf, size) != 0) {
 682                 ret = -EIO;
 683                 netdev_err(priv->net_dev, "data compare error (%d)\n", ret);
 684                 goto err_free_read_buf;
 685         }
 686
 687         return 0;
 688
 689 err_free_read_buf:
 690         kfree(read_buf);
 691
 692         return ret;
 693 }
 694
 695 static int ks7010_copy_firmware(struct ks_wlan_private *priv,
 696                                 const struct firmware *fw_entry)
 697 {
 698         unsigned int length;
 699         unsigned int size;
 700         unsigned int offset;
 701         unsigned int n = 0;
 702         u8 *rom_buf;
 703         int ret;
 704
 705         rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
 706         if (!rom_buf)
 707                 return -ENOMEM;
 708
 709         length = fw_entry->size;
 710
 711         do {
 712                 if (length >= ROM_BUFF_SIZE) {
 713                         size = ROM_BUFF_SIZE;
 714                         length = length - ROM_BUFF_SIZE;
 715                 } else {
 716                         size = length;
 717                         length = 0;
 718                 }
 719                 if (size == 0)
 720                         break;
 721
 722                 memcpy(rom_buf, fw_entry->data + n, size);
 723
 724                 offset = n;
 725                 ret = ks7010_sdio_update_index(priv,
 726                                                KS7010_IRAM_ADDRESS + offset);
 727                 if (ret)
 728                         goto free_rom_buf;
 729
 730                 ret = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size);
 731                 if (ret)
 732                         goto free_rom_buf;
 733
 734                 ret = ks7010_sdio_data_compare(priv,
 735                                                DATA_WINDOW, rom_buf, size);
 736                 if (ret)
 737                         goto free_rom_buf;
 738
 739                 n += size;
 740
 741         } while (size);
 742
 743         ret = ks7010_sdio_writeb(priv, GCR_A_REG, GCR_A_REMAP);
 744
 745 free_rom_buf:
 746         kfree(rom_buf);
 747         return ret;
 748 }
 749
 750 static int ks7010_upload_firmware(struct ks_sdio_card *card)
 751 {
 752         struct ks_wlan_private *priv = card->priv;
 753         struct sdio_func *func = ks7010_to_func(priv);
 754         unsigned int n;
 755         u8 byte = 0;
 756         int ret;
 757         const struct firmware *fw_entry = NULL;
 758
 759         sdio_claim_host(func);
 760
 761         /* Firmware running ? */
 762         ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte);
 763         if (ret)
 764                 goto release_host;
 765         if (byte == GCR_A_RUN) {
 766                 netdev_dbg(priv->net_dev, "MAC firmware running ...\n");
 767                 ret = -EBUSY;
 768                 goto release_host;
 769         }
 770
 771         ret = reject_firmware(&fw_entry, ROM_FILE,
 772                                &func->dev);
 773         if (ret)
 774                 goto release_host;
 775
 776         ret = ks7010_copy_firmware(priv, fw_entry);
 777         if (ret)
 778                 goto release_firmware;
 779
 780         /* Firmware running check */
 781         for (n = 0; n < 50; ++n) {
 782                 usleep_range(10000, 11000);     /* wait_ms(10); */
 783                 ret = ks7010_sdio_readb(priv, GCR_A_REG, &byte);
 784                 if (ret)
 785                         goto release_firmware;
 786
 787                 if (byte == GCR_A_RUN)
 788                         break;
 789         }
 790         if ((50) <= n) {
 791                 netdev_err(priv->net_dev, "firmware can't start\n");
 792                 ret = -EIO;
 793                 goto release_firmware;
 794         }
 795
 796         ret = 0;
 797
 798  release_firmware:
 799         release_firmware(fw_entry);
 800  release_host:
 801         sdio_release_host(func);
 802
 803         return ret;
 804 }
 805
 806 static void ks7010_sme_enqueue_events(struct ks_wlan_private *priv)
 807 {
 808         static const u16 init_events[] = {
 809                 SME_GET_EEPROM_CKSUM, SME_STOP_REQUEST,
 810                 SME_RTS_THRESHOLD_REQUEST, SME_FRAGMENTATION_THRESHOLD_REQUEST,
 811                 SME_WEP_INDEX_REQUEST, SME_WEP_KEY1_REQUEST,
 812                 SME_WEP_KEY2_REQUEST, SME_WEP_KEY3_REQUEST,
 813                 SME_WEP_KEY4_REQUEST, SME_WEP_FLAG_REQUEST,
 814                 SME_RSN_ENABLED_REQUEST, SME_MODE_SET_REQUEST,
 815                 SME_START_REQUEST
 816         };
 817         int ev;
 818
 819         for (ev = 0; ev < ARRAY_SIZE(init_events); ev++)
 820                 hostif_sme_enqueue(priv, init_events[ev]);
 821 }
 822
 823 static void ks7010_card_init(struct ks_wlan_private *priv)
 824 {
 825         init_completion(&priv->confirm_wait);
 826
 827         /* get mac address & firmware version */
 828         hostif_sme_enqueue(priv, SME_START);
 829
 830         if (!wait_for_completion_interruptible_timeout
 831             (&priv->confirm_wait, 5 * HZ)) {
 832                 netdev_dbg(priv->net_dev, "wait time out!! SME_START\n");
 833         }
 834
 835         if (priv->mac_address_valid && priv->version_size != 0)
 836                 priv->dev_state = DEVICE_STATE_PREINIT;
 837
 838         ks7010_sme_enqueue_events(priv);
 839
 840         if (!wait_for_completion_interruptible_timeout
 841             (&priv->confirm_wait, 5 * HZ)) {
 842                 netdev_dbg(priv->net_dev, "wait time out!! wireless parameter set\n");
 843         }
 844
 845         if (priv->dev_state >= DEVICE_STATE_PREINIT) {
 846                 netdev_dbg(priv->net_dev, "DEVICE READY!!\n");
 847                 priv->dev_state = DEVICE_STATE_READY;
 848         }
 849 }
 850
 851 static void ks7010_init_defaults(struct ks_wlan_private *priv)
 852 {
 853         priv->reg.tx_rate = TX_RATE_AUTO;
 854         priv->reg.preamble = LONG_PREAMBLE;
 855         priv->reg.power_mgmt = POWER_MGMT_ACTIVE;
 856         priv->reg.scan_type = ACTIVE_SCAN;
 857         priv->reg.beacon_lost_count = 20;
 858         priv->reg.rts = 2347UL;
 859         priv->reg.fragment = 2346UL;
 860         priv->reg.phy_type = D_11BG_COMPATIBLE_MODE;
 861         priv->reg.cts_mode = CTS_MODE_FALSE;
 862         priv->reg.rate_set.body[11] = TX_RATE_54M;
 863         priv->reg.rate_set.body[10] = TX_RATE_48M;
 864         priv->reg.rate_set.body[9] = TX_RATE_36M;
 865         priv->reg.rate_set.body[8] = TX_RATE_18M;
 866         priv->reg.rate_set.body[7] = TX_RATE_9M;
 867         priv->reg.rate_set.body[6] = TX_RATE_24M | BASIC_RATE;
 868         priv->reg.rate_set.body[5] = TX_RATE_12M | BASIC_RATE;
 869         priv->reg.rate_set.body[4] = TX_RATE_6M | BASIC_RATE;
 870         priv->reg.rate_set.body[3] = TX_RATE_11M | BASIC_RATE;
 871         priv->reg.rate_set.body[2] = TX_RATE_5M | BASIC_RATE;
 872         priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
 873         priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
 874         priv->reg.tx_rate = TX_RATE_FULL_AUTO;
 875         priv->reg.rate_set.size = 12;
 876 }
 877
 878 static int ks7010_sdio_setup_irqs(struct sdio_func *func)
 879 {
 880         int ret;
 881
 882         /* interrupt disable */
 883         sdio_writeb(func, 0, INT_ENABLE_REG, &ret);
 884         if (ret)
 885                 goto irq_error;
 886
 887         sdio_writeb(func, 0xff, INT_PENDING_REG, &ret);
 888         if (ret)
 889                 goto irq_error;
 890
 891         /* setup interrupt handler */
 892         ret = sdio_claim_irq(func, ks_sdio_interrupt);
 893
 894 irq_error:
 895         return ret;
 896 }
 897
 898 static void ks7010_sdio_init_irqs(struct sdio_func *func,
 899                                   struct ks_wlan_private *priv)
 900 {
 901         u8 byte;
 902         int ret;
 903
 904         /*
 905          * interrupt setting
 906          * clear Interrupt status write
 907          * (ARMtoSD_InterruptPending FN1:00_0024)
 908          */
 909         sdio_claim_host(func);
 910         ret = ks7010_sdio_writeb(priv, INT_PENDING_REG, 0xff);
 911         sdio_release_host(func);
 912         if (ret)
 913                 netdev_err(priv->net_dev, "write INT_PENDING_REG\n");
 914
 915         /* enable ks7010sdio interrupt */
 916         byte = (INT_GCR_B | INT_READ_STATUS | INT_WRITE_STATUS);
 917         sdio_claim_host(func);
 918         ret = ks7010_sdio_writeb(priv, INT_ENABLE_REG, byte);
 919         sdio_release_host(func);
 920         if (ret)
 921                 netdev_err(priv->net_dev, "write INT_ENABLE_REG\n");
 922 }
 923
 924 static void ks7010_private_init(struct ks_wlan_private *priv,
 925                                 struct ks_sdio_card *card,
 926                                 struct net_device *netdev)
 927 {
 928         /* private memory initialize */
 929         priv->if_hw = card;
 930
 931         priv->dev_state = DEVICE_STATE_PREBOOT;
 932         priv->net_dev = netdev;
 933         priv->firmware_version[0] = '\0';
 934         priv->version_size = 0;
 935         priv->last_doze = jiffies;
 936         priv->last_wakeup = jiffies;
 937         memset(&priv->nstats, 0, sizeof(priv->nstats));
 938         memset(&priv->wstats, 0, sizeof(priv->wstats));
 939
 940         /* sleep mode */
 941         atomic_set(&priv->sleepstatus.status, 0);
 942         atomic_set(&priv->sleepstatus.doze_request, 0);
 943         atomic_set(&priv->sleepstatus.wakeup_request, 0);
 944
 945         trx_device_init(priv);
 946         hostif_init(priv);
 947         ks_wlan_net_start(netdev);
 948         ks7010_init_defaults(priv);
 949 }
 950
 951 static int ks7010_sdio_probe(struct sdio_func *func,
 952                              const struct sdio_device_id *device)
 953 {
 954         struct ks_wlan_private *priv = NULL;
 955         struct net_device *netdev = NULL;
 956         struct ks_sdio_card *card;
 957         int ret;
 958
 959         card = kzalloc(sizeof(*card), GFP_KERNEL);
 960         if (!card)
 961                 return -ENOMEM;
 962
 963         card->func = func;
 964
 965         sdio_claim_host(func);
 966
 967         ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
 968         if (ret)
 969                 goto err_free_card;
 970
 971         dev_dbg(&card->func->dev, "multi_block=%d sdio_set_block_size()=%d %d\n",
 972                 func->card->cccr.multi_block, func->cur_blksize, ret);
 973
 974         ret = sdio_enable_func(func);
 975         if (ret)
 976                 goto err_free_card;
 977
 978         ret = ks7010_sdio_setup_irqs(func);
 979         if (ret)
 980                 goto err_disable_func;
 981
 982         sdio_release_host(func);
 983
 984         sdio_set_drvdata(func, card);
 985
 986         dev_dbg(&card->func->dev, "class = 0x%X, vendor = 0x%X, device = 0x%X\n",
 987                 func->class, func->vendor, func->device);
 988
 989         /* private memory allocate */
 990         netdev = alloc_etherdev(sizeof(*priv));
 991         if (!netdev) {
 992                 dev_err(&card->func->dev, "Unable to alloc new net device\n");
 993                 goto err_release_irq;
 994         }
 995
 996         ret = dev_alloc_name(netdev, "wlan%d");
 997         if (ret < 0) {
 998                 dev_err(&card->func->dev, "Couldn't get name!\n");
 999                 goto err_free_netdev;
1000         }
1001
1002         priv = netdev_priv(netdev);
1003
1004         card->priv = priv;
1005         SET_NETDEV_DEV(netdev, &card->func->dev);
1006
1007         ks7010_private_init(priv, card, netdev);
1008
1009         ret = ks7010_upload_firmware(card);
1010         if (ret) {
1011                 netdev_err(priv->net_dev,
1012                            "firmware load failed !! ret = %d\n", ret);
1013                 goto err_free_netdev;
1014         }
1015
1016         ks7010_sdio_init_irqs(func, priv);
1017
1018         priv->dev_state = DEVICE_STATE_BOOT;
1019
1020         priv->wq = alloc_workqueue("wq", WQ_MEM_RECLAIM, 1);
1021         if (!priv->wq) {
1022                 netdev_err(priv->net_dev, "create_workqueue failed !!\n");
1023                 goto err_free_netdev;
1024         }
1025
1026         INIT_DELAYED_WORK(&priv->rw_dwork, ks7010_rw_function);
1027         ks7010_card_init(priv);
1028
1029         ret = register_netdev(priv->net_dev);
1030         if (ret)
1031                 goto err_free_netdev;
1032
1033         return 0;
1034
1035  err_free_netdev:
1036         free_netdev(netdev);
1037  err_release_irq:
1038         sdio_claim_host(func);
1039         sdio_release_irq(func);
1040  err_disable_func:
1041         sdio_disable_func(func);
1042  err_free_card:
1043         sdio_release_host(func);
1044         sdio_set_drvdata(func, NULL);
1045         kfree(card);
1046
1047         return -ENODEV;
1048 }
1049
1050 /* send stop request to MAC */
1051 static int send_stop_request(struct sdio_func *func)
1052 {
1053         struct hostif_stop_request *pp;
1054         struct ks_sdio_card *card;
1055         size_t size;
1056
1057         card = sdio_get_drvdata(func);
1058
1059         pp = kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL);
1060         if (!pp)
1061                 return -ENOMEM;
1062
1063         size = sizeof(*pp) - sizeof(pp->header.size);
1064         pp->header.size = cpu_to_le16(size);
1065         pp->header.event = cpu_to_le16(HIF_STOP_REQ);
1066
1067         sdio_claim_host(func);
1068         write_to_device(card->priv, (u8 *)pp, hif_align_size(sizeof(*pp)));
1069         sdio_release_host(func);
1070
1071         kfree(pp);
1072         return 0;
1073 }
1074
1075 static void ks7010_sdio_remove(struct sdio_func *func)
1076 {
1077         int ret;
1078         struct ks_sdio_card *card;
1079         struct ks_wlan_private *priv;
1080
1081         card = sdio_get_drvdata(func);
1082
1083         if (!card)
1084                 return;
1085
1086         priv = card->priv;
1087         if (!priv)
1088                 goto err_free_card;
1089
1090         ks_wlan_net_stop(priv->net_dev);
1091
1092         /* interrupt disable */
1093         sdio_claim_host(func);
1094         sdio_writeb(func, 0, INT_ENABLE_REG, &ret);
1095         sdio_writeb(func, 0xff, INT_PENDING_REG, &ret);
1096         sdio_release_host(func);
1097
1098         ret = send_stop_request(func);
1099         if (ret)        /* memory allocation failure */
1100                 goto err_free_card;
1101
1102         if (priv->wq) {
1103                 flush_workqueue(priv->wq);
1104                 destroy_workqueue(priv->wq);
1105         }
1106
1107         hostif_exit(priv);
1108
1109         unregister_netdev(priv->net_dev);
1110
1111         trx_device_exit(priv);
1112         free_netdev(priv->net_dev);
1113         card->priv = NULL;
1114
1115         sdio_claim_host(func);
1116         sdio_release_irq(func);
1117         sdio_disable_func(func);
1118         sdio_release_host(func);
1119 err_free_card:
1120         sdio_set_drvdata(func, NULL);
1121         kfree(card);
1122 }
1123
1124 static const struct sdio_device_id ks7010_sdio_ids[] = {
1125         {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010)},
1126         {SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010)},
1127         { /* all zero */ }
1128 };
1129 MODULE_DEVICE_TABLE(sdio, ks7010_sdio_ids);
1130
1131 static struct sdio_driver ks7010_sdio_driver = {
1132         .name = "ks7010_sdio",
1133         .id_table = ks7010_sdio_ids,
1134         .probe = ks7010_sdio_probe,
1135         .remove = ks7010_sdio_remove,
1136 };
1137
1138 module_driver(ks7010_sdio_driver, sdio_register_driver, sdio_unregister_driver);
1139 MODULE_AUTHOR("Sang Engineering, Qi-Hardware, KeyStream");
1140 MODULE_DESCRIPTION("Driver for KeyStream KS7010 based SDIO cards");
1141 MODULE_LICENSE("GPL v2");
1142 /*(DEBLOBBED)*/