1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 #include <drv_types.h> 8 #include <rtw_debug.h> 9 #include <hal_btcoex.h> 10 #include <linux/jiffies.h> 11 12 #ifndef dev_to_sdio_func 13 #define dev_to_sdio_func(d) container_of(d, struct sdio_func, dev) 14 #endif 15 16 static const struct sdio_device_id sdio_ids[] = { 17 { SDIO_DEVICE(0x024c, 0x0523), }, 18 { SDIO_DEVICE(0x024c, 0x0525), }, 19 { SDIO_DEVICE(0x024c, 0x0623), }, 20 { SDIO_DEVICE(0x024c, 0x0626), }, 21 { SDIO_DEVICE(0x024c, 0x0627), }, 22 { SDIO_DEVICE(0x024c, 0xb723), }, 23 { /* end: all zeroes */ }, 24 }; 25 MODULE_DEVICE_TABLE(sdio, sdio_ids); 26 27 static int rtw_drv_init(struct sdio_func *func, const struct sdio_device_id *id); 28 static void rtw_dev_remove(struct sdio_func *func); 29 static int rtw_sdio_resume(struct device *dev); 30 static int rtw_sdio_suspend(struct device *dev); 31 32 static const struct dev_pm_ops rtw_sdio_pm_ops = { 33 .suspend = rtw_sdio_suspend, 34 .resume = rtw_sdio_resume, 35 }; 36 37 static struct sdio_driver rtl8723bs_sdio_driver = { 38 .probe = rtw_drv_init, 39 .remove = rtw_dev_remove, 40 .name = "rtl8723bs", 41 .id_table = sdio_ids, 42 .drv = { 43 .pm = &rtw_sdio_pm_ops, 44 } 45 }; 46 47 static void sd_sync_int_hdl(struct sdio_func *func) 48 { 49 struct dvobj_priv *psdpriv; 50 51 52 psdpriv = sdio_get_drvdata(func); 53 54 if (!psdpriv->if1) 55 return; 56 57 rtw_sdio_set_irq_thd(psdpriv, current); 58 sd_int_hdl(psdpriv->if1); 59 rtw_sdio_set_irq_thd(psdpriv, NULL); 60 } 61 62 static int sdio_alloc_irq(struct dvobj_priv *dvobj) 63 { 64 struct sdio_data *psdio_data; 65 struct sdio_func *func; 66 int err; 67 68 psdio_data = &dvobj->intf_data; 69 func = psdio_data->func; 70 71 sdio_claim_host(func); 72 73 err = sdio_claim_irq(func, &sd_sync_int_hdl); 74 if (err) { 75 dvobj->drv_dbg.dbg_sdio_alloc_irq_error_cnt++; 76 printk(KERN_CRIT "%s: sdio_claim_irq FAIL(%d)!\n", __func__, err); 77 } else { 78 dvobj->drv_dbg.dbg_sdio_alloc_irq_cnt++; 79 dvobj->irq_alloc = 1; 80 } 81 82 sdio_release_host(func); 83 84 return err?_FAIL:_SUCCESS; 85 } 86 87 static void sdio_free_irq(struct dvobj_priv *dvobj) 88 { 89 struct sdio_data *psdio_data; 90 struct sdio_func *func; 91 int err; 92 93 if (dvobj->irq_alloc) { 94 psdio_data = &dvobj->intf_data; 95 func = psdio_data->func; 96 97 if (func) { 98 sdio_claim_host(func); 99 err = sdio_release_irq(func); 100 if (err) { 101 dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++; 102 netdev_err(dvobj->if1->pnetdev, 103 "%s: sdio_release_irq FAIL(%d)!\n", 104 __func__, err); 105 } else 106 dvobj->drv_dbg.dbg_sdio_free_irq_cnt++; 107 sdio_release_host(func); 108 } 109 dvobj->irq_alloc = 0; 110 } 111 } 112 113 static u32 sdio_init(struct dvobj_priv *dvobj) 114 { 115 struct sdio_data *psdio_data; 116 struct sdio_func *func; 117 int err; 118 119 psdio_data = &dvobj->intf_data; 120 func = psdio_data->func; 121 122 /* 3 1. init SDIO bus */ 123 sdio_claim_host(func); 124 125 err = sdio_enable_func(func); 126 if (err) { 127 dvobj->drv_dbg.dbg_sdio_init_error_cnt++; 128 goto release; 129 } 130 131 err = sdio_set_block_size(func, 512); 132 if (err) { 133 dvobj->drv_dbg.dbg_sdio_init_error_cnt++; 134 goto release; 135 } 136 psdio_data->block_transfer_len = 512; 137 psdio_data->tx_block_mode = 1; 138 psdio_data->rx_block_mode = 1; 139 140 release: 141 sdio_release_host(func); 142 143 if (err) 144 return _FAIL; 145 return _SUCCESS; 146 } 147 148 static void sdio_deinit(struct dvobj_priv *dvobj) 149 { 150 struct sdio_func *func; 151 int err; 152 153 func = dvobj->intf_data.func; 154 155 if (func) { 156 sdio_claim_host(func); 157 err = sdio_disable_func(func); 158 if (err) 159 dvobj->drv_dbg.dbg_sdio_deinit_error_cnt++; 160 161 if (dvobj->irq_alloc) { 162 err = sdio_release_irq(func); 163 if (err) 164 dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++; 165 else 166 dvobj->drv_dbg.dbg_sdio_free_irq_cnt++; 167 } 168 169 sdio_release_host(func); 170 } 171 } 172 static struct dvobj_priv *sdio_dvobj_init(struct sdio_func *func) 173 { 174 int status = _FAIL; 175 struct dvobj_priv *dvobj = NULL; 176 struct sdio_data *psdio; 177 178 dvobj = devobj_init(); 179 if (!dvobj) 180 goto exit; 181 182 sdio_set_drvdata(func, dvobj); 183 184 psdio = &dvobj->intf_data; 185 psdio->func = func; 186 187 if (sdio_init(dvobj) != _SUCCESS) 188 goto free_dvobj; 189 190 rtw_reset_continual_io_error(dvobj); 191 status = _SUCCESS; 192 193 free_dvobj: 194 if (status != _SUCCESS && dvobj) { 195 sdio_set_drvdata(func, NULL); 196 197 devobj_deinit(dvobj); 198 199 dvobj = NULL; 200 } 201 exit: 202 return dvobj; 203 } 204 205 static void sdio_dvobj_deinit(struct sdio_func *func) 206 { 207 struct dvobj_priv *dvobj = sdio_get_drvdata(func); 208 209 sdio_set_drvdata(func, NULL); 210 if (dvobj) { 211 sdio_deinit(dvobj); 212 devobj_deinit(dvobj); 213 } 214 } 215 216 void rtw_set_hal_ops(struct adapter *padapter) 217 { 218 /* alloc memory for HAL DATA */ 219 rtw_hal_data_init(padapter); 220 221 rtl8723bs_set_hal_ops(padapter); 222 } 223 224 static void sd_intf_start(struct adapter *padapter) 225 { 226 if (!padapter) 227 return; 228 229 /* hal dep */ 230 rtw_hal_enable_interrupt(padapter); 231 } 232 233 static void sd_intf_stop(struct adapter *padapter) 234 { 235 if (!padapter) 236 return; 237 238 /* hal dep */ 239 rtw_hal_disable_interrupt(padapter); 240 } 241 242 243 static struct adapter *rtw_sdio_if1_init(struct dvobj_priv *dvobj, const struct sdio_device_id *pdid) 244 { 245 int status = _FAIL; 246 struct net_device *pnetdev; 247 struct adapter *padapter = NULL; 248 struct sdio_data *psdio = &dvobj->intf_data; 249 250 padapter = vzalloc(sizeof(*padapter)); 251 if (!padapter) 252 goto exit; 253 254 padapter->dvobj = dvobj; 255 dvobj->if1 = padapter; 256 257 padapter->bDriverStopped = true; 258 259 dvobj->padapters = padapter; 260 padapter->iface_id = 0; 261 262 /* 3 1. init network device data */ 263 pnetdev = rtw_init_netdev(padapter); 264 if (!pnetdev) 265 goto free_adapter; 266 267 SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj)); 268 269 padapter = rtw_netdev_priv(pnetdev); 270 271 /* 3 3. init driver special setting, interface, OS and hardware relative */ 272 273 /* 4 3.1 set hardware operation functions */ 274 rtw_set_hal_ops(padapter); 275 276 277 /* 3 5. initialize Chip version */ 278 padapter->intf_start = &sd_intf_start; 279 padapter->intf_stop = &sd_intf_stop; 280 281 padapter->intf_init = &sdio_init; 282 padapter->intf_deinit = &sdio_deinit; 283 padapter->intf_alloc_irq = &sdio_alloc_irq; 284 padapter->intf_free_irq = &sdio_free_irq; 285 286 if (rtw_init_io_priv(padapter, sdio_set_intf_ops) == _FAIL) 287 goto free_hal_data; 288 289 rtw_hal_read_chip_version(padapter); 290 291 rtw_hal_chip_configure(padapter); 292 293 hal_btcoex_Initialize((void *) padapter); 294 295 /* 3 6. read efuse/eeprom data */ 296 rtw_hal_read_chip_info(padapter); 297 298 /* 3 7. init driver common data */ 299 if (rtw_init_drv_sw(padapter) == _FAIL) 300 goto free_hal_data; 301 302 rtw_wdev_alloc(padapter, dvobj_to_dev(dvobj)); 303 304 /* 3 8. get WLan MAC address */ 305 /* set mac addr */ 306 rtw_macaddr_cfg(&psdio->func->dev, padapter->eeprompriv.mac_addr); 307 308 rtw_hal_disable_interrupt(padapter); 309 310 status = _SUCCESS; 311 312 free_hal_data: 313 if (status != _SUCCESS && padapter->HalData) 314 kfree(padapter->HalData); 315 316 if (status != _SUCCESS) { 317 rtw_wdev_unregister(padapter->rtw_wdev); 318 rtw_wdev_free(padapter->rtw_wdev); 319 } 320 321 free_adapter: 322 if (status != _SUCCESS) { 323 if (pnetdev) 324 rtw_free_netdev(pnetdev); 325 else 326 vfree((u8 *)padapter); 327 padapter = NULL; 328 } 329 exit: 330 return padapter; 331 } 332 333 static void rtw_sdio_if1_deinit(struct adapter *if1) 334 { 335 struct net_device *pnetdev = if1->pnetdev; 336 struct mlme_priv *pmlmepriv = &if1->mlmepriv; 337 338 if (check_fwstate(pmlmepriv, _FW_LINKED)) 339 rtw_disassoc_cmd(if1, 0, false); 340 341 free_mlme_ap_info(if1); 342 343 rtw_cancel_all_timer(if1); 344 345 rtw_dev_unload(if1); 346 347 if (if1->rtw_wdev) 348 rtw_wdev_free(if1->rtw_wdev); 349 350 rtw_free_drv_sw(if1); 351 352 if (pnetdev) 353 rtw_free_netdev(pnetdev); 354 } 355 356 /* 357 * drv_init() - a device potentially for us 358 * 359 * notes: drv_init() is called when the bus driver has located a card for us to support. 360 * We accept the new device by returning 0. 361 */ 362 static int rtw_drv_init( 363 struct sdio_func *func, 364 const struct sdio_device_id *id) 365 { 366 int status = _FAIL; 367 struct adapter *if1 = NULL; 368 struct dvobj_priv *dvobj; 369 370 dvobj = sdio_dvobj_init(func); 371 if (!dvobj) 372 goto exit; 373 374 if1 = rtw_sdio_if1_init(dvobj, id); 375 if (!if1) 376 goto free_dvobj; 377 378 /* dev_alloc_name && register_netdev */ 379 status = rtw_drv_register_netdev(if1); 380 if (status != _SUCCESS) 381 goto free_if1; 382 383 if (sdio_alloc_irq(dvobj) != _SUCCESS) 384 goto free_if1; 385 386 rtw_ndev_notifier_register(); 387 status = _SUCCESS; 388 389 free_if1: 390 if (status != _SUCCESS && if1) 391 rtw_sdio_if1_deinit(if1); 392 393 free_dvobj: 394 if (status != _SUCCESS) 395 sdio_dvobj_deinit(func); 396 exit: 397 return status == _SUCCESS ? 0 : -ENODEV; 398 } 399 400 static void rtw_dev_remove(struct sdio_func *func) 401 { 402 struct dvobj_priv *dvobj = sdio_get_drvdata(func); 403 struct adapter *padapter = dvobj->if1; 404 405 dvobj->processing_dev_remove = true; 406 407 rtw_unregister_netdevs(dvobj); 408 409 if (!padapter->bSurpriseRemoved) { 410 int err; 411 412 /* test surprise remove */ 413 sdio_claim_host(func); 414 sdio_readb(func, 0, &err); 415 sdio_release_host(func); 416 if (err == -ENOMEDIUM) 417 padapter->bSurpriseRemoved = true; 418 } 419 420 rtw_ps_deny(padapter, PS_DENY_DRV_REMOVE); 421 422 rtw_pm_set_ips(padapter, IPS_NONE); 423 rtw_pm_set_lps(padapter, PS_MODE_ACTIVE); 424 425 LeaveAllPowerSaveMode(padapter); 426 427 rtw_btcoex_HaltNotify(padapter); 428 429 rtw_sdio_if1_deinit(padapter); 430 431 sdio_dvobj_deinit(func); 432 } 433 434 static int rtw_sdio_suspend(struct device *dev) 435 { 436 struct sdio_func *func = dev_to_sdio_func(dev); 437 struct dvobj_priv *psdpriv = sdio_get_drvdata(func); 438 struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv); 439 struct adapter *padapter = psdpriv->if1; 440 struct debug_priv *pdbgpriv = &psdpriv->drv_dbg; 441 442 if (padapter->bDriverStopped) 443 return 0; 444 445 if (pwrpriv->bInSuspend) { 446 pdbgpriv->dbg_suspend_error_cnt++; 447 return 0; 448 } 449 450 rtw_suspend_common(padapter); 451 452 return 0; 453 } 454 455 static int rtw_resume_process(struct adapter *padapter) 456 { 457 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); 458 struct dvobj_priv *psdpriv = padapter->dvobj; 459 struct debug_priv *pdbgpriv = &psdpriv->drv_dbg; 460 461 if (!pwrpriv->bInSuspend) { 462 pdbgpriv->dbg_resume_error_cnt++; 463 return -1; 464 } 465 466 return rtw_resume_common(padapter); 467 } 468 469 static int rtw_sdio_resume(struct device *dev) 470 { 471 struct sdio_func *func = dev_to_sdio_func(dev); 472 struct dvobj_priv *psdpriv = sdio_get_drvdata(func); 473 struct adapter *padapter = psdpriv->if1; 474 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv; 475 int ret = 0; 476 struct debug_priv *pdbgpriv = &psdpriv->drv_dbg; 477 478 pdbgpriv->dbg_resume_cnt++; 479 480 ret = rtw_resume_process(padapter); 481 482 pmlmeext->last_scan_time = jiffies; 483 return ret; 484 } 485 486 static int __init rtw_drv_entry(void) 487 { 488 int ret; 489 490 ret = sdio_register_driver(&rtl8723bs_sdio_driver); 491 if (ret != 0) 492 rtw_ndev_notifier_unregister(); 493 494 return ret; 495 } 496 497 static void __exit rtw_drv_halt(void) 498 { 499 sdio_unregister_driver(&rtl8723bs_sdio_driver); 500 501 rtw_ndev_notifier_unregister(); 502 } 503 504 505 module_init(rtw_drv_entry); 506 module_exit(rtw_drv_halt); 507