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