| 1 |
// SPDX-License-Identifier: GPL-2.0 |
| 2 |
/* Copyright(c) 2009-2012 Realtek Corporation.*/ |
| 3 |
|
| 4 |
#include "wifi.h" |
| 5 |
#include "base.h" |
| 6 |
#include "ps.h" |
| 7 |
#include <linux/export.h> |
| 8 |
#include "btcoexist/rtl_btc.h" |
| 9 |
|
| 10 |
bool rtl_ps_enable_nic(struct ieee80211_hw *hw) |
| 11 |
{ |
| 12 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 13 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 14 |
struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); |
| 15 |
struct rtl_mac *rtlmac = rtl_mac(rtl_priv(hw)); |
| 16 |
|
| 17 |
/*<1> reset trx ring */ |
| 18 |
if (rtlhal->interface == INTF_PCI) |
| 19 |
rtlpriv->intf_ops->reset_trx_ring(hw); |
| 20 |
|
| 21 |
if (is_hal_stop(rtlhal)) |
| 22 |
rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING, |
| 23 |
"Driver is already down!\n"); |
| 24 |
|
| 25 |
/*<2> Enable Adapter */ |
| 26 |
if (rtlpriv->cfg->ops->hw_init(hw)) |
| 27 |
return false; |
| 28 |
rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_RETRY_LIMIT, |
| 29 |
&rtlmac->retry_long); |
| 30 |
RT_CLEAR_PS_LEVEL(ppsc, RT_RF_OFF_LEVL_HALT_NIC); |
| 31 |
|
| 32 |
rtlpriv->cfg->ops->switch_channel(hw); |
| 33 |
rtlpriv->cfg->ops->set_channel_access(hw); |
| 34 |
rtlpriv->cfg->ops->set_bw_mode(hw, |
| 35 |
cfg80211_get_chandef_type(&hw->conf.chandef)); |
| 36 |
|
| 37 |
/*<3> Enable Interrupt */ |
| 38 |
rtlpriv->cfg->ops->enable_interrupt(hw); |
| 39 |
|
| 40 |
/*<enable timer> */ |
| 41 |
rtl_watch_dog_timer_callback(&rtlpriv->works.watchdog_timer); |
| 42 |
|
| 43 |
return true; |
| 44 |
} |
| 45 |
EXPORT_SYMBOL(rtl_ps_enable_nic); |
| 46 |
|
| 47 |
bool rtl_ps_disable_nic(struct ieee80211_hw *hw) |
| 48 |
{ |
| 49 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 50 |
|
| 51 |
/*<1> Stop all timer */ |
| 52 |
rtl_deinit_deferred_work(hw, true); |
| 53 |
|
| 54 |
/*<2> Disable Interrupt */ |
| 55 |
rtlpriv->cfg->ops->disable_interrupt(hw); |
| 56 |
tasklet_kill(&rtlpriv->works.irq_tasklet); |
| 57 |
|
| 58 |
/*<3> Disable Adapter */ |
| 59 |
rtlpriv->cfg->ops->hw_disable(hw); |
| 60 |
|
| 61 |
return true; |
| 62 |
} |
| 63 |
EXPORT_SYMBOL(rtl_ps_disable_nic); |
| 64 |
|
| 65 |
static bool rtl_ps_set_rf_state(struct ieee80211_hw *hw, |
| 66 |
enum rf_pwrstate state_toset, |
| 67 |
u32 changesource) |
| 68 |
{ |
| 69 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 70 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 71 |
bool actionallowed = false; |
| 72 |
u16 rfwait_cnt = 0; |
| 73 |
|
| 74 |
/*Only one thread can change |
| 75 |
*the RF state at one time, and others |
| 76 |
*should wait to be executed. |
| 77 |
*/ |
| 78 |
while (true) { |
| 79 |
spin_lock(&rtlpriv->locks.rf_ps_lock); |
| 80 |
if (ppsc->rfchange_inprogress) { |
| 81 |
spin_unlock(&rtlpriv->locks.rf_ps_lock); |
| 82 |
|
| 83 |
rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING, |
| 84 |
"RF Change in progress! Wait to set..state_toset(%d).\n", |
| 85 |
state_toset); |
| 86 |
|
| 87 |
/* Set RF after the previous action is done. */ |
| 88 |
while (ppsc->rfchange_inprogress) { |
| 89 |
rfwait_cnt++; |
| 90 |
mdelay(1); |
| 91 |
/*Wait too long, return false to avoid |
| 92 |
*to be stuck here. |
| 93 |
*/ |
| 94 |
if (rfwait_cnt > 100) |
| 95 |
return false; |
| 96 |
} |
| 97 |
} else { |
| 98 |
ppsc->rfchange_inprogress = true; |
| 99 |
spin_unlock(&rtlpriv->locks.rf_ps_lock); |
| 100 |
break; |
| 101 |
} |
| 102 |
} |
| 103 |
|
| 104 |
switch (state_toset) { |
| 105 |
case ERFON: |
| 106 |
ppsc->rfoff_reason &= (~changesource); |
| 107 |
|
| 108 |
if ((changesource == RF_CHANGE_BY_HW) && |
| 109 |
(ppsc->hwradiooff)) { |
| 110 |
ppsc->hwradiooff = false; |
| 111 |
} |
| 112 |
|
| 113 |
if (!ppsc->rfoff_reason) { |
| 114 |
ppsc->rfoff_reason = 0; |
| 115 |
actionallowed = true; |
| 116 |
} |
| 117 |
|
| 118 |
break; |
| 119 |
|
| 120 |
case ERFOFF: |
| 121 |
|
| 122 |
if ((changesource == RF_CHANGE_BY_HW) && !ppsc->hwradiooff) { |
| 123 |
ppsc->hwradiooff = true; |
| 124 |
} |
| 125 |
|
| 126 |
ppsc->rfoff_reason |= changesource; |
| 127 |
actionallowed = true; |
| 128 |
break; |
| 129 |
|
| 130 |
case ERFSLEEP: |
| 131 |
ppsc->rfoff_reason |= changesource; |
| 132 |
actionallowed = true; |
| 133 |
break; |
| 134 |
|
| 135 |
default: |
| 136 |
pr_err("switch case %#x not processed\n", state_toset); |
| 137 |
break; |
| 138 |
} |
| 139 |
|
| 140 |
if (actionallowed) |
| 141 |
rtlpriv->cfg->ops->set_rf_power_state(hw, state_toset); |
| 142 |
|
| 143 |
spin_lock(&rtlpriv->locks.rf_ps_lock); |
| 144 |
ppsc->rfchange_inprogress = false; |
| 145 |
spin_unlock(&rtlpriv->locks.rf_ps_lock); |
| 146 |
|
| 147 |
return actionallowed; |
| 148 |
} |
| 149 |
|
| 150 |
static void _rtl_ps_inactive_ps(struct ieee80211_hw *hw) |
| 151 |
{ |
| 152 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 153 |
struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); |
| 154 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 155 |
|
| 156 |
ppsc->swrf_processing = true; |
| 157 |
|
| 158 |
if (ppsc->inactive_pwrstate == ERFON && |
| 159 |
rtlhal->interface == INTF_PCI) { |
| 160 |
if ((ppsc->reg_rfps_level & RT_RF_OFF_LEVL_ASPM) && |
| 161 |
RT_IN_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM)) { |
| 162 |
rtlpriv->intf_ops->disable_aspm(hw); |
| 163 |
RT_CLEAR_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM); |
| 164 |
} |
| 165 |
} |
| 166 |
|
| 167 |
rtl_ps_set_rf_state(hw, ppsc->inactive_pwrstate, |
| 168 |
RF_CHANGE_BY_IPS); |
| 169 |
|
| 170 |
if (ppsc->inactive_pwrstate == ERFOFF && |
| 171 |
rtlhal->interface == INTF_PCI) { |
| 172 |
if (ppsc->reg_rfps_level & RT_RF_OFF_LEVL_ASPM && |
| 173 |
!RT_IN_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM)) { |
| 174 |
rtlpriv->intf_ops->enable_aspm(hw); |
| 175 |
RT_SET_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM); |
| 176 |
} |
| 177 |
} |
| 178 |
|
| 179 |
ppsc->swrf_processing = false; |
| 180 |
} |
| 181 |
|
| 182 |
void rtl_ips_nic_off_wq_callback(struct work_struct *work) |
| 183 |
{ |
| 184 |
struct rtl_works *rtlworks = container_of(work, struct rtl_works, |
| 185 |
ips_nic_off_wq.work); |
| 186 |
struct ieee80211_hw *hw = rtlworks->hw; |
| 187 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 188 |
struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); |
| 189 |
struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); |
| 190 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 191 |
enum rf_pwrstate rtstate; |
| 192 |
|
| 193 |
if (mac->opmode != NL80211_IFTYPE_STATION) { |
| 194 |
rtl_dbg(rtlpriv, COMP_ERR, DBG_WARNING, |
| 195 |
"not station return\n"); |
| 196 |
return; |
| 197 |
} |
| 198 |
|
| 199 |
if (mac->p2p_in_use) |
| 200 |
return; |
| 201 |
|
| 202 |
if (mac->link_state > MAC80211_NOLINK) |
| 203 |
return; |
| 204 |
|
| 205 |
if (is_hal_stop(rtlhal)) |
| 206 |
return; |
| 207 |
|
| 208 |
if (rtlpriv->sec.being_setkey) |
| 209 |
return; |
| 210 |
|
| 211 |
if (rtlpriv->cfg->ops->bt_coex_off_before_lps) |
| 212 |
rtlpriv->cfg->ops->bt_coex_off_before_lps(hw); |
| 213 |
|
| 214 |
if (ppsc->inactiveps) { |
| 215 |
rtstate = ppsc->rfpwr_state; |
| 216 |
|
| 217 |
/* |
| 218 |
*Do not enter IPS in the following conditions: |
| 219 |
*(1) RF is already OFF or Sleep |
| 220 |
*(2) swrf_processing (indicates the IPS is still under going) |
| 221 |
*(3) Connectted (only disconnected can trigger IPS) |
| 222 |
*(4) IBSS (send Beacon) |
| 223 |
*(5) AP mode (send Beacon) |
| 224 |
*(6) monitor mode (rcv packet) |
| 225 |
*/ |
| 226 |
|
| 227 |
if (rtstate == ERFON && |
| 228 |
!ppsc->swrf_processing && |
| 229 |
(mac->link_state == MAC80211_NOLINK) && |
| 230 |
!mac->act_scanning) { |
| 231 |
rtl_dbg(rtlpriv, COMP_RF, DBG_TRACE, |
| 232 |
"IPSEnter(): Turn off RF\n"); |
| 233 |
|
| 234 |
ppsc->inactive_pwrstate = ERFOFF; |
| 235 |
ppsc->in_powersavemode = true; |
| 236 |
|
| 237 |
/* call before RF off */ |
| 238 |
if (rtlpriv->cfg->ops->get_btc_status()) |
| 239 |
rtlpriv->btcoexist.btc_ops->btc_ips_notify(rtlpriv, |
| 240 |
ppsc->inactive_pwrstate); |
| 241 |
|
| 242 |
/*rtl_pci_reset_trx_ring(hw); */ |
| 243 |
_rtl_ps_inactive_ps(hw); |
| 244 |
} |
| 245 |
} |
| 246 |
} |
| 247 |
|
| 248 |
void rtl_ips_nic_off(struct ieee80211_hw *hw) |
| 249 |
{ |
| 250 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 251 |
|
| 252 |
/* because when link with ap, mac80211 will ask us |
| 253 |
* to disable nic quickly after scan before linking, |
| 254 |
* this will cause link failed, so we delay 100ms here |
| 255 |
*/ |
| 256 |
queue_delayed_work(rtlpriv->works.rtl_wq, |
| 257 |
&rtlpriv->works.ips_nic_off_wq, MSECS(100)); |
| 258 |
} |
| 259 |
|
| 260 |
/* NOTICE: any opmode should exc nic_on, or disable without |
| 261 |
* nic_on may something wrong, like adhoc TP |
| 262 |
*/ |
| 263 |
void rtl_ips_nic_on(struct ieee80211_hw *hw) |
| 264 |
{ |
| 265 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 266 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 267 |
enum rf_pwrstate rtstate; |
| 268 |
|
| 269 |
cancel_delayed_work_sync(&rtlpriv->works.ips_nic_off_wq); |
| 270 |
|
| 271 |
mutex_lock(&rtlpriv->locks.ips_mutex); |
| 272 |
if (ppsc->inactiveps) { |
| 273 |
rtstate = ppsc->rfpwr_state; |
| 274 |
|
| 275 |
if (rtstate != ERFON && |
| 276 |
!ppsc->swrf_processing && |
| 277 |
ppsc->rfoff_reason <= RF_CHANGE_BY_IPS) { |
| 278 |
|
| 279 |
ppsc->inactive_pwrstate = ERFON; |
| 280 |
ppsc->in_powersavemode = false; |
| 281 |
_rtl_ps_inactive_ps(hw); |
| 282 |
/* call after RF on */ |
| 283 |
if (rtlpriv->cfg->ops->get_btc_status()) |
| 284 |
rtlpriv->btcoexist.btc_ops->btc_ips_notify(rtlpriv, |
| 285 |
ppsc->inactive_pwrstate); |
| 286 |
} |
| 287 |
} |
| 288 |
mutex_unlock(&rtlpriv->locks.ips_mutex); |
| 289 |
} |
| 290 |
EXPORT_SYMBOL_GPL(rtl_ips_nic_on); |
| 291 |
|
| 292 |
/*for FW LPS*/ |
| 293 |
|
| 294 |
/* |
| 295 |
*Determine if we can set Fw into PS mode |
| 296 |
*in current condition.Return TRUE if it |
| 297 |
*can enter PS mode. |
| 298 |
*/ |
| 299 |
static bool rtl_get_fwlps_doze(struct ieee80211_hw *hw) |
| 300 |
{ |
| 301 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 302 |
struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); |
| 303 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 304 |
u32 ps_timediff; |
| 305 |
|
| 306 |
ps_timediff = jiffies_to_msecs(jiffies - |
| 307 |
ppsc->last_delaylps_stamp_jiffies); |
| 308 |
|
| 309 |
if (ps_timediff < 2000) { |
| 310 |
rtl_dbg(rtlpriv, COMP_POWER, DBG_LOUD, |
| 311 |
"Delay enter Fw LPS for DHCP, ARP, or EAPOL exchanging state\n"); |
| 312 |
return false; |
| 313 |
} |
| 314 |
|
| 315 |
if (mac->link_state != MAC80211_LINKED) |
| 316 |
return false; |
| 317 |
|
| 318 |
if (mac->opmode == NL80211_IFTYPE_ADHOC) |
| 319 |
return false; |
| 320 |
|
| 321 |
return true; |
| 322 |
} |
| 323 |
|
| 324 |
/* Change current and default preamble mode.*/ |
| 325 |
void rtl_lps_set_psmode(struct ieee80211_hw *hw, u8 rt_psmode) |
| 326 |
{ |
| 327 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 328 |
struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); |
| 329 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 330 |
bool enter_fwlps; |
| 331 |
|
| 332 |
if (mac->opmode == NL80211_IFTYPE_ADHOC) |
| 333 |
return; |
| 334 |
|
| 335 |
if (mac->link_state != MAC80211_LINKED) |
| 336 |
return; |
| 337 |
|
| 338 |
if (ppsc->dot11_psmode == rt_psmode && rt_psmode == EACTIVE) |
| 339 |
return; |
| 340 |
|
| 341 |
/* Update power save mode configured. */ |
| 342 |
ppsc->dot11_psmode = rt_psmode; |
| 343 |
|
| 344 |
/* |
| 345 |
*<FW control LPS> |
| 346 |
*1. Enter PS mode |
| 347 |
* Set RPWM to Fw to turn RF off and send H2C fw_pwrmode |
| 348 |
* cmd to set Fw into PS mode. |
| 349 |
*2. Leave PS mode |
| 350 |
* Send H2C fw_pwrmode cmd to Fw to set Fw into Active |
| 351 |
* mode and set RPWM to turn RF on. |
| 352 |
*/ |
| 353 |
|
| 354 |
if ((ppsc->fwctrl_lps) && ppsc->report_linked) { |
| 355 |
if (ppsc->dot11_psmode == EACTIVE) { |
| 356 |
rtl_dbg(rtlpriv, COMP_RF, DBG_DMESG, |
| 357 |
"FW LPS leave ps_mode:%x\n", |
| 358 |
FW_PS_ACTIVE_MODE); |
| 359 |
enter_fwlps = false; |
| 360 |
ppsc->pwr_mode = FW_PS_ACTIVE_MODE; |
| 361 |
ppsc->smart_ps = 0; |
| 362 |
rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_FW_LPS_ACTION, |
| 363 |
(u8 *)(&enter_fwlps)); |
| 364 |
if (ppsc->p2p_ps_info.opp_ps) |
| 365 |
rtl_p2p_ps_cmd(hw , P2P_PS_ENABLE); |
| 366 |
|
| 367 |
if (rtlpriv->cfg->ops->get_btc_status()) |
| 368 |
rtlpriv->btcoexist.btc_ops->btc_lps_notify(rtlpriv, rt_psmode); |
| 369 |
} else { |
| 370 |
if (rtl_get_fwlps_doze(hw)) { |
| 371 |
rtl_dbg(rtlpriv, COMP_RF, DBG_DMESG, |
| 372 |
"FW LPS enter ps_mode:%x\n", |
| 373 |
ppsc->fwctrl_psmode); |
| 374 |
if (rtlpriv->cfg->ops->get_btc_status()) |
| 375 |
rtlpriv->btcoexist.btc_ops->btc_lps_notify(rtlpriv, rt_psmode); |
| 376 |
enter_fwlps = true; |
| 377 |
ppsc->pwr_mode = ppsc->fwctrl_psmode; |
| 378 |
ppsc->smart_ps = 2; |
| 379 |
rtlpriv->cfg->ops->set_hw_reg(hw, |
| 380 |
HW_VAR_FW_LPS_ACTION, |
| 381 |
(u8 *)(&enter_fwlps)); |
| 382 |
|
| 383 |
} else { |
| 384 |
/* Reset the power save related parameters. */ |
| 385 |
ppsc->dot11_psmode = EACTIVE; |
| 386 |
} |
| 387 |
} |
| 388 |
} |
| 389 |
} |
| 390 |
|
| 391 |
/* Interrupt safe routine to enter the leisure power save mode.*/ |
| 392 |
static void rtl_lps_enter_core(struct ieee80211_hw *hw) |
| 393 |
{ |
| 394 |
struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); |
| 395 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 396 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 397 |
|
| 398 |
if (!ppsc->fwctrl_lps) |
| 399 |
return; |
| 400 |
|
| 401 |
if (rtlpriv->sec.being_setkey) |
| 402 |
return; |
| 403 |
|
| 404 |
if (rtlpriv->link_info.busytraffic) |
| 405 |
return; |
| 406 |
|
| 407 |
/*sleep after linked 10s, to let DHCP and 4-way handshake ok enough!! */ |
| 408 |
if (mac->cnt_after_linked < 5) |
| 409 |
return; |
| 410 |
|
| 411 |
if (mac->opmode == NL80211_IFTYPE_ADHOC) |
| 412 |
return; |
| 413 |
|
| 414 |
if (mac->link_state != MAC80211_LINKED) |
| 415 |
return; |
| 416 |
|
| 417 |
mutex_lock(&rtlpriv->locks.lps_mutex); |
| 418 |
|
| 419 |
/* Don't need to check (ppsc->dot11_psmode == EACTIVE), because |
| 420 |
* bt_ccoexist may ask to enter lps. |
| 421 |
* In normal case, this constraint move to rtl_lps_set_psmode(). |
| 422 |
*/ |
| 423 |
rtl_dbg(rtlpriv, COMP_POWER, DBG_LOUD, |
| 424 |
"Enter 802.11 power save mode...\n"); |
| 425 |
rtl_lps_set_psmode(hw, EAUTOPS); |
| 426 |
|
| 427 |
mutex_unlock(&rtlpriv->locks.lps_mutex); |
| 428 |
} |
| 429 |
|
| 430 |
/* Interrupt safe routine to leave the leisure power save mode.*/ |
| 431 |
static void rtl_lps_leave_core(struct ieee80211_hw *hw) |
| 432 |
{ |
| 433 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 434 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 435 |
struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw)); |
| 436 |
|
| 437 |
mutex_lock(&rtlpriv->locks.lps_mutex); |
| 438 |
|
| 439 |
if (ppsc->fwctrl_lps) { |
| 440 |
if (ppsc->dot11_psmode != EACTIVE) { |
| 441 |
|
| 442 |
/*FIX ME */ |
| 443 |
/*rtlpriv->cfg->ops->enable_interrupt(hw); */ |
| 444 |
|
| 445 |
if (ppsc->reg_rfps_level & RT_RF_LPS_LEVEL_ASPM && |
| 446 |
RT_IN_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM) && |
| 447 |
rtlhal->interface == INTF_PCI) { |
| 448 |
rtlpriv->intf_ops->disable_aspm(hw); |
| 449 |
RT_CLEAR_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM); |
| 450 |
} |
| 451 |
|
| 452 |
rtl_dbg(rtlpriv, COMP_POWER, DBG_LOUD, |
| 453 |
"Busy Traffic,Leave 802.11 power save..\n"); |
| 454 |
|
| 455 |
rtl_lps_set_psmode(hw, EACTIVE); |
| 456 |
} |
| 457 |
} |
| 458 |
mutex_unlock(&rtlpriv->locks.lps_mutex); |
| 459 |
} |
| 460 |
|
| 461 |
/* For sw LPS*/ |
| 462 |
void rtl_swlps_beacon(struct ieee80211_hw *hw, void *data, unsigned int len) |
| 463 |
{ |
| 464 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 465 |
struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); |
| 466 |
struct ieee80211_hdr *hdr = data; |
| 467 |
struct ieee80211_tim_ie *tim_ie; |
| 468 |
u8 *tim; |
| 469 |
u8 tim_len; |
| 470 |
bool u_buffed; |
| 471 |
bool m_buffed; |
| 472 |
|
| 473 |
if (mac->opmode != NL80211_IFTYPE_STATION) |
| 474 |
return; |
| 475 |
|
| 476 |
if (!rtlpriv->psc.swctrl_lps) |
| 477 |
return; |
| 478 |
|
| 479 |
if (rtlpriv->mac80211.link_state != MAC80211_LINKED) |
| 480 |
return; |
| 481 |
|
| 482 |
if (!rtlpriv->psc.sw_ps_enabled) |
| 483 |
return; |
| 484 |
|
| 485 |
if (rtlpriv->psc.fwctrl_lps) |
| 486 |
return; |
| 487 |
|
| 488 |
if (likely(!(hw->conf.flags & IEEE80211_CONF_PS))) |
| 489 |
return; |
| 490 |
|
| 491 |
/* check if this really is a beacon */ |
| 492 |
if (!ieee80211_is_beacon(hdr->frame_control)) |
| 493 |
return; |
| 494 |
|
| 495 |
/* min. beacon length + FCS_LEN */ |
| 496 |
if (len <= 40 + FCS_LEN) |
| 497 |
return; |
| 498 |
|
| 499 |
/* and only beacons from the associated BSSID, please */ |
| 500 |
if (!ether_addr_equal_64bits(hdr->addr3, rtlpriv->mac80211.bssid)) |
| 501 |
return; |
| 502 |
|
| 503 |
rtlpriv->psc.last_beacon = jiffies; |
| 504 |
|
| 505 |
tim = rtl_find_ie(data, len - FCS_LEN, WLAN_EID_TIM); |
| 506 |
if (!tim) |
| 507 |
return; |
| 508 |
|
| 509 |
if (tim[1] < sizeof(*tim_ie)) |
| 510 |
return; |
| 511 |
|
| 512 |
tim_len = tim[1]; |
| 513 |
tim_ie = (struct ieee80211_tim_ie *) &tim[2]; |
| 514 |
|
| 515 |
if (!WARN_ON_ONCE(!hw->conf.ps_dtim_period)) |
| 516 |
rtlpriv->psc.dtim_counter = tim_ie->dtim_count; |
| 517 |
|
| 518 |
/* Check whenever the PHY can be turned off again. */ |
| 519 |
|
| 520 |
/* 1. What about buffered unicast traffic for our AID? */ |
| 521 |
u_buffed = ieee80211_check_tim(tim_ie, tim_len, |
| 522 |
rtlpriv->mac80211.assoc_id, false); |
| 523 |
|
| 524 |
/* 2. Maybe the AP wants to send multicast/broadcast data? */ |
| 525 |
m_buffed = tim_ie->bitmap_ctrl & 0x01; |
| 526 |
rtlpriv->psc.multi_buffered = m_buffed; |
| 527 |
|
| 528 |
/* unicast will process by mac80211 through |
| 529 |
* set ~IEEE80211_CONF_PS, So we just check |
| 530 |
* multicast frames here */ |
| 531 |
if (!m_buffed) { |
| 532 |
/* back to low-power land. and delay is |
| 533 |
* prevent null power save frame tx fail */ |
| 534 |
queue_delayed_work(rtlpriv->works.rtl_wq, |
| 535 |
&rtlpriv->works.ps_work, MSECS(5)); |
| 536 |
} else { |
| 537 |
rtl_dbg(rtlpriv, COMP_POWER, DBG_DMESG, |
| 538 |
"u_bufferd: %x, m_buffered: %x\n", u_buffed, m_buffed); |
| 539 |
} |
| 540 |
} |
| 541 |
EXPORT_SYMBOL_GPL(rtl_swlps_beacon); |
| 542 |
|
| 543 |
void rtl_swlps_rf_awake(struct ieee80211_hw *hw) |
| 544 |
{ |
| 545 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 546 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 547 |
struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); |
| 548 |
|
| 549 |
if (!rtlpriv->psc.swctrl_lps) |
| 550 |
return; |
| 551 |
if (mac->link_state != MAC80211_LINKED) |
| 552 |
return; |
| 553 |
|
| 554 |
if (ppsc->reg_rfps_level & RT_RF_LPS_LEVEL_ASPM && |
| 555 |
RT_IN_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM)) { |
| 556 |
rtlpriv->intf_ops->disable_aspm(hw); |
| 557 |
RT_CLEAR_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM); |
| 558 |
} |
| 559 |
|
| 560 |
mutex_lock(&rtlpriv->locks.lps_mutex); |
| 561 |
rtl_ps_set_rf_state(hw, ERFON, RF_CHANGE_BY_PS); |
| 562 |
mutex_unlock(&rtlpriv->locks.lps_mutex); |
| 563 |
} |
| 564 |
|
| 565 |
void rtl_swlps_rfon_wq_callback(struct work_struct *work) |
| 566 |
{ |
| 567 |
struct rtl_works *rtlworks = container_of(work, struct rtl_works, |
| 568 |
ps_rfon_wq.work); |
| 569 |
struct ieee80211_hw *hw = rtlworks->hw; |
| 570 |
|
| 571 |
rtl_swlps_rf_awake(hw); |
| 572 |
} |
| 573 |
|
| 574 |
void rtl_swlps_rf_sleep(struct ieee80211_hw *hw) |
| 575 |
{ |
| 576 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 577 |
struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); |
| 578 |
struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw)); |
| 579 |
u8 sleep_intv; |
| 580 |
|
| 581 |
if (!rtlpriv->psc.sw_ps_enabled) |
| 582 |
return; |
| 583 |
|
| 584 |
if ((rtlpriv->sec.being_setkey) || |
| 585 |
(mac->opmode == NL80211_IFTYPE_ADHOC)) |
| 586 |
return; |
| 587 |
|
| 588 |
/*sleep after linked 10s, to let DHCP and 4-way handshake ok enough!! */ |
| 589 |
if ((mac->link_state != MAC80211_LINKED) || (mac->cnt_after_linked < 5)) |
| 590 |
return; |
| 591 |
|
| 592 |
if (rtlpriv->link_info.busytraffic) |
| 593 |
return; |
| 594 |
|
| 595 |
spin_lock(&rtlpriv->locks.rf_ps_lock); |
| 596 |
if (rtlpriv->psc.rfchange_inprogress) { |
| 597 |
spin_unlock(&rtlpriv->locks.rf_ps_lock); |
| 598 |
return; |
| 599 |
} |
| 600 |
spin_unlock(&rtlpriv->locks.rf_ps_lock); |
| 601 |
|
| 602 |
mutex_lock(&rtlpriv->locks.lps_mutex); |
| 603 |
rtl_ps_set_rf_state(hw, ERFSLEEP, RF_CHANGE_BY_PS); |
| 604 |
mutex_unlock(&rtlpriv->locks.lps_mutex); |
| 605 |
|
| 606 |
if (ppsc->reg_rfps_level & RT_RF_OFF_LEVL_ASPM && |
| 607 |
!RT_IN_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM)) { |
| 608 |
rtlpriv->intf_ops->enable_aspm(hw); |
| 609 |
RT_SET_PS_LEVEL(ppsc, RT_PS_LEVEL_ASPM); |
| 610 |
} |
| 611 |
|
| 612 |
/* here is power save alg, when this beacon is DTIM |
| 613 |
* we will set sleep time to dtim_period * n; |
| 614 |
* when this beacon is not DTIM, we will set sleep |
| 615 |
* time to sleep_intv = rtlpriv->psc.dtim_counter or |
| 616 |
* MAX_SW_LPS_SLEEP_INTV(default set to 5) */ |
| 617 |
|
| 618 |
if (rtlpriv->psc.dtim_counter == 0) { |
| 619 |
if (hw->conf.ps_dtim_period == 1) |
| 620 |
sleep_intv = hw->conf.ps_dtim_period * 2; |
| 621 |
else |
| 622 |
sleep_intv = hw->conf.ps_dtim_period; |
| 623 |
} else { |
| 624 |
sleep_intv = rtlpriv->psc.dtim_counter; |
| 625 |
} |
| 626 |
|
| 627 |
if (sleep_intv > MAX_SW_LPS_SLEEP_INTV) |
| 628 |
sleep_intv = MAX_SW_LPS_SLEEP_INTV; |
| 629 |
|
| 630 |
/* this print should always be dtim_conter = 0 & |
| 631 |
* sleep = dtim_period, that meaons, we should |
| 632 |
* awake before every dtim */ |
| 633 |
rtl_dbg(rtlpriv, COMP_POWER, DBG_DMESG, |
| 634 |
"dtim_counter:%x will sleep :%d beacon_intv\n", |
| 635 |
rtlpriv->psc.dtim_counter, sleep_intv); |
| 636 |
|
| 637 |
/* we tested that 40ms is enough for sw & hw sw delay */ |
| 638 |
queue_delayed_work(rtlpriv->works.rtl_wq, &rtlpriv->works.ps_rfon_wq, |
| 639 |
MSECS(sleep_intv * mac->vif->bss_conf.beacon_int - 40)); |
| 640 |
} |
| 641 |
|
| 642 |
void rtl_lps_change_work_callback(struct work_struct *work) |
| 643 |
{ |
| 644 |
struct rtl_works *rtlworks = |
| 645 |
container_of(work, struct rtl_works, lps_change_work); |
| 646 |
struct ieee80211_hw *hw = rtlworks->hw; |
| 647 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 648 |
|
| 649 |
if (rtlpriv->enter_ps) |
| 650 |
rtl_lps_enter_core(hw); |
| 651 |
else |
| 652 |
rtl_lps_leave_core(hw); |
| 653 |
} |
| 654 |
EXPORT_SYMBOL_GPL(rtl_lps_change_work_callback); |
| 655 |
|
| 656 |
void rtl_lps_enter(struct ieee80211_hw *hw, bool may_block) |
| 657 |
{ |
| 658 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 659 |
|
| 660 |
if (may_block) |
| 661 |
return rtl_lps_enter_core(hw); |
| 662 |
rtlpriv->enter_ps = true; |
| 663 |
schedule_work(&rtlpriv->works.lps_change_work); |
| 664 |
} |
| 665 |
EXPORT_SYMBOL_GPL(rtl_lps_enter); |
| 666 |
|
| 667 |
void rtl_lps_leave(struct ieee80211_hw *hw, bool may_block) |
| 668 |
{ |
| 669 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 670 |
|
| 671 |
if (may_block) |
| 672 |
return rtl_lps_leave_core(hw); |
| 673 |
rtlpriv->enter_ps = false; |
| 674 |
schedule_work(&rtlpriv->works.lps_change_work); |
| 675 |
} |
| 676 |
EXPORT_SYMBOL_GPL(rtl_lps_leave); |
| 677 |
|
| 678 |
void rtl_swlps_wq_callback(struct work_struct *work) |
| 679 |
{ |
| 680 |
struct rtl_works *rtlworks = container_of(work, struct rtl_works, |
| 681 |
ps_work.work); |
| 682 |
struct ieee80211_hw *hw = rtlworks->hw; |
| 683 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 684 |
|
| 685 |
/* we can sleep after ps null send ok */ |
| 686 |
if (rtlpriv->psc.state_inap) |
| 687 |
rtl_swlps_rf_sleep(hw); |
| 688 |
} |
| 689 |
|
| 690 |
static void rtl_p2p_noa_ie(struct ieee80211_hw *hw, void *data, |
| 691 |
unsigned int len) |
| 692 |
{ |
| 693 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 694 |
struct ieee80211_mgmt *mgmt = data; |
| 695 |
struct rtl_p2p_ps_info *p2pinfo = &(rtlpriv->psc.p2p_ps_info); |
| 696 |
u8 *pos, *end, *ie; |
| 697 |
u16 noa_len; |
| 698 |
static u8 p2p_oui_ie_type[4] = {0x50, 0x6f, 0x9a, 0x09}; |
| 699 |
u8 noa_num, index , i, noa_index = 0; |
| 700 |
bool find_p2p_ie = false , find_p2p_ps_ie = false; |
| 701 |
|
| 702 |
pos = (u8 *)mgmt->u.beacon.variable; |
| 703 |
end = data + len; |
| 704 |
ie = NULL; |
| 705 |
|
| 706 |
while (pos + 1 < end) { |
| 707 |
if (pos + 2 + pos[1] > end) |
| 708 |
return; |
| 709 |
|
| 710 |
if (pos[0] == 221 && pos[1] > 4) { |
| 711 |
if (memcmp(&pos[2], p2p_oui_ie_type, 4) == 0) { |
| 712 |
ie = pos + 2+4; |
| 713 |
break; |
| 714 |
} |
| 715 |
} |
| 716 |
pos += 2 + pos[1]; |
| 717 |
} |
| 718 |
|
| 719 |
if (ie == NULL) |
| 720 |
return; |
| 721 |
find_p2p_ie = true; |
| 722 |
/*to find noa ie*/ |
| 723 |
while (ie + 1 < end) { |
| 724 |
noa_len = le16_to_cpu(*((__le16 *)&ie[1])); |
| 725 |
if (ie + 3 + ie[1] > end) |
| 726 |
return; |
| 727 |
|
| 728 |
if (ie[0] == 12) { |
| 729 |
find_p2p_ps_ie = true; |
| 730 |
if ((noa_len - 2) % 13 != 0) { |
| 731 |
rtl_dbg(rtlpriv, COMP_INIT, DBG_LOUD, |
| 732 |
"P2P notice of absence: invalid length.%d\n", |
| 733 |
noa_len); |
| 734 |
return; |
| 735 |
} else { |
| 736 |
noa_num = (noa_len - 2) / 13; |
| 737 |
if (noa_num > P2P_MAX_NOA_NUM) |
| 738 |
noa_num = P2P_MAX_NOA_NUM; |
| 739 |
|
| 740 |
} |
| 741 |
noa_index = ie[3]; |
| 742 |
if (rtlpriv->psc.p2p_ps_info.p2p_ps_mode == |
| 743 |
P2P_PS_NONE || noa_index != p2pinfo->noa_index) { |
| 744 |
rtl_dbg(rtlpriv, COMP_FW, DBG_LOUD, |
| 745 |
"update NOA ie.\n"); |
| 746 |
p2pinfo->noa_index = noa_index; |
| 747 |
p2pinfo->opp_ps = (ie[4] >> 7); |
| 748 |
p2pinfo->ctwindow = ie[4] & 0x7F; |
| 749 |
p2pinfo->noa_num = noa_num; |
| 750 |
index = 5; |
| 751 |
for (i = 0; i < noa_num; i++) { |
| 752 |
p2pinfo->noa_count_type[i] = |
| 753 |
*(u8 *)(ie + index); |
| 754 |
index += 1; |
| 755 |
p2pinfo->noa_duration[i] = |
| 756 |
le32_to_cpu(*(__le32 *)(ie + index)); |
| 757 |
index += 4; |
| 758 |
p2pinfo->noa_interval[i] = |
| 759 |
le32_to_cpu(*(__le32 *)(ie + index)); |
| 760 |
index += 4; |
| 761 |
p2pinfo->noa_start_time[i] = |
| 762 |
le32_to_cpu(*(__le32 *)(ie + index)); |
| 763 |
index += 4; |
| 764 |
} |
| 765 |
|
| 766 |
if (p2pinfo->opp_ps == 1) { |
| 767 |
p2pinfo->p2p_ps_mode = P2P_PS_CTWINDOW; |
| 768 |
/* Driver should wait LPS entering |
| 769 |
* CTWindow |
| 770 |
*/ |
| 771 |
if (rtlpriv->psc.fw_current_inpsmode) |
| 772 |
rtl_p2p_ps_cmd(hw, |
| 773 |
P2P_PS_ENABLE); |
| 774 |
} else if (p2pinfo->noa_num > 0) { |
| 775 |
p2pinfo->p2p_ps_mode = P2P_PS_NOA; |
| 776 |
rtl_p2p_ps_cmd(hw, P2P_PS_ENABLE); |
| 777 |
} else if (p2pinfo->p2p_ps_mode > P2P_PS_NONE) { |
| 778 |
rtl_p2p_ps_cmd(hw, P2P_PS_DISABLE); |
| 779 |
} |
| 780 |
} |
| 781 |
break; |
| 782 |
} |
| 783 |
ie += 3 + noa_len; |
| 784 |
} |
| 785 |
|
| 786 |
if (find_p2p_ie) { |
| 787 |
if ((p2pinfo->p2p_ps_mode > P2P_PS_NONE) && |
| 788 |
(!find_p2p_ps_ie)) |
| 789 |
rtl_p2p_ps_cmd(hw, P2P_PS_DISABLE); |
| 790 |
} |
| 791 |
} |
| 792 |
|
| 793 |
static void rtl_p2p_action_ie(struct ieee80211_hw *hw, void *data, |
| 794 |
unsigned int len) |
| 795 |
{ |
| 796 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 797 |
struct ieee80211_mgmt *mgmt = data; |
| 798 |
struct rtl_p2p_ps_info *p2pinfo = &(rtlpriv->psc.p2p_ps_info); |
| 799 |
u8 noa_num, index , i , noa_index = 0; |
| 800 |
u8 *pos, *end, *ie; |
| 801 |
u16 noa_len; |
| 802 |
static u8 p2p_oui_ie_type[4] = {0x50, 0x6f, 0x9a, 0x09}; |
| 803 |
|
| 804 |
pos = (u8 *)&mgmt->u.action.category; |
| 805 |
end = data + len; |
| 806 |
ie = NULL; |
| 807 |
|
| 808 |
if (pos[0] == 0x7f) { |
| 809 |
if (memcmp(&pos[1], p2p_oui_ie_type, 4) == 0) |
| 810 |
ie = pos + 3+4; |
| 811 |
} |
| 812 |
|
| 813 |
if (ie == NULL) |
| 814 |
return; |
| 815 |
|
| 816 |
rtl_dbg(rtlpriv, COMP_FW, DBG_LOUD, "action frame find P2P IE.\n"); |
| 817 |
/*to find noa ie*/ |
| 818 |
while (ie + 1 < end) { |
| 819 |
noa_len = le16_to_cpu(*(__le16 *)&ie[1]); |
| 820 |
if (ie + 3 + ie[1] > end) |
| 821 |
return; |
| 822 |
|
| 823 |
if (ie[0] == 12) { |
| 824 |
rtl_dbg(rtlpriv, COMP_FW, DBG_LOUD, "find NOA IE.\n"); |
| 825 |
RT_PRINT_DATA(rtlpriv, COMP_FW, DBG_LOUD, "noa ie ", |
| 826 |
ie, noa_len); |
| 827 |
if ((noa_len - 2) % 13 != 0) { |
| 828 |
rtl_dbg(rtlpriv, COMP_FW, DBG_LOUD, |
| 829 |
"P2P notice of absence: invalid length.%d\n", |
| 830 |
noa_len); |
| 831 |
return; |
| 832 |
} else { |
| 833 |
noa_num = (noa_len - 2) / 13; |
| 834 |
if (noa_num > P2P_MAX_NOA_NUM) |
| 835 |
noa_num = P2P_MAX_NOA_NUM; |
| 836 |
|
| 837 |
} |
| 838 |
noa_index = ie[3]; |
| 839 |
if (rtlpriv->psc.p2p_ps_info.p2p_ps_mode == |
| 840 |
P2P_PS_NONE || noa_index != p2pinfo->noa_index) { |
| 841 |
p2pinfo->noa_index = noa_index; |
| 842 |
p2pinfo->opp_ps = (ie[4] >> 7); |
| 843 |
p2pinfo->ctwindow = ie[4] & 0x7F; |
| 844 |
p2pinfo->noa_num = noa_num; |
| 845 |
index = 5; |
| 846 |
for (i = 0; i < noa_num; i++) { |
| 847 |
p2pinfo->noa_count_type[i] = |
| 848 |
*(u8 *)(ie + index); |
| 849 |
index += 1; |
| 850 |
p2pinfo->noa_duration[i] = |
| 851 |
le32_to_cpu(*(__le32 *)(ie + index)); |
| 852 |
index += 4; |
| 853 |
p2pinfo->noa_interval[i] = |
| 854 |
le32_to_cpu(*(__le32 *)(ie + index)); |
| 855 |
index += 4; |
| 856 |
p2pinfo->noa_start_time[i] = |
| 857 |
le32_to_cpu(*(__le32 *)(ie + index)); |
| 858 |
index += 4; |
| 859 |
} |
| 860 |
|
| 861 |
if (p2pinfo->opp_ps == 1) { |
| 862 |
p2pinfo->p2p_ps_mode = P2P_PS_CTWINDOW; |
| 863 |
/* Driver should wait LPS entering |
| 864 |
* CTWindow |
| 865 |
*/ |
| 866 |
if (rtlpriv->psc.fw_current_inpsmode) |
| 867 |
rtl_p2p_ps_cmd(hw, |
| 868 |
P2P_PS_ENABLE); |
| 869 |
} else if (p2pinfo->noa_num > 0) { |
| 870 |
p2pinfo->p2p_ps_mode = P2P_PS_NOA; |
| 871 |
rtl_p2p_ps_cmd(hw, P2P_PS_ENABLE); |
| 872 |
} else if (p2pinfo->p2p_ps_mode > P2P_PS_NONE) { |
| 873 |
rtl_p2p_ps_cmd(hw, P2P_PS_DISABLE); |
| 874 |
} |
| 875 |
} |
| 876 |
break; |
| 877 |
} |
| 878 |
ie += 3 + noa_len; |
| 879 |
} |
| 880 |
} |
| 881 |
|
| 882 |
void rtl_p2p_ps_cmd(struct ieee80211_hw *hw , u8 p2p_ps_state) |
| 883 |
{ |
| 884 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 885 |
struct rtl_ps_ctl *rtlps = rtl_psc(rtl_priv(hw)); |
| 886 |
struct rtl_p2p_ps_info *p2pinfo = &(rtlpriv->psc.p2p_ps_info); |
| 887 |
|
| 888 |
rtl_dbg(rtlpriv, COMP_FW, DBG_LOUD, " p2p state %x\n", p2p_ps_state); |
| 889 |
switch (p2p_ps_state) { |
| 890 |
case P2P_PS_DISABLE: |
| 891 |
p2pinfo->p2p_ps_state = p2p_ps_state; |
| 892 |
rtlpriv->cfg->ops->set_hw_reg(hw, HW_VAR_H2C_FW_P2P_PS_OFFLOAD, |
| 893 |
&p2p_ps_state); |
| 894 |
p2pinfo->noa_index = 0; |
| 895 |
p2pinfo->ctwindow = 0; |
| 896 |
p2pinfo->opp_ps = 0; |
| 897 |
p2pinfo->noa_num = 0; |
| 898 |
p2pinfo->p2p_ps_mode = P2P_PS_NONE; |
| 899 |
if (rtlps->fw_current_inpsmode) { |
| 900 |
if (rtlps->smart_ps == 0) { |
| 901 |
rtlps->smart_ps = 2; |
| 902 |
rtlpriv->cfg->ops->set_hw_reg(hw, |
| 903 |
HW_VAR_H2C_FW_PWRMODE, |
| 904 |
&rtlps->pwr_mode); |
| 905 |
} |
| 906 |
|
| 907 |
} |
| 908 |
break; |
| 909 |
case P2P_PS_ENABLE: |
| 910 |
if (p2pinfo->p2p_ps_mode > P2P_PS_NONE) { |
| 911 |
p2pinfo->p2p_ps_state = p2p_ps_state; |
| 912 |
|
| 913 |
if (p2pinfo->ctwindow > 0) { |
| 914 |
if (rtlps->smart_ps != 0) { |
| 915 |
rtlps->smart_ps = 0; |
| 916 |
rtlpriv->cfg->ops->set_hw_reg(hw, |
| 917 |
HW_VAR_H2C_FW_PWRMODE, |
| 918 |
&rtlps->pwr_mode); |
| 919 |
} |
| 920 |
} |
| 921 |
rtlpriv->cfg->ops->set_hw_reg(hw, |
| 922 |
HW_VAR_H2C_FW_P2P_PS_OFFLOAD, |
| 923 |
&p2p_ps_state); |
| 924 |
|
| 925 |
} |
| 926 |
break; |
| 927 |
case P2P_PS_SCAN: |
| 928 |
case P2P_PS_SCAN_DONE: |
| 929 |
case P2P_PS_ALLSTASLEEP: |
| 930 |
if (p2pinfo->p2p_ps_mode > P2P_PS_NONE) { |
| 931 |
p2pinfo->p2p_ps_state = p2p_ps_state; |
| 932 |
rtlpriv->cfg->ops->set_hw_reg(hw, |
| 933 |
HW_VAR_H2C_FW_P2P_PS_OFFLOAD, |
| 934 |
&p2p_ps_state); |
| 935 |
} |
| 936 |
break; |
| 937 |
default: |
| 938 |
break; |
| 939 |
} |
| 940 |
rtl_dbg(rtlpriv, COMP_FW, DBG_LOUD, |
| 941 |
"ctwindow %x oppps %x\n", |
| 942 |
p2pinfo->ctwindow, p2pinfo->opp_ps); |
| 943 |
rtl_dbg(rtlpriv, COMP_FW, DBG_LOUD, |
| 944 |
"count %x duration %x index %x interval %x start time %x noa num %x\n", |
| 945 |
p2pinfo->noa_count_type[0], |
| 946 |
p2pinfo->noa_duration[0], |
| 947 |
p2pinfo->noa_index, |
| 948 |
p2pinfo->noa_interval[0], |
| 949 |
p2pinfo->noa_start_time[0], |
| 950 |
p2pinfo->noa_num); |
| 951 |
rtl_dbg(rtlpriv, COMP_FW, DBG_LOUD, "end\n"); |
| 952 |
} |
| 953 |
|
| 954 |
void rtl_p2p_info(struct ieee80211_hw *hw, void *data, unsigned int len) |
| 955 |
{ |
| 956 |
struct rtl_priv *rtlpriv = rtl_priv(hw); |
| 957 |
struct rtl_mac *mac = rtl_mac(rtl_priv(hw)); |
| 958 |
struct ieee80211_hdr *hdr = data; |
| 959 |
|
| 960 |
if (!mac->p2p) |
| 961 |
return; |
| 962 |
if (mac->link_state != MAC80211_LINKED) |
| 963 |
return; |
| 964 |
/* min. beacon length + FCS_LEN */ |
| 965 |
if (len <= 40 + FCS_LEN) |
| 966 |
return; |
| 967 |
|
| 968 |
/* and only beacons from the associated BSSID, please */ |
| 969 |
if (!ether_addr_equal_64bits(hdr->addr3, rtlpriv->mac80211.bssid)) |
| 970 |
return; |
| 971 |
|
| 972 |
/* check if this really is a beacon */ |
| 973 |
if (!(ieee80211_is_beacon(hdr->frame_control) || |
| 974 |
ieee80211_is_probe_resp(hdr->frame_control) || |
| 975 |
ieee80211_is_action(hdr->frame_control))) |
| 976 |
return; |
| 977 |
|
| 978 |
if (ieee80211_is_action(hdr->frame_control)) |
| 979 |
rtl_p2p_action_ie(hw , data , len - FCS_LEN); |
| 980 |
else |
| 981 |
rtl_p2p_noa_ie(hw , data , len - FCS_LEN); |
| 982 |
} |
| 983 |
EXPORT_SYMBOL_GPL(rtl_p2p_info); |