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