1
2
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
18int ui_pid[3] = {0, 0, 0};
19
20static int rtw_suspend(struct usb_interface *intf, pm_message_t message);
21static int rtw_resume(struct usb_interface *intf);
22
23static int rtw_drv_init(struct usb_interface *pusb_intf, const struct usb_device_id *pdid);
24static void rtw_dev_remove(struct usb_interface *pusb_intf);
25
26#define USB_VENDER_ID_REALTEK 0x0bda
27
28
29static struct usb_device_id rtw_usb_id_tbl[] = {
30
31 {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8179)},
32 {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x0179)},
33 {USB_DEVICE(USB_VENDER_ID_REALTEK, 0xf179)},
34
35
36 {USB_DEVICE(0x07B8, 0x8179)},
37 {USB_DEVICE(0x0DF6, 0x0076)},
38 {USB_DEVICE(0x2001, 0x330F)},
39 {USB_DEVICE(0x2001, 0x3310)},
40 {USB_DEVICE(0x2001, 0x3311)},
41 {USB_DEVICE(0x2001, 0x331B)},
42 {USB_DEVICE(0x056E, 0x4008)},
43 {USB_DEVICE(0x2357, 0x010c)},
44 {USB_DEVICE(0x2357, 0x0111)},
45 {USB_DEVICE(0x2C4E, 0x0102)},
46 {USB_DEVICE(0x0B05, 0x18F0)},
47 {USB_DEVICE(0x7392, 0xb811)},
48 {}
49};
50
51MODULE_DEVICE_TABLE(usb, rtw_usb_id_tbl);
52
53static struct specific_device_id specific_device_id_tbl[] = {
54 {}
55};
56
57struct rtw_usb_drv {
58 struct usb_driver usbdrv;
59 int drv_registered;
60 struct mutex hw_init_mutex;
61};
62
63static 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
73static struct rtw_usb_drv *usb_drv = &rtl8188e_usb_drv;
74
75static 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
80static 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
85static 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
90static 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
95static 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
100static 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
105static 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
110static inline int RT_usb_endpoint_num(const struct usb_endpoint_descriptor *epd)
111{
112 return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
113}
114
115static 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);
128exit:
129 return rst;
130}
131
132static 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
138static 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
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
211free_dvobj:
212 if (status != _SUCCESS && pdvobjpriv) {
213 usb_set_intfdata(usb_intf, NULL);
214 kfree(pdvobjpriv);
215 pdvobjpriv = NULL;
216 }
217exit:
218 return pdvobjpriv;
219}
220
221static 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
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
234
235
236
237
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
250static void chip_by_usb_id(struct adapter *padapter)
251{
252 padapter->chip_type = NULL_CHIP_TYPE;
253 hal_set_hw_type(padapter);
254}
255
256static void usb_intf_start(struct adapter *padapter)
257{
258 rtw_hal_inirp_init(padapter);
259}
260
261static void usb_intf_stop(struct adapter *padapter)
262{
263
264 rtw_hal_inirp_deinit(padapter);
265
266
267 rtw_write_port_cancel(padapter);
268
269
270}
271
272static 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
280 if (padapter->intf_stop)
281 padapter->intf_stop(padapter);
282
283 if (!padapter->pwrctrlpriv.bInternalAutoSuspend)
284 rtw_stop_drv_threads(padapter);
285
286
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
298static 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
320int 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
342 if (pnetdev) {
343 netif_carrier_off(pnetdev);
344 rtw_netif_stop_queue(pnetdev);
345 }
346
347
348 rtw_disassoc_cmd(padapter, 500, false);
349
350
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
362 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_DISCONNECT, 0);
363 }
364 }
365
366 rtw_free_assoc_resources(padapter, 1);
367
368
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
377error_exit:
378 DBG_88E("%s, failed\n", __func__);
379 return -1;
380}
381
382int 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;
417error_exit:
418 DBG_88E("%s, Open net dev failed\n", __func__);
419 return -1;
420}
421
422static 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
450 if (pnetdev) {
451 netif_carrier_off(pnetdev);
452 rtw_netif_stop_queue(pnetdev);
453 }
454
455
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
470 rtw_indicate_disconnect(padapter);
471
472 rtw_free_assoc_resources(padapter, 1);
473
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
485exit:
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
492static 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
506int 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;
544exit:
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
556
557
558
559
560
561
562static 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
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
593 rtl8188eu_set_hal_ops(padapter);
594
595 padapter->intf_start = &usb_intf_start;
596 padapter->intf_stop = &usb_intf_stop;
597
598
599 rtw_init_io_priv(padapter, usb_set_intf_ops);
600
601
602 rtw_hal_read_chip_version(padapter);
603
604
605 rtw_hal_chip_configure(padapter);
606
607
608 rtw_hal_read_chip_info(padapter);
609
610
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
625
626 if (usb_autopm_get_interface(pusb_intf) < 0)
627 DBG_88E("can't get autopm:\n");
628
629
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
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
653free_hal_data:
654 if (status != _SUCCESS)
655 kfree(padapter->HalData);
656handle_dualmac:
657 if (status != _SUCCESS)
658 rtw_handle_dualmac(padapter, 0);
659free_adapter:
660 if (status != _SUCCESS) {
661 if (pnetdev)
662 rtw_free_netdev(pnetdev);
663 else if (padapter)
664 vfree(padapter);
665 padapter = NULL;
666 }
667exit:
668 return padapter;
669}
670
671static 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
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
701static 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
707 process_spec_devid(pdid);
708
709
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
727free_dvobj:
728 usb_dvobj_deinit(pusb_intf);
729err:
730 return -ENODEV;
731}
732
733
734
735
736
737static 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
759static 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
769static 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
780module_init(rtw_drv_entry);
781module_exit(rtw_drv_halt);
782