1 /* 2 * Copyright (c) 2013-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022 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 <nan_public_structs.h> 24 #include <wmi_unified_nan_api.h> 25 #include <wlan_nan_msg_common_v2.h> 26 27 static QDF_STATUS 28 extract_nan_event_rsp_tlv(wmi_unified_t wmi_handle, void *evt_buf, 29 struct nan_event_params *evt_params, 30 uint8_t **msg_buf) 31 { 32 WMI_NAN_EVENTID_param_tlvs *event; 33 wmi_nan_event_hdr *nan_rsp_event_hdr; 34 nan_msg_header_t *nan_msg_hdr; 35 wmi_nan_event_info *nan_evt_info; 36 37 /* 38 * This is how received evt looks like 39 * 40 * <-------------------- evt_buf -----------------------------------> 41 * 42 * <--wmi_nan_event_hdr--><---WMI_TLV_HDR_SIZE---><----- data --------> 43 * 44 * +-----------+---------+-----------------------+--------------------+- 45 * | tlv_header| data_len| WMITLV_TAG_ARRAY_BYTE | nan_rsp_event_data | 46 * +-----------+---------+-----------------------+--------------------+- 47 * 48 * (Only for NAN Enable Resp) 49 * <--wmi_nan_event_info--> 50 * +-----------+-----------+ 51 * | tlv_header| event_info| 52 * +-----------+-----------+ 53 * 54 */ 55 56 event = (WMI_NAN_EVENTID_param_tlvs *)evt_buf; 57 nan_rsp_event_hdr = event->fixed_param; 58 59 /* Actual data may include some padding, so data_len <= num_data */ 60 if (nan_rsp_event_hdr->data_len > event->num_data) { 61 wmi_err("Provided NAN event length(%d) exceeding actual length(%d)!", 62 nan_rsp_event_hdr->data_len, 63 event->num_data); 64 return QDF_STATUS_E_INVAL; 65 } 66 evt_params->buf_len = nan_rsp_event_hdr->data_len; 67 *msg_buf = event->data; 68 69 if (nan_rsp_event_hdr->data_len < sizeof(nan_msg_header_t) || 70 nan_rsp_event_hdr->data_len > (WMI_SVC_MSG_MAX_SIZE - 71 WMI_TLV_HDR_SIZE)) { 72 wmi_err("Invalid NAN event data length(%d)!", 73 nan_rsp_event_hdr->data_len); 74 return QDF_STATUS_E_INVAL; 75 } 76 nan_msg_hdr = (nan_msg_header_t *)event->data; 77 78 if (!wmi_service_enabled(wmi_handle, wmi_service_nan_dbs_support) && 79 !wmi_service_enabled(wmi_handle, wmi_service_nan_disable_support)) { 80 evt_params->evt_type = nan_event_id_generic_rsp; 81 return QDF_STATUS_SUCCESS; 82 } 83 84 switch (nan_msg_hdr->msg_id) { 85 case NAN_MSG_ID_ENABLE_RSP: 86 nan_evt_info = event->event_info; 87 if (!nan_evt_info) { 88 wmi_err("Fail: NAN enable rsp event info Null"); 89 return QDF_STATUS_E_INVAL; 90 } 91 evt_params->evt_type = nan_event_id_enable_rsp; 92 evt_params->mac_id = nan_evt_info->mac_id; 93 evt_params->is_nan_enable_success = (nan_evt_info->status == 0); 94 evt_params->vdev_id = nan_evt_info->vdev_id; 95 break; 96 case NAN_MSG_ID_DISABLE_IND: 97 evt_params->evt_type = nan_event_id_disable_ind; 98 break; 99 case NAN_MSG_ID_ERROR_RSP: 100 evt_params->evt_type = nan_event_id_error_rsp; 101 break; 102 default: 103 evt_params->evt_type = nan_event_id_generic_rsp; 104 break; 105 } 106 107 return QDF_STATUS_SUCCESS; 108 } 109 110 /** 111 * send_nan_disable_req_cmd_tlv() - to send nan disable request to target 112 * @wmi_handle: wmi handle 113 * @nan_msg: request data which will be non-null 114 * 115 * Return: CDF status 116 */ 117 static QDF_STATUS send_nan_disable_req_cmd_tlv(wmi_unified_t wmi_handle, 118 struct nan_disable_req *nan_msg) 119 { 120 QDF_STATUS ret; 121 wmi_nan_cmd_param *cmd; 122 wmi_nan_host_config_param *cfg; 123 wmi_buf_t buf; 124 /* Initialize with minimum length required, which is Scenario 2*/ 125 uint16_t len = sizeof(*cmd) + sizeof(*cfg) + 2 * WMI_TLV_HDR_SIZE; 126 uint16_t nan_data_len, nan_data_len_aligned = 0; 127 uint8_t *buf_ptr; 128 129 /* 130 * Scenario 1: NAN Disable with NAN msg data from upper layers 131 * 132 * <-----nan cmd param-----><-- WMI_TLV_HDR_SIZE --><--- data ----> 133 * +------------+----------+-----------------------+--------------+ 134 * | tlv_header | data_len | WMITLV_TAG_ARRAY_BYTE | nan_msg_data | 135 * +------------+----------+-----------------------+--------------+ 136 * 137 * <-- WMI_TLV_HDR_SIZE --><------nan host config params-----> 138 * -+-----------------------+---------------------------------+ 139 * | WMITLV_TAG_ARRAY_STRUC| tlv_header | 2g/5g disable flags| 140 * -+-----------------------+---------------------------------+ 141 * 142 * Scenario 2: NAN Disable without any NAN msg data from upper layers 143 * 144 * <------nan cmd param------><--WMI_TLV_HDR_SIZE--><--WMI_TLV_HDR_SI 145 * +------------+------------+----------------------+---------------- 146 * | tlv_header | data_len=0 | WMITLV_TAG_ARRAY_BYTE| WMITLV_TAG_ARRA 147 * +------------+------------+----------------------+---------------- 148 * 149 * ZE----><------nan host config params-----> 150 * -------+---------------------------------+ 151 * Y_STRUC| tlv_header | 2g/5g disable flags| 152 * -------+---------------------------------+ 153 */ 154 155 if (!nan_msg) { 156 wmi_err("nan req is not valid"); 157 return QDF_STATUS_E_FAILURE; 158 } 159 160 nan_data_len = nan_msg->params.request_data_len; 161 162 if (nan_data_len) { 163 nan_data_len_aligned = roundup(nan_data_len, sizeof(uint32_t)); 164 if (nan_data_len_aligned < nan_data_len) { 165 wmi_err("Int overflow while rounding up data_len"); 166 return QDF_STATUS_E_FAILURE; 167 } 168 169 if (nan_data_len_aligned > WMI_SVC_MSG_MAX_SIZE 170 - WMI_TLV_HDR_SIZE) { 171 wmi_err("nan_data_len exceeding wmi_max_msg_size"); 172 return QDF_STATUS_E_FAILURE; 173 } 174 175 len += nan_data_len_aligned; 176 } 177 178 buf = wmi_buf_alloc(wmi_handle, len); 179 if (!buf) 180 return QDF_STATUS_E_NOMEM; 181 182 buf_ptr = (uint8_t *)wmi_buf_data(buf); 183 cmd = (wmi_nan_cmd_param *)buf_ptr; 184 WMITLV_SET_HDR(&cmd->tlv_header, 185 WMITLV_TAG_STRUC_wmi_nan_cmd_param, 186 WMITLV_GET_STRUCT_TLVLEN(wmi_nan_cmd_param)); 187 188 cmd->data_len = nan_data_len; 189 wmi_debug("nan data len value is %u", nan_data_len); 190 buf_ptr += sizeof(wmi_nan_cmd_param); 191 192 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, nan_data_len_aligned); 193 buf_ptr += WMI_TLV_HDR_SIZE; 194 195 if (nan_data_len) { 196 qdf_mem_copy(buf_ptr, nan_msg->params.request_data, 197 cmd->data_len); 198 buf_ptr += nan_data_len_aligned; 199 } 200 201 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 202 sizeof(wmi_nan_host_config_param)); 203 buf_ptr += WMI_TLV_HDR_SIZE; 204 205 cfg = (wmi_nan_host_config_param *)buf_ptr; 206 WMITLV_SET_HDR(&cfg->tlv_header, 207 WMITLV_TAG_STRUC_wmi_nan_host_config_param, 208 WMITLV_GET_STRUCT_TLVLEN(wmi_nan_host_config_param)); 209 cfg->nan_2g_disc_disable = nan_msg->disable_2g_discovery; 210 cfg->nan_5g_disc_disable = nan_msg->disable_5g_discovery; 211 212 wmi_mtrace(WMI_NAN_CMDID, NO_SESSION, 0); 213 ret = wmi_unified_cmd_send(wmi_handle, buf, len, 214 WMI_NAN_CMDID); 215 if (QDF_IS_STATUS_ERROR(ret)) { 216 wmi_err("Failed to send set param command ret = %d", ret); 217 wmi_buf_free(buf); 218 } 219 220 return ret; 221 } 222 223 /** 224 * send_nan_req_cmd_tlv() - to send nan request to target 225 * @wmi_handle: wmi handle 226 * @nan_msg: request data which will be non-null 227 * 228 * Return: CDF status 229 */ 230 static QDF_STATUS send_nan_req_cmd_tlv(wmi_unified_t wmi_handle, 231 struct nan_msg_params *nan_msg) 232 { 233 QDF_STATUS ret; 234 wmi_nan_cmd_param *cmd; 235 wmi_buf_t buf; 236 wmi_nan_host_config_param *cfg; 237 uint16_t len = sizeof(*cmd) + sizeof(*cfg) + 2 * WMI_TLV_HDR_SIZE; 238 uint16_t nan_data_len, nan_data_len_aligned; 239 uint8_t *buf_ptr; 240 241 /* 242 * <----- cmd ------------><-- WMI_TLV_HDR_SIZE --><--- data ----> 243 * +------------+----------+-----------------------+--------------+ 244 * | tlv_header | data_len | WMITLV_TAG_ARRAY_BYTE | nan_msg_data | 245 * +------------+----------+-----------------------+--------------+ 246 * 247 * <-- WMI_TLV_HDR_SIZE --><------nan host config params--------> 248 * +-----------------------+------------------------------------+ 249 * | WMITLV_TAG_ARRAY_STRUC| tlv_header | disable flags | flags | 250 * +-----------------------+------------------------------------+ 251 */ 252 if (!nan_msg) { 253 wmi_err("nan req is not valid"); 254 return QDF_STATUS_E_FAILURE; 255 } 256 nan_data_len = nan_msg->request_data_len; 257 nan_data_len_aligned = roundup(nan_msg->request_data_len, 258 sizeof(uint32_t)); 259 if (nan_data_len_aligned < nan_msg->request_data_len) { 260 wmi_err("integer overflow while rounding up data_len"); 261 return QDF_STATUS_E_FAILURE; 262 } 263 264 if (nan_data_len_aligned > WMI_SVC_MSG_MAX_SIZE - WMI_TLV_HDR_SIZE) { 265 wmi_err("wmi_max_msg_size overflow for given datalen"); 266 return QDF_STATUS_E_FAILURE; 267 } 268 269 len += nan_data_len_aligned; 270 buf = wmi_buf_alloc(wmi_handle, len); 271 if (!buf) 272 return QDF_STATUS_E_NOMEM; 273 274 buf_ptr = (uint8_t *)wmi_buf_data(buf); 275 cmd = (wmi_nan_cmd_param *)buf_ptr; 276 WMITLV_SET_HDR(&cmd->tlv_header, 277 WMITLV_TAG_STRUC_wmi_nan_cmd_param, 278 WMITLV_GET_STRUCT_TLVLEN(wmi_nan_cmd_param)); 279 cmd->data_len = nan_msg->request_data_len; 280 buf_ptr += sizeof(wmi_nan_cmd_param); 281 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, nan_data_len_aligned); 282 buf_ptr += WMI_TLV_HDR_SIZE; 283 qdf_mem_copy(buf_ptr, nan_msg->request_data, cmd->data_len); 284 buf_ptr += nan_data_len_aligned; 285 286 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 287 sizeof(wmi_nan_host_config_param)); 288 buf_ptr += WMI_TLV_HDR_SIZE; 289 290 cfg = (wmi_nan_host_config_param *)buf_ptr; 291 WMITLV_SET_HDR(&cfg->tlv_header, 292 WMITLV_TAG_STRUC_wmi_nan_host_config_param, 293 WMITLV_GET_STRUCT_TLVLEN(wmi_nan_host_config_param)); 294 295 WMI_NAN_SET_RANGING_INITIATOR_ROLE(cfg->flags, !!(nan_msg->rtt_cap & 296 WMI_FW_NAN_RTT_INITR)); 297 WMI_NAN_SET_RANGING_RESPONDER_ROLE(cfg->flags, !!(nan_msg->rtt_cap & 298 WMI_FW_NAN_RTT_RESPR)); 299 WMI_NAN_SET_NAN_6G_DISABLE(cfg->flags, nan_msg->disable_6g_nan); 300 301 wmi_mtrace(WMI_NAN_CMDID, NO_SESSION, 0); 302 ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_NAN_CMDID); 303 if (QDF_IS_STATUS_ERROR(ret)) { 304 wmi_err("Failed to send NAN req command ret = %d", ret); 305 wmi_buf_free(buf); 306 } 307 308 return ret; 309 } 310 311 /** 312 * send_terminate_all_ndps_cmd_tlv() - send NDP Terminate for all NDP's 313 * associated with the given vdev id 314 * @wmi_handle: wmi handle 315 * @vdev_id: vdev id 316 * 317 * Return: QDF status 318 */ 319 static QDF_STATUS send_terminate_all_ndps_cmd_tlv(wmi_unified_t wmi_handle, 320 uint32_t vdev_id) 321 { 322 wmi_ndp_cmd_param *cmd; 323 wmi_buf_t wmi_buf; 324 uint32_t len; 325 QDF_STATUS status; 326 327 wmi_debug("Enter"); 328 329 len = sizeof(*cmd); 330 wmi_buf = wmi_buf_alloc(wmi_handle, len); 331 if (!wmi_buf) 332 return QDF_STATUS_E_NOMEM; 333 334 cmd = (wmi_ndp_cmd_param *)wmi_buf_data(wmi_buf); 335 336 WMITLV_SET_HDR(&cmd->tlv_header, WMITLV_TAG_STRUC_wmi_ndp_cmd_param, 337 WMITLV_GET_STRUCT_TLVLEN(wmi_ndp_cmd_param)); 338 339 cmd->vdev_id = vdev_id; 340 cmd->ndp_disable = 1; 341 342 wmi_mtrace(WMI_NDP_CMDID, NO_SESSION, 0); 343 status = wmi_unified_cmd_send(wmi_handle, wmi_buf, len, WMI_NDP_CMDID); 344 if (QDF_IS_STATUS_ERROR(status)) { 345 wmi_err("Failed to send NDP Terminate cmd: %d", status); 346 wmi_buf_free(wmi_buf); 347 } 348 349 return status; 350 } 351 352 static QDF_STATUS nan_ndp_initiator_req_tlv(wmi_unified_t wmi_handle, 353 struct nan_datapath_initiator_req *ndp_req) 354 { 355 uint16_t len; 356 wmi_buf_t buf; 357 uint8_t *tlv_ptr; 358 QDF_STATUS status; 359 wmi_channel *ch_tlv; 360 wmi_ndp_initiator_req_fixed_param *cmd; 361 uint32_t passphrase_len, service_name_len; 362 uint32_t ndp_cfg_len, ndp_app_info_len, pmk_len; 363 wmi_ndp_transport_ip_param *tcp_ip_param; 364 365 /* 366 * WMI command expects 4 byte aligned len: 367 * round up ndp_cfg_len and ndp_app_info_len to 4 bytes 368 */ 369 ndp_cfg_len = qdf_roundup(ndp_req->ndp_config.ndp_cfg_len, 4); 370 ndp_app_info_len = qdf_roundup(ndp_req->ndp_info.ndp_app_info_len, 4); 371 pmk_len = qdf_roundup(ndp_req->pmk.pmk_len, 4); 372 passphrase_len = qdf_roundup(ndp_req->passphrase.passphrase_len, 4); 373 service_name_len = 374 qdf_roundup(ndp_req->service_name.service_name_len, 4); 375 /* allocated memory for fixed params as well as variable size data */ 376 len = sizeof(*cmd) + sizeof(*ch_tlv) + (5 * WMI_TLV_HDR_SIZE) 377 + ndp_cfg_len + ndp_app_info_len + pmk_len 378 + passphrase_len + service_name_len; 379 380 if (ndp_req->is_ipv6_addr_present) 381 len += sizeof(*tcp_ip_param); 382 383 buf = wmi_buf_alloc(wmi_handle, len); 384 if (!buf) { 385 return QDF_STATUS_E_NOMEM; 386 } 387 388 cmd = (wmi_ndp_initiator_req_fixed_param *) wmi_buf_data(buf); 389 WMITLV_SET_HDR(&cmd->tlv_header, 390 WMITLV_TAG_STRUC_wmi_ndp_initiator_req_fixed_param, 391 WMITLV_GET_STRUCT_TLVLEN( 392 wmi_ndp_initiator_req_fixed_param)); 393 cmd->vdev_id = wlan_vdev_get_id(ndp_req->vdev); 394 cmd->transaction_id = ndp_req->transaction_id; 395 cmd->service_instance_id = ndp_req->service_instance_id; 396 WMI_CHAR_ARRAY_TO_MAC_ADDR(ndp_req->peer_discovery_mac_addr.bytes, 397 &cmd->peer_discovery_mac_addr); 398 399 cmd->ndp_cfg_len = ndp_req->ndp_config.ndp_cfg_len; 400 cmd->ndp_app_info_len = ndp_req->ndp_info.ndp_app_info_len; 401 cmd->ndp_channel_cfg = ndp_req->channel_cfg; 402 cmd->nan_pmk_len = ndp_req->pmk.pmk_len; 403 cmd->nan_csid = ndp_req->ncs_sk_type; 404 cmd->nan_passphrase_len = ndp_req->passphrase.passphrase_len; 405 cmd->nan_servicename_len = ndp_req->service_name.service_name_len; 406 407 ch_tlv = (wmi_channel *)&cmd[1]; 408 WMITLV_SET_HDR(ch_tlv, WMITLV_TAG_STRUC_wmi_channel, 409 WMITLV_GET_STRUCT_TLVLEN(wmi_channel)); 410 ch_tlv->mhz = ndp_req->channel; 411 tlv_ptr = (uint8_t *)&ch_tlv[1]; 412 413 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_cfg_len); 414 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], 415 ndp_req->ndp_config.ndp_cfg, cmd->ndp_cfg_len); 416 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + ndp_cfg_len; 417 418 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_app_info_len); 419 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], 420 ndp_req->ndp_info.ndp_app_info, cmd->ndp_app_info_len); 421 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + ndp_app_info_len; 422 423 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, pmk_len); 424 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], ndp_req->pmk.pmk, 425 cmd->nan_pmk_len); 426 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + pmk_len; 427 428 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, passphrase_len); 429 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], ndp_req->passphrase.passphrase, 430 cmd->nan_passphrase_len); 431 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + passphrase_len; 432 433 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, service_name_len); 434 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], 435 ndp_req->service_name.service_name, 436 cmd->nan_servicename_len); 437 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + service_name_len; 438 439 if (ndp_req->is_ipv6_addr_present) { 440 tcp_ip_param = (wmi_ndp_transport_ip_param *)tlv_ptr; 441 WMITLV_SET_HDR(tcp_ip_param, 442 WMITLV_TAG_STRUC_wmi_ndp_transport_ip_param, 443 WMITLV_GET_STRUCT_TLVLEN( 444 wmi_ndp_transport_ip_param)); 445 tcp_ip_param->ipv6_addr_present = true; 446 qdf_mem_copy(tcp_ip_param->ipv6_intf_addr, 447 ndp_req->ipv6_addr, WMI_NDP_IPV6_INTF_ADDR_LEN); 448 } 449 wmi_debug("IPv6 addr present: %d, addr: %pI6", 450 ndp_req->is_ipv6_addr_present, ndp_req->ipv6_addr); 451 452 wmi_debug("vdev_id = %d, transaction_id: %d, service_instance_id: %d, ch: %d, ch_cfg: %d, csid: %d peer mac addr: mac_addr31to0: 0x%x, mac_addr47to32: 0x%x", 453 cmd->vdev_id, cmd->transaction_id, cmd->service_instance_id, 454 ch_tlv->mhz, cmd->ndp_channel_cfg, cmd->nan_csid, 455 cmd->peer_discovery_mac_addr.mac_addr31to0, 456 cmd->peer_discovery_mac_addr.mac_addr47to32); 457 458 wmi_debug("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d", 459 cmd->ndp_cfg_len, cmd->ndp_app_info_len, cmd->nan_pmk_len, 460 cmd->nan_passphrase_len, cmd->nan_servicename_len); 461 462 wmi_mtrace(WMI_NDP_INITIATOR_REQ_CMDID, cmd->vdev_id, 0); 463 status = wmi_unified_cmd_send(wmi_handle, buf, len, 464 WMI_NDP_INITIATOR_REQ_CMDID); 465 if (QDF_IS_STATUS_ERROR(status)) { 466 wmi_err("WMI_NDP_INITIATOR_REQ_CMDID failed, ret: %d", status); 467 wmi_buf_free(buf); 468 } 469 470 return status; 471 } 472 473 static QDF_STATUS nan_ndp_responder_req_tlv(wmi_unified_t wmi_handle, 474 struct nan_datapath_responder_req *req) 475 { 476 uint16_t len; 477 wmi_buf_t buf; 478 uint8_t *tlv_ptr; 479 QDF_STATUS status; 480 wmi_ndp_responder_req_fixed_param *cmd; 481 wmi_ndp_transport_ip_param *tcp_ip_param; 482 uint32_t passphrase_len, service_name_len; 483 uint32_t vdev_id = 0, ndp_cfg_len, ndp_app_info_len, pmk_len; 484 485 vdev_id = wlan_vdev_get_id(req->vdev); 486 wmi_debug("vdev_id: %d, transaction_id: %d, ndp_rsp %d, ndp_instance_id: %d, ndp_app_info_len: %d", 487 vdev_id, req->transaction_id, 488 req->ndp_rsp, 489 req->ndp_instance_id, 490 req->ndp_info.ndp_app_info_len); 491 492 /* 493 * WMI command expects 4 byte aligned len: 494 * round up ndp_cfg_len and ndp_app_info_len to 4 bytes 495 */ 496 ndp_cfg_len = qdf_roundup(req->ndp_config.ndp_cfg_len, 4); 497 ndp_app_info_len = qdf_roundup(req->ndp_info.ndp_app_info_len, 4); 498 pmk_len = qdf_roundup(req->pmk.pmk_len, 4); 499 passphrase_len = qdf_roundup(req->passphrase.passphrase_len, 4); 500 service_name_len = 501 qdf_roundup(req->service_name.service_name_len, 4); 502 503 /* allocated memory for fixed params as well as variable size data */ 504 len = sizeof(*cmd) + 5*WMI_TLV_HDR_SIZE + ndp_cfg_len + ndp_app_info_len 505 + pmk_len + passphrase_len + service_name_len; 506 507 if (req->is_ipv6_addr_present || req->is_port_present || 508 req->is_protocol_present) 509 len += sizeof(*tcp_ip_param); 510 511 buf = wmi_buf_alloc(wmi_handle, len); 512 if (!buf) { 513 return QDF_STATUS_E_NOMEM; 514 } 515 cmd = (wmi_ndp_responder_req_fixed_param *) wmi_buf_data(buf); 516 WMITLV_SET_HDR(&cmd->tlv_header, 517 WMITLV_TAG_STRUC_wmi_ndp_responder_req_fixed_param, 518 WMITLV_GET_STRUCT_TLVLEN( 519 wmi_ndp_responder_req_fixed_param)); 520 cmd->vdev_id = vdev_id; 521 cmd->transaction_id = req->transaction_id; 522 cmd->ndp_instance_id = req->ndp_instance_id; 523 cmd->rsp_code = req->ndp_rsp; 524 cmd->ndp_cfg_len = req->ndp_config.ndp_cfg_len; 525 cmd->ndp_app_info_len = req->ndp_info.ndp_app_info_len; 526 cmd->nan_pmk_len = req->pmk.pmk_len; 527 cmd->nan_csid = req->ncs_sk_type; 528 cmd->nan_passphrase_len = req->passphrase.passphrase_len; 529 cmd->nan_servicename_len = req->service_name.service_name_len; 530 531 tlv_ptr = (uint8_t *)&cmd[1]; 532 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_cfg_len); 533 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], 534 req->ndp_config.ndp_cfg, cmd->ndp_cfg_len); 535 536 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + ndp_cfg_len; 537 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, ndp_app_info_len); 538 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], 539 req->ndp_info.ndp_app_info, 540 req->ndp_info.ndp_app_info_len); 541 542 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + ndp_app_info_len; 543 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, pmk_len); 544 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], req->pmk.pmk, 545 cmd->nan_pmk_len); 546 547 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + pmk_len; 548 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, passphrase_len); 549 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], 550 req->passphrase.passphrase, 551 cmd->nan_passphrase_len); 552 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + passphrase_len; 553 554 WMITLV_SET_HDR(tlv_ptr, WMITLV_TAG_ARRAY_BYTE, service_name_len); 555 qdf_mem_copy(&tlv_ptr[WMI_TLV_HDR_SIZE], 556 req->service_name.service_name, 557 cmd->nan_servicename_len); 558 559 tlv_ptr = tlv_ptr + WMI_TLV_HDR_SIZE + service_name_len; 560 561 if (req->is_ipv6_addr_present || req->is_port_present || 562 req->is_protocol_present) { 563 tcp_ip_param = (wmi_ndp_transport_ip_param *)tlv_ptr; 564 WMITLV_SET_HDR(tcp_ip_param, 565 WMITLV_TAG_STRUC_wmi_ndp_transport_ip_param, 566 WMITLV_GET_STRUCT_TLVLEN( 567 wmi_ndp_transport_ip_param)); 568 tcp_ip_param->ipv6_addr_present = req->is_ipv6_addr_present; 569 qdf_mem_copy(tcp_ip_param->ipv6_intf_addr, 570 req->ipv6_addr, WMI_NDP_IPV6_INTF_ADDR_LEN); 571 572 tcp_ip_param->trans_port_present = req->is_port_present; 573 tcp_ip_param->transport_port = req->port; 574 575 tcp_ip_param->trans_proto_present = req->is_protocol_present; 576 tcp_ip_param->transport_protocol = req->protocol; 577 } 578 579 wmi_debug("ndp_config len: %d ndp_app_info len: %d pmk len: %d pass phrase len: %d service name len: %d", 580 req->ndp_config.ndp_cfg_len, req->ndp_info.ndp_app_info_len, 581 cmd->nan_pmk_len, cmd->nan_passphrase_len, 582 cmd->nan_servicename_len); 583 584 wmi_mtrace(WMI_NDP_RESPONDER_REQ_CMDID, cmd->vdev_id, 0); 585 status = wmi_unified_cmd_send(wmi_handle, buf, len, 586 WMI_NDP_RESPONDER_REQ_CMDID); 587 if (QDF_IS_STATUS_ERROR(status)) { 588 wmi_err("WMI_NDP_RESPONDER_REQ_CMDID failed, ret: %d", status); 589 wmi_buf_free(buf); 590 } 591 return status; 592 } 593 594 static QDF_STATUS nan_ndp_end_req_tlv(wmi_unified_t wmi_handle, 595 struct nan_datapath_end_req *req) 596 { 597 uint16_t len; 598 wmi_buf_t buf; 599 QDF_STATUS status; 600 uint32_t ndp_end_req_len, i; 601 wmi_ndp_end_req *ndp_end_req_lst; 602 wmi_ndp_end_req_fixed_param *cmd; 603 604 /* len of tlv following fixed param */ 605 ndp_end_req_len = sizeof(wmi_ndp_end_req) * req->num_ndp_instances; 606 /* above comes out to 4 byte aligned already, no need of padding */ 607 len = sizeof(*cmd) + ndp_end_req_len + WMI_TLV_HDR_SIZE; 608 buf = wmi_buf_alloc(wmi_handle, len); 609 if (!buf) { 610 return QDF_STATUS_E_NOMEM; 611 } 612 613 cmd = (wmi_ndp_end_req_fixed_param *) wmi_buf_data(buf); 614 WMITLV_SET_HDR(&cmd->tlv_header, 615 WMITLV_TAG_STRUC_wmi_ndp_end_req_fixed_param, 616 WMITLV_GET_STRUCT_TLVLEN(wmi_ndp_end_req_fixed_param)); 617 618 cmd->transaction_id = req->transaction_id; 619 620 /* set tlv pointer to end of fixed param */ 621 WMITLV_SET_HDR((uint8_t *)&cmd[1], WMITLV_TAG_ARRAY_STRUC, 622 ndp_end_req_len); 623 624 ndp_end_req_lst = (wmi_ndp_end_req *)((uint8_t *)&cmd[1] + 625 WMI_TLV_HDR_SIZE); 626 for (i = 0; i < req->num_ndp_instances; i++) { 627 WMITLV_SET_HDR(&ndp_end_req_lst[i], 628 WMITLV_TAG_ARRAY_FIXED_STRUC, 629 (sizeof(*ndp_end_req_lst) - WMI_TLV_HDR_SIZE)); 630 631 ndp_end_req_lst[i].ndp_instance_id = req->ndp_ids[i]; 632 } 633 634 wmi_mtrace(WMI_NDP_END_REQ_CMDID, NO_SESSION, 0); 635 status = wmi_unified_cmd_send(wmi_handle, buf, len, 636 WMI_NDP_END_REQ_CMDID); 637 if (QDF_IS_STATUS_ERROR(status)) { 638 wmi_err("WMI_NDP_END_REQ_CMDID failed, ret: %d", status); 639 wmi_buf_free(buf); 640 } 641 642 return status; 643 } 644 645 static QDF_STATUS 646 extract_ndp_host_event_tlv(wmi_unified_t wmi_handle, uint8_t *data, 647 struct nan_datapath_host_event *evt) 648 { 649 WMI_NDP_EVENTID_param_tlvs *event; 650 wmi_ndp_event_param *fixed_params; 651 652 event = (WMI_NDP_EVENTID_param_tlvs *)data; 653 fixed_params = event->fixed_param; 654 655 evt->vdev = 656 wlan_objmgr_get_vdev_by_id_from_psoc(wmi_handle->soc->wmi_psoc, 657 fixed_params->vdev_id, 658 WLAN_NAN_ID); 659 if (!evt->vdev) { 660 wmi_err("vdev is null"); 661 return QDF_STATUS_E_INVAL; 662 } 663 664 evt->ndp_termination_in_progress = 665 fixed_params->ndp_termination_in_progress ? true : false; 666 667 return QDF_STATUS_SUCCESS; 668 } 669 670 static QDF_STATUS extract_ndp_initiator_rsp_tlv(wmi_unified_t wmi_handle, 671 uint8_t *data, struct nan_datapath_initiator_rsp *rsp) 672 { 673 WMI_NDP_INITIATOR_RSP_EVENTID_param_tlvs *event; 674 wmi_ndp_initiator_rsp_event_fixed_param *fixed_params; 675 676 event = (WMI_NDP_INITIATOR_RSP_EVENTID_param_tlvs *)data; 677 fixed_params = event->fixed_param; 678 679 rsp->vdev = 680 wlan_objmgr_get_vdev_by_id_from_psoc(wmi_handle->soc->wmi_psoc, 681 fixed_params->vdev_id, 682 WLAN_NAN_ID); 683 if (!rsp->vdev) { 684 wmi_err("vdev is null"); 685 return QDF_STATUS_E_INVAL; 686 } 687 688 rsp->transaction_id = fixed_params->transaction_id; 689 rsp->ndp_instance_id = fixed_params->ndp_instance_id; 690 rsp->status = fixed_params->rsp_status; 691 rsp->reason = fixed_params->reason_code; 692 693 return QDF_STATUS_SUCCESS; 694 } 695 696 #define MAX_NAN_MSG_LEN 400 697 698 static QDF_STATUS extract_nan_msg_tlv(uint8_t *data, 699 struct nan_dump_msg *msg) 700 { 701 WMI_NAN_DMESG_EVENTID_param_tlvs *event; 702 wmi_nan_dmesg_event_fixed_param *fixed_params; 703 704 event = (WMI_NAN_DMESG_EVENTID_param_tlvs *)data; 705 fixed_params = (wmi_nan_dmesg_event_fixed_param *)event->fixed_param; 706 if (!fixed_params->msg_len || 707 fixed_params->msg_len > MAX_NAN_MSG_LEN || 708 fixed_params->msg_len > event->num_msg) 709 return QDF_STATUS_E_FAILURE; 710 711 msg->data_len = fixed_params->msg_len; 712 msg->msg = event->msg; 713 714 msg->msg[fixed_params->msg_len - 1] = (uint8_t)'\0'; 715 716 return QDF_STATUS_SUCCESS; 717 } 718 719 static QDF_STATUS extract_ndp_ind_tlv(wmi_unified_t wmi_handle, 720 uint8_t *data, struct nan_datapath_indication_event *rsp) 721 { 722 WMI_NDP_INDICATION_EVENTID_param_tlvs *event; 723 wmi_ndp_indication_event_fixed_param *fixed_params; 724 size_t total_array_len; 725 726 event = (WMI_NDP_INDICATION_EVENTID_param_tlvs *)data; 727 fixed_params = 728 (wmi_ndp_indication_event_fixed_param *)event->fixed_param; 729 730 if (fixed_params->ndp_cfg_len > event->num_ndp_cfg) { 731 wmi_err("FW message ndp cfg length %d larger than TLV hdr %d", 732 fixed_params->ndp_cfg_len, event->num_ndp_cfg); 733 return QDF_STATUS_E_INVAL; 734 } 735 736 if (fixed_params->ndp_app_info_len > event->num_ndp_app_info) { 737 wmi_err("FW message ndp app info length %d more than TLV hdr %d", 738 fixed_params->ndp_app_info_len, 739 event->num_ndp_app_info); 740 return QDF_STATUS_E_INVAL; 741 } 742 743 if (fixed_params->nan_scid_len > event->num_ndp_scid) { 744 wmi_err("FW msg ndp scid info len %d more than TLV hdr %d", 745 fixed_params->nan_scid_len, 746 event->num_ndp_scid); 747 return QDF_STATUS_E_INVAL; 748 } 749 750 if (fixed_params->service_id_len > event->num_service_id) { 751 wmi_err("FW msg service id len %d more than TLV hdr %d", 752 fixed_params->service_id_len, 753 event->num_service_id); 754 return QDF_STATUS_E_INVAL; 755 } 756 757 if (fixed_params->ndp_cfg_len > 758 (WMI_SVC_MSG_MAX_SIZE - sizeof(*fixed_params))) { 759 wmi_err("excess wmi buffer: ndp_cfg_len %d", 760 fixed_params->ndp_cfg_len); 761 return QDF_STATUS_E_INVAL; 762 } 763 764 total_array_len = fixed_params->ndp_cfg_len + 765 sizeof(*fixed_params); 766 767 if (fixed_params->ndp_app_info_len > 768 (WMI_SVC_MSG_MAX_SIZE - total_array_len)) { 769 wmi_err("excess wmi buffer: ndp_cfg_len %d", 770 fixed_params->ndp_app_info_len); 771 return QDF_STATUS_E_INVAL; 772 } 773 total_array_len += fixed_params->ndp_app_info_len; 774 775 if (fixed_params->nan_scid_len > 776 (WMI_SVC_MSG_MAX_SIZE - total_array_len)) { 777 wmi_err("excess wmi buffer: ndp_cfg_len %d", 778 fixed_params->nan_scid_len); 779 return QDF_STATUS_E_INVAL; 780 } 781 782 total_array_len += fixed_params->nan_scid_len; 783 784 if (fixed_params->service_id_len > 785 (WMI_SVC_MSG_MAX_SIZE - total_array_len)) { 786 wmi_err("excess wmi buffer: service_cfg_len %d", 787 fixed_params->service_id_len); 788 return QDF_STATUS_E_INVAL; 789 } 790 791 rsp->vdev = 792 wlan_objmgr_get_vdev_by_id_from_psoc(wmi_handle->soc->wmi_psoc, 793 fixed_params->vdev_id, 794 WLAN_NAN_ID); 795 if (!rsp->vdev) { 796 wmi_err("vdev is null"); 797 return QDF_STATUS_E_INVAL; 798 } 799 rsp->service_instance_id = fixed_params->service_instance_id; 800 rsp->ndp_instance_id = fixed_params->ndp_instance_id; 801 rsp->role = fixed_params->self_ndp_role; 802 rsp->policy = fixed_params->accept_policy; 803 804 WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr, 805 rsp->peer_mac_addr.bytes); 806 WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_discovery_mac_addr, 807 rsp->peer_discovery_mac_addr.bytes); 808 809 wmi_debug("WMI_NDP_INDICATION_EVENTID(0x%X) received. vdev %d service_instance %d, ndp_instance %d, role %d, policy %d csid: %d, scid_len: %d, peer_addr: "QDF_MAC_ADDR_FMT", peer_disc_addr: "QDF_MAC_ADDR_FMT" ndp_cfg - %d bytes ndp_app_info - %d bytes", 810 WMI_NDP_INDICATION_EVENTID, fixed_params->vdev_id, 811 fixed_params->service_instance_id, 812 fixed_params->ndp_instance_id, fixed_params->self_ndp_role, 813 fixed_params->accept_policy, fixed_params->nan_csid, 814 fixed_params->nan_scid_len, 815 QDF_MAC_ADDR_REF(rsp->peer_mac_addr.bytes), 816 QDF_MAC_ADDR_REF(rsp->peer_discovery_mac_addr.bytes), 817 fixed_params->ndp_cfg_len, 818 fixed_params->ndp_app_info_len); 819 820 rsp->ncs_sk_type = fixed_params->nan_csid; 821 if (event->ndp_cfg) { 822 rsp->ndp_config.ndp_cfg_len = fixed_params->ndp_cfg_len; 823 if (rsp->ndp_config.ndp_cfg_len > NDP_QOS_INFO_LEN) 824 rsp->ndp_config.ndp_cfg_len = NDP_QOS_INFO_LEN; 825 qdf_mem_copy(rsp->ndp_config.ndp_cfg, event->ndp_cfg, 826 rsp->ndp_config.ndp_cfg_len); 827 } 828 829 if (event->ndp_app_info) { 830 rsp->ndp_info.ndp_app_info_len = fixed_params->ndp_app_info_len; 831 if (rsp->ndp_info.ndp_app_info_len > NDP_APP_INFO_LEN) 832 rsp->ndp_info.ndp_app_info_len = NDP_APP_INFO_LEN; 833 qdf_mem_copy(rsp->ndp_info.ndp_app_info, event->ndp_app_info, 834 rsp->ndp_info.ndp_app_info_len); 835 } 836 837 if (event->ndp_scid) { 838 rsp->scid.scid_len = fixed_params->nan_scid_len; 839 if (rsp->scid.scid_len > NDP_SCID_BUF_LEN) 840 rsp->scid.scid_len = NDP_SCID_BUF_LEN; 841 qdf_mem_copy(rsp->scid.scid, event->ndp_scid, 842 rsp->scid.scid_len); 843 } 844 845 if (event->ndp_transport_ip_param && 846 event->num_ndp_transport_ip_param) { 847 if (event->ndp_transport_ip_param->ipv6_addr_present) { 848 rsp->is_ipv6_addr_present = true; 849 qdf_mem_copy(rsp->ipv6_addr, 850 event->ndp_transport_ip_param->ipv6_intf_addr, 851 WMI_NDP_IPV6_INTF_ADDR_LEN); 852 } 853 } 854 wmi_debug("IPv6 addr present: %d, addr: %pI6", 855 rsp->is_ipv6_addr_present, rsp->ipv6_addr); 856 857 rsp->is_service_id_present = false; 858 if (fixed_params->service_id_len && event->service_id) { 859 if (fixed_params->service_id_len < NDP_SERVICE_ID_LEN) { 860 wmi_err("Invalid service id length %d", 861 event->num_service_id); 862 return QDF_STATUS_E_INVAL; 863 } 864 rsp->is_service_id_present = true; 865 qdf_mem_copy(rsp->service_id, event->service_id, 866 NDP_SERVICE_ID_LEN); 867 } 868 869 return QDF_STATUS_SUCCESS; 870 } 871 872 static QDF_STATUS extract_ndp_confirm_tlv(wmi_unified_t wmi_handle, 873 uint8_t *data, struct nan_datapath_confirm_event *rsp) 874 { 875 uint8_t i; 876 WMI_HOST_WLAN_PHY_MODE ch_mode; 877 WMI_NDP_CONFIRM_EVENTID_param_tlvs *event; 878 wmi_ndp_confirm_event_fixed_param *fixed_params; 879 size_t total_array_len; 880 bool ndi_dbs = wmi_service_enabled(wmi_handle, 881 wmi_service_ndi_dbs_support); 882 883 event = (WMI_NDP_CONFIRM_EVENTID_param_tlvs *) data; 884 fixed_params = (wmi_ndp_confirm_event_fixed_param *)event->fixed_param; 885 wmi_debug("WMI_NDP_CONFIRM_EVENTID(0x%X) received. vdev %d, ndp_instance %d, rsp_code %d, reason_code: %d, num_active_ndps_on_peer: %d num_ch: %d", 886 WMI_NDP_CONFIRM_EVENTID, fixed_params->vdev_id, 887 fixed_params->ndp_instance_id, fixed_params->rsp_code, 888 fixed_params->reason_code, 889 fixed_params->num_active_ndps_on_peer, 890 fixed_params->num_ndp_channels); 891 892 if (fixed_params->ndp_cfg_len > event->num_ndp_cfg) { 893 wmi_err("FW message ndp cfg length %d larger than TLV hdr %d", 894 fixed_params->ndp_cfg_len, event->num_ndp_cfg); 895 return QDF_STATUS_E_INVAL; 896 } 897 898 if (fixed_params->ndp_app_info_len > event->num_ndp_app_info) { 899 wmi_err("FW message ndp app info length %d more than TLV hdr %d", 900 fixed_params->ndp_app_info_len, 901 event->num_ndp_app_info); 902 return QDF_STATUS_E_INVAL; 903 } 904 905 wmi_debug("ndp_cfg - %d bytes, ndp_app_info - %d bytes", 906 fixed_params->ndp_cfg_len, fixed_params->ndp_app_info_len); 907 908 if (fixed_params->ndp_cfg_len > 909 (WMI_SVC_MSG_MAX_SIZE - sizeof(*fixed_params))) { 910 wmi_err("excess wmi buffer: ndp_cfg_len %d", 911 fixed_params->ndp_cfg_len); 912 return QDF_STATUS_E_INVAL; 913 } 914 915 total_array_len = fixed_params->ndp_cfg_len + 916 sizeof(*fixed_params); 917 918 if (fixed_params->ndp_app_info_len > 919 (WMI_SVC_MSG_MAX_SIZE - total_array_len)) { 920 wmi_err("excess wmi buffer: ndp_cfg_len %d", 921 fixed_params->ndp_app_info_len); 922 return QDF_STATUS_E_INVAL; 923 } 924 925 if (fixed_params->num_ndp_channels > event->num_ndp_channel_list || 926 fixed_params->num_ndp_channels > event->num_nss_list) { 927 wmi_err("NDP Ch count %d greater than NDP Ch TLV len(%d) or NSS TLV len(%d)", 928 fixed_params->num_ndp_channels, 929 event->num_ndp_channel_list, 930 event->num_nss_list); 931 return QDF_STATUS_E_INVAL; 932 } 933 934 if (ndi_dbs && 935 fixed_params->num_ndp_channels > event->num_ndp_channel_info) { 936 wmi_err("NDP Ch count %d greater than NDP Ch info(%d)", 937 fixed_params->num_ndp_channels, 938 event->num_ndp_channel_info); 939 return QDF_STATUS_E_INVAL; 940 } 941 942 rsp->vdev = 943 wlan_objmgr_get_vdev_by_id_from_psoc(wmi_handle->soc->wmi_psoc, 944 fixed_params->vdev_id, 945 WLAN_NAN_ID); 946 if (!rsp->vdev) { 947 wmi_err("vdev is null"); 948 return QDF_STATUS_E_INVAL; 949 } 950 rsp->ndp_instance_id = fixed_params->ndp_instance_id; 951 rsp->rsp_code = fixed_params->rsp_code; 952 rsp->reason_code = fixed_params->reason_code; 953 rsp->num_active_ndps_on_peer = fixed_params->num_active_ndps_on_peer; 954 rsp->num_channels = fixed_params->num_ndp_channels; 955 WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr, 956 rsp->peer_ndi_mac_addr.bytes); 957 rsp->ndp_info.ndp_app_info_len = fixed_params->ndp_app_info_len; 958 959 if (rsp->ndp_info.ndp_app_info_len > NDP_APP_INFO_LEN) 960 rsp->ndp_info.ndp_app_info_len = NDP_APP_INFO_LEN; 961 962 qdf_mem_copy(rsp->ndp_info.ndp_app_info, event->ndp_app_info, 963 rsp->ndp_info.ndp_app_info_len); 964 965 if (rsp->num_channels > NAN_CH_INFO_MAX_CHANNELS) { 966 wmi_err("too many channels"); 967 rsp->num_channels = NAN_CH_INFO_MAX_CHANNELS; 968 } 969 970 for (i = 0; i < rsp->num_channels; i++) { 971 rsp->ch[i].freq = event->ndp_channel_list[i].mhz; 972 rsp->ch[i].nss = event->nss_list[i]; 973 ch_mode = WMI_GET_CHANNEL_MODE(&event->ndp_channel_list[i]); 974 rsp->ch[i].ch_width = wmi_get_ch_width_from_phy_mode(wmi_handle, 975 ch_mode); 976 if (ndi_dbs) { 977 rsp->ch[i].mac_id = event->ndp_channel_info[i].mac_id; 978 wmi_debug("Freq: %d, ch_mode: %d, nss: %d mac_id: %d", 979 rsp->ch[i].freq, rsp->ch[i].ch_width, 980 rsp->ch[i].nss, rsp->ch[i].mac_id); 981 } else { 982 wmi_debug("Freq: %d, ch_mode: %d, nss: %d", 983 rsp->ch[i].freq, rsp->ch[i].ch_width, 984 rsp->ch[i].nss); 985 } 986 } 987 988 if (event->ndp_transport_ip_param && 989 event->num_ndp_transport_ip_param) { 990 if (event->ndp_transport_ip_param->ipv6_addr_present) { 991 rsp->is_ipv6_addr_present = true; 992 qdf_mem_copy(rsp->ipv6_addr, 993 event->ndp_transport_ip_param->ipv6_intf_addr, 994 WMI_NDP_IPV6_INTF_ADDR_LEN); 995 } 996 997 if (event->ndp_transport_ip_param->trans_port_present) { 998 rsp->is_port_present = true; 999 rsp->port = 1000 event->ndp_transport_ip_param->transport_port; 1001 } 1002 1003 if (event->ndp_transport_ip_param->trans_proto_present) { 1004 rsp->is_protocol_present = true; 1005 rsp->protocol = 1006 event->ndp_transport_ip_param->transport_protocol; 1007 } 1008 } 1009 wmi_debug("IPv6 addr present: %d, addr: %pI6 port: %d present: %d protocol: %d present: %d", 1010 rsp->is_ipv6_addr_present, rsp->ipv6_addr, rsp->port, 1011 rsp->is_port_present, rsp->protocol, rsp->is_protocol_present); 1012 1013 return QDF_STATUS_SUCCESS; 1014 } 1015 1016 static QDF_STATUS extract_ndp_responder_rsp_tlv(wmi_unified_t wmi_handle, 1017 uint8_t *data, struct nan_datapath_responder_rsp *rsp) 1018 { 1019 WMI_NDP_RESPONDER_RSP_EVENTID_param_tlvs *event; 1020 wmi_ndp_responder_rsp_event_fixed_param *fixed_params; 1021 1022 event = (WMI_NDP_RESPONDER_RSP_EVENTID_param_tlvs *)data; 1023 fixed_params = event->fixed_param; 1024 1025 rsp->vdev = 1026 wlan_objmgr_get_vdev_by_id_from_psoc(wmi_handle->soc->wmi_psoc, 1027 fixed_params->vdev_id, 1028 WLAN_NAN_ID); 1029 if (!rsp->vdev) { 1030 wmi_err("vdev is null"); 1031 return QDF_STATUS_E_INVAL; 1032 } 1033 rsp->transaction_id = fixed_params->transaction_id; 1034 rsp->reason = fixed_params->reason_code; 1035 rsp->status = fixed_params->rsp_status; 1036 rsp->create_peer = fixed_params->create_peer; 1037 WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_ndi_mac_addr, 1038 rsp->peer_mac_addr.bytes); 1039 wmi_debug("WMI_NDP_RESPONDER_RSP_EVENTID(0x%X) received. vdev_id: %d, peer_mac_addr: "QDF_MAC_ADDR_FMT",transaction_id: %d, status_code %d, reason_code: %d, create_peer: %d", 1040 WMI_NDP_RESPONDER_RSP_EVENTID, fixed_params->vdev_id, 1041 QDF_MAC_ADDR_REF(rsp->peer_mac_addr.bytes), 1042 rsp->transaction_id, 1043 rsp->status, rsp->reason, rsp->create_peer); 1044 1045 return QDF_STATUS_SUCCESS; 1046 } 1047 1048 static QDF_STATUS extract_ndp_end_rsp_tlv(wmi_unified_t wmi_handle, 1049 uint8_t *data, struct nan_datapath_end_rsp_event *rsp) 1050 { 1051 WMI_NDP_END_RSP_EVENTID_param_tlvs *event; 1052 wmi_ndp_end_rsp_event_fixed_param *fixed_params = NULL; 1053 1054 event = (WMI_NDP_END_RSP_EVENTID_param_tlvs *) data; 1055 fixed_params = (wmi_ndp_end_rsp_event_fixed_param *)event->fixed_param; 1056 wmi_debug("WMI_NDP_END_RSP_EVENTID(0x%X) received. transaction_id: %d, rsp_status: %d, reason_code: %d", 1057 WMI_NDP_END_RSP_EVENTID, fixed_params->transaction_id, 1058 fixed_params->rsp_status, fixed_params->reason_code); 1059 1060 rsp->vdev = wlan_objmgr_get_vdev_by_opmode_from_psoc( 1061 wmi_handle->soc->wmi_psoc, QDF_NDI_MODE, WLAN_NAN_ID); 1062 if (!rsp->vdev) { 1063 wmi_err("vdev is null"); 1064 return QDF_STATUS_E_INVAL; 1065 } 1066 rsp->transaction_id = fixed_params->transaction_id; 1067 rsp->reason = fixed_params->reason_code; 1068 rsp->status = fixed_params->rsp_status; 1069 1070 return QDF_STATUS_SUCCESS; 1071 } 1072 1073 static QDF_STATUS extract_ndp_end_ind_tlv(wmi_unified_t wmi_handle, 1074 uint8_t *data, struct nan_datapath_end_indication_event **rsp) 1075 { 1076 uint32_t i, buf_size; 1077 wmi_ndp_end_indication *ind; 1078 struct qdf_mac_addr peer_addr; 1079 WMI_NDP_END_INDICATION_EVENTID_param_tlvs *event; 1080 1081 event = (WMI_NDP_END_INDICATION_EVENTID_param_tlvs *) data; 1082 ind = event->ndp_end_indication_list; 1083 1084 if (event->num_ndp_end_indication_list == 0) { 1085 wmi_err("Error: Event ignored, 0 ndp instances"); 1086 return QDF_STATUS_E_INVAL; 1087 } 1088 1089 wmi_debug("number of ndp instances = %d", 1090 event->num_ndp_end_indication_list); 1091 1092 if (event->num_ndp_end_indication_list > ((UINT_MAX - sizeof(**rsp))/ 1093 sizeof((*rsp)->ndp_map[0]))) { 1094 wmi_err("num_ndp_end_ind_list %d too large", 1095 event->num_ndp_end_indication_list); 1096 return QDF_STATUS_E_INVAL; 1097 } 1098 1099 buf_size = sizeof(**rsp) + event->num_ndp_end_indication_list * 1100 sizeof((*rsp)->ndp_map[0]); 1101 *rsp = qdf_mem_malloc(buf_size); 1102 if (!(*rsp)) 1103 return QDF_STATUS_E_NOMEM; 1104 1105 (*rsp)->num_ndp_ids = event->num_ndp_end_indication_list; 1106 for (i = 0; i < (*rsp)->num_ndp_ids; i++) { 1107 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ind[i].peer_ndi_mac_addr, 1108 peer_addr.bytes); 1109 wmi_debug("ind[%d]: type %d, reason_code %d, instance_id %d num_active %d ", 1110 i, ind[i].type, ind[i].reason_code, 1111 ind[i].ndp_instance_id, 1112 ind[i].num_active_ndps_on_peer); 1113 /* Add each instance entry to the list */ 1114 (*rsp)->ndp_map[i].ndp_instance_id = ind[i].ndp_instance_id; 1115 (*rsp)->ndp_map[i].vdev_id = ind[i].vdev_id; 1116 WMI_MAC_ADDR_TO_CHAR_ARRAY(&ind[i].peer_ndi_mac_addr, 1117 (*rsp)->ndp_map[i].peer_ndi_mac_addr.bytes); 1118 (*rsp)->ndp_map[i].num_active_ndp_sessions = 1119 ind[i].num_active_ndps_on_peer; 1120 (*rsp)->ndp_map[i].type = ind[i].type; 1121 (*rsp)->ndp_map[i].reason_code = ind[i].reason_code; 1122 } 1123 1124 return QDF_STATUS_SUCCESS; 1125 } 1126 1127 static QDF_STATUS extract_ndp_sch_update_tlv(wmi_unified_t wmi_handle, 1128 uint8_t *data, struct nan_datapath_sch_update_event *ind) 1129 { 1130 uint8_t i; 1131 WMI_HOST_WLAN_PHY_MODE ch_mode; 1132 WMI_NDL_SCHEDULE_UPDATE_EVENTID_param_tlvs *event; 1133 wmi_ndl_schedule_update_fixed_param *fixed_params; 1134 bool ndi_dbs = wmi_service_enabled(wmi_handle, 1135 wmi_service_ndi_dbs_support); 1136 1137 event = (WMI_NDL_SCHEDULE_UPDATE_EVENTID_param_tlvs *)data; 1138 fixed_params = event->fixed_param; 1139 1140 wmi_debug("flags: %d, num_ch: %d, num_ndp_instances: %d", 1141 fixed_params->flags, fixed_params->num_channels, 1142 fixed_params->num_ndp_instances); 1143 1144 if (fixed_params->num_channels > event->num_ndl_channel_list || 1145 fixed_params->num_channels > event->num_nss_list) { 1146 wmi_err("Channel count %d greater than NDP Ch list TLV len(%d) or NSS list TLV len(%d)", 1147 fixed_params->num_channels, 1148 event->num_ndl_channel_list, 1149 event->num_nss_list); 1150 return QDF_STATUS_E_INVAL; 1151 } 1152 1153 if (ndi_dbs && 1154 fixed_params->num_channels > event->num_ndp_channel_info) { 1155 wmi_err("Channel count %d greater than NDP Ch info(%d)", 1156 fixed_params->num_channels, 1157 event->num_ndp_channel_info); 1158 return QDF_STATUS_E_INVAL; 1159 } 1160 1161 if (fixed_params->num_ndp_instances > event->num_ndp_instance_list) { 1162 wmi_err("NDP Instance count %d greater than NDP Instancei TLV len %d", 1163 fixed_params->num_ndp_instances, 1164 event->num_ndp_instance_list); 1165 return QDF_STATUS_E_INVAL; 1166 } 1167 1168 ind->vdev = 1169 wlan_objmgr_get_vdev_by_id_from_psoc(wmi_handle->soc->wmi_psoc, 1170 fixed_params->vdev_id, 1171 WLAN_NAN_ID); 1172 if (!ind->vdev) { 1173 wmi_err("vdev is null"); 1174 return QDF_STATUS_E_INVAL; 1175 } 1176 1177 ind->flags = fixed_params->flags; 1178 ind->num_channels = fixed_params->num_channels; 1179 ind->num_ndp_instances = fixed_params->num_ndp_instances; 1180 WMI_MAC_ADDR_TO_CHAR_ARRAY(&fixed_params->peer_macaddr, 1181 ind->peer_addr.bytes); 1182 1183 if (ind->num_ndp_instances > NDP_NUM_INSTANCE_ID) { 1184 wmi_err("uint32 overflow"); 1185 wlan_objmgr_vdev_release_ref(ind->vdev, WLAN_NAN_ID); 1186 return QDF_STATUS_E_INVAL; 1187 } 1188 1189 qdf_mem_copy(ind->ndp_instances, event->ndp_instance_list, 1190 sizeof(uint32_t) * ind->num_ndp_instances); 1191 1192 if (ind->num_channels > NAN_CH_INFO_MAX_CHANNELS) { 1193 wmi_err("too many channels"); 1194 ind->num_channels = NAN_CH_INFO_MAX_CHANNELS; 1195 } 1196 1197 for (i = 0; i < ind->num_channels; i++) { 1198 ind->ch[i].freq = event->ndl_channel_list[i].mhz; 1199 ind->ch[i].nss = event->nss_list[i]; 1200 ch_mode = WMI_GET_CHANNEL_MODE(&event->ndl_channel_list[i]); 1201 ind->ch[i].ch_width = wmi_get_ch_width_from_phy_mode(wmi_handle, 1202 ch_mode); 1203 if (ndi_dbs) { 1204 ind->ch[i].mac_id = event->ndp_channel_info[i].mac_id; 1205 wmi_debug("Freq: %d, ch_mode: %d, nss: %d mac_id: %d", 1206 ind->ch[i].freq, ind->ch[i].ch_width, 1207 ind->ch[i].nss, ind->ch[i].mac_id); 1208 } else { 1209 wmi_debug("Freq: %d, ch_mode: %d, nss: %d", 1210 ind->ch[i].freq, ind->ch[i].ch_width, 1211 ind->ch[i].nss); 1212 } 1213 } 1214 1215 for (i = 0; i < fixed_params->num_ndp_instances; i++) 1216 wmi_debug("instance_id[%d]: %d", 1217 i, event->ndp_instance_list[i]); 1218 1219 return QDF_STATUS_SUCCESS; 1220 } 1221 1222 void wmi_nan_attach_tlv(wmi_unified_t wmi_handle) 1223 { 1224 struct wmi_ops *ops = wmi_handle->ops; 1225 1226 ops->send_nan_req_cmd = send_nan_req_cmd_tlv; 1227 ops->send_nan_disable_req_cmd = send_nan_disable_req_cmd_tlv; 1228 ops->extract_nan_event_rsp = extract_nan_event_rsp_tlv; 1229 ops->send_terminate_all_ndps_req_cmd = send_terminate_all_ndps_cmd_tlv; 1230 ops->send_ndp_initiator_req_cmd = nan_ndp_initiator_req_tlv; 1231 ops->send_ndp_responder_req_cmd = nan_ndp_responder_req_tlv; 1232 ops->send_ndp_end_req_cmd = nan_ndp_end_req_tlv; 1233 ops->extract_ndp_initiator_rsp = extract_ndp_initiator_rsp_tlv; 1234 ops->extract_ndp_ind = extract_ndp_ind_tlv; 1235 ops->extract_nan_msg = extract_nan_msg_tlv, 1236 ops->extract_ndp_confirm = extract_ndp_confirm_tlv; 1237 ops->extract_ndp_responder_rsp = extract_ndp_responder_rsp_tlv; 1238 ops->extract_ndp_end_rsp = extract_ndp_end_rsp_tlv; 1239 ops->extract_ndp_end_ind = extract_ndp_end_ind_tlv; 1240 ops->extract_ndp_sch_update = extract_ndp_sch_update_tlv; 1241 ops->extract_ndp_host_event = extract_ndp_host_event_tlv; 1242 } 1243