1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3 * Copyright (C) 2018 - 2019 Intel Corporation
4 */
5 #ifndef __PMSR_H
6 #define __PMSR_H
7 #include <net/cfg80211.h>
8 #include "core.h"
9 #include "nl80211.h"
10 #include "rdev-ops.h"
11
pmsr_parse_ftm(struct cfg80211_registered_device * rdev,struct nlattr * ftmreq,struct cfg80211_pmsr_request_peer * out,struct genl_info * info)12 static int pmsr_parse_ftm(struct cfg80211_registered_device *rdev,
13 struct nlattr *ftmreq,
14 struct cfg80211_pmsr_request_peer *out,
15 struct genl_info *info)
16 {
17 const struct cfg80211_pmsr_capabilities *capa = rdev->wiphy.pmsr_capa;
18 struct nlattr *tb[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1];
19 u32 preamble = NL80211_PREAMBLE_DMG; /* only optional in DMG */
20
21 /* validate existing data */
22 if (!(rdev->wiphy.pmsr_capa->ftm.bandwidths & BIT(out->chandef.width))) {
23 NL_SET_ERR_MSG(info->extack, "FTM: unsupported bandwidth");
24 return -EINVAL;
25 }
26
27 /* no validation needed - was already done via nested policy */
28 nla_parse_nested_deprecated(tb, NL80211_PMSR_FTM_REQ_ATTR_MAX, ftmreq,
29 NULL, NULL);
30
31 if (tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE])
32 preamble = nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]);
33
34 /* set up values - struct is 0-initialized */
35 out->ftm.requested = true;
36
37 switch (out->chandef.chan->band) {
38 case NL80211_BAND_60GHZ:
39 /* optional */
40 break;
41 default:
42 if (!tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE]) {
43 NL_SET_ERR_MSG(info->extack,
44 "FTM: must specify preamble");
45 return -EINVAL;
46 }
47 }
48
49 if (!(capa->ftm.preambles & BIT(preamble))) {
50 NL_SET_ERR_MSG_ATTR(info->extack,
51 tb[NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE],
52 "FTM: invalid preamble");
53 return -EINVAL;
54 }
55
56 out->ftm.preamble = preamble;
57
58 out->ftm.burst_period = 0;
59 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD])
60 out->ftm.burst_period =
61 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD]);
62
63 out->ftm.asap = !!tb[NL80211_PMSR_FTM_REQ_ATTR_ASAP];
64 if (out->ftm.asap && !capa->ftm.asap) {
65 NL_SET_ERR_MSG_ATTR(info->extack,
66 tb[NL80211_PMSR_FTM_REQ_ATTR_ASAP],
67 "FTM: ASAP mode not supported");
68 return -EINVAL;
69 }
70
71 if (!out->ftm.asap && !capa->ftm.non_asap) {
72 NL_SET_ERR_MSG(info->extack,
73 "FTM: non-ASAP mode not supported");
74 return -EINVAL;
75 }
76
77 out->ftm.num_bursts_exp = 0;
78 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP])
79 out->ftm.num_bursts_exp =
80 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP]);
81
82 if (capa->ftm.max_bursts_exponent >= 0 &&
83 out->ftm.num_bursts_exp > capa->ftm.max_bursts_exponent) {
84 NL_SET_ERR_MSG_ATTR(info->extack,
85 tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP],
86 "FTM: max NUM_BURSTS_EXP must be set lower than the device limit");
87 return -EINVAL;
88 }
89
90 out->ftm.burst_duration = 15;
91 if (tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION])
92 out->ftm.burst_duration =
93 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION]);
94
95 out->ftm.ftms_per_burst = 0;
96 if (tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST])
97 out->ftm.ftms_per_burst =
98 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST]);
99
100 if (capa->ftm.max_ftms_per_burst &&
101 (out->ftm.ftms_per_burst > capa->ftm.max_ftms_per_burst ||
102 out->ftm.ftms_per_burst == 0)) {
103 NL_SET_ERR_MSG_ATTR(info->extack,
104 tb[NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST],
105 "FTM: FTMs per burst must be set lower than the device limit but non-zero");
106 return -EINVAL;
107 }
108
109 out->ftm.ftmr_retries = 3;
110 if (tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES])
111 out->ftm.ftmr_retries =
112 nla_get_u32(tb[NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES]);
113
114 out->ftm.request_lci = !!tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI];
115 if (out->ftm.request_lci && !capa->ftm.request_lci) {
116 NL_SET_ERR_MSG_ATTR(info->extack,
117 tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI],
118 "FTM: LCI request not supported");
119 }
120
121 out->ftm.request_civicloc =
122 !!tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC];
123 if (out->ftm.request_civicloc && !capa->ftm.request_civicloc) {
124 NL_SET_ERR_MSG_ATTR(info->extack,
125 tb[NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC],
126 "FTM: civic location request not supported");
127 }
128
129 return 0;
130 }
131
pmsr_parse_peer(struct cfg80211_registered_device * rdev,struct nlattr * peer,struct cfg80211_pmsr_request_peer * out,struct genl_info * info)132 static int pmsr_parse_peer(struct cfg80211_registered_device *rdev,
133 struct nlattr *peer,
134 struct cfg80211_pmsr_request_peer *out,
135 struct genl_info *info)
136 {
137 struct nlattr *tb[NL80211_PMSR_PEER_ATTR_MAX + 1];
138 struct nlattr *req[NL80211_PMSR_REQ_ATTR_MAX + 1];
139 struct nlattr *treq;
140 int err, rem;
141
142 /* no validation needed - was already done via nested policy */
143 nla_parse_nested_deprecated(tb, NL80211_PMSR_PEER_ATTR_MAX, peer,
144 NULL, NULL);
145
146 if (!tb[NL80211_PMSR_PEER_ATTR_ADDR] ||
147 !tb[NL80211_PMSR_PEER_ATTR_CHAN] ||
148 !tb[NL80211_PMSR_PEER_ATTR_REQ]) {
149 NL_SET_ERR_MSG_ATTR(info->extack, peer,
150 "insufficient peer data");
151 return -EINVAL;
152 }
153
154 memcpy(out->addr, nla_data(tb[NL80211_PMSR_PEER_ATTR_ADDR]), ETH_ALEN);
155
156 /* reuse info->attrs */
157 memset(info->attrs, 0, sizeof(*info->attrs) * (NL80211_ATTR_MAX + 1));
158 /* need to validate here, we don't want to have validation recursion */
159 err = nla_parse_nested_deprecated(info->attrs, NL80211_ATTR_MAX,
160 tb[NL80211_PMSR_PEER_ATTR_CHAN],
161 nl80211_policy, info->extack);
162 if (err)
163 return err;
164
165 err = nl80211_parse_chandef(rdev, info, &out->chandef);
166 if (err)
167 return err;
168
169 /* no validation needed - was already done via nested policy */
170 nla_parse_nested_deprecated(req, NL80211_PMSR_REQ_ATTR_MAX,
171 tb[NL80211_PMSR_PEER_ATTR_REQ], NULL,
172 NULL);
173
174 if (!req[NL80211_PMSR_REQ_ATTR_DATA]) {
175 NL_SET_ERR_MSG_ATTR(info->extack,
176 tb[NL80211_PMSR_PEER_ATTR_REQ],
177 "missing request type/data");
178 return -EINVAL;
179 }
180
181 if (req[NL80211_PMSR_REQ_ATTR_GET_AP_TSF])
182 out->report_ap_tsf = true;
183
184 if (out->report_ap_tsf && !rdev->wiphy.pmsr_capa->report_ap_tsf) {
185 NL_SET_ERR_MSG_ATTR(info->extack,
186 req[NL80211_PMSR_REQ_ATTR_GET_AP_TSF],
187 "reporting AP TSF is not supported");
188 return -EINVAL;
189 }
190
191 nla_for_each_nested(treq, req[NL80211_PMSR_REQ_ATTR_DATA], rem) {
192 switch (nla_type(treq)) {
193 case NL80211_PMSR_TYPE_FTM:
194 err = pmsr_parse_ftm(rdev, treq, out, info);
195 break;
196 default:
197 NL_SET_ERR_MSG_ATTR(info->extack, treq,
198 "unsupported measurement type");
199 err = -EINVAL;
200 }
201 }
202
203 if (err)
204 return err;
205
206 return 0;
207 }
208
nl80211_pmsr_start(struct sk_buff * skb,struct genl_info * info)209 int nl80211_pmsr_start(struct sk_buff *skb, struct genl_info *info)
210 {
211 struct nlattr *reqattr = info->attrs[NL80211_ATTR_PEER_MEASUREMENTS];
212 struct cfg80211_registered_device *rdev = info->user_ptr[0];
213 struct wireless_dev *wdev = info->user_ptr[1];
214 struct cfg80211_pmsr_request *req;
215 struct nlattr *peers, *peer;
216 int count, rem, err, idx;
217
218 if (!rdev->wiphy.pmsr_capa)
219 return -EOPNOTSUPP;
220
221 if (!reqattr)
222 return -EINVAL;
223
224 peers = nla_find(nla_data(reqattr), nla_len(reqattr),
225 NL80211_PMSR_ATTR_PEERS);
226 if (!peers)
227 return -EINVAL;
228
229 count = 0;
230 nla_for_each_nested(peer, peers, rem) {
231 count++;
232
233 if (count > rdev->wiphy.pmsr_capa->max_peers) {
234 NL_SET_ERR_MSG_ATTR(info->extack, peer,
235 "Too many peers used");
236 return -EINVAL;
237 }
238 }
239
240 req = kzalloc(struct_size(req, peers, count), GFP_KERNEL);
241 if (!req)
242 return -ENOMEM;
243
244 if (info->attrs[NL80211_ATTR_TIMEOUT])
245 req->timeout = nla_get_u32(info->attrs[NL80211_ATTR_TIMEOUT]);
246
247 if (info->attrs[NL80211_ATTR_MAC]) {
248 if (!rdev->wiphy.pmsr_capa->randomize_mac_addr) {
249 NL_SET_ERR_MSG_ATTR(info->extack,
250 info->attrs[NL80211_ATTR_MAC],
251 "device cannot randomize MAC address");
252 err = -EINVAL;
253 goto out_err;
254 }
255
256 err = nl80211_parse_random_mac(info->attrs, req->mac_addr,
257 req->mac_addr_mask);
258 if (err)
259 goto out_err;
260 } else {
261 memcpy(req->mac_addr, wdev_address(wdev), ETH_ALEN);
262 eth_broadcast_addr(req->mac_addr_mask);
263 }
264
265 idx = 0;
266 nla_for_each_nested(peer, peers, rem) {
267 /* NB: this reuses info->attrs, but we no longer need it */
268 err = pmsr_parse_peer(rdev, peer, &req->peers[idx], info);
269 if (err)
270 goto out_err;
271 idx++;
272 }
273
274 req->n_peers = count;
275 req->cookie = cfg80211_assign_cookie(rdev);
276 req->nl_portid = info->snd_portid;
277
278 err = rdev_start_pmsr(rdev, wdev, req);
279 if (err)
280 goto out_err;
281
282 list_add_tail(&req->list, &wdev->pmsr_list);
283
284 nl_set_extack_cookie_u64(info->extack, req->cookie);
285 return 0;
286 out_err:
287 kfree(req);
288 return err;
289 }
290
cfg80211_pmsr_complete(struct wireless_dev * wdev,struct cfg80211_pmsr_request * req,gfp_t gfp)291 void cfg80211_pmsr_complete(struct wireless_dev *wdev,
292 struct cfg80211_pmsr_request *req,
293 gfp_t gfp)
294 {
295 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
296 struct cfg80211_pmsr_request *tmp, *prev, *to_free = NULL;
297 struct sk_buff *msg;
298 void *hdr;
299
300 trace_cfg80211_pmsr_complete(wdev->wiphy, wdev, req->cookie);
301
302 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
303 if (!msg)
304 goto free_request;
305
306 hdr = nl80211hdr_put(msg, 0, 0, 0,
307 NL80211_CMD_PEER_MEASUREMENT_COMPLETE);
308 if (!hdr)
309 goto free_msg;
310
311 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
312 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
313 NL80211_ATTR_PAD))
314 goto free_msg;
315
316 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->cookie,
317 NL80211_ATTR_PAD))
318 goto free_msg;
319
320 genlmsg_end(msg, hdr);
321 genlmsg_unicast(wiphy_net(wdev->wiphy), msg, req->nl_portid);
322 goto free_request;
323 free_msg:
324 nlmsg_free(msg);
325 free_request:
326 spin_lock_bh(&wdev->pmsr_lock);
327 /*
328 * cfg80211_pmsr_process_abort() may have already moved this request
329 * to the free list, and will free it later. In this case, don't free
330 * it here.
331 */
332 list_for_each_entry_safe(tmp, prev, &wdev->pmsr_list, list) {
333 if (tmp == req) {
334 list_del(&req->list);
335 to_free = req;
336 break;
337 }
338 }
339 spin_unlock_bh(&wdev->pmsr_lock);
340 kfree(to_free);
341 }
342 EXPORT_SYMBOL_GPL(cfg80211_pmsr_complete);
343
nl80211_pmsr_send_ftm_res(struct sk_buff * msg,struct cfg80211_pmsr_result * res)344 static int nl80211_pmsr_send_ftm_res(struct sk_buff *msg,
345 struct cfg80211_pmsr_result *res)
346 {
347 if (res->status == NL80211_PMSR_STATUS_FAILURE) {
348 if (nla_put_u32(msg, NL80211_PMSR_FTM_RESP_ATTR_FAIL_REASON,
349 res->ftm.failure_reason))
350 goto error;
351
352 if (res->ftm.failure_reason ==
353 NL80211_PMSR_FTM_FAILURE_PEER_BUSY &&
354 res->ftm.busy_retry_time &&
355 nla_put_u32(msg, NL80211_PMSR_FTM_RESP_ATTR_BUSY_RETRY_TIME,
356 res->ftm.busy_retry_time))
357 goto error;
358
359 return 0;
360 }
361
362 #define PUT(tp, attr, val) \
363 do { \
364 if (nla_put_##tp(msg, \
365 NL80211_PMSR_FTM_RESP_ATTR_##attr, \
366 res->ftm.val)) \
367 goto error; \
368 } while (0)
369
370 #define PUTOPT(tp, attr, val) \
371 do { \
372 if (res->ftm.val##_valid) \
373 PUT(tp, attr, val); \
374 } while (0)
375
376 #define PUT_U64(attr, val) \
377 do { \
378 if (nla_put_u64_64bit(msg, \
379 NL80211_PMSR_FTM_RESP_ATTR_##attr,\
380 res->ftm.val, \
381 NL80211_PMSR_FTM_RESP_ATTR_PAD)) \
382 goto error; \
383 } while (0)
384
385 #define PUTOPT_U64(attr, val) \
386 do { \
387 if (res->ftm.val##_valid) \
388 PUT_U64(attr, val); \
389 } while (0)
390
391 if (res->ftm.burst_index >= 0)
392 PUT(u32, BURST_INDEX, burst_index);
393 PUTOPT(u32, NUM_FTMR_ATTEMPTS, num_ftmr_attempts);
394 PUTOPT(u32, NUM_FTMR_SUCCESSES, num_ftmr_successes);
395 PUT(u8, NUM_BURSTS_EXP, num_bursts_exp);
396 PUT(u8, BURST_DURATION, burst_duration);
397 PUT(u8, FTMS_PER_BURST, ftms_per_burst);
398 PUTOPT(s32, RSSI_AVG, rssi_avg);
399 PUTOPT(s32, RSSI_SPREAD, rssi_spread);
400 if (res->ftm.tx_rate_valid &&
401 !nl80211_put_sta_rate(msg, &res->ftm.tx_rate,
402 NL80211_PMSR_FTM_RESP_ATTR_TX_RATE))
403 goto error;
404 if (res->ftm.rx_rate_valid &&
405 !nl80211_put_sta_rate(msg, &res->ftm.rx_rate,
406 NL80211_PMSR_FTM_RESP_ATTR_RX_RATE))
407 goto error;
408 PUTOPT_U64(RTT_AVG, rtt_avg);
409 PUTOPT_U64(RTT_VARIANCE, rtt_variance);
410 PUTOPT_U64(RTT_SPREAD, rtt_spread);
411 PUTOPT_U64(DIST_AVG, dist_avg);
412 PUTOPT_U64(DIST_VARIANCE, dist_variance);
413 PUTOPT_U64(DIST_SPREAD, dist_spread);
414 if (res->ftm.lci && res->ftm.lci_len &&
415 nla_put(msg, NL80211_PMSR_FTM_RESP_ATTR_LCI,
416 res->ftm.lci_len, res->ftm.lci))
417 goto error;
418 if (res->ftm.civicloc && res->ftm.civicloc_len &&
419 nla_put(msg, NL80211_PMSR_FTM_RESP_ATTR_CIVICLOC,
420 res->ftm.civicloc_len, res->ftm.civicloc))
421 goto error;
422 #undef PUT
423 #undef PUTOPT
424 #undef PUT_U64
425 #undef PUTOPT_U64
426
427 return 0;
428 error:
429 return -ENOSPC;
430 }
431
nl80211_pmsr_send_result(struct sk_buff * msg,struct cfg80211_pmsr_result * res)432 static int nl80211_pmsr_send_result(struct sk_buff *msg,
433 struct cfg80211_pmsr_result *res)
434 {
435 struct nlattr *pmsr, *peers, *peer, *resp, *data, *typedata;
436
437 pmsr = nla_nest_start_noflag(msg, NL80211_ATTR_PEER_MEASUREMENTS);
438 if (!pmsr)
439 goto error;
440
441 peers = nla_nest_start_noflag(msg, NL80211_PMSR_ATTR_PEERS);
442 if (!peers)
443 goto error;
444
445 peer = nla_nest_start_noflag(msg, 1);
446 if (!peer)
447 goto error;
448
449 if (nla_put(msg, NL80211_PMSR_PEER_ATTR_ADDR, ETH_ALEN, res->addr))
450 goto error;
451
452 resp = nla_nest_start_noflag(msg, NL80211_PMSR_PEER_ATTR_RESP);
453 if (!resp)
454 goto error;
455
456 if (nla_put_u32(msg, NL80211_PMSR_RESP_ATTR_STATUS, res->status) ||
457 nla_put_u64_64bit(msg, NL80211_PMSR_RESP_ATTR_HOST_TIME,
458 res->host_time, NL80211_PMSR_RESP_ATTR_PAD))
459 goto error;
460
461 if (res->ap_tsf_valid &&
462 nla_put_u64_64bit(msg, NL80211_PMSR_RESP_ATTR_AP_TSF,
463 res->ap_tsf, NL80211_PMSR_RESP_ATTR_PAD))
464 goto error;
465
466 if (res->final && nla_put_flag(msg, NL80211_PMSR_RESP_ATTR_FINAL))
467 goto error;
468
469 data = nla_nest_start_noflag(msg, NL80211_PMSR_RESP_ATTR_DATA);
470 if (!data)
471 goto error;
472
473 typedata = nla_nest_start_noflag(msg, res->type);
474 if (!typedata)
475 goto error;
476
477 switch (res->type) {
478 case NL80211_PMSR_TYPE_FTM:
479 if (nl80211_pmsr_send_ftm_res(msg, res))
480 goto error;
481 break;
482 default:
483 WARN_ON(1);
484 }
485
486 nla_nest_end(msg, typedata);
487 nla_nest_end(msg, data);
488 nla_nest_end(msg, resp);
489 nla_nest_end(msg, peer);
490 nla_nest_end(msg, peers);
491 nla_nest_end(msg, pmsr);
492
493 return 0;
494 error:
495 return -ENOSPC;
496 }
497
cfg80211_pmsr_report(struct wireless_dev * wdev,struct cfg80211_pmsr_request * req,struct cfg80211_pmsr_result * result,gfp_t gfp)498 void cfg80211_pmsr_report(struct wireless_dev *wdev,
499 struct cfg80211_pmsr_request *req,
500 struct cfg80211_pmsr_result *result,
501 gfp_t gfp)
502 {
503 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
504 struct sk_buff *msg;
505 void *hdr;
506 int err;
507
508 trace_cfg80211_pmsr_report(wdev->wiphy, wdev, req->cookie,
509 result->addr);
510
511 /*
512 * Currently, only variable items are LCI and civic location,
513 * both of which are reasonably short so we don't need to
514 * worry about them here for the allocation.
515 */
516 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
517 if (!msg)
518 return;
519
520 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PEER_MEASUREMENT_RESULT);
521 if (!hdr)
522 goto free;
523
524 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
525 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
526 NL80211_ATTR_PAD))
527 goto free;
528
529 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->cookie,
530 NL80211_ATTR_PAD))
531 goto free;
532
533 err = nl80211_pmsr_send_result(msg, result);
534 if (err) {
535 pr_err_ratelimited("peer measurement result: message didn't fit!");
536 goto free;
537 }
538
539 genlmsg_end(msg, hdr);
540 genlmsg_unicast(wiphy_net(wdev->wiphy), msg, req->nl_portid);
541 return;
542 free:
543 nlmsg_free(msg);
544 }
545 EXPORT_SYMBOL_GPL(cfg80211_pmsr_report);
546
cfg80211_pmsr_process_abort(struct wireless_dev * wdev)547 static void cfg80211_pmsr_process_abort(struct wireless_dev *wdev)
548 {
549 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
550 struct cfg80211_pmsr_request *req, *tmp;
551 LIST_HEAD(free_list);
552
553 lockdep_assert_held(&wdev->mtx);
554
555 spin_lock_bh(&wdev->pmsr_lock);
556 list_for_each_entry_safe(req, tmp, &wdev->pmsr_list, list) {
557 if (req->nl_portid)
558 continue;
559 list_move_tail(&req->list, &free_list);
560 }
561 spin_unlock_bh(&wdev->pmsr_lock);
562
563 list_for_each_entry_safe(req, tmp, &free_list, list) {
564 rdev_abort_pmsr(rdev, wdev, req);
565
566 kfree(req);
567 }
568 }
569
cfg80211_pmsr_free_wk(struct work_struct * work)570 void cfg80211_pmsr_free_wk(struct work_struct *work)
571 {
572 struct wireless_dev *wdev = container_of(work, struct wireless_dev,
573 pmsr_free_wk);
574
575 wdev_lock(wdev);
576 cfg80211_pmsr_process_abort(wdev);
577 wdev_unlock(wdev);
578 }
579
cfg80211_pmsr_wdev_down(struct wireless_dev * wdev)580 void cfg80211_pmsr_wdev_down(struct wireless_dev *wdev)
581 {
582 struct cfg80211_pmsr_request *req;
583 bool found = false;
584
585 spin_lock_bh(&wdev->pmsr_lock);
586 list_for_each_entry(req, &wdev->pmsr_list, list) {
587 found = true;
588 req->nl_portid = 0;
589 }
590 spin_unlock_bh(&wdev->pmsr_lock);
591
592 if (found)
593 cfg80211_pmsr_process_abort(wdev);
594
595 WARN_ON(!list_empty(&wdev->pmsr_list));
596 }
597
cfg80211_release_pmsr(struct wireless_dev * wdev,u32 portid)598 void cfg80211_release_pmsr(struct wireless_dev *wdev, u32 portid)
599 {
600 struct cfg80211_pmsr_request *req;
601
602 spin_lock_bh(&wdev->pmsr_lock);
603 list_for_each_entry(req, &wdev->pmsr_list, list) {
604 if (req->nl_portid == portid) {
605 req->nl_portid = 0;
606 schedule_work(&wdev->pmsr_free_wk);
607 }
608 }
609 spin_unlock_bh(&wdev->pmsr_lock);
610 }
611
612 #endif /* __PMSR_H */
613