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 struct sdio_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 struct sdio_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 struct sdio_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 struct sdio_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 struct sdio_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); 673