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