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