drivers/staging/r8188eu/os_dep/os_intfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2007 - 2011 Realtek Corporation. */
   3
   4 #define _OS_INTFS_C_
   5
   6 #include "../include/osdep_service.h"
   7 #include "../include/drv_types.h"
   8 #include "../include/xmit_osdep.h"
   9 #include "../include/recv_osdep.h"
  10 #include "../include/hal_intf.h"
  11 #include "../include/rtw_ioctl.h"
  12 #include "../include/usb_osintf.h"
  13 #include "../include/rtw_br_ext.h"
  14 #include "../include/rtw_led.h"
  15 #include "../include/rtl8188e_dm.h"
  16
  17 MODULE_LICENSE("GPL");
  18 MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
  19 MODULE_AUTHOR("Realtek Semiconductor Corp.");
  20 MODULE_VERSION(DRIVERVERSION);
  21
  22 #define CONFIG_BR_EXT_BRNAME "br0"
  23 #define RTW_NOTCH_FILTER 0 /* 0:Disable, 1:Enable, */
  24
  25 /* module param defaults */
  26 static int rtw_chip_version = 0x00;
  27 static int rtw_rfintfs = HWPI;
  28 static int rtw_lbkmode;/* RTL8712_AIR_TRX; */
  29 static int rtw_network_mode = Ndis802_11IBSS;/* Ndis802_11Infrastructure; infra, ad-hoc, auto */
  30 static int rtw_channel = 1;/* ad-hoc support requirement */
  31 static int rtw_wireless_mode = WIRELESS_11BG_24N;
  32 static int rtw_vrtl_carrier_sense = AUTO_VCS;
  33 static int rtw_vcs_type = RTS_CTS;/*  */
  34 static int rtw_rts_thresh = 2347;/*  */
  35 static int rtw_frag_thresh = 2346;/*  */
  36 static int rtw_preamble = PREAMBLE_LONG;/* long, short, auto */
  37 static int rtw_scan_mode = 1;/* active, passive */
  38 static int rtw_adhoc_tx_pwr = 1;
  39 static int rtw_soft_ap;
  40 static int rtw_power_mgnt = 1;
  41 static int rtw_ips_mode = IPS_NORMAL;
  42
  43 static int rtw_smart_ps = 2;
  44
  45 module_param(rtw_ips_mode, int, 0644);
  46 MODULE_PARM_DESC(rtw_ips_mode, "The default IPS mode");
  47
  48 static int rtw_radio_enable = 1;
  49 static int rtw_long_retry_lmt = 7;
  50 static int rtw_short_retry_lmt = 7;
  51 static int rtw_busy_thresh = 40;
  52 static int rtw_ack_policy = NORMAL_ACK;
  53
  54 static int rtw_software_encrypt;
  55 static int rtw_software_decrypt;
  56
  57 static int rtw_acm_method;/*  0:By SW 1:By HW. */
  58
  59 static int rtw_wmm_enable = 1;/*  default is set to enable the wmm. */
  60 static int rtw_uapsd_enable;
  61 static int rtw_uapsd_max_sp = NO_LIMIT;
  62 static int rtw_uapsd_acbk_en;
  63 static int rtw_uapsd_acbe_en;
  64 static int rtw_uapsd_acvi_en;
  65 static int rtw_uapsd_acvo_en;
  66
  67 static int rtw_led_enable = 1;
  68
  69 int rtw_ht_enable = 1;
  70 int rtw_cbw40_enable = 3; /*  0 :disable, bit(0): enable 2.4g, bit(1): enable 5g */
  71 int rtw_ampdu_enable = 1;/* for enable tx_ampdu */
  72 static int rtw_rx_stbc = 1;/*  0: disable, bit(0):enable 2.4g, bit(1):enable 5g, default is set to enable 2.4GHZ for IOT issue with bufflao's AP at 5GHZ */
  73 static int rtw_ampdu_amsdu;/*  0: disabled, 1:enabled, 2:auto */
  74
  75 static int rtw_lowrate_two_xmit = 1;/* Use 2 path Tx to transmit MCS0~7 and legacy mode */
  76
  77 static int rtw_low_power;
  78 static int rtw_wifi_spec;
  79 static int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX;
  80 static int rtw_AcceptAddbaReq = true;/*  0:Reject AP's Add BA req, 1:Accept AP's Add BA req. */
  81
  82 static int rtw_antdiv_cfg = 2; /*  0:OFF , 1:ON, 2:decide by Efuse config */
  83 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) */
  84
  85
  86 static int rtw_hwpdn_mode = 2;/* 0:disable, 1:enable, 2: by EFUSE config */
  87
  88 static int rtw_hwpwrp_detect; /* HW power  ping detect 0:disable , 1:enable */
  89
  90 static int rtw_hw_wps_pbc = 1;
  91
  92 int rtw_mc2u_disable;
  93
  94 static int rtw_80211d;
  95
  96 static char *ifname = "wlan%d";
  97 module_param(ifname, charp, 0644);
  98 MODULE_PARM_DESC(ifname, "The default name to allocate for first interface");
  99
 100 static char *if2name = "wlan%d";
 101 module_param(if2name, charp, 0644);
 102 MODULE_PARM_DESC(if2name, "The default name to allocate for second interface");
 103
 104 char *rtw_initmac;  /*  temp mac address if users want to use instead of the mac address in Efuse */
 105
 106 module_param(rtw_initmac, charp, 0644);
 107 module_param(rtw_channel_plan, int, 0644);
 108 module_param(rtw_chip_version, int, 0644);
 109 module_param(rtw_rfintfs, int, 0644);
 110 module_param(rtw_lbkmode, int, 0644);
 111 module_param(rtw_network_mode, int, 0644);
 112 module_param(rtw_channel, int, 0644);
 113 module_param(rtw_wmm_enable, int, 0644);
 114 module_param(rtw_vrtl_carrier_sense, int, 0644);
 115 module_param(rtw_vcs_type, int, 0644);
 116 module_param(rtw_busy_thresh, int, 0644);
 117 module_param(rtw_led_enable, int, 0644);
 118 module_param(rtw_ht_enable, int, 0644);
 119 module_param(rtw_cbw40_enable, int, 0644);
 120 module_param(rtw_ampdu_enable, int, 0644);
 121 module_param(rtw_rx_stbc, int, 0644);
 122 module_param(rtw_ampdu_amsdu, int, 0644);
 123 module_param(rtw_lowrate_two_xmit, int, 0644);
 124 module_param(rtw_power_mgnt, int, 0644);
 125 module_param(rtw_smart_ps, int, 0644);
 126 module_param(rtw_low_power, int, 0644);
 127 module_param(rtw_wifi_spec, int, 0644);
 128 module_param(rtw_antdiv_cfg, int, 0644);
 129 module_param(rtw_antdiv_type, int, 0644);
 130 module_param(rtw_hwpdn_mode, int, 0644);
 131 module_param(rtw_hwpwrp_detect, int, 0644);
 132 module_param(rtw_hw_wps_pbc, int, 0644);
 133
 134 static uint rtw_max_roaming_times = 2;
 135 module_param(rtw_max_roaming_times, uint, 0644);
 136 MODULE_PARM_DESC(rtw_max_roaming_times, "The max roaming times to try");
 137
 138 static int rtw_fw_iol = 1;/*  0:Disable, 1:enable, 2:by usb speed */
 139 module_param(rtw_fw_iol, int, 0644);
 140 MODULE_PARM_DESC(rtw_fw_iol, "FW IOL");
 141
 142 module_param(rtw_mc2u_disable, int, 0644);
 143
 144 module_param(rtw_80211d, int, 0644);
 145 MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
 146
 147 static uint rtw_notch_filter = RTW_NOTCH_FILTER;
 148 module_param(rtw_notch_filter, uint, 0644);
 149 MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P");
 150
 151 static uint loadparam(struct adapter *padapter)
 152 {
 153         struct registry_priv  *registry_par = &padapter->registrypriv;
 154
 155         registry_par->chip_version = (u8)rtw_chip_version;
 156         registry_par->rfintfs = (u8)rtw_rfintfs;
 157         registry_par->lbkmode = (u8)rtw_lbkmode;
 158         registry_par->network_mode  = (u8)rtw_network_mode;
 159
 160         memcpy(registry_par->ssid.Ssid, "ANY", 3);
 161         registry_par->ssid.SsidLength = 3;
 162
 163         registry_par->channel = (u8)rtw_channel;
 164         registry_par->wireless_mode = (u8)rtw_wireless_mode;
 165         registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense;
 166         registry_par->vcs_type = (u8)rtw_vcs_type;
 167         registry_par->rts_thresh = (u16)rtw_rts_thresh;
 168         registry_par->frag_thresh = (u16)rtw_frag_thresh;
 169         registry_par->preamble = (u8)rtw_preamble;
 170         registry_par->scan_mode = (u8)rtw_scan_mode;
 171         registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr;
 172         registry_par->soft_ap =  (u8)rtw_soft_ap;
 173         registry_par->smart_ps =  (u8)rtw_smart_ps;
 174         registry_par->power_mgnt = (u8)rtw_power_mgnt;
 175         registry_par->ips_mode = (u8)rtw_ips_mode;
 176         registry_par->radio_enable = (u8)rtw_radio_enable;
 177         registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt;
 178         registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt;
 179         registry_par->busy_thresh = (u16)rtw_busy_thresh;
 180         registry_par->ack_policy = (u8)rtw_ack_policy;
 181         registry_par->software_encrypt = (u8)rtw_software_encrypt;
 182         registry_par->software_decrypt = (u8)rtw_software_decrypt;
 183         registry_par->acm_method = (u8)rtw_acm_method;
 184
 185          /* UAPSD */
 186         registry_par->wmm_enable = (u8)rtw_wmm_enable;
 187         registry_par->uapsd_enable = (u8)rtw_uapsd_enable;
 188         registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp;
 189         registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en;
 190         registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en;
 191         registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en;
 192         registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en;
 193
 194         registry_par->led_enable = (u8)rtw_led_enable;
 195
 196         registry_par->ht_enable = (u8)rtw_ht_enable;
 197         registry_par->cbw40_enable = (u8)rtw_cbw40_enable;
 198         registry_par->ampdu_enable = (u8)rtw_ampdu_enable;
 199         registry_par->rx_stbc = (u8)rtw_rx_stbc;
 200         registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu;
 201         registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit;
 202         registry_par->low_power = (u8)rtw_low_power;
 203         registry_par->wifi_spec = (u8)rtw_wifi_spec;
 204         registry_par->channel_plan = (u8)rtw_channel_plan;
 205         registry_par->bAcceptAddbaReq = (u8)rtw_AcceptAddbaReq;
 206         registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg;
 207         registry_par->antdiv_type = (u8)rtw_antdiv_type;
 208         registry_par->hwpdn_mode = (u8)rtw_hwpdn_mode;/* 0:disable, 1:enable, 2:by EFUSE config */
 209         registry_par->hwpwrp_detect = (u8)rtw_hwpwrp_detect;/* 0:disable, 1:enable */
 210         registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc;
 211
 212         registry_par->max_roaming_times = (u8)rtw_max_roaming_times;
 213
 214         registry_par->fw_iol = rtw_fw_iol;
 215
 216         registry_par->enable80211d = (u8)rtw_80211d;
 217         snprintf(registry_par->ifname, 16, "%s", ifname);
 218         snprintf(registry_par->if2name, 16, "%s", if2name);
 219         registry_par->notch_filter = (u8)rtw_notch_filter;
 220
 221         return _SUCCESS;
 222 }
 223
 224 static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p)
 225 {
 226         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
 227         struct sockaddr *addr = p;
 228
 229         if (!padapter->bup)
 230                 memcpy(padapter->eeprompriv.mac_addr, addr->sa_data, ETH_ALEN);
 231
 232         return 0;
 233 }
 234
 235 static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
 236 {
 237         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
 238         struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
 239         struct recv_priv *precvpriv = &padapter->recvpriv;
 240
 241         padapter->stats.tx_packets = pxmitpriv->tx_pkts;/* pxmitpriv->tx_pkts++; */
 242         padapter->stats.rx_packets = precvpriv->rx_pkts;/* precvpriv->rx_pkts++; */
 243         padapter->stats.tx_dropped = pxmitpriv->tx_drop;
 244         padapter->stats.rx_dropped = precvpriv->rx_drop;
 245         padapter->stats.tx_bytes = pxmitpriv->tx_bytes;
 246         padapter->stats.rx_bytes = precvpriv->rx_bytes;
 247         return &padapter->stats;
 248 }
 249
 250 /*
 251  * AC to queue mapping
 252  *
 253  * AC_VO -> queue 0
 254  * AC_VI -> queue 1
 255  * AC_BE -> queue 2
 256  * AC_BK -> queue 3
 257  */
 258 static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
 259
 260 /* Given a data frame determine the 802.1p/1d tag to use. */
 261 static unsigned int rtw_classify8021d(struct sk_buff *skb)
 262 {
 263         unsigned int dscp;
 264
 265         /* skb->priority values from 256->263 are magic values to
 266          * directly indicate a specific 802.1d priority.  This is used
 267          * to allow 802.1d priority to be passed directly in from VLAN
 268          * tags, etc.
 269          */
 270         if (skb->priority >= 256 && skb->priority <= 263)
 271                 return skb->priority - 256;
 272
 273         switch (skb->protocol) {
 274         case htons(ETH_P_IP):
 275                 dscp = ip_hdr(skb)->tos & 0xfc;
 276                 break;
 277         default:
 278                 return 0;
 279         }
 280
 281         return dscp >> 5;
 282 }
 283
 284 static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb, struct net_device *sb_dev)
 285 {
 286         struct adapter  *padapter = rtw_netdev_priv(dev);
 287         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 288
 289         skb->priority = rtw_classify8021d(skb);
 290
 291         if (pmlmepriv->acm_mask != 0)
 292                 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
 293
 294         return rtw_1d_to_queue[skb->priority];
 295 }
 296
 297 u16 rtw_recv_select_queue(struct sk_buff *skb)
 298 {
 299         struct iphdr *piphdr;
 300         unsigned int dscp;
 301         __be16  eth_type;
 302         u32 priority;
 303         u8 *pdata = skb->data;
 304
 305         memcpy(&eth_type, pdata + (ETH_ALEN << 1), 2);
 306
 307         switch (eth_type) {
 308         case htons(ETH_P_IP):
 309                 piphdr = (struct iphdr *)(pdata + ETH_HLEN);
 310                 dscp = piphdr->tos & 0xfc;
 311                 priority = dscp >> 5;
 312                 break;
 313         default:
 314                 priority = 0;
 315         }
 316
 317         return rtw_1d_to_queue[priority];
 318 }
 319
 320 static const struct net_device_ops rtw_netdev_ops = {
 321         .ndo_open = netdev_open,
 322         .ndo_stop = netdev_close,
 323         .ndo_start_xmit = rtw_xmit_entry,
 324         .ndo_select_queue       = rtw_select_queue,
 325         .ndo_set_mac_address = rtw_net_set_mac_address,
 326         .ndo_get_stats = rtw_net_get_stats,
 327 };
 328
 329 int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
 330 {
 331         int err;
 332
 333         err = dev_alloc_name(pnetdev, ifname);
 334         if (err < 0)
 335                 return err;
 336
 337         netif_carrier_off(pnetdev);
 338         return 0;
 339 }
 340
 341 static const struct device_type wlan_type = {
 342         .name = "wlan",
 343 };
 344
 345 struct net_device *rtw_init_netdev(struct adapter *old_padapter)
 346 {
 347         struct adapter *padapter;
 348         struct net_device *pnetdev;
 349
 350         if (old_padapter)
 351                 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(struct adapter), (void *)old_padapter);
 352         else
 353                 pnetdev = rtw_alloc_etherdev(sizeof(struct adapter));
 354
 355         if (!pnetdev)
 356                 return NULL;
 357
 358         pnetdev->dev.type = &wlan_type;
 359         padapter = rtw_netdev_priv(pnetdev);
 360         padapter->pnetdev = pnetdev;
 361         pnetdev->netdev_ops = &rtw_netdev_ops;
 362         pnetdev->watchdog_timeo = HZ * 3; /* 3 second timeout */
 363         pnetdev->wireless_handlers = (struct iw_handler_def *)&rtw_handlers_def;
 364
 365         /* step 2. */
 366         loadparam(padapter);
 367
 368         return pnetdev;
 369 }
 370
 371 u32 rtw_start_drv_threads(struct adapter *padapter)
 372 {
 373         u32 _status = _SUCCESS;
 374
 375         padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
 376         if (IS_ERR(padapter->cmdThread))
 377                 _status = _FAIL;
 378         else
 379                 /* wait for rtw_cmd_thread() to start running */
 380                 wait_for_completion(&padapter->cmdpriv.start_cmd_thread);
 381
 382         return _status;
 383 }
 384
 385 void rtw_stop_drv_threads(struct adapter *padapter)
 386 {
 387         /* Below is to termindate rtw_cmd_thread & event_thread... */
 388         complete(&padapter->cmdpriv.enqueue_cmd);
 389         if (padapter->cmdThread)
 390                 /* wait for rtw_cmd_thread() to stop running */
 391                 wait_for_completion(&padapter->cmdpriv.stop_cmd_thread);
 392 }
 393
 394 static void rtw_init_default_value(struct adapter *padapter)
 395 {
 396         struct registry_priv *pregistrypriv = &padapter->registrypriv;
 397         struct xmit_priv        *pxmitpriv = &padapter->xmitpriv;
 398         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 399         struct security_priv *psecuritypriv = &padapter->securitypriv;
 400
 401         /* xmit_priv */
 402         pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
 403         pxmitpriv->vcs = pregistrypriv->vcs_type;
 404         pxmitpriv->vcs_type = pregistrypriv->vcs_type;
 405         pxmitpriv->frag_len = pregistrypriv->frag_thresh;
 406
 407         /* mlme_priv */
 408         pmlmepriv->scan_interval = SCAN_INTERVAL;/*  30*2 sec = 60sec */
 409         pmlmepriv->scan_mode = SCAN_ACTIVE;
 410
 411         /* ht_priv */
 412         pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */
 413
 414         /* security_priv */
 415         psecuritypriv->binstallGrpkey = _FAIL;
 416         psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt;
 417         psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt;
 418         psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
 419         psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
 420         psecuritypriv->dot11PrivacyKeyIndex = 0;
 421         psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
 422         psecuritypriv->dot118021XGrpKeyid = 1;
 423         psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
 424         psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
 425
 426         /* registry_priv */
 427         rtw_init_registrypriv_dev_network(padapter);
 428         rtw_update_registrypriv_dev_network(padapter);
 429
 430         /* hal_priv */
 431         rtl8188eu_init_default_value(padapter);
 432
 433         /* misc. */
 434         padapter->bReadPortCancel = false;
 435         padapter->bWritePortCancel = false;
 436         padapter->bRxRSSIDisplay = 0;
 437         padapter->bNotifyChannelChange = 0;
 438         padapter->bShowGetP2PState = 1;
 439 }
 440
 441 u8 rtw_reset_drv_sw(struct adapter *padapter)
 442 {
 443         struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
 444
 445         /* hal_priv */
 446         rtl8188eu_init_default_value(padapter);
 447         padapter->bReadPortCancel = false;
 448         padapter->bWritePortCancel = false;
 449         padapter->bRxRSSIDisplay = 0;
 450         pmlmepriv->scan_interval = SCAN_INTERVAL;/*  30*2 sec = 60sec */
 451
 452         padapter->xmitpriv.tx_pkts = 0;
 453         padapter->recvpriv.rx_pkts = 0;
 454
 455         pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
 456
 457         _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING);
 458
 459         /* mlmeextpriv */
 460         padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE;
 461
 462         rtw_set_signal_stat_timer(&padapter->recvpriv);
 463
 464         return _SUCCESS;
 465 }
 466
 467 u8 rtw_init_drv_sw(struct adapter *padapter)
 468 {
 469         if ((rtw_init_cmd_priv(&padapter->cmdpriv)) == _FAIL) {
 470                 dev_err(dvobj_to_dev(padapter->dvobj), "rtw_init_cmd_priv failed\n");
 471                 return _FAIL;
 472         }
 473
 474         padapter->cmdpriv.padapter = padapter;
 475
 476         if ((rtw_init_evt_priv(&padapter->evtpriv)) == _FAIL) {
 477                 dev_err(dvobj_to_dev(padapter->dvobj), "rtw_init_evt_priv failed\n");
 478                 goto free_cmd_priv;
 479         }
 480
 481         if (rtw_init_mlme_priv(padapter) == _FAIL) {
 482                 dev_err(dvobj_to_dev(padapter->dvobj), "rtw_init_mlme_priv failed\n");
 483                 goto free_evt_priv;
 484         }
 485
 486         rtw_init_wifidirect_timers(padapter);
 487         init_wifidirect_info(padapter, P2P_ROLE_DISABLE);
 488         reset_global_wifidirect_info(padapter);
 489
 490         init_mlme_ext_priv(padapter);
 491
 492         if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL) {
 493                 dev_err(dvobj_to_dev(padapter->dvobj), "_rtw_init_xmit_priv failed\n");
 494                 goto free_mlme_ext;
 495         }
 496
 497         if (_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL) {
 498                 dev_err(dvobj_to_dev(padapter->dvobj), "_rtw_init_recv_priv failed\n");
 499                 goto free_xmit_priv;
 500         }
 501
 502         if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL) {
 503                 dev_err(dvobj_to_dev(padapter->dvobj), "_rtw_init_sta_priv failed\n");
 504                 goto free_recv_priv;
 505         }
 506
 507         padapter->stapriv.padapter = padapter;
 508
 509         rtw_init_bcmc_stainfo(padapter);
 510
 511         rtw_init_pwrctrl_priv(padapter);
 512
 513         rtw_init_default_value(padapter);
 514
 515         rtl8188e_init_dm_priv(padapter);
 516         rtl8188eu_InitSwLeds(padapter);
 517
 518         spin_lock_init(&padapter->br_ext_lock);
 519
 520         return _SUCCESS;
 521
 522 free_recv_priv:
 523         _rtw_free_recv_priv(&padapter->recvpriv);
 524
 525 free_xmit_priv:
 526         _rtw_free_xmit_priv(&padapter->xmitpriv);
 527
 528 free_mlme_ext:
 529         free_mlme_ext_priv(&padapter->mlmeextpriv);
 530
 531         rtw_free_mlme_priv(&padapter->mlmepriv);
 532
 533 free_evt_priv:
 534         rtw_free_evt_priv(&padapter->evtpriv);
 535
 536 free_cmd_priv:
 537         rtw_free_cmd_priv(&padapter->cmdpriv);
 538
 539         return _FAIL;
 540 }
 541
 542 void rtw_cancel_all_timer(struct adapter *padapter)
 543 {
 544         _cancel_timer_ex(&padapter->mlmepriv.assoc_timer);
 545
 546         _cancel_timer_ex(&padapter->mlmepriv.scan_to_timer);
 547
 548         _cancel_timer_ex(&padapter->mlmepriv.dynamic_chk_timer);
 549
 550         /*  cancel sw led timer */
 551         rtl8188eu_DeInitSwLeds(padapter);
 552
 553         _cancel_timer_ex(&padapter->pwrctrlpriv.pwr_state_check_timer);
 554
 555         _cancel_timer_ex(&padapter->recvpriv.signal_stat_timer);
 556 }
 557
 558 u8 rtw_free_drv_sw(struct adapter *padapter)
 559 {
 560         /* we can call rtw_p2p_enable here, but: */
 561         /*  1. rtw_p2p_enable may have IO operation */
 562         /*  2. rtw_p2p_enable is bundled with wext interface */
 563         {
 564                 struct wifidirect_info *pwdinfo = &padapter->wdinfo;
 565                 if (!rtw_p2p_chk_state(pwdinfo, P2P_STATE_NONE)) {
 566                         _cancel_timer_ex(&pwdinfo->find_phase_timer);
 567                         _cancel_timer_ex(&pwdinfo->restore_p2p_state_timer);
 568                         _cancel_timer_ex(&pwdinfo->pre_tx_scan_timer);
 569                         rtw_p2p_set_state(pwdinfo, P2P_STATE_NONE);
 570                 }
 571         }
 572
 573         free_mlme_ext_priv(&padapter->mlmeextpriv);
 574
 575         rtw_free_cmd_priv(&padapter->cmdpriv);
 576
 577         rtw_free_evt_priv(&padapter->evtpriv);
 578
 579         rtw_free_mlme_priv(&padapter->mlmepriv);
 580         _rtw_free_xmit_priv(&padapter->xmitpriv);
 581
 582         _rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */
 583
 584         _rtw_free_recv_priv(&padapter->recvpriv);
 585
 586         /* free the old_pnetdev */
 587         if (padapter->rereg_nd_name_priv.old_pnetdev) {
 588                 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
 589                 padapter->rereg_nd_name_priv.old_pnetdev = NULL;
 590         }
 591
 592         /*  clear pbuddystruct adapter to avoid access wrong pointer. */
 593         if (padapter->pbuddy_adapter)
 594                 padapter->pbuddy_adapter->pbuddy_adapter = NULL;
 595
 596         return _SUCCESS;
 597 }
 598
 599 void netdev_br_init(struct net_device *netdev)
 600 {
 601         struct adapter *adapter = (struct adapter *)rtw_netdev_priv(netdev);
 602
 603         rcu_read_lock();
 604
 605         if (rcu_dereference(adapter->pnetdev->rx_handler_data)) {
 606                 struct net_device *br_netdev;
 607                 struct net *devnet = NULL;
 608
 609                 devnet = dev_net(netdev);
 610                 br_netdev = dev_get_by_name(devnet, CONFIG_BR_EXT_BRNAME);
 611                 if (br_netdev) {
 612                         memcpy(adapter->br_mac, br_netdev->dev_addr, ETH_ALEN);
 613                         dev_put(br_netdev);
 614                 } else {
 615                         pr_info("%s()-%d: dev_get_by_name(%s) failed!",
 616                                 __func__, __LINE__, CONFIG_BR_EXT_BRNAME);
 617                 }
 618         }
 619         adapter->ethBrExtInfo.addPPPoETag = 1;
 620
 621         rcu_read_unlock();
 622 }
 623
 624 int _netdev_open(struct net_device *pnetdev)
 625 {
 626         uint status;
 627         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
 628
 629         if (!padapter->bup) {
 630                 padapter->bDriverStopped = false;
 631                 padapter->bSurpriseRemoved = false;
 632                 padapter->bCardDisableWOHSM = false;
 633
 634                 status = rtw_hal_init(padapter);
 635                 if (status == _FAIL)
 636                         goto netdev_open_error;
 637
 638                 pr_info("MAC Address = %pM\n", pnetdev->dev_addr);
 639
 640                 status = rtw_start_drv_threads(padapter);
 641                 if (status == _FAIL) {
 642                         pr_info("Initialize driver software resource Failed!\n");
 643                         goto netdev_open_error;
 644                 }
 645
 646                 if (init_hw_mlme_ext(padapter) == _FAIL) {
 647                         pr_info("can't init mlme_ext_priv\n");
 648                         goto netdev_open_error;
 649                 }
 650                 if (padapter->intf_start)
 651                         padapter->intf_start(padapter);
 652
 653                 rtw_led_control(padapter, LED_CTL_NO_LINK);
 654
 655                 padapter->bup = true;
 656         }
 657         padapter->net_closed = false;
 658
 659         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
 660
 661         padapter->pwrctrlpriv.bips_processing = false;
 662         rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
 663
 664         if (!rtw_netif_queue_stopped(pnetdev))
 665                 netif_tx_start_all_queues(pnetdev);
 666         else
 667                 netif_tx_wake_all_queues(pnetdev);
 668
 669         netdev_br_init(pnetdev);
 670
 671         return 0;
 672
 673 netdev_open_error:
 674         padapter->bup = false;
 675         netif_carrier_off(pnetdev);
 676         netif_tx_stop_all_queues(pnetdev);
 677         return -1;
 678 }
 679
 680 int netdev_open(struct net_device *pnetdev)
 681 {
 682         int ret;
 683         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
 684
 685         mutex_lock(padapter->hw_init_mutex);
 686         ret = _netdev_open(pnetdev);
 687         mutex_unlock(padapter->hw_init_mutex);
 688         return ret;
 689 }
 690
 691 static int  ips_netdrv_open(struct adapter *padapter)
 692 {
 693         int status = _SUCCESS;
 694         padapter->net_closed = false;
 695
 696         padapter->bDriverStopped = false;
 697         padapter->bSurpriseRemoved = false;
 698         padapter->bCardDisableWOHSM = false;
 699
 700         status = rtw_hal_init(padapter);
 701         if (status == _FAIL)
 702                 goto netdev_open_error;
 703
 704         if (padapter->intf_start)
 705                 padapter->intf_start(padapter);
 706
 707         rtw_set_pwr_state_check_timer(&padapter->pwrctrlpriv);
 708         _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 5000);
 709
 710         return _SUCCESS;
 711
 712 netdev_open_error:
 713         return _FAIL;
 714 }
 715
 716 int rtw_ips_pwr_up(struct adapter *padapter)
 717 {
 718         int result;
 719         rtw_reset_drv_sw(padapter);
 720
 721         result = ips_netdrv_open(padapter);
 722
 723         rtw_led_control(padapter, LED_CTL_NO_LINK);
 724
 725         return result;
 726 }
 727
 728 void rtw_ips_pwr_down(struct adapter *padapter)
 729 {
 730         padapter->bCardDisableWOHSM = true;
 731         padapter->net_closed = true;
 732
 733         rtw_led_control(padapter, LED_CTL_POWER_OFF);
 734
 735         rtw_ips_dev_unload(padapter);
 736         padapter->bCardDisableWOHSM = false;
 737 }
 738
 739 static void rtw_fifo_cleanup(struct adapter *adapter)
 740 {
 741         struct pwrctrl_priv *pwrpriv = &adapter->pwrctrlpriv;
 742         u8 trycnt = 100;
 743
 744         /* pause tx */
 745         rtw_write8(adapter, REG_TXPAUSE, 0xff);
 746
 747         /* keep sn */
 748         adapter->xmitpriv.nqos_ssn = rtw_read16(adapter, REG_NQOS_SEQ);
 749
 750         if (!pwrpriv->bkeepfwalive) {
 751                 /* RX DMA stop */
 752                 rtw_write32(adapter, REG_RXPKT_NUM,
 753                             (rtw_read32(adapter, REG_RXPKT_NUM) | RW_RELEASE_EN));
 754                 do {
 755                         if (!(rtw_read32(adapter, REG_RXPKT_NUM) & RXDMA_IDLE))
 756                                 break;
 757                 } while (trycnt--);
 758
 759                 /* RQPN Load 0 */
 760                 rtw_write16(adapter, REG_RQPN_NPQ, 0x0);
 761                 rtw_write32(adapter, REG_RQPN, 0x80000000);
 762                 mdelay(10);
 763         }
 764 }
 765
 766 void rtw_ips_dev_unload(struct adapter *padapter)
 767 {
 768         rtw_fifo_cleanup(padapter);
 769
 770         if (padapter->intf_stop)
 771                 padapter->intf_stop(padapter);
 772
 773         /* s5. */
 774         if (!padapter->bSurpriseRemoved)
 775                 rtw_hal_deinit(padapter);
 776 }
 777
 778 int netdev_close(struct net_device *pnetdev)
 779 {
 780         struct adapter *padapter = (struct adapter *)rtw_netdev_priv(pnetdev);
 781         struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
 782
 783         padapter->net_closed = true;
 784
 785         if (padapter->pwrctrlpriv.rf_pwrstate == rf_on) {
 786                 /* s1. */
 787                 if (pnetdev) {
 788                         if (!rtw_netif_queue_stopped(pnetdev))
 789                                 netif_tx_stop_all_queues(pnetdev);
 790                 }
 791
 792                 /* s2. */
 793                 LeaveAllPowerSaveMode(padapter);
 794                 rtw_disassoc_cmd(padapter, 500, false);
 795                 /* s2-2.  indicate disconnect to os */
 796                 rtw_indicate_disconnect(padapter);
 797                 /* s2-3. */
 798                 rtw_free_assoc_resources(padapter, 1);
 799                 /* s2-4. */
 800                 rtw_free_network_queue(padapter, true);
 801                 /*  Close LED */
 802                 rtw_led_control(padapter, LED_CTL_POWER_OFF);
 803         }
 804
 805         nat25_db_cleanup(padapter);
 806
 807         rtw_p2p_enable(padapter, P2P_ROLE_DISABLE);
 808
 809         kfree(dvobj->firmware.data);
 810         dvobj->firmware.data = NULL;
 811
 812         return 0;
 813 }