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