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