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