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