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