1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2007 - 2011 Realtek Corporation. */
3
4 #define _HCI_INTF_C_
5
6 #include <linux/usb.h>
7 #include "../include/osdep_service.h"
8 #include "../include/drv_types.h"
9 #include "../include/recv_osdep.h"
10 #include "../include/xmit_osdep.h"
11 #include "../include/hal_intf.h"
12 #include "../include/osdep_intf.h"
13 #include "../include/usb_vendor_req.h"
14 #include "../include/usb_ops.h"
15 #include "../include/usb_osintf.h"
16 #include "../include/rtw_ioctl.h"
17
18 int ui_pid[3] = {0, 0, 0};
19
20 static int rtw_suspend(struct usb_interface *intf, pm_message_t message);
21 static int rtw_resume(struct usb_interface *intf);
22
23 static int rtw_drv_init(struct usb_interface *pusb_intf, const struct usb_device_id *pdid);
24 static void rtw_dev_remove(struct usb_interface *pusb_intf);
25
26 #define USB_VENDER_ID_REALTEK 0x0bda
27
28 /* DID_USB_v916_20130116 */
29 static struct usb_device_id rtw_usb_id_tbl[] = {
30 /*=== Realtek demoboard ===*/
31 {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8179)}, /* 8188EUS */
32 {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x0179)}, /* 8188ETV */
33 {USB_DEVICE(USB_VENDER_ID_REALTEK, 0xf179)}, /* 8188FU */
34 /*=== Customer ID ===*/
35 /****** 8188EUS ********/
36 {USB_DEVICE(0x07B8, 0x8179)}, /* Abocom - Abocom */
37 {USB_DEVICE(0x0DF6, 0x0076)}, /* Sitecom N150 v2 */
38 {USB_DEVICE(0x2001, 0x330F)}, /* DLink DWA-125 REV D1 */
39 {USB_DEVICE(0x2001, 0x3310)}, /* Dlink DWA-123 REV D1 */
40 {USB_DEVICE(0x2001, 0x3311)}, /* DLink GO-USB-N150 REV B1 */
41 {USB_DEVICE(0x2001, 0x331B)}, /* D-Link DWA-121 rev B1 */
42 {USB_DEVICE(0x056E, 0x4008)}, /* Elecom WDC-150SU2M */
43 {USB_DEVICE(0x2357, 0x010c)}, /* TP-Link TL-WN722N v2 */
44 {USB_DEVICE(0x2357, 0x0111)}, /* TP-Link TL-WN727N v5.21 */
45 {USB_DEVICE(0x2C4E, 0x0102)}, /* MERCUSYS MW150US v2 */
46 {USB_DEVICE(0x0B05, 0x18F0)}, /* ASUS USB-N10 Nano B1 */
47 {USB_DEVICE(0x7392, 0xb811)}, /* Edimax EW-7811Un V2 */
48 {} /* Terminating entry */
49 };
50
51 MODULE_DEVICE_TABLE(usb, rtw_usb_id_tbl);
52
53 static struct specific_device_id specific_device_id_tbl[] = {
54 {} /* empty table for now */
55 };
56
57 struct rtw_usb_drv {
58 struct usb_driver usbdrv;
59 int drv_registered;
60 struct mutex hw_init_mutex;
61 };
62
63 static struct rtw_usb_drv rtl8188e_usb_drv = {
64 .usbdrv.name = "r8188eu",
65 .usbdrv.probe = rtw_drv_init,
66 .usbdrv.disconnect = rtw_dev_remove,
67 .usbdrv.id_table = rtw_usb_id_tbl,
68 .usbdrv.suspend = rtw_suspend,
69 .usbdrv.resume = rtw_resume,
70 .usbdrv.reset_resume = rtw_resume,
71 };
72
73 static struct rtw_usb_drv *usb_drv = &rtl8188e_usb_drv;
74
RT_usb_endpoint_dir_in(const struct usb_endpoint_descriptor * epd)75 static inline int RT_usb_endpoint_dir_in(const struct usb_endpoint_descriptor *epd)
76 {
77 return (epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN;
78 }
79
RT_usb_endpoint_dir_out(const struct usb_endpoint_descriptor * epd)80 static inline int RT_usb_endpoint_dir_out(const struct usb_endpoint_descriptor *epd)
81 {
82 return (epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT;
83 }
84
RT_usb_endpoint_xfer_int(const struct usb_endpoint_descriptor * epd)85 static inline int RT_usb_endpoint_xfer_int(const struct usb_endpoint_descriptor *epd)
86 {
87 return (epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT;
88 }
89
RT_usb_endpoint_xfer_bulk(const struct usb_endpoint_descriptor * epd)90 static inline int RT_usb_endpoint_xfer_bulk(const struct usb_endpoint_descriptor *epd)
91 {
92 return (epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK;
93 }
94
RT_usb_endpoint_is_bulk_in(const struct usb_endpoint_descriptor * epd)95 static inline int RT_usb_endpoint_is_bulk_in(const struct usb_endpoint_descriptor *epd)
96 {
97 return RT_usb_endpoint_xfer_bulk(epd) && RT_usb_endpoint_dir_in(epd);
98 }
99
RT_usb_endpoint_is_bulk_out(const struct usb_endpoint_descriptor * epd)100 static inline int RT_usb_endpoint_is_bulk_out(const struct usb_endpoint_descriptor *epd)
101 {
102 return RT_usb_endpoint_xfer_bulk(epd) && RT_usb_endpoint_dir_out(epd);
103 }
104
usb_endpoint_is_int(const struct usb_endpoint_descriptor * epd)105 static inline int usb_endpoint_is_int(const struct usb_endpoint_descriptor *epd)
106 {
107 return RT_usb_endpoint_xfer_int(epd) && RT_usb_endpoint_dir_in(epd);
108 }
109
RT_usb_endpoint_num(const struct usb_endpoint_descriptor * epd)110 static inline int RT_usb_endpoint_num(const struct usb_endpoint_descriptor *epd)
111 {
112 return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
113 }
114
rtw_init_intf_priv(struct dvobj_priv * dvobj)115 static u8 rtw_init_intf_priv(struct dvobj_priv *dvobj)
116 {
117 u8 rst = _SUCCESS;
118
119 _rtw_mutex_init(&dvobj->usb_vendor_req_mutex);
120
121 dvobj->usb_alloc_vendor_req_buf = kzalloc(MAX_USB_IO_CTL_SIZE, GFP_KERNEL);
122 if (!dvobj->usb_alloc_vendor_req_buf) {
123 DBG_88E("alloc usb_vendor_req_buf failed... /n");
124 rst = _FAIL;
125 goto exit;
126 }
127 dvobj->usb_vendor_req_buf = (u8 *)N_BYTE_ALIGMENT((size_t)(dvobj->usb_alloc_vendor_req_buf), ALIGNMENT_UNIT);
128 exit:
129 return rst;
130 }
131
rtw_deinit_intf_priv(struct dvobj_priv * dvobj)132 static void rtw_deinit_intf_priv(struct dvobj_priv *dvobj)
133 {
134 kfree(dvobj->usb_alloc_vendor_req_buf);
135 _rtw_mutex_free(&dvobj->usb_vendor_req_mutex);
136 }
137
usb_dvobj_init(struct usb_interface * usb_intf)138 static struct dvobj_priv *usb_dvobj_init(struct usb_interface *usb_intf)
139 {
140 int i;
141 int status = _FAIL;
142 struct dvobj_priv *pdvobjpriv;
143 struct usb_host_config *phost_conf;
144 struct usb_config_descriptor *pconf_desc;
145 struct usb_host_interface *phost_iface;
146 struct usb_interface_descriptor *piface_desc;
147 struct usb_endpoint_descriptor *pendp_desc;
148 struct usb_device *pusbd;
149
150 pdvobjpriv = kzalloc(sizeof(*pdvobjpriv), GFP_KERNEL);
151 if (!pdvobjpriv)
152 goto exit;
153
154 pdvobjpriv->pusbintf = usb_intf;
155 pusbd = interface_to_usbdev(usb_intf);
156 pdvobjpriv->pusbdev = pusbd;
157 usb_set_intfdata(usb_intf, pdvobjpriv);
158
159 pdvobjpriv->RtNumInPipes = 0;
160 pdvobjpriv->RtNumOutPipes = 0;
161
162 phost_conf = pusbd->actconfig;
163 pconf_desc = &phost_conf->desc;
164
165 phost_iface = &usb_intf->altsetting[0];
166 piface_desc = &phost_iface->desc;
167
168 pdvobjpriv->NumInterfaces = pconf_desc->bNumInterfaces;
169 pdvobjpriv->InterfaceNumber = piface_desc->bInterfaceNumber;
170 pdvobjpriv->nr_endpoint = piface_desc->bNumEndpoints;
171
172 for (i = 0; i < pdvobjpriv->nr_endpoint; i++) {
173 int ep_num;
174 pendp_desc = &phost_iface->endpoint[i].desc;
175
176 ep_num = usb_endpoint_num(pendp_desc);
177
178 if (usb_endpoint_is_bulk_in(pendp_desc)) {
179 pdvobjpriv->RtInPipe[pdvobjpriv->RtNumInPipes] = ep_num;
180 pdvobjpriv->RtNumInPipes++;
181 } else if (usb_endpoint_is_int_in(pendp_desc)) {
182 pdvobjpriv->RtInPipe[pdvobjpriv->RtNumInPipes] = ep_num;
183 pdvobjpriv->RtNumInPipes++;
184 } else if (usb_endpoint_is_bulk_out(pendp_desc)) {
185 pdvobjpriv->RtOutPipe[pdvobjpriv->RtNumOutPipes] =
186 ep_num;
187 pdvobjpriv->RtNumOutPipes++;
188 }
189 pdvobjpriv->ep_num[i] = ep_num;
190 }
191
192 if (pusbd->speed == USB_SPEED_HIGH) {
193 pdvobjpriv->ishighspeed = true;
194 DBG_88E("USB_SPEED_HIGH\n");
195 } else {
196 pdvobjpriv->ishighspeed = false;
197 DBG_88E("NON USB_SPEED_HIGH\n");
198 }
199
200 if (rtw_init_intf_priv(pdvobjpriv) == _FAIL)
201 goto free_dvobj;
202
203 /* 3 misc */
204 sema_init(&pdvobjpriv->usb_suspend_sema, 0);
205 rtw_reset_continual_urb_error(pdvobjpriv);
206
207 usb_get_dev(pusbd);
208
209 status = _SUCCESS;
210
211 free_dvobj:
212 if (status != _SUCCESS && pdvobjpriv) {
213 usb_set_intfdata(usb_intf, NULL);
214 kfree(pdvobjpriv);
215 pdvobjpriv = NULL;
216 }
217 exit:
218 return pdvobjpriv;
219 }
220
usb_dvobj_deinit(struct usb_interface * usb_intf)221 static void usb_dvobj_deinit(struct usb_interface *usb_intf)
222 {
223 struct dvobj_priv *dvobj = usb_get_intfdata(usb_intf);
224
225 usb_set_intfdata(usb_intf, NULL);
226 if (dvobj) {
227 /* Modify condition for 92DU DMDP 2010.11.18, by Thomas */
228 if ((dvobj->NumInterfaces != 2 &&
229 dvobj->NumInterfaces != 3) ||
230 (dvobj->InterfaceNumber == 1)) {
231 if (interface_to_usbdev(usb_intf)->state !=
232 USB_STATE_NOTATTACHED) {
233 /* If we didn't unplug usb dongle and
234 * remove/insert module, driver fails
235 * on sitesurvey for the first time when
236 * device is up . Reset usb port for sitesurvey
237 * fail issue. */
238 DBG_88E("usb attached..., try to reset usb device\n");
239 usb_reset_device(interface_to_usbdev(usb_intf));
240 }
241 }
242 rtw_deinit_intf_priv(dvobj);
243 kfree(dvobj);
244 }
245
246 usb_put_dev(interface_to_usbdev(usb_intf));
247
248 }
249
chip_by_usb_id(struct adapter * padapter)250 static void chip_by_usb_id(struct adapter *padapter)
251 {
252 padapter->chip_type = NULL_CHIP_TYPE;
253 hal_set_hw_type(padapter);
254 }
255
usb_intf_start(struct adapter * padapter)256 static void usb_intf_start(struct adapter *padapter)
257 {
258 rtw_hal_inirp_init(padapter);
259 }
260
usb_intf_stop(struct adapter * padapter)261 static void usb_intf_stop(struct adapter *padapter)
262 {
263 /* cancel in irp */
264 rtw_hal_inirp_deinit(padapter);
265
266 /* cancel out irp */
267 rtw_write_port_cancel(padapter);
268
269 /* todo:cancel other irps */
270 }
271
rtw_dev_unload(struct adapter * padapter)272 static void rtw_dev_unload(struct adapter *padapter)
273 {
274 if (padapter->bup) {
275 DBG_88E("===> rtw_dev_unload\n");
276 padapter->bDriverStopped = true;
277 if (padapter->xmitpriv.ack_tx)
278 rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
279 /* s3. */
280 if (padapter->intf_stop)
281 padapter->intf_stop(padapter);
282 /* s4. */
283 if (!padapter->pwrctrlpriv.bInternalAutoSuspend)
284 rtw_stop_drv_threads(padapter);
285
286 /* s5. */
287 if (!padapter->bSurpriseRemoved) {
288 rtw_hal_deinit(padapter);
289 padapter->bSurpriseRemoved = true;
290 }
291
292 padapter->bup = false;
293 }
294
295 DBG_88E("<=== rtw_dev_unload\n");
296 }
297
process_spec_devid(const struct usb_device_id * pdid)298 static void process_spec_devid(const struct usb_device_id *pdid)
299 {
300 u16 vid, pid;
301 u32 flags;
302 int i;
303 int num = sizeof(specific_device_id_tbl) /
304 sizeof(struct specific_device_id);
305
306 for (i = 0; i < num; i++) {
307 vid = specific_device_id_tbl[i].idVendor;
308 pid = specific_device_id_tbl[i].idProduct;
309 flags = specific_device_id_tbl[i].flags;
310
311 if ((pdid->idVendor == vid) && (pdid->idProduct == pid) &&
312 (flags & SPEC_DEV_ID_DISABLE_HT)) {
313 rtw_ht_enable = 0;
314 rtw_cbw40_enable = 0;
315 rtw_ampdu_enable = 0;
316 }
317 }
318 }
319
rtw_hw_suspend(struct adapter * padapter)320 int rtw_hw_suspend(struct adapter *padapter)
321 {
322 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
323 struct net_device *pnetdev = padapter->pnetdev;
324
325
326 if (!padapter)
327 goto error_exit;
328 if ((!padapter->bup) || (padapter->bDriverStopped) ||
329 (padapter->bSurpriseRemoved)) {
330 DBG_88E("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
331 padapter->bup, padapter->bDriverStopped,
332 padapter->bSurpriseRemoved);
333 goto error_exit;
334 }
335
336 LeaveAllPowerSaveMode(padapter);
337
338 DBG_88E("==> rtw_hw_suspend\n");
339 _enter_pwrlock(&pwrpriv->lock);
340 pwrpriv->bips_processing = true;
341 /* s1. */
342 if (pnetdev) {
343 netif_carrier_off(pnetdev);
344 rtw_netif_stop_queue(pnetdev);
345 }
346
347 /* s2. */
348 rtw_disassoc_cmd(padapter, 500, false);
349
350 /* s2-2. indicate disconnect to os */
351 {
352 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
353
354 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
355 _clr_fwstate_(pmlmepriv, _FW_LINKED);
356
357 rtw_led_control(padapter, LED_CTL_NO_LINK);
358
359 rtw_os_indicate_disconnect(padapter);
360
361 /* donnot enqueue cmd */
362 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_DISCONNECT, 0);
363 }
364 }
365 /* s2-3. */
366 rtw_free_assoc_resources(padapter, 1);
367
368 /* s2-4. */
369 rtw_free_network_queue(padapter, true);
370 rtw_ips_dev_unload(padapter);
371 pwrpriv->rf_pwrstate = rf_off;
372 pwrpriv->bips_processing = false;
373
374 _exit_pwrlock(&pwrpriv->lock);
375 return 0;
376
377 error_exit:
378 DBG_88E("%s, failed\n", __func__);
379 return -1;
380 }
381
rtw_hw_resume(struct adapter * padapter)382 int rtw_hw_resume(struct adapter *padapter)
383 {
384 struct pwrctrl_priv *pwrpriv;
385 struct net_device *pnetdev = padapter->pnetdev;
386
387 if (!padapter)
388 goto error_exit;
389 pwrpriv = &padapter->pwrctrlpriv;
390 DBG_88E("==> rtw_hw_resume\n");
391 _enter_pwrlock(&pwrpriv->lock);
392 pwrpriv->bips_processing = true;
393 rtw_reset_drv_sw(padapter);
394
395 if (pm_netdev_open(pnetdev, false) != 0) {
396 _exit_pwrlock(&pwrpriv->lock);
397 goto error_exit;
398 }
399
400 netif_device_attach(pnetdev);
401 netif_carrier_on(pnetdev);
402
403 if (!netif_queue_stopped(pnetdev))
404 netif_start_queue(pnetdev);
405 else
406 netif_wake_queue(pnetdev);
407
408 pwrpriv->bkeepfwalive = false;
409 pwrpriv->brfoffbyhw = false;
410
411 pwrpriv->rf_pwrstate = rf_on;
412 pwrpriv->bips_processing = false;
413
414 _exit_pwrlock(&pwrpriv->lock);
415
416 return 0;
417 error_exit:
418 DBG_88E("%s, Open net dev failed\n", __func__);
419 return -1;
420 }
421
rtw_suspend(struct usb_interface * pusb_intf,pm_message_t message)422 static int rtw_suspend(struct usb_interface *pusb_intf, pm_message_t message)
423 {
424 struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
425 struct adapter *padapter = dvobj->if1;
426 struct net_device *pnetdev = padapter->pnetdev;
427 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
428 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
429
430 int ret = 0;
431 u32 start_time = jiffies;
432
433
434 DBG_88E("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
435
436 if ((!padapter->bup) || (padapter->bDriverStopped) ||
437 (padapter->bSurpriseRemoved)) {
438 DBG_88E("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
439 padapter->bup, padapter->bDriverStopped,
440 padapter->bSurpriseRemoved);
441 goto exit;
442 }
443
444 pwrpriv->bInSuspend = true;
445 rtw_cancel_all_timer(padapter);
446 LeaveAllPowerSaveMode(padapter);
447
448 _enter_pwrlock(&pwrpriv->lock);
449 /* s1. */
450 if (pnetdev) {
451 netif_carrier_off(pnetdev);
452 rtw_netif_stop_queue(pnetdev);
453 }
454
455 /* s2. */
456 rtw_disassoc_cmd(padapter, 0, false);
457
458 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) &&
459 check_fwstate(pmlmepriv, _FW_LINKED)) {
460 DBG_88E("%s:%d %s(%pM), length:%d assoc_ssid.length:%d\n",
461 __func__, __LINE__,
462 pmlmepriv->cur_network.network.Ssid.Ssid,
463 pmlmepriv->cur_network.network.MacAddress,
464 pmlmepriv->cur_network.network.Ssid.SsidLength,
465 pmlmepriv->assoc_ssid.SsidLength);
466
467 pmlmepriv->to_roaming = 1;
468 }
469 /* s2-2. indicate disconnect to os */
470 rtw_indicate_disconnect(padapter);
471 /* s2-3. */
472 rtw_free_assoc_resources(padapter, 1);
473 /* s2-4. */
474 rtw_free_network_queue(padapter, true);
475
476 rtw_dev_unload(padapter);
477 _exit_pwrlock(&pwrpriv->lock);
478
479 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
480 rtw_indicate_scan_done(padapter, 1);
481
482 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
483 rtw_indicate_disconnect(padapter);
484
485 exit:
486 DBG_88E("<=== %s return %d.............. in %dms\n", __func__
487 , ret, rtw_get_passing_time_ms(start_time));
488
489 return ret;
490 }
491
rtw_resume(struct usb_interface * pusb_intf)492 static int rtw_resume(struct usb_interface *pusb_intf)
493 {
494 struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
495 struct adapter *padapter = dvobj->if1;
496 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
497 int ret = 0;
498
499 if (pwrpriv->bInternalAutoSuspend)
500 ret = rtw_resume_process(padapter);
501 else
502 ret = rtw_resume_process(padapter);
503 return ret;
504 }
505
rtw_resume_process(struct adapter * padapter)506 int rtw_resume_process(struct adapter *padapter)
507 {
508 struct net_device *pnetdev;
509 struct pwrctrl_priv *pwrpriv = NULL;
510 int ret = -1;
511 u32 start_time = jiffies;
512
513 DBG_88E("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
514
515 if (padapter) {
516 pnetdev = padapter->pnetdev;
517 pwrpriv = &padapter->pwrctrlpriv;
518 } else {
519 goto exit;
520 }
521
522 _enter_pwrlock(&pwrpriv->lock);
523 rtw_reset_drv_sw(padapter);
524 if (pwrpriv)
525 pwrpriv->bkeepfwalive = false;
526
527 DBG_88E("bkeepfwalive(%x)\n", pwrpriv->bkeepfwalive);
528 if (pm_netdev_open(pnetdev, true) != 0)
529 goto exit;
530
531 netif_device_attach(pnetdev);
532 netif_carrier_on(pnetdev);
533
534 _exit_pwrlock(&pwrpriv->lock);
535
536 if (padapter->pid[1] != 0) {
537 DBG_88E("pid[1]:%d\n", padapter->pid[1]);
538 rtw_signal_process(padapter->pid[1], SIGUSR2);
539 }
540
541 rtw_roaming(padapter, NULL);
542
543 ret = 0;
544 exit:
545 if (pwrpriv)
546 pwrpriv->bInSuspend = false;
547 DBG_88E("<=== %s return %d.............. in %dms\n", __func__,
548 ret, rtw_get_passing_time_ms(start_time));
549
550
551 return ret;
552 }
553
554 /*
555 * drv_init() - a device potentially for us
556 *
557 * notes: drv_init() is called when the bus driver has located
558 * a card for us to support.
559 * We accept the new device by returning 0.
560 */
561
rtw_usb_if1_init(struct dvobj_priv * dvobj,struct usb_interface * pusb_intf)562 static struct adapter *rtw_usb_if1_init(struct dvobj_priv *dvobj,
563 struct usb_interface *pusb_intf)
564 {
565 struct adapter *padapter = NULL;
566 struct net_device *pnetdev = NULL;
567 int status = _FAIL;
568
569 padapter = vzalloc(sizeof(*padapter));
570 if (!padapter)
571 goto exit;
572 padapter->dvobj = dvobj;
573 dvobj->if1 = padapter;
574
575 padapter->bDriverStopped = true;
576
577 padapter->hw_init_mutex = &usb_drv->hw_init_mutex;
578
579 /* step 1-1., decide the chip_type via vid/pid */
580 padapter->interface_type = RTW_USB;
581 chip_by_usb_id(padapter);
582
583 if (rtw_handle_dualmac(padapter, 1) != _SUCCESS)
584 goto free_adapter;
585
586 pnetdev = rtw_init_netdev(padapter);
587 if (!pnetdev)
588 goto handle_dualmac;
589 SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj));
590 padapter = rtw_netdev_priv(pnetdev);
591
592 /* step 2. hook HalFunc, allocate HalData */
593 rtl8188eu_set_hal_ops(padapter);
594
595 padapter->intf_start = &usb_intf_start;
596 padapter->intf_stop = &usb_intf_stop;
597
598 /* step init_io_priv */
599 rtw_init_io_priv(padapter, usb_set_intf_ops);
600
601 /* step read_chip_version */
602 rtw_hal_read_chip_version(padapter);
603
604 /* step usb endpoint mapping */
605 rtw_hal_chip_configure(padapter);
606
607 /* step read efuse/eeprom data and get mac_addr */
608 rtw_hal_read_chip_info(padapter);
609
610 /* step 5. */
611 if (rtw_init_drv_sw(padapter) == _FAIL)
612 goto free_hal_data;
613
614 #ifdef CONFIG_PM
615 if (padapter->pwrctrlpriv.bSupportRemoteWakeup) {
616 dvobj->pusbdev->do_remote_wakeup = 1;
617 pusb_intf->needs_remote_wakeup = 1;
618 device_init_wakeup(&pusb_intf->dev, 1);
619 DBG_88E("\n padapter->pwrctrlpriv.bSupportRemoteWakeup~~~[%d]~~~\n",
620 device_may_wakeup(&pusb_intf->dev));
621 }
622 #endif
623
624 /* 2012-07-11 Move here to prevent the 8723AS-VAU BT auto
625 * suspend influence */
626 if (usb_autopm_get_interface(pusb_intf) < 0)
627 DBG_88E("can't get autopm:\n");
628
629 /* alloc dev name after read efuse. */
630 rtw_init_netdev_name(pnetdev, padapter->registrypriv.ifname);
631 rtw_macaddr_cfg(padapter->eeprompriv.mac_addr);
632 #ifdef CONFIG_88EU_P2P
633 rtw_init_wifidirect_addrs(padapter, padapter->eeprompriv.mac_addr,
634 padapter->eeprompriv.mac_addr);
635 #endif
636 memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
637 DBG_88E("MAC Address from pnetdev->dev_addr = %pM\n",
638 pnetdev->dev_addr);
639
640 /* step 6. Tell the network stack we exist */
641 if (register_netdev(pnetdev) != 0)
642 goto free_hal_data;
643
644 DBG_88E("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n"
645 , padapter->bDriverStopped
646 , padapter->bSurpriseRemoved
647 , padapter->bup
648 , padapter->hw_init_completed
649 );
650
651 status = _SUCCESS;
652
653 free_hal_data:
654 if (status != _SUCCESS)
655 kfree(padapter->HalData);
656 handle_dualmac:
657 if (status != _SUCCESS)
658 rtw_handle_dualmac(padapter, 0);
659 free_adapter:
660 if (status != _SUCCESS) {
661 if (pnetdev)
662 rtw_free_netdev(pnetdev);
663 else if (padapter)
664 vfree(padapter);
665 padapter = NULL;
666 }
667 exit:
668 return padapter;
669 }
670
rtw_usb_if1_deinit(struct adapter * if1)671 static void rtw_usb_if1_deinit(struct adapter *if1)
672 {
673 struct net_device *pnetdev = if1->pnetdev;
674 struct mlme_priv *pmlmepriv = &if1->mlmepriv;
675
676 if (check_fwstate(pmlmepriv, _FW_LINKED))
677 rtw_disassoc_cmd(if1, 0, false);
678
679 #ifdef CONFIG_88EU_AP_MODE
680 free_mlme_ap_info(if1);
681 #endif
682
683 if (if1->DriverState != DRIVER_DISAPPEAR) {
684 if (pnetdev) {
685 /* will call netdev_close() */
686 unregister_netdev(pnetdev);
687 rtw_proc_remove_one(pnetdev);
688 }
689 }
690 rtw_cancel_all_timer(if1);
691
692 rtw_dev_unload(if1);
693 DBG_88E("+r871xu_dev_remove, hw_init_completed=%d\n",
694 if1->hw_init_completed);
695 rtw_handle_dualmac(if1, 0);
696 rtw_free_drv_sw(if1);
697 if (pnetdev)
698 rtw_free_netdev(pnetdev);
699 }
700
rtw_drv_init(struct usb_interface * pusb_intf,const struct usb_device_id * pdid)701 static int rtw_drv_init(struct usb_interface *pusb_intf, const struct usb_device_id *pdid)
702 {
703 struct adapter *if1 = NULL;
704 struct dvobj_priv *dvobj;
705
706 /* step 0. */
707 process_spec_devid(pdid);
708
709 /* Initialize dvobj_priv */
710 dvobj = usb_dvobj_init(pusb_intf);
711 if (!dvobj)
712 goto err;
713
714 if1 = rtw_usb_if1_init(dvobj, pusb_intf);
715 if (!if1) {
716 DBG_88E("rtw_init_primarystruct adapter Failed!\n");
717 goto free_dvobj;
718 }
719
720 if (ui_pid[1] != 0) {
721 DBG_88E("ui_pid[1]:%d\n", ui_pid[1]);
722 rtw_signal_process(ui_pid[1], SIGUSR2);
723 }
724
725 return 0;
726
727 free_dvobj:
728 usb_dvobj_deinit(pusb_intf);
729 err:
730 return -ENODEV;
731 }
732
733 /*
734 * dev_remove() - our device is being removed
735 */
736 /* rmmod module & unplug(SurpriseRemoved) will call r871xu_dev_remove() => how to recognize both */
rtw_dev_remove(struct usb_interface * pusb_intf)737 static void rtw_dev_remove(struct usb_interface *pusb_intf)
738 {
739 struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
740 struct adapter *padapter = dvobj->if1;
741
742 DBG_88E("+rtw_dev_remove\n");
743
744 if (usb_drv->drv_registered)
745 padapter->bSurpriseRemoved = true;
746
747 rtw_pm_set_ips(padapter, IPS_NONE);
748 rtw_pm_set_lps(padapter, PS_MODE_ACTIVE);
749
750 LeaveAllPowerSaveMode(padapter);
751
752 rtw_usb_if1_deinit(padapter);
753
754 usb_dvobj_deinit(pusb_intf);
755
756 DBG_88E("-r871xu_dev_remove, done\n");
757 }
758
rtw_drv_entry(void)759 static int __init rtw_drv_entry(void)
760 {
761 DBG_88E(DRV_NAME " driver version=%s\n", DRIVERVERSION);
762
763 _rtw_mutex_init(&usb_drv->hw_init_mutex);
764
765 usb_drv->drv_registered = true;
766 return usb_register(&usb_drv->usbdrv);
767 }
768
rtw_drv_halt(void)769 static void __exit rtw_drv_halt(void)
770 {
771 DBG_88E("+rtw_drv_halt\n");
772
773 usb_drv->drv_registered = false;
774 usb_deregister(&usb_drv->usbdrv);
775
776 _rtw_mutex_free(&usb_drv->hw_init_mutex);
777 DBG_88E("-rtw_drv_halt\n");
778 }
779
780 module_init(rtw_drv_entry);
781 module_exit(rtw_drv_halt);
782
