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