1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* Copyright(c) 2019-2020 Realtek Corporation 3 */ 4 5 #include "chan.h" 6 #include "coex.h" 7 #include "core.h" 8 #include "debug.h" 9 #include "fw.h" 10 #include "mac.h" 11 #include "phy.h" 12 #include "ps.h" 13 #include "reg.h" 14 #include "util.h" 15 16 static int rtw89_fw_receive_lps_h2c_check(struct rtw89_dev *rtwdev, u8 macid) 17 { 18 struct rtw89_mac_c2h_info c2h_info = {}; 19 u16 c2hreg_macid; 20 u32 c2hreg_ret; 21 int ret; 22 23 if (!RTW89_CHK_FW_FEATURE(LPS_DACK_BY_C2H_REG, &rtwdev->fw)) 24 return 0; 25 26 c2h_info.id = RTW89_FWCMD_C2HREG_FUNC_PS_LEAVE_ACK; 27 ret = rtw89_fw_msg_reg(rtwdev, NULL, &c2h_info); 28 if (ret) 29 return ret; 30 31 c2hreg_macid = u32_get_bits(c2h_info.u.c2hreg[0], 32 RTW89_C2HREG_PS_LEAVE_ACK_MACID); 33 c2hreg_ret = u32_get_bits(c2h_info.u.c2hreg[1], RTW89_C2HREG_PS_LEAVE_ACK_RET); 34 35 if (macid != c2hreg_macid || c2hreg_ret) 36 rtw89_warn(rtwdev, "rtw89: check lps h2c received by firmware fail\n"); 37 38 return 0; 39 } 40 41 static int rtw89_fw_leave_lps_check(struct rtw89_dev *rtwdev, u8 macid) 42 { 43 const struct rtw89_mac_gen_def *mac = rtwdev->chip->mac_def; 44 u32 pwr_en_bit = 0xE; 45 u32 chk_msk = pwr_en_bit << (4 * macid); 46 u32 polling; 47 int ret; 48 49 ret = read_poll_timeout_atomic(rtw89_read32_mask, polling, !polling, 50 1000, 50000, false, rtwdev, 51 mac->ps_status, chk_msk); 52 if (ret) { 53 rtw89_info(rtwdev, "rtw89: failed to leave lps state\n"); 54 return -EBUSY; 55 } 56 57 return 0; 58 } 59 60 static void rtw89_ps_power_mode_change_with_hci(struct rtw89_dev *rtwdev, 61 bool enter) 62 { 63 ieee80211_stop_queues(rtwdev->hw); 64 rtwdev->hci.paused = true; 65 flush_work(&rtwdev->txq_work); 66 ieee80211_wake_queues(rtwdev->hw); 67 68 rtw89_hci_pause(rtwdev, true); 69 rtw89_mac_power_mode_change(rtwdev, enter); 70 rtw89_hci_switch_mode(rtwdev, enter); 71 rtw89_hci_pause(rtwdev, false); 72 73 rtwdev->hci.paused = false; 74 75 if (!enter) { 76 local_bh_disable(); 77 napi_schedule(&rtwdev->napi); 78 local_bh_enable(); 79 } 80 } 81 82 static void rtw89_ps_power_mode_change(struct rtw89_dev *rtwdev, bool enter) 83 { 84 if (rtwdev->chip->low_power_hci_modes & BIT(rtwdev->ps_mode) && 85 !test_bit(RTW89_FLAG_WOWLAN, rtwdev->flags)) 86 rtw89_ps_power_mode_change_with_hci(rtwdev, enter); 87 else 88 rtw89_mac_power_mode_change(rtwdev, enter); 89 } 90 91 void __rtw89_enter_ps_mode(struct rtw89_dev *rtwdev) 92 { 93 if (!rtwdev->ps_mode) 94 return; 95 96 if (test_and_set_bit(RTW89_FLAG_LOW_POWER_MODE, rtwdev->flags)) 97 return; 98 99 rtw89_ps_power_mode_change(rtwdev, true); 100 } 101 102 void __rtw89_leave_ps_mode(struct rtw89_dev *rtwdev) 103 { 104 if (!rtwdev->ps_mode) 105 return; 106 107 if (test_and_clear_bit(RTW89_FLAG_LOW_POWER_MODE, rtwdev->flags)) 108 rtw89_ps_power_mode_change(rtwdev, false); 109 } 110 111 static void __rtw89_enter_lps_link(struct rtw89_dev *rtwdev, 112 struct rtw89_vif_link *rtwvif_link) 113 { 114 struct rtw89_lps_parm lps_param = { 115 .macid = rtwvif_link->mac_id, 116 .psmode = RTW89_MAC_AX_PS_MODE_LEGACY, 117 .lastrpwm = RTW89_LAST_RPWM_PS, 118 }; 119 120 rtw89_btc_ntfy_radio_state(rtwdev, BTC_RFCTRL_FW_CTRL); 121 rtw89_fw_h2c_lps_parm(rtwdev, &lps_param); 122 123 if (RTW89_CHK_FW_FEATURE(BEACON_TRACKING, &rtwdev->fw)) 124 rtw89_fw_h2c_pwr_lvl(rtwdev, rtwvif_link); 125 } 126 127 static void __rtw89_leave_lps(struct rtw89_dev *rtwdev, 128 struct rtw89_vif_link *rtwvif_link) 129 { 130 struct rtw89_lps_parm lps_param = { 131 .macid = rtwvif_link->mac_id, 132 .psmode = RTW89_MAC_AX_PS_MODE_ACTIVE, 133 .lastrpwm = RTW89_LAST_RPWM_ACTIVE, 134 }; 135 136 rtw89_fw_h2c_lps_parm(rtwdev, &lps_param); 137 rtw89_fw_receive_lps_h2c_check(rtwdev, rtwvif_link->mac_id); 138 rtw89_fw_leave_lps_check(rtwdev, rtwvif_link->mac_id); 139 rtw89_btc_ntfy_radio_state(rtwdev, BTC_RFCTRL_WL_ON); 140 rtw89_chip_digital_pwr_comp(rtwdev, rtwvif_link->phy_idx); 141 } 142 143 void rtw89_leave_ps_mode(struct rtw89_dev *rtwdev) 144 { 145 lockdep_assert_wiphy(rtwdev->hw->wiphy); 146 147 __rtw89_leave_ps_mode(rtwdev); 148 } 149 150 void rtw89_enter_lps(struct rtw89_dev *rtwdev, struct rtw89_vif *rtwvif, 151 bool ps_mode) 152 { 153 struct rtw89_vif_link *rtwvif_link; 154 bool can_ps_mode = true; 155 unsigned int link_id; 156 157 lockdep_assert_wiphy(rtwdev->hw->wiphy); 158 159 if (test_and_set_bit(RTW89_FLAG_LEISURE_PS, rtwdev->flags)) 160 return; 161 162 rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) { 163 __rtw89_enter_lps_link(rtwdev, rtwvif_link); 164 165 if (rtwvif_link->wifi_role == RTW89_WIFI_ROLE_P2P_CLIENT) 166 can_ps_mode = false; 167 } 168 169 rtw89_fw_h2c_rf_ps_info(rtwdev, rtwvif); 170 171 if (RTW89_CHK_FW_FEATURE(LPS_CH_INFO, &rtwdev->fw)) 172 rtw89_fw_h2c_lps_ch_info(rtwdev, rtwvif); 173 else 174 rtw89_fw_h2c_lps_ml_cmn_info(rtwdev, rtwvif); 175 176 if (ps_mode && can_ps_mode) 177 __rtw89_enter_ps_mode(rtwdev); 178 } 179 180 static void rtw89_leave_lps_vif(struct rtw89_dev *rtwdev, 181 struct rtw89_vif_link *rtwvif_link) 182 { 183 if (rtwvif_link->wifi_role != RTW89_WIFI_ROLE_STATION && 184 rtwvif_link->wifi_role != RTW89_WIFI_ROLE_P2P_CLIENT) 185 return; 186 187 __rtw89_leave_lps(rtwdev, rtwvif_link); 188 } 189 190 void rtw89_leave_lps(struct rtw89_dev *rtwdev) 191 { 192 struct rtw89_vif_link *rtwvif_link; 193 struct rtw89_vif *rtwvif; 194 unsigned int link_id; 195 196 lockdep_assert_wiphy(rtwdev->hw->wiphy); 197 198 if (!test_and_clear_bit(RTW89_FLAG_LEISURE_PS, rtwdev->flags)) 199 return; 200 201 __rtw89_leave_ps_mode(rtwdev); 202 203 rtw89_phy_dm_reinit(rtwdev); 204 205 rtw89_for_each_rtwvif(rtwdev, rtwvif) 206 rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) 207 rtw89_leave_lps_vif(rtwdev, rtwvif_link); 208 } 209 210 void rtw89_enter_ips(struct rtw89_dev *rtwdev) 211 { 212 struct rtw89_vif_link *rtwvif_link; 213 struct rtw89_vif *rtwvif; 214 unsigned int link_id; 215 216 set_bit(RTW89_FLAG_INACTIVE_PS, rtwdev->flags); 217 218 if (!test_bit(RTW89_FLAG_POWERON, rtwdev->flags)) 219 return; 220 221 rtw89_for_each_rtwvif(rtwdev, rtwvif) 222 rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) 223 rtw89_mac_vif_deinit(rtwdev, rtwvif_link); 224 225 rtw89_core_stop(rtwdev); 226 } 227 228 void rtw89_leave_ips(struct rtw89_dev *rtwdev) 229 { 230 struct rtw89_vif_link *rtwvif_link; 231 struct rtw89_vif *rtwvif; 232 unsigned int link_id; 233 int ret; 234 235 if (test_bit(RTW89_FLAG_POWERON, rtwdev->flags)) 236 return; 237 238 ret = rtw89_core_start(rtwdev); 239 if (ret) 240 rtw89_err(rtwdev, "failed to leave idle state\n"); 241 242 rtw89_set_channel(rtwdev); 243 244 rtw89_for_each_rtwvif(rtwdev, rtwvif) 245 rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) 246 rtw89_mac_vif_init(rtwdev, rtwvif_link); 247 248 clear_bit(RTW89_FLAG_INACTIVE_PS, rtwdev->flags); 249 } 250 251 void rtw89_set_coex_ctrl_lps(struct rtw89_dev *rtwdev, bool btc_ctrl) 252 { 253 if (btc_ctrl) 254 rtw89_leave_lps(rtwdev); 255 } 256 257 static void rtw89_tsf32_toggle(struct rtw89_dev *rtwdev, 258 struct rtw89_vif_link *rtwvif_link, 259 enum rtw89_p2pps_action act) 260 { 261 if (act == RTW89_P2P_ACT_UPDATE || act == RTW89_P2P_ACT_REMOVE) 262 return; 263 264 if (act == RTW89_P2P_ACT_INIT) 265 rtw89_fw_h2c_tsf32_toggle(rtwdev, rtwvif_link, true); 266 else if (act == RTW89_P2P_ACT_TERMINATE) 267 rtw89_fw_h2c_tsf32_toggle(rtwdev, rtwvif_link, false); 268 } 269 270 void rtw89_p2p_disable_all_noa(struct rtw89_dev *rtwdev, 271 struct rtw89_vif_link *rtwvif_link, 272 struct ieee80211_bss_conf *bss_conf) 273 { 274 enum rtw89_p2pps_action act; 275 u8 oppps_ctwindow; 276 u8 noa_id; 277 278 rcu_read_lock(); 279 280 if (!bss_conf) 281 bss_conf = rtw89_vif_rcu_dereference_link(rtwvif_link, true); 282 283 oppps_ctwindow = bss_conf->p2p_noa_attr.oppps_ctwindow; 284 285 rcu_read_unlock(); 286 287 if (rtwvif_link->last_noa_nr == 0) 288 return; 289 290 for (noa_id = 0; noa_id < rtwvif_link->last_noa_nr; noa_id++) { 291 if (noa_id == rtwvif_link->last_noa_nr - 1) 292 act = RTW89_P2P_ACT_TERMINATE; 293 else 294 act = RTW89_P2P_ACT_REMOVE; 295 rtw89_tsf32_toggle(rtwdev, rtwvif_link, act); 296 rtw89_fw_h2c_p2p_act(rtwdev, rtwvif_link, NULL, 297 act, noa_id, oppps_ctwindow); 298 } 299 } 300 301 static void rtw89_p2p_update_noa(struct rtw89_dev *rtwdev, 302 struct rtw89_vif_link *rtwvif_link, 303 struct ieee80211_bss_conf *bss_conf) 304 { 305 struct ieee80211_p2p_noa_desc *desc; 306 enum rtw89_p2pps_action act; 307 u8 noa_id; 308 309 for (noa_id = 0; noa_id < RTW89_P2P_MAX_NOA_NUM; noa_id++) { 310 desc = &bss_conf->p2p_noa_attr.desc[noa_id]; 311 if (!desc->count || !desc->duration) 312 break; 313 314 if (noa_id == 0) 315 act = RTW89_P2P_ACT_INIT; 316 else 317 act = RTW89_P2P_ACT_UPDATE; 318 rtw89_tsf32_toggle(rtwdev, rtwvif_link, act); 319 rtw89_fw_h2c_p2p_act(rtwdev, rtwvif_link, desc, act, noa_id, 320 bss_conf->p2p_noa_attr.oppps_ctwindow); 321 } 322 rtwvif_link->last_noa_nr = noa_id; 323 } 324 325 void rtw89_process_p2p_ps(struct rtw89_dev *rtwdev, 326 struct rtw89_vif_link *rtwvif_link, 327 struct ieee80211_bss_conf *bss_conf) 328 { 329 rtw89_p2p_disable_all_noa(rtwdev, rtwvif_link, bss_conf); 330 rtw89_p2p_update_noa(rtwdev, rtwvif_link, bss_conf); 331 } 332 333 void rtw89_recalc_lps(struct rtw89_dev *rtwdev) 334 { 335 struct ieee80211_vif *vif, *found_vif = NULL; 336 struct rtw89_vif *rtwvif; 337 enum rtw89_entity_mode mode; 338 int count = 0; 339 340 mode = rtw89_get_entity_mode(rtwdev); 341 if (mode == RTW89_ENTITY_MODE_MCC) 342 goto disable_lps; 343 344 rtw89_for_each_rtwvif(rtwdev, rtwvif) { 345 vif = rtwvif_to_vif(rtwvif); 346 347 if (vif->type != NL80211_IFTYPE_STATION) { 348 count = 0; 349 break; 350 } 351 352 count++; 353 found_vif = vif; 354 } 355 356 if (count == 1 && found_vif->cfg.ps) { 357 rtwdev->lps_enabled = true; 358 return; 359 } 360 361 disable_lps: 362 rtw89_leave_lps(rtwdev); 363 rtwdev->lps_enabled = false; 364 } 365 366 void rtw89_p2p_noa_renew(struct rtw89_vif_link *rtwvif_link) 367 { 368 struct rtw89_p2p_noa_setter *setter = &rtwvif_link->p2p_noa; 369 struct rtw89_p2p_noa_ie *ie = &setter->ie; 370 struct rtw89_p2p_ie_head *p2p_head = &ie->p2p_head; 371 struct rtw89_noa_attr_head *noa_head = &ie->noa_head; 372 373 if (setter->noa_count) { 374 setter->noa_index++; 375 setter->noa_count = 0; 376 } 377 378 memset(ie, 0, sizeof(*ie)); 379 380 p2p_head->eid = WLAN_EID_VENDOR_SPECIFIC; 381 p2p_head->ie_len = 4 + sizeof(*noa_head); 382 p2p_head->oui[0] = (WLAN_OUI_WFA >> 16) & 0xff; 383 p2p_head->oui[1] = (WLAN_OUI_WFA >> 8) & 0xff; 384 p2p_head->oui[2] = (WLAN_OUI_WFA >> 0) & 0xff; 385 p2p_head->oui_type = WLAN_OUI_TYPE_WFA_P2P; 386 387 noa_head->attr_type = IEEE80211_P2P_ATTR_ABSENCE_NOTICE; 388 noa_head->attr_len = cpu_to_le16(2); 389 noa_head->index = setter->noa_index; 390 noa_head->oppps_ctwindow = 0; 391 } 392 393 void rtw89_p2p_noa_append(struct rtw89_vif_link *rtwvif_link, 394 const struct ieee80211_p2p_noa_desc *desc) 395 { 396 struct rtw89_p2p_noa_setter *setter = &rtwvif_link->p2p_noa; 397 struct rtw89_p2p_noa_ie *ie = &setter->ie; 398 struct rtw89_p2p_ie_head *p2p_head = &ie->p2p_head; 399 struct rtw89_noa_attr_head *noa_head = &ie->noa_head; 400 401 if (!desc->count || !desc->duration) 402 return; 403 404 if (setter->noa_count >= RTW89_P2P_MAX_NOA_NUM) 405 return; 406 407 p2p_head->ie_len += sizeof(*desc); 408 le16_add_cpu(&noa_head->attr_len, sizeof(*desc)); 409 410 ie->noa_desc[setter->noa_count++] = *desc; 411 } 412 413 u8 rtw89_p2p_noa_fetch(struct rtw89_vif_link *rtwvif_link, void **data) 414 { 415 struct rtw89_p2p_noa_setter *setter = &rtwvif_link->p2p_noa; 416 struct rtw89_p2p_noa_ie *ie = &setter->ie; 417 void *tail; 418 419 if (!setter->noa_count) 420 return 0; 421 422 *data = ie; 423 tail = ie->noa_desc + setter->noa_count; 424 return tail - *data; 425 } 426 427 static void rtw89_ps_noa_once_set_work(struct wiphy *wiphy, struct wiphy_work *work) 428 { 429 struct rtw89_ps_noa_once_handler *noa_once = 430 container_of(work, struct rtw89_ps_noa_once_handler, set_work.work); 431 432 lockdep_assert_wiphy(wiphy); 433 434 noa_once->in_duration = true; 435 } 436 437 static void rtw89_ps_noa_once_clr_work(struct wiphy *wiphy, struct wiphy_work *work) 438 { 439 struct rtw89_ps_noa_once_handler *noa_once = 440 container_of(work, struct rtw89_ps_noa_once_handler, clr_work.work); 441 struct rtw89_vif_link *rtwvif_link = 442 container_of(noa_once, struct rtw89_vif_link, noa_once); 443 struct rtw89_dev *rtwdev = rtwvif_link->rtwvif->rtwdev; 444 445 lockdep_assert_wiphy(wiphy); 446 447 rtw89_fw_h2c_set_bcn_fltr_cfg(rtwdev, rtwvif_link, true); 448 noa_once->in_duration = false; 449 } 450 451 void rtw89_p2p_noa_once_init(struct rtw89_vif_link *rtwvif_link) 452 { 453 struct rtw89_ps_noa_once_handler *noa_once = &rtwvif_link->noa_once; 454 455 noa_once->in_duration = false; 456 noa_once->tsf_begin = 0; 457 noa_once->tsf_end = 0; 458 459 wiphy_delayed_work_init(&noa_once->set_work, rtw89_ps_noa_once_set_work); 460 wiphy_delayed_work_init(&noa_once->clr_work, rtw89_ps_noa_once_clr_work); 461 } 462 463 static void rtw89_p2p_noa_once_cancel(struct rtw89_vif_link *rtwvif_link) 464 { 465 struct rtw89_ps_noa_once_handler *noa_once = &rtwvif_link->noa_once; 466 struct rtw89_dev *rtwdev = rtwvif_link->rtwvif->rtwdev; 467 struct wiphy *wiphy = rtwdev->hw->wiphy; 468 469 wiphy_delayed_work_cancel(wiphy, &noa_once->set_work); 470 wiphy_delayed_work_cancel(wiphy, &noa_once->clr_work); 471 } 472 473 void rtw89_p2p_noa_once_deinit(struct rtw89_vif_link *rtwvif_link) 474 { 475 rtw89_p2p_noa_once_cancel(rtwvif_link); 476 rtw89_p2p_noa_once_init(rtwvif_link); 477 } 478 479 void rtw89_p2p_noa_once_recalc(struct rtw89_vif_link *rtwvif_link) 480 { 481 struct rtw89_ps_noa_once_handler *noa_once = &rtwvif_link->noa_once; 482 struct rtw89_dev *rtwdev = rtwvif_link->rtwvif->rtwdev; 483 const struct ieee80211_p2p_noa_desc *noa_desc; 484 struct wiphy *wiphy = rtwdev->hw->wiphy; 485 struct ieee80211_bss_conf *bss_conf; 486 u64 tsf_begin = U64_MAX, tsf_end; 487 u64 set_delay_us = 0; 488 u64 clr_delay_us = 0; 489 u32 start_time; 490 u32 interval; 491 u32 duration; 492 u64 tsf; 493 int ret; 494 int i; 495 496 lockdep_assert_wiphy(wiphy); 497 498 ret = rtw89_mac_port_get_tsf(rtwdev, rtwvif_link, &tsf); 499 if (ret) { 500 rtw89_warn(rtwdev, "%s: failed to get tsf\n", __func__); 501 return; 502 } 503 504 rcu_read_lock(); 505 506 bss_conf = rtw89_vif_rcu_dereference_link(rtwvif_link, true); 507 508 for (i = 0; i < ARRAY_SIZE(bss_conf->p2p_noa_attr.desc); i++) { 509 bool first = tsf_begin == U64_MAX; 510 u64 tmp; 511 512 noa_desc = &bss_conf->p2p_noa_attr.desc[i]; 513 if (noa_desc->count == 0 || noa_desc->count == 255) 514 continue; 515 516 start_time = le32_to_cpu(noa_desc->start_time); 517 interval = le32_to_cpu(noa_desc->interval); 518 duration = le32_to_cpu(noa_desc->duration); 519 520 if (unlikely(duration == 0 || 521 (noa_desc->count > 1 && interval == 0))) 522 continue; 523 524 tmp = start_time + interval * (noa_desc->count - 1) + duration; 525 tmp = (tsf & GENMASK_ULL(63, 32)) + tmp; 526 if (unlikely(tmp <= tsf)) 527 continue; 528 tsf_end = first ? tmp : max(tsf_end, tmp); 529 530 tmp = (tsf & GENMASK_ULL(63, 32)) | start_time; 531 tsf_begin = first ? tmp : min(tsf_begin, tmp); 532 } 533 534 rcu_read_unlock(); 535 536 if (tsf_begin == U64_MAX) 537 return; 538 539 rtw89_p2p_noa_once_cancel(rtwvif_link); 540 541 if (noa_once->tsf_end > tsf) { 542 tsf_begin = min(tsf_begin, noa_once->tsf_begin); 543 tsf_end = max(tsf_end, noa_once->tsf_end); 544 } 545 546 clr_delay_us = min_t(u64, tsf_end - tsf, UINT_MAX); 547 548 if (tsf_begin <= tsf) { 549 noa_once->in_duration = true; 550 goto out; 551 } 552 553 set_delay_us = tsf_begin - tsf; 554 if (unlikely(set_delay_us > UINT_MAX)) { 555 rtw89_warn(rtwdev, "%s: unhandled begin\n", __func__); 556 set_delay_us = 0; 557 clr_delay_us = 0; 558 rtw89_fw_h2c_set_bcn_fltr_cfg(rtwdev, rtwvif_link, true); 559 noa_once->in_duration = false; 560 } 561 562 out: 563 if (set_delay_us) 564 wiphy_delayed_work_queue(wiphy, &noa_once->set_work, 565 usecs_to_jiffies(set_delay_us)); 566 if (clr_delay_us) 567 wiphy_delayed_work_queue(wiphy, &noa_once->clr_work, 568 usecs_to_jiffies(clr_delay_us)); 569 570 noa_once->tsf_begin = tsf_begin; 571 noa_once->tsf_end = tsf_end; 572 } 573