1 /* 2 * Copyright (c) 2013-2018 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <osdep.h> 20 #include <wmi.h> 21 #include <wmi_unified_priv.h> 22 #include <wmi_unified_p2p_api.h> 23 24 /** 25 * send_set_p2pgo_noa_req_cmd_tlv() - send p2p go noa request to fw 26 * @wmi_handle: wmi handle 27 * @noa: p2p power save parameters 28 * 29 * Return: CDF status 30 */ 31 static QDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle, 32 struct p2p_ps_params *noa) 33 { 34 wmi_p2p_set_noa_cmd_fixed_param *cmd; 35 wmi_p2p_noa_descriptor *noa_discriptor; 36 wmi_buf_t buf; 37 uint8_t *buf_ptr; 38 uint16_t len; 39 QDF_STATUS status; 40 uint32_t duration; 41 42 WMI_LOGD("%s: Enter", __func__); 43 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + sizeof(*noa_discriptor); 44 buf = wmi_buf_alloc(wmi_handle, len); 45 if (!buf) { 46 status = QDF_STATUS_E_FAILURE; 47 goto end; 48 } 49 50 buf_ptr = (uint8_t *)wmi_buf_data(buf); 51 cmd = (wmi_p2p_set_noa_cmd_fixed_param *)buf_ptr; 52 WMITLV_SET_HDR(&cmd->tlv_header, 53 WMITLV_TAG_STRUC_wmi_p2p_set_noa_cmd_fixed_param, 54 WMITLV_GET_STRUCT_TLVLEN 55 (wmi_p2p_set_noa_cmd_fixed_param)); 56 duration = (noa->count == 1) ? noa->single_noa_duration : noa->duration; 57 cmd->vdev_id = noa->session_id; 58 cmd->enable = (duration) ? true : false; 59 cmd->num_noa = 1; 60 61 WMITLV_SET_HDR((buf_ptr + sizeof(wmi_p2p_set_noa_cmd_fixed_param)), 62 WMITLV_TAG_ARRAY_STRUC, sizeof(wmi_p2p_noa_descriptor)); 63 noa_discriptor = (wmi_p2p_noa_descriptor *)(buf_ptr + 64 sizeof 65 (wmi_p2p_set_noa_cmd_fixed_param) 66 + WMI_TLV_HDR_SIZE); 67 WMITLV_SET_HDR(&noa_discriptor->tlv_header, 68 WMITLV_TAG_STRUC_wmi_p2p_noa_descriptor, 69 WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_noa_descriptor)); 70 noa_discriptor->type_count = noa->count; 71 noa_discriptor->duration = duration; 72 noa_discriptor->interval = noa->interval; 73 noa_discriptor->start_time = 0; 74 75 WMI_LOGI("SET P2P GO NOA:vdev_id:%d count:%d duration:%d interval:%d", 76 cmd->vdev_id, noa->count, noa_discriptor->duration, 77 noa->interval); 78 wmi_mtrace(WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID, cmd->vdev_id, 0); 79 status = wmi_unified_cmd_send(wmi_handle, buf, len, 80 WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID); 81 if (QDF_IS_STATUS_ERROR(status)) { 82 WMI_LOGE("Failed to send WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID"); 83 wmi_buf_free(buf); 84 } 85 86 end: 87 WMI_LOGD("%s: Exit", __func__); 88 return status; 89 } 90 91 /** 92 * send_set_p2pgo_oppps_req_cmd_tlv() - send p2p go opp power save request to fw 93 * @wmi_handle: wmi handle 94 * @noa: p2p opp power save parameters 95 * 96 * Return: CDF status 97 */ 98 static QDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle, 99 struct p2p_ps_params *oppps) 100 { 101 wmi_p2p_set_oppps_cmd_fixed_param *cmd; 102 wmi_buf_t buf; 103 QDF_STATUS status; 104 105 WMI_LOGD("%s: Enter", __func__); 106 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 107 if (!buf) { 108 status = QDF_STATUS_E_FAILURE; 109 goto end; 110 } 111 112 cmd = (wmi_p2p_set_oppps_cmd_fixed_param *) wmi_buf_data(buf); 113 WMITLV_SET_HDR(&cmd->tlv_header, 114 WMITLV_TAG_STRUC_wmi_p2p_set_oppps_cmd_fixed_param, 115 WMITLV_GET_STRUCT_TLVLEN( 116 wmi_p2p_set_oppps_cmd_fixed_param)); 117 cmd->vdev_id = oppps->session_id; 118 if (oppps->ctwindow) 119 WMI_UNIFIED_OPPPS_ATTR_ENABLED_SET(cmd); 120 121 WMI_UNIFIED_OPPPS_ATTR_CTWIN_SET(cmd, oppps->ctwindow); 122 WMI_LOGI("SET P2P GO OPPPS:vdev_id:%d ctwindow:%d", 123 cmd->vdev_id, oppps->ctwindow); 124 wmi_mtrace(WMI_P2P_SET_OPPPS_PARAM_CMDID, cmd->vdev_id, 0); 125 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 126 WMI_P2P_SET_OPPPS_PARAM_CMDID); 127 if (QDF_IS_STATUS_ERROR(status)) { 128 WMI_LOGE("Failed to send WMI_P2P_SET_OPPPS_PARAM_CMDID"); 129 wmi_buf_free(buf); 130 } 131 132 end: 133 WMI_LOGD("%s: Exit", __func__); 134 return status; 135 } 136 137 /** 138 * extract_p2p_noa_ev_param_tlv() - extract p2p noa information from event 139 * @wmi_handle: wmi handle 140 * @param evt_buf: pointer to event buffer 141 * @param param: Pointer to hold p2p noa info 142 * 143 * Return: QDF_STATUS_SUCCESS for success or error code 144 */ 145 static QDF_STATUS extract_p2p_noa_ev_param_tlv( 146 wmi_unified_t wmi_handle, void *evt_buf, 147 struct p2p_noa_info *param) 148 { 149 WMI_P2P_NOA_EVENTID_param_tlvs *param_tlvs; 150 wmi_p2p_noa_event_fixed_param *fixed_param; 151 uint8_t i; 152 wmi_p2p_noa_info *wmi_noa_info; 153 uint8_t *buf_ptr; 154 uint32_t descriptors; 155 156 param_tlvs = (WMI_P2P_NOA_EVENTID_param_tlvs *)evt_buf; 157 if (!param_tlvs) { 158 WMI_LOGE("%s: Invalid P2P NoA event buffer", __func__); 159 return QDF_STATUS_E_INVAL; 160 } 161 162 if (!param) { 163 WMI_LOGE("noa information param is null"); 164 return QDF_STATUS_E_INVAL; 165 } 166 167 fixed_param = param_tlvs->fixed_param; 168 buf_ptr = (uint8_t *) fixed_param; 169 buf_ptr += sizeof(wmi_p2p_noa_event_fixed_param); 170 wmi_noa_info = (wmi_p2p_noa_info *) (buf_ptr); 171 172 if (!WMI_UNIFIED_NOA_ATTR_IS_MODIFIED(wmi_noa_info)) { 173 WMI_LOGE("%s: noa attr is not modified", __func__); 174 return QDF_STATUS_E_INVAL; 175 } 176 177 param->vdev_id = fixed_param->vdev_id; 178 param->index = 179 (uint8_t)WMI_UNIFIED_NOA_ATTR_INDEX_GET(wmi_noa_info); 180 param->opps_ps = 181 (uint8_t)WMI_UNIFIED_NOA_ATTR_OPP_PS_GET(wmi_noa_info); 182 param->ct_window = 183 (uint8_t)WMI_UNIFIED_NOA_ATTR_CTWIN_GET(wmi_noa_info); 184 descriptors = WMI_UNIFIED_NOA_ATTR_NUM_DESC_GET(wmi_noa_info); 185 param->num_desc = (uint8_t)descriptors; 186 if (param->num_desc > WMI_P2P_MAX_NOA_DESCRIPTORS) { 187 WMI_LOGE("%s: invalid num desc:%d", __func__, 188 param->num_desc); 189 return QDF_STATUS_E_INVAL; 190 } 191 192 WMI_LOGD("%s:index %u, opps_ps %u, ct_window %u, num_descriptors = %u", 193 __func__, 194 param->index, param->opps_ps, param->ct_window, 195 param->num_desc); 196 for (i = 0; i < param->num_desc; i++) { 197 param->noa_desc[i].type_count = 198 (uint8_t)wmi_noa_info->noa_descriptors[i]. 199 type_count; 200 param->noa_desc[i].duration = 201 wmi_noa_info->noa_descriptors[i].duration; 202 param->noa_desc[i].interval = 203 wmi_noa_info->noa_descriptors[i].interval; 204 param->noa_desc[i].start_time = 205 wmi_noa_info->noa_descriptors[i].start_time; 206 WMI_LOGD("%s:NoA descriptor[%d] type_count %u, duration %u, interval %u, start_time = %u", 207 __func__, i, param->noa_desc[i].type_count, 208 param->noa_desc[i].duration, 209 param->noa_desc[i].interval, 210 param->noa_desc[i].start_time); 211 } 212 213 return QDF_STATUS_SUCCESS; 214 } 215 216 static QDF_STATUS 217 send_set_mac_addr_rx_filter_cmd_tlv(wmi_unified_t wmi_handle, 218 struct p2p_set_mac_filter *param) 219 { 220 wmi_vdev_add_mac_addr_to_rx_filter_cmd_fixed_param *cmd; 221 uint32_t len; 222 wmi_buf_t buf; 223 int ret; 224 225 if (!wmi_handle) { 226 WMI_LOGE("WMA context is invald!"); 227 return QDF_STATUS_E_INVAL; 228 } 229 230 len = sizeof(*cmd); 231 buf = wmi_buf_alloc(wmi_handle, len); 232 if (!buf) { 233 WMI_LOGE("Failed allocate wmi buffer"); 234 return QDF_STATUS_E_NOMEM; 235 } 236 237 cmd = (wmi_vdev_add_mac_addr_to_rx_filter_cmd_fixed_param *) 238 wmi_buf_data(buf); 239 240 WMITLV_SET_HDR( 241 &cmd->tlv_header, 242 WMITLV_TAG_STRUC_wmi_vdev_add_mac_addr_to_rx_filter_cmd_fixed_param, 243 WMITLV_GET_STRUCT_TLVLEN( 244 wmi_vdev_add_mac_addr_to_rx_filter_cmd_fixed_param)); 245 246 cmd->vdev_id = param->vdev_id; 247 cmd->freq = param->freq; 248 WMI_CHAR_ARRAY_TO_MAC_ADDR(param->mac, &cmd->mac_addr); 249 if (param->set) 250 cmd->enable = 1; 251 else 252 cmd->enable = 0; 253 WMI_LOGD("set random mac rx vdev %d freq %d set %d %pM", 254 param->vdev_id, param->freq, param->set, param->mac); 255 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 256 WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_CMDID); 257 if (ret) { 258 WMI_LOGE("Failed to send action frame random mac cmd"); 259 wmi_buf_free(buf); 260 return QDF_STATUS_E_FAILURE; 261 } 262 263 return QDF_STATUS_SUCCESS; 264 } 265 266 static QDF_STATUS extract_mac_addr_rx_filter_evt_param_tlv( 267 wmi_unified_t wmi_handle, void *evt_buf, 268 struct p2p_set_mac_filter_evt *param) 269 { 270 WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_STATUS_EVENTID_param_tlvs *param_buf; 271 wmi_vdev_add_mac_addr_to_rx_filter_status_event_fixed_param *event; 272 273 param_buf = 274 (WMI_VDEV_ADD_MAC_ADDR_TO_RX_FILTER_STATUS_EVENTID_param_tlvs *) 275 evt_buf; 276 if (!param_buf) { 277 WMI_LOGE("Invalid action frame filter mac event"); 278 return QDF_STATUS_E_INVAL; 279 } 280 event = param_buf->fixed_param; 281 if (!event) { 282 WMI_LOGE("Invalid fixed param"); 283 return QDF_STATUS_E_INVAL; 284 } 285 param->vdev_id = event->vdev_id; 286 param->status = event->status; 287 288 return QDF_STATUS_SUCCESS; 289 } 290 291 #ifdef FEATURE_P2P_LISTEN_OFFLOAD 292 /** 293 * send_p2p_lo_start_cmd_tlv() - send p2p lo start request to fw 294 * @wmi_handle: wmi handle 295 * @param: p2p listen offload start parameters 296 * 297 * Return: QDF status 298 */ 299 static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle, 300 struct p2p_lo_start *param) 301 { 302 wmi_buf_t buf; 303 wmi_p2p_lo_start_cmd_fixed_param *cmd; 304 int32_t len = sizeof(*cmd); 305 uint8_t *buf_ptr; 306 QDF_STATUS status; 307 int device_types_len_aligned; 308 int probe_resp_len_aligned; 309 310 if (!param) { 311 WMI_LOGE("lo start param is null"); 312 return QDF_STATUS_E_INVAL; 313 } 314 315 WMI_LOGD("%s: vdev_id:%d", __func__, param->vdev_id); 316 317 device_types_len_aligned = 318 qdf_roundup(param->dev_types_len, 319 sizeof(uint32_t)); 320 probe_resp_len_aligned = 321 qdf_roundup(param->probe_resp_len, 322 sizeof(uint32_t)); 323 324 len += 2 * WMI_TLV_HDR_SIZE + device_types_len_aligned + 325 probe_resp_len_aligned; 326 327 buf = wmi_buf_alloc(wmi_handle, len); 328 if (!buf) { 329 return QDF_STATUS_E_NOMEM; 330 } 331 332 cmd = (wmi_p2p_lo_start_cmd_fixed_param *)wmi_buf_data(buf); 333 buf_ptr = (uint8_t *) wmi_buf_data(buf); 334 335 WMITLV_SET_HDR(&cmd->tlv_header, 336 WMITLV_TAG_STRUC_wmi_p2p_lo_start_cmd_fixed_param, 337 WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_lo_start_cmd_fixed_param)); 338 339 cmd->vdev_id = param->vdev_id; 340 cmd->ctl_flags = param->ctl_flags; 341 cmd->channel = param->freq; 342 cmd->period = param->period; 343 cmd->interval = param->interval; 344 cmd->count = param->count; 345 cmd->device_types_len = param->dev_types_len; 346 cmd->prob_resp_len = param->probe_resp_len; 347 348 buf_ptr += sizeof(wmi_p2p_lo_start_cmd_fixed_param); 349 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, 350 device_types_len_aligned); 351 buf_ptr += WMI_TLV_HDR_SIZE; 352 qdf_mem_copy(buf_ptr, param->device_types, 353 param->dev_types_len); 354 355 buf_ptr += device_types_len_aligned; 356 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, 357 probe_resp_len_aligned); 358 buf_ptr += WMI_TLV_HDR_SIZE; 359 qdf_mem_copy(buf_ptr, param->probe_resp_tmplt, 360 param->probe_resp_len); 361 362 WMI_LOGD("%s: Sending WMI_P2P_LO_START command, channel=%d, period=%d, interval=%d, count=%d", __func__, 363 cmd->channel, cmd->period, cmd->interval, cmd->count); 364 365 wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_START_CMDID, cmd->vdev_id, 0); 366 status = wmi_unified_cmd_send(wmi_handle, 367 buf, len, 368 WMI_P2P_LISTEN_OFFLOAD_START_CMDID); 369 if (status != QDF_STATUS_SUCCESS) { 370 WMI_LOGE("%s: Failed to send p2p lo start: %d", 371 __func__, status); 372 wmi_buf_free(buf); 373 return status; 374 } 375 376 WMI_LOGD("%s: Successfully sent WMI_P2P_LO_START", __func__); 377 378 return QDF_STATUS_SUCCESS; 379 } 380 381 /** 382 * send_p2p_lo_stop_cmd_tlv() - send p2p lo stop request to fw 383 * @wmi_handle: wmi handle 384 * @param: p2p listen offload stop parameters 385 * 386 * Return: QDF status 387 */ 388 static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle, 389 uint8_t vdev_id) 390 { 391 wmi_buf_t buf; 392 wmi_p2p_lo_stop_cmd_fixed_param *cmd; 393 int32_t len; 394 QDF_STATUS status; 395 396 WMI_LOGD("%s: vdev_id:%d", __func__, vdev_id); 397 398 len = sizeof(*cmd); 399 buf = wmi_buf_alloc(wmi_handle, len); 400 if (!buf) { 401 return QDF_STATUS_E_NOMEM; 402 } 403 cmd = (wmi_p2p_lo_stop_cmd_fixed_param *)wmi_buf_data(buf); 404 405 WMITLV_SET_HDR(&cmd->tlv_header, 406 WMITLV_TAG_STRUC_wmi_p2p_lo_stop_cmd_fixed_param, 407 WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_lo_stop_cmd_fixed_param)); 408 409 cmd->vdev_id = vdev_id; 410 411 WMI_LOGD("%s: Sending WMI_P2P_LO_STOP command", __func__); 412 413 wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID, cmd->vdev_id, 0); 414 status = wmi_unified_cmd_send(wmi_handle, 415 buf, len, 416 WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID); 417 if (status != QDF_STATUS_SUCCESS) { 418 WMI_LOGE("%s: Failed to send p2p lo stop: %d", 419 __func__, status); 420 wmi_buf_free(buf); 421 return status; 422 } 423 424 WMI_LOGD("%s: Successfully sent WMI_P2P_LO_STOP", __func__); 425 426 return QDF_STATUS_SUCCESS; 427 } 428 429 /** 430 * extract_p2p_lo_stop_ev_param_tlv() - extract p2p lo stop 431 * information from event 432 * @wmi_handle: wmi handle 433 * @param evt_buf: pointer to event buffer 434 * @param param: Pointer to hold p2p lo stop event information 435 * 436 * Return: QDF_STATUS_SUCCESS for success or error code 437 */ 438 static QDF_STATUS extract_p2p_lo_stop_ev_param_tlv( 439 wmi_unified_t wmi_handle, void *evt_buf, 440 struct p2p_lo_event *param) 441 { 442 WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID_param_tlvs *param_tlvs; 443 wmi_p2p_lo_stopped_event_fixed_param *lo_param; 444 445 param_tlvs = (WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID_param_tlvs *) 446 evt_buf; 447 if (!param_tlvs) { 448 WMI_LOGE("%s: Invalid P2P lo stop event buffer", __func__); 449 return QDF_STATUS_E_INVAL; 450 } 451 452 if (!param) { 453 WMI_LOGE("lo stop event param is null"); 454 return QDF_STATUS_E_INVAL; 455 } 456 457 lo_param = param_tlvs->fixed_param; 458 param->vdev_id = lo_param->vdev_id; 459 param->reason_code = lo_param->reason; 460 WMI_LOGD("%s: vdev_id:%d, reason:%d", __func__, 461 param->vdev_id, param->reason_code); 462 463 return QDF_STATUS_SUCCESS; 464 } 465 466 void wmi_p2p_listen_offload_attach_tlv(wmi_unified_t wmi_handle) 467 { 468 struct wmi_ops *ops = wmi_handle->ops; 469 470 ops->send_p2p_lo_start_cmd = send_p2p_lo_start_cmd_tlv; 471 ops->send_p2p_lo_stop_cmd = send_p2p_lo_stop_cmd_tlv; 472 ops->extract_p2p_lo_stop_ev_param = 473 extract_p2p_lo_stop_ev_param_tlv; 474 } 475 #endif /* FEATURE_P2P_LISTEN_OFFLOAD */ 476 477 void wmi_p2p_attach_tlv(wmi_unified_t wmi_handle) 478 { 479 struct wmi_ops *ops = wmi_handle->ops; 480 481 ops->send_set_p2pgo_oppps_req_cmd = send_set_p2pgo_oppps_req_cmd_tlv; 482 ops->send_set_p2pgo_noa_req_cmd = send_set_p2pgo_noa_req_cmd_tlv; 483 ops->extract_p2p_noa_ev_param = extract_p2p_noa_ev_param_tlv; 484 ops->set_mac_addr_rx_filter = send_set_mac_addr_rx_filter_cmd_tlv, 485 ops->extract_mac_addr_rx_filter_evt_param = 486 extract_mac_addr_rx_filter_evt_param_tlv, 487 wmi_p2p_listen_offload_attach_tlv(wmi_handle); 488 } 489 490