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 { 20 { SDIO_DEVICE(0x024c, 0x0523), }, 21 { SDIO_DEVICE(0x024c, 0x0525), }, 22 { SDIO_DEVICE(0x024c, 0x0623), }, 23 { SDIO_DEVICE(0x024c, 0x0626), }, 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 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 == false) { 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 == true) { 558 DBG_871X("%s bDriverStopped = %d\n", __func__, padapter->bDriverStopped); 559 return 0; 560 } 561 562 if (pwrpriv->bInSuspend == true) { 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 == false) { 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); 651