drivers/staging/rtl8723bs/os_dep/os_intfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
   5  *
   6  ******************************************************************************/
   7 #define _OS_INTFS_C_
   8
   9 #include <drv_types.h>
  10 #include <rtw_debug.h>
  11 #include <hal_data.h>
  12
  13 MODULE_LICENSE("GPL");
  14 MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
  15 MODULE_AUTHOR("Realtek Semiconductor Corp.");
  16 MODULE_VERSION(DRIVERVERSION);
  17
  18 /* module param defaults */
  19 static int rtw_chip_version;
  20 static int rtw_rfintfs = HWPI;
  21 static int rtw_lbkmode;/* RTL8712_AIR_TRX; */
  22
  23
  24 static int rtw_network_mode = Ndis802_11IBSS;/* Ndis802_11Infrastructure;infra, ad-hoc, auto */
  25 /* struct ndis_802_11_ssid      ssid; */
  26 static int rtw_channel = 1;/* ad-hoc support requirement */
  27 static int rtw_wireless_mode = WIRELESS_MODE_MAX;
  28 static int rtw_vrtl_carrier_sense = AUTO_VCS;
  29 static int rtw_vcs_type = RTS_CTS;/*  */
  30 static int rtw_rts_thresh = 2347;/*  */
  31 static int rtw_frag_thresh = 2346;/*  */
  32 static int rtw_preamble = PREAMBLE_LONG;/* long, short, auto */
  33 static int rtw_scan_mode = 1;/* active, passive */
  34 static int rtw_adhoc_tx_pwr = 1;
  35 static int rtw_soft_ap;
  36 /* int smart_ps = 1; */
  37 static int rtw_power_mgnt = 1;
  38 static int rtw_ips_mode = IPS_NORMAL;
  39 module_param(rtw_ips_mode, int, 0644);
  40 MODULE_PARM_DESC(rtw_ips_mode, "The default IPS mode");
  41
  42 static int rtw_smart_ps = 2;
  43
  44 static int rtw_check_fw_ps = 1;
  45
  46 static int rtw_usb_rxagg_mode = 2;/* USB_RX_AGG_DMA = 1, USB_RX_AGG_USB =2 */
  47 module_param(rtw_usb_rxagg_mode, int, 0644);
  48
  49 static int rtw_radio_enable = 1;
  50 static int rtw_long_retry_lmt = 7;
  51 static int rtw_short_retry_lmt = 7;
  52 static int rtw_busy_thresh = 40;
  53 /* int qos_enable = 0; */
  54 static int rtw_ack_policy = NORMAL_ACK;
  55
  56 static int rtw_software_encrypt;
  57 static int rtw_software_decrypt;
  58
  59 static int rtw_acm_method;/*  0:By SW 1:By HW. */
  60
  61 static int rtw_wmm_enable = 1;/*  default is set to enable the wmm. */
  62 static int rtw_uapsd_enable;
  63 static int rtw_uapsd_max_sp = NO_LIMIT;
  64 static int rtw_uapsd_acbk_en;
  65 static int rtw_uapsd_acbe_en;
  66 static int rtw_uapsd_acvi_en;
  67 static int rtw_uapsd_acvo_en;
  68
  69 int rtw_ht_enable = 1;
  70 /*  0: 20 MHz, 1: 40 MHz, 2: 80 MHz, 3: 160MHz, 4: 80+80MHz */
  71 /*  2.4G use bit 0 ~ 3, 5G use bit 4 ~ 7 */
  72 /*  0x21 means enable 2.4G 40MHz & 5G 80MHz */
  73 static int rtw_bw_mode = 0x21;
  74 static int rtw_ampdu_enable = 1;/* for enable tx_ampdu ,0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec) */
  75 static int rtw_rx_stbc = 1;/*  0: disable, 1:enable 2.4g */
  76 static int rtw_ampdu_amsdu;/*  0: disabled, 1:enabled, 2:auto . There is an IOT issu with DLINK DIR-629 when the flag turn on */
  77 /*  Short GI support Bit Map */
  78 /*  BIT0 - 20MHz, 0: non-support, 1: support */
  79 /*  BIT1 - 40MHz, 0: non-support, 1: support */
  80 /*  BIT2 - 80MHz, 0: non-support, 1: support */
  81 /*  BIT3 - 160MHz, 0: non-support, 1: support */
  82 static int rtw_short_gi = 0xf;
  83 /*  BIT0: Enable VHT LDPC Rx, BIT1: Enable VHT LDPC Tx, BIT4: Enable HT LDPC Rx, BIT5: Enable HT LDPC Tx */
  84 static int rtw_ldpc_cap = 0x33;
  85 /*  BIT0: Enable VHT STBC Rx, BIT1: Enable VHT STBC Tx, BIT4: Enable HT STBC Rx, BIT5: Enable HT STBC Tx */
  86 static int rtw_stbc_cap = 0x13;
  87 /*  BIT0: Enable VHT Beamformer, BIT1: Enable VHT Beamformee, BIT4: Enable HT Beamformer, BIT5: Enable HT Beamformee */
  88 static int rtw_beamform_cap = 0x2;
  89
  90 static int rtw_lowrate_two_xmit = 1;/* Use 2 path Tx to transmit MCS0~7 and legacy mode */
  91
  92 /* int rf_config = RF_1T2R;  1T2R */
  93 static int rtw_rf_config = RF_MAX_TYPE;  /* auto */
  94 static int rtw_low_power;
  95 static int rtw_wifi_spec;
  96 static int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX;
  97
  98 static int rtw_btcoex_enable = 1;
  99 module_param(rtw_btcoex_enable, int, 0644);
 100 MODULE_PARM_DESC(rtw_btcoex_enable, "Enable BT co-existence mechanism");
 101 static int rtw_bt_iso = 2;/*  0:Low, 1:High, 2:From Efuse */
 102 static int rtw_bt_sco = 3;/*  0:Idle, 1:None-SCO, 2:SCO, 3:From Counter, 4.Busy, 5.OtherBusy */
 103 static int rtw_bt_ampdu = 1 ;/*  0:Disable BT control A-MPDU, 1:Enable BT control A-MPDU. */
 104 static int rtw_ant_num = -1; /*  <0: undefined, >0: Antenna number */
 105 module_param(rtw_ant_num, int, 0644);
 106 MODULE_PARM_DESC(rtw_ant_num, "Antenna number setting");
 107
 108 static int rtw_antdiv_cfg = 1; /*  0:OFF , 1:ON, 2:decide by Efuse config */
 109 static int rtw_antdiv_type; /* 0:decide by efuse  1: for 88EE, 1Tx and 1RxCG are diversity.(2 Ant with SPDT), 2:  for 88EE, 1Tx and 2Rx are diversity.(2 Ant, Tx and RxCG are both on aux port, RxCS is on main port), 3: for 88EE, 1Tx and 1RxCG are fixed.(1Ant, Tx and RxCG are both on aux port) */
 110
 111
 112 static int rtw_enusbss;/* 0:disable, 1:enable */
 113
 114 static int rtw_hwpdn_mode = 2;/* 0:disable, 1:enable, 2: by EFUSE config */
 115
 116 #ifdef CONFIG_HW_PWRP_DETECTION
 117 static int rtw_hwpwrp_detect = 1;
 118 #else
 119 static int rtw_hwpwrp_detect; /* HW power  ping detect 0:disable , 1:enable */
 120 #endif
 121
 122 static int rtw_hw_wps_pbc;
 123
 124 int rtw_mc2u_disable = 0;
 125
 126 static int rtw_80211d;
 127
 128 #ifdef CONFIG_QOS_OPTIMIZATION
 129 static int rtw_qos_opt_enable = 1;/* 0: disable, 1:enable */
 130 #else
 131 static int rtw_qos_opt_enable;/* 0: disable, 1:enable */
 132 #endif
 133 module_param(rtw_qos_opt_enable, int, 0644);
 134
 135 static char *ifname = "wlan%d";
 136 module_param(ifname, charp, 0644);
 137 MODULE_PARM_DESC(ifname, "The default name to allocate for first interface");
 138
 139 char *rtw_initmac = NULL;  /*  temp mac address if users want to use instead of the mac address in Efuse */
 140
 141 module_param(rtw_initmac, charp, 0644);
 142 module_param(rtw_channel_plan, int, 0644);
 143 module_param(rtw_chip_version, int, 0644);
 144 module_param(rtw_rfintfs, int, 0644);
 145 module_param(rtw_lbkmode, int, 0644);
 146 module_param(rtw_network_mode, int, 0644);
 147 module_param(rtw_channel, int, 0644);
 148 module_param(rtw_wmm_enable, int, 0644);
 149 module_param(rtw_vrtl_carrier_sense, int, 0644);
 150 module_param(rtw_vcs_type, int, 0644);
 151 module_param(rtw_busy_thresh, int, 0644);
 152
 153 module_param(rtw_ht_enable, int, 0644);
 154 module_param(rtw_bw_mode, int, 0644);
 155 module_param(rtw_ampdu_enable, int, 0644);
 156 module_param(rtw_rx_stbc, int, 0644);
 157 module_param(rtw_ampdu_amsdu, int, 0644);
 158
 159 module_param(rtw_lowrate_two_xmit, int, 0644);
 160
 161 module_param(rtw_rf_config, int, 0644);
 162 module_param(rtw_power_mgnt, int, 0644);
 163 module_param(rtw_smart_ps, int, 0644);
 164 module_param(rtw_low_power, int, 0644);
 165 module_param(rtw_wifi_spec, int, 0644);
 166
 167 module_param(rtw_antdiv_cfg, int, 0644);
 168 module_param(rtw_antdiv_type, int, 0644);
 169
 170 module_param(rtw_enusbss, int, 0644);
 171 module_param(rtw_hwpdn_mode, int, 0644);
 172 module_param(rtw_hwpwrp_detect, int, 0644);
 173
 174 module_param(rtw_hw_wps_pbc, int, 0644);
 175
 176 static uint rtw_max_roaming_times = 2;
 177 module_param(rtw_max_roaming_times, uint, 0644);
 178 MODULE_PARM_DESC(rtw_max_roaming_times, "The max roaming times to try");
 179
 180 module_param(rtw_mc2u_disable, int, 0644);
 181
 182 module_param(rtw_80211d, int, 0644);
 183 MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
 184
 185 static uint rtw_notch_filter;
 186 module_param(rtw_notch_filter, uint, 0644);
 187 MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P");
 188
 189 #define CONFIG_RTW_HIQ_FILTER 1
 190
 191 static uint rtw_hiq_filter = CONFIG_RTW_HIQ_FILTER;
 192 module_param(rtw_hiq_filter, uint, 0644);
 193 MODULE_PARM_DESC(rtw_hiq_filter, "0:allow all, 1:allow special, 2:deny all");
 194
 195 static int rtw_tx_pwr_lmt_enable;
 196 static int rtw_tx_pwr_by_rate;
 197
 198 module_param(rtw_tx_pwr_lmt_enable, int, 0644);
 199 MODULE_PARM_DESC(rtw_tx_pwr_lmt_enable, "0:Disable, 1:Enable, 2: Depend on efuse");
 200
 201 module_param(rtw_tx_pwr_by_rate, int, 0644);
 202 MODULE_PARM_DESC(rtw_tx_pwr_by_rate, "0:Disable, 1:Enable, 2: Depend on efuse");
 203
 204 char *rtw_phy_file_path = "";
 205 module_param(rtw_phy_file_path, charp, 0644);
 206 MODULE_PARM_DESC(rtw_phy_file_path, "The path of phy parameter");
 207 /*  PHY FILE Bit Map */
 208 /*  BIT0 - MAC,                         0: non-support, 1: support */
 209 /*  BIT1 - BB,                                  0: non-support, 1: support */
 210 /*  BIT2 - BB_PG,                               0: non-support, 1: support */
 211 /*  BIT3 - BB_MP,                               0: non-support, 1: support */
 212 /*  BIT4 - RF,                                  0: non-support, 1: support */
 213 /*  BIT5 - RF_TXPWR_TRACK,      0: non-support, 1: support */
 214 /*  BIT6 - RF_TXPWR_LMT,                0: non-support, 1: support */
 215 static int rtw_load_phy_file = (BIT2 | BIT6);
 216 module_param(rtw_load_phy_file, int, 0644);
 217 MODULE_PARM_DESC(rtw_load_phy_file, "PHY File Bit Map");
 218 static int rtw_decrypt_phy_file;
 219 module_param(rtw_decrypt_phy_file, int, 0644);
 220 MODULE_PARM_DESC(rtw_decrypt_phy_file, "Enable Decrypt PHY File");
 221
 222 int _netdev_open(struct net_device *pnetdev);
 223 int netdev_open (struct net_device *pnetdev);
 224 static int netdev_close (struct net_device *pnetdev);
 225
 226 static uint loadparam(struct adapter *padapter, _nic_hdl pnetdev)
 227 {
 228         uint status = _SUCCESS;
 229         struct registry_priv  *registry_par = &padapter->registrypriv;
 230
 231         registry_par->chip_version = (u8)rtw_chip_version;
 232         registry_par->rfintfs = (u8)rtw_rfintfs;
 233         registry_par->lbkmode = (u8)rtw_lbkmode;
 234         /* registry_par->hci = (u8)hci; */
 235         registry_par->network_mode  = (u8)rtw_network_mode;
 236
 237         memcpy(registry_par->ssid.Ssid, "ANY", 3);
 238         registry_par->ssid.SsidLength = 3;
 239
 240         registry_par->channel = (u8)rtw_channel;
 241         registry_par->wireless_mode = (u8)rtw_wireless_mode;
 242
 243         if (registry_par->channel > 14)
 244                 registry_par->channel = 1;
 245
 246         registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense ;
 247         registry_par->vcs_type = (u8)rtw_vcs_type;
 248         registry_par->rts_thresh = (u16)rtw_rts_thresh;
 249         registry_par->frag_thresh = (u16)rtw_frag_thresh;
 250         registry_par->preamble = (u8)rtw_preamble;
 251         registry_par->scan_mode = (u8)rtw_scan_mode;
 252         registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr;
 253         registry_par->soft_ap =  (u8)rtw_soft_ap;
 254         registry_par->smart_ps =  (u8)rtw_smart_ps;
 255         registry_par->check_fw_ps = (u8)rtw_check_fw_ps;
 256         registry_par->power_mgnt = (u8)rtw_power_mgnt;
 257         registry_par->ips_mode = (u8)rtw_ips_mode;
 258         registry_par->radio_enable = (u8)rtw_radio_enable;
 259         registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt;
 260         registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt;
 261         registry_par->busy_thresh = (u16)rtw_busy_thresh;
 262         /* registry_par->qos_enable = (u8)rtw_qos_enable; */
 263         registry_par->ack_policy = (u8)rtw_ack_policy;
 264         registry_par->software_encrypt = (u8)rtw_software_encrypt;
 265         registry_par->software_decrypt = (u8)rtw_software_decrypt;
 266
 267         registry_par->acm_method = (u8)rtw_acm_method;
 268         registry_par->usb_rxagg_mode = (u8)rtw_usb_rxagg_mode;
 269
 270          /* UAPSD */
 271         registry_par->wmm_enable = (u8)rtw_wmm_enable;
 272         registry_par->uapsd_enable = (u8)rtw_uapsd_enable;
 273         registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp;
 274         registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en;
 275         registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en;
 276         registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en;
 277         registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en;
 278
 279         registry_par->ht_enable = (u8)rtw_ht_enable;
 280         registry_par->bw_mode = (u8)rtw_bw_mode;
 281         registry_par->ampdu_enable = (u8)rtw_ampdu_enable;
 282         registry_par->rx_stbc = (u8)rtw_rx_stbc;
 283         registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu;
 284         registry_par->short_gi = (u8)rtw_short_gi;
 285         registry_par->ldpc_cap = (u8)rtw_ldpc_cap;
 286         registry_par->stbc_cap = (u8)rtw_stbc_cap;
 287         registry_par->beamform_cap = (u8)rtw_beamform_cap;
 288
 289         registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit;
 290         registry_par->rf_config = (u8)rtw_rf_config;
 291         registry_par->low_power = (u8)rtw_low_power;
 292
 293
 294         registry_par->wifi_spec = (u8)rtw_wifi_spec;
 295
 296         registry_par->channel_plan = (u8)rtw_channel_plan;
 297
 298         registry_par->btcoex = (u8)rtw_btcoex_enable;
 299         registry_par->bt_iso = (u8)rtw_bt_iso;
 300         registry_par->bt_sco = (u8)rtw_bt_sco;
 301         registry_par->bt_ampdu = (u8)rtw_bt_ampdu;
 302         registry_par->ant_num = (s8)rtw_ant_num;
 303
 304         registry_par->accept_addba_req = true;
 305
 306         registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg;
 307         registry_par->antdiv_type = (u8)rtw_antdiv_type;
 308
 309         registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc;
 310
 311         registry_par->max_roaming_times = (u8)rtw_max_roaming_times;
 312 #ifdef CONFIG_INTEL_WIDI
 313         registry_par->max_roaming_times = (u8)rtw_max_roaming_times + 2;
 314 #endif /*  CONFIG_INTEL_WIDI */
 315
 316         registry_par->enable80211d = (u8)rtw_80211d;
 317
 318         snprintf(registry_par->ifname, 16, "%s", ifname);
 319
 320         registry_par->notch_filter = (u8)rtw_notch_filter;
 321
 322         registry_par->RegEnableTxPowerLimit = (u8)rtw_tx_pwr_lmt_enable;
 323         registry_par->RegEnableTxPowerByRate = (u8)rtw_tx_pwr_by_rate;
 324
 325         registry_par->RegPowerBase = 14;
 326         registry_par->TxBBSwing_2G = 0xFF;
 327         registry_par->TxBBSwing_5G = 0xFF;
 328         registry_par->bEn_RFE = 1;
 329         registry_par->RFE_Type = 64;
 330
 331         registry_par->load_phy_file = (u8)rtw_load_phy_file;
 332         registry_par->RegDecryptCustomFile = (u8)rtw_decrypt_phy_file;
 333         registry_par->qos_opt_enable = (u8)rtw_qos_opt_enable;
 334
 335         registry_par->hiq_filter = (u8)rtw_hiq_filter;
 336         return status;
 337 }
 338
 339 static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p)
 340 {
 341         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
 342         struct sockaddr *addr = p;
 343
 344         if (padapter->bup == false) {
 345                 /* DBG_871X("r8711_net_set_mac_address(), MAC =%x:%x:%x:%x:%x:%x\n", addr->sa_data[0], addr->sa_data[1], addr->sa_data[2], addr->sa_data[3], */
 346                 /* addr->sa_data[4], addr->sa_data[5]); */
 347                 memcpy(padapter->eeprompriv.mac_addr, addr->sa_data, ETH_ALEN);
 348                 /* memcpy(pnetdev->dev_addr, addr->sa_data, ETH_ALEN); */
 349                 /* padapter->bset_hwaddr = true; */
 350         }
 351
 352         return 0;
 353 }
 354
 355 static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
 356 {
 357         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
 358         struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
 359         struct recv_priv *precvpriv = &(padapter->recvpriv);
 360
 361         padapter->stats.tx_packets = pxmitpriv->tx_pkts;/* pxmitpriv->tx_pkts++; */
 362         padapter->stats.rx_packets = precvpriv->rx_pkts;/* precvpriv->rx_pkts++; */
 363         padapter->stats.tx_dropped = pxmitpriv->tx_drop;
 364         padapter->stats.rx_dropped = precvpriv->rx_drop;
 365         padapter->stats.tx_bytes = pxmitpriv->tx_bytes;
 366         padapter->stats.rx_bytes = precvpriv->rx_bytes;
 367
 368         return &padapter->stats;
 369 }
 370
 371 /*
 372  * AC to queue mapping
 373  *
 374  * AC_VO -> queue 0
 375  * AC_VI -> queue 1
 376  * AC_BE -> queue 2
 377  * AC_BK -> queue 3
 378  */
 379 static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
 380
 381 /* Given a data frame determine the 802.1p/1d tag to use. */
 382 static unsigned int rtw_classify8021d(struct sk_buff *skb)
 383 {
 384         unsigned int dscp;
 385
 386         /* skb->priority values from 256->263 are magic values to
 387          * directly indicate a specific 802.1d priority.  This is used
 388          * to allow 802.1d priority to be passed directly in from VLAN
 389          * tags, etc.
 390          */
 391         if (skb->priority >= 256 && skb->priority <= 263)
 392                 return skb->priority - 256;
 393
 394         switch (skb->protocol) {
 395         case htons(ETH_P_IP):
 396                 dscp = ip_hdr(skb)->tos & 0xfc;
 397                 break;
 398         default:
 399                 return 0;
 400         }
 401
 402         return dscp >> 5;
 403 }
 404
 405
 406 static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb,
 407                             struct net_device *sb_dev)
 408 {
 409         struct adapter  *padapter = rtw_netdev_priv(dev);
 410         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 411
 412         skb->priority = rtw_classify8021d(skb);
 413
 414         if (pmlmepriv->acm_mask != 0)
 415                 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
 416
 417         return rtw_1d_to_queue[skb->priority];
 418 }
 419
 420 u16 rtw_recv_select_queue(struct sk_buff *skb)
 421 {
 422         struct iphdr *piphdr;
 423         unsigned int dscp;
 424         __be16  eth_type;
 425         u32 priority;
 426         u8 *pdata = skb->data;
 427
 428         memcpy(&eth_type, pdata + (ETH_ALEN << 1), 2);
 429
 430         switch (be16_to_cpu(eth_type)) {
 431                 case ETH_P_IP:
 432
 433                         piphdr = (struct iphdr *)(pdata + ETH_HLEN);
 434
 435                         dscp = piphdr->tos & 0xfc;
 436
 437                         priority = dscp >> 5;
 438
 439                         break;
 440                 default:
 441                         priority = 0;
 442         }
 443
 444         return rtw_1d_to_queue[priority];
 445 }
 446
 447 static int rtw_ndev_notifier_call(struct notifier_block *nb, unsigned long state, void *ptr)
 448 {
 449         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 450
 451         if (dev->netdev_ops->ndo_do_ioctl != rtw_ioctl)
 452                 return NOTIFY_DONE;
 453
 454         DBG_871X_LEVEL(_drv_info_, FUNC_NDEV_FMT " state:%lu\n", FUNC_NDEV_ARG(dev), state);
 455
 456         switch (state) {
 457         case NETDEV_CHANGENAME:
 458                 rtw_adapter_proc_replace(dev);
 459                 break;
 460         }
 461
 462         return NOTIFY_DONE;
 463 }
 464
 465 static struct notifier_block rtw_ndev_notifier = {
 466         .notifier_call = rtw_ndev_notifier_call,
 467 };
 468
 469 int rtw_ndev_notifier_register(void)
 470 {
 471         return register_netdevice_notifier(&rtw_ndev_notifier);
 472 }
 473
 474 void rtw_ndev_notifier_unregister(void)
 475 {
 476         unregister_netdevice_notifier(&rtw_ndev_notifier);
 477 }
 478
 479
 480 static int rtw_ndev_init(struct net_device *dev)
 481 {
 482         struct adapter *adapter = rtw_netdev_priv(dev);
 483
 484         DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter));
 485         strncpy(adapter->old_ifname, dev->name, IFNAMSIZ);
 486         rtw_adapter_proc_init(dev);
 487
 488         return 0;
 489 }
 490
 491 static void rtw_ndev_uninit(struct net_device *dev)
 492 {
 493         struct adapter *adapter = rtw_netdev_priv(dev);
 494
 495         DBG_871X_LEVEL(_drv_always_, FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter));
 496         rtw_adapter_proc_deinit(dev);
 497 }
 498
 499 static const struct net_device_ops rtw_netdev_ops = {
 500         .ndo_init = rtw_ndev_init,
 501         .ndo_uninit = rtw_ndev_uninit,
 502         .ndo_open = netdev_open,
 503         .ndo_stop = netdev_close,
 504         .ndo_start_xmit = rtw_xmit_entry,
 505         .ndo_select_queue       = rtw_select_queue,
 506         .ndo_set_mac_address = rtw_net_set_mac_address,
 507         .ndo_get_stats = rtw_net_get_stats,
 508         .ndo_do_ioctl = rtw_ioctl,
 509 };
 510
 511 int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
 512 {
 513         if (dev_alloc_name(pnetdev, ifname) < 0) {
 514                 pr_err("dev_alloc_name, fail for %s\n", ifname);
 515                 return 1;
 516         }
 517         netif_carrier_off(pnetdev);
 518         /* rtw_netif_stop_queue(pnetdev); */
 519
 520         return 0;
 521 }
 522
 523 struct net_device *rtw_init_netdev(struct adapter *old_padapter)
 524 {
 525         struct adapter *padapter;
 526         struct net_device *pnetdev;
 527
 528         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+init_net_dev\n"));
 529
 530         if (old_padapter != NULL)
 531                 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(struct adapter), (void *)old_padapter);
 532         else
 533                 pnetdev = rtw_alloc_etherdev(sizeof(struct adapter));
 534
 535         pr_info("pnetdev = %p\n", pnetdev);
 536         if (!pnetdev)
 537                 return NULL;
 538
 539         padapter = rtw_netdev_priv(pnetdev);
 540         padapter->pnetdev = pnetdev;
 541
 542         /* pnetdev->init = NULL; */
 543
 544         DBG_871X("register rtw_netdev_ops to netdev_ops\n");
 545         pnetdev->netdev_ops = &rtw_netdev_ops;
 546
 547         /* pnetdev->tx_timeout = NULL; */
 548         pnetdev->watchdog_timeo = HZ * 3; /* 3 second timeout */
 549         pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def;
 550
 551         /* step 2. */
 552         loadparam(padapter, pnetdev);
 553
 554         return pnetdev;
 555 }
 556
 557 void rtw_unregister_netdevs(struct dvobj_priv *dvobj)
 558 {
 559         struct adapter *padapter = NULL;
 560         struct net_device *pnetdev = NULL;
 561
 562         padapter = dvobj->padapters;
 563
 564         if (padapter == NULL)
 565                 return;
 566
 567         pnetdev = padapter->pnetdev;
 568
 569         if ((padapter->DriverState != DRIVER_DISAPPEAR) && pnetdev)
 570                 unregister_netdev(pnetdev); /* will call netdev_close() */
 571         rtw_wdev_unregister(padapter->rtw_wdev);
 572 }
 573
 574 u32 rtw_start_drv_threads(struct adapter *padapter)
 575 {
 576         u32 _status = _SUCCESS;
 577
 578         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_start_drv_threads\n"));
 579         padapter->xmitThread = kthread_run(rtw_xmit_thread, padapter, "RTW_XMIT_THREAD");
 580         if (IS_ERR(padapter->xmitThread))
 581                 _status = _FAIL;
 582
 583         padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
 584         if (IS_ERR(padapter->cmdThread))
 585                 _status = _FAIL;
 586         else
 587                 wait_for_completion(&padapter->cmdpriv.terminate_cmdthread_comp); /* wait for cmd_thread to run */
 588
 589         rtw_hal_start_thread(padapter);
 590         return _status;
 591 }
 592
 593 void rtw_stop_drv_threads (struct adapter *padapter)
 594 {
 595         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_stop_drv_threads\n"));
 596
 597         rtw_stop_cmd_thread(padapter);
 598
 599         /*  Below is to termindate tx_thread... */
 600         complete(&padapter->xmitpriv.xmit_comp);
 601         wait_for_completion(&padapter->xmitpriv.terminate_xmitthread_comp);
 602         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("\n drv_halt: rtw_xmit_thread can be terminated !\n"));
 603
 604         rtw_hal_stop_thread(padapter);
 605 }
 606
 607 static u8 rtw_init_default_value(struct adapter *padapter)
 608 {
 609         u8 ret  = _SUCCESS;
 610         struct registry_priv *pregistrypriv = &padapter->registrypriv;
 611         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 612         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 613         struct security_priv *psecuritypriv = &padapter->securitypriv;
 614
 615         /* xmit_priv */
 616         pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
 617         pxmitpriv->vcs = pregistrypriv->vcs_type;
 618         pxmitpriv->vcs_type = pregistrypriv->vcs_type;
 619         /* pxmitpriv->rts_thresh = pregistrypriv->rts_thresh; */
 620         pxmitpriv->frag_len = pregistrypriv->frag_thresh;
 621
 622         /* recv_priv */
 623
 624         /* mlme_priv */
 625         pmlmepriv->scan_mode = SCAN_ACTIVE;
 626
 627         /* qos_priv */
 628         /* pmlmepriv->qospriv.qos_option = pregistrypriv->wmm_enable; */
 629
 630         /* ht_priv */
 631         pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */
 632
 633         /* security_priv */
 634         /* rtw_get_encrypt_decrypt_from_registrypriv(padapter); */
 635         psecuritypriv->binstallGrpkey = _FAIL;
 636 #ifdef CONFIG_GTK_OL
 637         psecuritypriv->binstallKCK_KEK = _FAIL;
 638 #endif /* CONFIG_GTK_OL */
 639         psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt;
 640         psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt;
 641
 642         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
 643         psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
 644
 645         psecuritypriv->dot11PrivacyKeyIndex = 0;
 646
 647         psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
 648         psecuritypriv->dot118021XGrpKeyid = 1;
 649
 650         psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
 651         psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
 652
 653         /* registry_priv */
 654         rtw_init_registrypriv_dev_network(padapter);
 655         rtw_update_registrypriv_dev_network(padapter);
 656
 657         /* hal_priv */
 658         rtw_hal_def_value_init(padapter);
 659
 660         /* misc. */
 661         RTW_ENABLE_FUNC(padapter, DF_RX_BIT);
 662         RTW_ENABLE_FUNC(padapter, DF_TX_BIT);
 663         padapter->bLinkInfoDump = 0;
 664         padapter->bNotifyChannelChange = 0;
 665
 666         /* for debug purpose */
 667         padapter->fix_rate = 0xFF;
 668         padapter->driver_ampdu_spacing = 0xFF;
 669         padapter->driver_rx_ampdu_factor =  0xFF;
 670
 671         return ret;
 672 }
 673
 674 struct dvobj_priv *devobj_init(void)
 675 {
 676         struct dvobj_priv *pdvobj = NULL;
 677
 678         pdvobj = rtw_zmalloc(sizeof(*pdvobj));
 679         if (pdvobj == NULL)
 680                 return NULL;
 681
 682         mutex_init(&pdvobj->hw_init_mutex);
 683         mutex_init(&pdvobj->h2c_fwcmd_mutex);
 684         mutex_init(&pdvobj->setch_mutex);
 685         mutex_init(&pdvobj->setbw_mutex);
 686
 687         spin_lock_init(&pdvobj->lock);
 688
 689         pdvobj->macid[1] = true; /* macid = 1 for bc/mc stainfo */
 690
 691         pdvobj->processing_dev_remove = false;
 692
 693         atomic_set(&pdvobj->disable_func, 0);
 694
 695         spin_lock_init(&pdvobj->cam_ctl.lock);
 696
 697         return pdvobj;
 698 }
 699
 700 void devobj_deinit(struct dvobj_priv *pdvobj)
 701 {
 702         if (!pdvobj)
 703                 return;
 704
 705         mutex_destroy(&pdvobj->hw_init_mutex);
 706         mutex_destroy(&pdvobj->h2c_fwcmd_mutex);
 707         mutex_destroy(&pdvobj->setch_mutex);
 708         mutex_destroy(&pdvobj->setbw_mutex);
 709
 710         kfree(pdvobj);
 711 }
 712
 713 u8 rtw_reset_drv_sw(struct adapter *padapter)
 714 {
 715         u8 ret8 = _SUCCESS;
 716         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 717         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
 718
 719         /* hal_priv */
 720         if (is_primary_adapter(padapter))
 721                 rtw_hal_def_value_init(padapter);
 722
 723         RTW_ENABLE_FUNC(padapter, DF_RX_BIT);
 724         RTW_ENABLE_FUNC(padapter, DF_TX_BIT);
 725         padapter->bLinkInfoDump = 0;
 726
 727         padapter->xmitpriv.tx_pkts = 0;
 728         padapter->recvpriv.rx_pkts = 0;
 729
 730         pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
 731
 732         /* pmlmepriv->LinkDetectInfo.TrafficBusyState = false; */
 733         pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
 734         pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
 735
 736         _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING);
 737
 738         pwrctrlpriv->pwr_state_check_cnts = 0;
 739
 740         /* mlmeextpriv */
 741         padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE;
 742
 743         rtw_set_signal_stat_timer(&padapter->recvpriv);
 744
 745         return ret8;
 746 }
 747
 748
 749 u8 rtw_init_drv_sw(struct adapter *padapter)
 750 {
 751         u8 ret8 = _SUCCESS;
 752
 753         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_init_drv_sw\n"));
 754
 755         ret8 = rtw_init_default_value(padapter);
 756
 757         rtw_init_hal_com_default_value(padapter);
 758
 759         if ((rtw_init_cmd_priv(&padapter->cmdpriv)) == _FAIL) {
 760                 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init cmd_priv\n"));
 761                 ret8 = _FAIL;
 762                 goto exit;
 763         }
 764
 765         padapter->cmdpriv.padapter = padapter;
 766
 767         if ((rtw_init_evt_priv(&padapter->evtpriv)) == _FAIL) {
 768                 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init evt_priv\n"));
 769                 ret8 = _FAIL;
 770                 goto exit;
 771         }
 772
 773
 774         if (rtw_init_mlme_priv(padapter) == _FAIL) {
 775                 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init mlme_priv\n"));
 776                 ret8 = _FAIL;
 777                 goto exit;
 778         }
 779
 780         if (init_mlme_ext_priv(padapter) == _FAIL) {
 781                 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("\n Can't init mlme_ext_priv\n"));
 782                 ret8 = _FAIL;
 783                 goto exit;
 784         }
 785
 786         if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL) {
 787                 DBG_871X("Can't _rtw_init_xmit_priv\n");
 788                 ret8 = _FAIL;
 789                 goto exit;
 790         }
 791
 792         if (_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL) {
 793                 DBG_871X("Can't _rtw_init_recv_priv\n");
 794                 ret8 = _FAIL;
 795                 goto exit;
 796         }
 797         /*  add for CONFIG_IEEE80211W, none 11w also can use */
 798         spin_lock_init(&padapter->security_key_mutex);
 799
 800         /*  We don't need to memset padapter->XXX to zero, because adapter is allocated by vzalloc(). */
 801         /* memset((unsigned char *)&padapter->securitypriv, 0, sizeof (struct security_priv)); */
 802
 803         if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL) {
 804                 DBG_871X("Can't _rtw_init_sta_priv\n");
 805                 ret8 = _FAIL;
 806                 goto exit;
 807         }
 808
 809         padapter->stapriv.padapter = padapter;
 810         padapter->setband = GHZ24_50;
 811         padapter->fix_rate = 0xFF;
 812         rtw_init_bcmc_stainfo(padapter);
 813
 814         rtw_init_pwrctrl_priv(padapter);
 815
 816         rtw_hal_dm_init(padapter);
 817
 818 #ifdef CONFIG_INTEL_WIDI
 819         if (rtw_init_intel_widi(padapter) == _FAIL) {
 820                 DBG_871X("Can't rtw_init_intel_widi\n");
 821                 ret8 = _FAIL;
 822                 goto exit;
 823         }
 824 #endif /* CONFIG_INTEL_WIDI */
 825
 826 exit:
 827
 828         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-rtw_init_drv_sw\n"));
 829
 830         return ret8;
 831 }
 832
 833 void rtw_cancel_all_timer(struct adapter *padapter)
 834 {
 835         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+rtw_cancel_all_timer\n"));
 836
 837         del_timer_sync(&padapter->mlmepriv.assoc_timer);
 838         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel association timer complete!\n"));
 839
 840         del_timer_sync(&padapter->mlmepriv.scan_to_timer);
 841         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel scan_to_timer!\n"));
 842
 843         del_timer_sync(&padapter->mlmepriv.dynamic_chk_timer);
 844         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel dynamic_chk_timer!\n"));
 845
 846         del_timer_sync(&(adapter_to_pwrctl(padapter)->pwr_state_check_timer));
 847
 848         del_timer_sync(&padapter->mlmepriv.set_scan_deny_timer);
 849         rtw_clear_scan_deny(padapter);
 850         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("rtw_cancel_all_timer:cancel set_scan_deny_timer!\n"));
 851
 852         del_timer_sync(&padapter->recvpriv.signal_stat_timer);
 853
 854         /* cancel dm timer */
 855         rtw_hal_dm_deinit(padapter);
 856 }
 857
 858 u8 rtw_free_drv_sw(struct adapter *padapter)
 859 {
 860         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("==>rtw_free_drv_sw"));
 861
 862 #ifdef CONFIG_INTEL_WIDI
 863         rtw_free_intel_widi(padapter);
 864 #endif /* CONFIG_INTEL_WIDI */
 865
 866         free_mlme_ext_priv(&padapter->mlmeextpriv);
 867
 868         rtw_free_cmd_priv(&padapter->cmdpriv);
 869
 870         rtw_free_evt_priv(&padapter->evtpriv);
 871
 872         rtw_free_mlme_priv(&padapter->mlmepriv);
 873
 874         /* free_io_queue(padapter); */
 875
 876         _rtw_free_xmit_priv(&padapter->xmitpriv);
 877
 878         _rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */
 879
 880         _rtw_free_recv_priv(&padapter->recvpriv);
 881
 882         rtw_free_pwrctrl_priv(padapter);
 883
 884         /* kfree((void *)padapter); */
 885
 886         rtw_hal_free_data(padapter);
 887
 888         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("<==rtw_free_drv_sw\n"));
 889
 890         /* free the old_pnetdev */
 891         if (padapter->rereg_nd_name_priv.old_pnetdev) {
 892                 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
 893                 padapter->rereg_nd_name_priv.old_pnetdev = NULL;
 894         }
 895
 896         /*  clear pbuddystruct adapter to avoid access wrong pointer. */
 897         if (padapter->pbuddy_adapter != NULL)
 898                 padapter->pbuddy_adapter->pbuddy_adapter = NULL;
 899
 900         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-rtw_free_drv_sw\n"));
 901
 902         return _SUCCESS;
 903 }
 904
 905 static int _rtw_drv_register_netdev(struct adapter *padapter, char *name)
 906 {
 907         int ret = _SUCCESS;
 908         struct net_device *pnetdev = padapter->pnetdev;
 909
 910         /* alloc netdev name */
 911         if (rtw_init_netdev_name(pnetdev, name))
 912                 return _FAIL;
 913
 914         memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
 915
 916         /* Tell the network stack we exist */
 917         if (register_netdev(pnetdev) != 0) {
 918                 DBG_871X(FUNC_NDEV_FMT "Failed!\n", FUNC_NDEV_ARG(pnetdev));
 919                 ret = _FAIL;
 920                 goto error_register_netdev;
 921         }
 922
 923         DBG_871X("%s, MAC Address (if%d) = " MAC_FMT "\n", __func__, (padapter->iface_id + 1), MAC_ARG(pnetdev->dev_addr));
 924
 925         return ret;
 926
 927 error_register_netdev:
 928
 929         rtw_free_drv_sw(padapter);
 930
 931         rtw_free_netdev(pnetdev);
 932
 933         return ret;
 934 }
 935
 936 int rtw_drv_register_netdev(struct adapter *if1)
 937 {
 938         struct dvobj_priv *dvobj = if1->dvobj;
 939         struct adapter *padapter = dvobj->padapters;
 940         char *name = if1->registrypriv.ifname;
 941
 942         return _rtw_drv_register_netdev(padapter, name);
 943 }
 944
 945 int _netdev_open(struct net_device *pnetdev)
 946 {
 947         uint status;
 948         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
 949         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
 950
 951         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+871x_drv - dev_open\n"));
 952         DBG_871X("+871x_drv - drv_open, bup =%d\n", padapter->bup);
 953
 954         padapter->netif_up = true;
 955
 956         if (pwrctrlpriv->ps_flag == true) {
 957                 padapter->net_closed = false;
 958                 goto netdev_open_normal_process;
 959         }
 960
 961         if (padapter->bup == false) {
 962                 padapter->bDriverStopped = false;
 963                 padapter->bSurpriseRemoved = false;
 964                 padapter->bCardDisableWOHSM = false;
 965
 966                 status = rtw_hal_init(padapter);
 967                 if (status == _FAIL) {
 968                         RT_TRACE(_module_os_intfs_c_, _drv_err_, ("rtl871x_hal_init(): Can't init h/w!\n"));
 969                         goto netdev_open_error;
 970                 }
 971
 972                 DBG_871X("MAC Address = " MAC_FMT "\n", MAC_ARG(pnetdev->dev_addr));
 973
 974                 status = rtw_start_drv_threads(padapter);
 975                 if (status == _FAIL) {
 976                         DBG_871X("Initialize driver software resource Failed!\n");
 977                         goto netdev_open_error;
 978                 }
 979
 980                 if (padapter->intf_start)
 981                         padapter->intf_start(padapter);
 982
 983                 rtw_cfg80211_init_wiphy(padapter);
 984
 985                 padapter->bup = true;
 986                 pwrctrlpriv->bips_processing = false;
 987         }
 988         padapter->net_closed = false;
 989
 990         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
 991
 992         if (!rtw_netif_queue_stopped(pnetdev))
 993                 rtw_netif_start_queue(pnetdev);
 994         else
 995                 rtw_netif_wake_queue(pnetdev);
 996
 997 netdev_open_normal_process:
 998
 999         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-871x_drv - dev_open\n"));
1000         DBG_871X("-871x_drv - drv_open, bup =%d\n", padapter->bup);
1001
1002         return 0;
1003
1004 netdev_open_error:
1005
1006         padapter->bup = false;
1007
1008         netif_carrier_off(pnetdev);
1009         rtw_netif_stop_queue(pnetdev);
1010
1011         RT_TRACE(_module_os_intfs_c_, _drv_err_, ("-871x_drv - dev_open, fail!\n"));
1012         DBG_871X("-871x_drv - drv_open fail, bup =%d\n", padapter->bup);
1013
1014         return (-1);
1015 }
1016
1017 int netdev_open(struct net_device *pnetdev)
1018 {
1019         int ret;
1020         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
1021         struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
1022
1023         if (pwrctrlpriv->bInSuspend == true) {
1024                 DBG_871X("+871x_drv - drv_open, bInSuspend =%d\n", pwrctrlpriv->bInSuspend);
1025                 return 0;
1026         }
1027
1028         if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex)))
1029                 return -1;
1030
1031         ret = _netdev_open(pnetdev);
1032         mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
1033
1034         return ret;
1035 }
1036
1037 static int  ips_netdrv_open(struct adapter *padapter)
1038 {
1039         int status = _SUCCESS;
1040         /* struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); */
1041
1042         padapter->net_closed = false;
1043
1044         DBG_871X("===> %s.........\n", __func__);
1045
1046
1047         padapter->bDriverStopped = false;
1048         padapter->bCardDisableWOHSM = false;
1049         /* padapter->bup = true; */
1050
1051         status = rtw_hal_init(padapter);
1052         if (status == _FAIL) {
1053                 RT_TRACE(_module_os_intfs_c_, _drv_err_, ("ips_netdrv_open(): Can't init h/w!\n"));
1054                 goto netdev_open_error;
1055         }
1056
1057         if (padapter->intf_start)
1058                 padapter->intf_start(padapter);
1059
1060         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
1061
1062         return _SUCCESS;
1063
1064 netdev_open_error:
1065         /* padapter->bup = false; */
1066         DBG_871X("-ips_netdrv_open - drv_open failure, bup =%d\n", padapter->bup);
1067
1068         return _FAIL;
1069 }
1070
1071
1072 int rtw_ips_pwr_up(struct adapter *padapter)
1073 {
1074         int result;
1075         DBG_871X("===>  rtw_ips_pwr_up..............\n");
1076
1077         result = ips_netdrv_open(padapter);
1078
1079         DBG_871X("<===  rtw_ips_pwr_up..............\n");
1080         return result;
1081 }
1082
1083 void rtw_ips_pwr_down(struct adapter *padapter)
1084 {
1085         DBG_871X("===> rtw_ips_pwr_down...................\n");
1086
1087         padapter->bCardDisableWOHSM = true;
1088         padapter->net_closed = true;
1089
1090         rtw_ips_dev_unload(padapter);
1091         padapter->bCardDisableWOHSM = false;
1092         DBG_871X("<=== rtw_ips_pwr_down.....................\n");
1093 }
1094
1095 void rtw_ips_dev_unload(struct adapter *padapter)
1096 {
1097         DBG_871X("====> %s...\n", __func__);
1098
1099
1100         if (padapter->bSurpriseRemoved == false)
1101                 rtw_hal_deinit(padapter);
1102 }
1103
1104
1105 static int pm_netdev_open(struct net_device *pnetdev, u8 bnormal)
1106 {
1107         int status = -1;
1108
1109         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
1110
1111         if (true == bnormal) {
1112                 if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex)) == 0) {
1113                         status = _netdev_open(pnetdev);
1114                         mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
1115                 }
1116         }
1117         else
1118                 status =  (_SUCCESS == ips_netdrv_open(padapter)) ? (0) : (-1);
1119
1120         return status;
1121 }
1122
1123 static int netdev_close(struct net_device *pnetdev)
1124 {
1125         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
1126         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
1127
1128         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("+871x_drv - drv_close\n"));
1129
1130         if (pwrctl->bInternalAutoSuspend == true) {
1131                 /* rtw_pwr_wakeup(padapter); */
1132                 if (pwrctl->rf_pwrstate == rf_off)
1133                         pwrctl->ps_flag = true;
1134         }
1135         padapter->net_closed = true;
1136         padapter->netif_up = false;
1137
1138 /*if (!padapter->hw_init_completed)
1139         {
1140                 DBG_871X("(1)871x_drv - drv_close, bup =%d, hw_init_completed =%d\n", padapter->bup, padapter->hw_init_completed);
1141
1142                 padapter->bDriverStopped = true;
1143
1144                 rtw_dev_unload(padapter);
1145         }
1146         else*/
1147         if (pwrctl->rf_pwrstate == rf_on) {
1148                 DBG_871X("(2)871x_drv - drv_close, bup =%d, hw_init_completed =%d\n", padapter->bup, padapter->hw_init_completed);
1149
1150                 /* s1. */
1151                 if (pnetdev) {
1152                         if (!rtw_netif_queue_stopped(pnetdev))
1153                                 rtw_netif_stop_queue(pnetdev);
1154                 }
1155
1156                 /* s2. */
1157                 LeaveAllPowerSaveMode(padapter);
1158                 rtw_disassoc_cmd(padapter, 500, false);
1159                 /* s2-2.  indicate disconnect to os */
1160                 rtw_indicate_disconnect(padapter);
1161                 /* s2-3. */
1162                 rtw_free_assoc_resources(padapter, 1);
1163                 /* s2-4. */
1164                 rtw_free_network_queue(padapter, true);
1165         }
1166
1167         rtw_scan_abort(padapter);
1168         adapter_wdev_data(padapter)->bandroid_scan = false;
1169
1170         RT_TRACE(_module_os_intfs_c_, _drv_info_, ("-871x_drv - drv_close\n"));
1171         DBG_871X("-871x_drv - drv_close, bup =%d\n", padapter->bup);
1172
1173         return 0;
1174 }
1175
1176 void rtw_ndev_destructor(struct net_device *ndev)
1177 {
1178         DBG_871X(FUNC_NDEV_FMT "\n", FUNC_NDEV_ARG(ndev));
1179
1180         if (ndev->ieee80211_ptr)
1181                 kfree((u8 *)ndev->ieee80211_ptr);
1182 }
1183
1184 void rtw_dev_unload(struct adapter *padapter)
1185 {
1186         struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
1187         struct dvobj_priv *pobjpriv = padapter->dvobj;
1188         struct debug_priv *pdbgpriv = &pobjpriv->drv_dbg;
1189         struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
1190         u8 cnt = 0;
1191
1192         RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("+%s\n", __func__));
1193
1194         if (padapter->bup == true) {
1195                 DBG_871X("===> %s\n", __func__);
1196
1197                 padapter->bDriverStopped = true;
1198                 if (padapter->xmitpriv.ack_tx)
1199                         rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
1200
1201                 if (padapter->intf_stop)
1202                         padapter->intf_stop(padapter);
1203
1204                 RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("@ rtw_dev_unload: stop intf complete!\n"));
1205
1206                 if (!pwrctl->bInternalAutoSuspend)
1207                         rtw_stop_drv_threads(padapter);
1208
1209                 while (atomic_read(&(pcmdpriv->cmdthd_running)) == true) {
1210                         if (cnt > 5) {
1211                                 DBG_871X("stop cmdthd timeout\n");
1212                                 break;
1213                         } else {
1214                                 cnt ++;
1215                                 DBG_871X("cmdthd is running(%d)\n", cnt);
1216                                 msleep(10);
1217                         }
1218                 }
1219
1220                 RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("@ %s: stop thread complete!\n", __func__));
1221
1222                 /* check the status of IPS */
1223                 if (rtw_hal_check_ips_status(padapter) == true || pwrctl->rf_pwrstate == rf_off) { /* check HW status and SW state */
1224                         DBG_871X_LEVEL(_drv_always_, "%s: driver in IPS-FWLPS\n", __func__);
1225                         pdbgpriv->dbg_dev_unload_inIPS_cnt++;
1226                         LeaveAllPowerSaveMode(padapter);
1227                 } else {
1228                         DBG_871X_LEVEL(_drv_always_, "%s: driver not in IPS\n", __func__);
1229                 }
1230
1231                 if (padapter->bSurpriseRemoved == false) {
1232                         rtw_btcoex_IpsNotify(padapter, pwrctl->ips_mode_req);
1233 #ifdef CONFIG_WOWLAN
1234                         if (pwrctl->bSupportRemoteWakeup == true &&
1235                                 pwrctl->wowlan_mode == true) {
1236                                 DBG_871X_LEVEL(_drv_always_, "%s bSupportRemoteWakeup ==true  do not run rtw_hal_deinit()\n", __func__);
1237                         }
1238                         else
1239 #endif
1240                         {
1241                                 /* amy modify 20120221 for power seq is different between driver open and ips */
1242                                 rtw_hal_deinit(padapter);
1243                         }
1244                         padapter->bSurpriseRemoved = true;
1245                 }
1246                 RT_TRACE(_module_hci_intfs_c_, _drv_notice_,
1247                          ("@ %s: deinit hal complete!\n", __func__));
1248
1249                 padapter->bup = false;
1250
1251                 DBG_871X("<=== %s\n", __func__);
1252         }
1253         else {
1254                 RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("%s: bup ==false\n", __func__));
1255                 DBG_871X("%s: bup ==false\n", __func__);
1256         }
1257
1258         RT_TRACE(_module_hci_intfs_c_, _drv_notice_, ("-%s\n", __func__));
1259 }
1260
1261 static int rtw_suspend_free_assoc_resource(struct adapter *padapter)
1262 {
1263         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1264
1265         DBG_871X("==> " FUNC_ADPT_FMT " entry....\n", FUNC_ADPT_ARG(padapter));
1266
1267         if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
1268                 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
1269                         && check_fwstate(pmlmepriv, _FW_LINKED)) {
1270                         DBG_871X("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n", __func__,
1271                                         pmlmepriv->cur_network.network.Ssid.Ssid,
1272                                         MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
1273                                         pmlmepriv->cur_network.network.Ssid.SsidLength,
1274                                         pmlmepriv->assoc_ssid.SsidLength);
1275                         rtw_set_to_roam(padapter, 1);
1276                 }
1277         }
1278
1279         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)) {
1280                 rtw_disassoc_cmd(padapter, 0, false);
1281                 /* s2-2.  indicate disconnect to os */
1282                 rtw_indicate_disconnect(padapter);
1283         }
1284         else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1285                 rtw_sta_flush(padapter);
1286         }
1287
1288         /* s2-3. */
1289         rtw_free_assoc_resources(padapter, 1);
1290
1291         /* s2-4. */
1292         rtw_free_network_queue(padapter, true);
1293
1294         if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
1295                 rtw_indicate_scan_done(padapter, 1);
1296
1297         if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) {
1298                 DBG_871X_LEVEL(_drv_always_, "%s: fw_under_linking\n", __func__);
1299                 rtw_indicate_disconnect(padapter);
1300         }
1301
1302         DBG_871X("<== " FUNC_ADPT_FMT " exit....\n", FUNC_ADPT_ARG(padapter));
1303         return _SUCCESS;
1304 }
1305
1306 #ifdef CONFIG_WOWLAN
1307 int rtw_suspend_wow(struct adapter *padapter)
1308 {
1309         u8 ch, bw, offset;
1310         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1311         struct net_device *pnetdev = padapter->pnetdev;
1312         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1313         struct wowlan_ioctl_param poidparam;
1314         int ret = _SUCCESS;
1315
1316         DBG_871X("==> " FUNC_ADPT_FMT " entry....\n", FUNC_ADPT_ARG(padapter));
1317
1318
1319         DBG_871X("wowlan_mode: %d\n", pwrpriv->wowlan_mode);
1320         DBG_871X("wowlan_pno_enable: %d\n", pwrpriv->wowlan_pno_enable);
1321
1322         if (pwrpriv->wowlan_mode == true) {
1323                 if (pnetdev)
1324                         rtw_netif_stop_queue(pnetdev);
1325                 /*  1. stop thread */
1326                 padapter->bDriverStopped = true;        /* for stop thread */
1327                 rtw_stop_drv_threads(padapter);
1328                 padapter->bDriverStopped = false;       /* for 32k command */
1329
1330                 /*  2. disable interrupt */
1331                 if (padapter->intf_stop) {
1332                         padapter->intf_stop(padapter);
1333                 }
1334
1335                 /*  2.1 clean interupt */
1336                 if (padapter->HalFunc.clear_interrupt)
1337                         padapter->HalFunc.clear_interrupt(padapter);
1338
1339                 /*  2.2 free irq */
1340                 /* sdio_free_irq(adapter_to_dvobj(padapter)); */
1341                 if (padapter->intf_free_irq)
1342                         padapter->intf_free_irq(adapter_to_dvobj(padapter));
1343
1344                 poidparam.subcode = WOWLAN_ENABLE;
1345                 padapter->HalFunc.SetHwRegHandler(padapter, HW_VAR_WOWLAN, (u8 *)&poidparam);
1346                 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
1347                         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
1348                                 && check_fwstate(pmlmepriv, _FW_LINKED)) {
1349                                 DBG_871X("%s %s(" MAC_FMT "), length:%d assoc_ssid.length:%d\n", __func__,
1350                                                 pmlmepriv->cur_network.network.Ssid.Ssid,
1351                                                 MAC_ARG(pmlmepriv->cur_network.network.MacAddress),
1352                                                 pmlmepriv->cur_network.network.Ssid.SsidLength,
1353                                                 pmlmepriv->assoc_ssid.SsidLength);
1354
1355                                 rtw_set_to_roam(padapter, 0);
1356                         }
1357                 }
1358
1359                 DBG_871X_LEVEL(_drv_always_, "%s: wowmode suspending\n", __func__);
1360
1361                 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true) {
1362                         DBG_871X_LEVEL(_drv_always_, "%s: fw_under_survey\n", __func__);
1363                         rtw_indicate_scan_done(padapter, 1);
1364                         clr_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
1365                 }
1366
1367                 if (rtw_get_ch_setting_union(padapter, &ch, &bw, &offset) != 0) {
1368                         DBG_871X(FUNC_ADPT_FMT " back to linked/linking union - ch:%u, bw:%u, offset:%u\n",
1369                                 FUNC_ADPT_ARG(padapter), ch, bw, offset);
1370                         set_channel_bwmode(padapter, ch, offset, bw);
1371                 }
1372
1373                 if (pwrpriv->wowlan_pno_enable)
1374                         DBG_871X_LEVEL(_drv_always_, "%s: pno: %d\n", __func__, pwrpriv->wowlan_pno_enable);
1375                 else
1376                         rtw_set_ps_mode(padapter, PS_MODE_DTIM, 0, 0, "WOWLAN");
1377         }
1378         else {
1379                 DBG_871X_LEVEL(_drv_always_, "%s: ### ERROR ### wowlan_mode =%d\n", __func__, pwrpriv->wowlan_mode);
1380         }
1381         DBG_871X("<== " FUNC_ADPT_FMT " exit....\n", FUNC_ADPT_ARG(padapter));
1382         return ret;
1383 }
1384 #endif /* ifdef CONFIG_WOWLAN */
1385
1386 #ifdef CONFIG_AP_WOWLAN
1387 int rtw_suspend_ap_wow(struct adapter *padapter)
1388 {
1389         u8 ch, bw, offset;
1390         struct net_device *pnetdev = padapter->pnetdev;
1391         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1392         struct wowlan_ioctl_param poidparam;
1393         int ret = _SUCCESS;
1394
1395         DBG_871X("==> " FUNC_ADPT_FMT " entry....\n", FUNC_ADPT_ARG(padapter));
1396
1397         pwrpriv->wowlan_ap_mode = true;
1398
1399         DBG_871X("wowlan_ap_mode: %d\n", pwrpriv->wowlan_ap_mode);
1400
1401         if (pnetdev)
1402                 rtw_netif_stop_queue(pnetdev);
1403         /*  1. stop thread */
1404         padapter->bDriverStopped = true;        /* for stop thread */
1405         rtw_stop_drv_threads(padapter);
1406         padapter->bDriverStopped = false;       /* for 32k command */
1407
1408         /*  2. disable interrupt */
1409         rtw_hal_disable_interrupt(padapter); /*  It need wait for leaving 32K. */
1410
1411         /*  2.1 clean interupt */
1412         if (padapter->HalFunc.clear_interrupt)
1413                 padapter->HalFunc.clear_interrupt(padapter);
1414
1415         /*  2.2 free irq */
1416         /* sdio_free_irq(adapter_to_dvobj(padapter)); */
1417         if (padapter->intf_free_irq)
1418                 padapter->intf_free_irq(adapter_to_dvobj(padapter));
1419
1420         poidparam.subcode = WOWLAN_AP_ENABLE;
1421         padapter->HalFunc.SetHwRegHandler(padapter,
1422                                         HW_VAR_AP_WOWLAN, (u8 *)&poidparam);
1423
1424         DBG_871X_LEVEL(_drv_always_, "%s: wowmode suspending\n", __func__);
1425
1426         if (rtw_get_ch_setting_union(padapter, &ch, &bw, &offset) != 0) {
1427                 DBG_871X(FUNC_ADPT_FMT " back to linked/linking union - ch:%u, bw:%u, offset:%u\n",
1428                          FUNC_ADPT_ARG(padapter), ch, bw, offset);
1429                 set_channel_bwmode(padapter, ch, offset, bw);
1430         }
1431
1432         rtw_set_ps_mode(padapter, PS_MODE_MIN, 0, 0, "AP-WOWLAN");
1433
1434         DBG_871X("<== " FUNC_ADPT_FMT " exit....\n", FUNC_ADPT_ARG(padapter));
1435         return ret;
1436 }
1437 #endif /* ifdef CONFIG_AP_WOWLAN */
1438
1439
1440 static int rtw_suspend_normal(struct adapter *padapter)
1441 {
1442         struct net_device *pnetdev = padapter->pnetdev;
1443         int ret = _SUCCESS;
1444
1445         DBG_871X("==> " FUNC_ADPT_FMT " entry....\n", FUNC_ADPT_ARG(padapter));
1446         if (pnetdev) {
1447                 netif_carrier_off(pnetdev);
1448                 rtw_netif_stop_queue(pnetdev);
1449         }
1450
1451         rtw_suspend_free_assoc_resource(padapter);
1452
1453         if ((rtw_hal_check_ips_status(padapter) == true)
1454                 || (adapter_to_pwrctl(padapter)->rf_pwrstate == rf_off)) {
1455                 DBG_871X_LEVEL(_drv_always_, "%s: ### ERROR #### driver in IPS ####ERROR###!!!\n", __func__);
1456         }
1457
1458         rtw_dev_unload(padapter);
1459
1460         /* sdio_deinit(adapter_to_dvobj(padapter)); */
1461         if (padapter->intf_deinit)
1462                 padapter->intf_deinit(adapter_to_dvobj(padapter));
1463
1464         DBG_871X("<== " FUNC_ADPT_FMT " exit....\n", FUNC_ADPT_ARG(padapter));
1465         return ret;
1466 }
1467
1468 int rtw_suspend_common(struct adapter *padapter)
1469 {
1470         struct dvobj_priv *psdpriv = padapter->dvobj;
1471         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1472         struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
1473         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1474
1475         int ret = 0;
1476         unsigned long start_time = jiffies;
1477
1478         DBG_871X_LEVEL(_drv_always_, " suspend start\n");
1479         DBG_871X("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
1480         pdbgpriv->dbg_suspend_cnt++;
1481
1482         pwrpriv->bInSuspend = true;
1483
1484         while (pwrpriv->bips_processing == true)
1485                 msleep(1);
1486
1487         if ((!padapter->bup) || (padapter->bDriverStopped) || (padapter->bSurpriseRemoved)) {
1488                 DBG_871X("%s bup =%d bDriverStopped =%d bSurpriseRemoved = %d\n", __func__
1489                         , padapter->bup, padapter->bDriverStopped, padapter->bSurpriseRemoved);
1490                 pdbgpriv->dbg_suspend_error_cnt++;
1491                 goto exit;
1492         }
1493         rtw_ps_deny(padapter, PS_DENY_SUSPEND);
1494
1495         rtw_cancel_all_timer(padapter);
1496
1497         LeaveAllPowerSaveModeDirect(padapter);
1498
1499         rtw_stop_cmd_thread(padapter);
1500
1501         /*  wait for the latest FW to remove this condition. */
1502         if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
1503                 rtw_btcoex_SuspendNotify(padapter, 0);
1504                 DBG_871X("WIFI_AP_STATE\n");
1505         } else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1506                 rtw_btcoex_SuspendNotify(padapter, 1);
1507                 DBG_871X("STATION\n");
1508         }
1509
1510         rtw_ps_deny_cancel(padapter, PS_DENY_SUSPEND);
1511
1512         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1513         #ifdef CONFIG_WOWLAN
1514                 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
1515                         pwrpriv->wowlan_mode = true;
1516                 } else if (pwrpriv->wowlan_pno_enable == true) {
1517                         pwrpriv->wowlan_mode |= pwrpriv->wowlan_pno_enable;
1518                 }
1519
1520                 if (pwrpriv->wowlan_mode == true)
1521                 rtw_suspend_wow(padapter);
1522                 else
1523                         rtw_suspend_normal(padapter);
1524
1525         #else /* CONFIG_WOWLAN */
1526                 rtw_suspend_normal(padapter);
1527         #endif /* CONFIG_WOWLAN */
1528         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
1529         #ifdef CONFIG_AP_WOWLAN
1530                 rtw_suspend_ap_wow(padapter);
1531         #else
1532                 rtw_suspend_normal(padapter);
1533         #endif /* CONFIG_AP_WOWLAN */
1534         } else {
1535                 rtw_suspend_normal(padapter);
1536         }
1537
1538         DBG_871X_LEVEL(_drv_always_, "rtw suspend success in %d ms\n",
1539                 jiffies_to_msecs(jiffies - start_time));
1540
1541 exit:
1542         DBG_871X("<===  %s return %d.............. in %dms\n", __func__
1543                 , ret, jiffies_to_msecs(jiffies - start_time));
1544
1545         return ret;
1546 }
1547
1548 #ifdef CONFIG_WOWLAN
1549 int rtw_resume_process_wow(struct adapter *padapter)
1550 {
1551         struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
1552         struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
1553         struct net_device *pnetdev = padapter->pnetdev;
1554         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1555         struct dvobj_priv *psdpriv = padapter->dvobj;
1556         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1557         struct wowlan_ioctl_param poidparam;
1558         struct sta_info *psta = NULL;
1559         int ret = _SUCCESS;
1560
1561         DBG_871X("==> " FUNC_ADPT_FMT " entry....\n", FUNC_ADPT_ARG(padapter));
1562
1563         if (padapter) {
1564                 pnetdev = padapter->pnetdev;
1565                 pwrpriv = adapter_to_pwrctl(padapter);
1566         } else {
1567                 pdbgpriv->dbg_resume_error_cnt++;
1568                 ret = -1;
1569                 goto exit;
1570         }
1571
1572         if (padapter->bDriverStopped || padapter->bSurpriseRemoved) {
1573                 DBG_871X("%s pdapter %p bDriverStopped %d bSurpriseRemoved %d\n",
1574                                 __func__, padapter, padapter->bDriverStopped,
1575                                 padapter->bSurpriseRemoved);
1576                 goto exit;
1577         }
1578
1579 #ifdef CONFIG_PNO_SUPPORT
1580         pwrpriv->pno_in_resume = true;
1581 #endif
1582
1583         if (pwrpriv->wowlan_mode == true) {
1584                 rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0, "WOWLAN");
1585
1586                 pwrpriv->bFwCurrentInPSMode = false;
1587
1588                 if (padapter->intf_stop) {
1589                         padapter->intf_stop(padapter);
1590                 }
1591
1592                 if (padapter->HalFunc.clear_interrupt)
1593                         padapter->HalFunc.clear_interrupt(padapter);
1594
1595                 /* if (sdio_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS) { */
1596                 if ((padapter->intf_alloc_irq) && (padapter->intf_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS)) {
1597                         ret = -1;
1598                         RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: sdio_alloc_irq Failed!!\n", __func__));
1599                         goto exit;
1600                 }
1601
1602                 /* Disable WOW, set H2C command */
1603                 poidparam.subcode = WOWLAN_DISABLE;
1604                 padapter->HalFunc.SetHwRegHandler(padapter, HW_VAR_WOWLAN, (u8 *)&poidparam);
1605
1606                 psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(&padapter->mlmepriv));
1607                 if (psta) {
1608                         set_sta_rate(padapter, psta);
1609                 }
1610
1611
1612                 padapter->bDriverStopped = false;
1613                 DBG_871X("%s: wowmode resuming, DriverStopped:%d\n", __func__, padapter->bDriverStopped);
1614                 rtw_start_drv_threads(padapter);
1615
1616                 if (padapter->intf_start) {
1617                         padapter->intf_start(padapter);
1618                 }
1619
1620                 /*  start netif queue */
1621                 if (pnetdev) {
1622                         if (!rtw_netif_queue_stopped(pnetdev))
1623                                 rtw_netif_start_queue(pnetdev);
1624                         else
1625                                 rtw_netif_wake_queue(pnetdev);
1626                 }
1627         }
1628         else {
1629                 DBG_871X_LEVEL(_drv_always_, "%s: ### ERROR ### wowlan_mode =%d\n", __func__, pwrpriv->wowlan_mode);
1630         }
1631
1632         if (padapter->pid[1] != 0) {
1633                 DBG_871X("pid[1]:%d\n", padapter->pid[1]);
1634                 rtw_signal_process(padapter->pid[1], SIGUSR2);
1635         }
1636
1637         if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
1638                 if (pwrpriv->wowlan_wake_reason == FWDecisionDisconnect ||
1639                         pwrpriv->wowlan_wake_reason == Rx_DisAssoc ||
1640                         pwrpriv->wowlan_wake_reason == Rx_DeAuth) {
1641                         DBG_871X("%s: disconnect reason: %02x\n", __func__,
1642                                                 pwrpriv->wowlan_wake_reason);
1643                         rtw_indicate_disconnect(padapter);
1644
1645                         rtw_sta_media_status_rpt(padapter,
1646                                 rtw_get_stainfo(&padapter->stapriv,
1647                                         get_bssid(&padapter->mlmepriv)), 0);
1648
1649                         rtw_free_assoc_resources(padapter, 1);
1650                         pmlmeinfo->state = WIFI_FW_NULL_STATE;
1651
1652                 } else {
1653                         DBG_871X("%s: do roaming\n", __func__);
1654                         rtw_roaming(padapter, NULL);
1655                 }
1656         }
1657
1658         if (pwrpriv->wowlan_mode == true) {
1659                 pwrpriv->bips_processing = false;
1660                 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
1661         } else {
1662                 DBG_871X_LEVEL(_drv_always_, "do not reset timer\n");
1663         }
1664
1665         pwrpriv->wowlan_mode = false;
1666
1667         /* clean driver side wake up reason. */
1668         pwrpriv->wowlan_wake_reason = 0;
1669 exit:
1670         DBG_871X("<== " FUNC_ADPT_FMT " exit....\n", FUNC_ADPT_ARG(padapter));
1671         return ret;
1672 }
1673 #endif /* ifdef CONFIG_WOWLAN */
1674
1675 #ifdef CONFIG_AP_WOWLAN
1676 int rtw_resume_process_ap_wow(struct adapter *padapter)
1677 {
1678         struct net_device *pnetdev = padapter->pnetdev;
1679         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1680         struct dvobj_priv *psdpriv = padapter->dvobj;
1681         struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
1682         struct wowlan_ioctl_param poidparam;
1683         int ret = _SUCCESS;
1684
1685         DBG_871X("==> " FUNC_ADPT_FMT " entry....\n", FUNC_ADPT_ARG(padapter));
1686
1687         if (padapter) {
1688                 pnetdev = padapter->pnetdev;
1689                 pwrpriv = adapter_to_pwrctl(padapter);
1690         } else {
1691                 pdbgpriv->dbg_resume_error_cnt++;
1692                 ret = -1;
1693                 goto exit;
1694         }
1695
1696         rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0, "AP-WOWLAN");
1697
1698         pwrpriv->bFwCurrentInPSMode = false;
1699
1700         rtw_hal_disable_interrupt(padapter);
1701
1702         if (padapter->HalFunc.clear_interrupt)
1703                 padapter->HalFunc.clear_interrupt(padapter);
1704
1705         /* if (sdio_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS) { */
1706         if ((padapter->intf_alloc_irq) && (padapter->intf_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS)) {
1707                 ret = -1;
1708                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: sdio_alloc_irq Failed!!\n", __func__));
1709                 goto exit;
1710         }
1711
1712         /* Disable WOW, set H2C command */
1713         poidparam.subcode = WOWLAN_AP_DISABLE;
1714         padapter->HalFunc.SetHwRegHandler(padapter,
1715                 HW_VAR_AP_WOWLAN, (u8 *)&poidparam);
1716         pwrpriv->wowlan_ap_mode = false;
1717
1718         padapter->bDriverStopped = false;
1719         DBG_871X("%s: wowmode resuming, DriverStopped:%d\n", __func__, padapter->bDriverStopped);
1720         rtw_start_drv_threads(padapter);
1721
1722         if (padapter->intf_start) {
1723                 padapter->intf_start(padapter);
1724         }
1725
1726         /*  start netif queue */
1727         if (pnetdev) {
1728                 if (!rtw_netif_queue_stopped(pnetdev))
1729                         rtw_netif_start_queue(pnetdev);
1730                 else
1731                         rtw_netif_wake_queue(pnetdev);
1732         }
1733
1734         if (padapter->pid[1] != 0) {
1735                 DBG_871X("pid[1]:%d\n", padapter->pid[1]);
1736                 rtw_signal_process(padapter->pid[1], SIGUSR2);
1737         }
1738
1739         pwrpriv->bips_processing = false;
1740         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
1741
1742         /* clean driver side wake up reason. */
1743         pwrpriv->wowlan_wake_reason = 0;
1744 exit:
1745         DBG_871X("<== " FUNC_ADPT_FMT " exit....\n", FUNC_ADPT_ARG(padapter));
1746         return ret;
1747 }
1748 #endif /* ifdef CONFIG_APWOWLAN */
1749
1750 static int rtw_resume_process_normal(struct adapter *padapter)
1751 {
1752         struct net_device *pnetdev;
1753         struct pwrctrl_priv *pwrpriv;
1754         struct mlme_priv *pmlmepriv;
1755         struct dvobj_priv *psdpriv;
1756         struct debug_priv *pdbgpriv;
1757
1758         int ret = _SUCCESS;
1759
1760         if (!padapter) {
1761                 ret = -1;
1762                 goto exit;
1763         }
1764
1765         pnetdev = padapter->pnetdev;
1766         pwrpriv = adapter_to_pwrctl(padapter);
1767         pmlmepriv = &padapter->mlmepriv;
1768         psdpriv = padapter->dvobj;
1769         pdbgpriv = &psdpriv->drv_dbg;
1770
1771         DBG_871X("==> " FUNC_ADPT_FMT " entry....\n", FUNC_ADPT_ARG(padapter));
1772         /*  interface init */
1773         /* if (sdio_init(adapter_to_dvobj(padapter)) != _SUCCESS) */
1774         if ((padapter->intf_init) && (padapter->intf_init(adapter_to_dvobj(padapter)) != _SUCCESS)) {
1775                 ret = -1;
1776                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: initialize SDIO Failed!!\n", __func__));
1777                 goto exit;
1778         }
1779         rtw_hal_disable_interrupt(padapter);
1780         /* if (sdio_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS) */
1781         if ((padapter->intf_alloc_irq) && (padapter->intf_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS)) {
1782                 ret = -1;
1783                 RT_TRACE(_module_hci_intfs_c_, _drv_err_, ("%s: sdio_alloc_irq Failed!!\n", __func__));
1784                 goto exit;
1785         }
1786
1787         rtw_reset_drv_sw(padapter);
1788         pwrpriv->bkeepfwalive = false;
1789
1790         DBG_871X("bkeepfwalive(%x)\n", pwrpriv->bkeepfwalive);
1791         if (pm_netdev_open(pnetdev, true) != 0) {
1792                 ret = -1;
1793                 pdbgpriv->dbg_resume_error_cnt++;
1794                 goto exit;
1795         }
1796
1797         netif_device_attach(pnetdev);
1798         netif_carrier_on(pnetdev);
1799
1800         if (padapter->pid[1] != 0) {
1801                 DBG_871X("pid[1]:%d\n", padapter->pid[1]);
1802                 rtw_signal_process(padapter->pid[1], SIGUSR2);
1803         }
1804
1805
1806         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
1807                 DBG_871X(FUNC_ADPT_FMT " fwstate:0x%08x - WIFI_STATION_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
1808
1809                 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME))
1810                         rtw_roaming(padapter, NULL);
1811
1812         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1813                 DBG_871X(FUNC_ADPT_FMT " fwstate:0x%08x - WIFI_AP_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
1814                 rtw_ap_restore_network(padapter);
1815         } else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
1816                 DBG_871X(FUNC_ADPT_FMT " fwstate:0x%08x - WIFI_ADHOC_STATE\n", FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
1817         } else {
1818                 DBG_871X(FUNC_ADPT_FMT " fwstate:0x%08x - ???\n", FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
1819         }
1820
1821         DBG_871X("<== " FUNC_ADPT_FMT " exit....\n", FUNC_ADPT_ARG(padapter));
1822
1823 exit:
1824         return ret;
1825 }
1826
1827 int rtw_resume_common(struct adapter *padapter)
1828 {
1829         int ret = 0;
1830         unsigned long start_time = jiffies;
1831         struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
1832         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1833
1834         DBG_871X_LEVEL(_drv_always_, "resume start\n");
1835         DBG_871X("==> %s (%s:%d)\n", __func__, current->comm, current->pid);
1836
1837         if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
1838         #ifdef CONFIG_WOWLAN
1839                 if (pwrpriv->wowlan_mode == true)
1840                         rtw_resume_process_wow(padapter);
1841                 else
1842                         rtw_resume_process_normal(padapter);
1843         #else
1844                 rtw_resume_process_normal(padapter);
1845         #endif
1846
1847         } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
1848         #ifdef CONFIG_AP_WOWLAN
1849                 rtw_resume_process_ap_wow(padapter);
1850         #else
1851                 rtw_resume_process_normal(padapter);
1852         #endif /* CONFIG_AP_WOWLAN */
1853         } else {
1854                 rtw_resume_process_normal(padapter);
1855         }
1856
1857         rtw_btcoex_SuspendNotify(padapter, 0);
1858
1859         if (pwrpriv) {
1860                 pwrpriv->bInSuspend = false;
1861         #ifdef CONFIG_PNO_SUPPORT
1862                 pwrpriv->pno_in_resume = false;
1863         #endif
1864         }
1865         DBG_871X_LEVEL(_drv_always_, "%s:%d in %d ms\n", __func__ , ret,
1866                 jiffies_to_msecs(jiffies - start_time));
1867
1868         return ret;
1869 }