1 /******************************************************************************
3 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 ******************************************************************************/
22 #include <osdep_service.h>
23 #include <drv_types.h>
24 #include <recv_osdep.h>
25 #include <xmit_osdep.h>
27 #include <rtw_version.h>
28 #include <linux/usb.h>
29 #include <osdep_intf.h>
31 #include <usb_vendor_req.h>
33 #include <usb_osintf.h>
35 #include <rtw_ioctl.h>
37 int ui_pid
[3] = {0, 0, 0};
39 static int rtw_suspend(struct usb_interface
*intf
, pm_message_t message
);
40 static int rtw_resume(struct usb_interface
*intf
);
43 static int rtw_drv_init(struct usb_interface
*pusb_intf
, const struct usb_device_id
*pdid
);
44 static void rtw_dev_remove(struct usb_interface
*pusb_intf
);
47 #define USB_VENDER_ID_REALTEK 0x0bda
49 /* DID_USB_v916_20130116 */
50 static struct usb_device_id rtw_usb_id_tbl
[] = {
51 /*=== Realtek demoboard ===*/
52 {USB_DEVICE(USB_VENDER_ID_REALTEK
, 0x8179)}, /* 8188EUS */
53 {USB_DEVICE(USB_VENDER_ID_REALTEK
, 0x0179)}, /* 8188ETV */
54 /*=== Customer ID ===*/
55 /****** 8188EUS ********/
56 {USB_DEVICE(0x8179, 0x07B8)}, /* Abocom - Abocom */
57 {USB_DEVICE(0x2001, 0x330F)}, /* DLink DWA-125 REV D1 */
58 {} /* Terminating entry */
61 MODULE_DEVICE_TABLE(usb
, rtw_usb_id_tbl
);
63 static struct specific_device_id specific_device_id_tbl
[] = {
64 {} /* empty table for now */
68 struct usb_driver usbdrv
;
70 struct mutex hw_init_mutex
;
73 static struct rtw_usb_drv rtl8188e_usb_drv
= {
74 .usbdrv
.name
= (char *)"r8188eu",
75 .usbdrv
.probe
= rtw_drv_init
,
76 .usbdrv
.disconnect
= rtw_dev_remove
,
77 .usbdrv
.id_table
= rtw_usb_id_tbl
,
78 .usbdrv
.suspend
= rtw_suspend
,
79 .usbdrv
.resume
= rtw_resume
,
80 .usbdrv
.reset_resume
= rtw_resume
,
83 static struct rtw_usb_drv
*usb_drv
= &rtl8188e_usb_drv
;
85 static inline int RT_usb_endpoint_dir_in(const struct usb_endpoint_descriptor
*epd
)
87 return (epd
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) == USB_DIR_IN
;
90 static inline int RT_usb_endpoint_dir_out(const struct usb_endpoint_descriptor
*epd
)
92 return (epd
->bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) == USB_DIR_OUT
;
95 static inline int RT_usb_endpoint_xfer_int(const struct usb_endpoint_descriptor
*epd
)
97 return (epd
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) == USB_ENDPOINT_XFER_INT
;
100 static inline int RT_usb_endpoint_xfer_bulk(const struct usb_endpoint_descriptor
*epd
)
102 return (epd
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) == USB_ENDPOINT_XFER_BULK
;
105 static inline int RT_usb_endpoint_is_bulk_in(const struct usb_endpoint_descriptor
*epd
)
107 return RT_usb_endpoint_xfer_bulk(epd
) && RT_usb_endpoint_dir_in(epd
);
110 static inline int RT_usb_endpoint_is_bulk_out(const struct usb_endpoint_descriptor
*epd
)
112 return RT_usb_endpoint_xfer_bulk(epd
) && RT_usb_endpoint_dir_out(epd
);
115 static inline int usb_endpoint_is_int(const struct usb_endpoint_descriptor
*epd
)
117 return RT_usb_endpoint_xfer_int(epd
) && RT_usb_endpoint_dir_in(epd
);
120 static inline int RT_usb_endpoint_num(const struct usb_endpoint_descriptor
*epd
)
122 return epd
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
;
125 static u8
rtw_init_intf_priv(struct dvobj_priv
*dvobj
)
129 _rtw_mutex_init(&dvobj
->usb_vendor_req_mutex
);
131 dvobj
->usb_alloc_vendor_req_buf
= rtw_zmalloc(MAX_USB_IO_CTL_SIZE
);
132 if (dvobj
->usb_alloc_vendor_req_buf
== NULL
) {
133 DBG_88E("alloc usb_vendor_req_buf failed... /n");
137 dvobj
->usb_vendor_req_buf
= (u8
*)N_BYTE_ALIGMENT((size_t)(dvobj
->usb_alloc_vendor_req_buf
), ALIGNMENT_UNIT
);
142 static u8
rtw_deinit_intf_priv(struct dvobj_priv
*dvobj
)
146 kfree(dvobj
->usb_alloc_vendor_req_buf
);
147 _rtw_mutex_free(&dvobj
->usb_vendor_req_mutex
);
151 static struct dvobj_priv
*usb_dvobj_init(struct usb_interface
*usb_intf
)
155 struct dvobj_priv
*pdvobjpriv
;
156 struct usb_host_config
*phost_conf
;
157 struct usb_config_descriptor
*pconf_desc
;
158 struct usb_host_interface
*phost_iface
;
159 struct usb_interface_descriptor
*piface_desc
;
160 struct usb_host_endpoint
*phost_endp
;
161 struct usb_endpoint_descriptor
*pendp_desc
;
162 struct usb_device
*pusbd
;
166 pdvobjpriv
= (struct dvobj_priv
*)rtw_zmalloc(sizeof(*pdvobjpriv
));
167 if (pdvobjpriv
== NULL
)
170 pdvobjpriv
->pusbintf
= usb_intf
;
171 pusbd
= interface_to_usbdev(usb_intf
);
172 pdvobjpriv
->pusbdev
= pusbd
;
173 usb_set_intfdata(usb_intf
, pdvobjpriv
);
175 pdvobjpriv
->RtNumInPipes
= 0;
176 pdvobjpriv
->RtNumOutPipes
= 0;
178 phost_conf
= pusbd
->actconfig
;
179 pconf_desc
= &phost_conf
->desc
;
181 phost_iface
= &usb_intf
->altsetting
[0];
182 piface_desc
= &phost_iface
->desc
;
184 pdvobjpriv
->NumInterfaces
= pconf_desc
->bNumInterfaces
;
185 pdvobjpriv
->InterfaceNumber
= piface_desc
->bInterfaceNumber
;
186 pdvobjpriv
->nr_endpoint
= piface_desc
->bNumEndpoints
;
188 for (i
= 0; i
< pdvobjpriv
->nr_endpoint
; i
++) {
189 phost_endp
= phost_iface
->endpoint
+ i
;
191 pendp_desc
= &phost_endp
->desc
;
193 DBG_88E("\nusb_endpoint_descriptor(%d):\n", i
);
194 DBG_88E("bLength=%x\n", pendp_desc
->bLength
);
195 DBG_88E("bDescriptorType=%x\n",
196 pendp_desc
->bDescriptorType
);
197 DBG_88E("bEndpointAddress=%x\n",
198 pendp_desc
->bEndpointAddress
);
199 DBG_88E("wMaxPacketSize=%d\n",
200 le16_to_cpu(pendp_desc
->wMaxPacketSize
));
201 DBG_88E("bInterval=%x\n", pendp_desc
->bInterval
);
203 if (RT_usb_endpoint_is_bulk_in(pendp_desc
)) {
204 DBG_88E("RT_usb_endpoint_is_bulk_in = %x\n",
205 RT_usb_endpoint_num(pendp_desc
));
206 pdvobjpriv
->RtInPipe
[pdvobjpriv
->RtNumInPipes
] = RT_usb_endpoint_num(pendp_desc
);
207 pdvobjpriv
->RtNumInPipes
++;
208 } else if (usb_endpoint_is_int(pendp_desc
)) {
209 DBG_88E("usb_endpoint_is_int = %x, Interval = %x\n",
210 RT_usb_endpoint_num(pendp_desc
),
211 pendp_desc
->bInterval
);
212 pdvobjpriv
->RtInPipe
[pdvobjpriv
->RtNumInPipes
] = RT_usb_endpoint_num(pendp_desc
);
213 pdvobjpriv
->RtNumInPipes
++;
214 } else if (RT_usb_endpoint_is_bulk_out(pendp_desc
)) {
215 DBG_88E("RT_usb_endpoint_is_bulk_out = %x\n",
216 RT_usb_endpoint_num(pendp_desc
));
217 pdvobjpriv
->RtOutPipe
[pdvobjpriv
->RtNumOutPipes
] = RT_usb_endpoint_num(pendp_desc
);
218 pdvobjpriv
->RtNumOutPipes
++;
220 pdvobjpriv
->ep_num
[i
] = RT_usb_endpoint_num(pendp_desc
);
224 DBG_88E("nr_endpoint=%d, in_num=%d, out_num=%d\n\n",
225 pdvobjpriv
->nr_endpoint
, pdvobjpriv
->RtNumInPipes
,
226 pdvobjpriv
->RtNumOutPipes
);
228 if (pusbd
->speed
== USB_SPEED_HIGH
) {
229 pdvobjpriv
->ishighspeed
= true;
230 DBG_88E("USB_SPEED_HIGH\n");
232 pdvobjpriv
->ishighspeed
= false;
233 DBG_88E("NON USB_SPEED_HIGH\n");
236 if (rtw_init_intf_priv(pdvobjpriv
) == _FAIL
) {
237 RT_TRACE(_module_os_intfs_c_
, _drv_err_
,
238 ("\n Can't INIT rtw_init_intf_priv\n"));
243 _rtw_init_sema(&(pdvobjpriv
->usb_suspend_sema
), 0);
244 rtw_reset_continual_urb_error(pdvobjpriv
);
251 if (status
!= _SUCCESS
&& pdvobjpriv
) {
252 usb_set_intfdata(usb_intf
, NULL
);
261 static void usb_dvobj_deinit(struct usb_interface
*usb_intf
)
263 struct dvobj_priv
*dvobj
= usb_get_intfdata(usb_intf
);
267 usb_set_intfdata(usb_intf
, NULL
);
269 /* Modify condition for 92DU DMDP 2010.11.18, by Thomas */
270 if ((dvobj
->NumInterfaces
!= 2 &&
271 dvobj
->NumInterfaces
!= 3) ||
272 (dvobj
->InterfaceNumber
== 1)) {
273 if (interface_to_usbdev(usb_intf
)->state
!=
274 USB_STATE_NOTATTACHED
) {
275 /* If we didn't unplug usb dongle and
276 * remove/insert module, driver fails
277 * on sitesurvey for the first time when
278 * device is up . Reset usb port for sitesurvey
280 DBG_88E("usb attached..., try to reset usb device\n");
281 usb_reset_device(interface_to_usbdev(usb_intf
));
284 rtw_deinit_intf_priv(dvobj
);
288 usb_put_dev(interface_to_usbdev(usb_intf
));
293 static void chip_by_usb_id(struct adapter
*padapter
,
294 const struct usb_device_id
*pdid
)
296 padapter
->chip_type
= NULL_CHIP_TYPE
;
297 hal_set_hw_type(padapter
);
300 static void usb_intf_start(struct adapter
*padapter
)
302 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("+usb_intf_start\n"));
304 rtw_hal_inirp_init(padapter
);
306 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("-usb_intf_start\n"));
309 static void usb_intf_stop(struct adapter
*padapter
)
311 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("+usb_intf_stop\n"));
313 /* disabel_hw_interrupt */
314 if (!padapter
->bSurpriseRemoved
) {
315 /* device still exists, so driver can do i/o operation */
317 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
,
318 ("SurpriseRemoved == false\n"));
322 rtw_hal_inirp_deinit(padapter
);
325 rtw_write_port_cancel(padapter
);
327 /* todo:cancel other irps */
329 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("-usb_intf_stop\n"));
332 static void rtw_dev_unload(struct adapter
*padapter
)
334 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("+rtw_dev_unload\n"));
337 DBG_88E("===> rtw_dev_unload\n");
338 padapter
->bDriverStopped
= true;
339 if (padapter
->xmitpriv
.ack_tx
)
340 rtw_ack_tx_done(&padapter
->xmitpriv
, RTW_SCTX_DONE_DRV_STOP
);
342 if (padapter
->intf_stop
)
343 padapter
->intf_stop(padapter
);
345 if (!padapter
->pwrctrlpriv
.bInternalAutoSuspend
)
346 rtw_stop_drv_threads(padapter
);
349 if (!padapter
->bSurpriseRemoved
) {
350 rtw_hal_deinit(padapter
);
351 padapter
->bSurpriseRemoved
= true;
354 padapter
->bup
= false;
356 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
,
357 ("r871x_dev_unload():padapter->bup == false\n"));
360 DBG_88E("<=== rtw_dev_unload\n");
362 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("-rtw_dev_unload\n"));
365 static void process_spec_devid(const struct usb_device_id
*pdid
)
370 int num
= sizeof(specific_device_id_tbl
) /
371 sizeof(struct specific_device_id
);
373 for (i
= 0; i
< num
; i
++) {
374 vid
= specific_device_id_tbl
[i
].idVendor
;
375 pid
= specific_device_id_tbl
[i
].idProduct
;
376 flags
= specific_device_id_tbl
[i
].flags
;
378 if ((pdid
->idVendor
== vid
) && (pdid
->idProduct
== pid
) &&
379 (flags
&SPEC_DEV_ID_DISABLE_HT
)) {
381 rtw_cbw40_enable
= 0;
382 rtw_ampdu_enable
= 0;
387 int rtw_hw_suspend(struct adapter
*padapter
)
389 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
390 struct net_device
*pnetdev
= padapter
->pnetdev
;
394 if ((!padapter
->bup
) || (padapter
->bDriverStopped
) ||
395 (padapter
->bSurpriseRemoved
)) {
396 DBG_88E("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
397 padapter
->bup
, padapter
->bDriverStopped
,
398 padapter
->bSurpriseRemoved
);
402 if (padapter
) { /* system suspend */
403 LeaveAllPowerSaveMode(padapter
);
405 DBG_88E("==> rtw_hw_suspend\n");
406 _enter_pwrlock(&pwrpriv
->lock
);
407 pwrpriv
->bips_processing
= true;
410 netif_carrier_off(pnetdev
);
411 rtw_netif_stop_queue(pnetdev
);
415 rtw_disassoc_cmd(padapter
, 500, false);
417 /* s2-2. indicate disconnect to os */
419 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
421 if (check_fwstate(pmlmepriv
, _FW_LINKED
)) {
422 _clr_fwstate_(pmlmepriv
, _FW_LINKED
);
424 rtw_led_control(padapter
, LED_CTL_NO_LINK
);
426 rtw_os_indicate_disconnect(padapter
);
428 /* donnot enqueue cmd */
429 rtw_lps_ctrl_wk_cmd(padapter
, LPS_CTRL_DISCONNECT
, 0);
433 rtw_free_assoc_resources(padapter
, 1);
436 rtw_free_network_queue(padapter
, true);
437 rtw_ips_dev_unload(padapter
);
438 pwrpriv
->rf_pwrstate
= rf_off
;
439 pwrpriv
->bips_processing
= false;
441 _exit_pwrlock(&pwrpriv
->lock
);
449 DBG_88E("%s, failed\n", __func__
);
453 int rtw_hw_resume(struct adapter
*padapter
)
455 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
456 struct net_device
*pnetdev
= padapter
->pnetdev
;
460 if (padapter
) { /* system resume */
461 DBG_88E("==> rtw_hw_resume\n");
462 _enter_pwrlock(&pwrpriv
->lock
);
463 pwrpriv
->bips_processing
= true;
464 rtw_reset_drv_sw(padapter
);
466 if (pm_netdev_open(pnetdev
, false) != 0) {
467 _exit_pwrlock(&pwrpriv
->lock
);
471 netif_device_attach(pnetdev
);
472 netif_carrier_on(pnetdev
);
474 if (!netif_queue_stopped(pnetdev
))
475 netif_start_queue(pnetdev
);
477 netif_wake_queue(pnetdev
);
479 pwrpriv
->bkeepfwalive
= false;
480 pwrpriv
->brfoffbyhw
= false;
482 pwrpriv
->rf_pwrstate
= rf_on
;
483 pwrpriv
->bips_processing
= false;
485 _exit_pwrlock(&pwrpriv
->lock
);
494 DBG_88E("%s, Open net dev failed\n", __func__
);
498 static int rtw_suspend(struct usb_interface
*pusb_intf
, pm_message_t message
)
500 struct dvobj_priv
*dvobj
= usb_get_intfdata(pusb_intf
);
501 struct adapter
*padapter
= dvobj
->if1
;
502 struct net_device
*pnetdev
= padapter
->pnetdev
;
503 struct mlme_priv
*pmlmepriv
= &padapter
->mlmepriv
;
504 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
507 u32 start_time
= rtw_get_current_time();
511 DBG_88E("==> %s (%s:%d)\n", __func__
, current
->comm
, current
->pid
);
513 if ((!padapter
->bup
) || (padapter
->bDriverStopped
) ||
514 (padapter
->bSurpriseRemoved
)) {
515 DBG_88E("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
516 padapter
->bup
, padapter
->bDriverStopped
,
517 padapter
->bSurpriseRemoved
);
521 pwrpriv
->bInSuspend
= true;
522 rtw_cancel_all_timer(padapter
);
523 LeaveAllPowerSaveMode(padapter
);
525 _enter_pwrlock(&pwrpriv
->lock
);
528 netif_carrier_off(pnetdev
);
529 rtw_netif_stop_queue(pnetdev
);
533 rtw_disassoc_cmd(padapter
, 0, false);
535 if (check_fwstate(pmlmepriv
, WIFI_STATION_STATE
) &&
536 check_fwstate(pmlmepriv
, _FW_LINKED
)) {
537 DBG_88E("%s:%d %s(%pM), length:%d assoc_ssid.length:%d\n",
539 pmlmepriv
->cur_network
.network
.Ssid
.Ssid
,
540 pmlmepriv
->cur_network
.network
.MacAddress
,
541 pmlmepriv
->cur_network
.network
.Ssid
.SsidLength
,
542 pmlmepriv
->assoc_ssid
.SsidLength
);
544 pmlmepriv
->to_roaming
= 1;
546 /* s2-2. indicate disconnect to os */
547 rtw_indicate_disconnect(padapter
);
549 rtw_free_assoc_resources(padapter
, 1);
551 rtw_free_network_queue(padapter
, true);
553 rtw_dev_unload(padapter
);
554 _exit_pwrlock(&pwrpriv
->lock
);
556 if (check_fwstate(pmlmepriv
, _FW_UNDER_SURVEY
))
557 rtw_indicate_scan_done(padapter
, 1);
559 if (check_fwstate(pmlmepriv
, _FW_UNDER_LINKING
))
560 rtw_indicate_disconnect(padapter
);
563 DBG_88E("<=== %s return %d.............. in %dms\n", __func__
564 , ret
, rtw_get_passing_time_ms(start_time
));
570 static int rtw_resume(struct usb_interface
*pusb_intf
)
572 struct dvobj_priv
*dvobj
= usb_get_intfdata(pusb_intf
);
573 struct adapter
*padapter
= dvobj
->if1
;
574 struct pwrctrl_priv
*pwrpriv
= &padapter
->pwrctrlpriv
;
577 if (pwrpriv
->bInternalAutoSuspend
)
578 ret
= rtw_resume_process(padapter
);
580 ret
= rtw_resume_process(padapter
);
584 int rtw_resume_process(struct adapter
*padapter
)
586 struct net_device
*pnetdev
;
587 struct pwrctrl_priv
*pwrpriv
= NULL
;
589 u32 start_time
= rtw_get_current_time();
592 DBG_88E("==> %s (%s:%d)\n", __func__
, current
->comm
, current
->pid
);
595 pnetdev
= padapter
->pnetdev
;
596 pwrpriv
= &padapter
->pwrctrlpriv
;
601 _enter_pwrlock(&pwrpriv
->lock
);
602 rtw_reset_drv_sw(padapter
);
604 pwrpriv
->bkeepfwalive
= false;
606 DBG_88E("bkeepfwalive(%x)\n", pwrpriv
->bkeepfwalive
);
607 if (pm_netdev_open(pnetdev
, true) != 0)
610 netif_device_attach(pnetdev
);
611 netif_carrier_on(pnetdev
);
613 _exit_pwrlock(&pwrpriv
->lock
);
615 if (padapter
->pid
[1] != 0) {
616 DBG_88E("pid[1]:%d\n", padapter
->pid
[1]);
617 rtw_signal_process(padapter
->pid
[1], SIGUSR2
);
620 rtw_roaming(padapter
, NULL
);
625 pwrpriv
->bInSuspend
= false;
626 DBG_88E("<=== %s return %d.............. in %dms\n", __func__
,
627 ret
, rtw_get_passing_time_ms(start_time
));
635 * drv_init() - a device potentially for us
637 * notes: drv_init() is called when the bus driver has located
638 * a card for us to support.
639 * We accept the new device by returning 0.
642 static struct adapter
*rtw_usb_if1_init(struct dvobj_priv
*dvobj
,
643 struct usb_interface
*pusb_intf
, const struct usb_device_id
*pdid
)
645 struct adapter
*padapter
= NULL
;
646 struct net_device
*pnetdev
= NULL
;
649 padapter
= (struct adapter
*)rtw_zvmalloc(sizeof(*padapter
));
650 if (padapter
== NULL
)
652 padapter
->dvobj
= dvobj
;
653 dvobj
->if1
= padapter
;
655 padapter
->bDriverStopped
= true;
657 padapter
->hw_init_mutex
= &usb_drv
->hw_init_mutex
;
659 /* step 1-1., decide the chip_type via vid/pid */
660 padapter
->interface_type
= RTW_USB
;
661 chip_by_usb_id(padapter
, pdid
);
663 if (rtw_handle_dualmac(padapter
, 1) != _SUCCESS
)
666 pnetdev
= rtw_init_netdev(padapter
);
669 SET_NETDEV_DEV(pnetdev
, dvobj_to_dev(dvobj
));
670 padapter
= rtw_netdev_priv(pnetdev
);
672 /* step 2. hook HalFunc, allocate HalData */
673 hal_set_hal_ops(padapter
);
675 padapter
->intf_start
= &usb_intf_start
;
676 padapter
->intf_stop
= &usb_intf_stop
;
678 /* step init_io_priv */
679 rtw_init_io_priv(padapter
, usb_set_intf_ops
);
681 /* step read_chip_version */
682 rtw_hal_read_chip_version(padapter
);
684 /* step usb endpoint mapping */
685 rtw_hal_chip_configure(padapter
);
687 /* step read efuse/eeprom data and get mac_addr */
688 rtw_hal_read_chip_info(padapter
);
691 if (rtw_init_drv_sw(padapter
) == _FAIL
) {
692 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
,
693 ("Initialize driver software resource Failed!\n"));
698 if (padapter
->pwrctrlpriv
.bSupportRemoteWakeup
) {
699 dvobj
->pusbdev
->do_remote_wakeup
= 1;
700 pusb_intf
->needs_remote_wakeup
= 1;
701 device_init_wakeup(&pusb_intf
->dev
, 1);
702 DBG_88E("\n padapter->pwrctrlpriv.bSupportRemoteWakeup~~~~~~\n");
703 DBG_88E("\n padapter->pwrctrlpriv.bSupportRemoteWakeup~~~[%d]~~~\n",
704 device_may_wakeup(&pusb_intf
->dev
));
708 /* 2012-07-11 Move here to prevent the 8723AS-VAU BT auto
709 * suspend influence */
710 if (usb_autopm_get_interface(pusb_intf
) < 0)
711 DBG_88E("can't get autopm:\n");
713 /* alloc dev name after read efuse. */
714 rtw_init_netdev_name(pnetdev
, padapter
->registrypriv
.ifname
);
715 rtw_macaddr_cfg(padapter
->eeprompriv
.mac_addr
);
716 #ifdef CONFIG_88EU_P2P
717 rtw_init_wifidirect_addrs(padapter
, padapter
->eeprompriv
.mac_addr
,
718 padapter
->eeprompriv
.mac_addr
);
720 memcpy(pnetdev
->dev_addr
, padapter
->eeprompriv
.mac_addr
, ETH_ALEN
);
721 DBG_88E("MAC Address from pnetdev->dev_addr = %pM\n",
724 /* step 6. Tell the network stack we exist */
725 if (register_netdev(pnetdev
) != 0) {
726 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("register_netdev() failed\n"));
730 DBG_88E("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n"
731 , padapter
->bDriverStopped
732 , padapter
->bSurpriseRemoved
734 , padapter
->hw_init_completed
740 if (status
!= _SUCCESS
&& padapter
->HalData
)
741 kfree(padapter
->HalData
);
743 if (status
!= _SUCCESS
)
744 rtw_handle_dualmac(padapter
, 0);
746 if (status
!= _SUCCESS
) {
748 rtw_free_netdev(pnetdev
);
750 rtw_vmfree((u8
*)padapter
, sizeof(*padapter
));
757 static void rtw_usb_if1_deinit(struct adapter
*if1
)
759 struct net_device
*pnetdev
= if1
->pnetdev
;
760 struct mlme_priv
*pmlmepriv
= &if1
->mlmepriv
;
762 if (check_fwstate(pmlmepriv
, _FW_LINKED
))
763 rtw_disassoc_cmd(if1
, 0, false);
765 #ifdef CONFIG_88EU_AP_MODE
766 free_mlme_ap_info(if1
);
769 if (if1
->DriverState
!= DRIVER_DISAPPEAR
) {
771 /* will call netdev_close() */
772 unregister_netdev(pnetdev
);
773 rtw_proc_remove_one(pnetdev
);
776 rtw_cancel_all_timer(if1
);
779 DBG_88E("+r871xu_dev_remove, hw_init_completed=%d\n",
780 if1
->hw_init_completed
);
781 rtw_handle_dualmac(if1
, 0);
782 rtw_free_drv_sw(if1
);
784 rtw_free_netdev(pnetdev
);
787 static int rtw_drv_init(struct usb_interface
*pusb_intf
, const struct usb_device_id
*pdid
)
789 struct adapter
*if1
= NULL
;
791 struct dvobj_priv
*dvobj
;
793 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("+rtw_drv_init\n"));
796 process_spec_devid(pdid
);
798 /* Initialize dvobj_priv */
799 dvobj
= usb_dvobj_init(pusb_intf
);
801 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
,
802 ("initialize device object priv Failed!\n"));
806 if1
= rtw_usb_if1_init(dvobj
, pusb_intf
, pdid
);
808 DBG_88E("rtw_init_primarystruct adapter Failed!\n");
812 if (ui_pid
[1] != 0) {
813 DBG_88E("ui_pid[1]:%d\n", ui_pid
[1]);
814 rtw_signal_process(ui_pid
[1], SIGUSR2
);
817 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("-871x_drv - drv_init, success!\n"));
821 if (status
!= _SUCCESS
&& if1
)
822 rtw_usb_if1_deinit(if1
);
824 if (status
!= _SUCCESS
)
825 usb_dvobj_deinit(pusb_intf
);
827 return status
== _SUCCESS
? 0 : -ENODEV
;
831 * dev_remove() - our device is being removed
833 /* rmmod module & unplug(SurpriseRemoved) will call r871xu_dev_remove() => how to recognize both */
834 static void rtw_dev_remove(struct usb_interface
*pusb_intf
)
836 struct dvobj_priv
*dvobj
= usb_get_intfdata(pusb_intf
);
837 struct adapter
*padapter
= dvobj
->if1
;
841 DBG_88E("+rtw_dev_remove\n");
842 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("+dev_remove()\n"));
844 if (usb_drv
->drv_registered
)
845 padapter
->bSurpriseRemoved
= true;
847 rtw_pm_set_ips(padapter
, IPS_NONE
);
848 rtw_pm_set_lps(padapter
, PS_MODE_ACTIVE
);
850 LeaveAllPowerSaveMode(padapter
);
852 rtw_usb_if1_deinit(padapter
);
854 usb_dvobj_deinit(pusb_intf
);
856 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("-dev_remove()\n"));
857 DBG_88E("-r871xu_dev_remove, done\n");
863 static int __init
rtw_drv_entry(void)
865 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("+rtw_drv_entry\n"));
867 DBG_88E(DRV_NAME
" driver version=%s\n", DRIVERVERSION
);
868 DBG_88E("build time: %s %s\n", __DATE__
, __TIME__
);
870 rtw_suspend_lock_init();
872 _rtw_mutex_init(&usb_drv
->hw_init_mutex
);
874 usb_drv
->drv_registered
= true;
875 return usb_register(&usb_drv
->usbdrv
);
878 static void __exit
rtw_drv_halt(void)
880 RT_TRACE(_module_hci_intfs_c_
, _drv_err_
, ("+rtw_drv_halt\n"));
881 DBG_88E("+rtw_drv_halt\n");
883 rtw_suspend_lock_uninit();
885 usb_drv
->drv_registered
= false;
886 usb_deregister(&usb_drv
->usbdrv
);
888 _rtw_mutex_free(&usb_drv
->hw_init_mutex
);
889 DBG_88E("-rtw_drv_halt\n");
892 module_init(rtw_drv_entry
);
893 module_exit(rtw_drv_halt
);