1 /* 2 * Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include <osdep.h> 21 #include "wmi.h" 22 #include "wmi_unified_priv.h" 23 #include "wmi_unified_twt_param.h" 24 #include "wmi_unified_twt_api.h" 25 26 #if defined(WLAN_SUPPORT_TWT) && defined(WLAN_TWT_CONV_SUPPORTED) 27 static QDF_STATUS send_twt_enable_cmd_tlv(wmi_unified_t wmi_handle, 28 struct twt_enable_param *params) 29 { 30 wmi_twt_enable_cmd_fixed_param *cmd; 31 wmi_buf_t buf; 32 QDF_STATUS status; 33 34 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 35 if (!buf) { 36 wmi_err("Failed to allocate memory"); 37 return QDF_STATUS_E_FAILURE; 38 } 39 40 cmd = (wmi_twt_enable_cmd_fixed_param *)wmi_buf_data(buf); 41 WMITLV_SET_HDR(&cmd->tlv_header, 42 WMITLV_TAG_STRUC_wmi_twt_enable_cmd_fixed_param, 43 WMITLV_GET_STRUCT_TLVLEN 44 (wmi_twt_enable_cmd_fixed_param)); 45 46 cmd->pdev_id = 47 wmi_handle->ops->convert_pdev_id_host_to_target( 48 wmi_handle, 49 params->pdev_id); 50 cmd->sta_cong_timer_ms = params->sta_cong_timer_ms; 51 cmd->mbss_support = params->mbss_support; 52 cmd->default_slot_size = params->default_slot_size; 53 cmd->congestion_thresh_setup = params->congestion_thresh_setup; 54 cmd->congestion_thresh_teardown = params->congestion_thresh_teardown; 55 cmd->congestion_thresh_critical = params->congestion_thresh_critical; 56 cmd->interference_thresh_teardown = 57 params->interference_thresh_teardown; 58 cmd->interference_thresh_setup = params->interference_thresh_setup; 59 cmd->min_no_sta_setup = params->min_no_sta_setup; 60 cmd->min_no_sta_teardown = params->min_no_sta_teardown; 61 cmd->no_of_bcast_mcast_slots = params->no_of_bcast_mcast_slots; 62 cmd->min_no_twt_slots = params->min_no_twt_slots; 63 cmd->max_no_sta_twt = params->max_no_sta_twt; 64 cmd->mode_check_interval = params->mode_check_interval; 65 cmd->add_sta_slot_interval = params->add_sta_slot_interval; 66 cmd->remove_sta_slot_interval = params->remove_sta_slot_interval; 67 68 TWT_EN_DIS_FLAGS_SET_BTWT(cmd->flags, params->b_twt_enable); 69 TWT_EN_DIS_FLAGS_SET_B_R_TWT(cmd->flags, params->r_twt_enable); 70 TWT_EN_DIS_FLAGS_SET_L_MBSSID(cmd->flags, 71 params->b_twt_legacy_mbss_enable); 72 TWT_EN_DIS_FLAGS_SET_AX_MBSSID(cmd->flags, 73 params->b_twt_ax_mbss_enable); 74 if (params->ext_conf_present) { 75 TWT_EN_DIS_FLAGS_SET_SPLIT_CONFIG(cmd->flags, 1); 76 TWT_EN_DIS_FLAGS_SET_REQ_RESP(cmd->flags, params->twt_role); 77 TWT_EN_DIS_FLAGS_SET_I_B_TWT(cmd->flags, params->twt_oper); 78 } 79 80 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 81 WMI_TWT_ENABLE_CMDID); 82 if (QDF_IS_STATUS_ERROR(status)) { 83 wmi_err("Failed to send WMI_TWT_ENABLE_CMDID"); 84 wmi_buf_free(buf); 85 } 86 87 return status; 88 } 89 90 static WMI_DISABLE_TWT_REASON_T 91 wmi_convert_dis_reason_code(enum HOST_TWT_DISABLE_REASON reason) 92 { 93 switch (reason) { 94 case HOST_TWT_DISABLE_REASON_NONE: 95 return WMI_DISABLE_TWT_REASON_NONE; 96 case HOST_TWT_DISABLE_REASON_CONCURRENCY_SCC: 97 return WMI_DISABLE_TWT_REASON_CONCURRENCY_SCC; 98 case HOST_TWT_DISABLE_REASON_CONCURRENCY_MCC: 99 return WMI_DISABLE_TWT_REASON_CONCURRENCY_MCC; 100 case HOST_TWT_DISABLE_REASON_CHANGE_CONGESTION_TIMEOUT: 101 return WMI_DISABLE_TWT_REASON_CHANGE_CONGESTION_TIMEOUT; 102 case HOST_TWT_DISABLE_REASON_P2P_GO_NOA: 103 return WMI_DISABLE_TWT_REASON_P2P_GO_NOA; 104 default: 105 return WMI_DISABLE_TWT_REASON_NONE; 106 } 107 } 108 109 static QDF_STATUS send_twt_disable_cmd_tlv(wmi_unified_t wmi_handle, 110 struct twt_disable_param *params) 111 { 112 wmi_twt_disable_cmd_fixed_param *cmd; 113 wmi_buf_t buf; 114 QDF_STATUS status; 115 116 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 117 if (!buf) { 118 wmi_err("Failed to allocate memory"); 119 return QDF_STATUS_E_FAILURE; 120 } 121 122 cmd = (wmi_twt_disable_cmd_fixed_param *)wmi_buf_data(buf); 123 WMITLV_SET_HDR(&cmd->tlv_header, 124 WMITLV_TAG_STRUC_wmi_twt_disable_cmd_fixed_param, 125 WMITLV_GET_STRUCT_TLVLEN 126 (wmi_twt_disable_cmd_fixed_param)); 127 128 cmd->pdev_id = 129 wmi_handle->ops->convert_pdev_id_host_to_target( 130 wmi_handle, 131 params->pdev_id); 132 if (params->ext_conf_present) { 133 TWT_EN_DIS_FLAGS_SET_SPLIT_CONFIG(cmd->flags, 1); 134 TWT_EN_DIS_FLAGS_SET_REQ_RESP(cmd->flags, params->twt_role); 135 TWT_EN_DIS_FLAGS_SET_I_B_TWT(cmd->flags, params->twt_oper); 136 } 137 138 cmd->reason_code = wmi_convert_dis_reason_code( 139 params->dis_reason_code); 140 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 141 WMI_TWT_DISABLE_CMDID); 142 if (QDF_IS_STATUS_ERROR(status)) { 143 wmi_err("Failed to send WMI_TWT_DISABLE_CMDID"); 144 wmi_buf_free(buf); 145 } 146 147 return status; 148 } 149 150 #ifdef WLAN_SUPPORT_BCAST_TWT 151 static void 152 twt_add_dialog_set_bcast_twt_params(struct twt_add_dialog_param *params, 153 wmi_twt_add_dialog_cmd_fixed_param *cmd) 154 { 155 TWT_FLAGS_SET_BTWT_ID0(cmd->flags, params->flag_b_twt_id0); 156 cmd->b_twt_persistence = params->b_twt_persistence; 157 cmd->b_twt_recommendation = params->b_twt_recommendation; 158 } 159 #else 160 static void 161 twt_add_dialog_set_bcast_twt_params(struct twt_add_dialog_param *params, 162 wmi_twt_add_dialog_cmd_fixed_param *cmd) 163 { 164 } 165 #endif 166 167 static QDF_STATUS 168 send_twt_add_dialog_cmd_tlv(wmi_unified_t wmi_handle, 169 struct twt_add_dialog_param *params) 170 { 171 wmi_twt_add_dialog_cmd_fixed_param *cmd; 172 wmi_buf_t buf; 173 QDF_STATUS status; 174 175 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 176 if (!buf) { 177 wmi_err("Failed to allocate memory"); 178 return QDF_STATUS_E_FAILURE; 179 } 180 181 cmd = (wmi_twt_add_dialog_cmd_fixed_param *)wmi_buf_data(buf); 182 WMITLV_SET_HDR(&cmd->tlv_header, 183 WMITLV_TAG_STRUC_wmi_twt_add_dialog_cmd_fixed_param, 184 WMITLV_GET_STRUCT_TLVLEN 185 (wmi_twt_add_dialog_cmd_fixed_param)); 186 187 cmd->vdev_id = params->vdev_id; 188 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, 189 &cmd->peer_macaddr); 190 cmd->dialog_id = params->dialog_id; 191 cmd->wake_intvl_us = params->wake_intvl_us; 192 cmd->wake_intvl_mantis = params->wake_intvl_mantis; 193 cmd->wake_dura_us = params->wake_dura_us; 194 cmd->sp_offset_us = params->sp_offset_us; 195 cmd->min_wake_intvl_us = params->min_wake_intvl_us; 196 cmd->max_wake_intvl_us = params->max_wake_intvl_us; 197 cmd->min_wake_dura_us = params->min_wake_dura_us; 198 cmd->max_wake_dura_us = params->max_wake_dura_us; 199 cmd->sp_start_tsf_lo = (uint32_t)(params->wake_time_tsf & 0xFFFFFFFF); 200 cmd->sp_start_tsf_hi = (uint32_t)(params->wake_time_tsf >> 32); 201 cmd->announce_timeout_us = params->announce_timeout_us; 202 cmd->link_id_bitmap = params->link_id_bitmap; 203 cmd->r_twt_dl_tid_bitmap = params->r_twt_dl_tid_bitmap; 204 cmd->r_twt_ul_tid_bitmap = params->r_twt_ul_tid_bitmap; 205 TWT_FLAGS_SET_CMD(cmd->flags, params->twt_cmd); 206 TWT_FLAGS_SET_BROADCAST(cmd->flags, params->flag_bcast); 207 TWT_FLAGS_SET_TRIGGER(cmd->flags, params->flag_trigger); 208 TWT_FLAGS_SET_FLOW_TYPE(cmd->flags, params->flag_flow_type); 209 TWT_FLAGS_SET_PROTECTION(cmd->flags, params->flag_protection); 210 211 twt_add_dialog_set_bcast_twt_params(params, cmd); 212 213 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 214 WMI_TWT_ADD_DIALOG_CMDID); 215 if (QDF_IS_STATUS_ERROR(status)) { 216 wmi_err("Failed to send WMI_TWT_ADD_DIALOG_CMDID"); 217 wmi_buf_free(buf); 218 } 219 220 return status; 221 } 222 223 #ifdef WLAN_SUPPORT_BCAST_TWT 224 static void 225 twt_del_dialog_set_bcast_twt_params(struct twt_del_dialog_param *params, 226 wmi_twt_del_dialog_cmd_fixed_param *cmd) 227 { 228 cmd->b_twt_persistence = params->b_twt_persistence; 229 } 230 #else 231 static void 232 twt_del_dialog_set_bcast_twt_params(struct twt_del_dialog_param *params, 233 wmi_twt_del_dialog_cmd_fixed_param *cmd) 234 { 235 } 236 #endif 237 238 static QDF_STATUS 239 send_twt_del_dialog_cmd_tlv(wmi_unified_t wmi_handle, 240 struct twt_del_dialog_param *params) 241 { 242 wmi_twt_del_dialog_cmd_fixed_param *cmd; 243 wmi_buf_t buf; 244 QDF_STATUS status; 245 246 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 247 if (!buf) { 248 wmi_err("Failed to allocate memory"); 249 return QDF_STATUS_E_FAILURE; 250 } 251 252 cmd = (wmi_twt_del_dialog_cmd_fixed_param *)wmi_buf_data(buf); 253 WMITLV_SET_HDR(&cmd->tlv_header, 254 WMITLV_TAG_STRUC_wmi_twt_del_dialog_cmd_fixed_param, 255 WMITLV_GET_STRUCT_TLVLEN 256 (wmi_twt_del_dialog_cmd_fixed_param)); 257 258 cmd->vdev_id = params->vdev_id; 259 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, 260 &cmd->peer_macaddr); 261 cmd->dialog_id = params->dialog_id; 262 263 twt_del_dialog_set_bcast_twt_params(params, cmd); 264 265 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 266 WMI_TWT_DEL_DIALOG_CMDID); 267 if (QDF_IS_STATUS_ERROR(status)) { 268 wmi_err("Failed to send WMI_TWT_DEL_DIALOG_CMDID"); 269 wmi_buf_free(buf); 270 } 271 272 return status; 273 } 274 275 static QDF_STATUS 276 send_twt_pause_dialog_cmd_tlv(wmi_unified_t wmi_handle, 277 struct twt_pause_dialog_cmd_param *params) 278 { 279 wmi_twt_pause_dialog_cmd_fixed_param *cmd; 280 wmi_buf_t buf; 281 QDF_STATUS status; 282 283 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 284 if (!buf) { 285 wmi_err("Failed to allocate memory"); 286 return QDF_STATUS_E_FAILURE; 287 } 288 289 cmd = (wmi_twt_pause_dialog_cmd_fixed_param *)wmi_buf_data(buf); 290 WMITLV_SET_HDR(&cmd->tlv_header, 291 WMITLV_TAG_STRUC_wmi_twt_pause_dialog_cmd_fixed_param, 292 WMITLV_GET_STRUCT_TLVLEN 293 (wmi_twt_pause_dialog_cmd_fixed_param)); 294 295 cmd->vdev_id = params->vdev_id; 296 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, 297 &cmd->peer_macaddr); 298 cmd->dialog_id = params->dialog_id; 299 300 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 301 WMI_TWT_PAUSE_DIALOG_CMDID); 302 if (QDF_IS_STATUS_ERROR(status)) { 303 wmi_err("Failed to send WMI_TWT_PAUSE_DIALOG_CMDID"); 304 wmi_buf_free(buf); 305 } 306 307 return status; 308 } 309 310 static QDF_STATUS 311 send_twt_nudge_dialog_cmd_tlv(wmi_unified_t wmi_handle, 312 struct twt_nudge_dialog_cmd_param *params) 313 { 314 wmi_twt_nudge_dialog_cmd_fixed_param *cmd; 315 wmi_buf_t buf; 316 QDF_STATUS status; 317 318 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 319 if (!buf) 320 return QDF_STATUS_E_FAILURE; 321 322 cmd = (wmi_twt_nudge_dialog_cmd_fixed_param *)wmi_buf_data(buf); 323 WMITLV_SET_HDR(&cmd->tlv_header, 324 WMITLV_TAG_STRUC_wmi_twt_nudge_dialog_cmd_fixed_param, 325 WMITLV_GET_STRUCT_TLVLEN 326 (wmi_twt_nudge_dialog_cmd_fixed_param)); 327 328 cmd->vdev_id = params->vdev_id; 329 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, 330 &cmd->peer_macaddr); 331 cmd->dialog_id = params->dialog_id; 332 cmd->suspend_duration_ms = params->suspend_duration / 1000; 333 cmd->next_twt_size = params->next_twt_size; 334 cmd->sp_start_offset = params->sp_start_offset; 335 336 wmi_debug("vdev_id: %d dialog_id: %d duration(in ms): %u next_twt_size: %d " 337 "peer_macaddr: " QDF_MAC_ADDR_FMT " sp_start_offset: %d", 338 cmd->vdev_id, cmd->dialog_id, cmd->suspend_duration_ms, 339 cmd->next_twt_size, 340 QDF_MAC_ADDR_REF(params->peer_macaddr.bytes), 341 cmd->sp_start_offset); 342 343 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 344 WMI_TWT_NUDGE_DIALOG_CMDID); 345 if (QDF_IS_STATUS_ERROR(status)) 346 wmi_buf_free(buf); 347 348 return status; 349 } 350 351 static QDF_STATUS send_twt_resume_dialog_cmd_tlv(wmi_unified_t wmi_handle, 352 struct twt_resume_dialog_cmd_param *params) 353 { 354 wmi_twt_resume_dialog_cmd_fixed_param *cmd; 355 wmi_buf_t buf; 356 QDF_STATUS status; 357 358 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 359 if (!buf) { 360 wmi_err("Failed to allocate memory"); 361 return QDF_STATUS_E_FAILURE; 362 } 363 364 cmd = (wmi_twt_resume_dialog_cmd_fixed_param *)wmi_buf_data(buf); 365 WMITLV_SET_HDR(&cmd->tlv_header, 366 WMITLV_TAG_STRUC_wmi_twt_resume_dialog_cmd_fixed_param, 367 WMITLV_GET_STRUCT_TLVLEN 368 (wmi_twt_resume_dialog_cmd_fixed_param)); 369 370 cmd->vdev_id = params->vdev_id; 371 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, 372 &cmd->peer_macaddr); 373 cmd->dialog_id = params->dialog_id; 374 cmd->sp_offset_us = params->sp_offset_us; 375 cmd->next_twt_size = params->next_twt_size; 376 377 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 378 WMI_TWT_RESUME_DIALOG_CMDID); 379 if (QDF_IS_STATUS_ERROR(status)) { 380 wmi_err("Failed to send WMI_TWT_RESUME_DIALOG_CMDID"); 381 wmi_buf_free(buf); 382 } 383 384 return status; 385 } 386 387 #ifdef WLAN_SUPPORT_BCAST_TWT 388 static QDF_STATUS 389 send_twt_btwt_invite_sta_cmd_tlv(wmi_unified_t wmi_handle, 390 struct twt_btwt_invite_sta_cmd_param *params) 391 { 392 wmi_twt_btwt_invite_sta_cmd_fixed_param *cmd; 393 wmi_buf_t buf; 394 QDF_STATUS status; 395 396 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 397 if (!buf) { 398 wmi_err("Failed to allocate memory"); 399 return QDF_STATUS_E_FAILURE; 400 } 401 402 cmd = (wmi_twt_btwt_invite_sta_cmd_fixed_param *)wmi_buf_data(buf); 403 WMITLV_SET_HDR(&cmd->tlv_header, 404 WMITLV_TAG_STRUC_wmi_twt_btwt_invite_sta_cmd_fixed_param, 405 WMITLV_GET_STRUCT_TLVLEN 406 (wmi_twt_btwt_invite_sta_cmd_fixed_param)); 407 408 cmd->vdev_id = params->vdev_id; 409 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, 410 &cmd->peer_macaddr); 411 cmd->dialog_id = params->dialog_id; 412 cmd->r_twt_dl_tid_bitmap = params->r_twt_dl_tid_bitmap; 413 cmd->r_twt_ul_tid_bitmap = params->r_twt_ul_tid_bitmap; 414 415 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 416 WMI_TWT_BTWT_INVITE_STA_CMDID); 417 if (QDF_IS_STATUS_ERROR(status)) { 418 wmi_buf_free(buf); 419 wmi_err("Failed to send WMI_TWT_BTWT_INVITE_STA_CMDID"); 420 } 421 422 return status; 423 } 424 425 static QDF_STATUS 426 send_twt_btwt_remove_sta_cmd_tlv(wmi_unified_t wmi_handle, 427 struct twt_btwt_remove_sta_cmd_param 428 *params) 429 { 430 wmi_twt_btwt_remove_sta_cmd_fixed_param *cmd; 431 wmi_buf_t buf; 432 QDF_STATUS status; 433 434 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 435 if (!buf) { 436 wmi_err("Failed to allocate memory"); 437 return QDF_STATUS_E_FAILURE; 438 } 439 440 cmd = (wmi_twt_btwt_remove_sta_cmd_fixed_param *)wmi_buf_data(buf); 441 WMITLV_SET_HDR(&cmd->tlv_header, 442 WMITLV_TAG_STRUC_wmi_twt_btwt_remove_sta_cmd_fixed_param, 443 WMITLV_GET_STRUCT_TLVLEN 444 (wmi_twt_btwt_remove_sta_cmd_fixed_param)); 445 446 cmd->vdev_id = params->vdev_id; 447 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr.bytes, 448 &cmd->peer_macaddr); 449 cmd->dialog_id = params->dialog_id; 450 cmd->r_twt_dl_tid_bitmap = params->r_twt_dl_tid_bitmap; 451 cmd->r_twt_ul_tid_bitmap = params->r_twt_ul_tid_bitmap; 452 453 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 454 WMI_TWT_BTWT_REMOVE_STA_CMDID); 455 if (QDF_IS_STATUS_ERROR(status)) { 456 wmi_buf_free(buf); 457 wmi_err("Failed to send WMI_TWT_BTWT_REMOVE_STA_CMDID"); 458 } 459 460 return status; 461 } 462 #endif 463 464 static enum HOST_TWT_ENABLE_STATUS 465 wmi_twt_enable_status_to_host_twt_status(WMI_ENABLE_TWT_STATUS_T status) 466 { 467 switch (status) { 468 case WMI_ENABLE_TWT_STATUS_OK: 469 return HOST_TWT_ENABLE_STATUS_OK; 470 case WMI_ENABLE_TWT_STATUS_ALREADY_ENABLED: 471 return HOST_TWT_ENABLE_STATUS_ALREADY_ENABLED; 472 case WMI_ENABLE_TWT_STATUS_NOT_READY: 473 return HOST_TWT_ENABLE_STATUS_NOT_READY; 474 case WMI_ENABLE_TWT_INVALID_PARAM: 475 return HOST_TWT_ENABLE_INVALID_PARAM; 476 default: 477 return HOST_TWT_ENABLE_STATUS_UNKNOWN_ERROR; 478 } 479 } 480 481 static QDF_STATUS extract_twt_enable_comp_event_tlv(wmi_unified_t wmi_handle, 482 uint8_t *evt_buf, 483 struct twt_enable_complete_event_param *params) 484 { 485 WMI_TWT_ENABLE_COMPLETE_EVENTID_param_tlvs *param_buf; 486 wmi_twt_enable_complete_event_fixed_param *ev; 487 488 param_buf = (WMI_TWT_ENABLE_COMPLETE_EVENTID_param_tlvs *)evt_buf; 489 if (!param_buf) { 490 wmi_err("evt_buf is NULL"); 491 return QDF_STATUS_E_INVAL; 492 } 493 494 ev = param_buf->fixed_param; 495 496 params->pdev_id = 497 wmi_handle->ops->convert_pdev_id_target_to_host(wmi_handle, 498 ev->pdev_id); 499 params->status = wmi_twt_enable_status_to_host_twt_status(ev->status); 500 501 return QDF_STATUS_SUCCESS; 502 } 503 504 static enum HOST_TWT_DISABLE_STATUS 505 wmi_twt_disable_status_to_host_twt_status(WMI_DISABLE_TWT_STATUS_T status) 506 { 507 switch (status) { 508 case WMI_DISABLE_TWT_STATUS_OK: 509 return HOST_TWT_DISABLE_STATUS_OK; 510 case WMI_DISABLE_TWT_STATUS_ROAM_IN_PROGRESS: 511 return HOST_TWT_DISABLE_STATUS_ROAM_IN_PROGRESS; 512 case WMI_DISABLE_TWT_STATUS_CHAN_SW_IN_PROGRESS: 513 return HOST_TWT_DISABLE_STATUS_CHAN_SW_IN_PROGRESS; 514 case WMI_DISABLE_TWT_STATUS_SCAN_IN_PROGRESS: 515 return HOST_TWT_DISABLE_STATUS_SCAN_IN_PROGRESS; 516 default: 517 return HOST_TWT_DISABLE_STATUS_UNKNOWN_ERROR; 518 } 519 } 520 521 static QDF_STATUS extract_twt_disable_comp_event_tlv(wmi_unified_t wmi_handle, 522 uint8_t *evt_buf, 523 struct twt_disable_complete_event_param *params) 524 { 525 WMI_TWT_DISABLE_COMPLETE_EVENTID_param_tlvs *param_buf; 526 wmi_twt_disable_complete_event_fixed_param *ev; 527 528 param_buf = (WMI_TWT_DISABLE_COMPLETE_EVENTID_param_tlvs *)evt_buf; 529 if (!param_buf) { 530 wmi_err("evt_buf is NULL"); 531 return QDF_STATUS_E_INVAL; 532 } 533 534 ev = param_buf->fixed_param; 535 536 params->pdev_id = 537 wmi_handle->ops->convert_pdev_id_target_to_host(wmi_handle, 538 ev->pdev_id); 539 params->status = wmi_twt_disable_status_to_host_twt_status(ev->status); 540 541 return QDF_STATUS_SUCCESS; 542 } 543 544 static enum HOST_TWT_ADD_STATUS 545 wmi_get_converted_twt_add_dialog_status(WMI_ADD_TWT_STATUS_T tgt_status) 546 { 547 switch (tgt_status) { 548 case WMI_ADD_TWT_STATUS_OK: 549 return HOST_TWT_ADD_STATUS_OK; 550 case WMI_ADD_TWT_STATUS_TWT_NOT_ENABLED: 551 return HOST_TWT_ADD_STATUS_TWT_NOT_ENABLED; 552 case WMI_ADD_TWT_STATUS_USED_DIALOG_ID: 553 return HOST_TWT_ADD_STATUS_USED_DIALOG_ID; 554 case WMI_ADD_TWT_STATUS_INVALID_PARAM: 555 return HOST_TWT_ADD_STATUS_INVALID_PARAM; 556 case WMI_ADD_TWT_STATUS_NOT_READY: 557 return HOST_TWT_ADD_STATUS_NOT_READY; 558 case WMI_ADD_TWT_STATUS_NO_RESOURCE: 559 return HOST_TWT_ADD_STATUS_NO_RESOURCE; 560 case WMI_ADD_TWT_STATUS_NO_ACK: 561 return HOST_TWT_ADD_STATUS_NO_ACK; 562 case WMI_ADD_TWT_STATUS_NO_RESPONSE: 563 return HOST_TWT_ADD_STATUS_NO_RESPONSE; 564 case WMI_ADD_TWT_STATUS_DENIED: 565 return HOST_TWT_ADD_STATUS_DENIED; 566 case WMI_ADD_TWT_STATUS_AP_PARAMS_NOT_IN_RANGE: 567 return HOST_TWT_ADD_STATUS_AP_PARAMS_NOT_IN_RANGE; 568 case WMI_ADD_TWT_STATUS_AP_IE_VALIDATION_FAILED: 569 return HOST_TWT_ADD_STATUS_AP_IE_VALIDATION_FAILED; 570 case WMI_ADD_TWT_STATUS_ROAM_IN_PROGRESS: 571 return HOST_TWT_ADD_STATUS_ROAM_IN_PROGRESS; 572 case WMI_ADD_TWT_STATUS_CHAN_SW_IN_PROGRESS: 573 return HOST_TWT_ADD_STATUS_CHAN_SW_IN_PROGRESS; 574 case WMI_ADD_TWT_STATUS_SCAN_IN_PROGRESS: 575 return HOST_TWT_ADD_STATUS_SCAN_IN_PROGRESS; 576 default: 577 return HOST_TWT_ADD_STATUS_UNKNOWN_ERROR; 578 } 579 } 580 581 /** 582 * extract_twt_add_dialog_comp_event_tlv - Extacts twt add dialog complete wmi 583 * event from firmware 584 * @wmi_handle: WMI handle 585 * @evt_buf: Pointer to wmi event buf of twt add dialog complete event 586 * @params: Pointer to store the extracted parameters 587 * 588 * Return: QDF_STATUS_SUCCESS on success or QDF STATUS error values on failure 589 */ 590 static QDF_STATUS extract_twt_add_dialog_comp_event_tlv( 591 wmi_unified_t wmi_handle, 592 uint8_t *evt_buf, 593 struct twt_add_dialog_complete_event_param *params) 594 { 595 WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 596 wmi_twt_add_dialog_complete_event_fixed_param *ev; 597 598 param_buf = (WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 599 if (!param_buf) { 600 wmi_err("evt_buf is NULL"); 601 return QDF_STATUS_E_INVAL; 602 } 603 604 ev = param_buf->fixed_param; 605 606 params->vdev_id = ev->vdev_id; 607 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, 608 params->peer_macaddr.bytes); 609 params->status = wmi_get_converted_twt_add_dialog_status(ev->status); 610 params->dialog_id = ev->dialog_id; 611 params->num_additional_twt_params = param_buf->num_twt_params; 612 613 return QDF_STATUS_SUCCESS; 614 } 615 616 /** 617 * extract_twt_add_dialog_comp_additional_parameters() - Extracts additional twt 618 * twt parameters, as part of add dialog completion event 619 * @wmi_handle: wmi handle 620 * @evt_buf: Pointer event buffer 621 * @evt_buf_len: length of the add dialog event buffer 622 * @idx: index of num_twt_params 623 * @additional_params: twt additional parameters to extract 624 * 625 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_INVAL for failure 626 */ 627 static QDF_STATUS extract_twt_add_dialog_comp_additional_parameters 628 ( 629 wmi_unified_t wmi_handle, uint8_t *evt_buf, 630 uint32_t evt_buf_len, uint32_t idx, 631 struct twt_add_dialog_additional_params *additional_params 632 ) 633 { 634 WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 635 wmi_twt_add_dialog_complete_event_fixed_param *ev; 636 uint32_t flags = 0; 637 uint32_t expected_len; 638 639 param_buf = (WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 640 if (!param_buf) { 641 wmi_err("evt_buf is NULL"); 642 return QDF_STATUS_E_INVAL; 643 } 644 645 ev = param_buf->fixed_param; 646 647 if (idx >= param_buf->num_twt_params) { 648 wmi_err("Invalid idx %d while num_twt_params = %d", 649 idx, param_buf->num_twt_params); 650 return QDF_STATUS_E_INVAL; 651 } 652 653 if (!param_buf->twt_params) { 654 wmi_err("Unable to extract additional twt parameters"); 655 return QDF_STATUS_E_INVAL; 656 } 657 658 expected_len = (sizeof(wmi_twt_add_dialog_complete_event_fixed_param) + 659 WMI_TLV_HDR_SIZE + (param_buf->num_twt_params * 660 sizeof(wmi_twt_add_dialog_additional_params))); 661 662 if (evt_buf_len != expected_len) { 663 wmi_err("Got invalid len data from FW %d expected %d", 664 evt_buf_len, expected_len); 665 return QDF_STATUS_E_INVAL; 666 } 667 668 flags = param_buf->twt_params[idx].flags; 669 additional_params->twt_cmd = TWT_FLAGS_GET_CMD(flags); 670 additional_params->bcast = TWT_FLAGS_GET_BROADCAST(flags); 671 additional_params->trig_en = TWT_FLAGS_GET_TRIGGER(flags); 672 additional_params->announce = TWT_FLAGS_GET_FLOW_TYPE(flags); 673 additional_params->protection = TWT_FLAGS_GET_PROTECTION(flags); 674 additional_params->b_twt_id0 = TWT_FLAGS_GET_BTWT_ID0(flags); 675 additional_params->info_frame_disabled = 676 TWT_FLAGS_GET_TWT_INFO_FRAME_DISABLED(flags); 677 additional_params->wake_dur_us = param_buf->twt_params[idx].wake_dur_us; 678 additional_params->wake_intvl_us = 679 param_buf->twt_params[idx].wake_intvl_us; 680 additional_params->sp_offset_us = 681 param_buf->twt_params[idx].sp_offset_us; 682 additional_params->sp_tsf_us_lo = 683 param_buf->twt_params[idx].sp_tsf_us_lo; 684 additional_params->sp_tsf_us_hi = 685 param_buf->twt_params[idx].sp_tsf_us_hi; 686 additional_params->pm_responder_bit_valid = 687 TWT_FLAGS_GET_PM_RESPONDER_MODE_VALID(flags); 688 additional_params->pm_responder_bit = 689 TWT_FLAGS_GET_PM_RESPONDER_MODE(flags); 690 691 return QDF_STATUS_SUCCESS; 692 } 693 694 static enum HOST_TWT_DEL_STATUS 695 wmi_get_converted_twt_del_dialog_status(WMI_DEL_TWT_STATUS_T tgt_status) 696 { 697 switch (tgt_status) { 698 case WMI_DEL_TWT_STATUS_OK: 699 return HOST_TWT_DEL_STATUS_OK; 700 case WMI_DEL_TWT_STATUS_DIALOG_ID_NOT_EXIST: 701 return HOST_TWT_DEL_STATUS_DIALOG_ID_NOT_EXIST; 702 case WMI_DEL_TWT_STATUS_INVALID_PARAM: 703 return HOST_TWT_DEL_STATUS_INVALID_PARAM; 704 case WMI_DEL_TWT_STATUS_DIALOG_ID_BUSY: 705 return HOST_TWT_DEL_STATUS_DIALOG_ID_BUSY; 706 case WMI_DEL_TWT_STATUS_NO_RESOURCE: 707 return HOST_TWT_DEL_STATUS_NO_RESOURCE; 708 case WMI_DEL_TWT_STATUS_NO_ACK: 709 return HOST_TWT_DEL_STATUS_NO_ACK; 710 case WMI_DEL_TWT_STATUS_PEER_INIT_TEARDOWN: 711 return HOST_TWT_DEL_STATUS_PEER_INIT_TEARDOWN; 712 case WMI_DEL_TWT_STATUS_ROAMING: 713 return HOST_TWT_DEL_STATUS_ROAMING; 714 case WMI_DEL_TWT_STATUS_CONCURRENCY: 715 return HOST_TWT_DEL_STATUS_CONCURRENCY; 716 case WMI_DEL_TWT_STATUS_CHAN_SW_IN_PROGRESS: 717 return HOST_TWT_DEL_STATUS_CHAN_SW_IN_PROGRESS; 718 case WMI_DEL_TWT_STATUS_SCAN_IN_PROGRESS: 719 return HOST_TWT_DEL_STATUS_SCAN_IN_PROGRESS; 720 default: 721 return HOST_TWT_DEL_STATUS_UNKNOWN_ERROR; 722 } 723 } 724 725 static QDF_STATUS extract_twt_del_dialog_comp_event_tlv( 726 wmi_unified_t wmi_handle, 727 uint8_t *evt_buf, 728 struct twt_del_dialog_complete_event_param *params) 729 { 730 WMI_TWT_DEL_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 731 wmi_twt_del_dialog_complete_event_fixed_param *ev; 732 733 param_buf = (WMI_TWT_DEL_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 734 if (!param_buf) { 735 wmi_err("evt_buf is NULL"); 736 return QDF_STATUS_E_INVAL; 737 } 738 739 ev = param_buf->fixed_param; 740 741 params->vdev_id = ev->vdev_id; 742 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, 743 params->peer_macaddr.bytes); 744 params->dialog_id = ev->dialog_id; 745 params->status = wmi_get_converted_twt_del_dialog_status(ev->status); 746 747 return QDF_STATUS_SUCCESS; 748 } 749 750 static enum HOST_TWT_PAUSE_STATUS 751 wmi_twt_pause_status_to_host_twt_status(WMI_PAUSE_TWT_STATUS_T status) 752 { 753 switch (status) { 754 case WMI_PAUSE_TWT_STATUS_OK: 755 return HOST_TWT_PAUSE_STATUS_OK; 756 case WMI_PAUSE_TWT_STATUS_DIALOG_ID_NOT_EXIST: 757 return HOST_TWT_PAUSE_STATUS_DIALOG_ID_NOT_EXIST; 758 case WMI_PAUSE_TWT_STATUS_INVALID_PARAM: 759 return HOST_TWT_PAUSE_STATUS_INVALID_PARAM; 760 case WMI_PAUSE_TWT_STATUS_DIALOG_ID_BUSY: 761 return HOST_TWT_PAUSE_STATUS_DIALOG_ID_BUSY; 762 case WMI_PAUSE_TWT_STATUS_NO_RESOURCE: 763 return HOST_TWT_PAUSE_STATUS_NO_RESOURCE; 764 case WMI_PAUSE_TWT_STATUS_NO_ACK: 765 return HOST_TWT_PAUSE_STATUS_NO_ACK; 766 case WMI_PAUSE_TWT_STATUS_ALREADY_PAUSED: 767 return HOST_TWT_PAUSE_STATUS_ALREADY_PAUSED; 768 case WMI_PAUSE_TWT_STATUS_CHAN_SW_IN_PROGRESS: 769 return HOST_TWT_PAUSE_STATUS_CHAN_SW_IN_PROGRESS; 770 case WMI_PAUSE_TWT_STATUS_ROAM_IN_PROGRESS: 771 return HOST_TWT_PAUSE_STATUS_ROAM_IN_PROGRESS; 772 case WMI_PAUSE_TWT_STATUS_SCAN_IN_PROGRESS: 773 return HOST_TWT_PAUSE_STATUS_SCAN_IN_PROGRESS; 774 default: 775 return HOST_TWT_PAUSE_STATUS_UNKNOWN_ERROR; 776 } 777 } 778 779 static QDF_STATUS extract_twt_pause_dialog_comp_event_tlv( 780 wmi_unified_t wmi_handle, 781 uint8_t *evt_buf, 782 struct twt_pause_dialog_complete_event_param *params) 783 { 784 WMI_TWT_PAUSE_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 785 wmi_twt_pause_dialog_complete_event_fixed_param *ev; 786 787 param_buf = (WMI_TWT_PAUSE_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 788 if (!param_buf) { 789 wmi_err("evt_buf is NULL"); 790 return QDF_STATUS_E_INVAL; 791 } 792 793 ev = param_buf->fixed_param; 794 795 params->vdev_id = ev->vdev_id; 796 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, 797 params->peer_macaddr.bytes); 798 params->status = wmi_twt_pause_status_to_host_twt_status(ev->status); 799 params->dialog_id = ev->dialog_id; 800 801 return QDF_STATUS_SUCCESS; 802 } 803 804 static enum HOST_TWT_NUDGE_STATUS 805 wmi_twt_nudge_status_to_host_twt_status(WMI_TWT_NUDGE_STATUS_T status) 806 { 807 switch (status) { 808 case WMI_NUDGE_TWT_STATUS_OK: 809 return HOST_TWT_NUDGE_STATUS_OK; 810 case WMI_NUDGE_TWT_STATUS_DIALOG_ID_NOT_EXIST: 811 return HOST_TWT_NUDGE_STATUS_DIALOG_ID_NOT_EXIST; 812 case WMI_NUDGE_TWT_STATUS_INVALID_PARAM: 813 return HOST_TWT_NUDGE_STATUS_INVALID_PARAM; 814 case WMI_NUDGE_TWT_STATUS_DIALOG_ID_BUSY: 815 return HOST_TWT_NUDGE_STATUS_DIALOG_ID_BUSY; 816 case WMI_NUDGE_TWT_STATUS_NO_RESOURCE: 817 return HOST_TWT_NUDGE_STATUS_NO_RESOURCE; 818 case WMI_NUDGE_TWT_STATUS_NO_ACK: 819 return HOST_TWT_NUDGE_STATUS_NO_ACK; 820 case WMI_NUDGE_TWT_STATUS_ALREADY_PAUSED: 821 return HOST_TWT_NUDGE_STATUS_ALREADY_PAUSED; 822 case WMI_NUDGE_TWT_STATUS_CHAN_SW_IN_PROGRESS: 823 return HOST_TWT_NUDGE_STATUS_CHAN_SW_IN_PROGRESS; 824 case WMI_NUDGE_TWT_STATUS_ROAM_IN_PROGRESS: 825 return HOST_TWT_NUDGE_STATUS_ROAM_IN_PROGRESS; 826 case WMI_NUDGE_TWT_STATUS_SCAN_IN_PROGRESS: 827 return HOST_TWT_NUDGE_STATUS_SCAN_IN_PROGRESS; 828 default: 829 return HOST_TWT_NUDGE_STATUS_UNKNOWN_ERROR; 830 } 831 } 832 833 static QDF_STATUS extract_twt_nudge_dialog_comp_event_tlv( 834 wmi_unified_t wmi_handle, 835 uint8_t *evt_buf, 836 struct twt_nudge_dialog_complete_event_param *params) 837 { 838 WMI_TWT_NUDGE_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 839 wmi_twt_nudge_dialog_complete_event_fixed_param *ev; 840 841 param_buf = (WMI_TWT_NUDGE_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 842 if (!param_buf) { 843 wmi_err("evt_buf is NULL"); 844 return QDF_STATUS_E_INVAL; 845 } 846 847 ev = param_buf->fixed_param; 848 849 params->vdev_id = ev->vdev_id; 850 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, 851 params->peer_macaddr.bytes); 852 params->status = wmi_twt_nudge_status_to_host_twt_status(ev->status); 853 params->dialog_id = ev->dialog_id; 854 params->next_twt_tsf_us_lo = ev->sp_tsf_us_lo; 855 params->next_twt_tsf_us_hi = ev->sp_tsf_us_hi; 856 857 wmi_debug("vdev_id: %d dialog_id: %d tsf hi : %x tsf lo: %x", 858 params->vdev_id, params->dialog_id, 859 params->next_twt_tsf_us_hi, params->next_twt_tsf_us_lo); 860 861 return QDF_STATUS_SUCCESS; 862 } 863 864 static enum HOST_TWT_RESUME_STATUS 865 wmi_get_converted_twt_resume_dialog_status(WMI_RESUME_TWT_STATUS_T tgt_status) 866 { 867 switch (tgt_status) { 868 case WMI_RESUME_TWT_STATUS_OK: 869 return HOST_TWT_RESUME_STATUS_OK; 870 case WMI_RESUME_TWT_STATUS_DIALOG_ID_NOT_EXIST: 871 return HOST_TWT_RESUME_STATUS_DIALOG_ID_NOT_EXIST; 872 case WMI_RESUME_TWT_STATUS_INVALID_PARAM: 873 return HOST_TWT_RESUME_STATUS_INVALID_PARAM; 874 case WMI_RESUME_TWT_STATUS_DIALOG_ID_BUSY: 875 return HOST_TWT_RESUME_STATUS_DIALOG_ID_BUSY; 876 case WMI_RESUME_TWT_STATUS_NOT_PAUSED: 877 return HOST_TWT_RESUME_STATUS_NOT_PAUSED; 878 case WMI_RESUME_TWT_STATUS_NO_RESOURCE: 879 return HOST_TWT_RESUME_STATUS_NO_RESOURCE; 880 case WMI_RESUME_TWT_STATUS_NO_ACK: 881 return HOST_TWT_RESUME_STATUS_NO_ACK; 882 case WMI_RESUME_TWT_STATUS_CHAN_SW_IN_PROGRESS: 883 return HOST_TWT_RESUME_STATUS_CHAN_SW_IN_PROGRESS; 884 case WMI_RESUME_TWT_STATUS_ROAM_IN_PROGRESS: 885 return HOST_TWT_RESUME_STATUS_ROAM_IN_PROGRESS; 886 case WMI_RESUME_TWT_STATUS_SCAN_IN_PROGRESS: 887 return HOST_TWT_RESUME_STATUS_SCAN_IN_PROGRESS; 888 default: 889 return HOST_TWT_RESUME_STATUS_UNKNOWN_ERROR; 890 } 891 } 892 893 static QDF_STATUS extract_twt_resume_dialog_comp_event_tlv( 894 wmi_unified_t wmi_handle, 895 uint8_t *evt_buf, 896 struct twt_resume_dialog_complete_event_param *params) 897 { 898 WMI_TWT_RESUME_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 899 wmi_twt_resume_dialog_complete_event_fixed_param *ev; 900 901 param_buf = 902 (WMI_TWT_RESUME_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 903 if (!param_buf) { 904 wmi_err("evt_buf is NULL"); 905 return QDF_STATUS_E_INVAL; 906 } 907 908 ev = param_buf->fixed_param; 909 910 params->vdev_id = ev->vdev_id; 911 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, 912 params->peer_macaddr.bytes); 913 params->status = wmi_get_converted_twt_resume_dialog_status(ev->status); 914 params->dialog_id = ev->dialog_id; 915 916 return QDF_STATUS_SUCCESS; 917 } 918 919 static enum HOST_TWT_NOTIFY_STATUS 920 wmi_get_converted_twt_notify_status(WMI_TWT_NOTIFICATION_ID_T tgt_status) 921 { 922 switch (tgt_status) { 923 case WMI_TWT_NOTIFY_EVENT_AP_TWT_REQ_BIT_SET: 924 return HOST_TWT_NOTIFY_EVENT_AP_TWT_REQ_BIT_SET; 925 case WMI_TWT_NOTIFY_EVENT_AP_TWT_REQ_BIT_CLEAR: 926 return HOST_TWT_NOTIFY_EVENT_AP_TWT_REQ_BIT_CLEAR; 927 default: 928 return HOST_TWT_NOTIFY_EVENT_READY; 929 } 930 } 931 932 static QDF_STATUS extract_twt_notify_event_tlv( 933 wmi_unified_t wmi_handle, 934 uint8_t *evt_buf, 935 struct twt_notify_event_param *params) 936 { 937 WMI_TWT_NOTIFY_EVENTID_param_tlvs *param_buf; 938 wmi_twt_notify_event_fixed_param *ev; 939 940 param_buf = 941 (WMI_TWT_NOTIFY_EVENTID_param_tlvs *)evt_buf; 942 if (!param_buf) { 943 wmi_err("evt_buf is NULL"); 944 return QDF_STATUS_E_INVAL; 945 } 946 947 ev = param_buf->fixed_param; 948 949 if (ev->event_id > WMI_TWT_NOTIFY_EVENT_AP_TWT_REQ_BIT_CLEAR) { 950 wmi_debug("Incorrect TWT notify event vdev_id: %d, status: %d", 951 ev->vdev_id, ev->event_id); 952 return QDF_STATUS_E_INVAL; 953 } 954 955 params->vdev_id = ev->vdev_id; 956 params->status = wmi_get_converted_twt_notify_status(ev->event_id); 957 958 wmi_debug("Extract notify event vdev_id: %d, status: %d", 959 params->vdev_id, params->status); 960 961 return QDF_STATUS_SUCCESS; 962 } 963 964 #ifdef WLAN_SUPPORT_BCAST_TWT 965 static QDF_STATUS 966 extract_twt_btwt_invite_sta_comp_event_tlv( 967 wmi_unified_t wmi_handle, 968 uint8_t *evt_buf, 969 struct 970 twt_btwt_invite_sta_complete_event_param 971 *params) 972 { 973 WMI_TWT_BTWT_INVITE_STA_COMPLETE_EVENTID_param_tlvs *param_buf; 974 wmi_twt_btwt_invite_sta_complete_event_fixed_param *ev; 975 976 param_buf = 977 (WMI_TWT_BTWT_INVITE_STA_COMPLETE_EVENTID_param_tlvs *)evt_buf; 978 if (!param_buf) { 979 wmi_err("evt_buf is NULL"); 980 return QDF_STATUS_E_INVAL; 981 } 982 983 ev = param_buf->fixed_param; 984 985 params->vdev_id = ev->vdev_id; 986 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, 987 params->peer_macaddr.bytes); 988 params->status = ev->status; 989 params->dialog_id = ev->dialog_id; 990 991 return QDF_STATUS_SUCCESS; 992 } 993 994 static QDF_STATUS 995 extract_twt_btwt_remove_sta_comp_event_tlv( 996 wmi_unified_t wmi_handle, 997 uint8_t *evt_buf, 998 struct 999 twt_btwt_remove_sta_complete_event_param 1000 *params) 1001 { 1002 WMI_TWT_BTWT_REMOVE_STA_COMPLETE_EVENTID_param_tlvs *param_buf; 1003 wmi_twt_btwt_remove_sta_complete_event_fixed_param *ev; 1004 1005 param_buf = 1006 (WMI_TWT_BTWT_REMOVE_STA_COMPLETE_EVENTID_param_tlvs *)evt_buf; 1007 if (!param_buf) { 1008 wmi_err("evt_buf is NULL"); 1009 return QDF_STATUS_E_INVAL; 1010 } 1011 1012 ev = param_buf->fixed_param; 1013 1014 params->vdev_id = ev->vdev_id; 1015 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, 1016 params->peer_macaddr.bytes); 1017 params->status = ev->status; 1018 params->dialog_id = ev->dialog_id; 1019 1020 return QDF_STATUS_SUCCESS; 1021 } 1022 #endif 1023 1024 #ifdef WLAN_SUPPORT_BCAST_TWT 1025 static void 1026 wmi_twt_attach_bcast_twt_tlv(struct wmi_ops *ops) 1027 { 1028 ops->send_twt_btwt_invite_sta_cmd = send_twt_btwt_invite_sta_cmd_tlv; 1029 ops->send_twt_btwt_remove_sta_cmd = send_twt_btwt_remove_sta_cmd_tlv; 1030 ops->extract_twt_btwt_invite_sta_comp_event = 1031 extract_twt_btwt_invite_sta_comp_event_tlv; 1032 ops->extract_twt_btwt_remove_sta_comp_event = 1033 extract_twt_btwt_remove_sta_comp_event_tlv; 1034 } 1035 #else 1036 static void 1037 wmi_twt_attach_bcast_twt_tlv(struct wmi_ops *ops) 1038 { 1039 } 1040 #endif 1041 1042 static QDF_STATUS 1043 extract_twt_session_stats_event_tlv(wmi_unified_t wmi_handle, 1044 uint8_t *evt_buf, 1045 struct twt_session_stats_event_param 1046 *params) 1047 { 1048 WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *param_buf; 1049 wmi_pdev_twt_session_stats_event_fixed_param *ev; 1050 1051 param_buf = 1052 (WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *)evt_buf; 1053 if (!param_buf) { 1054 wmi_err("evt_buf is NULL"); 1055 return QDF_STATUS_E_INVAL; 1056 } 1057 1058 ev = param_buf->fixed_param; 1059 params->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host( 1060 wmi_handle, 1061 ev->pdev_id); 1062 params->num_sessions = param_buf->num_twt_sessions; 1063 1064 wmi_debug("pdev_id=%d, num of TWT sessions=%d", 1065 params->pdev_id, params->num_sessions); 1066 1067 return QDF_STATUS_SUCCESS; 1068 } 1069 1070 static QDF_STATUS 1071 extract_twt_session_stats_event_data(wmi_unified_t wmi_handle, 1072 uint8_t *evt_buf, 1073 struct twt_session_stats_event_param 1074 *params, 1075 struct twt_session_stats_info 1076 *session, 1077 uint32_t idx) 1078 { 1079 WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *param_buf; 1080 wmi_twt_session_stats_info *twt_session; 1081 uint32_t flags; 1082 wmi_mac_addr *m1; 1083 uint8_t *m2; 1084 1085 param_buf = 1086 (WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *)evt_buf; 1087 if (!param_buf) { 1088 wmi_err("evt_buf is NULL"); 1089 return QDF_STATUS_E_INVAL; 1090 } 1091 1092 if (idx >= param_buf->num_twt_sessions) { 1093 wmi_err("wrong idx, idx=%d, num_sessions=%d", 1094 idx, param_buf->num_twt_sessions); 1095 return QDF_STATUS_E_INVAL; 1096 } 1097 1098 twt_session = ¶m_buf->twt_sessions[idx]; 1099 1100 session->vdev_id = twt_session->vdev_id; 1101 m1 = &twt_session->peer_mac; 1102 m2 = session->peer_mac.bytes; 1103 WMI_MAC_ADDR_TO_CHAR_ARRAY(m1, m2); 1104 session->event_type = twt_session->event_type; 1105 flags = twt_session->flow_id_flags; 1106 session->flow_id = WMI_TWT_SESSION_FLAG_FLOW_ID_GET(flags); 1107 session->bcast = WMI_TWT_SESSION_FLAG_BCAST_TWT_GET(flags); 1108 session->trig = WMI_TWT_SESSION_FLAG_TRIGGER_TWT_GET(flags); 1109 session->announ = WMI_TWT_SESSION_FLAG_ANNOUN_TWT_GET(flags); 1110 session->protection = WMI_TWT_SESSION_FLAG_TWT_PROTECTION_GET(flags); 1111 session->info_frame_disabled = 1112 WMI_TWT_SESSION_FLAG_TWT_INFO_FRAME_DISABLED_GET(flags); 1113 session->pm_responder_bit = 1114 WMI_TWT_SESSION_FLAG_TWT_PM_RESPONDER_MODE_GET(flags); 1115 session->pm_responder_bit_valid = 1116 WMI_TWT_SESSION_FLAG_TWT_PM_RESPONDER_MODE_VALID_GET(flags); 1117 session->dialog_id = twt_session->dialog_id; 1118 session->wake_dura_us = twt_session->wake_dura_us; 1119 session->wake_intvl_us = twt_session->wake_intvl_us; 1120 session->sp_offset_us = twt_session->sp_offset_us; 1121 session->sp_tsf_us_lo = twt_session->sp_tsf_us_lo; 1122 session->sp_tsf_us_hi = twt_session->sp_tsf_us_hi; 1123 wmi_debug("type=%d id=%d bcast=%d trig=%d announ=%d diagid=%d wake_dur=%ul wake_int=%ul offset=%ul", 1124 session->event_type, session->flow_id, 1125 session->bcast, session->trig, 1126 session->announ, session->dialog_id, session->wake_dura_us, 1127 session->wake_intvl_us, session->sp_offset_us); 1128 wmi_debug("resp_pm_valid=%d resp_pm=%d", 1129 session->pm_responder_bit_valid, session->pm_responder_bit); 1130 1131 return QDF_STATUS_SUCCESS; 1132 } 1133 1134 static QDF_STATUS extract_twt_cap_service_ready_ext2_tlv( 1135 wmi_unified_t wmi_handle, uint8_t *event, 1136 struct wmi_twt_cap_bitmap_params *var) 1137 { 1138 WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *param_buf; 1139 wmi_twt_caps_params *twt_caps; 1140 1141 param_buf = (WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *)event; 1142 if (!param_buf) 1143 return QDF_STATUS_E_INVAL; 1144 1145 twt_caps = param_buf->twt_caps; 1146 if (!twt_caps) 1147 return QDF_STATUS_E_INVAL; 1148 1149 var->twt_ack_support_cap = WMI_GET_BITS(twt_caps->twt_capability_bitmap, 1150 0, 1); 1151 1152 return QDF_STATUS_SUCCESS; 1153 } 1154 1155 static enum WMI_HOST_TWT_CMD_FOR_ACK_EVENT 1156 wmi_get_converted_twt_command_for_ack_event(WMI_CMD_ID tgt_cmd) 1157 { 1158 switch (tgt_cmd) { 1159 case WMI_TWT_ADD_DIALOG_CMDID: 1160 return WMI_HOST_TWT_ADD_DIALOG_CMDID; 1161 case WMI_TWT_DEL_DIALOG_CMDID: 1162 return WMI_HOST_TWT_DEL_DIALOG_CMDID; 1163 case WMI_TWT_PAUSE_DIALOG_CMDID: 1164 return WMI_HOST_TWT_PAUSE_DIALOG_CMDID; 1165 case WMI_TWT_RESUME_DIALOG_CMDID: 1166 return WMI_HOST_TWT_RESUME_DIALOG_CMDID; 1167 case WMI_TWT_NUDGE_DIALOG_CMDID: 1168 return WMI_HOST_TWT_NUDGE_DIALOG_CMDID; 1169 default: 1170 return WMI_HOST_TWT_UNKNOWN_CMDID; 1171 } 1172 } 1173 1174 static QDF_STATUS 1175 extract_twt_ack_comp_event_tlv(wmi_unified_t wmi_handle, 1176 uint8_t *evt_buf, 1177 struct twt_ack_complete_event_param *var) 1178 { 1179 WMI_TWT_ACK_EVENTID_param_tlvs *param_buf; 1180 wmi_twt_ack_event_fixed_param *ack_event; 1181 1182 param_buf = (WMI_TWT_ACK_EVENTID_param_tlvs *)evt_buf; 1183 if (!param_buf) { 1184 wmi_err("evt_buf is NULL"); 1185 return QDF_STATUS_E_INVAL; 1186 } 1187 1188 ack_event = param_buf->fixed_param; 1189 1190 var->vdev_id = ack_event->vdev_id; 1191 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ack_event->peer_macaddr, 1192 var->peer_macaddr.bytes); 1193 var->dialog_id = ack_event->dialog_id; 1194 var->twt_cmd_ack = wmi_get_converted_twt_command_for_ack_event( 1195 ack_event->twt_cmd); 1196 1197 switch (ack_event->twt_cmd) { 1198 case WMI_TWT_ADD_DIALOG_CMDID: 1199 var->status = wmi_get_converted_twt_add_dialog_status( 1200 ack_event->status); 1201 break; 1202 case WMI_TWT_DEL_DIALOG_CMDID: 1203 var->status = wmi_get_converted_twt_del_dialog_status( 1204 ack_event->status); 1205 break; 1206 case WMI_TWT_PAUSE_DIALOG_CMDID: 1207 var->status = wmi_twt_pause_status_to_host_twt_status( 1208 ack_event->status); 1209 break; 1210 case WMI_TWT_RESUME_DIALOG_CMDID: 1211 var->status = wmi_get_converted_twt_resume_dialog_status( 1212 ack_event->status); 1213 break; 1214 case WMI_TWT_NUDGE_DIALOG_CMDID: 1215 var->status = wmi_twt_nudge_status_to_host_twt_status( 1216 ack_event->status); 1217 break; 1218 default: 1219 break; 1220 } 1221 return QDF_STATUS_SUCCESS; 1222 } 1223 #elif WLAN_SUPPORT_TWT 1224 static QDF_STATUS send_twt_enable_cmd_tlv(wmi_unified_t wmi_handle, 1225 struct wmi_twt_enable_param *params) 1226 { 1227 wmi_twt_enable_cmd_fixed_param *cmd; 1228 wmi_buf_t buf; 1229 QDF_STATUS status; 1230 1231 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1232 if (!buf) { 1233 wmi_err("Failed to allocate memory"); 1234 return QDF_STATUS_E_FAILURE; 1235 } 1236 1237 cmd = (wmi_twt_enable_cmd_fixed_param *) wmi_buf_data(buf); 1238 WMITLV_SET_HDR(&cmd->tlv_header, 1239 WMITLV_TAG_STRUC_wmi_twt_enable_cmd_fixed_param, 1240 WMITLV_GET_STRUCT_TLVLEN 1241 (wmi_twt_enable_cmd_fixed_param)); 1242 1243 cmd->pdev_id = 1244 wmi_handle->ops->convert_pdev_id_host_to_target( 1245 wmi_handle, 1246 params->pdev_id); 1247 cmd->sta_cong_timer_ms = params->sta_cong_timer_ms; 1248 cmd->mbss_support = params->mbss_support; 1249 cmd->default_slot_size = params->default_slot_size; 1250 cmd->congestion_thresh_setup = params->congestion_thresh_setup; 1251 cmd->congestion_thresh_teardown = params->congestion_thresh_teardown; 1252 cmd->congestion_thresh_critical = params->congestion_thresh_critical; 1253 cmd->interference_thresh_teardown = 1254 params->interference_thresh_teardown; 1255 cmd->interference_thresh_setup = params->interference_thresh_setup; 1256 cmd->min_no_sta_setup = params->min_no_sta_setup; 1257 cmd->min_no_sta_teardown = params->min_no_sta_teardown; 1258 cmd->no_of_bcast_mcast_slots = params->no_of_bcast_mcast_slots; 1259 cmd->min_no_twt_slots = params->min_no_twt_slots; 1260 cmd->max_no_sta_twt = params->max_no_sta_twt; 1261 cmd->mode_check_interval = params->mode_check_interval; 1262 cmd->add_sta_slot_interval = params->add_sta_slot_interval; 1263 cmd->remove_sta_slot_interval = params->remove_sta_slot_interval; 1264 1265 TWT_EN_DIS_FLAGS_SET_BTWT(cmd->flags, params->b_twt_enable); 1266 TWT_EN_DIS_FLAGS_SET_B_R_TWT(cmd->flags, params->r_twt_enable); 1267 TWT_EN_DIS_FLAGS_SET_L_MBSSID(cmd->flags, 1268 params->b_twt_legacy_mbss_enable); 1269 TWT_EN_DIS_FLAGS_SET_AX_MBSSID(cmd->flags, 1270 params->b_twt_ax_mbss_enable); 1271 if (params->ext_conf_present) { 1272 TWT_EN_DIS_FLAGS_SET_SPLIT_CONFIG(cmd->flags, 1); 1273 TWT_EN_DIS_FLAGS_SET_REQ_RESP(cmd->flags, params->twt_role); 1274 TWT_EN_DIS_FLAGS_SET_I_B_TWT(cmd->flags, params->twt_oper); 1275 } 1276 1277 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 1278 WMI_TWT_ENABLE_CMDID); 1279 if (QDF_IS_STATUS_ERROR(status)) { 1280 wmi_err("Failed to send WMI_TWT_ENABLE_CMDID"); 1281 wmi_buf_free(buf); 1282 } 1283 1284 return status; 1285 } 1286 1287 static QDF_STATUS send_twt_disable_cmd_tlv(wmi_unified_t wmi_handle, 1288 struct wmi_twt_disable_param *params) 1289 { 1290 wmi_twt_disable_cmd_fixed_param *cmd; 1291 wmi_buf_t buf; 1292 QDF_STATUS status; 1293 1294 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1295 if (!buf) { 1296 wmi_err("Failed to allocate memory"); 1297 return QDF_STATUS_E_FAILURE; 1298 } 1299 1300 cmd = (wmi_twt_disable_cmd_fixed_param *) wmi_buf_data(buf); 1301 WMITLV_SET_HDR(&cmd->tlv_header, 1302 WMITLV_TAG_STRUC_wmi_twt_disable_cmd_fixed_param, 1303 WMITLV_GET_STRUCT_TLVLEN 1304 (wmi_twt_disable_cmd_fixed_param)); 1305 1306 cmd->pdev_id = 1307 wmi_handle->ops->convert_pdev_id_host_to_target( 1308 wmi_handle, 1309 params->pdev_id); 1310 if (params->ext_conf_present) { 1311 TWT_EN_DIS_FLAGS_SET_SPLIT_CONFIG(cmd->flags, 1); 1312 TWT_EN_DIS_FLAGS_SET_REQ_RESP(cmd->flags, params->twt_role); 1313 TWT_EN_DIS_FLAGS_SET_I_B_TWT(cmd->flags, params->twt_oper); 1314 } 1315 1316 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 1317 WMI_TWT_DISABLE_CMDID); 1318 if (QDF_IS_STATUS_ERROR(status)) { 1319 wmi_err("Failed to send WMI_TWT_DISABLE_CMDID"); 1320 wmi_buf_free(buf); 1321 } 1322 1323 return status; 1324 } 1325 1326 #ifdef WLAN_SUPPORT_BCAST_TWT 1327 static void 1328 twt_add_dialog_set_bcast_twt_params(struct wmi_twt_add_dialog_param *params, 1329 wmi_twt_add_dialog_cmd_fixed_param *cmd) 1330 { 1331 TWT_FLAGS_SET_BTWT_ID0(cmd->flags, params->flag_b_twt_id0); 1332 cmd->b_twt_persistence = params->b_twt_persistence; 1333 cmd->b_twt_recommendation = params->b_twt_recommendation; 1334 } 1335 #else 1336 static void 1337 twt_add_dialog_set_bcast_twt_params(struct wmi_twt_add_dialog_param *params, 1338 wmi_twt_add_dialog_cmd_fixed_param *cmd) 1339 { 1340 } 1341 #endif 1342 1343 static QDF_STATUS 1344 send_twt_add_dialog_cmd_tlv(wmi_unified_t wmi_handle, 1345 struct wmi_twt_add_dialog_param *params) 1346 { 1347 wmi_twt_add_dialog_cmd_fixed_param *cmd; 1348 wmi_buf_t buf; 1349 QDF_STATUS status; 1350 1351 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1352 if (!buf) { 1353 wmi_err("Failed to allocate memory"); 1354 return QDF_STATUS_E_FAILURE; 1355 } 1356 1357 cmd = (wmi_twt_add_dialog_cmd_fixed_param *) wmi_buf_data(buf); 1358 WMITLV_SET_HDR(&cmd->tlv_header, 1359 WMITLV_TAG_STRUC_wmi_twt_add_dialog_cmd_fixed_param, 1360 WMITLV_GET_STRUCT_TLVLEN 1361 (wmi_twt_add_dialog_cmd_fixed_param)); 1362 1363 cmd->vdev_id = params->vdev_id; 1364 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr, &cmd->peer_macaddr); 1365 cmd->dialog_id = params->dialog_id; 1366 cmd->wake_intvl_us = params->wake_intvl_us; 1367 cmd->wake_intvl_mantis = params->wake_intvl_mantis; 1368 cmd->wake_dura_us = params->wake_dura_us; 1369 cmd->sp_offset_us = params->sp_offset_us; 1370 cmd->min_wake_intvl_us = params->min_wake_intvl_us; 1371 cmd->max_wake_intvl_us = params->max_wake_intvl_us; 1372 cmd->min_wake_dura_us = params->min_wake_dura_us; 1373 cmd->max_wake_dura_us = params->max_wake_dura_us; 1374 cmd->sp_start_tsf_lo = (uint32_t)(params->wake_time_tsf & 0xFFFFFFFF); 1375 cmd->sp_start_tsf_hi = (uint32_t)(params->wake_time_tsf >> 32); 1376 cmd->announce_timeout_us = params->announce_timeout_us; 1377 cmd->link_id_bitmap = params->link_id_bitmap; 1378 cmd->r_twt_dl_tid_bitmap = params->r_twt_dl_tid_bitmap; 1379 cmd->r_twt_ul_tid_bitmap = params->r_twt_ul_tid_bitmap; 1380 TWT_FLAGS_SET_CMD(cmd->flags, params->twt_cmd); 1381 TWT_FLAGS_SET_BROADCAST(cmd->flags, params->flag_bcast); 1382 TWT_FLAGS_SET_TRIGGER(cmd->flags, params->flag_trigger); 1383 TWT_FLAGS_SET_FLOW_TYPE(cmd->flags, params->flag_flow_type); 1384 TWT_FLAGS_SET_PROTECTION(cmd->flags, params->flag_protection); 1385 1386 twt_add_dialog_set_bcast_twt_params(params, cmd); 1387 1388 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 1389 WMI_TWT_ADD_DIALOG_CMDID); 1390 if (QDF_IS_STATUS_ERROR(status)) { 1391 wmi_err("Failed to send WMI_TWT_ADD_DIALOG_CMDID"); 1392 wmi_buf_free(buf); 1393 } 1394 1395 return status; 1396 } 1397 1398 #ifdef WLAN_SUPPORT_BCAST_TWT 1399 static void 1400 twt_del_dialog_set_bcast_twt_params(struct wmi_twt_del_dialog_param *params, 1401 wmi_twt_del_dialog_cmd_fixed_param *cmd) 1402 { 1403 cmd->b_twt_persistence = params->b_twt_persistence; 1404 } 1405 #else 1406 static void 1407 twt_del_dialog_set_bcast_twt_params(struct wmi_twt_del_dialog_param *params, 1408 wmi_twt_del_dialog_cmd_fixed_param *cmd) 1409 { 1410 } 1411 #endif 1412 1413 static QDF_STATUS 1414 send_twt_del_dialog_cmd_tlv(wmi_unified_t wmi_handle, 1415 struct wmi_twt_del_dialog_param *params) 1416 { 1417 wmi_twt_del_dialog_cmd_fixed_param *cmd; 1418 wmi_buf_t buf; 1419 QDF_STATUS status; 1420 1421 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1422 if (!buf) { 1423 wmi_err("Failed to allocate memory"); 1424 return QDF_STATUS_E_FAILURE; 1425 } 1426 1427 cmd = (wmi_twt_del_dialog_cmd_fixed_param *) wmi_buf_data(buf); 1428 WMITLV_SET_HDR(&cmd->tlv_header, 1429 WMITLV_TAG_STRUC_wmi_twt_del_dialog_cmd_fixed_param, 1430 WMITLV_GET_STRUCT_TLVLEN 1431 (wmi_twt_del_dialog_cmd_fixed_param)); 1432 1433 cmd->vdev_id = params->vdev_id; 1434 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr, &cmd->peer_macaddr); 1435 cmd->dialog_id = params->dialog_id; 1436 1437 twt_del_dialog_set_bcast_twt_params(params, cmd); 1438 1439 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 1440 WMI_TWT_DEL_DIALOG_CMDID); 1441 if (QDF_IS_STATUS_ERROR(status)) { 1442 wmi_err("Failed to send WMI_TWT_DEL_DIALOG_CMDID"); 1443 wmi_buf_free(buf); 1444 } 1445 1446 return status; 1447 } 1448 1449 static QDF_STATUS 1450 send_twt_pause_dialog_cmd_tlv(wmi_unified_t wmi_handle, 1451 struct wmi_twt_pause_dialog_cmd_param *params) 1452 { 1453 wmi_twt_pause_dialog_cmd_fixed_param *cmd; 1454 wmi_buf_t buf; 1455 QDF_STATUS status; 1456 1457 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1458 if (!buf) { 1459 wmi_err("Failed to allocate memory"); 1460 return QDF_STATUS_E_FAILURE; 1461 } 1462 1463 cmd = (wmi_twt_pause_dialog_cmd_fixed_param *) wmi_buf_data(buf); 1464 WMITLV_SET_HDR(&cmd->tlv_header, 1465 WMITLV_TAG_STRUC_wmi_twt_pause_dialog_cmd_fixed_param, 1466 WMITLV_GET_STRUCT_TLVLEN 1467 (wmi_twt_pause_dialog_cmd_fixed_param)); 1468 1469 cmd->vdev_id = params->vdev_id; 1470 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr, &cmd->peer_macaddr); 1471 cmd->dialog_id = params->dialog_id; 1472 1473 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 1474 WMI_TWT_PAUSE_DIALOG_CMDID); 1475 if (QDF_IS_STATUS_ERROR(status)) { 1476 wmi_err("Failed to send WMI_TWT_PAUSE_DIALOG_CMDID"); 1477 wmi_buf_free(buf); 1478 } 1479 1480 return status; 1481 } 1482 1483 static QDF_STATUS 1484 send_twt_nudge_dialog_cmd_tlv(wmi_unified_t wmi_handle, 1485 struct wmi_twt_nudge_dialog_cmd_param *params) 1486 { 1487 wmi_twt_nudge_dialog_cmd_fixed_param *cmd; 1488 wmi_buf_t buf; 1489 QDF_STATUS status; 1490 1491 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1492 if (!buf) 1493 return QDF_STATUS_E_FAILURE; 1494 1495 cmd = (wmi_twt_nudge_dialog_cmd_fixed_param *) wmi_buf_data(buf); 1496 WMITLV_SET_HDR(&cmd->tlv_header, 1497 WMITLV_TAG_STRUC_wmi_twt_nudge_dialog_cmd_fixed_param, 1498 WMITLV_GET_STRUCT_TLVLEN 1499 (wmi_twt_nudge_dialog_cmd_fixed_param)); 1500 1501 cmd->vdev_id = params->vdev_id; 1502 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr, &cmd->peer_macaddr); 1503 cmd->dialog_id = params->dialog_id; 1504 cmd->suspend_duration_ms = params->suspend_duration / 1000; 1505 cmd->next_twt_size = params->next_twt_size; 1506 1507 wmi_debug("vdev_id: %d dialog_id: %d duration(in ms): %u next_twt_size: %d " 1508 "peer_macaddr: "QDF_MAC_ADDR_FMT, cmd->vdev_id, 1509 cmd->dialog_id, cmd->suspend_duration_ms, cmd->next_twt_size, 1510 QDF_MAC_ADDR_REF(params->peer_macaddr)); 1511 1512 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 1513 WMI_TWT_NUDGE_DIALOG_CMDID); 1514 if (QDF_IS_STATUS_ERROR(status)) 1515 wmi_buf_free(buf); 1516 1517 return status; 1518 } 1519 1520 static QDF_STATUS send_twt_resume_dialog_cmd_tlv(wmi_unified_t wmi_handle, 1521 struct wmi_twt_resume_dialog_cmd_param *params) 1522 { 1523 wmi_twt_resume_dialog_cmd_fixed_param *cmd; 1524 wmi_buf_t buf; 1525 QDF_STATUS status; 1526 1527 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1528 if (!buf) { 1529 wmi_err("Failed to allocate memory"); 1530 return QDF_STATUS_E_FAILURE; 1531 } 1532 1533 cmd = (wmi_twt_resume_dialog_cmd_fixed_param *) wmi_buf_data(buf); 1534 WMITLV_SET_HDR(&cmd->tlv_header, 1535 WMITLV_TAG_STRUC_wmi_twt_resume_dialog_cmd_fixed_param, 1536 WMITLV_GET_STRUCT_TLVLEN 1537 (wmi_twt_resume_dialog_cmd_fixed_param)); 1538 1539 cmd->vdev_id = params->vdev_id; 1540 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr, &cmd->peer_macaddr); 1541 cmd->dialog_id = params->dialog_id; 1542 cmd->sp_offset_us = params->sp_offset_us; 1543 cmd->next_twt_size = params->next_twt_size; 1544 1545 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 1546 WMI_TWT_RESUME_DIALOG_CMDID); 1547 if (QDF_IS_STATUS_ERROR(status)) { 1548 wmi_err("Failed to send WMI_TWT_RESUME_DIALOG_CMDID"); 1549 wmi_buf_free(buf); 1550 } 1551 1552 return status; 1553 } 1554 1555 #ifdef WLAN_SUPPORT_BCAST_TWT 1556 static QDF_STATUS 1557 send_twt_btwt_invite_sta_cmd_tlv(wmi_unified_t wmi_handle, 1558 struct wmi_twt_btwt_invite_sta_cmd_param 1559 *params) 1560 { 1561 wmi_twt_btwt_invite_sta_cmd_fixed_param *cmd; 1562 wmi_buf_t buf; 1563 QDF_STATUS status; 1564 1565 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1566 if (!buf) { 1567 wmi_err("Failed to allocate memory"); 1568 return QDF_STATUS_E_FAILURE; 1569 } 1570 1571 cmd = (wmi_twt_btwt_invite_sta_cmd_fixed_param *)wmi_buf_data(buf); 1572 WMITLV_SET_HDR(&cmd->tlv_header, 1573 WMITLV_TAG_STRUC_wmi_twt_btwt_invite_sta_cmd_fixed_param, 1574 WMITLV_GET_STRUCT_TLVLEN 1575 (wmi_twt_btwt_invite_sta_cmd_fixed_param)); 1576 1577 cmd->vdev_id = params->vdev_id; 1578 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr, &cmd->peer_macaddr); 1579 cmd->dialog_id = params->dialog_id; 1580 1581 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 1582 WMI_TWT_BTWT_INVITE_STA_CMDID); 1583 if (QDF_IS_STATUS_ERROR(status)) { 1584 wmi_buf_free(buf); 1585 } 1586 1587 return status; 1588 } 1589 1590 static QDF_STATUS 1591 send_twt_btwt_remove_sta_cmd_tlv(wmi_unified_t wmi_handle, 1592 struct wmi_twt_btwt_remove_sta_cmd_param 1593 *params) 1594 { 1595 wmi_twt_btwt_remove_sta_cmd_fixed_param *cmd; 1596 wmi_buf_t buf; 1597 QDF_STATUS status; 1598 1599 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 1600 if (!buf) { 1601 wmi_err("Failed to allocate memory"); 1602 return QDF_STATUS_E_FAILURE; 1603 } 1604 1605 cmd = (wmi_twt_btwt_remove_sta_cmd_fixed_param *)wmi_buf_data(buf); 1606 WMITLV_SET_HDR(&cmd->tlv_header, 1607 WMITLV_TAG_STRUC_wmi_twt_btwt_remove_sta_cmd_fixed_param, 1608 WMITLV_GET_STRUCT_TLVLEN 1609 (wmi_twt_btwt_remove_sta_cmd_fixed_param)); 1610 1611 cmd->vdev_id = params->vdev_id; 1612 WMI_CHAR_ARRAY_TO_MAC_ADDR(params->peer_macaddr, &cmd->peer_macaddr); 1613 cmd->dialog_id = params->dialog_id; 1614 1615 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 1616 WMI_TWT_BTWT_REMOVE_STA_CMDID); 1617 if (QDF_IS_STATUS_ERROR(status)) { 1618 wmi_buf_free(buf); 1619 } 1620 1621 return status; 1622 } 1623 #endif 1624 1625 static QDF_STATUS extract_twt_enable_comp_event_tlv(wmi_unified_t wmi_handle, 1626 uint8_t *evt_buf, 1627 struct wmi_twt_enable_complete_event_param *params) 1628 { 1629 WMI_TWT_ENABLE_COMPLETE_EVENTID_param_tlvs *param_buf; 1630 wmi_twt_enable_complete_event_fixed_param *ev; 1631 1632 param_buf = (WMI_TWT_ENABLE_COMPLETE_EVENTID_param_tlvs *)evt_buf; 1633 if (!param_buf) { 1634 wmi_err("evt_buf is NULL"); 1635 return QDF_STATUS_E_INVAL; 1636 } 1637 1638 ev = param_buf->fixed_param; 1639 1640 params->pdev_id = 1641 wmi_handle->ops->convert_pdev_id_target_to_host(wmi_handle, 1642 ev->pdev_id); 1643 params->status = ev->status; 1644 1645 return QDF_STATUS_SUCCESS; 1646 } 1647 1648 static QDF_STATUS extract_twt_disable_comp_event_tlv(wmi_unified_t wmi_handle, 1649 uint8_t *evt_buf, 1650 struct wmi_twt_disable_complete_event *params) 1651 { 1652 WMI_TWT_DISABLE_COMPLETE_EVENTID_param_tlvs *param_buf; 1653 wmi_twt_disable_complete_event_fixed_param *ev; 1654 1655 param_buf = (WMI_TWT_DISABLE_COMPLETE_EVENTID_param_tlvs *)evt_buf; 1656 if (!param_buf) { 1657 wmi_err("evt_buf is NULL"); 1658 return QDF_STATUS_E_INVAL; 1659 } 1660 1661 ev = param_buf->fixed_param; 1662 1663 #if 0 1664 params->pdev_id = 1665 wmi_handle->ops->convert_pdev_id_target_to_host(wmi_handle, 1666 ev->pdev_id); 1667 params->status = ev->status; 1668 #endif 1669 1670 return QDF_STATUS_SUCCESS; 1671 } 1672 1673 static enum WMI_HOST_ADD_TWT_STATUS 1674 wmi_get_converted_twt_add_dialog_status(WMI_ADD_TWT_STATUS_T tgt_status) 1675 { 1676 switch (tgt_status) { 1677 case WMI_ADD_TWT_STATUS_OK: 1678 return WMI_HOST_ADD_TWT_STATUS_OK; 1679 case WMI_ADD_TWT_STATUS_TWT_NOT_ENABLED: 1680 return WMI_HOST_ADD_TWT_STATUS_TWT_NOT_ENABLED; 1681 case WMI_ADD_TWT_STATUS_USED_DIALOG_ID: 1682 return WMI_HOST_ADD_TWT_STATUS_USED_DIALOG_ID; 1683 case WMI_ADD_TWT_STATUS_INVALID_PARAM: 1684 return WMI_HOST_ADD_TWT_STATUS_INVALID_PARAM; 1685 case WMI_ADD_TWT_STATUS_NOT_READY: 1686 return WMI_HOST_ADD_TWT_STATUS_NOT_READY; 1687 case WMI_ADD_TWT_STATUS_NO_RESOURCE: 1688 return WMI_HOST_ADD_TWT_STATUS_NO_RESOURCE; 1689 case WMI_ADD_TWT_STATUS_NO_ACK: 1690 return WMI_HOST_ADD_TWT_STATUS_NO_ACK; 1691 case WMI_ADD_TWT_STATUS_NO_RESPONSE: 1692 return WMI_HOST_ADD_TWT_STATUS_NO_RESPONSE; 1693 case WMI_ADD_TWT_STATUS_DENIED: 1694 return WMI_HOST_ADD_TWT_STATUS_DENIED; 1695 case WMI_ADD_TWT_STATUS_AP_PARAMS_NOT_IN_RANGE: 1696 return WMI_HOST_ADD_TWT_STATUS_AP_PARAMS_NOT_IN_RANGE; 1697 case WMI_ADD_TWT_STATUS_AP_IE_VALIDATION_FAILED: 1698 return WMI_HOST_ADD_TWT_STATUS_AP_IE_VALIDATION_FAILED; 1699 case WMI_ADD_TWT_STATUS_ROAM_IN_PROGRESS: 1700 return WMI_HOST_ADD_TWT_STATUS_ROAM_IN_PROGRESS; 1701 case WMI_ADD_TWT_STATUS_CHAN_SW_IN_PROGRESS: 1702 return WMI_HOST_ADD_TWT_STATUS_CHAN_SW_IN_PROGRESS; 1703 case WMI_ADD_TWT_STATUS_SCAN_IN_PROGRESS: 1704 return WMI_HOST_ADD_TWT_STATUS_SCAN_IN_PROGRESS; 1705 default: 1706 return WMI_HOST_ADD_TWT_STATUS_UNKNOWN_ERROR; 1707 } 1708 } 1709 1710 /** 1711 * extract_twt_add_dialog_comp_event_tlv - Extacts twt add dialog complete wmi 1712 * event from firmware 1713 * @wmi_handle: WMI handle 1714 * @evt_buf: Pointer to wmi event buf of twt add dialog complete event 1715 * @params: Pointer to store the extracted parameters 1716 * 1717 * Return: QDF_STATUS_SUCCESS on success or QDF STATUS error values on failure 1718 */ 1719 static QDF_STATUS extract_twt_add_dialog_comp_event_tlv( 1720 wmi_unified_t wmi_handle, 1721 uint8_t *evt_buf, 1722 struct wmi_twt_add_dialog_complete_event_param *params) 1723 { 1724 WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 1725 wmi_twt_add_dialog_complete_event_fixed_param *ev; 1726 1727 param_buf = (WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 1728 if (!param_buf) { 1729 wmi_err("evt_buf is NULL"); 1730 return QDF_STATUS_E_INVAL; 1731 } 1732 1733 ev = param_buf->fixed_param; 1734 1735 params->vdev_id = ev->vdev_id; 1736 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, params->peer_macaddr); 1737 params->status = wmi_get_converted_twt_add_dialog_status(ev->status); 1738 params->dialog_id = ev->dialog_id; 1739 params->num_additional_twt_params = param_buf->num_twt_params; 1740 1741 return QDF_STATUS_SUCCESS; 1742 } 1743 1744 /** 1745 * extract_twt_add_dialog_comp_additional_parameters() - Extracts additional twt 1746 * twt parameters, as part of add dialog completion event 1747 * @wmi_handle: wmi handle 1748 * @evt_buf: Pointer event buffer 1749 * @evt_buf_len: length of the add dialog event buffer 1750 * @idx: index of num_twt_params 1751 * @additional_params: twt additional parameters to extract 1752 * 1753 * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_INVAL for failure 1754 */ 1755 static QDF_STATUS extract_twt_add_dialog_comp_additional_parameters 1756 ( 1757 wmi_unified_t wmi_handle, uint8_t *evt_buf, 1758 uint32_t evt_buf_len, uint32_t idx, 1759 struct wmi_twt_add_dialog_additional_params *additional_params 1760 ) 1761 { 1762 WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 1763 wmi_twt_add_dialog_complete_event_fixed_param *ev; 1764 uint32_t flags = 0; 1765 uint32_t expected_len; 1766 1767 param_buf = (WMI_TWT_ADD_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 1768 if (!param_buf) { 1769 wmi_err("evt_buf is NULL"); 1770 return QDF_STATUS_E_INVAL; 1771 } 1772 1773 ev = param_buf->fixed_param; 1774 1775 if (idx >= param_buf->num_twt_params) { 1776 wmi_err("Invalid idx %d while num_twt_params = %d", 1777 idx, param_buf->num_twt_params); 1778 return QDF_STATUS_E_INVAL; 1779 } 1780 1781 if (!param_buf->twt_params) { 1782 wmi_err("Unable to extract additional twt parameters"); 1783 return QDF_STATUS_E_INVAL; 1784 } 1785 1786 expected_len = (sizeof(wmi_twt_add_dialog_complete_event_fixed_param) + 1787 WMI_TLV_HDR_SIZE + (param_buf->num_twt_params * 1788 sizeof(wmi_twt_add_dialog_additional_params))); 1789 1790 if (evt_buf_len != expected_len) { 1791 wmi_err("Got invalid len data from FW %d expected %d", 1792 evt_buf_len, expected_len); 1793 return QDF_STATUS_E_INVAL; 1794 } 1795 1796 flags = param_buf->twt_params[idx].flags; 1797 additional_params->twt_cmd = TWT_FLAGS_GET_CMD(flags); 1798 additional_params->bcast = TWT_FLAGS_GET_BROADCAST(flags); 1799 additional_params->trig_en = TWT_FLAGS_GET_TRIGGER(flags); 1800 additional_params->announce = TWT_FLAGS_GET_FLOW_TYPE(flags); 1801 additional_params->protection = TWT_FLAGS_GET_PROTECTION(flags); 1802 additional_params->b_twt_id0 = TWT_FLAGS_GET_BTWT_ID0(flags); 1803 additional_params->info_frame_disabled = 1804 TWT_FLAGS_GET_TWT_INFO_FRAME_DISABLED(flags); 1805 additional_params->wake_dur_us = param_buf->twt_params[idx].wake_dur_us; 1806 additional_params->wake_intvl_us = 1807 param_buf->twt_params[idx].wake_intvl_us; 1808 additional_params->sp_offset_us = 1809 param_buf->twt_params[idx].sp_offset_us; 1810 additional_params->sp_tsf_us_lo = 1811 param_buf->twt_params[idx].sp_tsf_us_lo; 1812 additional_params->sp_tsf_us_hi = 1813 param_buf->twt_params[idx].sp_tsf_us_hi; 1814 additional_params->pm_responder_bit_valid = 1815 TWT_FLAGS_GET_PM_RESPONDER_MODE_VALID(flags); 1816 additional_params->pm_responder_bit = 1817 TWT_FLAGS_GET_PM_RESPONDER_MODE(flags); 1818 1819 return QDF_STATUS_SUCCESS; 1820 } 1821 1822 static enum WMI_HOST_DEL_TWT_STATUS 1823 wmi_get_converted_twt_del_dialog_status(WMI_DEL_TWT_STATUS_T tgt_status) 1824 { 1825 switch (tgt_status) { 1826 case WMI_DEL_TWT_STATUS_OK: 1827 return WMI_HOST_DEL_TWT_STATUS_OK; 1828 case WMI_DEL_TWT_STATUS_DIALOG_ID_NOT_EXIST: 1829 return WMI_HOST_DEL_TWT_STATUS_DIALOG_ID_NOT_EXIST; 1830 case WMI_DEL_TWT_STATUS_INVALID_PARAM: 1831 return WMI_HOST_DEL_TWT_STATUS_INVALID_PARAM; 1832 case WMI_DEL_TWT_STATUS_DIALOG_ID_BUSY: 1833 return WMI_HOST_DEL_TWT_STATUS_DIALOG_ID_BUSY; 1834 case WMI_DEL_TWT_STATUS_NO_RESOURCE: 1835 return WMI_HOST_DEL_TWT_STATUS_NO_RESOURCE; 1836 case WMI_DEL_TWT_STATUS_NO_ACK: 1837 return WMI_HOST_DEL_TWT_STATUS_NO_ACK; 1838 case WMI_DEL_TWT_STATUS_UNKNOWN_ERROR: 1839 return WMI_HOST_DEL_TWT_STATUS_UNKNOWN_ERROR; 1840 case WMI_DEL_TWT_STATUS_PEER_INIT_TEARDOWN: 1841 return WMI_HOST_DEL_TWT_STATUS_PEER_INIT_TEARDOWN; 1842 case WMI_DEL_TWT_STATUS_ROAMING: 1843 return WMI_HOST_DEL_TWT_STATUS_ROAMING; 1844 case WMI_DEL_TWT_STATUS_CONCURRENCY: 1845 return WMI_HOST_DEL_TWT_STATUS_CONCURRENCY; 1846 case WMI_DEL_TWT_STATUS_CHAN_SW_IN_PROGRESS: 1847 return WMI_HOST_DEL_TWT_STATUS_CHAN_SW_IN_PROGRESS; 1848 case WMI_DEL_TWT_STATUS_SCAN_IN_PROGRESS: 1849 return WMI_HOST_DEL_TWT_STATUS_SCAN_IN_PROGRESS; 1850 default: 1851 return WMI_HOST_DEL_TWT_STATUS_UNKNOWN_ERROR; 1852 } 1853 1854 return WMI_HOST_DEL_TWT_STATUS_UNKNOWN_ERROR; 1855 } 1856 1857 static QDF_STATUS extract_twt_del_dialog_comp_event_tlv( 1858 wmi_unified_t wmi_handle, 1859 uint8_t *evt_buf, 1860 struct wmi_twt_del_dialog_complete_event_param *params) 1861 { 1862 WMI_TWT_DEL_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 1863 wmi_twt_del_dialog_complete_event_fixed_param *ev; 1864 1865 param_buf = (WMI_TWT_DEL_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 1866 if (!param_buf) { 1867 wmi_err("evt_buf is NULL"); 1868 return QDF_STATUS_E_INVAL; 1869 } 1870 1871 ev = param_buf->fixed_param; 1872 1873 params->vdev_id = ev->vdev_id; 1874 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, params->peer_macaddr); 1875 params->dialog_id = ev->dialog_id; 1876 params->status = wmi_get_converted_twt_del_dialog_status(ev->status); 1877 1878 return QDF_STATUS_SUCCESS; 1879 } 1880 1881 static enum WMI_HOST_PAUSE_TWT_STATUS 1882 wmi_twt_pause_status_to_host_twt_status(WMI_PAUSE_TWT_STATUS_T status) 1883 { 1884 switch (status) { 1885 case WMI_PAUSE_TWT_STATUS_OK: 1886 return WMI_HOST_PAUSE_TWT_STATUS_OK; 1887 case WMI_PAUSE_TWT_STATUS_DIALOG_ID_NOT_EXIST: 1888 return WMI_HOST_PAUSE_TWT_STATUS_DIALOG_ID_NOT_EXIST; 1889 case WMI_PAUSE_TWT_STATUS_INVALID_PARAM: 1890 return WMI_HOST_PAUSE_TWT_STATUS_INVALID_PARAM; 1891 case WMI_PAUSE_TWT_STATUS_DIALOG_ID_BUSY: 1892 return WMI_HOST_PAUSE_TWT_STATUS_DIALOG_ID_BUSY; 1893 case WMI_PAUSE_TWT_STATUS_NO_RESOURCE: 1894 return WMI_HOST_PAUSE_TWT_STATUS_NO_RESOURCE; 1895 case WMI_PAUSE_TWT_STATUS_NO_ACK: 1896 return WMI_HOST_PAUSE_TWT_STATUS_NO_ACK; 1897 case WMI_PAUSE_TWT_STATUS_UNKNOWN_ERROR: 1898 return WMI_HOST_PAUSE_TWT_STATUS_UNKNOWN_ERROR; 1899 case WMI_PAUSE_TWT_STATUS_ALREADY_PAUSED: 1900 return WMI_HOST_PAUSE_TWT_STATUS_ALREADY_PAUSED; 1901 case WMI_PAUSE_TWT_STATUS_CHAN_SW_IN_PROGRESS: 1902 return WMI_HOST_PAUSE_TWT_STATUS_CHAN_SW_IN_PROGRESS; 1903 case WMI_PAUSE_TWT_STATUS_ROAM_IN_PROGRESS: 1904 return WMI_HOST_PAUSE_TWT_STATUS_ROAM_IN_PROGRESS; 1905 case WMI_PAUSE_TWT_STATUS_SCAN_IN_PROGRESS: 1906 return WMI_HOST_PAUSE_TWT_STATUS_SCAN_IN_PROGRESS; 1907 default: 1908 return WMI_HOST_PAUSE_TWT_STATUS_UNKNOWN_ERROR; 1909 } 1910 } 1911 1912 static QDF_STATUS extract_twt_pause_dialog_comp_event_tlv( 1913 wmi_unified_t wmi_handle, 1914 uint8_t *evt_buf, 1915 struct wmi_twt_pause_dialog_complete_event_param *params) 1916 { 1917 WMI_TWT_PAUSE_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 1918 wmi_twt_pause_dialog_complete_event_fixed_param *ev; 1919 1920 param_buf = (WMI_TWT_PAUSE_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 1921 if (!param_buf) { 1922 wmi_err("evt_buf is NULL"); 1923 return QDF_STATUS_E_INVAL; 1924 } 1925 1926 ev = param_buf->fixed_param; 1927 1928 params->vdev_id = ev->vdev_id; 1929 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, params->peer_macaddr); 1930 params->status = wmi_twt_pause_status_to_host_twt_status(ev->status); 1931 params->dialog_id = ev->dialog_id; 1932 1933 return QDF_STATUS_SUCCESS; 1934 } 1935 1936 static enum WMI_HOST_NUDGE_TWT_STATUS 1937 wmi_twt_nudge_status_to_host_twt_status(WMI_TWT_NUDGE_STATUS_T status) 1938 { 1939 switch (status) { 1940 case WMI_NUDGE_TWT_STATUS_OK: 1941 return WMI_HOST_NUDGE_TWT_STATUS_OK; 1942 case WMI_NUDGE_TWT_STATUS_DIALOG_ID_NOT_EXIST: 1943 return WMI_HOST_NUDGE_TWT_STATUS_DIALOG_ID_NOT_EXIST; 1944 case WMI_NUDGE_TWT_STATUS_INVALID_PARAM: 1945 return WMI_HOST_NUDGE_TWT_STATUS_INVALID_PARAM; 1946 case WMI_NUDGE_TWT_STATUS_DIALOG_ID_BUSY: 1947 return WMI_HOST_NUDGE_TWT_STATUS_DIALOG_ID_BUSY; 1948 case WMI_NUDGE_TWT_STATUS_NO_RESOURCE: 1949 return WMI_HOST_NUDGE_TWT_STATUS_NO_RESOURCE; 1950 case WMI_NUDGE_TWT_STATUS_NO_ACK: 1951 return WMI_HOST_NUDGE_TWT_STATUS_NO_ACK; 1952 case WMI_NUDGE_TWT_STATUS_UNKNOWN_ERROR: 1953 return WMI_HOST_NUDGE_TWT_STATUS_UNKNOWN_ERROR; 1954 case WMI_NUDGE_TWT_STATUS_ALREADY_PAUSED: 1955 return WMI_HOST_NUDGE_TWT_STATUS_ALREADY_PAUSED; 1956 case WMI_NUDGE_TWT_STATUS_CHAN_SW_IN_PROGRESS: 1957 return WMI_HOST_NUDGE_TWT_STATUS_CHAN_SW_IN_PROGRESS; 1958 case WMI_NUDGE_TWT_STATUS_ROAM_IN_PROGRESS: 1959 return WMI_HOST_NUDGE_TWT_STATUS_ROAM_IN_PROGRESS; 1960 case WMI_NUDGE_TWT_STATUS_SCAN_IN_PROGRESS: 1961 return WMI_HOST_NUDGE_TWT_STATUS_SCAN_IN_PROGRESS; 1962 default: 1963 return WMI_HOST_NUDGE_TWT_STATUS_UNKNOWN_ERROR; 1964 } 1965 } 1966 1967 static QDF_STATUS extract_twt_nudge_dialog_comp_event_tlv( 1968 wmi_unified_t wmi_handle, 1969 uint8_t *evt_buf, 1970 struct wmi_twt_nudge_dialog_complete_event_param *params) 1971 { 1972 WMI_TWT_NUDGE_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 1973 wmi_twt_nudge_dialog_complete_event_fixed_param *ev; 1974 1975 param_buf = (WMI_TWT_NUDGE_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 1976 if (!param_buf) { 1977 wmi_err("evt_buf is NULL"); 1978 return QDF_STATUS_E_INVAL; 1979 } 1980 1981 ev = param_buf->fixed_param; 1982 1983 params->vdev_id = ev->vdev_id; 1984 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, params->peer_macaddr); 1985 params->status = wmi_twt_nudge_status_to_host_twt_status(ev->status); 1986 params->dialog_id = ev->dialog_id; 1987 params->next_twt_tsf_us_lo = ev->sp_tsf_us_lo; 1988 params->next_twt_tsf_us_hi = ev->sp_tsf_us_hi; 1989 1990 wmi_debug("vdev_id: %d dialog_id: %d tsf hi : %x tsf lo: %x", 1991 params->vdev_id, params->dialog_id, 1992 params->next_twt_tsf_us_hi, params->next_twt_tsf_us_lo); 1993 1994 return QDF_STATUS_SUCCESS; 1995 } 1996 1997 static enum WMI_HOST_RESUME_TWT_STATUS 1998 wmi_get_converted_twt_resume_dialog_status(WMI_RESUME_TWT_STATUS_T tgt_status) 1999 { 2000 switch (tgt_status) { 2001 case WMI_RESUME_TWT_STATUS_OK: 2002 return WMI_HOST_RESUME_TWT_STATUS_OK; 2003 case WMI_RESUME_TWT_STATUS_DIALOG_ID_NOT_EXIST: 2004 return WMI_HOST_RESUME_TWT_STATUS_DIALOG_ID_NOT_EXIST; 2005 case WMI_RESUME_TWT_STATUS_INVALID_PARAM: 2006 return WMI_HOST_RESUME_TWT_STATUS_INVALID_PARAM; 2007 case WMI_RESUME_TWT_STATUS_DIALOG_ID_BUSY: 2008 return WMI_HOST_RESUME_TWT_STATUS_DIALOG_ID_BUSY; 2009 case WMI_RESUME_TWT_STATUS_NOT_PAUSED: 2010 return WMI_HOST_RESUME_TWT_STATUS_NOT_PAUSED; 2011 case WMI_RESUME_TWT_STATUS_NO_RESOURCE: 2012 return WMI_HOST_RESUME_TWT_STATUS_NO_RESOURCE; 2013 case WMI_RESUME_TWT_STATUS_NO_ACK: 2014 return WMI_HOST_RESUME_TWT_STATUS_NO_ACK; 2015 case WMI_RESUME_TWT_STATUS_CHAN_SW_IN_PROGRESS: 2016 return WMI_HOST_RESUME_TWT_STATUS_CHAN_SW_IN_PROGRESS; 2017 case WMI_RESUME_TWT_STATUS_ROAM_IN_PROGRESS: 2018 return WMI_HOST_RESUME_TWT_STATUS_ROAM_IN_PROGRESS; 2019 case WMI_RESUME_TWT_STATUS_SCAN_IN_PROGRESS: 2020 return WMI_HOST_RESUME_TWT_STATUS_SCAN_IN_PROGRESS; 2021 default: 2022 return WMI_HOST_RESUME_TWT_STATUS_UNKNOWN_ERROR; 2023 } 2024 } 2025 2026 static QDF_STATUS extract_twt_resume_dialog_comp_event_tlv( 2027 wmi_unified_t wmi_handle, 2028 uint8_t *evt_buf, 2029 struct wmi_twt_resume_dialog_complete_event_param *params) 2030 { 2031 WMI_TWT_RESUME_DIALOG_COMPLETE_EVENTID_param_tlvs *param_buf; 2032 wmi_twt_resume_dialog_complete_event_fixed_param *ev; 2033 2034 param_buf = 2035 (WMI_TWT_RESUME_DIALOG_COMPLETE_EVENTID_param_tlvs *)evt_buf; 2036 if (!param_buf) { 2037 wmi_err("evt_buf is NULL"); 2038 return QDF_STATUS_E_INVAL; 2039 } 2040 2041 ev = param_buf->fixed_param; 2042 2043 params->vdev_id = ev->vdev_id; 2044 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, params->peer_macaddr); 2045 params->status = wmi_get_converted_twt_resume_dialog_status(ev->status); 2046 params->dialog_id = ev->dialog_id; 2047 2048 return QDF_STATUS_SUCCESS; 2049 } 2050 2051 static QDF_STATUS extract_twt_notify_event_tlv( 2052 wmi_unified_t wmi_handle, 2053 uint8_t *evt_buf, 2054 struct wmi_twt_notify_event_param *params) 2055 { 2056 WMI_TWT_NOTIFY_EVENTID_param_tlvs *param_buf; 2057 wmi_twt_notify_event_fixed_param *ev; 2058 2059 param_buf = 2060 (WMI_TWT_NOTIFY_EVENTID_param_tlvs *)evt_buf; 2061 if (!param_buf) { 2062 wmi_err("evt_buf is NULL"); 2063 return QDF_STATUS_E_INVAL; 2064 } 2065 2066 ev = param_buf->fixed_param; 2067 2068 params->vdev_id = ev->vdev_id; 2069 2070 return QDF_STATUS_SUCCESS; 2071 } 2072 2073 #ifdef WLAN_SUPPORT_BCAST_TWT 2074 static QDF_STATUS 2075 extract_twt_btwt_invite_sta_comp_event_tlv( 2076 wmi_unified_t wmi_handle, 2077 uint8_t *evt_buf, 2078 struct 2079 wmi_twt_btwt_invite_sta_complete_event_param 2080 *params) 2081 { 2082 WMI_TWT_BTWT_INVITE_STA_COMPLETE_EVENTID_param_tlvs *param_buf; 2083 wmi_twt_btwt_invite_sta_complete_event_fixed_param *ev; 2084 2085 param_buf = 2086 (WMI_TWT_BTWT_INVITE_STA_COMPLETE_EVENTID_param_tlvs *)evt_buf; 2087 if (!param_buf) { 2088 wmi_err("evt_buf is NULL"); 2089 return QDF_STATUS_E_INVAL; 2090 } 2091 2092 ev = param_buf->fixed_param; 2093 2094 params->vdev_id = ev->vdev_id; 2095 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, params->peer_macaddr); 2096 params->status = ev->status; 2097 params->dialog_id = ev->dialog_id; 2098 2099 return QDF_STATUS_SUCCESS; 2100 } 2101 2102 static QDF_STATUS 2103 extract_twt_btwt_remove_sta_comp_event_tlv( 2104 wmi_unified_t wmi_handle, 2105 uint8_t *evt_buf, 2106 struct 2107 wmi_twt_btwt_remove_sta_complete_event_param 2108 *params) 2109 { 2110 WMI_TWT_BTWT_REMOVE_STA_COMPLETE_EVENTID_param_tlvs *param_buf; 2111 wmi_twt_btwt_remove_sta_complete_event_fixed_param *ev; 2112 2113 param_buf = 2114 (WMI_TWT_BTWT_REMOVE_STA_COMPLETE_EVENTID_param_tlvs *)evt_buf; 2115 if (!param_buf) { 2116 wmi_err("evt_buf is NULL"); 2117 return QDF_STATUS_E_INVAL; 2118 } 2119 2120 ev = param_buf->fixed_param; 2121 2122 params->vdev_id = ev->vdev_id; 2123 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->peer_macaddr, params->peer_macaddr); 2124 params->status = ev->status; 2125 params->dialog_id = ev->dialog_id; 2126 2127 return QDF_STATUS_SUCCESS; 2128 } 2129 #endif 2130 2131 #ifdef WLAN_SUPPORT_BCAST_TWT 2132 static void 2133 wmi_twt_attach_bcast_twt_tlv(struct wmi_ops *ops) 2134 { 2135 ops->send_twt_btwt_invite_sta_cmd = send_twt_btwt_invite_sta_cmd_tlv; 2136 ops->send_twt_btwt_remove_sta_cmd = send_twt_btwt_remove_sta_cmd_tlv; 2137 ops->extract_twt_btwt_invite_sta_comp_event = 2138 extract_twt_btwt_invite_sta_comp_event_tlv; 2139 ops->extract_twt_btwt_remove_sta_comp_event = 2140 extract_twt_btwt_remove_sta_comp_event_tlv; 2141 } 2142 #else 2143 static void 2144 wmi_twt_attach_bcast_twt_tlv(struct wmi_ops *ops) 2145 { 2146 } 2147 #endif 2148 2149 static QDF_STATUS 2150 extract_twt_session_stats_event_tlv(wmi_unified_t wmi_handle, 2151 uint8_t *evt_buf, 2152 struct wmi_twt_session_stats_event_param 2153 *params) 2154 { 2155 WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *param_buf; 2156 wmi_pdev_twt_session_stats_event_fixed_param *ev; 2157 2158 param_buf = 2159 (WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *)evt_buf; 2160 if (!param_buf) { 2161 wmi_err("evt_buf is NULL"); 2162 return QDF_STATUS_E_INVAL; 2163 } 2164 2165 ev = param_buf->fixed_param; 2166 params->pdev_id = wmi_handle->ops->convert_pdev_id_target_to_host( 2167 wmi_handle, 2168 ev->pdev_id); 2169 params->num_sessions = param_buf->num_twt_sessions; 2170 2171 wmi_debug("pdev_id=%d, num of TWT sessions=%d", 2172 params->pdev_id, params->num_sessions); 2173 2174 return QDF_STATUS_SUCCESS; 2175 } 2176 2177 static QDF_STATUS 2178 extract_twt_session_stats_event_data(wmi_unified_t wmi_handle, 2179 uint8_t *evt_buf, 2180 struct wmi_twt_session_stats_event_param 2181 *params, 2182 struct wmi_host_twt_session_stats_info 2183 *session, 2184 uint32_t idx) 2185 { 2186 WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *param_buf; 2187 wmi_twt_session_stats_info *twt_session; 2188 uint32_t flags; 2189 wmi_mac_addr *m1; 2190 uint8_t *m2; 2191 2192 param_buf = 2193 (WMI_TWT_SESSION_STATS_EVENTID_param_tlvs *)evt_buf; 2194 if (!param_buf) { 2195 wmi_err("evt_buf is NULL"); 2196 return QDF_STATUS_E_INVAL; 2197 } 2198 2199 if (idx >= param_buf->num_twt_sessions) { 2200 wmi_err("wrong idx, idx=%d, num_sessions=%d", 2201 idx, param_buf->num_twt_sessions); 2202 return QDF_STATUS_E_INVAL; 2203 } 2204 2205 twt_session = ¶m_buf->twt_sessions[idx]; 2206 2207 session->vdev_id = twt_session->vdev_id; 2208 m1 = &twt_session->peer_mac; 2209 m2 = session->peer_mac; 2210 WMI_MAC_ADDR_TO_CHAR_ARRAY(m1, m2); 2211 session->event_type = twt_session->event_type; 2212 flags = twt_session->flow_id_flags; 2213 session->flow_id = WMI_TWT_SESSION_FLAG_FLOW_ID_GET(flags); 2214 session->bcast = WMI_TWT_SESSION_FLAG_BCAST_TWT_GET(flags); 2215 session->trig = WMI_TWT_SESSION_FLAG_TRIGGER_TWT_GET(flags); 2216 session->announ = WMI_TWT_SESSION_FLAG_ANNOUN_TWT_GET(flags); 2217 session->protection = WMI_TWT_SESSION_FLAG_TWT_PROTECTION_GET(flags); 2218 session->info_frame_disabled = 2219 WMI_TWT_SESSION_FLAG_TWT_INFO_FRAME_DISABLED_GET(flags); 2220 session->pm_responder_bit = 2221 WMI_TWT_SESSION_FLAG_TWT_PM_RESPONDER_MODE_GET(flags); 2222 session->pm_responder_bit_valid = 2223 WMI_TWT_SESSION_FLAG_TWT_PM_RESPONDER_MODE_VALID_GET(flags); 2224 session->dialog_id = twt_session->dialog_id; 2225 session->wake_dura_us = twt_session->wake_dura_us; 2226 session->wake_intvl_us = twt_session->wake_intvl_us; 2227 session->sp_offset_us = twt_session->sp_offset_us; 2228 session->sp_tsf_us_lo = twt_session->sp_tsf_us_lo; 2229 session->sp_tsf_us_hi = twt_session->sp_tsf_us_hi; 2230 wmi_debug("type=%d id=%d bcast=%d trig=%d announ=%d diagid=%d wake_dur=%ul wake_int=%ul offset=%ul", 2231 session->event_type, session->flow_id, 2232 session->bcast, session->trig, 2233 session->announ, session->dialog_id, session->wake_dura_us, 2234 session->wake_intvl_us, session->sp_offset_us); 2235 wmi_debug("resp_pm_valid=%d resp_pm=%d", 2236 session->pm_responder_bit_valid, session->pm_responder_bit); 2237 2238 return QDF_STATUS_SUCCESS; 2239 } 2240 2241 static QDF_STATUS extract_twt_cap_service_ready_ext2_tlv( 2242 wmi_unified_t wmi_handle, uint8_t *event, 2243 struct wmi_twt_cap_bitmap_params *var) 2244 { 2245 WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *param_buf; 2246 wmi_twt_caps_params *twt_caps; 2247 2248 param_buf = (WMI_SERVICE_READY_EXT2_EVENTID_param_tlvs *)event; 2249 if (!param_buf) 2250 return QDF_STATUS_E_INVAL; 2251 2252 twt_caps = param_buf->twt_caps; 2253 if (!twt_caps) 2254 return QDF_STATUS_E_INVAL; 2255 2256 var->twt_ack_support_cap = WMI_GET_BITS(twt_caps->twt_capability_bitmap, 2257 0, 1); 2258 2259 return QDF_STATUS_SUCCESS; 2260 } 2261 2262 static enum WMI_HOST_TWT_CMD_FOR_ACK_EVENT 2263 wmi_get_converted_twt_command_for_ack_event(WMI_CMD_ID tgt_cmd) 2264 { 2265 switch (tgt_cmd) { 2266 case WMI_TWT_ADD_DIALOG_CMDID: 2267 return WMI_HOST_TWT_ADD_DIALOG_CMDID; 2268 case WMI_TWT_DEL_DIALOG_CMDID: 2269 return WMI_HOST_TWT_DEL_DIALOG_CMDID; 2270 case WMI_TWT_PAUSE_DIALOG_CMDID: 2271 return WMI_HOST_TWT_PAUSE_DIALOG_CMDID; 2272 case WMI_TWT_RESUME_DIALOG_CMDID: 2273 return WMI_HOST_TWT_RESUME_DIALOG_CMDID; 2274 case WMI_TWT_NUDGE_DIALOG_CMDID: 2275 return WMI_HOST_TWT_NUDGE_DIALOG_CMDID; 2276 default: 2277 return WMI_HOST_TWT_UNKNOWN_CMDID; 2278 } 2279 } 2280 2281 static QDF_STATUS 2282 extract_twt_ack_comp_event_tlv(wmi_unified_t wmi_handle, 2283 uint8_t *evt_buf, 2284 struct wmi_twt_ack_complete_event_param *var) 2285 { 2286 WMI_TWT_ACK_EVENTID_param_tlvs *param_buf; 2287 wmi_twt_ack_event_fixed_param *ack_event; 2288 2289 param_buf = (WMI_TWT_ACK_EVENTID_param_tlvs *)evt_buf; 2290 if (!param_buf) { 2291 wmi_err("evt_buf is NULL"); 2292 return QDF_STATUS_E_INVAL; 2293 } 2294 2295 ack_event = param_buf->fixed_param; 2296 2297 var->vdev_id = ack_event->vdev_id; 2298 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ack_event->peer_macaddr, 2299 var->peer_macaddr.bytes); 2300 var->dialog_id = ack_event->dialog_id; 2301 var->twt_cmd_ack = wmi_get_converted_twt_command_for_ack_event( 2302 ack_event->twt_cmd); 2303 2304 switch (ack_event->twt_cmd) { 2305 case WMI_TWT_ADD_DIALOG_CMDID: 2306 var->status = wmi_get_converted_twt_add_dialog_status( 2307 ack_event->status); 2308 break; 2309 case WMI_TWT_DEL_DIALOG_CMDID: 2310 var->status = wmi_get_converted_twt_del_dialog_status( 2311 ack_event->status); 2312 break; 2313 case WMI_TWT_PAUSE_DIALOG_CMDID: 2314 var->status = wmi_twt_pause_status_to_host_twt_status( 2315 ack_event->status); 2316 break; 2317 case WMI_TWT_RESUME_DIALOG_CMDID: 2318 var->status = wmi_get_converted_twt_resume_dialog_status( 2319 ack_event->status); 2320 break; 2321 case WMI_TWT_NUDGE_DIALOG_CMDID: 2322 var->status = wmi_twt_nudge_status_to_host_twt_status( 2323 ack_event->status); 2324 break; 2325 default: 2326 break; 2327 } 2328 return QDF_STATUS_SUCCESS; 2329 } 2330 #endif 2331 2332 void wmi_twt_attach_tlv(wmi_unified_t wmi_handle) 2333 { 2334 struct wmi_ops *ops = wmi_handle->ops; 2335 2336 ops->send_twt_enable_cmd = send_twt_enable_cmd_tlv; 2337 ops->send_twt_disable_cmd = send_twt_disable_cmd_tlv; 2338 ops->send_twt_add_dialog_cmd = send_twt_add_dialog_cmd_tlv; 2339 ops->send_twt_del_dialog_cmd = send_twt_del_dialog_cmd_tlv; 2340 ops->send_twt_pause_dialog_cmd = send_twt_pause_dialog_cmd_tlv; 2341 ops->send_twt_nudge_dialog_cmd = send_twt_nudge_dialog_cmd_tlv; 2342 ops->send_twt_resume_dialog_cmd = send_twt_resume_dialog_cmd_tlv; 2343 ops->extract_twt_enable_comp_event = extract_twt_enable_comp_event_tlv; 2344 ops->extract_twt_disable_comp_event = 2345 extract_twt_disable_comp_event_tlv; 2346 ops->extract_twt_add_dialog_comp_event = 2347 extract_twt_add_dialog_comp_event_tlv; 2348 ops->extract_twt_add_dialog_comp_additional_params = 2349 extract_twt_add_dialog_comp_additional_parameters; 2350 ops->extract_twt_del_dialog_comp_event = 2351 extract_twt_del_dialog_comp_event_tlv; 2352 ops->extract_twt_pause_dialog_comp_event = 2353 extract_twt_pause_dialog_comp_event_tlv; 2354 ops->extract_twt_nudge_dialog_comp_event = 2355 extract_twt_nudge_dialog_comp_event_tlv; 2356 ops->extract_twt_resume_dialog_comp_event = 2357 extract_twt_resume_dialog_comp_event_tlv; 2358 ops->extract_twt_session_stats_event = 2359 extract_twt_session_stats_event_tlv; 2360 ops->extract_twt_session_stats_data = 2361 extract_twt_session_stats_event_data; 2362 ops->extract_twt_notify_event = 2363 extract_twt_notify_event_tlv; 2364 ops->extract_twt_cap_service_ready_ext2 = 2365 extract_twt_cap_service_ready_ext2_tlv, 2366 ops->extract_twt_ack_comp_event = extract_twt_ack_comp_event_tlv; 2367 wmi_twt_attach_bcast_twt_tlv(ops); 2368 } 2369