1 /* 2 * Copyright (c) 2013-2018 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <osdep.h> 20 #include <wmi.h> 21 #include <wmi_unified_priv.h> 22 #include <wmi_unified_p2p_api.h> 23 24 /** 25 * send_set_p2pgo_noa_req_cmd_tlv() - send p2p go noa request to fw 26 * @wmi_handle: wmi handle 27 * @noa: p2p power save parameters 28 * 29 * Return: CDF status 30 */ 31 static QDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle, 32 struct p2p_ps_params *noa) 33 { 34 wmi_p2p_set_noa_cmd_fixed_param *cmd; 35 wmi_p2p_noa_descriptor *noa_discriptor; 36 wmi_buf_t buf; 37 uint8_t *buf_ptr; 38 uint16_t len; 39 QDF_STATUS status; 40 uint32_t duration; 41 42 WMI_LOGD("%s: Enter", __func__); 43 len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + sizeof(*noa_discriptor); 44 buf = wmi_buf_alloc(wmi_handle, len); 45 if (!buf) { 46 status = QDF_STATUS_E_FAILURE; 47 goto end; 48 } 49 50 buf_ptr = (uint8_t *)wmi_buf_data(buf); 51 cmd = (wmi_p2p_set_noa_cmd_fixed_param *)buf_ptr; 52 WMITLV_SET_HDR(&cmd->tlv_header, 53 WMITLV_TAG_STRUC_wmi_p2p_set_noa_cmd_fixed_param, 54 WMITLV_GET_STRUCT_TLVLEN 55 (wmi_p2p_set_noa_cmd_fixed_param)); 56 duration = (noa->count == 1) ? noa->single_noa_duration : noa->duration; 57 cmd->vdev_id = noa->session_id; 58 cmd->enable = (duration) ? true : false; 59 cmd->num_noa = 1; 60 61 WMITLV_SET_HDR((buf_ptr + sizeof(wmi_p2p_set_noa_cmd_fixed_param)), 62 WMITLV_TAG_ARRAY_STRUC, sizeof(wmi_p2p_noa_descriptor)); 63 noa_discriptor = (wmi_p2p_noa_descriptor *)(buf_ptr + 64 sizeof 65 (wmi_p2p_set_noa_cmd_fixed_param) 66 + WMI_TLV_HDR_SIZE); 67 WMITLV_SET_HDR(&noa_discriptor->tlv_header, 68 WMITLV_TAG_STRUC_wmi_p2p_noa_descriptor, 69 WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_noa_descriptor)); 70 noa_discriptor->type_count = noa->count; 71 noa_discriptor->duration = duration; 72 noa_discriptor->interval = noa->interval; 73 noa_discriptor->start_time = 0; 74 75 WMI_LOGI("SET P2P GO NOA:vdev_id:%d count:%d duration:%d interval:%d", 76 cmd->vdev_id, noa->count, noa_discriptor->duration, 77 noa->interval); 78 wmi_mtrace(WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID, cmd->vdev_id, 0); 79 status = wmi_unified_cmd_send(wmi_handle, buf, len, 80 WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID); 81 if (QDF_IS_STATUS_ERROR(status)) { 82 WMI_LOGE("Failed to send WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID"); 83 wmi_buf_free(buf); 84 } 85 86 end: 87 WMI_LOGD("%s: Exit", __func__); 88 return status; 89 } 90 91 /** 92 * send_set_p2pgo_oppps_req_cmd_tlv() - send p2p go opp power save request to fw 93 * @wmi_handle: wmi handle 94 * @noa: p2p opp power save parameters 95 * 96 * Return: CDF status 97 */ 98 static QDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle, 99 struct p2p_ps_params *oppps) 100 { 101 wmi_p2p_set_oppps_cmd_fixed_param *cmd; 102 wmi_buf_t buf; 103 QDF_STATUS status; 104 105 WMI_LOGD("%s: Enter", __func__); 106 buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd)); 107 if (!buf) { 108 status = QDF_STATUS_E_FAILURE; 109 goto end; 110 } 111 112 cmd = (wmi_p2p_set_oppps_cmd_fixed_param *) wmi_buf_data(buf); 113 WMITLV_SET_HDR(&cmd->tlv_header, 114 WMITLV_TAG_STRUC_wmi_p2p_set_oppps_cmd_fixed_param, 115 WMITLV_GET_STRUCT_TLVLEN( 116 wmi_p2p_set_oppps_cmd_fixed_param)); 117 cmd->vdev_id = oppps->session_id; 118 if (oppps->ctwindow) 119 WMI_UNIFIED_OPPPS_ATTR_ENABLED_SET(cmd); 120 121 WMI_UNIFIED_OPPPS_ATTR_CTWIN_SET(cmd, oppps->ctwindow); 122 WMI_LOGI("SET P2P GO OPPPS:vdev_id:%d ctwindow:%d", 123 cmd->vdev_id, oppps->ctwindow); 124 wmi_mtrace(WMI_P2P_SET_OPPPS_PARAM_CMDID, cmd->vdev_id, 0); 125 status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd), 126 WMI_P2P_SET_OPPPS_PARAM_CMDID); 127 if (QDF_IS_STATUS_ERROR(status)) { 128 WMI_LOGE("Failed to send WMI_P2P_SET_OPPPS_PARAM_CMDID"); 129 wmi_buf_free(buf); 130 } 131 132 end: 133 WMI_LOGD("%s: Exit", __func__); 134 return status; 135 } 136 137 /** 138 * extract_p2p_noa_ev_param_tlv() - extract p2p noa information from event 139 * @wmi_handle: wmi handle 140 * @param evt_buf: pointer to event buffer 141 * @param param: Pointer to hold p2p noa info 142 * 143 * Return: QDF_STATUS_SUCCESS for success or error code 144 */ 145 static QDF_STATUS extract_p2p_noa_ev_param_tlv( 146 wmi_unified_t wmi_handle, void *evt_buf, 147 struct p2p_noa_info *param) 148 { 149 WMI_P2P_NOA_EVENTID_param_tlvs *param_tlvs; 150 wmi_p2p_noa_event_fixed_param *fixed_param; 151 uint8_t i; 152 wmi_p2p_noa_info *wmi_noa_info; 153 uint8_t *buf_ptr; 154 uint32_t descriptors; 155 156 param_tlvs = (WMI_P2P_NOA_EVENTID_param_tlvs *)evt_buf; 157 if (!param_tlvs) { 158 WMI_LOGE("%s: Invalid P2P NoA event buffer", __func__); 159 return QDF_STATUS_E_INVAL; 160 } 161 162 if (!param) { 163 WMI_LOGE("noa information param is null"); 164 return QDF_STATUS_E_INVAL; 165 } 166 167 fixed_param = param_tlvs->fixed_param; 168 buf_ptr = (uint8_t *) fixed_param; 169 buf_ptr += sizeof(wmi_p2p_noa_event_fixed_param); 170 wmi_noa_info = (wmi_p2p_noa_info *) (buf_ptr); 171 172 if (!WMI_UNIFIED_NOA_ATTR_IS_MODIFIED(wmi_noa_info)) { 173 WMI_LOGE("%s: noa attr is not modified", __func__); 174 return QDF_STATUS_E_INVAL; 175 } 176 177 param->vdev_id = fixed_param->vdev_id; 178 param->index = 179 (uint8_t)WMI_UNIFIED_NOA_ATTR_INDEX_GET(wmi_noa_info); 180 param->opps_ps = 181 (uint8_t)WMI_UNIFIED_NOA_ATTR_OPP_PS_GET(wmi_noa_info); 182 param->ct_window = 183 (uint8_t)WMI_UNIFIED_NOA_ATTR_CTWIN_GET(wmi_noa_info); 184 descriptors = WMI_UNIFIED_NOA_ATTR_NUM_DESC_GET(wmi_noa_info); 185 param->num_desc = (uint8_t)descriptors; 186 if (param->num_desc > WMI_P2P_MAX_NOA_DESCRIPTORS) { 187 WMI_LOGE("%s: invalid num desc:%d", __func__, 188 param->num_desc); 189 return QDF_STATUS_E_INVAL; 190 } 191 192 WMI_LOGD("%s:index %u, opps_ps %u, ct_window %u, num_descriptors = %u", 193 __func__, 194 param->index, param->opps_ps, param->ct_window, 195 param->num_desc); 196 for (i = 0; i < param->num_desc; i++) { 197 param->noa_desc[i].type_count = 198 (uint8_t)wmi_noa_info->noa_descriptors[i]. 199 type_count; 200 param->noa_desc[i].duration = 201 wmi_noa_info->noa_descriptors[i].duration; 202 param->noa_desc[i].interval = 203 wmi_noa_info->noa_descriptors[i].interval; 204 param->noa_desc[i].start_time = 205 wmi_noa_info->noa_descriptors[i].start_time; 206 WMI_LOGD("%s:NoA descriptor[%d] type_count %u, duration %u, interval %u, start_time = %u", 207 __func__, i, param->noa_desc[i].type_count, 208 param->noa_desc[i].duration, 209 param->noa_desc[i].interval, 210 param->noa_desc[i].start_time); 211 } 212 213 return QDF_STATUS_SUCCESS; 214 } 215 216 #ifdef FEATURE_P2P_LISTEN_OFFLOAD 217 /** 218 * send_p2p_lo_start_cmd_tlv() - send p2p lo start request to fw 219 * @wmi_handle: wmi handle 220 * @param: p2p listen offload start parameters 221 * 222 * Return: QDF status 223 */ 224 static QDF_STATUS send_p2p_lo_start_cmd_tlv(wmi_unified_t wmi_handle, 225 struct p2p_lo_start *param) 226 { 227 wmi_buf_t buf; 228 wmi_p2p_lo_start_cmd_fixed_param *cmd; 229 int32_t len = sizeof(*cmd); 230 uint8_t *buf_ptr; 231 QDF_STATUS status; 232 int device_types_len_aligned; 233 int probe_resp_len_aligned; 234 235 if (!param) { 236 WMI_LOGE("lo start param is null"); 237 return QDF_STATUS_E_INVAL; 238 } 239 240 WMI_LOGD("%s: vdev_id:%d", __func__, param->vdev_id); 241 242 device_types_len_aligned = 243 qdf_roundup(param->dev_types_len, 244 sizeof(uint32_t)); 245 probe_resp_len_aligned = 246 qdf_roundup(param->probe_resp_len, 247 sizeof(uint32_t)); 248 249 len += 2 * WMI_TLV_HDR_SIZE + device_types_len_aligned + 250 probe_resp_len_aligned; 251 252 buf = wmi_buf_alloc(wmi_handle, len); 253 if (!buf) { 254 return QDF_STATUS_E_NOMEM; 255 } 256 257 cmd = (wmi_p2p_lo_start_cmd_fixed_param *)wmi_buf_data(buf); 258 buf_ptr = (uint8_t *) wmi_buf_data(buf); 259 260 WMITLV_SET_HDR(&cmd->tlv_header, 261 WMITLV_TAG_STRUC_wmi_p2p_lo_start_cmd_fixed_param, 262 WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_lo_start_cmd_fixed_param)); 263 264 cmd->vdev_id = param->vdev_id; 265 cmd->ctl_flags = param->ctl_flags; 266 cmd->channel = param->freq; 267 cmd->period = param->period; 268 cmd->interval = param->interval; 269 cmd->count = param->count; 270 cmd->device_types_len = param->dev_types_len; 271 cmd->prob_resp_len = param->probe_resp_len; 272 273 buf_ptr += sizeof(wmi_p2p_lo_start_cmd_fixed_param); 274 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, 275 device_types_len_aligned); 276 buf_ptr += WMI_TLV_HDR_SIZE; 277 qdf_mem_copy(buf_ptr, param->device_types, 278 param->dev_types_len); 279 280 buf_ptr += device_types_len_aligned; 281 WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, 282 probe_resp_len_aligned); 283 buf_ptr += WMI_TLV_HDR_SIZE; 284 qdf_mem_copy(buf_ptr, param->probe_resp_tmplt, 285 param->probe_resp_len); 286 287 WMI_LOGD("%s: Sending WMI_P2P_LO_START command, channel=%d, period=%d, interval=%d, count=%d", __func__, 288 cmd->channel, cmd->period, cmd->interval, cmd->count); 289 290 wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_START_CMDID, cmd->vdev_id, 0); 291 status = wmi_unified_cmd_send(wmi_handle, 292 buf, len, 293 WMI_P2P_LISTEN_OFFLOAD_START_CMDID); 294 if (status != QDF_STATUS_SUCCESS) { 295 WMI_LOGE("%s: Failed to send p2p lo start: %d", 296 __func__, status); 297 wmi_buf_free(buf); 298 return status; 299 } 300 301 WMI_LOGD("%s: Successfully sent WMI_P2P_LO_START", __func__); 302 303 return QDF_STATUS_SUCCESS; 304 } 305 306 /** 307 * send_p2p_lo_stop_cmd_tlv() - send p2p lo stop request to fw 308 * @wmi_handle: wmi handle 309 * @param: p2p listen offload stop parameters 310 * 311 * Return: QDF status 312 */ 313 static QDF_STATUS send_p2p_lo_stop_cmd_tlv(wmi_unified_t wmi_handle, 314 uint8_t vdev_id) 315 { 316 wmi_buf_t buf; 317 wmi_p2p_lo_stop_cmd_fixed_param *cmd; 318 int32_t len; 319 QDF_STATUS status; 320 321 WMI_LOGD("%s: vdev_id:%d", __func__, vdev_id); 322 323 len = sizeof(*cmd); 324 buf = wmi_buf_alloc(wmi_handle, len); 325 if (!buf) { 326 return QDF_STATUS_E_NOMEM; 327 } 328 cmd = (wmi_p2p_lo_stop_cmd_fixed_param *)wmi_buf_data(buf); 329 330 WMITLV_SET_HDR(&cmd->tlv_header, 331 WMITLV_TAG_STRUC_wmi_p2p_lo_stop_cmd_fixed_param, 332 WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_lo_stop_cmd_fixed_param)); 333 334 cmd->vdev_id = vdev_id; 335 336 WMI_LOGD("%s: Sending WMI_P2P_LO_STOP command", __func__); 337 338 wmi_mtrace(WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID, cmd->vdev_id, 0); 339 status = wmi_unified_cmd_send(wmi_handle, 340 buf, len, 341 WMI_P2P_LISTEN_OFFLOAD_STOP_CMDID); 342 if (status != QDF_STATUS_SUCCESS) { 343 WMI_LOGE("%s: Failed to send p2p lo stop: %d", 344 __func__, status); 345 wmi_buf_free(buf); 346 return status; 347 } 348 349 WMI_LOGD("%s: Successfully sent WMI_P2P_LO_STOP", __func__); 350 351 return QDF_STATUS_SUCCESS; 352 } 353 354 /** 355 * extract_p2p_lo_stop_ev_param_tlv() - extract p2p lo stop 356 * information from event 357 * @wmi_handle: wmi handle 358 * @param evt_buf: pointer to event buffer 359 * @param param: Pointer to hold p2p lo stop event information 360 * 361 * Return: QDF_STATUS_SUCCESS for success or error code 362 */ 363 static QDF_STATUS extract_p2p_lo_stop_ev_param_tlv( 364 wmi_unified_t wmi_handle, void *evt_buf, 365 struct p2p_lo_event *param) 366 { 367 WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID_param_tlvs *param_tlvs; 368 wmi_p2p_lo_stopped_event_fixed_param *lo_param; 369 370 param_tlvs = (WMI_P2P_LISTEN_OFFLOAD_STOPPED_EVENTID_param_tlvs *) 371 evt_buf; 372 if (!param_tlvs) { 373 WMI_LOGE("%s: Invalid P2P lo stop event buffer", __func__); 374 return QDF_STATUS_E_INVAL; 375 } 376 377 if (!param) { 378 WMI_LOGE("lo stop event param is null"); 379 return QDF_STATUS_E_INVAL; 380 } 381 382 lo_param = param_tlvs->fixed_param; 383 param->vdev_id = lo_param->vdev_id; 384 param->reason_code = lo_param->reason; 385 WMI_LOGD("%s: vdev_id:%d, reason:%d", __func__, 386 param->vdev_id, param->reason_code); 387 388 return QDF_STATUS_SUCCESS; 389 } 390 391 void wmi_p2p_listen_offload_attach_tlv(wmi_unified_t wmi_handle) 392 { 393 struct wmi_ops *ops = wmi_handle->ops; 394 395 ops->send_p2p_lo_start_cmd = send_p2p_lo_start_cmd_tlv; 396 ops->send_p2p_lo_stop_cmd = send_p2p_lo_stop_cmd_tlv; 397 ops->extract_p2p_lo_stop_ev_param = 398 extract_p2p_lo_stop_ev_param_tlv; 399 } 400 #endif /* FEATURE_P2P_LISTEN_OFFLOAD */ 401 402 void wmi_p2p_attach_tlv(wmi_unified_t wmi_handle) 403 { 404 struct wmi_ops *ops = wmi_handle->ops; 405 406 ops->send_set_p2pgo_oppps_req_cmd = send_set_p2pgo_oppps_req_cmd_tlv; 407 ops->send_set_p2pgo_noa_req_cmd = send_set_p2pgo_noa_req_cmd_tlv; 408 ops->extract_p2p_noa_ev_param = extract_p2p_noa_ev_param_tlv; 409 wmi_p2p_listen_offload_attach_tlv(wmi_handle); 410 } 411 412