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