1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * 4 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved. 5 * 6 ******************************************************************************/ 7 #include <drv_types.h> 8 #include <hal_data.h> 9 #include <rtl8723b_xmit.h> 10 11 MODULE_LICENSE("GPL"); 12 MODULE_DESCRIPTION("Realtek Wireless Lan Driver"); 13 MODULE_AUTHOR("Realtek Semiconductor Corp."); 14 MODULE_VERSION(DRIVERVERSION); 15 16 /* module param defaults */ 17 static int rtw_chip_version; 18 static int rtw_rfintfs = HWPI; 19 static int rtw_lbkmode;/* RTL8712_AIR_TRX; */ 20 21 22 static int rtw_network_mode = Ndis802_11IBSS;/* Ndis802_11Infrastructure;infra, ad-hoc, auto */ 23 /* struct ndis_802_11_ssid ssid; */ 24 static int rtw_channel = 1;/* ad-hoc support requirement */ 25 static int rtw_wireless_mode = WIRELESS_11BG_24N; 26 static int rtw_vrtl_carrier_sense = AUTO_VCS; 27 static int rtw_vcs_type = RTS_CTS;/* */ 28 static int rtw_rts_thresh = 2347;/* */ 29 static int rtw_frag_thresh = 2346;/* */ 30 static int rtw_preamble = PREAMBLE_LONG;/* long, short, auto */ 31 static int rtw_scan_mode = 1;/* active, passive */ 32 static int rtw_adhoc_tx_pwr = 1; 33 static int rtw_soft_ap; 34 /* int smart_ps = 1; */ 35 static int rtw_power_mgnt = 1; 36 static int rtw_ips_mode = IPS_NORMAL; 37 module_param(rtw_ips_mode, int, 0644); 38 MODULE_PARM_DESC(rtw_ips_mode, "The default IPS mode"); 39 40 static int rtw_smart_ps = 2; 41 42 static int rtw_check_fw_ps = 1; 43 44 static int rtw_usb_rxagg_mode = 2;/* USB_RX_AGG_DMA = 1, USB_RX_AGG_USB =2 */ 45 module_param(rtw_usb_rxagg_mode, int, 0644); 46 47 static int rtw_radio_enable = 1; 48 static int rtw_long_retry_lmt = 7; 49 static int rtw_short_retry_lmt = 7; 50 static int rtw_busy_thresh = 40; 51 /* int qos_enable = 0; */ 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 int rtw_ht_enable = 1; 68 /* 69 * 0: 20 MHz, 1: 40 MHz 70 * 2.4G use bit 0 ~ 3 71 * 0x01 means enable 2.4G 40MHz 72 */ 73 static int rtw_bw_mode = 0x01; 74 static int rtw_ampdu_enable = 1;/* for enable tx_ampdu ,0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec) */ 75 static int rtw_rx_stbc = 1;/* 0: disable, 1:enable 2.4g */ 76 static int rtw_ampdu_amsdu;/* 0: disabled, 1:enabled, 2:auto . There is an IOT issu with DLINK DIR-629 when the flag turn on */ 77 /* Short GI support Bit Map */ 78 /* BIT0 - 20MHz, 0: non-support, 1: support */ 79 /* BIT1 - 40MHz, 0: non-support, 1: support */ 80 /* BIT2 - 80MHz, 0: non-support, 1: support */ 81 /* BIT3 - 160MHz, 0: non-support, 1: support */ 82 static int rtw_short_gi = 0xf; 83 /* BIT0: Enable VHT LDPC Rx, BIT1: Enable VHT LDPC Tx, BIT4: Enable HT LDPC Rx, BIT5: Enable HT LDPC Tx */ 84 static int rtw_ldpc_cap = 0x33; 85 /* BIT0: Enable VHT STBC Rx, BIT1: Enable VHT STBC Tx, BIT4: Enable HT STBC Rx, BIT5: Enable HT STBC Tx */ 86 static int rtw_stbc_cap = 0x13; 87 /* BIT0: Enable VHT Beamformer, BIT1: Enable VHT Beamformee, BIT4: Enable HT Beamformer, BIT5: Enable HT Beamformee */ 88 static int rtw_beamform_cap = 0x2; 89 90 static int rtw_lowrate_two_xmit = 1;/* Use 2 path Tx to transmit MCS0~7 and legacy mode */ 91 92 static int rtw_low_power; 93 static int rtw_wifi_spec; 94 static int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX; 95 96 static int rtw_ant_num = -1; /* <0: undefined, >0: Antenna number */ 97 module_param(rtw_ant_num, int, 0644); 98 MODULE_PARM_DESC(rtw_ant_num, "Antenna number setting"); 99 100 static int rtw_antdiv_cfg = 1; /* 0:OFF , 1:ON, 2:decide by Efuse config */ 101 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) */ 102 103 static int rtw_hw_wps_pbc; 104 105 int rtw_mc2u_disable; 106 107 static int rtw_80211d; 108 109 static int rtw_qos_opt_enable;/* 0: disable, 1:enable */ 110 module_param(rtw_qos_opt_enable, int, 0644); 111 112 static char *ifname = "wlan%d"; 113 module_param(ifname, charp, 0644); 114 MODULE_PARM_DESC(ifname, "The default name to allocate for first interface"); 115 116 char *rtw_initmac; /* temp mac address if users want to use instead of the mac address in Efuse */ 117 118 module_param(rtw_initmac, charp, 0644); 119 module_param(rtw_channel_plan, int, 0644); 120 module_param(rtw_chip_version, int, 0644); 121 module_param(rtw_rfintfs, int, 0644); 122 module_param(rtw_lbkmode, int, 0644); 123 module_param(rtw_network_mode, int, 0644); 124 module_param(rtw_channel, int, 0644); 125 module_param(rtw_wmm_enable, int, 0644); 126 module_param(rtw_vrtl_carrier_sense, int, 0644); 127 module_param(rtw_vcs_type, int, 0644); 128 module_param(rtw_busy_thresh, int, 0644); 129 130 module_param(rtw_ht_enable, int, 0644); 131 module_param(rtw_bw_mode, int, 0644); 132 module_param(rtw_ampdu_enable, int, 0644); 133 module_param(rtw_rx_stbc, int, 0644); 134 module_param(rtw_ampdu_amsdu, int, 0644); 135 136 module_param(rtw_lowrate_two_xmit, int, 0644); 137 138 module_param(rtw_power_mgnt, int, 0644); 139 module_param(rtw_smart_ps, int, 0644); 140 module_param(rtw_low_power, int, 0644); 141 module_param(rtw_wifi_spec, int, 0644); 142 143 module_param(rtw_antdiv_cfg, int, 0644); 144 module_param(rtw_antdiv_type, int, 0644); 145 146 147 module_param(rtw_hw_wps_pbc, int, 0644); 148 149 static uint rtw_max_roaming_times = 2; 150 module_param(rtw_max_roaming_times, uint, 0644); 151 MODULE_PARM_DESC(rtw_max_roaming_times, "The max roaming times to try"); 152 153 module_param(rtw_mc2u_disable, int, 0644); 154 155 module_param(rtw_80211d, int, 0644); 156 MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism"); 157 158 static uint rtw_notch_filter; 159 module_param(rtw_notch_filter, uint, 0644); 160 MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P"); 161 162 #define CONFIG_RTW_HIQ_FILTER 1 163 164 static uint rtw_hiq_filter = CONFIG_RTW_HIQ_FILTER; 165 module_param(rtw_hiq_filter, uint, 0644); 166 MODULE_PARM_DESC(rtw_hiq_filter, "0:allow all, 1:allow special, 2:deny all"); 167 168 static int rtw_tx_pwr_lmt_enable; 169 static int rtw_tx_pwr_by_rate; 170 171 module_param(rtw_tx_pwr_lmt_enable, int, 0644); 172 MODULE_PARM_DESC(rtw_tx_pwr_lmt_enable, "0:Disable, 1:Enable, 2: Depend on efuse"); 173 174 module_param(rtw_tx_pwr_by_rate, int, 0644); 175 MODULE_PARM_DESC(rtw_tx_pwr_by_rate, "0:Disable, 1:Enable, 2: Depend on efuse"); 176 177 static int netdev_close(struct net_device *pnetdev); 178 179 static void loadparam(struct adapter *padapter, struct net_device *pnetdev) 180 { 181 struct registry_priv *registry_par = &padapter->registrypriv; 182 183 registry_par->chip_version = (u8)rtw_chip_version; 184 registry_par->rfintfs = (u8)rtw_rfintfs; 185 registry_par->lbkmode = (u8)rtw_lbkmode; 186 /* registry_par->hci = (u8)hci; */ 187 registry_par->network_mode = (u8)rtw_network_mode; 188 189 memcpy(registry_par->ssid.ssid, "ANY", 3); 190 registry_par->ssid.ssid_length = 3; 191 192 registry_par->channel = (u8)rtw_channel; 193 registry_par->wireless_mode = (u8)rtw_wireless_mode; 194 195 registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense; 196 registry_par->vcs_type = (u8)rtw_vcs_type; 197 registry_par->rts_thresh = (u16)rtw_rts_thresh; 198 registry_par->frag_thresh = (u16)rtw_frag_thresh; 199 registry_par->preamble = (u8)rtw_preamble; 200 registry_par->scan_mode = (u8)rtw_scan_mode; 201 registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr; 202 registry_par->soft_ap = (u8)rtw_soft_ap; 203 registry_par->smart_ps = (u8)rtw_smart_ps; 204 registry_par->check_fw_ps = (u8)rtw_check_fw_ps; 205 registry_par->power_mgnt = (u8)rtw_power_mgnt; 206 registry_par->ips_mode = (u8)rtw_ips_mode; 207 registry_par->radio_enable = (u8)rtw_radio_enable; 208 registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt; 209 registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt; 210 registry_par->busy_thresh = (u16)rtw_busy_thresh; 211 /* registry_par->qos_enable = (u8)rtw_qos_enable; */ 212 registry_par->ack_policy = (u8)rtw_ack_policy; 213 registry_par->software_encrypt = (u8)rtw_software_encrypt; 214 registry_par->software_decrypt = (u8)rtw_software_decrypt; 215 216 registry_par->acm_method = (u8)rtw_acm_method; 217 registry_par->usb_rxagg_mode = (u8)rtw_usb_rxagg_mode; 218 219 /* UAPSD */ 220 registry_par->wmm_enable = (u8)rtw_wmm_enable; 221 registry_par->uapsd_enable = (u8)rtw_uapsd_enable; 222 registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp; 223 registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en; 224 registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en; 225 registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en; 226 registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en; 227 228 registry_par->ht_enable = (u8)rtw_ht_enable; 229 registry_par->bw_mode = (u8)rtw_bw_mode; 230 registry_par->ampdu_enable = (u8)rtw_ampdu_enable; 231 registry_par->rx_stbc = (u8)rtw_rx_stbc; 232 registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu; 233 registry_par->short_gi = (u8)rtw_short_gi; 234 registry_par->ldpc_cap = (u8)rtw_ldpc_cap; 235 registry_par->stbc_cap = (u8)rtw_stbc_cap; 236 registry_par->beamform_cap = (u8)rtw_beamform_cap; 237 238 registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit; 239 registry_par->low_power = (u8)rtw_low_power; 240 241 242 registry_par->wifi_spec = (u8)rtw_wifi_spec; 243 244 registry_par->channel_plan = (u8)rtw_channel_plan; 245 246 registry_par->ant_num = (s8)rtw_ant_num; 247 248 registry_par->accept_addba_req = true; 249 250 registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg; 251 registry_par->antdiv_type = (u8)rtw_antdiv_type; 252 253 registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc; 254 255 registry_par->max_roaming_times = (u8)rtw_max_roaming_times; 256 257 registry_par->enable80211d = (u8)rtw_80211d; 258 259 snprintf(registry_par->ifname, 16, "%s", ifname); 260 261 registry_par->notch_filter = (u8)rtw_notch_filter; 262 263 registry_par->reg_enable_tx_power_limit = (u8)rtw_tx_pwr_lmt_enable; 264 registry_par->reg_enable_tx_power_by_rate = (u8)rtw_tx_pwr_by_rate; 265 266 registry_par->reg_power_base = 14; 267 268 registry_par->qos_opt_enable = (u8)rtw_qos_opt_enable; 269 270 registry_par->hiq_filter = (u8)rtw_hiq_filter; 271 } 272 273 static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p) 274 { 275 struct adapter *padapter = rtw_netdev_priv(pnetdev); 276 struct sockaddr *addr = p; 277 278 if (!padapter->bup) { 279 /* addr->sa_data[4], addr->sa_data[5]); */ 280 memcpy(padapter->eeprompriv.mac_addr, addr->sa_data, ETH_ALEN); 281 /* eth_hw_addr_set(pnetdev, addr->sa_data); */ 282 /* padapter->bset_hwaddr = true; */ 283 } 284 285 return 0; 286 } 287 288 static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev) 289 { 290 struct adapter *padapter = rtw_netdev_priv(pnetdev); 291 struct xmit_priv *pxmitpriv = &(padapter->xmitpriv); 292 struct recv_priv *precvpriv = &(padapter->recvpriv); 293 294 padapter->stats.tx_packets = pxmitpriv->tx_pkts;/* pxmitpriv->tx_pkts++; */ 295 padapter->stats.rx_packets = precvpriv->rx_pkts;/* precvpriv->rx_pkts++; */ 296 padapter->stats.tx_dropped = pxmitpriv->tx_drop; 297 padapter->stats.rx_dropped = precvpriv->rx_drop; 298 padapter->stats.tx_bytes = pxmitpriv->tx_bytes; 299 padapter->stats.rx_bytes = precvpriv->rx_bytes; 300 301 return &padapter->stats; 302 } 303 304 /* 305 * AC to queue mapping 306 * 307 * AC_VO -> queue 0 308 * AC_VI -> queue 1 309 * AC_BE -> queue 2 310 * AC_BK -> queue 3 311 */ 312 static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 }; 313 314 /* Given a data frame determine the 802.1p/1d tag to use. */ 315 static unsigned int rtw_classify8021d(struct sk_buff *skb) 316 { 317 unsigned int dscp; 318 319 /* skb->priority values from 256->263 are magic values to 320 * directly indicate a specific 802.1d priority. This is used 321 * to allow 802.1d priority to be passed directly in from VLAN 322 * tags, etc. 323 */ 324 if (skb->priority >= 256 && skb->priority <= 263) 325 return skb->priority - 256; 326 327 switch (skb->protocol) { 328 case htons(ETH_P_IP): 329 dscp = ip_hdr(skb)->tos & 0xfc; 330 break; 331 default: 332 return 0; 333 } 334 335 return dscp >> 5; 336 } 337 338 339 static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb, 340 struct net_device *sb_dev) 341 { 342 struct adapter *padapter = rtw_netdev_priv(dev); 343 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 344 345 skb->priority = rtw_classify8021d(skb); 346 347 if (pmlmepriv->acm_mask != 0) 348 skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority); 349 350 return rtw_1d_to_queue[skb->priority]; 351 } 352 353 u16 rtw_recv_select_queue(struct sk_buff *skb) 354 { 355 struct iphdr *piphdr; 356 unsigned int dscp; 357 __be16 eth_type; 358 u32 priority; 359 u8 *pdata = skb->data; 360 361 memcpy(ð_type, pdata + (ETH_ALEN << 1), 2); 362 363 switch (be16_to_cpu(eth_type)) { 364 case ETH_P_IP: 365 366 piphdr = (struct iphdr *)(pdata + ETH_HLEN); 367 368 dscp = piphdr->tos & 0xfc; 369 370 priority = dscp >> 5; 371 372 break; 373 default: 374 priority = 0; 375 } 376 377 return rtw_1d_to_queue[priority]; 378 } 379 380 static int rtw_ndev_init(struct net_device *dev) 381 { 382 struct adapter *adapter = rtw_netdev_priv(dev); 383 384 netdev_dbg(dev, FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter)); 385 strscpy(adapter->old_ifname, dev->name); 386 387 return 0; 388 } 389 390 static void rtw_ndev_uninit(struct net_device *dev) 391 { 392 struct adapter *adapter = rtw_netdev_priv(dev); 393 394 netdev_dbg(dev, FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter)); 395 } 396 397 static const struct net_device_ops rtw_netdev_ops = { 398 .ndo_init = rtw_ndev_init, 399 .ndo_uninit = rtw_ndev_uninit, 400 .ndo_open = netdev_open, 401 .ndo_stop = netdev_close, 402 .ndo_start_xmit = rtw_xmit_entry, 403 .ndo_select_queue = rtw_select_queue, 404 .ndo_set_mac_address = rtw_net_set_mac_address, 405 .ndo_get_stats = rtw_net_get_stats, 406 }; 407 408 int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname) 409 { 410 if (dev_alloc_name(pnetdev, ifname) < 0) { 411 pr_err("dev_alloc_name, fail for %s\n", ifname); 412 return 1; 413 } 414 netif_carrier_off(pnetdev); 415 /* rtw_netif_stop_queue(pnetdev); */ 416 417 return 0; 418 } 419 420 struct net_device *rtw_init_netdev(struct adapter *old_padapter) 421 { 422 struct adapter *padapter; 423 struct net_device *pnetdev; 424 425 if (old_padapter) 426 pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(struct adapter), (void *)old_padapter); 427 else 428 pnetdev = rtw_alloc_etherdev(sizeof(struct adapter)); 429 430 pr_info("pnetdev = %p\n", pnetdev); 431 if (!pnetdev) 432 return NULL; 433 434 padapter = rtw_netdev_priv(pnetdev); 435 padapter->pnetdev = pnetdev; 436 437 /* pnetdev->init = NULL; */ 438 439 pnetdev->netdev_ops = &rtw_netdev_ops; 440 441 /* pnetdev->tx_timeout = NULL; */ 442 pnetdev->watchdog_timeo = HZ * 3; /* 3 second timeout */ 443 444 /* step 2. */ 445 loadparam(padapter, pnetdev); 446 447 return pnetdev; 448 } 449 450 void rtw_unregister_netdevs(struct dvobj_priv *dvobj) 451 { 452 struct adapter *padapter = NULL; 453 struct net_device *pnetdev = NULL; 454 455 padapter = dvobj->padapters; 456 457 if (!padapter) 458 return; 459 460 pnetdev = padapter->pnetdev; 461 462 if ((padapter->DriverState != DRIVER_DISAPPEAR) && pnetdev) 463 unregister_netdev(pnetdev); /* will call netdev_close() */ 464 rtw_wdev_unregister(padapter->rtw_wdev); 465 } 466 467 u32 rtw_start_drv_threads(struct adapter *padapter) 468 { 469 u32 _status = _SUCCESS; 470 471 padapter->xmitThread = kthread_run(rtw_xmit_thread, padapter, "RTW_XMIT_THREAD"); 472 if (IS_ERR(padapter->xmitThread)) 473 _status = _FAIL; 474 475 padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD"); 476 if (IS_ERR(padapter->cmdThread)) 477 _status = _FAIL; 478 else 479 wait_for_completion(&padapter->cmdpriv.terminate_cmdthread_comp); /* wait for cmd_thread to run */ 480 481 padapter->xmitpriv.SdioXmitThread = kthread_run(rtl8723bs_xmit_thread, 482 padapter, "RTWHALXT"); 483 if (IS_ERR(padapter->xmitpriv.SdioXmitThread)) { 484 padapter->xmitpriv.SdioXmitThread = NULL; 485 _status = _FAIL; 486 } 487 488 return _status; 489 } 490 491 void rtw_stop_drv_threads(struct adapter *padapter) 492 { 493 rtw_stop_cmd_thread(padapter); 494 495 /* Below is to terminate tx_thread... */ 496 complete(&padapter->xmitpriv.xmit_comp); 497 wait_for_completion(&padapter->xmitpriv.terminate_xmitthread_comp); 498 499 /* stop SdioXmitThread */ 500 if (padapter->xmitpriv.SdioXmitThread) { 501 complete(&padapter->xmitpriv.SdioXmitStart); 502 wait_for_completion(&padapter->xmitpriv.SdioXmitTerminate); 503 padapter->xmitpriv.SdioXmitThread = NULL; 504 } 505 } 506 507 static void rtw_init_default_value(struct adapter *padapter) 508 { 509 struct registry_priv *pregistrypriv = &padapter->registrypriv; 510 struct xmit_priv *pxmitpriv = &padapter->xmitpriv; 511 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 512 struct security_priv *psecuritypriv = &padapter->securitypriv; 513 514 /* xmit_priv */ 515 pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense; 516 pxmitpriv->vcs = pregistrypriv->vcs_type; 517 pxmitpriv->vcs_type = pregistrypriv->vcs_type; 518 /* pxmitpriv->rts_thresh = pregistrypriv->rts_thresh; */ 519 pxmitpriv->frag_len = pregistrypriv->frag_thresh; 520 521 /* recv_priv */ 522 523 /* mlme_priv */ 524 pmlmepriv->scan_mode = SCAN_ACTIVE; 525 526 /* qos_priv */ 527 /* pmlmepriv->qospriv.qos_option = pregistrypriv->wmm_enable; */ 528 529 /* ht_priv */ 530 pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */ 531 532 /* security_priv */ 533 psecuritypriv->binstallGrpkey = _FAIL; 534 psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt; 535 psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt; 536 537 psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */ 538 psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_; 539 540 psecuritypriv->dot11PrivacyKeyIndex = 0; 541 542 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_; 543 psecuritypriv->dot118021XGrpKeyid = 1; 544 545 psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen; 546 psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled; 547 548 /* registry_priv */ 549 rtw_init_registrypriv_dev_network(padapter); 550 rtw_update_registrypriv_dev_network(padapter); 551 552 /* hal_priv */ 553 rtw_hal_def_value_init(padapter); 554 555 /* misc. */ 556 RTW_ENABLE_FUNC(padapter, DF_RX_BIT); 557 RTW_ENABLE_FUNC(padapter, DF_TX_BIT); 558 padapter->bLinkInfoDump = 0; 559 padapter->bNotifyChannelChange = 0; 560 561 /* for debug purpose */ 562 padapter->fix_rate = 0xFF; 563 padapter->driver_ampdu_spacing = 0xFF; 564 padapter->driver_rx_ampdu_factor = 0xFF; 565 } 566 567 struct dvobj_priv *devobj_init(void) 568 { 569 struct dvobj_priv *pdvobj = NULL; 570 571 pdvobj = kzalloc_obj(*pdvobj); 572 if (!pdvobj) 573 return NULL; 574 575 mutex_init(&pdvobj->hw_init_mutex); 576 mutex_init(&pdvobj->h2c_fwcmd_mutex); 577 mutex_init(&pdvobj->setch_mutex); 578 mutex_init(&pdvobj->setbw_mutex); 579 580 spin_lock_init(&pdvobj->lock); 581 582 pdvobj->macid[1] = true; /* macid = 1 for bc/mc stainfo */ 583 584 pdvobj->processing_dev_remove = false; 585 586 atomic_set(&pdvobj->disable_func, 0); 587 588 spin_lock_init(&pdvobj->cam_ctl.lock); 589 590 return pdvobj; 591 } 592 593 void devobj_deinit(struct dvobj_priv *pdvobj) 594 { 595 if (!pdvobj) 596 return; 597 598 mutex_destroy(&pdvobj->hw_init_mutex); 599 mutex_destroy(&pdvobj->h2c_fwcmd_mutex); 600 mutex_destroy(&pdvobj->setch_mutex); 601 mutex_destroy(&pdvobj->setbw_mutex); 602 603 kfree(pdvobj); 604 } 605 606 void rtw_reset_drv_sw(struct adapter *padapter) 607 { 608 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 609 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter); 610 611 /* hal_priv */ 612 rtw_hal_def_value_init(padapter); 613 614 RTW_ENABLE_FUNC(padapter, DF_RX_BIT); 615 RTW_ENABLE_FUNC(padapter, DF_TX_BIT); 616 padapter->bLinkInfoDump = 0; 617 618 padapter->xmitpriv.tx_pkts = 0; 619 padapter->recvpriv.rx_pkts = 0; 620 621 pmlmepriv->link_detect_info.busy_traffic = false; 622 623 pmlmepriv->link_detect_info.traffic_transition_count = 0; 624 pmlmepriv->link_detect_info.low_power_transition_count = 0; 625 626 _clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING); 627 628 pwrctrlpriv->pwr_state_check_cnts = 0; 629 630 /* mlmeextpriv */ 631 padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE; 632 633 rtw_set_signal_stat_timer(&padapter->recvpriv); 634 } 635 636 637 u8 rtw_init_drv_sw(struct adapter *padapter) 638 { 639 rtw_init_default_value(padapter); 640 641 rtw_init_hal_com_default_value(padapter); 642 643 if (rtw_init_cmd_priv(&padapter->cmdpriv)) 644 return _FAIL; 645 646 padapter->cmdpriv.padapter = padapter; 647 648 if (rtw_init_evt_priv(&padapter->evtpriv)) 649 goto free_cmd_priv; 650 651 if (rtw_init_mlme_priv(padapter) == _FAIL) 652 goto free_evt_priv; 653 654 init_mlme_ext_priv(padapter); 655 656 if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL) 657 goto free_mlme_ext; 658 659 if (_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL) 660 goto free_xmit_priv; 661 /* add for CONFIG_IEEE80211W, none 11w also can use */ 662 spin_lock_init(&padapter->security_key_mutex); 663 664 /* We don't need to memset padapter->XXX to zero, because adapter is allocated by vzalloc(). */ 665 /* memset((unsigned char *)&padapter->securitypriv, 0, sizeof (struct security_priv)); */ 666 667 if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL) 668 goto free_recv_priv; 669 670 padapter->stapriv.padapter = padapter; 671 padapter->setband = GHZ24_50; 672 padapter->fix_rate = 0xFF; 673 rtw_init_bcmc_stainfo(padapter); 674 675 rtw_init_pwrctrl_priv(padapter); 676 677 rtw_hal_dm_init(padapter); 678 679 return _SUCCESS; 680 681 free_recv_priv: 682 _rtw_free_recv_priv(&padapter->recvpriv); 683 684 free_xmit_priv: 685 _rtw_free_xmit_priv(&padapter->xmitpriv); 686 687 free_mlme_ext: 688 free_mlme_ext_priv(&padapter->mlmeextpriv); 689 690 rtw_free_mlme_priv(&padapter->mlmepriv); 691 692 free_evt_priv: 693 rtw_free_evt_priv(&padapter->evtpriv); 694 695 free_cmd_priv: 696 rtw_free_cmd_priv(&padapter->cmdpriv); 697 698 return _FAIL; 699 } 700 701 void rtw_cancel_all_timer(struct adapter *padapter) 702 { 703 timer_delete_sync(&padapter->mlmepriv.assoc_timer); 704 705 timer_delete_sync(&padapter->mlmepriv.scan_to_timer); 706 707 timer_delete_sync(&padapter->mlmepriv.dynamic_chk_timer); 708 709 timer_delete_sync(&(adapter_to_pwrctl(padapter)->pwr_state_check_timer)); 710 711 timer_delete_sync(&padapter->mlmepriv.set_scan_deny_timer); 712 rtw_clear_scan_deny(padapter); 713 714 timer_delete_sync(&padapter->recvpriv.signal_stat_timer); 715 } 716 717 u8 rtw_free_drv_sw(struct adapter *padapter) 718 { 719 free_mlme_ext_priv(&padapter->mlmeextpriv); 720 721 rtw_free_cmd_priv(&padapter->cmdpriv); 722 723 rtw_free_evt_priv(&padapter->evtpriv); 724 725 rtw_free_mlme_priv(&padapter->mlmepriv); 726 727 _rtw_free_xmit_priv(&padapter->xmitpriv); 728 729 _rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */ 730 731 _rtw_free_recv_priv(&padapter->recvpriv); 732 733 rtw_free_pwrctrl_priv(padapter); 734 735 /* kfree((void *)padapter); */ 736 737 rtw_hal_free_data(padapter); 738 739 /* free the old_pnetdev */ 740 if (padapter->rereg_nd_name_priv.old_pnetdev) { 741 free_netdev(padapter->rereg_nd_name_priv.old_pnetdev); 742 padapter->rereg_nd_name_priv.old_pnetdev = NULL; 743 } 744 745 /* clear pbuddystruct adapter to avoid access wrong pointer. */ 746 if (padapter->pbuddy_adapter) 747 padapter->pbuddy_adapter->pbuddy_adapter = NULL; 748 749 return _SUCCESS; 750 } 751 752 static int _rtw_drv_register_netdev(struct adapter *padapter, char *name) 753 { 754 int ret = _SUCCESS; 755 struct net_device *pnetdev = padapter->pnetdev; 756 757 /* alloc netdev name */ 758 if (rtw_init_netdev_name(pnetdev, name)) 759 return _FAIL; 760 761 eth_hw_addr_set(pnetdev, padapter->eeprompriv.mac_addr); 762 763 /* Tell the network stack we exist */ 764 if (register_netdev(pnetdev) != 0) { 765 ret = _FAIL; 766 goto error_register_netdev; 767 } 768 769 return ret; 770 771 error_register_netdev: 772 773 rtw_free_drv_sw(padapter); 774 775 rtw_free_netdev(pnetdev); 776 777 return ret; 778 } 779 780 int rtw_drv_register_netdev(struct adapter *if1) 781 { 782 struct dvobj_priv *dvobj = if1->dvobj; 783 struct adapter *padapter = dvobj->padapters; 784 char *name = if1->registrypriv.ifname; 785 786 return _rtw_drv_register_netdev(padapter, name); 787 } 788 789 static int _netdev_open(struct net_device *pnetdev) 790 { 791 uint status; 792 struct adapter *padapter = rtw_netdev_priv(pnetdev); 793 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter); 794 795 padapter->netif_up = true; 796 797 if (pwrctrlpriv->ps_flag) { 798 padapter->net_closed = false; 799 goto netdev_open_normal_process; 800 } 801 802 if (!padapter->bup) { 803 padapter->bDriverStopped = false; 804 padapter->bSurpriseRemoved = false; 805 padapter->bCardDisableWOHSM = false; 806 807 status = rtw_hal_init(padapter); 808 if (status == _FAIL) 809 goto netdev_open_error; 810 811 status = rtw_start_drv_threads(padapter); 812 if (status == _FAIL) 813 goto netdev_open_error; 814 815 if (padapter->intf_start) 816 padapter->intf_start(padapter); 817 818 rtw_cfg80211_init_wiphy(padapter); 819 820 padapter->bup = true; 821 pwrctrlpriv->bips_processing = false; 822 } 823 padapter->net_closed = false; 824 825 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000); 826 827 if (!rtw_netif_queue_stopped(pnetdev)) 828 rtw_netif_start_queue(pnetdev); 829 else 830 rtw_netif_wake_queue(pnetdev); 831 832 netdev_open_normal_process: 833 834 return 0; 835 836 netdev_open_error: 837 838 padapter->bup = false; 839 840 netif_carrier_off(pnetdev); 841 rtw_netif_stop_queue(pnetdev); 842 843 return (-1); 844 } 845 846 int netdev_open(struct net_device *pnetdev) 847 { 848 int ret; 849 struct adapter *padapter = rtw_netdev_priv(pnetdev); 850 struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter); 851 852 if (pwrctrlpriv->bInSuspend) 853 return 0; 854 855 if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex))) 856 return -1; 857 858 ret = _netdev_open(pnetdev); 859 mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex)); 860 861 return ret; 862 } 863 864 static int ips_netdrv_open(struct adapter *padapter) 865 { 866 int status = _SUCCESS; 867 /* struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); */ 868 869 padapter->net_closed = false; 870 871 padapter->bDriverStopped = false; 872 padapter->bCardDisableWOHSM = false; 873 /* padapter->bup = true; */ 874 875 status = rtw_hal_init(padapter); 876 if (status == _FAIL) 877 goto netdev_open_error; 878 879 if (padapter->intf_start) 880 padapter->intf_start(padapter); 881 882 _set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000); 883 884 return _SUCCESS; 885 886 netdev_open_error: 887 888 return _FAIL; 889 } 890 891 892 int rtw_ips_pwr_up(struct adapter *padapter) 893 { 894 return ips_netdrv_open(padapter); 895 } 896 897 void rtw_ips_pwr_down(struct adapter *padapter) 898 { 899 padapter->bCardDisableWOHSM = true; 900 padapter->net_closed = true; 901 902 rtw_ips_dev_unload(padapter); 903 padapter->bCardDisableWOHSM = false; 904 } 905 906 void rtw_ips_dev_unload(struct adapter *padapter) 907 { 908 if (!padapter->bSurpriseRemoved) 909 rtw_hal_deinit(padapter); 910 } 911 912 static int pm_netdev_open(struct net_device *pnetdev, u8 bnormal) 913 { 914 int status = -1; 915 916 struct adapter *padapter = rtw_netdev_priv(pnetdev); 917 918 if (bnormal) { 919 if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex)) == 0) { 920 status = _netdev_open(pnetdev); 921 mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex)); 922 } 923 } else { 924 status = (ips_netdrv_open(padapter) == _SUCCESS) ? (0) : (-1); 925 } 926 927 return status; 928 } 929 930 static int netdev_close(struct net_device *pnetdev) 931 { 932 struct adapter *padapter = rtw_netdev_priv(pnetdev); 933 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter); 934 935 if (pwrctl->bInternalAutoSuspend) { 936 /* rtw_pwr_wakeup(padapter); */ 937 if (pwrctl->rf_pwrstate == rf_off) 938 pwrctl->ps_flag = true; 939 } 940 padapter->net_closed = true; 941 padapter->netif_up = false; 942 943 if (pwrctl->rf_pwrstate == rf_on) { 944 /* s1. */ 945 if (pnetdev) { 946 if (!rtw_netif_queue_stopped(pnetdev)) 947 rtw_netif_stop_queue(pnetdev); 948 } 949 950 /* s2. */ 951 LeaveAllPowerSaveMode(padapter); 952 rtw_disassoc_cmd(padapter, 500, false); 953 /* s2-2. indicate disconnect to os */ 954 rtw_indicate_disconnect(padapter); 955 /* s2-3. */ 956 rtw_free_assoc_resources(padapter, 1); 957 /* s2-4. */ 958 rtw_free_network_queue(padapter, true); 959 } 960 961 rtw_scan_abort(padapter); 962 963 return 0; 964 } 965 966 void rtw_ndev_destructor(struct net_device *ndev) 967 { 968 kfree(ndev->ieee80211_ptr); 969 } 970 971 void rtw_dev_unload(struct adapter *padapter) 972 { 973 struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter); 974 struct cmd_priv *pcmdpriv = &padapter->cmdpriv; 975 u8 cnt = 0; 976 977 if (padapter->bup) { 978 padapter->bDriverStopped = true; 979 if (padapter->xmitpriv.ack_tx) 980 rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP); 981 982 if (padapter->intf_stop) 983 padapter->intf_stop(padapter); 984 985 if (!pwrctl->bInternalAutoSuspend) 986 rtw_stop_drv_threads(padapter); 987 988 while (atomic_read(&pcmdpriv->cmdthd_running)) { 989 if (cnt > 5) { 990 break; 991 } else { 992 cnt++; 993 msleep(10); 994 } 995 } 996 997 /* check the status of IPS */ 998 if (rtw_hal_check_ips_status(padapter) || pwrctl->rf_pwrstate == rf_off) { 999 /* check HW status and SW state */ 1000 netdev_dbg(padapter->pnetdev, 1001 "%s: driver in IPS-FWLPS\n", __func__); 1002 LeaveAllPowerSaveMode(padapter); 1003 } else { 1004 netdev_dbg(padapter->pnetdev, 1005 "%s: driver not in IPS\n", __func__); 1006 } 1007 1008 if (!padapter->bSurpriseRemoved) { 1009 hal_btcoex_IpsNotify(padapter, pwrctl->ips_mode_req); 1010 1011 /* amy modify 20120221 for power seq is different between driver open and ips */ 1012 rtw_hal_deinit(padapter); 1013 1014 padapter->bSurpriseRemoved = true; 1015 } 1016 1017 padapter->bup = false; 1018 } 1019 } 1020 1021 static int rtw_suspend_free_assoc_resource(struct adapter *padapter) 1022 { 1023 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1024 1025 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) { 1026 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) 1027 && check_fwstate(pmlmepriv, _FW_LINKED)) { 1028 rtw_set_to_roam(padapter, 1); 1029 } 1030 } 1031 1032 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)) { 1033 rtw_disassoc_cmd(padapter, 0, false); 1034 /* s2-2. indicate disconnect to os */ 1035 rtw_indicate_disconnect(padapter); 1036 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 1037 rtw_sta_flush(padapter); 1038 } 1039 1040 /* s2-3. */ 1041 rtw_free_assoc_resources(padapter, 1); 1042 1043 /* s2-4. */ 1044 rtw_free_network_queue(padapter, true); 1045 1046 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) 1047 rtw_indicate_scan_done(padapter, 1); 1048 1049 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) { 1050 netdev_dbg(padapter->pnetdev, "%s: fw_under_linking\n", 1051 __func__); 1052 rtw_indicate_disconnect(padapter); 1053 } 1054 1055 return _SUCCESS; 1056 } 1057 1058 static void rtw_suspend_normal(struct adapter *padapter) 1059 { 1060 struct net_device *pnetdev = padapter->pnetdev; 1061 1062 if (pnetdev) { 1063 netif_carrier_off(pnetdev); 1064 rtw_netif_stop_queue(pnetdev); 1065 } 1066 1067 rtw_suspend_free_assoc_resource(padapter); 1068 1069 if ((rtw_hal_check_ips_status(padapter)) || (adapter_to_pwrctl(padapter)->rf_pwrstate == rf_off)) 1070 netdev_dbg(padapter->pnetdev, 1071 "%s: ### ERROR #### driver in IPS ####ERROR###!!!\n", 1072 __func__); 1073 1074 rtw_dev_unload(padapter); 1075 1076 /* sdio_deinit(adapter_to_dvobj(padapter)); */ 1077 if (padapter->intf_deinit) 1078 padapter->intf_deinit(adapter_to_dvobj(padapter)); 1079 } 1080 1081 void rtw_suspend_common(struct adapter *padapter) 1082 { 1083 struct dvobj_priv *psdpriv = padapter->dvobj; 1084 struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv); 1085 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1086 1087 unsigned long start_time = jiffies; 1088 1089 netdev_dbg(padapter->pnetdev, " suspend start\n"); 1090 1091 pwrpriv->bInSuspend = true; 1092 1093 while (pwrpriv->bips_processing) 1094 msleep(1); 1095 1096 if ((!padapter->bup) || (padapter->bDriverStopped) || (padapter->bSurpriseRemoved)) 1097 return; 1098 1099 rtw_ps_deny(padapter, PS_DENY_SUSPEND); 1100 1101 rtw_cancel_all_timer(padapter); 1102 1103 LeaveAllPowerSaveModeDirect(padapter); 1104 1105 rtw_stop_cmd_thread(padapter); 1106 1107 /* wait for the latest FW to remove this condition. */ 1108 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) 1109 hal_btcoex_SuspendNotify(padapter, 0); 1110 else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) 1111 hal_btcoex_SuspendNotify(padapter, 1); 1112 1113 rtw_ps_deny_cancel(padapter, PS_DENY_SUSPEND); 1114 1115 rtw_suspend_normal(padapter); 1116 1117 netdev_dbg(padapter->pnetdev, "rtw suspend success in %d ms\n", 1118 jiffies_to_msecs(jiffies - start_time)); 1119 } 1120 1121 static int rtw_resume_process_normal(struct adapter *padapter) 1122 { 1123 struct net_device *pnetdev; 1124 struct pwrctrl_priv *pwrpriv; 1125 struct mlme_priv *pmlmepriv; 1126 1127 int ret = _SUCCESS; 1128 1129 if (!padapter) { 1130 ret = -1; 1131 goto exit; 1132 } 1133 1134 pnetdev = padapter->pnetdev; 1135 pwrpriv = adapter_to_pwrctl(padapter); 1136 pmlmepriv = &padapter->mlmepriv; 1137 /* interface init */ 1138 if (padapter->intf_init) { 1139 ret = padapter->intf_init(adapter_to_dvobj(padapter)); 1140 if (ret) 1141 goto exit; 1142 } 1143 rtw_hal_disable_interrupt(padapter); 1144 /* if (sdio_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS) */ 1145 if ((padapter->intf_alloc_irq) && (padapter->intf_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS)) { 1146 ret = -1; 1147 goto exit; 1148 } 1149 1150 rtw_reset_drv_sw(padapter); 1151 pwrpriv->bkeepfwalive = false; 1152 1153 if (pm_netdev_open(pnetdev, true) != 0) { 1154 ret = -1; 1155 goto exit; 1156 } 1157 1158 netif_device_attach(pnetdev); 1159 netif_carrier_on(pnetdev); 1160 1161 if (padapter->pid[1] != 0) 1162 rtw_signal_process(padapter->pid[1], SIGUSR2); 1163 1164 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { 1165 if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) 1166 rtw_roaming(padapter, NULL); 1167 } else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) { 1168 rtw_ap_restore_network(padapter); 1169 } 1170 1171 exit: 1172 return ret; 1173 } 1174 1175 int rtw_resume_common(struct adapter *padapter) 1176 { 1177 int ret = 0; 1178 unsigned long start_time = jiffies; 1179 struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); 1180 1181 netdev_dbg(padapter->pnetdev, "resume start\n"); 1182 1183 rtw_resume_process_normal(padapter); 1184 1185 hal_btcoex_SuspendNotify(padapter, 0); 1186 1187 if (pwrpriv) 1188 pwrpriv->bInSuspend = false; 1189 1190 netdev_dbg(padapter->pnetdev, "%s:%d in %d ms\n", __func__, ret, 1191 jiffies_to_msecs(jiffies - start_time)); 1192 1193 return ret; 1194 } 1195