drivers/staging/ks7010/ks7010_sdio.c

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