drivers/net/wireless/rockchip_wlan/rda5990/rda_wlan/rda5890_if_sdio.c

   1 #include <linux/moduleparam.h>
   2 #include <linux/firmware.h>
   3 #include <linux/netdevice.h>
   4 #include <linux/delay.h>
   5 #include <linux/mmc/card.h>
   6 #include <linux/mmc/sdio_func.h>
   7 #include <linux/mmc/sdio_ids.h>
   8 #include <linux/sched.h>
   9
  10 #include "rda5890_defs.h"
  11 #include "rda5890_dev.h"
  12 #include "rda5890_if_sdio.h"
  13 #include "rda5890_wid.h"
  14 #include "rda5890_debugfs.h"
  15
  16 int rda5890_dbg_level = RDA5890_DL_CRIT;
  17 int rda5890_dbg_area = RDA5890_DA_MAIN
  18         | RDA5890_DA_SDIO
  19         //| RDA5890_DA_ETHER
  20         | RDA5890_DA_WID
  21         | RDA5890_DA_WEXT
  22         //| RDA5890_DA_TXRX
  23         //| RDA5890_DA_PM
  24         ;
  25
  26 void export_msdc_clk_always_on(void)
  27 {
  28     // todo...
  29 }
  30
  31 void export_msdc_clk_always_on_off(void)
  32 {
  33         // todo...
  34 }
  35
  36 extern void rk29_sdio_irq_enable(int enable);
  37 void export_wifi_eirq_enable(void)
  38 {
  39         // todo...
  40         //rk29_sdio_irq_enable(1);
  41 }
  42
  43 void export_wifi_eirq_disable(void)
  44 {
  45         // todo...
  46         //rk29_sdio_irq_enable(0);
  47 }
  48
  49 /* Module parameters */
  50 module_param_named(debug_level, rda5890_dbg_level, int, 0644);
  51 module_param_named(debug_area, rda5890_dbg_area, int, 0644);
  52 int sdio_test_flag = 0;
  53 module_param_named(sdio_test, sdio_test_flag, int, 0644);
  54
  55 #define SDIO_VENDOR_ID_RDA5890        0x5449
  56 #define SDIO_DEVICE_ID_RDA5890        0x0145
  57
  58 static const struct sdio_device_id if_sdio_ids[] = {
  59         { SDIO_DEVICE(SDIO_VENDOR_ID_RDA5890, SDIO_DEVICE_ID_RDA5890) },
  60         { /* end: all zeroes */                                         },
  61 };
  62
  63 MODULE_DEVICE_TABLE(sdio, if_sdio_ids);
  64
  65 struct if_sdio_packet {
  66         struct if_sdio_packet   *next;
  67     unsigned char packet_type;
  68         u16                     nb;
  69         u8                      buffer[0] __attribute__((aligned(4)));
  70 };
  71
  72 int if_sdio_card_to_host(struct if_sdio_card *card)
  73 {
  74         int ret = 0;
  75         struct rda5890_private *priv = card->priv;
  76         u8 size_l = 0, size_h = 0;
  77         u16 size, chunk;
  78
  79         RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
  80                 "%s <<< \n", __func__);
  81
  82         size_l = sdio_readb(card->func, IF_SDIO_AHB2SDIO_PKTLEN_L, &ret);
  83         if (ret) {
  84                 RDA5890_ERRP("read PKTLEN_L reg fail\n");
  85                 goto out;
  86         }
  87         else
  88                 RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_NORM,"read PKTLEN_L reg size_l:%d \n", size_l);
  89
  90         size_h = sdio_readb(card->func, IF_SDIO_AHB2SDIO_PKTLEN_H, &ret);
  91         if (ret) {
  92                 RDA5890_ERRP("read PKTLEN_H reg fail\n");
  93                 goto out;
  94         }
  95         else
  96                 RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_NORM,"read PKTLEN_H reg size_h:%d\n",size_h);
  97
  98         size = (size_l | ((size_h & 0x7f) << 8)) * 4;
  99         if (size < 4) {
 100                 RDA5890_ERRP("invalid packet size (%d bytes) from firmware\n", size);
 101                 ret = -EINVAL;
 102                 goto out;
 103         }
 104
 105         /* alignment is handled on firmside */
 106         //chunk = sdio_align_size(card->func, size);
 107         chunk = size;
 108
 109         RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_NORM,
 110                 "if_sdio_card_to_host, size = %d, aligned size = %d\n", size, chunk);
 111
 112         /* TODO: handle multiple packets here */
 113         ret = sdio_readsb(card->func, card->buffer, IF_SDIO_FUN1_FIFO_RD, chunk);
 114         if (ret) {
 115                 RDA5890_ERRP("sdio_readsb fail, ret = %d\n", ret);
 116                 goto out;
 117         }
 118
 119 #if 1
 120         if(priv->version == 7)
 121         {
 122                 sdio_writeb(card->func, 0x20 ,IF_SDIO_FUN1_INT_PEND, &ret);
 123                 if(ret) {
 124                         RDA5890_ERRP("clear SDIO Tx Complete flag failed\n");
 125                         goto out;
 126                 }
 127         }
 128 #endif
 129
 130         RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_VERB,
 131                 "if_sdio_card_to_host, read done\n");
 132
 133         if (sdio_test_flag) {
 134                 rda5890_sdio_test_card_to_host(card->buffer, chunk);
 135                 goto out;
 136         }
 137
 138         /* TODO: this chunk size need to be handled here */
 139         rda5890_card_to_host(priv, card->buffer, chunk);
 140
 141 out:
 142         RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 143                 "if_sdio_card_to_host >>>\n");
 144         return ret;
 145 }
 146
 147 #ifdef WIFI_POWER_MANAGER
 148 void if_sdio_sleep_worker(struct work_struct *work)
 149 {
 150         struct if_sdio_card *card = NULL;
 151         int ret = 0;
 152     struct rda5890_private *priv = NULL;
 153
 154         card = container_of(work, struct if_sdio_card,
 155                 sleep_work.work);
 156
 157         if(card)
 158                 priv = card->priv;
 159         else
 160                 goto out;
 161
 162         if(!priv)
 163                 goto out;
 164
 165         RDA5890_DBGLAP(RDA5890_DA_PM, RDA5890_DL_CRIT, "Sleep\n");
 166
 167         /* clear IF_SDIO_FUN1_INT_PEND, this allow device to sleep */
 168     sdio_claim_host(card->func);
 169         sdio_writeb(card->func, IF_SDIO_HOST_TX_FLAG ,IF_SDIO_FUN1_INT_PEND, &ret);
 170     sdio_release_host(card->func);
 171         if (ret)
 172         {
 173                 RDA5890_ERRP("clear IF_SDIO_HOST_TX_FLAG failed\n");
 174         }
 175         atomic_inc(&card->priv->sleep_flag);
 176
 177 out:
 178
 179     atomic_set(&card->sleep_work_is_active, 0);
 180 #ifdef WIFI_UNLOCK_SYSTEM
 181     rda5990_wakeUnlock();
 182 #endif
 183         return;
 184 }
 185
 186 static int if_sdio_wakeup_card(struct if_sdio_card *card)
 187 {
 188         struct rda5890_private *priv = card->priv;
 189         int ret = 0;
 190
 191 #ifdef WIFI_TEST_MODE
 192     if(rda_5990_wifi_in_test_mode())
 193         return 0;
 194 #endif
 195       sdio_claim_host(card->func);
 196       sdio_writeb(card->func, 1, IF_SDIO_FUN1_INT_TO_DEV, &ret);
 197       sdio_release_host(card->func);
 198         if (ret) {
 199                 RDA5890_ERRP("write FUN1_INT_TO_DEV reg fail\n");
 200                 goto out;
 201         }
 202     atomic_set(&priv->sleep_flag, 0);
 203
 204         RDA5890_DBGLAP(RDA5890_DA_PM, RDA5890_DL_CRIT, "wake up \n");
 205         // wait 15ms, hardware need 13ms to wakeup
 206     rda5890_shedule_timeout(8);
 207 out:
 208         return ret;
 209 }
 210
 211 #endif //WIFI_POWER_MANAGER
 212
 213 static void if_sdio_host_to_card_worker(struct work_struct *work)
 214 {
 215         struct if_sdio_card *card = NULL;
 216         struct rda5890_private *priv = NULL;
 217         struct if_sdio_packet *packet = NULL;
 218         int ret;
 219         unsigned long flags;
 220         u16 size;
 221     u32 retries = 500;
 222         u8 size_l, size_h, write_status = 0;
 223 #define SDIO_HOST_WRITE_BATCH_SIZE   512
 224         u16 bytes_left, offset, batch;
 225
 226         card = container_of(work, struct if_sdio_card, packet_worker);
 227         priv = card->priv;
 228
 229
 230 #ifdef WIFI_POWER_MANAGER
 231     if(is_sdio_init_complete())
 232     {
 233         if(atomic_read(&card->sleep_work_is_active))
 234         {
 235             cancel_delayed_work(&card->sleep_work);
 236 #ifdef WIFI_UNLOCK_SYSTEM
 237             rda5990_wakeUnlock();
 238 #endif
 239             atomic_set(&card->sleep_work_is_active, 0);
 240         }
 241     }
 242 #endif
 243
 244         while (1)
 245     {
 246         retries = 500;
 247
 248         spin_lock_irqsave(&card->lock, flags);
 249         packet = card->packets;
 250         if (packet)
 251                 card->packets = packet->next;
 252         spin_unlock_irqrestore(&card->lock, flags);
 253
 254         if (!packet)
 255                 break;
 256
 257 #ifdef WIFI_POWER_MANAGER
 258                 if (atomic_read(&priv->sleep_flag))
 259         {
 260             /* Deivce maybe sleep, wakeup it. */
 261             RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_NORM, "Wakeup\n");
 262             ret = if_sdio_wakeup_card(card);
 263             if (ret)
 264             {
 265                 RDA5890_ERRP("wakeup card fail\n");
 266                 goto out;
 267             }
 268         }
 269 #endif
 270         while(retries && is_sdio_patch_complete()) //check write flow ctrl
 271        {
 272             sdio_claim_host(card->func);
 273             write_status = sdio_readb(card->func, IF_SDIO_FUN1_INT_PEND, &ret);
 274             sdio_release_host(card->func);
 275             if(ret)
 276             {
 277                 RDA5890_ERRP("read IF_SDIO_FUN1_INT_PEND failed\n");
 278                 goto release;
 279             }
 280             if((write_status & IF_SDIO_INT_RXCMPL) == 0)
 281             {
 282                         //RDA5890_ERRP("**** sdio is busy retry next time \n ");
 283                         retries --;
 284                         schedule();
 285             }
 286             else
 287             {
 288                 sdio_claim_host(card->func);
 289                 sdio_writeb(card->func, IF_SDIO_INT_RXCMPL, IF_SDIO_FUN1_INT_PEND, &ret);
 290                 sdio_release_host(card->func);
 291                 if(ret)
 292                 {
 293                         RDA5890_ERRP("write IF_SDIO_FUN1_INT_PEND failed\n");
 294                         goto release;
 295                 }
 296                 break;
 297             }
 298         }
 299
 300                 RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 301                         "if_sdio_host_to_card_worker, send one packet, size = %d\n", packet->nb);
 302                 /* write length */
 303                 size = packet->nb/4;
 304                 size_l = (u8)(size & 0xff);
 305                 size_h = (u8)((size >> 8) & 0x7f);
 306                 size_h |= 0x80;
 307
 308       sdio_claim_host(card->func);
 309         sdio_writeb(card->func, size_l, IF_SDIO_SDIO2AHB_PKTLEN_L, &ret);
 310       sdio_release_host(card->func);
 311         if (ret) {
 312                 RDA5890_ERRP("write PKTLEN_L reg fail\n");
 313                 goto release;
 314         }
 315         sdio_claim_host(card->func);
 316         sdio_writeb(card->func, size_h, IF_SDIO_SDIO2AHB_PKTLEN_H, &ret);
 317         sdio_release_host(card->func);
 318         if (ret) {
 319                 RDA5890_ERRP("write PKTLEN_H reg fail\n");
 320                 goto release;
 321         }
 322
 323                 /* write data */
 324                 bytes_left = packet->nb;
 325                 offset = 0;
 326                 while(bytes_left)
 327         {
 328                         batch = (bytes_left < SDIO_HOST_WRITE_BATCH_SIZE)?
 329                                 bytes_left:SDIO_HOST_WRITE_BATCH_SIZE;
 330
 331             sdio_claim_host(card->func);
 332                 ret = sdio_writesb(card->func, IF_SDIO_FUN1_FIFO_WR,
 333                         packet->buffer + offset, batch);
 334             sdio_release_host(card->func);
 335                 if (ret) {
 336                         RDA5890_ERRP("sdio_writesb fail, ret = %d\n", ret);
 337                         goto release;
 338                 }
 339
 340                 RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 341                         "write batch %d, offset = %d\n", batch, offset);
 342
 343                 offset += batch;
 344                 bytes_left -= batch;
 345         }
 346
 347         RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 348                 "if_sdio_host_to_card_worker, send one packet done\n");
 349
 350 release:
 351
 352                 kfree(packet);
 353         packet = NULL;
 354         }
 355
 356 out:
 357
 358         if(is_sdio_init_complete()) //init complete should start sleep_work
 359     {
 360 #ifdef WIFI_UNLOCK_SYSTEM
 361         rda5990_wakeLock();
 362 #endif
 363
 364 #ifdef WIFI_POWER_MANAGER
 365 #ifdef WIFI_TEST_MODE
 366         if(rda_5990_wifi_in_test_mode())
 367             return;
 368 #endif  //end WIFI_TEST_MODE
 369         atomic_set(&card->sleep_work_is_active, 1);
 370             queue_delayed_work(priv->work_thread, &card->sleep_work, HZ/5);  // 100ms
 371 #endif   //end WIFI_POWER_MANAGER
 372     }
 373 }
 374
 375 /*******************************************************************/
 376 /* RDA5890 callbacks                                              */
 377 /*******************************************************************/
 378
 379 static int if_sdio_host_to_card(struct rda5890_private *priv,
 380                 u8 *buf, u16 nb, unsigned char packet_type)
 381 {
 382         int ret = 0;
 383         struct if_sdio_card *card;
 384         struct if_sdio_packet *packet, *cur;
 385         u16 size;
 386         unsigned long flags;
 387
 388         RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 389                 "%s >>>\n", __func__);
 390
 391         card = priv->card;
 392
 393         if (nb > (65536 - sizeof(struct if_sdio_packet))) {
 394                 ret = -EINVAL;
 395                 goto out;
 396         }
 397
 398         //size = sdio_align_size(card->func, nb);
 399         size = nb;
 400         if(size%4)
 401         {
 402                 size += (4-size%4);
 403         }
 404
 405         RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_NORM,
 406                 "if_sdio_host_to_card, size = %d, aligned size = %d\n", nb, size);
 407
 408         packet = kzalloc(sizeof(struct if_sdio_packet) + size,
 409                         GFP_ATOMIC);
 410         if (!packet) {
 411                 ret = -ENOMEM;
 412                 goto out;
 413         }
 414
 415         packet->next = NULL;
 416         packet->nb = size;
 417     packet->packet_type = packet_type;
 418
 419         memcpy(packet->buffer, buf, nb);
 420
 421         spin_lock_irqsave(&card->lock, flags);
 422
 423         if (!card->packets)
 424                 card->packets = packet;
 425         else {
 426                 cur = card->packets;
 427                 while (cur->next)
 428                         cur = cur->next;
 429                 cur->next = packet;
 430         }
 431
 432         spin_unlock_irqrestore(&card->lock, flags);
 433
 434     queue_work(card->work_thread, &card->packet_worker);
 435
 436         RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 437                 "%s <<<\n", __func__);
 438
 439         ret = 0;
 440
 441 out:
 442         return ret;
 443 }
 444
 445 static void if_sdio_interrupt(struct sdio_func *func)
 446 {
 447     int ret = 0;
 448     struct if_sdio_card *card;
 449     struct rda5890_private *priv;
 450     u8 status;
 451
 452     RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 453         "%s >>>\n", __func__);
 454
 455     card = sdio_get_drvdata(func);
 456     if(!card)
 457         return;
 458
 459     priv = card->priv;
 460
 461     status = sdio_readb(card->func, IF_SDIO_FUN1_INT_STAT, &ret);
 462     if (ret)
 463         goto out;
 464
 465     RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_VERB,
 466         "if_sdio_interrupt, status = 0x%02x\n", status);
 467
 468     if (status & IF_SDIO_INT_AHB2SDIO)
 469         if_sdio_card_to_host(card);
 470
 471     if (status & IF_SDIO_INT_ERROR)
 472     {
 473         sdio_writeb(card->func, IF_SDIO_INT_ERROR, IF_SDIO_FUN1_INT_PEND, &ret);
 474         if (ret)
 475         {
 476                 RDA5890_ERRP("write FUN1_INT_STAT reg fail\n");
 477                 goto out;
 478         }
 479
 480           RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_TRACE,
 481                 "%s, INT_ERROR\n", __func__);
 482     }
 483
 484 out:
 485     RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 486         "%s <<< ret=%d \n", __func__, ret);
 487     return ret;
 488 }
 489
 490
 491 static int if_sdio_probe(struct sdio_func *func,
 492                                         const struct sdio_device_id *id)
 493 {
 494     struct if_sdio_card *card = NULL;
 495     struct rda5890_private *priv = NULL;
 496     struct if_sdio_packet *packet = NULL;
 497     int ret = -1;
 498     unsigned long flags;
 499
 500     RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 501         "%s >>>\n", __func__);
 502
 503         //SMC_MSG("[rda_debug] sunximmc_probe, set clk.\n");
 504
 505         //mmc_set_clock(mmc, 4000000);
 506
 507
 508     if(id->vendor != 0x5449)
 509     {
 510             RDA5890_ERRP("rda5890 sdio  not corrent vendor:%x \n", id->vendor);
 511             goto out;
 512     }
 513
 514     card = kzalloc(sizeof(struct if_sdio_card), GFP_KERNEL);
 515     if (!card) {
 516         RDA5890_ERRP("kzalloc fail\n");
 517         return -ENOMEM;
 518     }
 519
 520     card->func = func;
 521     spin_lock_init(&card->lock);
 522     atomic_set(&card->wid_complete_flag, 0);
 523     INIT_WORK(&card->packet_worker, if_sdio_host_to_card_worker);
 524     card->work_thread = create_singlethread_workqueue("rda5890_if_sdio_worker");
 525
 526 #ifdef WIFI_POWER_MANAGER
 527     atomic_set(&card->sleep_work_is_active, 0);
 528     INIT_DELAYED_WORK(&card->sleep_work, if_sdio_sleep_worker);
 529 #endif
 530
 531 #ifdef WIFI_UNLOCK_SYSTEM
 532     atomic_set(&wake_lock_counter, 0);
 533     wake_lock_init(&sleep_worker_wake_lock, WAKE_LOCK_SUSPEND, "RDA_sleep_worker_wake_lock");
 534 #endif
 535
 536     sdio_claim_host(func);
 537     ret = sdio_enable_func(func);
 538     if (ret) {
 539         RDA5890_ERRP("sdio_enable_func fail, ret = %d\n", ret);
 540         goto release;
 541     }
 542
 543     ret = sdio_claim_irq(func, if_sdio_interrupt);
 544     if (ret) {
 545         RDA5890_ERRP("sdio_claim_irq fail, ret = %d\n", ret);
 546         goto disable;
 547     }
 548
 549     sdio_release_host(func);
 550     sdio_set_drvdata(func, card);
 551
 552     priv = rda5890_add_card(card);
 553         if (!priv) {
 554                 RDA5890_ERRP("rda5890_add_card fail\n");
 555                 ret = -ENOMEM;
 556                 goto release_int;
 557         }
 558     rda5890_debugfs_init_one(priv);
 559
 560     card->priv = priv;
 561     priv->card = card;
 562     priv->hw_host_to_card = if_sdio_host_to_card;
 563
 564     /*
 565      * Enable interrupts now that everything is set up
 566      */
 567     sdio_claim_host(func);
 568     sdio_writeb(func, 0x7, IF_SDIO_FUN1_INT_MASK, &ret);
 569     sdio_release_host(func);
 570     if (ret) {
 571         RDA5890_ERRP("enable func interrupt fail\n");
 572         goto remove_card;
 573     }
 574 #ifdef WIFI_TEST_MODE
 575     if(!rda_5990_wifi_in_test_mode())
 576         {
 577 #endif
 578             ret = rda5890_sdio_init(priv);
 579             if(ret < 0)
 580                 goto remove_card;
 581
 582                 ret=rda5890_disable_self_cts(priv);
 583             if(ret < 0)
 584                 goto remove_card;
 585
 586                 ret=rda5890_disable_block_bt(priv);
 587             if(ret < 0)
 588                 goto remove_card;
 589
 590             ret = rda5890_set_scan_timeout(priv);
 591             if (ret) {
 592                         RDA5890_ERRP("rda5890_set_scan_timeout fail, ret = %d\n", ret);
 593                         goto remove_card;
 594             }
 595
 596             ret= rda5890_set_listen_interval(priv, 0x06);
 597             if(ret < 0)
 598                 goto remove_card;
 599
 600             ret = rda5890_set_link_loss_threshold(priv, 0x06);
 601             if(ret < 0)
 602                 goto remove_card;
 603
 604             ret = rda5890_init_pm(priv);
 605             if(ret < 0)
 606                 goto remove_card;
 607
 608 #ifdef WIFI_TEST_MODE
 609         }
 610     else
 611         {
 612             ret = rda5890_set_test_mode(priv);
 613             if(ret < 0)
 614                 goto remove_card;
 615         }
 616 #endif
 617
 618     if (sdio_test_flag) {
 619         unsigned char mac_addr[6];
 620         RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_TRACE,
 621         "SDIO TESTING MODE\n");
 622
 623
 624         ret = rda5890_get_mac_addr(priv, mac_addr);
 625         printk(KERN_INFO "Test rda5890_get_mac_addr %x:%x:%x:%x:%x:%x", mac_addr[0],mac_addr[1],mac_addr[2],mac_addr[3],mac_addr[4],mac_addr[5]);
 626         goto done;
 627     }
 628
 629     ret = rda5890_start_card(priv);
 630     if (ret) {
 631         RDA5890_ERRP("rda5890_start_card fail, ret = %d\n", ret);
 632         goto remove_card;
 633     }
 634
 635 done:
 636     printk(KERN_INFO "RDA5890: SDIO card started\n");
 637
 638 out:
 639     RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 640         "%s ret:%d <<<\n", __func__, ret);
 641     return ret;
 642
 643 release_int:
 644         sdio_claim_host(func);
 645         sdio_release_irq(func);
 646 disable:
 647         sdio_disable_func(func);
 648 release:
 649         sdio_release_host(func);
 650
 651 remove_card:
 652
 653     if (atomic_read(&card->wid_complete_flag) && priv)
 654     {
 655         complete(&priv->wid_done);
 656         printk(KERN_INFO "*****RDA5890: probe send wid complete\n");
 657     }
 658     flush_work(&card->packet_worker);
 659     cancel_work_sync(&card->packet_worker);
 660
 661 #ifdef WIFI_POWER_MANAGER
 662     cancel_delayed_work(&card->sleep_work);
 663 #endif
 664     destroy_workqueue(card->work_thread);
 665
 666     if(priv)
 667         rda5890_remove_card(priv);
 668
 669     while (card->packets) {
 670         packet = card->packets;
 671         card->packets = card->packets->next;
 672         kfree(packet);
 673     }
 674
 675     kfree(card);
 676     goto out;
 677 }
 678
 679 static void if_sdio_remove(struct sdio_func *func)
 680 {
 681     struct if_sdio_card *card;
 682     struct if_sdio_packet *packet;
 683     unsigned char count = 20;
 684
 685     RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 686         "%s >>>\n", __func__);
 687
 688     printk(KERN_INFO "RDA5890: SDIO card detached\n");
 689
 690     card = sdio_get_drvdata(func);
 691     if(!card)
 692         return;
 693     while(card->priv->scan_running && count--)
 694     {
 695         rda5890_shedule_timeout(100);
 696         printk("remove card wait scan complete \n");
 697     }
 698
 699 #ifdef WIFI_POWER_MANAGER
 700     cancel_delayed_work_sync(&card->sleep_work);
 701 #endif
 702     cancel_work_sync(&card->packet_worker);
 703
 704     if (atomic_read(&card->wid_complete_flag) && card->priv)
 705     {
 706         complete(&card->priv->wid_done);
 707         printk(KERN_INFO "*****RDA5890: send wid complete\n");
 708     }
 709
 710     netif_stop_queue(card->priv->dev);
 711     netif_carrier_off(card->priv->dev);
 712     rda5890_stop_card(card->priv);
 713     rda5890_debugfs_remove_one(card->priv);
 714     destroy_workqueue(card->work_thread);
 715     rda5890_remove_card(card->priv);
 716
 717     while (card->packets) {
 718         packet = card->packets;
 719         card->packets = card->packets->next;
 720         kfree(packet);
 721     }
 722
 723     kfree(card);
 724
 725 #ifdef WIFI_UNLOCK_SYSTEM
 726     rda5990_wakeLock_destroy();
 727 #endif
 728
 729     printk(KERN_INFO "RDA5890: SDIO card removed\n");
 730
 731     RDA5890_DBGLAP(RDA5890_DA_SDIO, RDA5890_DL_DEBUG,
 732         "%s <<<\n", __func__);
 733     return;
 734 }
 735
 736 static struct sdio_driver if_sdio_driver = {
 737         .name           = "rda5890_sdio",
 738         .id_table       = if_sdio_ids,
 739         .probe          = if_sdio_probe,
 740         .remove         = if_sdio_remove,
 741 };
 742
 743 /*******************************************************************/
 744 /* Module functions                                                */
 745 /*******************************************************************/
 746 extern void mmc_rescan_slot(int id);
 747
 748 static int __init if_sdio_init_module(void)
 749 {
 750     int ret = 0;
 751
 752     printk(KERN_INFO "\nRDA5890 SDIO WIFI Driver for st_linux \n");
 753     printk(KERN_INFO "Ver: %d.%d.%d\n\n",
 754         RDA5890_SDIOWIFI_VER_MAJ,
 755         RDA5890_SDIOWIFI_VER_MIN,
 756         RDA5890_SDIOWIFI_VER_BLD);
 757
 758         printk("@@@@@@@@@@@@@@@22222 rda5990 start\n");
 759
 760         msleep(1000);
 761
 762         printk("@@@@@@@@@@@@@@ mmc_rescan_slot\n");
 763         mmc_rescan_slot(0);
 764         msleep(1000);
 765
 766         rda5890_debugfs_init();
 767         ret = sdio_register_driver(&if_sdio_driver);
 768
 769         if (ret)
 770         {
 771                 printk(KERN_INFO "\nif_sdio_init_module: register fail. \n");
 772                 //sunximmc_rescan_card(SDIOID,0);
 773         }
 774
 775         printk(KERN_INFO "\n if_sdio_init_module: register successful. \n");
 776
 777         return ret;
 778 }
 779
 780 extern void mmc_remove(int id);
 781 static void __exit if_sdio_exit_module(void)
 782 {
 783     printk(KERN_INFO "\n if_sdio_exit_module. \n");
 784                 mmc_remove(0);
 785     rda5890_debugfs_remove();
 786     sdio_unregister_driver(&if_sdio_driver);
 787 }
 788
 789
 790 module_init(if_sdio_init_module);
 791 module_exit(if_sdio_exit_module);
 792
 793 MODULE_DESCRIPTION("RDA5890 SDIO WLAN Driver");
 794 MODULE_AUTHOR("lwang");
 795 MODULE_LICENSE("GPL");