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