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