drivers/staging/ks7010/ks7010_sdio.c

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