1 // SPDX-License-Identifier: ISC
2 /* Copyright (C) 2020 Felix Fietkau <nbd@nbd.name> */
3 #include "mt76.h"
4
5 const struct nla_policy mt76_tm_policy[NUM_MT76_TM_ATTRS] = {
6 [MT76_TM_ATTR_RESET] = { .type = NLA_FLAG },
7 [MT76_TM_ATTR_STATE] = { .type = NLA_U8 },
8 [MT76_TM_ATTR_TX_COUNT] = { .type = NLA_U32 },
9 [MT76_TM_ATTR_TX_RATE_MODE] = { .type = NLA_U8 },
10 [MT76_TM_ATTR_TX_RATE_NSS] = { .type = NLA_U8 },
11 [MT76_TM_ATTR_TX_RATE_IDX] = { .type = NLA_U8 },
12 [MT76_TM_ATTR_TX_RATE_SGI] = { .type = NLA_U8 },
13 [MT76_TM_ATTR_TX_RATE_LDPC] = { .type = NLA_U8 },
14 [MT76_TM_ATTR_TX_RATE_STBC] = { .type = NLA_U8 },
15 [MT76_TM_ATTR_TX_LTF] = { .type = NLA_U8 },
16 [MT76_TM_ATTR_TX_ANTENNA] = { .type = NLA_U8 },
17 [MT76_TM_ATTR_TX_SPE_IDX] = { .type = NLA_U8 },
18 [MT76_TM_ATTR_TX_POWER_CONTROL] = { .type = NLA_U8 },
19 [MT76_TM_ATTR_TX_POWER] = { .type = NLA_NESTED },
20 [MT76_TM_ATTR_TX_DUTY_CYCLE] = { .type = NLA_U8 },
21 [MT76_TM_ATTR_TX_IPG] = { .type = NLA_U32 },
22 [MT76_TM_ATTR_TX_TIME] = { .type = NLA_U32 },
23 [MT76_TM_ATTR_FREQ_OFFSET] = { .type = NLA_U32 },
24 [MT76_TM_ATTR_DRV_DATA] = { .type = NLA_NESTED },
25 };
26 EXPORT_SYMBOL_GPL(mt76_tm_policy);
27
mt76_testmode_tx_pending(struct mt76_phy * phy)28 void mt76_testmode_tx_pending(struct mt76_phy *phy)
29 {
30 struct mt76_testmode_data *td = &phy->test;
31 struct mt76_dev *dev = phy->dev;
32 struct mt76_wcid *wcid = &dev->global_wcid;
33 struct sk_buff *skb = td->tx_skb;
34 struct mt76_queue *q;
35 u16 tx_queued_limit;
36 int qid;
37
38 if (!skb || !td->tx_pending)
39 return;
40
41 qid = skb_get_queue_mapping(skb);
42 q = phy->q_tx[qid];
43
44 tx_queued_limit = td->tx_queued_limit ? td->tx_queued_limit : 1000;
45
46 spin_lock_bh(&q->lock);
47
48 while (td->tx_pending > 0 &&
49 td->tx_queued - td->tx_done < tx_queued_limit &&
50 q->queued < q->ndesc / 2) {
51 int ret;
52
53 ret = dev->queue_ops->tx_queue_skb(dev, q, skb_get(skb), wcid,
54 NULL);
55 if (ret < 0)
56 break;
57
58 td->tx_pending--;
59 td->tx_queued++;
60 }
61
62 dev->queue_ops->kick(dev, q);
63
64 spin_unlock_bh(&q->lock);
65 }
66
67 static u32
mt76_testmode_max_mpdu_len(struct mt76_phy * phy,u8 tx_rate_mode)68 mt76_testmode_max_mpdu_len(struct mt76_phy *phy, u8 tx_rate_mode)
69 {
70 switch (tx_rate_mode) {
71 case MT76_TM_TX_MODE_HT:
72 return IEEE80211_MAX_MPDU_LEN_HT_7935;
73 case MT76_TM_TX_MODE_VHT:
74 case MT76_TM_TX_MODE_HE_SU:
75 case MT76_TM_TX_MODE_HE_EXT_SU:
76 case MT76_TM_TX_MODE_HE_TB:
77 case MT76_TM_TX_MODE_HE_MU:
78 if (phy->sband_5g.sband.vht_cap.cap &
79 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991)
80 return IEEE80211_MAX_MPDU_LEN_VHT_7991;
81 return IEEE80211_MAX_MPDU_LEN_VHT_11454;
82 case MT76_TM_TX_MODE_CCK:
83 case MT76_TM_TX_MODE_OFDM:
84 default:
85 return IEEE80211_MAX_FRAME_LEN;
86 }
87 }
88
89 static void
mt76_testmode_free_skb(struct mt76_phy * phy)90 mt76_testmode_free_skb(struct mt76_phy *phy)
91 {
92 struct mt76_testmode_data *td = &phy->test;
93
94 dev_kfree_skb(td->tx_skb);
95 td->tx_skb = NULL;
96 }
97
mt76_testmode_alloc_skb(struct mt76_phy * phy,u32 len)98 int mt76_testmode_alloc_skb(struct mt76_phy *phy, u32 len)
99 {
100 #define MT_TXP_MAX_LEN 4095
101 u16 fc = IEEE80211_FTYPE_DATA | IEEE80211_STYPE_DATA |
102 IEEE80211_FCTL_FROMDS;
103 struct mt76_testmode_data *td = &phy->test;
104 bool ext_phy = phy != &phy->dev->phy;
105 struct sk_buff **frag_tail, *head;
106 struct ieee80211_tx_info *info;
107 struct ieee80211_hdr *hdr;
108 u32 max_len, head_len;
109 int nfrags, i;
110
111 max_len = mt76_testmode_max_mpdu_len(phy, td->tx_rate_mode);
112 if (len > max_len)
113 len = max_len;
114 else if (len < sizeof(struct ieee80211_hdr))
115 len = sizeof(struct ieee80211_hdr);
116
117 nfrags = len / MT_TXP_MAX_LEN;
118 head_len = nfrags ? MT_TXP_MAX_LEN : len;
119
120 if (len > IEEE80211_MAX_FRAME_LEN)
121 fc |= IEEE80211_STYPE_QOS_DATA;
122
123 head = alloc_skb(head_len, GFP_KERNEL);
124 if (!head)
125 return -ENOMEM;
126
127 hdr = __skb_put_zero(head, head_len);
128 hdr->frame_control = cpu_to_le16(fc);
129 memcpy(hdr->addr1, td->addr[0], ETH_ALEN);
130 memcpy(hdr->addr2, td->addr[1], ETH_ALEN);
131 memcpy(hdr->addr3, td->addr[2], ETH_ALEN);
132 skb_set_queue_mapping(head, IEEE80211_AC_BE);
133
134 info = IEEE80211_SKB_CB(head);
135 info->flags = IEEE80211_TX_CTL_INJECTED |
136 IEEE80211_TX_CTL_NO_ACK |
137 IEEE80211_TX_CTL_NO_PS_BUFFER;
138
139 if (ext_phy)
140 info->hw_queue |= MT_TX_HW_QUEUE_EXT_PHY;
141
142 frag_tail = &skb_shinfo(head)->frag_list;
143
144 for (i = 0; i < nfrags; i++) {
145 struct sk_buff *frag;
146 u16 frag_len;
147
148 if (i == nfrags - 1)
149 frag_len = len % MT_TXP_MAX_LEN;
150 else
151 frag_len = MT_TXP_MAX_LEN;
152
153 frag = alloc_skb(frag_len, GFP_KERNEL);
154 if (!frag) {
155 mt76_testmode_free_skb(phy);
156 dev_kfree_skb(head);
157 return -ENOMEM;
158 }
159
160 __skb_put_zero(frag, frag_len);
161 head->len += frag->len;
162 head->data_len += frag->len;
163
164 *frag_tail = frag;
165 frag_tail = &(*frag_tail)->next;
166 }
167
168 mt76_testmode_free_skb(phy);
169 td->tx_skb = head;
170
171 return 0;
172 }
173 EXPORT_SYMBOL(mt76_testmode_alloc_skb);
174
175 static int
mt76_testmode_tx_init(struct mt76_phy * phy)176 mt76_testmode_tx_init(struct mt76_phy *phy)
177 {
178 struct mt76_testmode_data *td = &phy->test;
179 struct ieee80211_tx_info *info;
180 struct ieee80211_tx_rate *rate;
181 u8 max_nss = hweight8(phy->antenna_mask);
182 int ret;
183
184 ret = mt76_testmode_alloc_skb(phy, td->tx_mpdu_len);
185 if (ret)
186 return ret;
187
188 if (td->tx_rate_mode > MT76_TM_TX_MODE_VHT)
189 goto out;
190
191 if (td->tx_antenna_mask)
192 max_nss = min_t(u8, max_nss, hweight8(td->tx_antenna_mask));
193
194 info = IEEE80211_SKB_CB(td->tx_skb);
195 rate = &info->control.rates[0];
196 rate->count = 1;
197 rate->idx = td->tx_rate_idx;
198
199 switch (td->tx_rate_mode) {
200 case MT76_TM_TX_MODE_CCK:
201 if (phy->chandef.chan->band != NL80211_BAND_2GHZ)
202 return -EINVAL;
203
204 if (rate->idx > 4)
205 return -EINVAL;
206 break;
207 case MT76_TM_TX_MODE_OFDM:
208 if (phy->chandef.chan->band != NL80211_BAND_2GHZ)
209 break;
210
211 if (rate->idx > 8)
212 return -EINVAL;
213
214 rate->idx += 4;
215 break;
216 case MT76_TM_TX_MODE_HT:
217 if (rate->idx > 8 * max_nss &&
218 !(rate->idx == 32 &&
219 phy->chandef.width >= NL80211_CHAN_WIDTH_40))
220 return -EINVAL;
221
222 rate->flags |= IEEE80211_TX_RC_MCS;
223 break;
224 case MT76_TM_TX_MODE_VHT:
225 if (rate->idx > 9)
226 return -EINVAL;
227
228 if (td->tx_rate_nss > max_nss)
229 return -EINVAL;
230
231 ieee80211_rate_set_vht(rate, td->tx_rate_idx, td->tx_rate_nss);
232 rate->flags |= IEEE80211_TX_RC_VHT_MCS;
233 break;
234 default:
235 break;
236 }
237
238 if (td->tx_rate_sgi)
239 rate->flags |= IEEE80211_TX_RC_SHORT_GI;
240
241 if (td->tx_rate_ldpc)
242 info->flags |= IEEE80211_TX_CTL_LDPC;
243
244 if (td->tx_rate_stbc)
245 info->flags |= IEEE80211_TX_CTL_STBC;
246
247 if (td->tx_rate_mode >= MT76_TM_TX_MODE_HT) {
248 switch (phy->chandef.width) {
249 case NL80211_CHAN_WIDTH_40:
250 rate->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
251 break;
252 case NL80211_CHAN_WIDTH_80:
253 rate->flags |= IEEE80211_TX_RC_80_MHZ_WIDTH;
254 break;
255 case NL80211_CHAN_WIDTH_80P80:
256 case NL80211_CHAN_WIDTH_160:
257 rate->flags |= IEEE80211_TX_RC_160_MHZ_WIDTH;
258 break;
259 default:
260 break;
261 }
262 }
263 out:
264 return 0;
265 }
266
267 static void
mt76_testmode_tx_start(struct mt76_phy * phy)268 mt76_testmode_tx_start(struct mt76_phy *phy)
269 {
270 struct mt76_testmode_data *td = &phy->test;
271 struct mt76_dev *dev = phy->dev;
272
273 td->tx_queued = 0;
274 td->tx_done = 0;
275 td->tx_pending = td->tx_count;
276 mt76_worker_schedule(&dev->tx_worker);
277 }
278
279 static void
mt76_testmode_tx_stop(struct mt76_phy * phy)280 mt76_testmode_tx_stop(struct mt76_phy *phy)
281 {
282 struct mt76_testmode_data *td = &phy->test;
283 struct mt76_dev *dev = phy->dev;
284
285 mt76_worker_disable(&dev->tx_worker);
286
287 td->tx_pending = 0;
288
289 mt76_worker_enable(&dev->tx_worker);
290
291 wait_event_timeout(dev->tx_wait, td->tx_done == td->tx_queued,
292 MT76_TM_TIMEOUT * HZ);
293
294 mt76_testmode_free_skb(phy);
295 }
296
297 static inline void
mt76_testmode_param_set(struct mt76_testmode_data * td,u16 idx)298 mt76_testmode_param_set(struct mt76_testmode_data *td, u16 idx)
299 {
300 td->param_set[idx / 32] |= BIT(idx % 32);
301 }
302
303 static inline bool
mt76_testmode_param_present(struct mt76_testmode_data * td,u16 idx)304 mt76_testmode_param_present(struct mt76_testmode_data *td, u16 idx)
305 {
306 return td->param_set[idx / 32] & BIT(idx % 32);
307 }
308
309 static void
mt76_testmode_init_defaults(struct mt76_phy * phy)310 mt76_testmode_init_defaults(struct mt76_phy *phy)
311 {
312 struct mt76_testmode_data *td = &phy->test;
313
314 if (td->tx_mpdu_len > 0)
315 return;
316
317 td->tx_mpdu_len = 1024;
318 td->tx_count = 1;
319 td->tx_rate_mode = MT76_TM_TX_MODE_OFDM;
320 td->tx_rate_nss = 1;
321
322 memcpy(td->addr[0], phy->macaddr, ETH_ALEN);
323 memcpy(td->addr[1], phy->macaddr, ETH_ALEN);
324 memcpy(td->addr[2], phy->macaddr, ETH_ALEN);
325 }
326
327 static int
__mt76_testmode_set_state(struct mt76_phy * phy,enum mt76_testmode_state state)328 __mt76_testmode_set_state(struct mt76_phy *phy, enum mt76_testmode_state state)
329 {
330 enum mt76_testmode_state prev_state = phy->test.state;
331 struct mt76_dev *dev = phy->dev;
332 int err;
333
334 if (prev_state == MT76_TM_STATE_TX_FRAMES)
335 mt76_testmode_tx_stop(phy);
336
337 if (state == MT76_TM_STATE_TX_FRAMES) {
338 err = mt76_testmode_tx_init(phy);
339 if (err)
340 return err;
341 }
342
343 err = dev->test_ops->set_state(phy, state);
344 if (err) {
345 if (state == MT76_TM_STATE_TX_FRAMES)
346 mt76_testmode_tx_stop(phy);
347
348 return err;
349 }
350
351 if (state == MT76_TM_STATE_TX_FRAMES)
352 mt76_testmode_tx_start(phy);
353 else if (state == MT76_TM_STATE_RX_FRAMES) {
354 memset(&phy->test.rx_stats, 0, sizeof(phy->test.rx_stats));
355 }
356
357 phy->test.state = state;
358
359 return 0;
360 }
361
mt76_testmode_set_state(struct mt76_phy * phy,enum mt76_testmode_state state)362 int mt76_testmode_set_state(struct mt76_phy *phy, enum mt76_testmode_state state)
363 {
364 struct mt76_testmode_data *td = &phy->test;
365 struct ieee80211_hw *hw = phy->hw;
366
367 if (state == td->state && state == MT76_TM_STATE_OFF)
368 return 0;
369
370 if (state > MT76_TM_STATE_OFF &&
371 (!test_bit(MT76_STATE_RUNNING, &phy->state) ||
372 !(hw->conf.flags & IEEE80211_CONF_MONITOR)))
373 return -ENOTCONN;
374
375 if (state != MT76_TM_STATE_IDLE &&
376 td->state != MT76_TM_STATE_IDLE) {
377 int ret;
378
379 ret = __mt76_testmode_set_state(phy, MT76_TM_STATE_IDLE);
380 if (ret)
381 return ret;
382 }
383
384 return __mt76_testmode_set_state(phy, state);
385
386 }
387 EXPORT_SYMBOL(mt76_testmode_set_state);
388
389 static int
mt76_tm_get_u8(struct nlattr * attr,u8 * dest,u8 min,u8 max)390 mt76_tm_get_u8(struct nlattr *attr, u8 *dest, u8 min, u8 max)
391 {
392 u8 val;
393
394 if (!attr)
395 return 0;
396
397 val = nla_get_u8(attr);
398 if (val < min || val > max)
399 return -EINVAL;
400
401 *dest = val;
402 return 0;
403 }
404
mt76_testmode_cmd(struct ieee80211_hw * hw,struct ieee80211_vif * vif,void * data,int len)405 int mt76_testmode_cmd(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
406 void *data, int len)
407 {
408 struct mt76_phy *phy = hw->priv;
409 struct mt76_dev *dev = phy->dev;
410 struct mt76_testmode_data *td = &phy->test;
411 struct nlattr *tb[NUM_MT76_TM_ATTRS];
412 u32 state;
413 int err;
414 int i;
415
416 if (!dev->test_ops)
417 return -EOPNOTSUPP;
418
419 err = nla_parse_deprecated(tb, MT76_TM_ATTR_MAX, data, len,
420 mt76_tm_policy, NULL);
421 if (err)
422 return err;
423
424 err = -EINVAL;
425
426 mutex_lock(&dev->mutex);
427
428 if (tb[MT76_TM_ATTR_RESET]) {
429 mt76_testmode_set_state(phy, MT76_TM_STATE_OFF);
430 memset(td, 0, sizeof(*td));
431 }
432
433 mt76_testmode_init_defaults(phy);
434
435 if (tb[MT76_TM_ATTR_TX_COUNT])
436 td->tx_count = nla_get_u32(tb[MT76_TM_ATTR_TX_COUNT]);
437
438 if (tb[MT76_TM_ATTR_TX_RATE_IDX])
439 td->tx_rate_idx = nla_get_u8(tb[MT76_TM_ATTR_TX_RATE_IDX]);
440
441 if (mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_RATE_MODE], &td->tx_rate_mode,
442 0, MT76_TM_TX_MODE_MAX) ||
443 mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_RATE_NSS], &td->tx_rate_nss,
444 1, hweight8(phy->antenna_mask)) ||
445 mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_RATE_SGI], &td->tx_rate_sgi, 0, 2) ||
446 mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_RATE_LDPC], &td->tx_rate_ldpc, 0, 1) ||
447 mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_RATE_STBC], &td->tx_rate_stbc, 0, 1) ||
448 mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_LTF], &td->tx_ltf, 0, 2) ||
449 mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_ANTENNA],
450 &td->tx_antenna_mask, 0, 0xff) ||
451 mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_SPE_IDX], &td->tx_spe_idx, 0, 27) ||
452 mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_DUTY_CYCLE],
453 &td->tx_duty_cycle, 0, 99) ||
454 mt76_tm_get_u8(tb[MT76_TM_ATTR_TX_POWER_CONTROL],
455 &td->tx_power_control, 0, 1))
456 goto out;
457
458 if (tb[MT76_TM_ATTR_TX_LENGTH]) {
459 u32 val = nla_get_u32(tb[MT76_TM_ATTR_TX_LENGTH]);
460
461 if (val > mt76_testmode_max_mpdu_len(phy, td->tx_rate_mode) ||
462 val < sizeof(struct ieee80211_hdr))
463 goto out;
464
465 td->tx_mpdu_len = val;
466 }
467
468 if (tb[MT76_TM_ATTR_TX_IPG])
469 td->tx_ipg = nla_get_u32(tb[MT76_TM_ATTR_TX_IPG]);
470
471 if (tb[MT76_TM_ATTR_TX_TIME])
472 td->tx_time = nla_get_u32(tb[MT76_TM_ATTR_TX_TIME]);
473
474 if (tb[MT76_TM_ATTR_FREQ_OFFSET])
475 td->freq_offset = nla_get_u32(tb[MT76_TM_ATTR_FREQ_OFFSET]);
476
477 if (tb[MT76_TM_ATTR_STATE]) {
478 state = nla_get_u32(tb[MT76_TM_ATTR_STATE]);
479 if (state > MT76_TM_STATE_MAX)
480 goto out;
481 } else {
482 state = td->state;
483 }
484
485 if (tb[MT76_TM_ATTR_TX_POWER]) {
486 struct nlattr *cur;
487 int idx = 0;
488 int rem;
489
490 nla_for_each_nested(cur, tb[MT76_TM_ATTR_TX_POWER], rem) {
491 if (nla_len(cur) != 1 ||
492 idx >= ARRAY_SIZE(td->tx_power))
493 goto out;
494
495 td->tx_power[idx++] = nla_get_u8(cur);
496 }
497 }
498
499 if (tb[MT76_TM_ATTR_MAC_ADDRS]) {
500 struct nlattr *cur;
501 int idx = 0;
502 int rem;
503
504 nla_for_each_nested(cur, tb[MT76_TM_ATTR_MAC_ADDRS], rem) {
505 if (nla_len(cur) != ETH_ALEN || idx >= 3)
506 goto out;
507
508 memcpy(td->addr[idx], nla_data(cur), ETH_ALEN);
509 idx++;
510 }
511 }
512
513 if (dev->test_ops->set_params) {
514 err = dev->test_ops->set_params(phy, tb, state);
515 if (err)
516 goto out;
517 }
518
519 for (i = MT76_TM_ATTR_STATE; i < ARRAY_SIZE(tb); i++)
520 if (tb[i])
521 mt76_testmode_param_set(td, i);
522
523 err = 0;
524 if (tb[MT76_TM_ATTR_STATE])
525 err = mt76_testmode_set_state(phy, state);
526
527 out:
528 mutex_unlock(&dev->mutex);
529
530 return err;
531 }
532 EXPORT_SYMBOL(mt76_testmode_cmd);
533
534 static int
mt76_testmode_dump_stats(struct mt76_phy * phy,struct sk_buff * msg)535 mt76_testmode_dump_stats(struct mt76_phy *phy, struct sk_buff *msg)
536 {
537 struct mt76_testmode_data *td = &phy->test;
538 struct mt76_dev *dev = phy->dev;
539 u64 rx_packets = 0;
540 u64 rx_fcs_error = 0;
541 int i;
542
543 if (dev->test_ops->dump_stats) {
544 int ret;
545
546 ret = dev->test_ops->dump_stats(phy, msg);
547 if (ret)
548 return ret;
549 }
550
551 for (i = 0; i < ARRAY_SIZE(td->rx_stats.packets); i++) {
552 rx_packets += td->rx_stats.packets[i];
553 rx_fcs_error += td->rx_stats.fcs_error[i];
554 }
555
556 if (nla_put_u32(msg, MT76_TM_STATS_ATTR_TX_PENDING, td->tx_pending) ||
557 nla_put_u32(msg, MT76_TM_STATS_ATTR_TX_QUEUED, td->tx_queued) ||
558 nla_put_u32(msg, MT76_TM_STATS_ATTR_TX_DONE, td->tx_done) ||
559 nla_put_u64_64bit(msg, MT76_TM_STATS_ATTR_RX_PACKETS, rx_packets,
560 MT76_TM_STATS_ATTR_PAD) ||
561 nla_put_u64_64bit(msg, MT76_TM_STATS_ATTR_RX_FCS_ERROR, rx_fcs_error,
562 MT76_TM_STATS_ATTR_PAD))
563 return -EMSGSIZE;
564
565 return 0;
566 }
567
mt76_testmode_dump(struct ieee80211_hw * hw,struct sk_buff * msg,struct netlink_callback * cb,void * data,int len)568 int mt76_testmode_dump(struct ieee80211_hw *hw, struct sk_buff *msg,
569 struct netlink_callback *cb, void *data, int len)
570 {
571 struct mt76_phy *phy = hw->priv;
572 struct mt76_dev *dev = phy->dev;
573 struct mt76_testmode_data *td = &phy->test;
574 struct nlattr *tb[NUM_MT76_TM_ATTRS] = {};
575 int err = 0;
576 void *a;
577 int i;
578
579 if (!dev->test_ops)
580 return -EOPNOTSUPP;
581
582 if (cb->args[2]++ > 0)
583 return -ENOENT;
584
585 if (data) {
586 err = nla_parse_deprecated(tb, MT76_TM_ATTR_MAX, data, len,
587 mt76_tm_policy, NULL);
588 if (err)
589 return err;
590 }
591
592 mutex_lock(&dev->mutex);
593
594 if (tb[MT76_TM_ATTR_STATS]) {
595 err = -EINVAL;
596
597 a = nla_nest_start(msg, MT76_TM_ATTR_STATS);
598 if (a) {
599 err = mt76_testmode_dump_stats(phy, msg);
600 nla_nest_end(msg, a);
601 }
602
603 goto out;
604 }
605
606 mt76_testmode_init_defaults(phy);
607
608 err = -EMSGSIZE;
609 if (nla_put_u32(msg, MT76_TM_ATTR_STATE, td->state))
610 goto out;
611
612 if (dev->test_mtd.name &&
613 (nla_put_string(msg, MT76_TM_ATTR_MTD_PART, dev->test_mtd.name) ||
614 nla_put_u32(msg, MT76_TM_ATTR_MTD_OFFSET, dev->test_mtd.offset)))
615 goto out;
616
617 if (nla_put_u32(msg, MT76_TM_ATTR_TX_COUNT, td->tx_count) ||
618 nla_put_u32(msg, MT76_TM_ATTR_TX_LENGTH, td->tx_mpdu_len) ||
619 nla_put_u8(msg, MT76_TM_ATTR_TX_RATE_MODE, td->tx_rate_mode) ||
620 nla_put_u8(msg, MT76_TM_ATTR_TX_RATE_NSS, td->tx_rate_nss) ||
621 nla_put_u8(msg, MT76_TM_ATTR_TX_RATE_IDX, td->tx_rate_idx) ||
622 nla_put_u8(msg, MT76_TM_ATTR_TX_RATE_SGI, td->tx_rate_sgi) ||
623 nla_put_u8(msg, MT76_TM_ATTR_TX_RATE_LDPC, td->tx_rate_ldpc) ||
624 nla_put_u8(msg, MT76_TM_ATTR_TX_RATE_STBC, td->tx_rate_stbc) ||
625 (mt76_testmode_param_present(td, MT76_TM_ATTR_TX_LTF) &&
626 nla_put_u8(msg, MT76_TM_ATTR_TX_LTF, td->tx_ltf)) ||
627 (mt76_testmode_param_present(td, MT76_TM_ATTR_TX_ANTENNA) &&
628 nla_put_u8(msg, MT76_TM_ATTR_TX_ANTENNA, td->tx_antenna_mask)) ||
629 (mt76_testmode_param_present(td, MT76_TM_ATTR_TX_SPE_IDX) &&
630 nla_put_u8(msg, MT76_TM_ATTR_TX_SPE_IDX, td->tx_spe_idx)) ||
631 (mt76_testmode_param_present(td, MT76_TM_ATTR_TX_DUTY_CYCLE) &&
632 nla_put_u8(msg, MT76_TM_ATTR_TX_DUTY_CYCLE, td->tx_duty_cycle)) ||
633 (mt76_testmode_param_present(td, MT76_TM_ATTR_TX_IPG) &&
634 nla_put_u32(msg, MT76_TM_ATTR_TX_IPG, td->tx_ipg)) ||
635 (mt76_testmode_param_present(td, MT76_TM_ATTR_TX_TIME) &&
636 nla_put_u32(msg, MT76_TM_ATTR_TX_TIME, td->tx_time)) ||
637 (mt76_testmode_param_present(td, MT76_TM_ATTR_TX_POWER_CONTROL) &&
638 nla_put_u8(msg, MT76_TM_ATTR_TX_POWER_CONTROL, td->tx_power_control)) ||
639 (mt76_testmode_param_present(td, MT76_TM_ATTR_FREQ_OFFSET) &&
640 nla_put_u8(msg, MT76_TM_ATTR_FREQ_OFFSET, td->freq_offset)))
641 goto out;
642
643 if (mt76_testmode_param_present(td, MT76_TM_ATTR_TX_POWER)) {
644 a = nla_nest_start(msg, MT76_TM_ATTR_TX_POWER);
645 if (!a)
646 goto out;
647
648 for (i = 0; i < ARRAY_SIZE(td->tx_power); i++)
649 if (nla_put_u8(msg, i, td->tx_power[i]))
650 goto out;
651
652 nla_nest_end(msg, a);
653 }
654
655 if (mt76_testmode_param_present(td, MT76_TM_ATTR_MAC_ADDRS)) {
656 a = nla_nest_start(msg, MT76_TM_ATTR_MAC_ADDRS);
657 if (!a)
658 goto out;
659
660 for (i = 0; i < 3; i++)
661 if (nla_put(msg, i, ETH_ALEN, td->addr[i]))
662 goto out;
663
664 nla_nest_end(msg, a);
665 }
666
667 err = 0;
668
669 out:
670 mutex_unlock(&dev->mutex);
671
672 return err;
673 }
674 EXPORT_SYMBOL(mt76_testmode_dump);
675