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