drivers/net/wireless/rockchip_wlan/rtl8723au/os_dep/linux/usb_intf.c

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   4  *
   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.
   8  *
   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
  12  * more details.
  13  *
  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
  17  *
  18  *
  19  ******************************************************************************/
  20 #define _HCI_INTF_C_
  21
  22 #include <drv_conf.h>
  23 #include <osdep_service.h>
  24 #include <drv_types.h>
  25 #include <recv_osdep.h>
  26 #include <xmit_osdep.h>
  27 #include <hal_intf.h>
  28 #include <rtw_version.h>
  29 #ifndef CONFIG_USB_HCI
  30
  31 #error "CONFIG_USB_HCI shall be on!\n"
  32
  33 #endif
  34
  35 #include <usb_vendor_req.h>
  36 #include <usb_ops.h>
  37 #include <usb_osintf.h>
  38 #include <usb_hal.h>
  39 #ifdef CONFIG_PLATFORM_RTK_DMP
  40 #include <asm/io.h>
  41 #endif
  42
  43 #if defined (PLATFORM_LINUX) && defined (PLATFORM_WINDOWS)
  44
  45 #error "Shall be Linux or Windows, but not both!\n"
  46
  47 #endif
  48
  49 #ifdef CONFIG_80211N_HT
  50 extern int rtw_ht_enable;
  51 extern int rtw_cbw40_enable;
  52 extern int rtw_ampdu_enable;//for enable tx_ampdu
  53 #endif
  54
  55 #ifdef CONFIG_GLOBAL_UI_PID
  56 int ui_pid[3] = {0, 0, 0};
  57 #endif
  58
  59
  60 extern int pm_netdev_open(struct net_device *pnetdev,u8 bnormal);
  61 static int rtw_suspend(struct usb_interface *intf, pm_message_t message);
  62 static int rtw_resume(struct usb_interface *intf);
  63 int rtw_resume_process(_adapter *padapter);
  64
  65
  66 static int rtw_drv_init(struct usb_interface *pusb_intf,const struct usb_device_id *pdid);
  67 static void rtw_dev_remove(struct usb_interface *pusb_intf);
  68
  69 static void rtw_dev_shutdown(struct device *dev)
  70 {
  71         struct usb_interface *usb_intf = container_of(dev, struct usb_interface, dev);
  72         struct dvobj_priv *dvobj = NULL;
  73         _adapter *adapter = NULL;
  74         int i;
  75
  76         DBG_871X("%s\n", __func__);
  77
  78         if(usb_intf)
  79         {
  80                 dvobj = usb_get_intfdata(usb_intf);
  81                 if (dvobj)
  82                 {
  83                         for (i = 0; i<dvobj->iface_nums; i++)
  84                         {
  85                                 adapter = dvobj->padapters[i];
  86                                 if (adapter)
  87                                 {
  88                                         adapter->bSurpriseRemoved = _TRUE;
  89                                 }
  90                         }
  91
  92                         ATOMIC_SET(&dvobj->continual_io_error, MAX_CONTINUAL_IO_ERR+1);
  93                 }
  94         }
  95 }
  96
  97 #if (LINUX_VERSION_CODE<=KERNEL_VERSION(2,6,23))
  98 /* Some useful macros to use to create struct usb_device_id */
  99  #define USB_DEVICE_ID_MATCH_VENDOR                      0x0001
 100  #define USB_DEVICE_ID_MATCH_PRODUCT                     0x0002
 101  #define USB_DEVICE_ID_MATCH_DEV_LO                      0x0004
 102  #define USB_DEVICE_ID_MATCH_DEV_HI                      0x0008
 103  #define USB_DEVICE_ID_MATCH_DEV_CLASS                   0x0010
 104  #define USB_DEVICE_ID_MATCH_DEV_SUBCLASS                0x0020
 105  #define USB_DEVICE_ID_MATCH_DEV_PROTOCOL                0x0040
 106  #define USB_DEVICE_ID_MATCH_INT_CLASS                   0x0080
 107  #define USB_DEVICE_ID_MATCH_INT_SUBCLASS                0x0100
 108  #define USB_DEVICE_ID_MATCH_INT_PROTOCOL                0x0200
 109  #define USB_DEVICE_ID_MATCH_INT_NUMBER                  0x0400
 110
 111
 112 #define USB_DEVICE_ID_MATCH_INT_INFO \
 113                                  (USB_DEVICE_ID_MATCH_INT_CLASS | \
 114                                  USB_DEVICE_ID_MATCH_INT_SUBCLASS | \
 115                                  USB_DEVICE_ID_MATCH_INT_PROTOCOL)
 116
 117
 118 #define USB_DEVICE_AND_INTERFACE_INFO(vend, prod, cl, sc, pr) \
 119                  .match_flags = USB_DEVICE_ID_MATCH_INT_INFO \
 120                                  | USB_DEVICE_ID_MATCH_DEVICE, \
 121                  .idVendor = (vend), \
 122                  .idProduct = (prod), \
 123                  .bInterfaceClass = (cl), \
 124                  .bInterfaceSubClass = (sc), \
 125                  .bInterfaceProtocol = (pr)
 126
 127  /**
 128   * USB_VENDOR_AND_INTERFACE_INFO - describe a specific usb vendor with a class of usb interfaces
 129   * @vend: the 16 bit USB Vendor ID
 130   * @cl: bInterfaceClass value
 131   * @sc: bInterfaceSubClass value
 132   * @pr: bInterfaceProtocol value
 133   *
 134   * This macro is used to create a struct usb_device_id that matches a
 135   * specific vendor with a specific class of interfaces.
 136   *
 137   * This is especially useful when explicitly matching devices that have
 138   * vendor specific bDeviceClass values, but standards-compliant interfaces.
 139   */
 140 #define USB_VENDOR_AND_INTERFACE_INFO(vend, cl, sc, pr) \
 141                  .match_flags = USB_DEVICE_ID_MATCH_INT_INFO \
 142                                  | USB_DEVICE_ID_MATCH_VENDOR, \
 143                  .idVendor = (vend), \
 144                  .bInterfaceClass = (cl), \
 145                  .bInterfaceSubClass = (sc), \
 146                  .bInterfaceProtocol = (pr)
 147
 148 /* ----------------------------------------------------------------------- */
 149 #endif
 150
 151 #define USB_VENDER_ID_REALTEK           0x0BDA
 152
 153 /* DID_USB_v916_20130116 */
 154 #define RTL8192C_USB_IDS \
 155         /*=== Realtek demoboard ===*/ \
 156         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8191)},/* Default ID */ \
 157         /****** 8188CUS ********/ \
 158         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8176)},/* 8188cu 1*1 dongole */ \
 159         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8170)},/* 8188CE-VAU USB minCard */ \
 160         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817E)},/* 8188CE-VAU USB minCard */ \
 161         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817A)},/* 8188cu Slim Solo */ \
 162         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817B)},/* 8188cu Slim Combo */ \
 163         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817D)},/* 8188RU High-power USB Dongle */ \
 164         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8754)},/* 8188 Combo for BC4 */ \
 165         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817F)},/* 8188RU */ \
 166         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x818A)},/* RTL8188CUS-VL */ \
 167         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x018A)},/* RTL8188CTV */ \
 168         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x17C0)}, /* RTK demoboard - USB-N10E */ \
 169         /****** 8192CUS ********/ \
 170         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8177)},/* 8191cu 1*2 */ \
 171         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8178)},/* 8192cu 2*2 */ \
 172         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x817C)},/* 8192CE-VAU USB minCard */ \
 173         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8191)},/* 8192CU 2*2 */ \
 174         {USB_DEVICE(0x1058, 0x0631)},/* Alpha, 8192CU */ \
 175         /*=== Customer ID ===*/  \
 176         /****** 8188CUS Dongle ********/ \
 177         {USB_DEVICE(0x2019, 0xED17)},/* PCI - Edimax */ \
 178         {USB_DEVICE(0x0DF6, 0x0052)},/* Sitecom - Edimax */ \
 179         {USB_DEVICE(0x7392, 0x7811)},/* Edimax - Edimax */ \
 180         {USB_DEVICE(0x07B8, 0x8189)},/* Abocom - Abocom */ \
 181         {USB_DEVICE(0x0EB0, 0x9071)},/* NO Brand - Etop */ \
 182         {USB_DEVICE(0x06F8, 0xE033)},/* Hercules - Edimax */ \
 183         {USB_DEVICE(0x103C, 0x1629)},/* HP - Lite-On ,8188CUS Slim Combo */ \
 184         {USB_DEVICE(0x2001, 0x3308)},/* D-Link - Alpha */ \
 185         {USB_DEVICE(0x050D, 0x1102)},/* Belkin - Edimax */ \
 186         {USB_DEVICE(0x2019, 0xAB2A)},/* Planex - Abocom */ \
 187         {USB_DEVICE(0x20F4, 0x648B)},/* TRENDnet - Cameo */ \
 188         {USB_DEVICE(0x4855, 0x0090)},/*  - Feixun */ \
 189         {USB_DEVICE(0x13D3, 0x3357)},/*  - AzureWave */ \
 190         {USB_DEVICE(0x0DF6, 0x005C)},/* Sitecom - Edimax */ \
 191         {USB_DEVICE(0x0BDA, 0x5088)},/* Thinkware - CC&C */ \
 192         {USB_DEVICE(0x4856, 0x0091)},/* NetweeN - Feixun */ \
 193         {USB_DEVICE(0x0846, 0x9041)}, /* Netgear - Cameo */ \
 194         {USB_DEVICE(0x2019, 0x4902)},/* Planex - Etop */ \
 195         {USB_DEVICE(0x2019, 0xAB2E)},/* SW-WF02-AD15 -Abocom */ \
 196         {USB_DEVICE(0x2001, 0x330B)}, /* D-LINK - T&W */ \
 197         {USB_DEVICE(0xCDAB, 0x8010)}, /* - - compare */ \
 198         {USB_DEVICE(0x0B05, 0x17BA)}, /* ASUS - Edimax */ \
 199         {USB_DEVICE(0x0BDA, 0x1E1E)}, /* Intel - - */ \
 200         {USB_DEVICE(0x04BB, 0x094c)}, /* I-O DATA - Edimax */ \
 201         /****** 8188CTV ********/ \
 202         {USB_DEVICE(0xCDAB, 0x8011)}, /* - - compare */ \
 203         {USB_DEVICE(0x0BDA, 0x0A8A)}, /* Sony - Foxconn */ \
 204         /****** 8188 RU ********/ \
 205         {USB_DEVICE(0x0BDA, 0x317F)},/* Netcore,Netcore */ \
 206         /****** 8188CE-VAU ********/ \
 207         {USB_DEVICE(0x13D3, 0x3359)},/*  - Azwave */ \
 208         {USB_DEVICE(0x13D3, 0x3358)},/*  - Azwave */ \
 209         /****** 8188CUS Slim Solo********/ \
 210         {USB_DEVICE(0x04F2, 0xAFF7)},/* XAVI - XAVI */ \
 211         {USB_DEVICE(0x04F2, 0xAFF9)},/* XAVI - XAVI */ \
 212         {USB_DEVICE(0x04F2, 0xAFFA)},/* XAVI - XAVI */ \
 213         /****** 8188CUS Slim Combo ********/ \
 214         {USB_DEVICE(0x04F2, 0xAFF8)},/* XAVI - XAVI */ \
 215         {USB_DEVICE(0x04F2, 0xAFFB)},/* XAVI - XAVI */ \
 216         {USB_DEVICE(0x04F2, 0xAFFC)},/* XAVI - XAVI */ \
 217         {USB_DEVICE(0x2019, 0x1201)},/* Planex - Vencer */ \
 218         /****** 8192CUS Dongle ********/ \
 219         {USB_DEVICE(0x2001, 0x3307)},/* D-Link - Cameo */ \
 220         {USB_DEVICE(0x2001, 0x330A)},/* D-Link - Alpha */ \
 221         {USB_DEVICE(0x2001, 0x3309)},/* D-Link - Alpha */ \
 222         {USB_DEVICE(0x0586, 0x341F)},/* Zyxel - Abocom */ \
 223         {USB_DEVICE(0x7392, 0x7822)},/* Edimax - Edimax */ \
 224         {USB_DEVICE(0x2019, 0xAB2B)},/* Planex - Abocom */ \
 225         {USB_DEVICE(0x07B8, 0x8178)},/* Abocom - Abocom */ \
 226         {USB_DEVICE(0x07AA, 0x0056)},/* ATKK - Gemtek */ \
 227         {USB_DEVICE(0x4855, 0x0091)},/*  - Feixun */ \
 228         {USB_DEVICE(0x050D, 0x2102)},/* Belkin - Sercomm */ \
 229         {USB_DEVICE(0x050D, 0x2103)},/* Belkin - Edimax */ \
 230         {USB_DEVICE(0x20F4, 0x624D)},/* TRENDnet */ \
 231         {USB_DEVICE(0x0DF6, 0x0061)},/* Sitecom - Edimax */ \
 232         {USB_DEVICE(0x0B05, 0x17AB)},/* ASUS - Edimax */ \
 233         {USB_DEVICE(0x0846, 0x9021)},/* Netgear - Sercomm */ \
 234         {USB_DEVICE(0x0846, 0xF001)}, /* Netgear - Sercomm */ \
 235         {USB_DEVICE(0x0E66, 0x0019)},/* Hawking,Edimax */ \
 236         {USB_DEVICE(0x0E66, 0x0020)}, /* Hawking  - Edimax */ \
 237         {USB_DEVICE(0x050D, 0x1004)}, /* Belkin - Edimax */ \
 238         {USB_DEVICE(0x0BDA, 0x2E2E)}, /* Intel - - */ \
 239         {USB_DEVICE(0x2357, 0x0100)}, /* TP-Link - TP-Link */ \
 240         {USB_DEVICE(0x06F8, 0xE035)}, /* Hercules - Edimax */ \
 241         {USB_DEVICE(0x04BB, 0x0950)}, /* IO-DATA - Edimax */ \
 242         {USB_DEVICE(0x0DF6, 0x0070)}, /* Sitecom - Edimax */ \
 243         {USB_DEVICE(0x0789, 0x016D)}, /* LOGITEC - Edimax */ \
 244         /****** 8192CE-VAU  ********/ \
 245         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8186)},/* Intel-Xavi( Azwave) */
 246
 247 #define RTL8192D_USB_IDS \
 248         /*=== Realtek demoboard ===*/ \
 249         /****** 8192DU ********/ \
 250         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8193)},/* 8192DU-VC */ \
 251         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8194)},/* 8192DU-VS */ \
 252         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8111)},/* Realtek 5G dongle for WiFi Display */ \
 253         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x0193)},/* 8192DE-VAU */ \
 254         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8171)},/* 8192DU-VC */ \
 255         /*=== Customer ID ===*/ \
 256         /****** 8192DU-VC ********/ \
 257         {USB_DEVICE(0x2019, 0xAB2C)},/* PCI - Abocm */ \
 258         {USB_DEVICE(0x2019, 0x4903)},/* PCI - ETOP */ \
 259         {USB_DEVICE(0x2019, 0x4904)},/* PCI - ETOP */ \
 260         {USB_DEVICE(0x07B8, 0x8193)},/* Abocom - Abocom */ \
 261         /****** 8192DU-VS ********/ \
 262         {USB_DEVICE(0x20F4, 0x664B)}, /* TRENDnet - Cameo */ \
 263         {USB_DEVICE(0x04DD, 0x954F)},  /* Sharp */ \
 264         {USB_DEVICE(0x04DD, 0x96A6)},  /* Sharp */ \
 265         {USB_DEVICE(0x050D, 0x110A)}, /* Belkin - Edimax */ \
 266         {USB_DEVICE(0x050D, 0x1105)}, /* Belkin - Edimax */ \
 267         {USB_DEVICE(0x050D, 0x120A)}, /* Belkin - Edimax */ \
 268         {USB_DEVICE(0x1668, 0x8102)}, /*  -  */ \
 269         {USB_DEVICE(0x0BDA, 0xE194)}, /*  - Edimax */ \
 270         /****** 8192DU-WiFi Display Dongle ********/ \
 271         {USB_DEVICE(0x2019, 0xAB2D)},/* Planex - Abocom ,5G dongle for WiFi Display */
 272
 273 #define RTL8723A_USB_IDS \
 274         {USB_DEVICE_AND_INTERFACE_INFO(USB_VENDER_ID_REALTEK, 0x8724,0xff,0xff,0xff)}, /* 8723AU 1*1 */ \
 275         {USB_DEVICE_AND_INTERFACE_INFO(USB_VENDER_ID_REALTEK, 0x1724,0xff,0xff,0xff)}, /* 8723AU 1*1 */ \
 276         {USB_DEVICE_AND_INTERFACE_INFO(USB_VENDER_ID_REALTEK, 0x0724,0xff,0xff,0xff)}, /* 8723AU 1*1 */
 277
 278 #define RTL8188E_USB_IDS \
 279         /*=== Realtek demoboard ===*/ \
 280         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x8179)}, /* 8188EUS */ \
 281         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0x0179)}, /* 8188ETV */ \
 282         /*=== Customer ID ===*/ \
 283         /****** 8188EUS ********/ \
 284         {USB_DEVICE(0x07B8, 0x8179)}, /* Abocom - Abocom */
 285
 286 #ifndef CONFIG_RTL8192C
 287         #undef RTL8192C_USB_IDS
 288         #define RTL8192C_USB_IDS
 289 #endif
 290 #ifndef CONFIG_RTL8192D
 291         #undef RTL8192D_USB_IDS
 292         #define RTL8192D_USB_IDS
 293 #endif
 294 #ifndef CONFIG_RTL8723A
 295         #undef RTL8723A_USB_IDS
 296         #define RTL8723A_USB_IDS
 297 #endif
 298 #ifndef CONFIG_RTL8188E
 299         #undef RTL8188E_USB_IDS
 300         #define RTL8188E_USB_IDS
 301 #endif
 302
 303 static struct usb_device_id rtw_usb_id_tbl[] ={
 304         RTL8192C_USB_IDS
 305         RTL8192D_USB_IDS
 306         RTL8723A_USB_IDS
 307         RTL8188E_USB_IDS
 308         {}      /* Terminating entry */
 309 };
 310 MODULE_DEVICE_TABLE(usb, rtw_usb_id_tbl);
 311
 312 int const rtw_usb_id_len = sizeof(rtw_usb_id_tbl) / sizeof(struct usb_device_id);
 313
 314 static struct specific_device_id specific_device_id_tbl[] = {
 315         {.idVendor=USB_VENDER_ID_REALTEK, .idProduct=0x8177, .flags=SPEC_DEV_ID_DISABLE_HT},//8188cu 1*1 dongole, (b/g mode only)
 316         {.idVendor=USB_VENDER_ID_REALTEK, .idProduct=0x817E, .flags=SPEC_DEV_ID_DISABLE_HT},//8188CE-VAU USB minCard (b/g mode only)
 317         {.idVendor=0x0b05, .idProduct=0x1791, .flags=SPEC_DEV_ID_DISABLE_HT},
 318         {.idVendor=0x13D3, .idProduct=0x3311, .flags=SPEC_DEV_ID_DISABLE_HT},
 319         {.idVendor=0x13D3, .idProduct=0x3359, .flags=SPEC_DEV_ID_DISABLE_HT},//Russian customer -Azwave (8188CE-VAU  g mode)
 320 #ifdef RTK_DMP_PLATFORM
 321         {.idVendor=USB_VENDER_ID_REALTEK, .idProduct=0x8111, .flags=SPEC_DEV_ID_ASSIGN_IFNAME}, // Realtek 5G dongle for WiFi Display
 322         {.idVendor=0x2019, .idProduct=0xAB2D, .flags=SPEC_DEV_ID_ASSIGN_IFNAME}, // PCI-Abocom 5G dongle for WiFi Display
 323 #endif /* RTK_DMP_PLATFORM */
 324         {}
 325 };
 326
 327 struct rtw_usb_drv {
 328         struct usb_driver usbdrv;
 329         int drv_registered;
 330 };
 331
 332 #ifdef CONFIG_RTL8192C
 333 static struct usb_device_id rtl8192c_usb_id_tbl[] ={
 334         RTL8192C_USB_IDS
 335         {}      /* Terminating entry */
 336 };
 337
 338 struct rtw_usb_drv rtl8192c_usb_drv = {
 339         .usbdrv.name = (char*)"rtl8192cu",
 340         .usbdrv.probe = rtw_drv_init,
 341         .usbdrv.disconnect = rtw_dev_remove,
 342         .usbdrv.id_table = rtl8192c_usb_id_tbl,
 343         .usbdrv.suspend =  rtw_suspend,
 344         .usbdrv.resume = rtw_resume,
 345         #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22))
 346         .usbdrv.reset_resume   = rtw_resume,
 347         #endif
 348         #ifdef CONFIG_AUTOSUSPEND
 349         .usbdrv.supports_autosuspend = 1,
 350         #endif
 351
 352         #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19))
 353         .usbdrv.drvwrap.driver.shutdown = rtw_dev_shutdown,
 354         #else
 355         .usbdrv.driver.shutdown = rtw_dev_shutdown,
 356         #endif
 357 };
 358
 359 static struct rtw_usb_drv *usb_drv = &rtl8192c_usb_drv;
 360 #endif /* CONFIG_RTL8192C */
 361
 362 #ifdef CONFIG_RTL8192D
 363 static struct usb_device_id rtl8192d_usb_id_tbl[] ={
 364         RTL8192D_USB_IDS
 365         {}      /* Terminating entry */
 366 };
 367
 368 struct rtw_usb_drv rtl8192d_usb_drv = {
 369         .usbdrv.name = (char*)"rtl8192du",
 370         .usbdrv.probe = rtw_drv_init,
 371         .usbdrv.disconnect = rtw_dev_remove,
 372         .usbdrv.id_table = rtl8192d_usb_id_tbl,
 373         .usbdrv.suspend =  rtw_suspend,
 374         .usbdrv.resume = rtw_resume,
 375         #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22))
 376         .usbdrv.reset_resume   = rtw_resume,
 377         #endif
 378         #ifdef CONFIG_AUTOSUSPEND
 379         .usbdrv.supports_autosuspend = 1,
 380         #endif
 381
 382         #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19))
 383         .usbdrv.drvwrap.driver.shutdown = rtw_dev_shutdown,
 384         #else
 385         .usbdrv.driver.shutdown = rtw_dev_shutdown,
 386         #endif
 387 };
 388 static struct rtw_usb_drv *usb_drv = &rtl8192d_usb_drv;
 389 #endif /* CONFIG_RTL8192D */
 390
 391 #ifdef CONFIG_RTL8723A
 392 static struct usb_device_id rtl8723a_usb_id_tbl[] ={
 393         RTL8723A_USB_IDS
 394         {}      /* Terminating entry */
 395 };
 396
 397 struct rtw_usb_drv rtl8723a_usb_drv = {
 398         .usbdrv.name = (char*)"rtl8723au",
 399         .usbdrv.probe = rtw_drv_init,
 400         .usbdrv.disconnect = rtw_dev_remove,
 401         .usbdrv.id_table = rtl8723a_usb_id_tbl,
 402         .usbdrv.suspend =  rtw_suspend,
 403         .usbdrv.resume = rtw_resume,
 404         #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22))
 405         .usbdrv.reset_resume   = rtw_resume,
 406         #endif
 407         #ifdef CONFIG_AUTOSUSPEND
 408         .usbdrv.supports_autosuspend = 1,
 409         #endif
 410
 411         #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19))
 412         .usbdrv.drvwrap.driver.shutdown = rtw_dev_shutdown,
 413         #else
 414         .usbdrv.driver.shutdown = rtw_dev_shutdown,
 415         #endif
 416 };
 417
 418 static struct rtw_usb_drv *usb_drv = &rtl8723a_usb_drv;
 419 #endif /* CONFIG_RTL8723A */
 420
 421 #ifdef CONFIG_RTL8188E
 422 static struct usb_device_id rtl8188e_usb_id_tbl[] ={
 423         RTL8188E_USB_IDS
 424         {}      /* Terminating entry */
 425 };
 426
 427 struct rtw_usb_drv rtl8188e_usb_drv = {
 428         .usbdrv.name = (char*)"rtl8188eu",
 429         .usbdrv.probe = rtw_drv_init,
 430         .usbdrv.disconnect = rtw_dev_remove,
 431         .usbdrv.id_table = rtl8188e_usb_id_tbl,
 432         .usbdrv.suspend =  rtw_suspend,
 433         .usbdrv.resume = rtw_resume,
 434         #if (LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22))
 435         .usbdrv.reset_resume   = rtw_resume,
 436         #endif
 437         #ifdef CONFIG_AUTOSUSPEND
 438         .usbdrv.supports_autosuspend = 1,
 439         #endif
 440
 441         #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 19))
 442         .usbdrv.drvwrap.driver.shutdown = rtw_dev_shutdown,
 443         #else
 444         .usbdrv.driver.shutdown = rtw_dev_shutdown,
 445         #endif
 446 };
 447
 448 static struct rtw_usb_drv *usb_drv = &rtl8188e_usb_drv;
 449 #endif /* CONFIG_RTL8188E */
 450
 451 static inline int RT_usb_endpoint_dir_in(const struct usb_endpoint_descriptor *epd)
 452 {
 453         return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN);
 454 }
 455
 456 static inline int RT_usb_endpoint_dir_out(const struct usb_endpoint_descriptor *epd)
 457 {
 458         return ((epd->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);
 459 }
 460
 461 static inline int RT_usb_endpoint_xfer_int(const struct usb_endpoint_descriptor *epd)
 462 {
 463         return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT);
 464 }
 465
 466 static inline int RT_usb_endpoint_xfer_bulk(const struct usb_endpoint_descriptor *epd)
 467 {
 468         return ((epd->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK);
 469 }
 470
 471 static inline int RT_usb_endpoint_is_bulk_in(const struct usb_endpoint_descriptor *epd)
 472 {
 473         return (RT_usb_endpoint_xfer_bulk(epd) && RT_usb_endpoint_dir_in(epd));
 474 }
 475
 476 static inline int RT_usb_endpoint_is_bulk_out(const struct usb_endpoint_descriptor *epd)
 477 {
 478         return (RT_usb_endpoint_xfer_bulk(epd) && RT_usb_endpoint_dir_out(epd));
 479 }
 480
 481 static inline int RT_usb_endpoint_is_int_in(const struct usb_endpoint_descriptor *epd)
 482 {
 483         return (RT_usb_endpoint_xfer_int(epd) && RT_usb_endpoint_dir_in(epd));
 484 }
 485
 486 static inline int RT_usb_endpoint_num(const struct usb_endpoint_descriptor *epd)
 487 {
 488         return epd->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
 489 }
 490
 491 static u8 rtw_init_intf_priv(struct dvobj_priv *dvobj)
 492 {
 493         u8 rst = _SUCCESS;
 494
 495         #ifdef CONFIG_USB_VENDOR_REQ_MUTEX
 496         _rtw_mutex_init(&dvobj->usb_vendor_req_mutex);
 497         #endif
 498
 499
 500         #ifdef CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC
 501         dvobj->usb_alloc_vendor_req_buf = rtw_zmalloc(MAX_USB_IO_CTL_SIZE);
 502         if (dvobj->usb_alloc_vendor_req_buf == NULL) {
 503                 DBG_871X("alloc usb_vendor_req_buf failed... /n");
 504                 rst = _FAIL;
 505                 goto exit;
 506         }
 507         dvobj->usb_vendor_req_buf  =
 508                 (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(dvobj->usb_alloc_vendor_req_buf ), ALIGNMENT_UNIT);
 509 exit:
 510         #endif
 511
 512         return rst;
 513
 514 }
 515
 516 static u8 rtw_deinit_intf_priv(struct dvobj_priv *dvobj)
 517 {
 518         u8 rst = _SUCCESS;
 519
 520         #ifdef CONFIG_USB_VENDOR_REQ_BUFFER_PREALLOC
 521         if(dvobj->usb_vendor_req_buf)
 522                 rtw_mfree(dvobj->usb_alloc_vendor_req_buf, MAX_USB_IO_CTL_SIZE);
 523         #endif
 524
 525         #ifdef CONFIG_USB_VENDOR_REQ_MUTEX
 526         _rtw_mutex_free(&dvobj->usb_vendor_req_mutex);
 527         #endif
 528
 529         return rst;
 530 }
 531
 532 static struct dvobj_priv *usb_dvobj_init(struct usb_interface *usb_intf)
 533 {
 534         int     i;
 535         u8      val8;
 536         int     status = _FAIL;
 537         struct dvobj_priv *pdvobjpriv;
 538         struct usb_device_descriptor    *pdev_desc;
 539         struct usb_host_config                  *phost_conf;
 540         struct usb_config_descriptor            *pconf_desc;
 541         struct usb_host_interface               *phost_iface;
 542         struct usb_interface_descriptor *piface_desc;
 543         struct usb_host_endpoint                *phost_endp;
 544         struct usb_endpoint_descriptor  *pendp_desc;
 545         struct usb_device                               *pusbd;
 546
 547 _func_enter_;
 548
 549         if ((pdvobjpriv = (struct dvobj_priv*)rtw_zmalloc(sizeof(*pdvobjpriv))) == NULL) {
 550                 goto exit;
 551         }
 552
 553         _rtw_mutex_init(&pdvobjpriv->hw_init_mutex);
 554         _rtw_mutex_init(&pdvobjpriv->h2c_fwcmd_mutex);
 555         _rtw_mutex_init(&pdvobjpriv->setch_mutex);
 556         _rtw_mutex_init(&pdvobjpriv->setbw_mutex);
 557         pdvobjpriv->processing_dev_remove = _FALSE;
 558
 559         _rtw_spinlock_init(&pdvobjpriv->lock);
 560         pdvobjpriv->macid[1] = _TRUE; //macid=1 for bc/mc stainfo
 561         _rtw_spinlock_init(&pdvobjpriv->cam_ctl.lock);
 562
 563         pdvobjpriv->pusbintf = usb_intf ;
 564         pusbd = pdvobjpriv->pusbdev = interface_to_usbdev(usb_intf);
 565         usb_set_intfdata(usb_intf, pdvobjpriv);
 566
 567         pdvobjpriv->RtNumInPipes = 0;
 568         pdvobjpriv->RtNumOutPipes = 0;
 569
 570         //padapter->EepromAddressSize = 6;
 571         //pdvobjpriv->nr_endpoint = 6;
 572
 573         pdev_desc = &pusbd->descriptor;
 574
 575 #if 0
 576         DBG_871X("\n8712_usb_device_descriptor:\n");
 577         DBG_871X("bLength=%x\n", pdev_desc->bLength);
 578         DBG_871X("bDescriptorType=%x\n", pdev_desc->bDescriptorType);
 579         DBG_871X("bcdUSB=%x\n", pdev_desc->bcdUSB);
 580         DBG_871X("bDeviceClass=%x\n", pdev_desc->bDeviceClass);
 581         DBG_871X("bDeviceSubClass=%x\n", pdev_desc->bDeviceSubClass);
 582         DBG_871X("bDeviceProtocol=%x\n", pdev_desc->bDeviceProtocol);
 583         DBG_871X("bMaxPacketSize0=%x\n", pdev_desc->bMaxPacketSize0);
 584         DBG_871X("idVendor=%x\n", pdev_desc->idVendor);
 585         DBG_871X("idProduct=%x\n", pdev_desc->idProduct);
 586         DBG_871X("bcdDevice=%x\n", pdev_desc->bcdDevice);
 587         DBG_871X("iManufacturer=%x\n", pdev_desc->iManufacturer);
 588         DBG_871X("iProduct=%x\n", pdev_desc->iProduct);
 589         DBG_871X("iSerialNumber=%x\n", pdev_desc->iSerialNumber);
 590         DBG_871X("bNumConfigurations=%x\n", pdev_desc->bNumConfigurations);
 591 #endif
 592
 593         phost_conf = pusbd->actconfig;
 594         pconf_desc = &phost_conf->desc;
 595
 596 #if 0
 597         DBG_871X("\n8712_usb_configuration_descriptor:\n");
 598         DBG_871X("bLength=%x\n", pconf_desc->bLength);
 599         DBG_871X("bDescriptorType=%x\n", pconf_desc->bDescriptorType);
 600         DBG_871X("wTotalLength=%x\n", pconf_desc->wTotalLength);
 601         DBG_871X("bNumInterfaces=%x\n", pconf_desc->bNumInterfaces);
 602         DBG_871X("bConfigurationValue=%x\n", pconf_desc->bConfigurationValue);
 603         DBG_871X("iConfiguration=%x\n", pconf_desc->iConfiguration);
 604         DBG_871X("bmAttributes=%x\n", pconf_desc->bmAttributes);
 605         DBG_871X("bMaxPower=%x\n", pconf_desc->bMaxPower);
 606 #endif
 607
 608         //DBG_871X("\n/****** num of altsetting = (%d) ******/\n", pusb_interface->num_altsetting);
 609
 610         phost_iface = &usb_intf->altsetting[0];
 611         piface_desc = &phost_iface->desc;
 612
 613 #if 0
 614         DBG_871X("\n8712_usb_interface_descriptor:\n");
 615         DBG_871X("bLength=%x\n", piface_desc->bLength);
 616         DBG_871X("bDescriptorType=%x\n", piface_desc->bDescriptorType);
 617         DBG_871X("bInterfaceNumber=%x\n", piface_desc->bInterfaceNumber);
 618         DBG_871X("bAlternateSetting=%x\n", piface_desc->bAlternateSetting);
 619         DBG_871X("bNumEndpoints=%x\n", piface_desc->bNumEndpoints);
 620         DBG_871X("bInterfaceClass=%x\n", piface_desc->bInterfaceClass);
 621         DBG_871X("bInterfaceSubClass=%x\n", piface_desc->bInterfaceSubClass);
 622         DBG_871X("bInterfaceProtocol=%x\n", piface_desc->bInterfaceProtocol);
 623         DBG_871X("iInterface=%x\n", piface_desc->iInterface);
 624 #endif
 625
 626         pdvobjpriv->NumInterfaces = pconf_desc->bNumInterfaces;
 627         pdvobjpriv->InterfaceNumber = piface_desc->bInterfaceNumber;
 628         pdvobjpriv->nr_endpoint = piface_desc->bNumEndpoints;
 629
 630         //DBG_871X("\ndump usb_endpoint_descriptor:\n");
 631
 632         for (i = 0; i < pdvobjpriv->nr_endpoint; i++)
 633         {
 634                 phost_endp = phost_iface->endpoint + i;
 635                 if (phost_endp)
 636                 {
 637                         pendp_desc = &phost_endp->desc;
 638
 639                         DBG_871X("\nusb_endpoint_descriptor(%d):\n", i);
 640                         DBG_871X("bLength=%x\n",pendp_desc->bLength);
 641                         DBG_871X("bDescriptorType=%x\n",pendp_desc->bDescriptorType);
 642                         DBG_871X("bEndpointAddress=%x\n",pendp_desc->bEndpointAddress);
 643                         //DBG_871X("bmAttributes=%x\n",pendp_desc->bmAttributes);
 644                         DBG_871X("wMaxPacketSize=%d\n",le16_to_cpu(pendp_desc->wMaxPacketSize));
 645                         DBG_871X("bInterval=%x\n",pendp_desc->bInterval);
 646                         //DBG_871X("bRefresh=%x\n",pendp_desc->bRefresh);
 647                         //DBG_871X("bSynchAddress=%x\n",pendp_desc->bSynchAddress);
 648
 649                         if (RT_usb_endpoint_is_bulk_in(pendp_desc))
 650                         {
 651                                 DBG_871X("RT_usb_endpoint_is_bulk_in = %x\n", RT_usb_endpoint_num(pendp_desc));
 652                                 pdvobjpriv->RtInPipe[pdvobjpriv->RtNumInPipes] = RT_usb_endpoint_num(pendp_desc);
 653                                 pdvobjpriv->RtNumInPipes++;
 654                         }
 655                         else if (RT_usb_endpoint_is_int_in(pendp_desc))
 656                         {
 657                                 DBG_871X("RT_usb_endpoint_is_int_in = %x, Interval = %x\n", RT_usb_endpoint_num(pendp_desc),pendp_desc->bInterval);
 658                                 pdvobjpriv->RtInPipe[pdvobjpriv->RtNumInPipes] = RT_usb_endpoint_num(pendp_desc);
 659                                 pdvobjpriv->RtNumInPipes++;
 660                         }
 661                         else if (RT_usb_endpoint_is_bulk_out(pendp_desc))
 662                         {
 663                                 DBG_871X("RT_usb_endpoint_is_bulk_out = %x\n", RT_usb_endpoint_num(pendp_desc));
 664                                 pdvobjpriv->RtOutPipe[pdvobjpriv->RtNumOutPipes] = RT_usb_endpoint_num(pendp_desc);
 665                                 pdvobjpriv->RtNumOutPipes++;
 666                         }
 667                         pdvobjpriv->ep_num[i] = RT_usb_endpoint_num(pendp_desc);
 668                 }
 669         }
 670
 671         DBG_871X("nr_endpoint=%d, in_num=%d, out_num=%d\n\n", pdvobjpriv->nr_endpoint, pdvobjpriv->RtNumInPipes, pdvobjpriv->RtNumOutPipes);
 672
 673         if (pusbd->speed == USB_SPEED_HIGH) {
 674                 pdvobjpriv->ishighspeed = _TRUE;
 675                 DBG_871X("USB_SPEED_HIGH\n");
 676         } else {
 677                 pdvobjpriv->ishighspeed = _FALSE;
 678                 DBG_871X("NON USB_SPEED_HIGH\n");
 679         }
 680
 681         if (rtw_init_intf_priv(pdvobjpriv) == _FAIL) {
 682                 RT_TRACE(_module_os_intfs_c_,_drv_err_,("\n Can't INIT rtw_init_intf_priv\n"));
 683                 goto free_dvobj;
 684         }
 685
 686         //.3 misc
 687         _rtw_init_sema(&(pdvobjpriv->usb_suspend_sema), 0);
 688         rtw_reset_continual_io_error(pdvobjpriv);
 689
 690         usb_get_dev(pusbd);
 691
 692         status = _SUCCESS;
 693
 694 free_dvobj:
 695         if (status != _SUCCESS && pdvobjpriv) {
 696                 usb_set_intfdata(usb_intf, NULL);
 697                 _rtw_spinlock_free(&pdvobjpriv->lock);
 698                 _rtw_mutex_free(&pdvobjpriv->hw_init_mutex);
 699                 _rtw_mutex_free(&pdvobjpriv->h2c_fwcmd_mutex);
 700                 _rtw_mutex_free(&pdvobjpriv->setch_mutex);
 701                 _rtw_mutex_free(&pdvobjpriv->setbw_mutex);
 702                 _rtw_spinlock_free(&pdvobjpriv->cam_ctl.lock);
 703                 rtw_mfree((u8*)pdvobjpriv, sizeof(*pdvobjpriv));
 704                 pdvobjpriv = NULL;
 705         }
 706 exit:
 707 _func_exit_;
 708         return pdvobjpriv;
 709 }
 710
 711 static void usb_dvobj_deinit(struct usb_interface *usb_intf)
 712 {
 713         struct dvobj_priv *dvobj = usb_get_intfdata(usb_intf);
 714
 715 _func_enter_;
 716
 717         usb_set_intfdata(usb_intf, NULL);
 718         if (dvobj) {
 719                 //Modify condition for 92DU DMDP 2010.11.18, by Thomas
 720                 if ((dvobj->NumInterfaces != 2 && dvobj->NumInterfaces != 3)
 721                         || (dvobj->InterfaceNumber == 1)) {
 722                         if (interface_to_usbdev(usb_intf)->state != USB_STATE_NOTATTACHED) {
 723                                 //If we didn't unplug usb dongle and remove/insert modlue, driver fails on sitesurvey for the first time when device is up .
 724                                 //Reset usb port for sitesurvey fail issue. 2009.8.13, by Thomas
 725                                 DBG_871X("usb attached..., try to reset usb device\n");
 726                                 usb_reset_device(interface_to_usbdev(usb_intf));
 727                         }
 728                 }
 729                 rtw_deinit_intf_priv(dvobj);
 730                 _rtw_spinlock_free(&dvobj->lock);
 731                 _rtw_mutex_free(&dvobj->hw_init_mutex);
 732                 _rtw_mutex_free(&dvobj->h2c_fwcmd_mutex);
 733                 _rtw_mutex_free(&dvobj->setch_mutex);
 734                 _rtw_mutex_free(&dvobj->setbw_mutex);
 735                 _rtw_spinlock_free(&dvobj->cam_ctl.lock);
 736                 rtw_mfree((u8*)dvobj, sizeof(*dvobj));
 737         }
 738
 739         //DBG_871X("%s %d\n", __func__, ATOMIC_READ(&usb_intf->dev.kobj.kref.refcount));
 740         usb_put_dev(interface_to_usbdev(usb_intf));
 741
 742 _func_exit_;
 743 }
 744
 745 static void decide_chip_type_by_usb_device_id(_adapter *padapter, const struct usb_device_id *pdid)
 746 {
 747         padapter->chip_type = NULL_CHIP_TYPE;
 748         hal_set_hw_type(padapter);
 749 }
 750
 751 static void usb_intf_start(_adapter *padapter)
 752 {
 753
 754         RT_TRACE(_module_hci_intfs_c_,_drv_err_,("+usb_intf_start\n"));
 755
 756         rtw_hal_inirp_init(padapter);
 757
 758         RT_TRACE(_module_hci_intfs_c_,_drv_err_,("-usb_intf_start\n"));
 759
 760 }
 761
 762 static void usb_intf_stop(_adapter *padapter)
 763 {
 764
 765         RT_TRACE(_module_hci_intfs_c_,_drv_err_,("+usb_intf_stop\n"));
 766
 767         //disabel_hw_interrupt
 768         if(padapter->bSurpriseRemoved == _FALSE)
 769         {
 770                 //device still exists, so driver can do i/o operation
 771                 //TODO:
 772                 RT_TRACE(_module_hci_intfs_c_,_drv_err_,("SurpriseRemoved==_FALSE\n"));
 773         }
 774
 775         //cancel in irp
 776         rtw_hal_inirp_deinit(padapter);
 777
 778         //cancel out irp
 779         rtw_write_port_cancel(padapter);
 780
 781         //todo:cancel other irps
 782
 783         RT_TRACE(_module_hci_intfs_c_,_drv_err_,("-usb_intf_stop\n"));
 784
 785 }
 786
 787 void rtw_dev_unload(_adapter *padapter)
 788 {
 789         struct net_device *pnetdev= (struct net_device*)padapter->pnetdev;
 790         u8 val8;
 791         RT_TRACE(_module_hci_intfs_c_,_drv_err_,("+rtw_dev_unload\n"));
 792
 793         if(padapter->bup == _TRUE)
 794         {
 795                 DBG_871X("===> rtw_dev_unload\n");
 796
 797                 padapter->bDriverStopped = _TRUE;
 798                 #ifdef CONFIG_XMIT_ACK
 799                 if (padapter->xmitpriv.ack_tx)
 800                         rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
 801                 #endif
 802
 803                 //s3.
 804                 if(padapter->intf_stop)
 805                 {
 806                         padapter->intf_stop(padapter);
 807                 }
 808
 809                 //s4.
 810                 if(!adapter_to_pwrctl(padapter)->bInternalAutoSuspend )
 811                 rtw_stop_drv_threads(padapter);
 812
 813
 814                 //s5.
 815                 if(padapter->bSurpriseRemoved == _FALSE)
 816                 {
 817                         //DBG_871X("r871x_dev_unload()->rtl871x_hal_deinit()\n");
 818 #ifdef CONFIG_WOWLAN
 819                         if((adapter_to_pwrctl(padapter)->bSupportRemoteWakeup==_TRUE)&&(adapter_to_pwrctl(padapter)->wowlan_mode==_TRUE)){
 820                                 DBG_871X("%s bSupportWakeOnWlan==_TRUE  do not run rtw_hal_deinit()\n",__FUNCTION__);
 821                         }
 822                         else
 823 #endif //CONFIG_WOWLAN
 824                         {
 825                                 rtw_hal_deinit(padapter);
 826                         }
 827                         padapter->bSurpriseRemoved = _TRUE;
 828                 }
 829
 830                 padapter->bup = _FALSE;
 831 #ifdef CONFIG_WOWLAN
 832                 padapter->hw_init_completed=_FALSE;
 833 #endif //CONFIG_WOWLAN
 834         }
 835         else
 836         {
 837                 RT_TRACE(_module_hci_intfs_c_,_drv_err_,("r871x_dev_unload():padapter->bup == _FALSE\n" ));
 838         }
 839
 840         DBG_871X("<=== rtw_dev_unload\n");
 841
 842         RT_TRACE(_module_hci_intfs_c_,_drv_err_,("-rtw_dev_unload\n"));
 843
 844 }
 845
 846 static void process_spec_devid(const struct usb_device_id *pdid)
 847 {
 848         u16 vid, pid;
 849         u32 flags;
 850         int i;
 851         int num = sizeof(specific_device_id_tbl)/sizeof(struct specific_device_id);
 852
 853         for(i=0; i<num; i++)
 854         {
 855                 vid = specific_device_id_tbl[i].idVendor;
 856                 pid = specific_device_id_tbl[i].idProduct;
 857                 flags = specific_device_id_tbl[i].flags;
 858
 859 #ifdef CONFIG_80211N_HT
 860                 if((pdid->idVendor==vid) && (pdid->idProduct==pid) && (flags&SPEC_DEV_ID_DISABLE_HT))
 861                 {
 862                          rtw_ht_enable = 0;
 863                          rtw_cbw40_enable = 0;
 864                          rtw_ampdu_enable = 0;
 865                 }
 866 #endif
 867
 868 #ifdef RTK_DMP_PLATFORM
 869                 // Change the ifname to wlan10 when PC side WFD dongle plugin on DMP platform.
 870                 // It is used to distinguish between normal and PC-side wifi dongle/module.
 871                 if((pdid->idVendor==vid) && (pdid->idProduct==pid) && (flags&SPEC_DEV_ID_ASSIGN_IFNAME))
 872                 {
 873                         extern char* ifname;
 874                         strncpy(ifname, "wlan10", 6);
 875                         //DBG_871X("%s()-%d: ifname=%s, vid=%04X, pid=%04X\n", __FUNCTION__, __LINE__, ifname, vid, pid);
 876                 }
 877 #endif /* RTK_DMP_PLATFORM */
 878
 879         }
 880 }
 881
 882 #ifdef SUPPORT_HW_RFOFF_DETECTED
 883 int rtw_hw_suspend(_adapter *padapter )
 884 {
 885         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 886         struct usb_interface *pusb_intf = adapter_to_dvobj(padapter)->pusbintf;
 887         struct net_device *pnetdev = padapter->pnetdev;
 888
 889         _func_enter_;
 890
 891         if((!padapter->bup) || (padapter->bDriverStopped)||(padapter->bSurpriseRemoved))
 892         {
 893                 DBG_871X("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
 894                         padapter->bup, padapter->bDriverStopped,padapter->bSurpriseRemoved);
 895                 goto error_exit;
 896         }
 897
 898         if(padapter)//system suspend
 899         {
 900                 LeaveAllPowerSaveMode(padapter);
 901
 902                 DBG_871X("==> rtw_hw_suspend\n");
 903                 _enter_pwrlock(&pwrpriv->lock);
 904                 pwrpriv->bips_processing = _TRUE;
 905                 //padapter->net_closed = _TRUE;
 906                 //s1.
 907                 if(pnetdev)
 908                 {
 909                         netif_carrier_off(pnetdev);
 910                         rtw_netif_stop_queue(pnetdev);
 911                 }
 912
 913                 //s2.
 914                 rtw_disassoc_cmd(padapter, 500, _FALSE);
 915
 916                 //s2-2.  indicate disconnect to os
 917                 //rtw_indicate_disconnect(padapter);
 918                 {
 919                         struct  mlme_priv *pmlmepriv = &padapter->mlmepriv;
 920
 921                         if(check_fwstate(pmlmepriv, _FW_LINKED))
 922                         {
 923                                 _clr_fwstate_(pmlmepriv, _FW_LINKED);
 924
 925                                 rtw_led_control(padapter, LED_CTL_NO_LINK);
 926
 927                                 rtw_os_indicate_disconnect(padapter);
 928
 929                                 #ifdef CONFIG_LPS
 930                                 //donnot enqueue cmd
 931                                 rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_DISCONNECT, 0);
 932                                 #endif
 933                         }
 934
 935                 }
 936                 //s2-3.
 937                 rtw_free_assoc_resources(padapter, 1);
 938
 939                 //s2-4.
 940                 rtw_free_network_queue(padapter,_TRUE);
 941                 #ifdef CONFIG_IPS
 942                 rtw_ips_dev_unload(padapter);
 943                 #endif
 944                 pwrpriv->rf_pwrstate = rf_off;
 945                 pwrpriv->bips_processing = _FALSE;
 946
 947                 _exit_pwrlock(&pwrpriv->lock);
 948         }
 949         else
 950                 goto error_exit;
 951
 952         _func_exit_;
 953         return 0;
 954
 955 error_exit:
 956         DBG_871X("%s, failed \n",__FUNCTION__);
 957         return (-1);
 958
 959 }
 960
 961 int rtw_hw_resume(_adapter *padapter)
 962 {
 963         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
 964         struct usb_interface *pusb_intf = adapter_to_dvobj(padapter)->pusbintf;
 965         struct net_device *pnetdev = padapter->pnetdev;
 966
 967         _func_enter_;
 968
 969         if(padapter)//system resume
 970         {
 971                 DBG_871X("==> rtw_hw_resume\n");
 972                 _enter_pwrlock(&pwrpriv->lock);
 973                 pwrpriv->bips_processing = _TRUE;
 974                 rtw_reset_drv_sw(padapter);
 975
 976                 if(pm_netdev_open(pnetdev,_FALSE) != 0)
 977                 {
 978                         _exit_pwrlock(&pwrpriv->lock);
 979                         goto error_exit;
 980                 }
 981
 982                 netif_device_attach(pnetdev);
 983                 netif_carrier_on(pnetdev);
 984
 985                 if(!rtw_netif_queue_stopped(pnetdev))
 986                         rtw_netif_start_queue(pnetdev);
 987                 else
 988                         rtw_netif_wake_queue(pnetdev);
 989
 990                 pwrpriv->bkeepfwalive = _FALSE;
 991                 pwrpriv->brfoffbyhw = _FALSE;
 992
 993                 pwrpriv->rf_pwrstate = rf_on;
 994                 pwrpriv->bips_processing = _FALSE;
 995
 996                 _exit_pwrlock(&pwrpriv->lock);
 997         }
 998         else
 999         {
1000                 goto error_exit;
1001         }
1002
1003         _func_exit_;
1004
1005         return 0;
1006 error_exit:
1007         DBG_871X("%s, Open net dev failed \n",__FUNCTION__);
1008         return (-1);
1009 }
1010 #endif
1011
1012 #if 1
1013 #ifdef CONFIG_WOWLAN
1014 static void rtw_suspend_wow(_adapter *padapter)
1015 {
1016         struct net_device *pnetdev = padapter->pnetdev;
1017         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1018         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1019         struct wifidirect_info* pwdinfo = &padapter->wdinfo;
1020         struct wowlan_ioctl_param poidparam;
1021
1022         if (check_fwstate(pmlmepriv, _FW_LINKED))
1023                 pwrpriv->wowlan_mode = _TRUE;
1024         else
1025                 pwrpriv->wowlan_mode = _FALSE;
1026
1027         rtw_cancel_all_timer(padapter);
1028
1029         //padapter->net_closed = _TRUE;
1030         //s1.
1031         if(pnetdev)
1032         {
1033                 netif_carrier_off(pnetdev);
1034                 rtw_netif_stop_queue(pnetdev);
1035         }
1036
1037         if(pwrpriv->bSupportRemoteWakeup==_TRUE && pwrpriv->wowlan_mode==_TRUE){
1038                 //set H2C command
1039                 poidparam.subcode=WOWLAN_ENABLE;
1040                 padapter->HalFunc.SetHwRegHandler(padapter,HW_VAR_WOWLAN,(u8 *)&poidparam);
1041         }
1042         else
1043         {
1044                 //s2.
1045                 rtw_disassoc_cmd(padapter, 0, _FALSE);
1046         }
1047
1048
1049 #ifdef CONFIG_LAYER2_ROAMING_RESUME
1050         if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)&& rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE))
1051         {
1052                 //DBG_871X("%s:%d assoc_ssid:%s\n", __FUNCTION__, __LINE__, pmlmepriv->assoc_ssid.Ssid);
1053                 DBG_871X("%s:%d %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n",__FUNCTION__, __LINE__,
1054                                 pmlmepriv->cur_network.network.Ssid.Ssid,
1055                                 MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
1056                                 pmlmepriv->cur_network.network.Ssid.SsidLength,
1057                                 pmlmepriv->assoc_ssid.SsidLength);
1058
1059                 rtw_set_roaming(padapter, 1);
1060         }
1061 #endif
1062         //s2-2.  indicate disconnect to os
1063         rtw_indicate_disconnect(padapter);
1064         //s2-3.
1065         rtw_free_assoc_resources(padapter, 1);
1066 #ifdef CONFIG_AUTOSUSPEND
1067         if(!pwrpriv->bInternalAutoSuspend )
1068 #endif
1069         //s2-4.
1070         rtw_free_network_queue(padapter, _TRUE);
1071
1072         rtw_dev_unload(padapter);
1073
1074         if(check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
1075                 rtw_indicate_scan_done(padapter, 1);
1076
1077         //if(check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
1078         //      rtw_indicate_disconnect(padapter);
1079
1080 }
1081 #endif
1082 static int rtw_suspend(struct usb_interface *pusb_intf, pm_message_t message)
1083 {
1084         struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
1085         _adapter *padapter = dvobj->if1;
1086         struct net_device *pnetdev = padapter->pnetdev;
1087         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1088         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
1089         struct usb_device *usb_dev = interface_to_usbdev(pusb_intf);
1090
1091
1092         int ret = 0;
1093         u32 start_time = rtw_get_current_time();
1094
1095         _func_enter_;
1096
1097         DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);
1098
1099
1100 #ifdef CONFIG_IOL_READ_EFUSE_MAP
1101         if(!padapter->bup){
1102                 u8 bMacPwrCtrlOn = _FALSE;
1103                 rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
1104                 if(bMacPwrCtrlOn)
1105                         rtw_hal_power_off(padapter);
1106         }
1107 #endif
1108
1109         if((!padapter->bup) || (padapter->bDriverStopped)||(padapter->bSurpriseRemoved))
1110         {
1111                 DBG_871X("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
1112                         padapter->bup, padapter->bDriverStopped,padapter->bSurpriseRemoved);
1113                 goto exit;
1114         }
1115
1116         if(pwrpriv->bInternalAutoSuspend )
1117         {
1118         #ifdef CONFIG_AUTOSUSPEND
1119         #ifdef SUPPORT_HW_RFOFF_DETECTED
1120                 // The FW command register update must after MAC and FW init ready.
1121                 if((padapter->bFWReady) && (pwrpriv->bHWPwrPindetect ) && (padapter->registrypriv.usbss_enable ))
1122                 {
1123                         u8 bOpen = _TRUE;
1124                         rtw_interface_ps_func(padapter,HAL_USB_SELECT_SUSPEND,&bOpen);
1125                         //rtl8192c_set_FwSelectSuspend_cmd(padapter,_TRUE ,500);//note fw to support hw power down ping detect
1126                 }
1127         #endif
1128         #endif
1129         }
1130
1131         pwrpriv->bInSuspend = _TRUE;
1132
1133         LeaveAllPowerSaveMode(padapter);
1134
1135         rtw_stop_cmd_thread(padapter);
1136
1137         _enter_pwrlock(&pwrpriv->lock);
1138 #ifdef CONFIG_WOWLAN
1139         rtw_suspend_wow(padapter);
1140 #else
1141         rtw_suspend_common(padapter);
1142 #endif
1143
1144 #ifdef CONFIG_AUTOSUSPEND
1145         pwrpriv->rf_pwrstate = rf_off;
1146         pwrpriv->bips_processing = _FALSE;
1147 #endif
1148         _exit_pwrlock(&pwrpriv->lock);
1149
1150
1151 exit:
1152         DBG_871X("<===  %s return %d.............. in %dms\n", __FUNCTION__
1153                 , ret, rtw_get_passing_time_ms(start_time));
1154
1155         _func_exit_;
1156         return ret;
1157 }
1158 #else
1159 static int rtw_suspend(struct usb_interface *pusb_intf, pm_message_t message)
1160 {
1161         struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
1162         _adapter *padapter = dvobj->if1;
1163         struct net_device *pnetdev = padapter->pnetdev;
1164         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1165         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
1166         struct usb_device *usb_dev = interface_to_usbdev(pusb_intf);
1167 #ifdef CONFIG_WOWLAN
1168         struct wowlan_ioctl_param poidparam;
1169 #endif // CONFIG_WOWLAN
1170
1171         int ret = 0;
1172         u32 start_time = rtw_get_current_time();
1173
1174         _func_enter_;
1175
1176         DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);
1177
1178 #ifdef CONFIG_WOWLAN
1179         if (check_fwstate(pmlmepriv, _FW_LINKED))
1180                 pwrpriv->wowlan_mode = _TRUE;
1181         else
1182                 pwrpriv->wowlan_mode = _FALSE;
1183 #endif
1184
1185         if((!padapter->bup) || (padapter->bDriverStopped)||(padapter->bSurpriseRemoved))
1186         {
1187                 DBG_871X("padapter->bup=%d bDriverStopped=%d bSurpriseRemoved = %d\n",
1188                         padapter->bup, padapter->bDriverStopped,padapter->bSurpriseRemoved);
1189                 goto exit;
1190         }
1191
1192         if(pwrpriv->bInternalAutoSuspend )
1193         {
1194         #ifdef CONFIG_AUTOSUSPEND
1195         #ifdef SUPPORT_HW_RFOFF_DETECTED
1196                 // The FW command register update must after MAC and FW init ready.
1197                 if((padapter->bFWReady) && (pwrpriv->bHWPwrPindetect ) && (padapter->registrypriv.usbss_enable ))
1198                 {
1199                         u8 bOpen = _TRUE;
1200                         rtw_interface_ps_func(padapter,HAL_USB_SELECT_SUSPEND,&bOpen);
1201                         //rtl8192c_set_FwSelectSuspend_cmd(padapter,_TRUE ,500);//note fw to support hw power down ping detect
1202                 }
1203         #endif
1204         #endif
1205         }
1206         pwrpriv->bInSuspend = _TRUE;
1207         rtw_cancel_all_timer(padapter);
1208         LeaveAllPowerSaveMode(padapter);
1209
1210         rtw_stop_cmd_thread(padapter);
1211
1212         _enter_pwrlock(&pwrpriv->lock);
1213         //padapter->net_closed = _TRUE;
1214         //s1.
1215         if(pnetdev)
1216         {
1217                 netif_carrier_off(pnetdev);
1218                 rtw_netif_stop_queue(pnetdev);
1219         }
1220
1221 #ifdef CONFIG_WOWLAN
1222         if(pwrpriv->bSupportRemoteWakeup==_TRUE && pwrpriv->wowlan_mode==_TRUE){
1223                 //set H2C command
1224                 poidparam.subcode=WOWLAN_ENABLE;
1225                 padapter->HalFunc.SetHwRegHandler(padapter,HW_VAR_WOWLAN,(u8 *)&poidparam);
1226         }
1227         else
1228 #else
1229         {
1230         //s2.
1231         rtw_disassoc_cmd(padapter, 0, _FALSE);
1232         }
1233 #endif //CONFIG_WOWLAN
1234
1235 #ifdef CONFIG_LAYER2_ROAMING_RESUME
1236         if(check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED) )
1237         {
1238                 //DBG_871X("%s:%d assoc_ssid:%s\n", __FUNCTION__, __LINE__, pmlmepriv->assoc_ssid.Ssid);
1239                 DBG_871X("%s:%d %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n",__FUNCTION__, __LINE__,
1240                                 pmlmepriv->cur_network.network.Ssid.Ssid,
1241                                 MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
1242                                 pmlmepriv->cur_network.network.Ssid.SsidLength,
1243                                 pmlmepriv->assoc_ssid.SsidLength);
1244
1245                 rtw_set_roaming(padapter, 1);
1246         }
1247 #endif
1248         //s2-2.  indicate disconnect to os
1249         rtw_indicate_disconnect(padapter);
1250         //s2-3.
1251         rtw_free_assoc_resources(padapter, 1);
1252 #ifdef CONFIG_AUTOSUSPEND
1253         if(!pwrpriv->bInternalAutoSuspend )
1254 #endif
1255         //s2-4.
1256         rtw_free_network_queue(padapter, _TRUE);
1257
1258         rtw_dev_unload(padapter);
1259 #ifdef CONFIG_AUTOSUSPEND
1260         pwrpriv->rf_pwrstate = rf_off;
1261         pwrpriv->bips_processing = _FALSE;
1262 #endif
1263         _exit_pwrlock(&pwrpriv->lock);
1264
1265         if(check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
1266                 rtw_indicate_scan_done(padapter, 1);
1267
1268         if(check_fwstate(pmlmepriv, _FW_UNDER_LINKING))
1269                 rtw_indicate_disconnect(padapter);
1270
1271 exit:
1272         DBG_871X("<===  %s return %d.............. in %dms\n", __FUNCTION__
1273                 , ret, rtw_get_passing_time_ms(start_time));
1274
1275         _func_exit_;
1276         return ret;
1277 }
1278
1279 #endif
1280 static int rtw_resume(struct usb_interface *pusb_intf)
1281 {
1282         struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
1283         _adapter *padapter = dvobj->if1;
1284         struct net_device *pnetdev = padapter->pnetdev;
1285         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
1286          int ret = 0;
1287
1288         if(pwrpriv->bInternalAutoSuspend ){
1289                 ret = rtw_resume_process(padapter);
1290         } else {
1291 #ifdef CONFIG_RESUME_IN_WORKQUEUE
1292                 rtw_resume_in_workqueue(pwrpriv);
1293 #else
1294                 if (rtw_is_earlysuspend_registered(pwrpriv)
1295                         #ifdef CONFIG_WOWLAN
1296                         && !pwrpriv->wowlan_mode
1297                         #endif /* CONFIG_WOWLAN */
1298                 ) {
1299                         /* jeff: bypass resume here, do in late_resume */
1300                         rtw_set_do_late_resume(pwrpriv, _TRUE);
1301                 } else {
1302                         ret = rtw_resume_process(padapter);
1303                 }
1304 #endif /* CONFIG_RESUME_IN_WORKQUEUE */
1305         }
1306
1307         return ret;
1308
1309 }
1310
1311 int rtw_resume_process(_adapter *padapter)
1312 {
1313         struct net_device *pnetdev;
1314         struct pwrctrl_priv *pwrpriv;
1315         int ret = -1;
1316         u32 start_time = rtw_get_current_time();
1317 #ifdef CONFIG_BT_COEXIST
1318         u8 pm_cnt;
1319 #endif  //#ifdef CONFIG_BT_COEXIST
1320         _func_enter_;
1321
1322         DBG_871X("==> %s (%s:%d)\n",__FUNCTION__, current->comm, current->pid);
1323
1324         if(padapter) {
1325                 pnetdev= padapter->pnetdev;
1326                 pwrpriv = adapter_to_pwrctl(padapter);
1327         } else {
1328                 goto exit;
1329         }
1330
1331         _enter_pwrlock(&pwrpriv->lock);
1332 #ifdef CONFIG_BT_COEXIST
1333 #ifdef CONFIG_AUTOSUSPEND
1334         #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,32))
1335         DBG_871X("%s...pm_usage_cnt(%d)  pwrpriv->bAutoResume=%x.  ....\n",__func__,atomic_read(&(adapter_to_dvobj(padapter)->pusbintf->pm_usage_cnt)),pwrpriv->bAutoResume);
1336         pm_cnt=atomic_read(&(adapter_to_dvobj(padapter)->pusbintf->pm_usage_cnt));
1337         #else
1338         DBG_871X("...pm_usage_cnt(%d).....\n", adapter_to_dvobj(padapter)->pusbintf->pm_usage_cnt);
1339         pm_cnt = adapter_to_dvobj(padapter)->pusbintf->pm_usage_cnt;
1340         #endif
1341
1342         DBG_871X("pwrpriv->bAutoResume (%x)\n",pwrpriv->bAutoResume );
1343         if( _TRUE == pwrpriv->bAutoResume ){
1344                 pwrpriv->bInternalAutoSuspend = _FALSE;
1345                 pwrpriv->bAutoResume=_FALSE;
1346                 DBG_871X("pwrpriv->bAutoResume (%x)  pwrpriv->bInternalAutoSuspend(%x)\n",pwrpriv->bAutoResume,pwrpriv->bInternalAutoSuspend );
1347
1348         }
1349 #endif //#ifdef CONFIG_AUTOSUSPEND
1350 #endif //#ifdef CONFIG_BT_COEXIST
1351
1352
1353         if(rtw_resume_common(padapter)!= 0) {
1354                 DBG_871X("%s rtw_resume_common failed\n",__FUNCTION__);
1355                 _exit_pwrlock(&pwrpriv->lock);
1356                 goto exit;
1357         }
1358
1359 #ifdef CONFIG_AUTOSUSPEND
1360         if(pwrpriv->bInternalAutoSuspend )
1361         {
1362                 #ifdef CONFIG_AUTOSUSPEND
1363                 #ifdef SUPPORT_HW_RFOFF_DETECTED
1364                         // The FW command register update must after MAC and FW init ready.
1365                 if((padapter->bFWReady) && (pwrpriv->bHWPwrPindetect) && (padapter->registrypriv.usbss_enable ))
1366                 {
1367                         //rtl8192c_set_FwSelectSuspend_cmd(padapter,_FALSE ,500);//note fw to support hw power down ping detect
1368                         u8 bOpen = _FALSE;
1369                         rtw_interface_ps_func(padapter,HAL_USB_SELECT_SUSPEND,&bOpen);
1370                 }
1371                 #endif
1372                 #endif
1373 #ifdef CONFIG_BT_COEXIST
1374                 DBG_871X("pwrpriv->bAutoResume (%x)\n",pwrpriv->bAutoResume );
1375                 if( _TRUE == pwrpriv->bAutoResume ){
1376                         pwrpriv->bInternalAutoSuspend = _FALSE;
1377                         pwrpriv->bAutoResume=_FALSE;
1378                         DBG_871X("pwrpriv->bAutoResume (%x)  pwrpriv->bInternalAutoSuspend(%x)\n",pwrpriv->bAutoResume,pwrpriv->bInternalAutoSuspend );
1379                 }
1380
1381 #else   //#ifdef CONFIG_BT_COEXIST
1382                 pwrpriv->bInternalAutoSuspend = _FALSE;
1383 #endif  //#ifdef CONFIG_BT_COEXIST
1384                 pwrpriv->brfoffbyhw = _FALSE;
1385         }
1386 #endif
1387         _exit_pwrlock(&pwrpriv->lock);
1388
1389         if( padapter->pid[1]!=0) {
1390                 DBG_871X("pid[1]:%d\n",padapter->pid[1]);
1391                 rtw_signal_process(padapter->pid[1], SIGUSR2);
1392         }
1393
1394         ret = 0;
1395 exit:
1396         #ifdef CONFIG_RESUME_IN_WORKQUEUE
1397         rtw_unlock_suspend();
1398         #endif //CONFIG_RESUME_IN_WORKQUEUE
1399
1400         pwrpriv->bInSuspend = _FALSE;
1401         DBG_871X("<===  %s return %d.............. in %dms\n", __FUNCTION__
1402                 , ret, rtw_get_passing_time_ms(start_time));
1403
1404         _func_exit_;
1405
1406         return ret;
1407 }
1408
1409 #ifdef CONFIG_AUTOSUSPEND
1410 void autosuspend_enter(_adapter* padapter)
1411 {
1412         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1413         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1414
1415         DBG_871X("==>autosuspend_enter...........\n");
1416
1417         pwrpriv->bInternalAutoSuspend = _TRUE;
1418         pwrpriv->bips_processing = _TRUE;
1419
1420         if(rf_off == pwrpriv->change_rfpwrstate )
1421         {
1422 #ifndef CONFIG_BT_COEXIST
1423                 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
1424                 usb_enable_autosuspend(dvobj->pusbdev);
1425                 #else
1426                 dvobj->pusbdev->autosuspend_disabled = 0;//autosuspend disabled by the user
1427                 #endif
1428
1429                 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,33))
1430                         usb_autopm_put_interface(dvobj->pusbintf);
1431                 #elif (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,20))
1432                         usb_autopm_enable(dvobj->pusbintf);
1433                 #else
1434                         usb_autosuspend_device(dvobj->pusbdev, 1);
1435                 #endif
1436 #else   //#ifndef       CONFIG_BT_COEXIST
1437                 if(1==pwrpriv->autopm_cnt){
1438                 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
1439                 usb_enable_autosuspend(dvobj->pusbdev);
1440                 #else
1441                 dvobj->pusbdev->autosuspend_disabled = 0;//autosuspend disabled by the user
1442                 #endif
1443
1444                 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,33))
1445                         usb_autopm_put_interface(dvobj->pusbintf);
1446                 #elif (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,20))
1447                         usb_autopm_enable(dvobj->pusbintf);
1448                 #else
1449                         usb_autosuspend_device(dvobj->pusbdev, 1);
1450                 #endif
1451                         pwrpriv->autopm_cnt --;
1452                 }
1453                 else
1454                 DBG_871X("0!=pwrpriv->autopm_cnt[%d]   didn't usb_autopm_put_interface\n", pwrpriv->autopm_cnt);
1455
1456 #endif  //#ifndef       CONFIG_BT_COEXIST
1457         }
1458         #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,32))
1459         DBG_871X("...pm_usage_cnt(%d).....\n", atomic_read(&(dvobj->pusbintf->pm_usage_cnt)));
1460         #else
1461         DBG_871X("...pm_usage_cnt(%d).....\n", dvobj->pusbintf->pm_usage_cnt);
1462         #endif
1463
1464 }
1465 int autoresume_enter(_adapter* padapter)
1466 {
1467         int result = _SUCCESS;
1468         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1469         struct security_priv* psecuritypriv=&(padapter->securitypriv);
1470         struct mlme_ext_priv    *pmlmeext = &padapter->mlmeextpriv;
1471         struct mlme_ext_info    *pmlmeinfo = &(pmlmeext->mlmext_info);
1472         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
1473
1474         DBG_871X("====> autoresume_enter \n");
1475
1476         if(rf_off == pwrpriv->rf_pwrstate )
1477         {
1478                 pwrpriv->ps_flag = _FALSE;
1479 #ifndef CONFIG_BT_COEXIST
1480                 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,33))
1481                         if (usb_autopm_get_interface(dvobj->pusbintf) < 0)
1482                         {
1483                                 DBG_871X( "can't get autopm: %d\n", result);
1484                                 result = _FAIL;
1485                                 goto error_exit;
1486                         }
1487                 #elif (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,20))
1488                         usb_autopm_disable(dvobj->pusbintf);
1489                 #else
1490                         usb_autoresume_device(dvobj->pusbdev, 1);
1491                 #endif
1492
1493                 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,32))
1494                 DBG_871X("...pm_usage_cnt(%d).....\n", atomic_read(&(dvobj->pusbintf->pm_usage_cnt)));
1495                 #else
1496                 DBG_871X("...pm_usage_cnt(%d).....\n", dvobj->pusbintf->pm_usage_cnt);
1497                 #endif
1498 #else   //#ifndef       CONFIG_BT_COEXIST
1499                 pwrpriv->bAutoResume=_TRUE;
1500                 if(0==pwrpriv->autopm_cnt){
1501                 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,33))
1502                         if (usb_autopm_get_interface(dvobj->pusbintf) < 0)
1503                         {
1504                                 DBG_871X( "can't get autopm: %d\n", result);
1505                                 result = _FAIL;
1506                                 goto error_exit;
1507                         }
1508                 #elif (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,20))
1509                         usb_autopm_disable(dvobj->pusbintf);
1510                 #else
1511                         usb_autoresume_device(dvobj->pusbdev, 1);
1512                 #endif
1513                 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,32))
1514                         DBG_871X("...pm_usage_cnt(%d).....\n", atomic_read(&(dvobj->pusbintf->pm_usage_cnt)));
1515                 #else
1516                         DBG_871X("...pm_usage_cnt(%d).....\n", dvobj->pusbintf->pm_usage_cnt);
1517                 #endif
1518                         pwrpriv->autopm_cnt++;
1519                 }
1520                 else
1521                         DBG_871X("0!=pwrpriv->autopm_cnt[%d]   didn't usb_autopm_get_interface\n",pwrpriv->autopm_cnt);
1522 #endif //#ifndef        CONFIG_BT_COEXIST
1523         }
1524         DBG_871X("<==== autoresume_enter \n");
1525 error_exit:
1526
1527         return result;
1528 }
1529 #endif
1530
1531 #ifdef CONFIG_PLATFORM_RTD2880B
1532 extern void rtd2885_wlan_netlink_sendMsg(char *action_string, char *name);
1533 #endif
1534
1535 #ifdef CONFIG_PLATFORM_ARM_SUNxI
1536 #include <mach/sys_config.h>
1537 extern int sw_usb_disable_hcd(__u32 usbc_no);
1538 extern int sw_usb_enable_hcd(__u32 usbc_no);
1539 static int usb_wifi_host = 2;
1540 #endif
1541
1542 #ifdef CONFIG_PLATFORM_ARM_SUN6I
1543 #include <mach/sys_config.h>
1544 extern int sw_usb_disable_hcd(__u32 usbc_no);
1545 extern int sw_usb_enable_hcd(__u32 usbc_no);
1546 extern void wifi_pm_power(int on);
1547 static script_item_u item;
1548 #endif
1549
1550 /*
1551  * drv_init() - a device potentially for us
1552  *
1553  * notes: drv_init() is called when the bus driver has located a card for us to support.
1554  *        We accept the new device by returning 0.
1555 */
1556
1557 _adapter  *rtw_sw_export = NULL;
1558
1559 _adapter *rtw_usb_if1_init(struct dvobj_priv *dvobj,
1560         struct usb_interface *pusb_intf, const struct usb_device_id *pdid)
1561 {
1562         _adapter *padapter = NULL;
1563         struct net_device *pnetdev = NULL;
1564         int status = _FAIL;
1565
1566         if ((padapter = (_adapter *)rtw_zvmalloc(sizeof(*padapter))) == NULL) {
1567                 goto exit;
1568         }
1569         padapter->dvobj = dvobj;
1570         dvobj->if1 = padapter;
1571
1572         padapter->bDriverStopped=_TRUE;
1573
1574         dvobj->padapters[dvobj->iface_nums++] = padapter;
1575         padapter->iface_id = IFACE_ID0;
1576
1577 #if defined(CONFIG_CONCURRENT_MODE) || defined(CONFIG_DUALMAC_CONCURRENT)
1578         //set adapter_type/iface type for primary padapter
1579         padapter->isprimary = _TRUE;
1580         padapter->adapter_type = PRIMARY_ADAPTER;
1581         #ifndef CONFIG_HWPORT_SWAP
1582         padapter->iface_type = IFACE_PORT0;
1583         #else
1584         padapter->iface_type = IFACE_PORT1;
1585         #endif
1586 #endif
1587
1588         #ifndef RTW_DVOBJ_CHIP_HW_TYPE
1589         //step 1-1., decide the chip_type via vid/pid
1590         padapter->interface_type = RTW_USB;
1591         decide_chip_type_by_usb_device_id(padapter, pdid);
1592         #endif
1593
1594         if (rtw_handle_dualmac(padapter, 1) != _SUCCESS)
1595                 goto free_adapter;
1596
1597         if((pnetdev = rtw_init_netdev(padapter)) == NULL) {
1598                 goto handle_dualmac;
1599         }
1600         SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj));
1601         padapter = rtw_netdev_priv(pnetdev);
1602
1603 #ifdef CONFIG_IOCTL_CFG80211
1604         if(rtw_wdev_alloc(padapter, dvobj_to_dev(dvobj)) != 0) {
1605                 goto handle_dualmac;
1606         }
1607 #endif
1608
1609
1610         //step 2. hook HalFunc, allocate HalData
1611         hal_set_hal_ops(padapter);
1612
1613         padapter->intf_start=&usb_intf_start;
1614         padapter->intf_stop=&usb_intf_stop;
1615
1616         //step init_io_priv
1617         rtw_init_io_priv(padapter, usb_set_intf_ops);
1618
1619         //step read_chip_version
1620         rtw_hal_read_chip_version(padapter);
1621
1622         //step usb endpoint mapping
1623         rtw_hal_chip_configure(padapter);
1624
1625         //step read efuse/eeprom data and get mac_addr
1626         rtw_hal_read_chip_info(padapter);
1627
1628         //step 5.
1629         if(rtw_init_drv_sw(padapter) ==_FAIL) {
1630                 RT_TRACE(_module_hci_intfs_c_,_drv_err_,("Initialize driver software resource Failed!\n"));
1631                 goto free_hal_data;
1632         }
1633
1634 #ifdef CONFIG_PM
1635 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18))
1636         if(adapter_to_pwrctl(padapter)->bSupportRemoteWakeup)
1637         {
1638                 dvobj->pusbdev->do_remote_wakeup=1;
1639                 pusb_intf->needs_remote_wakeup = 1;
1640                 device_init_wakeup(&pusb_intf->dev, 1);
1641                 DBG_871X("\n  pwrctrlpriv.bSupportRemoteWakeup~~~~~~\n");
1642                 DBG_871X("\n  pwrctrlpriv.bSupportRemoteWakeup~~~[%d]~~~\n",device_may_wakeup(&pusb_intf->dev));
1643         }
1644 #endif
1645 #endif
1646
1647 #ifdef CONFIG_AUTOSUSPEND
1648         if( padapter->registrypriv.power_mgnt != PS_MODE_ACTIVE )
1649         {
1650                 if(padapter->registrypriv.usbss_enable ){       /* autosuspend (2s delay) */
1651                         #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,38))
1652                         dvobj->pusbdev->dev.power.autosuspend_delay = 0 * HZ;//15 * HZ; idle-delay time
1653                         #else
1654                         dvobj->pusbdev->autosuspend_delay = 0 * HZ;//15 * HZ; idle-delay time
1655                         #endif
1656
1657                         #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,35))
1658                         usb_enable_autosuspend(dvobj->pusbdev);
1659                         #elif  (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,22) && LINUX_VERSION_CODE<=KERNEL_VERSION(2,6,34))
1660                         padapter->bDisableAutosuspend = dvobj->pusbdev->autosuspend_disabled ;
1661                         dvobj->pusbdev->autosuspend_disabled = 0;//autosuspend disabled by the user
1662                         #endif
1663
1664                         //usb_autopm_get_interface(adapter_to_dvobj(padapter)->pusbintf );//init pm_usage_cnt ,let it start from 1
1665
1666                         #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,32))
1667                         DBG_871X("%s...pm_usage_cnt(%d).....\n",__FUNCTION__,atomic_read(&(dvobj->pusbintf ->pm_usage_cnt)));
1668                         #else
1669                         DBG_871X("%s...pm_usage_cnt(%d).....\n",__FUNCTION__,dvobj->pusbintf ->pm_usage_cnt);
1670                         #endif
1671                 }
1672         }
1673 #endif
1674         //2012-07-11 Move here to prevent the 8723AS-VAU BT auto suspend influence
1675         #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,33))
1676                         if (usb_autopm_get_interface(pusb_intf) < 0)
1677                                 {
1678                                         DBG_871X( "can't get autopm: \n");
1679                                 }
1680         #endif
1681 #ifdef  CONFIG_BT_COEXIST
1682         adapter_to_pwrctl(padapter)->autopm_cnt=1;
1683 #endif
1684
1685         // set mac addr
1686         rtw_macaddr_cfg(padapter->eeprompriv.mac_addr);
1687         rtw_init_wifidirect_addrs(padapter, padapter->eeprompriv.mac_addr, padapter->eeprompriv.mac_addr);
1688
1689         DBG_871X("bDriverStopped:%d, bSurpriseRemoved:%d, bup:%d, hw_init_completed:%d\n"
1690                 , padapter->bDriverStopped
1691                 , padapter->bSurpriseRemoved
1692                 , padapter->bup
1693                 , padapter->hw_init_completed
1694         );
1695
1696         status = _SUCCESS;
1697
1698 free_hal_data:
1699         if(status != _SUCCESS && padapter->HalData)
1700                 rtw_mfree(padapter->HalData, sizeof(*(padapter->HalData)));
1701 free_wdev:
1702         if(status != _SUCCESS) {
1703                 #ifdef CONFIG_IOCTL_CFG80211
1704                 rtw_wdev_unregister(padapter->rtw_wdev);
1705                 rtw_wdev_free(padapter->rtw_wdev);
1706                 #endif
1707         }
1708 handle_dualmac:
1709         if (status != _SUCCESS)
1710                 rtw_handle_dualmac(padapter, 0);
1711 free_adapter:
1712         if (status != _SUCCESS) {
1713                 if (pnetdev)
1714                         rtw_free_netdev(pnetdev);
1715                 else if (padapter)
1716                         rtw_vmfree((u8*)padapter, sizeof(*padapter));
1717                 padapter = NULL;
1718         }
1719 exit:
1720         return padapter;
1721 }
1722
1723 static void rtw_usb_if1_deinit(_adapter *if1)
1724 {
1725         struct net_device *pnetdev = if1->pnetdev;
1726         struct mlme_priv *pmlmepriv= &if1->mlmepriv;
1727         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(if1);
1728
1729         if(check_fwstate(pmlmepriv, _FW_LINKED))
1730                 rtw_disassoc_cmd(if1, 0, _FALSE);
1731
1732
1733 #ifdef CONFIG_AP_MODE
1734         free_mlme_ap_info(if1);
1735         #ifdef CONFIG_HOSTAPD_MLME
1736         hostapd_mode_unload(if1);
1737         #endif
1738 #endif
1739
1740         rtw_cancel_all_timer(if1);
1741
1742 #ifdef CONFIG_WOWLAN
1743         pwrctl->wowlan_mode=_FALSE;
1744 #endif //CONFIG_WOWLAN
1745
1746         rtw_dev_unload(if1);
1747
1748         DBG_871X("+r871xu_dev_remove, hw_init_completed=%d\n", if1->hw_init_completed);
1749
1750         rtw_handle_dualmac(if1, 0);
1751
1752 #ifdef CONFIG_IOCTL_CFG80211
1753         if(if1->rtw_wdev)
1754         {
1755                 //rtw_wdev_unregister(if1->rtw_wdev);
1756                 rtw_wdev_free(if1->rtw_wdev);
1757         }
1758 #endif
1759
1760 #ifdef CONFIG_BT_COEXIST
1761         if(1 == pwrctl->autopm_cnt){
1762                 #if (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,33))
1763                         usb_autopm_put_interface(adapter_to_dvobj(if1)->pusbintf);
1764                 #elif (LINUX_VERSION_CODE>=KERNEL_VERSION(2,6,20))
1765                         usb_autopm_enable(adapter_to_dvobj(if1)->pusbintf);
1766                 #else
1767                         usb_autosuspend_device(adapter_to_dvobj(if1)->pusbdev, 1);
1768                 #endif
1769                 pwrctl->autopm_cnt --;
1770         }
1771 #endif
1772
1773         rtw_free_drv_sw(if1);
1774
1775         if(pnetdev)
1776                 rtw_free_netdev(pnetdev);
1777
1778 #ifdef CONFIG_PLATFORM_RTD2880B
1779         DBG_871X("wlan link down\n");
1780         rtd2885_wlan_netlink_sendMsg("linkdown", "8712");
1781 #endif
1782
1783 }
1784
1785 static void dump_usb_interface(struct usb_interface *usb_intf)
1786 {
1787         int     i;
1788         u8      val8;
1789
1790         struct usb_device                               *udev = interface_to_usbdev(usb_intf);
1791         struct usb_device_descriptor    *dev_desc = &udev->descriptor;
1792
1793         struct usb_host_config                  *act_conf = udev->actconfig;
1794         struct usb_config_descriptor    *act_conf_desc = &act_conf->desc;
1795
1796         struct usb_host_interface               *host_iface;
1797         struct usb_interface_descriptor *iface_desc;
1798         struct usb_host_endpoint                *host_endp;
1799         struct usb_endpoint_descriptor  *endp_desc;
1800
1801 #if 1 /* The usb device this usb interface belongs to */
1802         DBG_871X("usb_interface:%p, usb_device:%p(num:%d, path:%s), usb_device_descriptor:%p\n", usb_intf, udev, udev->devnum, udev->devpath, dev_desc);
1803         DBG_871X("bLength:%u\n", dev_desc->bLength);
1804         DBG_871X("bDescriptorType:0x%02x\n", dev_desc->bDescriptorType);
1805         DBG_871X("bcdUSB:0x%04x\n", le16_to_cpu(dev_desc->bcdUSB));
1806         DBG_871X("bDeviceClass:0x%02x\n", dev_desc->bDeviceClass);
1807         DBG_871X("bDeviceSubClass:0x%02x\n", dev_desc->bDeviceSubClass);
1808         DBG_871X("bDeviceProtocol:0x%02x\n", dev_desc->bDeviceProtocol);
1809         DBG_871X("bMaxPacketSize0:%u\n", dev_desc->bMaxPacketSize0);
1810         DBG_871X("idVendor:0x%04x\n", le16_to_cpu(dev_desc->idVendor));
1811         DBG_871X("idProduct:0x%04x\n", le16_to_cpu(dev_desc->idProduct));
1812         DBG_871X("bcdDevice:0x%04x\n", le16_to_cpu(dev_desc->bcdDevice));
1813         DBG_871X("iManufacturer:0x02%x\n", dev_desc->iManufacturer);
1814         DBG_871X("iProduct:0x%02x\n", dev_desc->iProduct);
1815         DBG_871X("iSerialNumber:0x%02x\n", dev_desc->iSerialNumber);
1816         DBG_871X("bNumConfigurations:%u\n", dev_desc->bNumConfigurations);
1817 #endif
1818
1819
1820 #if 1 /* The acting usb_config_descriptor */
1821         DBG_871X("\nact_conf_desc:%p\n", act_conf_desc);
1822         DBG_871X("bLength:%u\n", act_conf_desc->bLength);
1823         DBG_871X("bDescriptorType:0x%02x\n", act_conf_desc->bDescriptorType);
1824         DBG_871X("wTotalLength:%u\n", le16_to_cpu(act_conf_desc->wTotalLength));
1825         DBG_871X("bNumInterfaces:%u\n", act_conf_desc->bNumInterfaces);
1826         DBG_871X("bConfigurationValue:0x%02x\n", act_conf_desc->bConfigurationValue);
1827         DBG_871X("iConfiguration:0x%02x\n", act_conf_desc->iConfiguration);
1828         DBG_871X("bmAttributes:0x%02x\n", act_conf_desc->bmAttributes);
1829         DBG_871X("bMaxPower=%u\n", act_conf_desc->bMaxPower);
1830 #endif
1831
1832
1833         DBG_871X("****** num of altsetting = (%d) ******/\n", usb_intf->num_altsetting);
1834         /* Get he host side alternate setting (the current alternate setting) for this interface*/
1835         host_iface = usb_intf->cur_altsetting;
1836         iface_desc = &host_iface->desc;
1837
1838 #if 1 /* The current alternate setting*/
1839         DBG_871X("\nusb_interface_descriptor:%p:\n", iface_desc);
1840         DBG_871X("bLength:%u\n", iface_desc->bLength);
1841         DBG_871X("bDescriptorType:0x%02x\n", iface_desc->bDescriptorType);
1842         DBG_871X("bInterfaceNumber:0x%02x\n", iface_desc->bInterfaceNumber);
1843         DBG_871X("bAlternateSetting=%x\n", iface_desc->bAlternateSetting);
1844         DBG_871X("bNumEndpoints=%x\n", iface_desc->bNumEndpoints);
1845         DBG_871X("bInterfaceClass=%x\n", iface_desc->bInterfaceClass);
1846         DBG_871X("bInterfaceSubClass=%x\n", iface_desc->bInterfaceSubClass);
1847         DBG_871X("bInterfaceProtocol=%x\n", iface_desc->bInterfaceProtocol);
1848         DBG_871X("iInterface=%x\n", iface_desc->iInterface);
1849 #endif
1850
1851
1852 #if 1
1853         //DBG_871X("\ndump usb_endpoint_descriptor:\n");
1854
1855         for (i = 0; i < iface_desc->bNumEndpoints; i++)
1856         {
1857                 host_endp = host_iface->endpoint + i;
1858                 if (host_endp)
1859                 {
1860                         endp_desc = &host_endp->desc;
1861
1862                         DBG_871X("\nusb_endpoint_descriptor(%d):\n", i);
1863                         DBG_871X("bLength=%x\n",endp_desc->bLength);
1864                         DBG_871X("bDescriptorType=%x\n",endp_desc->bDescriptorType);
1865                         DBG_871X("bEndpointAddress=%x\n",endp_desc->bEndpointAddress);
1866                         DBG_871X("bmAttributes=%x\n",endp_desc->bmAttributes);
1867                         DBG_871X("wMaxPacketSize=%x\n",endp_desc->wMaxPacketSize);
1868                         DBG_871X("wMaxPacketSize=%x\n",le16_to_cpu(endp_desc->wMaxPacketSize));
1869                         DBG_871X("bInterval=%x\n",endp_desc->bInterval);
1870                         //DBG_871X("bRefresh=%x\n",pendp_desc->bRefresh);
1871                         //DBG_871X("bSynchAddress=%x\n",pendp_desc->bSynchAddress);
1872
1873                         if (RT_usb_endpoint_is_bulk_in(endp_desc))
1874                         {
1875                                 DBG_871X("RT_usb_endpoint_is_bulk_in = %x\n", RT_usb_endpoint_num(endp_desc));
1876                                 //pdvobjpriv->RtNumInPipes++;
1877                         }
1878                         else if (RT_usb_endpoint_is_int_in(endp_desc))
1879                         {
1880                                 DBG_871X("RT_usb_endpoint_is_int_in = %x, Interval = %x\n", RT_usb_endpoint_num(endp_desc),endp_desc->bInterval);
1881                                 //pdvobjpriv->RtNumInPipes++;
1882                         }
1883                         else if (RT_usb_endpoint_is_bulk_out(endp_desc))
1884                         {
1885                                 DBG_871X("RT_usb_endpoint_is_bulk_out = %x\n", RT_usb_endpoint_num(endp_desc));
1886                                 //pdvobjpriv->RtNumOutPipes++;
1887                         }
1888                         //pdvobjpriv->ep_num[i] = RT_usb_endpoint_num(pendp_desc);
1889                 }
1890         }
1891
1892         //DBG_871X("nr_endpoint=%d, in_num=%d, out_num=%d\n\n", pdvobjpriv->nr_endpoint, pdvobjpriv->RtNumInPipes, pdvobjpriv->RtNumOutPipes);
1893 #endif
1894
1895         if (udev->speed == USB_SPEED_HIGH)
1896                 DBG_871X("USB_SPEED_HIGH\n");
1897         else
1898                 DBG_871X("NON USB_SPEED_HIGH\n");
1899
1900 }
1901
1902
1903 static int rtw_drv_init(struct usb_interface *pusb_intf, const struct usb_device_id *pdid)
1904 {
1905         int i;
1906         _adapter *if1 = NULL, *if2 = NULL;
1907         int status;
1908         struct dvobj_priv *dvobj;
1909
1910         RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("+rtw_drv_init\n"));
1911         //DBG_871X("+rtw_drv_init\n");
1912
1913         //step 0.
1914         process_spec_devid(pdid);
1915
1916         /* Initialize dvobj_priv */
1917         if ((dvobj = usb_dvobj_init(pusb_intf)) == NULL) {
1918                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("initialize device object priv Failed!\n"));
1919                 goto exit;
1920         }
1921
1922         #ifdef RTW_DVOBJ_CHIP_HW_TYPE
1923         decide_chip_type_by_usb_device_id(dvobj, pdid);
1924         #endif
1925
1926         if ((if1 = rtw_usb_if1_init(dvobj, pusb_intf, pdid)) == NULL) {
1927                 DBG_871X("rtw_init_primary_adapter Failed!\n");
1928                 goto free_dvobj;
1929         }
1930
1931 #ifdef CONFIG_CONCURRENT_MODE
1932         if((if2 = rtw_drv_if2_init(if1, usb_set_intf_ops)) == NULL) {
1933                 goto free_if1;
1934         }
1935 #endif
1936
1937 #ifdef CONFIG_INTEL_PROXIM
1938         rtw_sw_export=if1;
1939 #endif
1940
1941 #ifdef CONFIG_GLOBAL_UI_PID
1942         if(ui_pid[1]!=0) {
1943                 DBG_871X("ui_pid[1]:%d\n",ui_pid[1]);
1944                 rtw_signal_process(ui_pid[1], SIGUSR2);
1945         }
1946 #endif
1947
1948         //dev_alloc_name && register_netdev
1949         if((status = rtw_drv_register_netdev(if1)) != _SUCCESS) {
1950                 goto free_if2;
1951         }
1952
1953 #ifdef CONFIG_HOSTAPD_MLME
1954         hostapd_mode_init(if1);
1955 #endif
1956
1957 #ifdef CONFIG_PLATFORM_RTD2880B
1958         DBG_871X("wlan link up\n");
1959         rtd2885_wlan_netlink_sendMsg("linkup", "8712");
1960 #endif
1961
1962         RT_TRACE(_module_hci_intfs_c_,_drv_err_,("-871x_drv - drv_init, success!\n"));
1963
1964         status = _SUCCESS;
1965
1966 free_if2:
1967         if(status != _SUCCESS && if2) {
1968                 #ifdef CONFIG_CONCURRENT_MODE
1969                 rtw_drv_if2_stop(if2);
1970                 rtw_drv_if2_free(if2);
1971                 #endif
1972         }
1973 free_if1:
1974         if (status != _SUCCESS && if1) {
1975                 rtw_usb_if1_deinit(if1);
1976         }
1977 free_dvobj:
1978         if (status != _SUCCESS)
1979                 usb_dvobj_deinit(pusb_intf);
1980 exit:
1981         return status == _SUCCESS?0:-ENODEV;
1982 }
1983 extern void rtw_unregister_netdevs(struct dvobj_priv *dvobj);
1984 /*
1985  * dev_remove() - our device is being removed
1986 */
1987 //rmmod module & unplug(SurpriseRemoved) will call r871xu_dev_remove() => how to recognize both
1988 static void rtw_dev_remove(struct usb_interface *pusb_intf)
1989 {
1990         struct dvobj_priv *dvobj = usb_get_intfdata(pusb_intf);
1991         _adapter *padapter = dvobj->if1;
1992         struct net_device *pnetdev = padapter->pnetdev;
1993         struct mlme_priv *pmlmepriv= &padapter->mlmepriv;
1994
1995 _func_enter_;
1996
1997         DBG_871X("+rtw_dev_remove\n");
1998         RT_TRACE(_module_hci_intfs_c_,_drv_err_,("+dev_remove()\n"));
1999         dvobj->processing_dev_remove = _TRUE;
2000         rtw_unregister_netdevs(dvobj);
2001
2002         if(usb_drv->drv_registered == _TRUE)
2003         {
2004                 //DBG_871X("r871xu_dev_remove():padapter->bSurpriseRemoved == _TRUE\n");
2005                 padapter->bSurpriseRemoved = _TRUE;
2006         }
2007         /*else
2008         {
2009                 //DBG_871X("r871xu_dev_remove():module removed\n");
2010                 padapter->hw_init_completed = _FALSE;
2011         }*/
2012 #ifdef CONFIG_MP_INCLUDED
2013         if (padapter->registrypriv.mp_mode == 1)
2014                 MPT_DeInitAdapter(padapter);
2015 #endif
2016 #if defined(CONFIG_HAS_EARLYSUSPEND) || defined(CONFIG_ANDROID_POWER)
2017         rtw_unregister_early_suspend(dvobj_to_pwrctl(dvobj));
2018 #endif
2019
2020         rtw_pm_set_ips(padapter, IPS_NONE);
2021         rtw_pm_set_lps(padapter, PS_MODE_ACTIVE);
2022
2023         LeaveAllPowerSaveMode(padapter);
2024
2025 #ifdef CONFIG_CONCURRENT_MODE
2026         rtw_drv_if2_stop(dvobj->if2);
2027 #endif
2028
2029         rtw_usb_if1_deinit(padapter);
2030
2031 #ifdef CONFIG_CONCURRENT_MODE
2032         rtw_drv_if2_free(dvobj->if2);
2033 #endif
2034
2035         usb_dvobj_deinit(pusb_intf);
2036
2037         RT_TRACE(_module_hci_intfs_c_,_drv_err_,("-dev_remove()\n"));
2038         DBG_871X("-r871xu_dev_remove, done\n");
2039
2040
2041 #ifdef CONFIG_INTEL_PROXIM
2042         rtw_sw_export=NULL;
2043 #endif
2044
2045 _func_exit_;
2046
2047         return;
2048
2049 }
2050 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
2051 extern int console_suspend_enabled;
2052 #endif
2053
2054 static int /*__init*/ rtw_drv_entry(void)
2055 {
2056         int ret = 0;
2057
2058         DBG_871X_LEVEL(_drv_always_, "module init start\n");
2059         dump_drv_version(RTW_DBGDUMP);
2060 #ifdef BTCOEXVERSION
2061         DBG_871X_LEVEL(_drv_always_, DRV_NAME" BT-Coex version = %s\n", BTCOEXVERSION);
2062 #endif // BTCOEXVERSION
2063
2064 #ifdef CONFIG_PLATFORM_RTK_DMP
2065         u32 tmp;
2066         tmp=readl((volatile unsigned int*)0xb801a608);
2067         tmp &= 0xffffff00;
2068         tmp |= 0x55;
2069         writel(tmp,(volatile unsigned int*)0xb801a608);//write dummy register for 1055
2070 #endif
2071 #ifdef CONFIG_PLATFORM_ARM_SUNxI
2072 #ifndef CONFIG_RTL8723A
2073         /* ----------get usb_wifi_usbc_num------------- */
2074         ret = script_parser_fetch("usb_wifi_para", "usb_wifi_usbc_num", (int *)&usb_wifi_host, 64);
2075         if(ret != 0){
2076                 DBG_8192C("ERR: script_parser_fetch usb_wifi_usbc_num failed\n");
2077                 ret = -ENOMEM;
2078                 goto exit;
2079         }
2080         DBG_8192C("sw_usb_enable_hcd: usbc_num = %d\n", usb_wifi_host);
2081         sw_usb_enable_hcd(usb_wifi_host);
2082 #endif //CONFIG_RTL8723A
2083 #endif //CONFIG_PLATFORM_ARM_SUNxI
2084
2085 #if defined  CONFIG_PLATFORM_ARM_SUN6I
2086         script_item_value_type_e type;
2087
2088         type = script_get_item("wifi_para", "wifi_usbc_id", &item);
2089         if(SCIRPT_ITEM_VALUE_TYPE_INT != type){
2090                 printk("ERR: script_get_item wifi_usbc_id failed\n");
2091                 ret = -ENOMEM;
2092                 goto exit;
2093         }
2094
2095         printk("sw_usb_enable_hcd: usbc_num = %d\n", item.val);
2096         wifi_pm_power(1);
2097         mdelay(10);
2098
2099         #ifndef CONFIG_RTL8723A
2100         sw_usb_enable_hcd(item.val);
2101         #endif
2102 #endif // defined  CONFIG_PLATFORM_ARM_SUN6I  && !(defined CONFIG_RTL8723A)
2103
2104 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24))
2105         //console_suspend_enabled=0;
2106 #endif
2107
2108         usb_drv->drv_registered = _TRUE;
2109         rtw_suspend_lock_init();
2110         rtw_drv_proc_init();
2111         rtw_ndev_notifier_register();
2112
2113         ret = usb_register(&usb_drv->usbdrv);
2114
2115         if (ret != 0) {
2116                 usb_drv->drv_registered = _FALSE;
2117                 rtw_suspend_lock_uninit();
2118                 rtw_drv_proc_deinit();
2119                 rtw_ndev_notifier_unregister();
2120                 goto exit;
2121         }
2122
2123 exit:
2124         DBG_871X_LEVEL(_drv_always_, "module init ret=%d\n", ret);
2125         return ret;
2126 }
2127
2128 static void /*exit*/ rtw_drv_halt(void)
2129 {
2130         DBG_871X_LEVEL(_drv_always_, "module exit start\n");
2131
2132         usb_drv->drv_registered = _FALSE;
2133         usb_deregister(&usb_drv->usbdrv);
2134
2135 #ifdef CONFIG_PLATFORM_ARM_SUNxI
2136 #ifndef CONFIG_RTL8723A
2137         DBG_8192C("sw_usb_disable_hcd: usbc_num = %d\n", usb_wifi_host);
2138         sw_usb_disable_hcd(usb_wifi_host);
2139 #endif //ifndef CONFIG_RTL8723A
2140 #endif  //CONFIG_PLATFORM_ARM_SUNxI
2141
2142 #if defined  CONFIG_PLATFORM_ARM_SUN6I
2143         #ifndef CONFIG_RTL8723A
2144         sw_usb_disable_hcd(item.val);
2145         #endif
2146         wifi_pm_power(0);
2147 #endif  //  defined  CONFIG_PLATFORM_ARM_SUN6I  && !(defined CONFIG_RTL8723A)
2148
2149         rtw_suspend_lock_uninit();
2150         rtw_drv_proc_deinit();
2151         rtw_ndev_notifier_unregister();
2152
2153         DBG_871X_LEVEL(_drv_always_, "module exit success\n");
2154
2155         rtw_mstat_dump(RTW_DBGDUMP);
2156 }
2157
2158
2159 #include "wifi_version.h"
2160 #include <linux/rfkill-wlan.h>
2161
2162 int rockchip_wifi_init_module_rtkwifi(void)
2163 {
2164     printk("\n");
2165     printk("=======================================================\n");
2166     printk("==== Launching Wi-Fi driver! (Powered by Rockchip) ====\n");
2167     printk("=======================================================\n");
2168     printk("Realtek 8723AU USB WiFi driver (Powered by Rockchip,Ver %s) init.\n", RTL8192_DRV_VERSION);
2169     rockchip_wifi_power(1);
2170
2171     return rtw_drv_entry();
2172 }
2173
2174 void rockchip_wifi_exit_module_rtkwifi(void)
2175 {
2176     printk("\n");
2177     printk("=======================================================\n");
2178     printk("==== Dislaunching Wi-Fi driver! (Powered by Rockchip) ====\n");
2179     printk("=======================================================\n");
2180     printk("Realtek 8723AU USB WiFi driver (Powered by Rockchip,Ver %s) init.\n", RTL8192_DRV_VERSION);
2181     rtw_drv_halt();
2182     rockchip_wifi_power(0);
2183 }
2184
2185 module_init(rockchip_wifi_init_module_rtkwifi);
2186 module_exit(rockchip_wifi_exit_module_rtkwifi);
2187 //module_init(rtw_drv_entry);
2188 //module_exit(rtw_drv_halt);
2189
2190 #ifdef CONFIG_INTEL_PROXIM
2191 _adapter  *rtw_usb_get_sw_pointer(void)
2192 {
2193         return rtw_sw_export;
2194 }
2195 EXPORT_SYMBOL(rtw_usb_get_sw_pointer);
2196 #endif  //CONFIG_INTEL_PROXIM
2197