drivers/staging/rtl8723bs/os_dep/sdio_intf.c

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