1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Copyright (C) 2018 - 2021, 2023 - 2026 Intel Corporation 4 */ 5 #include <net/cfg80211.h> 6 #include "core.h" 7 #include "nl80211.h" 8 #include "rdev-ops.h" 9 10 static int pmsr_parse_ftm(struct cfg80211_registered_device *rdev, 11 struct nlattr *ftmreq, 12 struct cfg80211_pmsr_request_peer *out, 13 struct genl_info *info) 14 { 15 const struct cfg80211_pmsr_capabilities *capa = rdev->wiphy.pmsr_capa; 16 struct nlattr *tb[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1]; 17 u32 preamble = NL80211_PREAMBLE_DMG; /* only optional in DMG */ 18 19 /* validate existing data */ 20 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_INFRA && 21 !(capa->ftm.bandwidths & BIT(out->chandef.width))) { 22 NL_SET_ERR_MSG(info->extack, "FTM: unsupported bandwidth"); 23 return -EINVAL; 24 } 25 26 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 27 !(capa->ftm.pd_bandwidths & BIT(out->chandef.width))) { 28 NL_SET_ERR_MSG(info->extack, 29 "FTM: unsupported bandwidth for PD request"); 30 return -EINVAL; 31 } 32 33 /* no validation needed - was already done via nested policy */ 34 nla_parse_nested_deprecated(tb, NL80211_PMSR_FTM_REQ_ATTR_MAX, ftmreq, 35 NULL, NULL); 36 37 if (tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]) 38 preamble = nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]); 39 40 /* set up values - struct is 0-initialized */ 41 out->ftm.requested = true; 42 43 switch (out->chandef.chan->band) { 44 case NL80211_BAND_60GHZ: 45 /* optional */ 46 break; 47 default: 48 if (!tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]) { 49 NL_SET_ERR_MSG(info->extack, 50 "FTM: must specify preamble"); 51 return -EINVAL; 52 } 53 } 54 55 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_INFRA && 56 !(capa->ftm.preambles & BIT(preamble))) { 57 NL_SET_ERR_MSG_ATTR(info->extack, 58 tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE], 59 "FTM: invalid preamble"); 60 return -EINVAL; 61 } 62 63 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 64 !(capa->ftm.pd_preambles & BIT(preamble))) { 65 NL_SET_ERR_MSG_ATTR(info->extack, 66 tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE], 67 "FTM: invalid preamble for PD request"); 68 return -EINVAL; 69 } 70 71 out->ftm.preamble = preamble; 72 73 out->ftm.burst_period = 0; 74 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD]) 75 out->ftm.burst_period = 76 nla_get_u16(tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD]); 77 78 out->ftm.asap = !!tb[NL80211_PMSR_FTM_REQ_ATTR_ASAP]; 79 if (out->ftm.asap && !capa->ftm.asap) { 80 NL_SET_ERR_MSG_ATTR(info->extack, 81 tb[NL80211_PMSR_FTM_REQ_ATTR_ASAP], 82 "FTM: ASAP mode not supported"); 83 return -EINVAL; 84 } 85 86 if (!out->ftm.asap && !capa->ftm.non_asap) { 87 NL_SET_ERR_MSG(info->extack, 88 "FTM: non-ASAP mode not supported"); 89 return -EINVAL; 90 } 91 92 out->ftm.num_bursts_exp = 0; 93 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP]) 94 out->ftm.num_bursts_exp = 95 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP]); 96 97 if (capa->ftm.max_bursts_exponent >= 0 && 98 out->ftm.num_bursts_exp > capa->ftm.max_bursts_exponent) { 99 NL_SET_ERR_MSG_ATTR(info->extack, 100 tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP], 101 "FTM: max NUM_BURSTS_EXP must be set lower than the device limit"); 102 return -EINVAL; 103 } 104 105 out->ftm.ftms_per_burst = 0; 106 if (tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST]) 107 out->ftm.ftms_per_burst = 108 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST]); 109 110 if (capa->ftm.max_ftms_per_burst && 111 out->ftm.ftms_per_burst > capa->ftm.max_ftms_per_burst) { 112 NL_SET_ERR_MSG_ATTR(info->extack, 113 tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST], 114 "FTM: FTMs per burst must be set lower than the device limit"); 115 return -EINVAL; 116 } 117 118 out->ftm.ftmr_retries = 3; 119 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES]) 120 out->ftm.ftmr_retries = 121 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES]); 122 123 out->ftm.request_lci = !!tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI]; 124 if (out->ftm.request_lci && !capa->ftm.request_lci) { 125 NL_SET_ERR_MSG_ATTR(info->extack, 126 tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI], 127 "FTM: LCI request not supported"); 128 return -EOPNOTSUPP; 129 } 130 131 out->ftm.request_civicloc = 132 !!tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC]; 133 if (out->ftm.request_civicloc && !capa->ftm.request_civicloc) { 134 NL_SET_ERR_MSG_ATTR(info->extack, 135 tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC], 136 "FTM: civic location request not supported"); 137 return -EOPNOTSUPP; 138 } 139 140 out->ftm.trigger_based = 141 !!tb[NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED]; 142 if (out->ftm.trigger_based && !capa->ftm.trigger_based) { 143 NL_SET_ERR_MSG_ATTR(info->extack, 144 tb[NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED], 145 "FTM: trigger based ranging is not supported"); 146 return -EINVAL; 147 } 148 149 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 150 out->ftm.trigger_based) { 151 NL_SET_ERR_MSG_ATTR(info->extack, 152 ftmreq, 153 "FTM: TB ranging is not supported for PD request type"); 154 return -EINVAL; 155 } 156 157 out->ftm.non_trigger_based = 158 !!tb[NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED]; 159 if (out->ftm.non_trigger_based && !capa->ftm.non_trigger_based) { 160 NL_SET_ERR_MSG_ATTR(info->extack, 161 tb[NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED], 162 "FTM: trigger based ranging is not supported"); 163 return -EINVAL; 164 } 165 166 if (out->ftm.trigger_based && out->ftm.non_trigger_based) { 167 NL_SET_ERR_MSG(info->extack, 168 "FTM: can't set both trigger based and non trigger based"); 169 return -EINVAL; 170 } 171 172 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 173 out->ftm.non_trigger_based && out->ftm.ftms_per_burst > 4) { 174 NL_SET_ERR_MSG_ATTR(info->extack, 175 tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST], 176 "FTM: FTMs per burst must not exceed 4 for PD NTB ranging"); 177 return -ERANGE; 178 } 179 180 if (out->ftm.ftms_per_burst > 31 && !out->ftm.non_trigger_based && 181 !out->ftm.trigger_based) { 182 NL_SET_ERR_MSG_ATTR(info->extack, 183 tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST], 184 "FTM: FTMs per burst must be set lower than 31"); 185 return -ERANGE; 186 } 187 188 if ((out->ftm.trigger_based || out->ftm.non_trigger_based) && 189 out->ftm.preamble != NL80211_PREAMBLE_HE) { 190 NL_SET_ERR_MSG_ATTR(info->extack, 191 tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE], 192 "FTM: non EDCA based ranging must use HE preamble"); 193 return -EINVAL; 194 } 195 196 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION]) 197 out->ftm.burst_duration = 198 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION]); 199 else if (!out->ftm.non_trigger_based && !out->ftm.trigger_based) 200 out->ftm.burst_duration = 15; 201 202 out->ftm.lmr_feedback = 203 !!tb[NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK]; 204 if (!out->ftm.trigger_based && !out->ftm.non_trigger_based && 205 out->ftm.lmr_feedback) { 206 NL_SET_ERR_MSG_ATTR(info->extack, 207 tb[NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK], 208 "FTM: LMR feedback set for EDCA based ranging"); 209 return -EINVAL; 210 } 211 212 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR]) { 213 if (!out->ftm.non_trigger_based && !out->ftm.trigger_based) { 214 NL_SET_ERR_MSG_ATTR(info->extack, 215 tb[NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR], 216 "FTM: BSS color set for EDCA based ranging"); 217 return -EINVAL; 218 } 219 220 out->ftm.bss_color = 221 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR]); 222 } 223 224 out->ftm.rsta = !!tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA]; 225 if (out->ftm.rsta && out->ftm.non_trigger_based && 226 !capa->ftm.rsta.support_ntb) { 227 NL_SET_ERR_MSG_ATTR(info->extack, 228 tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA], 229 "FTM: NTB RSTA not supported by device"); 230 return -EOPNOTSUPP; 231 } 232 233 if (out->ftm.rsta && out->ftm.trigger_based && 234 !capa->ftm.rsta.support_tb) { 235 NL_SET_ERR_MSG_ATTR(info->extack, 236 tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA], 237 "FTM: TB RSTA not supported by device"); 238 return -EOPNOTSUPP; 239 } 240 241 if (out->ftm.rsta && !out->ftm.non_trigger_based && 242 !out->ftm.trigger_based && 243 !capa->ftm.rsta.support_edca) { 244 NL_SET_ERR_MSG_ATTR(info->extack, 245 tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA], 246 "FTM: EDCA RSTA not supported by device"); 247 return -EOPNOTSUPP; 248 } 249 250 if (out->ftm.rsta && 251 (out->ftm.non_trigger_based || out->ftm.trigger_based) && 252 !out->ftm.lmr_feedback) { 253 NL_SET_ERR_MSG_ATTR(info->extack, 254 tb[NL80211_PMSR_FTM_REQ_ATTR_RSTA], 255 "FTM: RSTA set without LMR feedback"); 256 return -EINVAL; 257 } 258 259 if (out->ftm.non_trigger_based) { 260 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 261 !tb[NL80211_PMSR_FTM_REQ_ATTR_NOMINAL_TIME]) { 262 NL_SET_ERR_MSG(info->extack, 263 "FTM: nominal time is required for PD NTB ranging"); 264 return -EINVAL; 265 } 266 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NOMINAL_TIME]) 267 out->ftm.nominal_time = 268 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_NOMINAL_TIME]); 269 270 if (tb[NL80211_PMSR_FTM_REQ_ATTR_MIN_TIME_BETWEEN_MEASUREMENTS]) 271 out->ftm.min_time_between_measurements = 272 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_MIN_TIME_BETWEEN_MEASUREMENTS]); 273 274 if (tb[NL80211_PMSR_FTM_REQ_ATTR_MAX_TIME_BETWEEN_MEASUREMENTS]) 275 out->ftm.max_time_between_measurements = 276 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_MAX_TIME_BETWEEN_MEASUREMENTS]); 277 278 if (tb[NL80211_PMSR_FTM_REQ_ATTR_AW_DURATION]) 279 out->ftm.availability_window = 280 nla_get_u8(tb[NL80211_PMSR_FTM_REQ_ATTR_AW_DURATION]); 281 282 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_MEASUREMENTS]) 283 out->ftm.num_measurements = 284 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_MEASUREMENTS]); 285 } 286 287 if (tb[NL80211_PMSR_FTM_REQ_ATTR_INGRESS]) 288 out->ftm.ingress_distance = 289 nla_get_u64(tb[NL80211_PMSR_FTM_REQ_ATTR_INGRESS]); 290 291 if (tb[NL80211_PMSR_FTM_REQ_ATTR_EGRESS]) 292 out->ftm.egress_distance = 293 nla_get_u64(tb[NL80211_PMSR_FTM_REQ_ATTR_EGRESS]); 294 295 out->ftm.pd_suppress_range_results = 296 nla_get_flag(tb[NL80211_PMSR_FTM_REQ_ATTR_PD_SUPPRESS_RESULTS]); 297 298 if (out->ftm.request_type != NL80211_PMSR_FTM_REQ_TYPE_PD && 299 out->ftm.pd_suppress_range_results) { 300 NL_SET_ERR_MSG_ATTR(info->extack, 301 tb[NL80211_PMSR_FTM_REQ_ATTR_PD_SUPPRESS_RESULTS], 302 "FTM: suppress range result flag only valid for PD requests"); 303 return -EINVAL; 304 } 305 306 return 0; 307 } 308 309 static int pmsr_parse_peer(struct cfg80211_registered_device *rdev, 310 struct nlattr *peer, 311 struct cfg80211_pmsr_request_peer *out, 312 struct genl_info *info) 313 { 314 struct nlattr *tb[NL80211_PMSR_PEER_ATTR_MAX + 1]; 315 struct nlattr *req[NL80211_PMSR_REQ_ATTR_MAX + 1]; 316 bool have_measurement_type = false; 317 struct nlattr *treq; 318 int err, rem; 319 320 /* no validation needed - was already done via nested policy */ 321 nla_parse_nested_deprecated(tb, NL80211_PMSR_PEER_ATTR_MAX, peer, 322 NULL, NULL); 323 324 if (!tb[NL80211_PMSR_PEER_ATTR_ADDR] || 325 !tb[NL80211_PMSR_PEER_ATTR_CHAN] || 326 !tb[NL80211_PMSR_PEER_ATTR_REQ]) { 327 NL_SET_ERR_MSG_ATTR(info->extack, peer, 328 "insufficient peer data"); 329 return -EINVAL; 330 } 331 332 memcpy(out->addr, nla_data(tb[NL80211_PMSR_PEER_ATTR_ADDR]), ETH_ALEN); 333 334 if (tb[NL80211_PMSR_PEER_ATTR_REQ_TYPE]) 335 out->ftm.request_type = 336 nla_get_u32(tb[NL80211_PMSR_PEER_ATTR_REQ_TYPE]); 337 else 338 out->ftm.request_type = NL80211_PMSR_FTM_REQ_TYPE_INFRA; 339 340 if (out->ftm.request_type == NL80211_PMSR_FTM_REQ_TYPE_PD && 341 !rdev->wiphy.pmsr_capa->ftm.type.pd_support) { 342 NL_SET_ERR_MSG_ATTR(info->extack, 343 tb[NL80211_PMSR_PEER_ATTR_REQ_TYPE], 344 "FTM: PD request type not supported by device"); 345 return -EINVAL; 346 } 347 /* reuse info->attrs */ 348 memset(info->attrs, 0, sizeof(*info->attrs) * (NL80211_ATTR_MAX + 1)); 349 err = nla_parse_nested_deprecated(info->attrs, NL80211_ATTR_MAX, 350 tb[NL80211_PMSR_PEER_ATTR_CHAN], 351 NULL, info->extack); 352 if (err) 353 return err; 354 355 err = nl80211_parse_chandef(rdev, info->extack, info->attrs, 356 &out->chandef, false); 357 if (err) 358 return err; 359 360 /* no validation needed - was already done via nested policy */ 361 nla_parse_nested_deprecated(req, NL80211_PMSR_REQ_ATTR_MAX, 362 tb[NL80211_PMSR_PEER_ATTR_REQ], NULL, 363 NULL); 364 365 if (!req[NL80211_PMSR_REQ_ATTR_DATA]) { 366 NL_SET_ERR_MSG_ATTR(info->extack, 367 tb[NL80211_PMSR_PEER_ATTR_REQ], 368 "missing request type/data"); 369 return -EINVAL; 370 } 371 372 if (req[NL80211_PMSR_REQ_ATTR_GET_AP_TSF]) 373 out->report_ap_tsf = true; 374 375 if (out->report_ap_tsf && !rdev->wiphy.pmsr_capa->report_ap_tsf) { 376 NL_SET_ERR_MSG_ATTR(info->extack, 377 req[NL80211_PMSR_REQ_ATTR_GET_AP_TSF], 378 "reporting AP TSF is not supported"); 379 return -EINVAL; 380 } 381 382 nla_for_each_nested(treq, req[NL80211_PMSR_REQ_ATTR_DATA], rem) { 383 if (have_measurement_type) { 384 NL_SET_ERR_MSG_ATTR(info->extack, treq, 385 "multiple measurement types in request data"); 386 return -EINVAL; 387 } 388 389 have_measurement_type = true; 390 391 switch (nla_type(treq)) { 392 case NL80211_PMSR_TYPE_FTM: 393 err = pmsr_parse_ftm(rdev, treq, out, info); 394 break; 395 default: 396 NL_SET_ERR_MSG_ATTR(info->extack, treq, 397 "unsupported measurement type"); 398 err = -EINVAL; 399 } 400 if (err) 401 return err; 402 } 403 404 if (!have_measurement_type) { 405 NL_SET_ERR_MSG_ATTR(info->extack, 406 req[NL80211_PMSR_REQ_ATTR_DATA], 407 "missing measurement type in request data"); 408 return -EINVAL; 409 } 410 411 return 0; 412 } 413 414 int nl80211_pmsr_start(struct sk_buff *skb, struct genl_info *info) 415 { 416 struct nlattr *reqattr = info->attrs[NL80211_ATTR_PEER_MEASUREMENTS]; 417 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 418 int count, rem, err, idx, peer_count; 419 struct wireless_dev *wdev = info->user_ptr[1]; 420 const struct cfg80211_pmsr_capabilities *capa; 421 struct cfg80211_pmsr_request *req; 422 struct nlattr *peers, *peer; 423 424 capa = rdev->wiphy.pmsr_capa; 425 426 if (!capa) 427 return -EOPNOTSUPP; 428 429 if (!reqattr) 430 return -EINVAL; 431 432 peers = nla_find(nla_data(reqattr), nla_len(reqattr), 433 NL80211_PMSR_ATTR_PEERS); 434 if (!peers) 435 return -EINVAL; 436 437 count = 0; 438 nla_for_each_nested(peer, peers, rem) { 439 count++; 440 441 if (count > capa->max_peers) { 442 NL_SET_ERR_MSG_ATTR(info->extack, peer, 443 "Too many peers used"); 444 return -EINVAL; 445 } 446 } 447 448 if (!count) { 449 NL_SET_ERR_MSG_ATTR(info->extack, peers, "No peers specified"); 450 return -EINVAL; 451 } 452 453 req = kzalloc_flex(*req, peers, count); 454 if (!req) 455 return -ENOMEM; 456 req->n_peers = count; 457 458 if (info->attrs[NL80211_ATTR_TIMEOUT]) 459 req->timeout = nla_get_u32(info->attrs[NL80211_ATTR_TIMEOUT]); 460 461 if (info->attrs[NL80211_ATTR_MAC]) { 462 if (!capa->randomize_mac_addr) { 463 NL_SET_ERR_MSG_ATTR(info->extack, 464 info->attrs[NL80211_ATTR_MAC], 465 "device cannot randomize MAC address"); 466 err = -EINVAL; 467 goto out_err; 468 } 469 470 err = nl80211_parse_random_mac(info->attrs, req->mac_addr, 471 req->mac_addr_mask); 472 if (err) 473 goto out_err; 474 } else { 475 memcpy(req->mac_addr, wdev_address(wdev), ETH_ALEN); 476 eth_broadcast_addr(req->mac_addr_mask); 477 } 478 479 idx = 0; 480 nla_for_each_nested(peer, peers, rem) { 481 /* NB: this reuses info->attrs, but we no longer need it */ 482 err = pmsr_parse_peer(rdev, peer, &req->peers[idx], info); 483 if (err) 484 goto out_err; 485 idx++; 486 } 487 488 /* Validate per-role peer limits if advertised */ 489 if (capa->ftm.ista.max_peers) { 490 peer_count = 0; 491 492 for (idx = 0; idx < req->n_peers; idx++) { 493 if (!req->peers[idx].ftm.rsta) { 494 peer_count++; 495 496 if (peer_count > capa->ftm.ista.max_peers) { 497 NL_SET_ERR_MSG(info->extack, 498 "Too many ISTA peers for device limit"); 499 err = -EINVAL; 500 goto out_err; 501 } 502 } 503 } 504 } 505 506 if (capa->ftm.rsta.max_peers) { 507 peer_count = 0; 508 509 for (idx = 0; idx < req->n_peers; idx++) { 510 if (req->peers[idx].ftm.rsta) { 511 peer_count++; 512 513 if (peer_count > capa->ftm.rsta.max_peers) { 514 NL_SET_ERR_MSG(info->extack, 515 "Too many RSTA peers for device limit"); 516 err = -EINVAL; 517 goto out_err; 518 } 519 } 520 } 521 } 522 req->cookie = cfg80211_assign_cookie(rdev); 523 req->nl_portid = info->snd_portid; 524 525 err = rdev_start_pmsr(rdev, wdev, req); 526 if (err) 527 goto out_err; 528 529 list_add_tail(&req->list, &wdev->pmsr_list); 530 531 nl_set_extack_cookie_u64(info->extack, req->cookie); 532 return 0; 533 out_err: 534 kfree(req); 535 return err; 536 } 537 538 void cfg80211_pmsr_complete(struct wireless_dev *wdev, 539 struct cfg80211_pmsr_request *req, 540 gfp_t gfp) 541 { 542 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 543 struct cfg80211_pmsr_request *tmp, *prev, *to_free = NULL; 544 struct sk_buff *msg; 545 void *hdr; 546 547 trace_cfg80211_pmsr_complete(wdev->wiphy, wdev, req->cookie); 548 549 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 550 if (!msg) 551 goto free_request; 552 553 hdr = nl80211hdr_put(msg, 0, 0, 0, 554 NL80211_CMD_PEER_MEASUREMENT_COMPLETE); 555 if (!hdr) 556 goto free_msg; 557 558 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 559 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 560 NL80211_ATTR_PAD)) 561 goto free_msg; 562 563 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->cookie, 564 NL80211_ATTR_PAD)) 565 goto free_msg; 566 567 genlmsg_end(msg, hdr); 568 genlmsg_unicast(wiphy_net(wdev->wiphy), msg, req->nl_portid); 569 goto free_request; 570 free_msg: 571 nlmsg_free(msg); 572 free_request: 573 spin_lock_bh(&wdev->pmsr_lock); 574 /* 575 * cfg80211_pmsr_process_abort() may have already moved this request 576 * to the free list, and will free it later. In this case, don't free 577 * it here. 578 */ 579 list_for_each_entry_safe(tmp, prev, &wdev->pmsr_list, list) { 580 if (tmp == req) { 581 list_del(&req->list); 582 to_free = req; 583 break; 584 } 585 } 586 spin_unlock_bh(&wdev->pmsr_lock); 587 kfree(to_free); 588 } 589 EXPORT_SYMBOL_GPL(cfg80211_pmsr_complete); 590 591 static int nl80211_pmsr_send_ftm_res(struct sk_buff *msg, 592 struct cfg80211_pmsr_result *res) 593 { 594 if (res->status == NL80211_PMSR_STATUS_FAILURE) { 595 if (nla_put_u32(msg, NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON, 596 res->ftm.failure_reason)) 597 goto error; 598 599 if (res->ftm.failure_reason == 600 NL80211_PMSR_FTM_FAILURE_PEER_BUSY && 601 res->ftm.busy_retry_time && 602 nla_put_u32(msg, NL80211_PMSR_FTM_RESP_ATTR_BUSY_RETRY_TIME, 603 res->ftm.busy_retry_time)) 604 goto error; 605 606 return 0; 607 } 608 609 #define PUT(tp, attr, val) \ 610 do { \ 611 if (nla_put_##tp(msg, \ 612 NL80211_PMSR_FTM_RESP_ATTR_##attr, \ 613 res->ftm.val)) \ 614 goto error; \ 615 } while (0) 616 617 #define PUTOPT(tp, attr, val) \ 618 do { \ 619 if (res->ftm.val##_valid) \ 620 PUT(tp, attr, val); \ 621 } while (0) 622 623 #define PUT_U64(attr, val) \ 624 do { \ 625 if (nla_put_u64_64bit(msg, \ 626 NL80211_PMSR_FTM_RESP_ATTR_##attr,\ 627 res->ftm.val, \ 628 NL80211_PMSR_FTM_RESP_ATTR_PAD)) \ 629 goto error; \ 630 } while (0) 631 632 #define PUTOPT_U64(attr, val) \ 633 do { \ 634 if (res->ftm.val##_valid) \ 635 PUT_U64(attr, val); \ 636 } while (0) 637 638 if (res->ftm.burst_index >= 0) 639 PUT(u32, BURST_INDEX, burst_index); 640 PUTOPT(u32, NUM_FTMR_ATTEMPTS, num_ftmr_attempts); 641 PUTOPT(u32, NUM_FTMR_SUCCESSES, num_ftmr_successes); 642 PUT(u8, NUM_BURSTS_EXP, num_bursts_exp); 643 PUT(u8, BURST_DURATION, burst_duration); 644 PUT(u8, FTMS_PER_BURST, ftms_per_burst); 645 PUT(u16, BURST_PERIOD, burst_period); 646 PUTOPT(s32, RSSI_AVG, rssi_avg); 647 PUTOPT(s32, RSSI_SPREAD, rssi_spread); 648 if (res->ftm.tx_rate_valid && 649 !nl80211_put_sta_rate(msg, &res->ftm.tx_rate, 650 NL80211_PMSR_FTM_RESP_ATTR_TX_RATE)) 651 goto error; 652 if (res->ftm.rx_rate_valid && 653 !nl80211_put_sta_rate(msg, &res->ftm.rx_rate, 654 NL80211_PMSR_FTM_RESP_ATTR_RX_RATE)) 655 goto error; 656 PUTOPT_U64(RTT_AVG, rtt_avg); 657 PUTOPT_U64(RTT_VARIANCE, rtt_variance); 658 PUTOPT_U64(RTT_SPREAD, rtt_spread); 659 PUTOPT_U64(DIST_AVG, dist_avg); 660 PUTOPT_U64(DIST_VARIANCE, dist_variance); 661 PUTOPT_U64(DIST_SPREAD, dist_spread); 662 PUTOPT(u32, TX_LTF_REPETITION_COUNT, tx_ltf_repetition_count); 663 PUTOPT(u32, RX_LTF_REPETITION_COUNT, rx_ltf_repetition_count); 664 PUTOPT(u32, MAX_TIME_BETWEEN_MEASUREMENTS, 665 max_time_between_measurements); 666 PUTOPT(u32, MIN_TIME_BETWEEN_MEASUREMENTS, 667 min_time_between_measurements); 668 PUTOPT(u8, NUM_TX_SPATIAL_STREAMS, num_tx_spatial_streams); 669 PUTOPT(u8, NUM_RX_SPATIAL_STREAMS, num_rx_spatial_streams); 670 PUTOPT(u32, NOMINAL_TIME, nominal_time); 671 PUTOPT(u8, AVAILABILITY_WINDOW, availability_window); 672 PUTOPT(u32, CHANNEL_WIDTH, chan_width); 673 PUTOPT(u32, PREAMBLE, preamble); 674 if (res->ftm.is_delayed_lmr && 675 nla_put_flag(msg, NL80211_PMSR_FTM_RESP_ATTR_IS_DELAYED_LMR)) 676 goto error; 677 if (res->ftm.lci && res->ftm.lci_len && 678 nla_put(msg, NL80211_PMSR_FTM_RESP_ATTR_LCI, 679 res->ftm.lci_len, res->ftm.lci)) 680 goto error; 681 if (res->ftm.civicloc && res->ftm.civicloc_len && 682 nla_put(msg, NL80211_PMSR_FTM_RESP_ATTR_CIVICLOC, 683 res->ftm.civicloc_len, res->ftm.civicloc)) 684 goto error; 685 #undef PUT 686 #undef PUTOPT 687 #undef PUT_U64 688 #undef PUTOPT_U64 689 690 return 0; 691 error: 692 return -ENOSPC; 693 } 694 695 static int nl80211_pmsr_send_result(struct sk_buff *msg, 696 struct cfg80211_pmsr_result *res) 697 { 698 struct nlattr *pmsr, *peers, *peer, *resp, *data, *typedata; 699 700 pmsr = nla_nest_start_noflag(msg, NL80211_ATTR_PEER_MEASUREMENTS); 701 if (!pmsr) 702 goto error; 703 704 peers = nla_nest_start_noflag(msg, NL80211_PMSR_ATTR_PEERS); 705 if (!peers) 706 goto error; 707 708 peer = nla_nest_start_noflag(msg, 1); 709 if (!peer) 710 goto error; 711 712 if (nla_put(msg, NL80211_PMSR_PEER_ATTR_ADDR, ETH_ALEN, res->addr)) 713 goto error; 714 715 resp = nla_nest_start_noflag(msg, NL80211_PMSR_PEER_ATTR_RESP); 716 if (!resp) 717 goto error; 718 719 if (nla_put_u32(msg, NL80211_PMSR_RESP_ATTR_STATUS, res->status) || 720 nla_put_u64_64bit(msg, NL80211_PMSR_RESP_ATTR_HOST_TIME, 721 res->host_time, NL80211_PMSR_RESP_ATTR_PAD)) 722 goto error; 723 724 if (res->ap_tsf_valid && 725 nla_put_u64_64bit(msg, NL80211_PMSR_RESP_ATTR_AP_TSF, 726 res->ap_tsf, NL80211_PMSR_RESP_ATTR_PAD)) 727 goto error; 728 729 if (res->final && nla_put_flag(msg, NL80211_PMSR_RESP_ATTR_FINAL)) 730 goto error; 731 732 data = nla_nest_start_noflag(msg, NL80211_PMSR_RESP_ATTR_DATA); 733 if (!data) 734 goto error; 735 736 typedata = nla_nest_start_noflag(msg, res->type); 737 if (!typedata) 738 goto error; 739 740 switch (res->type) { 741 case NL80211_PMSR_TYPE_FTM: 742 if (nl80211_pmsr_send_ftm_res(msg, res)) 743 goto error; 744 break; 745 default: 746 WARN_ON(1); 747 } 748 749 nla_nest_end(msg, typedata); 750 nla_nest_end(msg, data); 751 nla_nest_end(msg, resp); 752 nla_nest_end(msg, peer); 753 nla_nest_end(msg, peers); 754 nla_nest_end(msg, pmsr); 755 756 return 0; 757 error: 758 return -ENOSPC; 759 } 760 761 void cfg80211_pmsr_report(struct wireless_dev *wdev, 762 struct cfg80211_pmsr_request *req, 763 struct cfg80211_pmsr_result *result, 764 gfp_t gfp) 765 { 766 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 767 struct sk_buff *msg; 768 void *hdr; 769 int err; 770 771 trace_cfg80211_pmsr_report(wdev->wiphy, wdev, req->cookie, 772 result->addr); 773 774 /* 775 * Currently, only variable items are LCI and civic location, 776 * both of which are reasonably short so we don't need to 777 * worry about them here for the allocation. 778 */ 779 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 780 if (!msg) 781 return; 782 783 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PEER_MEASUREMENT_RESULT); 784 if (!hdr) 785 goto free; 786 787 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 788 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 789 NL80211_ATTR_PAD)) 790 goto free; 791 792 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->cookie, 793 NL80211_ATTR_PAD)) 794 goto free; 795 796 err = nl80211_pmsr_send_result(msg, result); 797 if (err) { 798 pr_err_ratelimited("peer measurement result: message didn't fit!"); 799 goto free; 800 } 801 802 genlmsg_end(msg, hdr); 803 genlmsg_unicast(wiphy_net(wdev->wiphy), msg, req->nl_portid); 804 return; 805 free: 806 nlmsg_free(msg); 807 } 808 EXPORT_SYMBOL_GPL(cfg80211_pmsr_report); 809 810 static void cfg80211_pmsr_process_abort(struct wireless_dev *wdev) 811 { 812 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 813 struct cfg80211_pmsr_request *req, *tmp; 814 LIST_HEAD(free_list); 815 816 lockdep_assert_wiphy(wdev->wiphy); 817 818 spin_lock_bh(&wdev->pmsr_lock); 819 list_for_each_entry_safe(req, tmp, &wdev->pmsr_list, list) { 820 if (req->nl_portid) 821 continue; 822 list_move_tail(&req->list, &free_list); 823 } 824 spin_unlock_bh(&wdev->pmsr_lock); 825 826 list_for_each_entry_safe(req, tmp, &free_list, list) { 827 rdev_abort_pmsr(rdev, wdev, req); 828 829 kfree(req); 830 } 831 } 832 833 void cfg80211_pmsr_free_wk(struct wiphy *wiphy, struct wiphy_work *work) 834 { 835 struct wireless_dev *wdev = container_of(work, struct wireless_dev, 836 pmsr_free_wk); 837 838 cfg80211_pmsr_process_abort(wdev); 839 } 840 841 void cfg80211_pmsr_wdev_down(struct wireless_dev *wdev) 842 { 843 struct cfg80211_pmsr_request *req; 844 bool found = false; 845 846 spin_lock_bh(&wdev->pmsr_lock); 847 list_for_each_entry(req, &wdev->pmsr_list, list) { 848 found = true; 849 req->nl_portid = 0; 850 } 851 spin_unlock_bh(&wdev->pmsr_lock); 852 853 wiphy_work_cancel(wdev->wiphy, &wdev->pmsr_free_wk); 854 if (found) 855 cfg80211_pmsr_process_abort(wdev); 856 857 WARN_ON(!list_empty(&wdev->pmsr_list)); 858 } 859 860 void cfg80211_release_pmsr(struct wireless_dev *wdev, u32 portid) 861 { 862 struct cfg80211_pmsr_request *req; 863 864 spin_lock_bh(&wdev->pmsr_lock); 865 list_for_each_entry(req, &wdev->pmsr_list, list) { 866 if (req->nl_portid == portid) { 867 req->nl_portid = 0; 868 wiphy_work_queue(wdev->wiphy, &wdev->pmsr_free_wk); 869 } 870 } 871 spin_unlock_bh(&wdev->pmsr_lock); 872 } 873