os_intfs.c

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