drivers/staging/rtl8723bs/os_dep/sdio_intf.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
   5  *
   6  ******************************************************************************/
   7 #define _HCI_INTF_C_
   8
   9 #include <drv_types.h>
  10 #include <rtw_debug.h>
  11 #include <linux/jiffies.h>
  12
  13 #ifndef dev_to_sdio_func
  14 #define dev_to_sdio_func(d)     container_of(d, struct sdio_func, dev)
  15 #endif
  16
  17 static const struct sdio_device_id sdio_ids[] =
  18 {
  19         { SDIO_DEVICE(0x024c, 0x0523), },
  20         { SDIO_DEVICE(0x024c, 0x0623), },
  21         { SDIO_DEVICE(0x024c, 0x0626), },
  22         { SDIO_DEVICE(0x024c, 0xb723), },
  23         { /* end: all zeroes */                         },
  24 };
  25 static const struct acpi_device_id acpi_ids[] = {
  26         {"OBDA8723", 0x0000},
  27         {}
  28 };
  29
  30 MODULE_DEVICE_TABLE(sdio, sdio_ids);
  31 MODULE_DEVICE_TABLE(acpi, acpi_ids);
  32
  33 static int rtw_drv_init(struct sdio_func *func, const struct sdio_device_id *id);
  34 static void rtw_dev_remove(struct sdio_func *func);
  35 static int rtw_sdio_resume(struct device *dev);
  36 static int rtw_sdio_suspend(struct device *dev);
  37
  38 static const struct dev_pm_ops rtw_sdio_pm_ops = {
  39         .suspend        = rtw_sdio_suspend,
  40         .resume = rtw_sdio_resume,
  41 };
  42
  43 struct sdio_drv_priv {
  44         struct sdio_driver r871xs_drv;
  45         int drv_registered;
  46 };
  47
  48 static struct sdio_drv_priv sdio_drvpriv = {
  49         .r871xs_drv.probe = rtw_drv_init,
  50         .r871xs_drv.remove = rtw_dev_remove,
  51         .r871xs_drv.name = "rtl8723bs",
  52         .r871xs_drv.id_table = sdio_ids,
  53         .r871xs_drv.drv = {
  54                 .pm = &rtw_sdio_pm_ops,
  55         }
  56 };
  57
  58 static void sd_sync_int_hdl(struct sdio_func *func)
  59 {
  60         struct dvobj_priv *psdpriv;
  61
  62
  63         psdpriv = sdio_get_drvdata(func);
  64
  65         if (!psdpriv->if1) {
  66                 DBG_871X("%s if1 == NULL\n", __func__);
  67                 return;
  68         }
  69
  70         rtw_sdio_set_irq_thd(psdpriv, current);
  71         sd_int_hdl(psdpriv->if1);
  72         rtw_sdio_set_irq_thd(psdpriv, NULL);
  73 }
  74
  75 static int sdio_alloc_irq(struct dvobj_priv *dvobj)
  76 {
  77         PSDIO_DATA psdio_data;
  78         struct sdio_func *func;
  79         int err;
  80
  81         psdio_data = &dvobj->intf_data;
  82         func = psdio_data->func;
  83
  84         sdio_claim_host(func);
  85
  86         err = sdio_claim_irq(func, &sd_sync_int_hdl);
  87         if (err)
  88         {
  89                 dvobj->drv_dbg.dbg_sdio_alloc_irq_error_cnt++;
  90                 printk(KERN_CRIT "%s: sdio_claim_irq FAIL(%d)!\n", __func__, err);
  91         }
  92         else
  93         {
  94                 dvobj->drv_dbg.dbg_sdio_alloc_irq_cnt++;
  95                 dvobj->irq_alloc = 1;
  96         }
  97
  98         sdio_release_host(func);
  99
 100         return err?_FAIL:_SUCCESS;
 101 }
 102
 103 static void sdio_free_irq(struct dvobj_priv *dvobj)
 104 {
 105     PSDIO_DATA psdio_data;
 106     struct sdio_func *func;
 107     int err;
 108
 109     if (dvobj->irq_alloc) {
 110         psdio_data = &dvobj->intf_data;
 111         func = psdio_data->func;
 112
 113         if (func) {
 114             sdio_claim_host(func);
 115             err = sdio_release_irq(func);
 116             if (err)
 117             {
 118                                 dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
 119                                 DBG_871X_LEVEL(_drv_err_,"%s: sdio_release_irq FAIL(%d)!\n", __func__, err);
 120             }
 121             else
 122                 dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
 123             sdio_release_host(func);
 124         }
 125         dvobj->irq_alloc = 0;
 126     }
 127 }
 128
 129 #ifdef CONFIG_GPIO_WAKEUP
 130 extern unsigned int oob_irq;
 131 static irqreturn_t gpio_hostwakeup_irq_thread(int irq, void *data)
 132 {
 133         struct adapter *padapter = data;
 134         DBG_871X_LEVEL(_drv_always_, "gpio_hostwakeup_irq_thread\n");
 135         /* Disable interrupt before calling handler */
 136         /* disable_irq_nosync(oob_irq); */
 137         rtw_lock_suspend_timeout(HZ/2);
 138         return IRQ_HANDLED;
 139 }
 140
 141 static u8 gpio_hostwakeup_alloc_irq(struct adapter *padapter)
 142 {
 143         int err;
 144         if (oob_irq == 0) {
 145                 DBG_871X("oob_irq ZERO!\n");
 146                 return _FAIL;
 147         }
 148         /* dont set it IRQF_TRIGGER_LOW, or wowlan */
 149         /* power is high after suspend */
 150         /* and failing can prevent can not sleep issue if */
 151         /* wifi gpio12 pin is not linked with CPU */
 152         err = request_threaded_irq(oob_irq, gpio_hostwakeup_irq_thread, NULL,
 153                 /* IRQF_TRIGGER_LOW | IRQF_ONESHOT, */
 154                 IRQF_TRIGGER_FALLING,
 155                 "rtw_wifi_gpio_wakeup", padapter);
 156         if (err < 0) {
 157                 DBG_871X("Oops: can't allocate gpio irq %d err:%d\n", oob_irq, err);
 158                 return false;
 159         } else {
 160                 DBG_871X("allocate gpio irq %d ok\n", oob_irq);
 161         }
 162
 163         enable_irq_wake(oob_irq);
 164         return _SUCCESS;
 165 }
 166
 167 static void gpio_hostwakeup_free_irq(struct adapter *padapter)
 168 {
 169         if (oob_irq == 0)
 170                 return;
 171
 172         disable_irq_wake(oob_irq);
 173         free_irq(oob_irq, padapter);
 174 }
 175 #endif
 176
 177 static u32 sdio_init(struct dvobj_priv *dvobj)
 178 {
 179         PSDIO_DATA psdio_data;
 180         struct sdio_func *func;
 181         int err;
 182
 183         psdio_data = &dvobj->intf_data;
 184         func = psdio_data->func;
 185
 186         /* 3 1. init SDIO bus */
 187         sdio_claim_host(func);
 188
 189         err = sdio_enable_func(func);
 190         if (err) {
 191                 dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
 192                 DBG_8192C(KERN_CRIT "%s: sdio_enable_func FAIL(%d)!\n", __func__, err);
 193                 goto release;
 194         }
 195
 196         err = sdio_set_block_size(func, 512);
 197         if (err) {
 198                 dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
 199                 DBG_8192C(KERN_CRIT "%s: sdio_set_block_size FAIL(%d)!\n", __func__, err);
 200                 goto release;
 201         }
 202         psdio_data->block_transfer_len = 512;
 203         psdio_data->tx_block_mode = 1;
 204         psdio_data->rx_block_mode = 1;
 205
 206 release:
 207         sdio_release_host(func);
 208
 209         if (err)
 210                 return _FAIL;
 211         return _SUCCESS;
 212 }
 213
 214 static void sdio_deinit(struct dvobj_priv *dvobj)
 215 {
 216         struct sdio_func *func;
 217         int err;
 218
 219
 220         RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+sdio_deinit\n"));
 221
 222         func = dvobj->intf_data.func;
 223
 224         if (func) {
 225                 sdio_claim_host(func);
 226                 err = sdio_disable_func(func);
 227                 if (err)
 228                 {
 229                         dvobj->drv_dbg.dbg_sdio_deinit_error_cnt++;
 230                         DBG_8192C(KERN_ERR "%s: sdio_disable_func(%d)\n", __func__, err);
 231                 }
 232
 233                 if (dvobj->irq_alloc) {
 234                         err = sdio_release_irq(func);
 235                         if (err)
 236                         {
 237                                 dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
 238                                 DBG_8192C(KERN_ERR "%s: sdio_release_irq(%d)\n", __func__, err);
 239                         }
 240                         else
 241                                 dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
 242                 }
 243
 244                 sdio_release_host(func);
 245         }
 246 }
 247 static struct dvobj_priv *sdio_dvobj_init(struct sdio_func *func)
 248 {
 249         int status = _FAIL;
 250         struct dvobj_priv *dvobj = NULL;
 251         PSDIO_DATA psdio;
 252
 253         dvobj = devobj_init();
 254         if (dvobj == NULL) {
 255                 goto exit;
 256         }
 257
 258         sdio_set_drvdata(func, dvobj);
 259
 260         psdio = &dvobj->intf_data;
 261         psdio->func = func;
 262
 263         if (sdio_init(dvobj) != _SUCCESS) {
 264                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: initialize SDIO Failed!\n", __func__));
 265                 goto free_dvobj;
 266         }
 267         rtw_reset_continual_io_error(dvobj);
 268         status = _SUCCESS;
 269
 270 free_dvobj:
 271         if (status != _SUCCESS && dvobj) {
 272                 sdio_set_drvdata(func, NULL);
 273
 274                 devobj_deinit(dvobj);
 275
 276                 dvobj = NULL;
 277         }
 278 exit:
 279         return dvobj;
 280 }
 281
 282 static void sdio_dvobj_deinit(struct sdio_func *func)
 283 {
 284         struct dvobj_priv *dvobj = sdio_get_drvdata(func);
 285
 286         sdio_set_drvdata(func, NULL);
 287         if (dvobj) {
 288                 sdio_deinit(dvobj);
 289                 devobj_deinit(dvobj);
 290         }
 291         return;
 292 }
 293
 294 void rtw_set_hal_ops(struct adapter *padapter)
 295 {
 296         /* alloc memory for HAL DATA */
 297         rtw_hal_data_init(padapter);
 298
 299         rtl8723bs_set_hal_ops(padapter);
 300 }
 301
 302 static void sd_intf_start(struct adapter *padapter)
 303 {
 304         if (padapter == NULL) {
 305                 DBG_8192C(KERN_ERR "%s: padapter is NULL!\n", __func__);
 306                 return;
 307         }
 308
 309         /*  hal dep */
 310         rtw_hal_enable_interrupt(padapter);
 311 }
 312
 313 static void sd_intf_stop(struct adapter *padapter)
 314 {
 315         if (padapter == NULL) {
 316                 DBG_8192C(KERN_ERR "%s: padapter is NULL!\n", __func__);
 317                 return;
 318         }
 319
 320         /*  hal dep */
 321         rtw_hal_disable_interrupt(padapter);
 322 }
 323
 324
 325 static struct adapter *rtw_sdio_if1_init(struct dvobj_priv *dvobj, const struct sdio_device_id  *pdid)
 326 {
 327         int status = _FAIL;
 328         struct net_device *pnetdev;
 329         struct adapter *padapter = NULL;
 330         PSDIO_DATA psdio = &dvobj->intf_data;
 331
 332         padapter = vzalloc(sizeof(*padapter));
 333         if (padapter == NULL) {
 334                 goto exit;
 335         }
 336
 337         padapter->dvobj = dvobj;
 338         dvobj->if1 = padapter;
 339
 340         padapter->bDriverStopped =true;
 341
 342         dvobj->padapters = padapter;
 343         padapter->iface_id = 0;
 344
 345         /* 3 1. init network device data */
 346         pnetdev = rtw_init_netdev(padapter);
 347         if (!pnetdev)
 348                 goto free_adapter;
 349
 350         SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj));
 351
 352         padapter = rtw_netdev_priv(pnetdev);
 353
 354         rtw_wdev_alloc(padapter, dvobj_to_dev(dvobj));
 355
 356         /* 3 3. init driver special setting, interface, OS and hardware relative */
 357
 358         /* 4 3.1 set hardware operation functions */
 359         rtw_set_hal_ops(padapter);
 360
 361
 362         /* 3 5. initialize Chip version */
 363         padapter->intf_start = &sd_intf_start;
 364         padapter->intf_stop = &sd_intf_stop;
 365
 366         padapter->intf_init = &sdio_init;
 367         padapter->intf_deinit = &sdio_deinit;
 368         padapter->intf_alloc_irq = &sdio_alloc_irq;
 369         padapter->intf_free_irq = &sdio_free_irq;
 370
 371         if (rtw_init_io_priv(padapter, sdio_set_intf_ops) == _FAIL)
 372         {
 373                 RT_TRACE(_module_hci_intfs_c_, _drv_err_,
 374                         ("rtw_drv_init: Can't init io_priv\n"));
 375                 goto free_hal_data;
 376         }
 377
 378         rtw_hal_read_chip_version(padapter);
 379
 380         rtw_hal_chip_configure(padapter);
 381
 382         rtw_btcoex_Initialize(padapter);
 383
 384         /* 3 6. read efuse/eeprom data */
 385         rtw_hal_read_chip_info(padapter);
 386
 387         /* 3 7. init driver common data */
 388         if (rtw_init_drv_sw(padapter) == _FAIL) {
 389                 RT_TRACE(_module_hci_intfs_c_, _drv_err_,
 390                          ("rtw_drv_init: Initialize driver software resource Failed!\n"));
 391                 goto free_hal_data;
 392         }
 393
 394         /* 3 8. get WLan MAC address */
 395         /*  set mac addr */
 396         rtw_macaddr_cfg(&psdio->func->dev, padapter->eeprompriv.mac_addr);
 397
 398         rtw_hal_disable_interrupt(padapter);
 399
 400         DBG_871X("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n"
 401                 , padapter->bDriverStopped
 402                 , padapter->bSurpriseRemoved
 403                 , padapter->bup
 404                 , padapter->hw_init_completed
 405         );
 406
 407         status = _SUCCESS;
 408
 409 free_hal_data:
 410         if (status != _SUCCESS && padapter->HalData)
 411                 kfree(padapter->HalData);
 412
 413         if (status != _SUCCESS) {
 414                 rtw_wdev_unregister(padapter->rtw_wdev);
 415                 rtw_wdev_free(padapter->rtw_wdev);
 416         }
 417
 418 free_adapter:
 419         if (status != _SUCCESS) {
 420                 if (pnetdev)
 421                         rtw_free_netdev(pnetdev);
 422                 else
 423                         vfree((u8 *)padapter);
 424                 padapter = NULL;
 425         }
 426 exit:
 427         return padapter;
 428 }
 429
 430 static void rtw_sdio_if1_deinit(struct adapter *if1)
 431 {
 432         struct net_device *pnetdev = if1->pnetdev;
 433         struct mlme_priv *pmlmepriv = &if1->mlmepriv;
 434
 435         if (check_fwstate(pmlmepriv, _FW_LINKED))
 436                 rtw_disassoc_cmd(if1, 0, false);
 437
 438         free_mlme_ap_info(if1);
 439
 440 #ifdef CONFIG_GPIO_WAKEUP
 441         gpio_hostwakeup_free_irq(if1);
 442 #endif
 443
 444         rtw_cancel_all_timer(if1);
 445
 446 #ifdef CONFIG_WOWLAN
 447         adapter_to_pwrctl(if1)->wowlan_mode =false;
 448         DBG_871X_LEVEL(_drv_always_, "%s wowlan_mode:%d\n", __func__, adapter_to_pwrctl(if1)->wowlan_mode);
 449 #endif /* CONFIG_WOWLAN */
 450
 451         rtw_dev_unload(if1);
 452         DBG_871X("+r871xu_dev_remove, hw_init_completed =%d\n", if1->hw_init_completed);
 453
 454         if (if1->rtw_wdev) {
 455                 rtw_wdev_free(if1->rtw_wdev);
 456         }
 457
 458         rtw_free_drv_sw(if1);
 459
 460         if (pnetdev)
 461                 rtw_free_netdev(pnetdev);
 462 }
 463
 464 /*
 465  * drv_init() - a device potentially for us
 466  *
 467  * notes: drv_init() is called when the bus driver has located a card for us to support.
 468  *        We accept the new device by returning 0.
 469  */
 470 static int rtw_drv_init(
 471         struct sdio_func *func,
 472         const struct sdio_device_id *id)
 473 {
 474         int status = _FAIL;
 475         struct adapter *if1 = NULL, *if2 = NULL;
 476         struct dvobj_priv *dvobj;
 477
 478         dvobj = sdio_dvobj_init(func);
 479         if (dvobj == NULL) {
 480                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("initialize device object priv Failed!\n"));
 481                 goto exit;
 482         }
 483
 484         if1 = rtw_sdio_if1_init(dvobj, id);
 485         if (if1 == NULL) {
 486                 DBG_871X("rtw_init_primarystruct adapter Failed!\n");
 487                 goto free_dvobj;
 488         }
 489
 490         /* dev_alloc_name && register_netdev */
 491         status = rtw_drv_register_netdev(if1);
 492         if (status != _SUCCESS) {
 493                 goto free_if2;
 494         }
 495
 496         if (sdio_alloc_irq(dvobj) != _SUCCESS)
 497                 goto free_if2;
 498
 499 #ifdef  CONFIG_GPIO_WAKEUP
 500         gpio_hostwakeup_alloc_irq(if1);
 501 #endif
 502
 503         RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("-871x_drv - drv_init, success!\n"));
 504
 505         rtw_ndev_notifier_register();
 506         status = _SUCCESS;
 507
 508 free_if2:
 509         if (status != _SUCCESS && if2) {
 510         }
 511         if (status != _SUCCESS && if1) {
 512                 rtw_sdio_if1_deinit(if1);
 513         }
 514 free_dvobj:
 515         if (status != _SUCCESS)
 516                 sdio_dvobj_deinit(func);
 517 exit:
 518         return status == _SUCCESS?0:-ENODEV;
 519 }
 520
 521 static void rtw_dev_remove(struct sdio_func *func)
 522 {
 523         struct dvobj_priv *dvobj = sdio_get_drvdata(func);
 524         struct adapter *padapter = dvobj->if1;
 525
 526         RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+rtw_dev_remove\n"));
 527
 528         dvobj->processing_dev_remove = true;
 529
 530         rtw_unregister_netdevs(dvobj);
 531
 532         if (padapter->bSurpriseRemoved == false) {
 533                 int err;
 534
 535                 /* test surprise remove */
 536                 sdio_claim_host(func);
 537                 sdio_readb(func, 0, &err);
 538                 sdio_release_host(func);
 539                 if (err == -ENOMEDIUM) {
 540                         padapter->bSurpriseRemoved = true;
 541                         DBG_871X(KERN_NOTICE "%s: device had been removed!\n", __func__);
 542                 }
 543         }
 544
 545         rtw_ps_deny(padapter, PS_DENY_DRV_REMOVE);
 546
 547         rtw_pm_set_ips(padapter, IPS_NONE);
 548         rtw_pm_set_lps(padapter, PS_MODE_ACTIVE);
 549
 550         LeaveAllPowerSaveMode(padapter);
 551
 552         rtw_btcoex_HaltNotify(padapter);
 553
 554         rtw_sdio_if1_deinit(padapter);
 555
 556         sdio_dvobj_deinit(func);
 557
 558         RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("-rtw_dev_remove\n"));
 559 }
 560
 561 extern int pm_netdev_open(struct net_device *pnetdev, u8 bnormal);
 562 extern int pm_netdev_close(struct net_device *pnetdev, u8 bnormal);
 563
 564 static int rtw_sdio_suspend(struct device *dev)
 565 {
 566         struct sdio_func *func =dev_to_sdio_func(dev);
 567         struct dvobj_priv *psdpriv = sdio_get_drvdata(func);
 568         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
 569         struct adapter *padapter = psdpriv->if1;
 570         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
 571
 572         if (padapter->bDriverStopped == true)
 573         {
 574                 DBG_871X("%s bDriverStopped = %d\n", __func__, padapter->bDriverStopped);
 575                 return 0;
 576         }
 577
 578         if (pwrpriv->bInSuspend == true)
 579         {
 580                 DBG_871X("%s bInSuspend = %d\n", __func__, pwrpriv->bInSuspend);
 581                 pdbgpriv->dbg_suspend_error_cnt++;
 582                 return 0;
 583         }
 584
 585         return rtw_suspend_common(padapter);
 586 }
 587
 588 static int rtw_resume_process(struct adapter *padapter)
 589 {
 590         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 591         struct dvobj_priv *psdpriv = padapter->dvobj;
 592         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
 593
 594         if (pwrpriv->bInSuspend == false)
 595         {
 596                 pdbgpriv->dbg_resume_error_cnt++;
 597                 DBG_871X("%s bInSuspend = %d\n", __func__, pwrpriv->bInSuspend);
 598                 return -1;
 599         }
 600
 601         return rtw_resume_common(padapter);
 602 }
 603
 604 static int rtw_sdio_resume(struct device *dev)
 605 {
 606         struct sdio_func *func =dev_to_sdio_func(dev);
 607         struct dvobj_priv *psdpriv = sdio_get_drvdata(func);
 608         struct adapter *padapter = psdpriv->if1;
 609         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
 610         int ret = 0;
 611         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
 612
 613         DBG_871X("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
 614
 615         pdbgpriv->dbg_resume_cnt++;
 616
 617         ret = rtw_resume_process(padapter);
 618
 619         pmlmeext->last_scan_time = jiffies;
 620         DBG_871X("<========  %s return %d\n", __func__, ret);
 621         return ret;
 622 }
 623
 624 static int __init rtw_drv_entry(void)
 625 {
 626         int ret = 0;
 627
 628         DBG_871X_LEVEL(_drv_always_, "module init start\n");
 629         dump_drv_version(RTW_DBGDUMP);
 630 #ifdef BTCOEXVERSION
 631         DBG_871X_LEVEL(_drv_always_, "rtl8723bs BT-Coex version = %s\n", BTCOEXVERSION);
 632 #endif /*  BTCOEXVERSION */
 633
 634         sdio_drvpriv.drv_registered = true;
 635         rtw_drv_proc_init();
 636
 637         ret = sdio_register_driver(&sdio_drvpriv.r871xs_drv);
 638         if (ret != 0)
 639         {
 640                 sdio_drvpriv.drv_registered = false;
 641                 rtw_drv_proc_deinit();
 642                 rtw_ndev_notifier_unregister();
 643                 DBG_871X("%s: register driver failed!!(%d)\n", __func__, ret);
 644                 goto exit;
 645         }
 646
 647         goto exit;
 648
 649 exit:
 650         DBG_871X_LEVEL(_drv_always_, "module init ret =%d\n", ret);
 651         return ret;
 652 }
 653
 654 static void __exit rtw_drv_halt(void)
 655 {
 656         DBG_871X_LEVEL(_drv_always_, "module exit start\n");
 657
 658         sdio_drvpriv.drv_registered = false;
 659
 660         sdio_unregister_driver(&sdio_drvpriv.r871xs_drv);
 661
 662         rtw_drv_proc_deinit();
 663         rtw_ndev_notifier_unregister();
 664
 665         DBG_871X_LEVEL(_drv_always_, "module exit success\n");
 666
 667         rtw_mstat_dump(RTW_DBGDUMP);
 668 }
 669
 670
 671 module_init(rtw_drv_entry);
 672 module_exit(rtw_drv_halt);