Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
wifi: mt76: mt7915: add bf backoff limit table support
The commit 22b980badc0f ("mt76: add functions for parsing rate power limits
from DT") introduced generic support for rates limits in the devicetree.
But the mt7915 supports beamforming and has another table for configuring
the backoff limits. These can be configured in the DT with the paths-*
properties. The path-*-bf are the ones relevant for beamforming and the
ones without -bf suffix for "traditional" path backoff.
Signed-off-by: Shayne Chen <shayne.chen@mediatek.com>
Signed-off-by: Sven Eckelmann (Plasma Cloud) <se@simonwunderlich.de>
Link: https://patch.msgid.link/20251007-backoff-table-support-v3-3-fd6e2684988f@simonwunderlich.de
Signed-off-by: Felix Fietkau <nbd@nbd.name>
authored by
Shayne Chen
and committed by
Felix Fietkau
b05ab4be
6b9833c6
+277
-55
+2
-2
drivers/net/wireless/mediatek/mt76/debugfs.c
+2
-2
drivers/net/wireless/mediatek/mt76/debugfs.c
···
93
93
{
94
94
int i;
95
95
96
-
seq_printf(file, "%10s:", str);
96
+
seq_printf(file, "%16s:", str);
97
97
for (i = 0; i < len; i++)
98
-
seq_printf(file, " %2d", val[i]);
98
+
seq_printf(file, " %4d", val[i]);
99
99
seq_puts(file, "\n");
100
100
}
101
101
EXPORT_SYMBOL_GPL(mt76_seq_puts_array);
+33
-5
drivers/net/wireless/mediatek/mt76/eeprom.c
+33
-5
drivers/net/wireless/mediatek/mt76/eeprom.c
···
324
324
static void
325
325
mt76_apply_multi_array_limit(s8 *pwr, size_t pwr_len, s8 pwr_num,
326
326
const s8 *data, size_t len, s8 target_power,
327
-
s8 nss_delta, s8 *max_power)
327
+
s8 nss_delta)
328
328
{
329
329
int i, cur;
330
+
s8 max_power = -128;
330
331
331
332
if (!data)
332
333
return;
···
338
337
break;
339
338
340
339
mt76_apply_array_limit(pwr + pwr_len * i, pwr_len, data + 1,
341
-
target_power, nss_delta, max_power);
340
+
target_power, nss_delta, &max_power);
342
341
if (--cur > 0)
343
342
continue;
344
343
···
365
364
char band;
366
365
size_t len;
367
366
s8 max_power = 0;
367
+
s8 max_power_backoff = -127;
368
368
s8 txs_delta;
369
+
int n_chains = hweight16(phy->chainmask);
370
+
s8 target_power_combine = target_power + mt76_tx_power_path_delta(n_chains);
369
371
370
372
if (!mcs_rates)
371
373
mcs_rates = 10;
372
374
373
-
memset(dest, target_power, sizeof(*dest));
375
+
memset(dest, target_power, sizeof(*dest) - sizeof(dest->path));
376
+
memset(&dest->path, 0, sizeof(dest->path));
374
377
375
378
if (!IS_ENABLED(CONFIG_OF))
376
379
return target_power;
···
420
415
val = mt76_get_of_array_s8(np, "rates-mcs", &len, mcs_rates + 1);
421
416
mt76_apply_multi_array_limit(dest->mcs[0], ARRAY_SIZE(dest->mcs[0]),
422
417
ARRAY_SIZE(dest->mcs), val, len,
423
-
target_power, txs_delta, &max_power);
418
+
target_power, txs_delta);
424
419
425
420
val = mt76_get_of_array_s8(np, "rates-ru", &len, ru_rates + 1);
426
421
mt76_apply_multi_array_limit(dest->ru[0], ARRAY_SIZE(dest->ru[0]),
427
422
ARRAY_SIZE(dest->ru), val, len,
428
-
target_power, txs_delta, &max_power);
423
+
target_power, txs_delta);
424
+
425
+
max_power_backoff = max_power;
426
+
val = mt76_get_of_array_s8(np, "paths-cck", &len, ARRAY_SIZE(dest->path.cck));
427
+
mt76_apply_array_limit(dest->path.cck, ARRAY_SIZE(dest->path.cck), val,
428
+
target_power_combine, txs_delta, &max_power_backoff);
429
+
430
+
val = mt76_get_of_array_s8(np, "paths-ofdm", &len, ARRAY_SIZE(dest->path.ofdm));
431
+
mt76_apply_array_limit(dest->path.ofdm, ARRAY_SIZE(dest->path.ofdm), val,
432
+
target_power_combine, txs_delta, &max_power_backoff);
433
+
434
+
val = mt76_get_of_array_s8(np, "paths-ofdm-bf", &len, ARRAY_SIZE(dest->path.ofdm_bf));
435
+
mt76_apply_array_limit(dest->path.ofdm_bf, ARRAY_SIZE(dest->path.ofdm_bf), val,
436
+
target_power_combine, txs_delta, &max_power_backoff);
437
+
438
+
val = mt76_get_of_array_s8(np, "paths-ru", &len, ARRAY_SIZE(dest->path.ru[0]) + 1);
439
+
mt76_apply_multi_array_limit(dest->path.ru[0], ARRAY_SIZE(dest->path.ru[0]),
440
+
ARRAY_SIZE(dest->path.ru), val, len,
441
+
target_power_combine, txs_delta);
442
+
443
+
val = mt76_get_of_array_s8(np, "paths-ru-bf", &len, ARRAY_SIZE(dest->path.ru_bf[0]) + 1);
444
+
mt76_apply_multi_array_limit(dest->path.ru_bf[0], ARRAY_SIZE(dest->path.ru_bf[0]),
445
+
ARRAY_SIZE(dest->path.ru_bf), val, len,
446
+
target_power_combine, txs_delta);
429
447
430
448
return max_power;
431
449
}
+8
drivers/net/wireless/mediatek/mt76/mt76.h
+8
drivers/net/wireless/mediatek/mt76/mt76.h
+70
-4
drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c
+70
-4
drivers/net/wireless/mediatek/mt76/mt7915/debugfs.c
···
1008
1008
if (!buf)
1009
1009
return -ENOMEM;
1010
1010
1011
-
ret = mt7915_mcu_get_txpower_sku(phy, txpwr, sizeof(txpwr));
1011
+
ret = mt7915_mcu_get_txpower_sku(phy, txpwr, sizeof(txpwr), TX_POWER_INFO_RATE);
1012
1012
if (ret)
1013
1013
goto out;
1014
1014
···
1118
1118
1119
1119
mutex_lock(&dev->mt76.mutex);
1120
1120
ret = mt7915_mcu_get_txpower_sku(phy, req.txpower_sku,
1121
-
sizeof(req.txpower_sku));
1121
+
sizeof(req.txpower_sku), TX_POWER_INFO_RATE);
1122
1122
if (ret)
1123
1123
goto out;
1124
1124
···
1160
1160
return ret ? ret : count;
1161
1161
}
1162
1162
1163
-
static const struct file_operations mt7915_rate_txpower_fops = {
1163
+
static const struct file_operations mt7915_txpower_fops = {
1164
1164
.write = mt7915_rate_txpower_set,
1165
1165
.read = mt7915_rate_txpower_get,
1166
1166
.open = simple_open,
1167
1167
.owner = THIS_MODULE,
1168
1168
.llseek = default_llseek,
1169
1169
};
1170
+
1171
+
static int
1172
+
mt7915_path_txpower_show(struct seq_file *file)
1173
+
{
1174
+
struct mt7915_phy *phy = file->private;
1175
+
s8 txpower[MT7915_SKU_PATH_NUM], *buf = txpower;
1176
+
int ret;
1177
+
1178
+
#define PATH_POWER_SHOW(_name, _len, _skip) do { \
1179
+
size_t __len = (_len); \
1180
+
if (_skip) { \
1181
+
buf -= 1; \
1182
+
*buf = 0; \
1183
+
} \
1184
+
mt76_seq_puts_array(file, _name, buf, __len); \
1185
+
buf += __len; \
1186
+
} while (0)
1187
+
1188
+
seq_printf(file, "\n%*c", 18, ' ');
1189
+
seq_puts(file, "1T1S/2T1S/3T1S/4T1S/2T2S/3T2S/4T2S/3T3S/4T3S/4T4S\n");
1190
+
ret = mt7915_mcu_get_txpower_sku(phy, txpower, sizeof(txpower),
1191
+
TX_POWER_INFO_PATH);
1192
+
if (ret)
1193
+
return ret;
1194
+
1195
+
PATH_POWER_SHOW("CCK", 4, 0);
1196
+
PATH_POWER_SHOW("OFDM", 4, 0);
1197
+
PATH_POWER_SHOW("BF-OFDM", 4, 1);
1198
+
1199
+
PATH_POWER_SHOW("HT/VHT20", 10, 0);
1200
+
PATH_POWER_SHOW("BF-HT/VHT20", 10, 1);
1201
+
PATH_POWER_SHOW("HT/VHT40", 10, 0);
1202
+
PATH_POWER_SHOW("BF-HT/VHT40", 10, 1);
1203
+
1204
+
PATH_POWER_SHOW("BW20/RU242", 10, 0);
1205
+
PATH_POWER_SHOW("BF-BW20/RU242", 10, 1);
1206
+
PATH_POWER_SHOW("BW40/RU484", 10, 0);
1207
+
PATH_POWER_SHOW("BF-BW40/RU484", 10, 1);
1208
+
PATH_POWER_SHOW("BW80/RU996", 10, 0);
1209
+
PATH_POWER_SHOW("BF-BW80/RU996", 10, 1);
1210
+
PATH_POWER_SHOW("BW160/RU2x996", 10, 0);
1211
+
PATH_POWER_SHOW("BF-BW160/RU2x996", 10, 1);
1212
+
PATH_POWER_SHOW("RU26", 10, 0);
1213
+
PATH_POWER_SHOW("BF-RU26", 10, 0);
1214
+
PATH_POWER_SHOW("RU52", 10, 0);
1215
+
PATH_POWER_SHOW("BF-RU52", 10, 0);
1216
+
PATH_POWER_SHOW("RU106", 10, 0);
1217
+
PATH_POWER_SHOW("BF-RU106", 10, 0);
1218
+
#undef PATH_POWER_SHOW
1219
+
1220
+
return 0;
1221
+
}
1222
+
1223
+
static int
1224
+
mt7915_txpower_path_show(struct seq_file *file, void *data)
1225
+
{
1226
+
struct mt7915_phy *phy = file->private;
1227
+
1228
+
seq_printf(file, "\nBand %d\n", phy != &phy->dev->phy);
1229
+
1230
+
return mt7915_path_txpower_show(file);
1231
+
}
1232
+
1233
+
DEFINE_SHOW_ATTRIBUTE(mt7915_txpower_path);
1170
1234
1171
1235
static int
1172
1236
mt7915_twt_stats(struct seq_file *s, void *data)
···
1318
1254
debugfs_create_file("implicit_txbf", 0600, dir, dev,
1319
1255
&fops_implicit_txbf);
1320
1256
debugfs_create_file("txpower_sku", 0400, dir, phy,
1321
-
&mt7915_rate_txpower_fops);
1257
+
&mt7915_txpower_fops);
1258
+
debugfs_create_file("txpower_path", 0400, dir, phy,
1259
+
&mt7915_txpower_path_fops);
1322
1260
debugfs_create_devm_seqfile(dev->mt76.dev, "twt_stats", dir,
1323
1261
mt7915_twt_stats);
1324
1262
debugfs_create_file("rf_regval", 0600, dir, dev, &fops_rf_regval);
+7
drivers/net/wireless/mediatek/mt76/mt7915/init.c
+7
drivers/net/wireless/mediatek/mt76/mt7915/init.c
···
289
289
int pwr_delta = mt7915_eeprom_get_power_delta(dev, sband->band);
290
290
struct mt76_power_limits limits;
291
291
292
+
phy->sku_limit_en = true;
293
+
phy->sku_path_en = true;
292
294
for (i = 0; i < sband->n_channels; i++) {
293
295
struct ieee80211_channel *chan = &sband->channels[i];
294
296
u32 target_power = 0;
···
307
305
target_power = mt76_get_rate_power_limits(phy->mt76, chan,
308
306
&limits,
309
307
target_power);
308
+
309
+
/* MT7915N can not enable Backoff table without setting value in dts */
310
+
if (!limits.path.ofdm[0])
311
+
phy->sku_path_en = false;
312
+
310
313
target_power += path_delta;
311
314
target_power = DIV_ROUND_UP(target_power, 2);
312
315
chan->max_power = min_t(int, chan->max_reg_power,
+1
-1
drivers/net/wireless/mediatek/mt76/mt7915/main.c
+1
-1
drivers/net/wireless/mediatek/mt76/mt7915/main.c
+142
-40
drivers/net/wireless/mediatek/mt76/mt7915/mcu.c
+142
-40
drivers/net/wireless/mediatek/mt76/mt7915/mcu.c
···
3336
3336
int ret;
3337
3337
s8 txpower_sku[MT7915_SKU_RATE_NUM];
3338
3338
3339
-
ret = mt7915_mcu_get_txpower_sku(phy, txpower_sku, sizeof(txpower_sku));
3339
+
ret = mt7915_mcu_get_txpower_sku(phy, txpower_sku, sizeof(txpower_sku),
3340
+
TX_POWER_INFO_RATE);
3340
3341
if (ret)
3341
3342
return ret;
3342
3343
···
3377
3376
sizeof(req), true);
3378
3377
}
3379
3378
3379
+
static void
3380
+
mt7915_update_txpower(struct mt7915_phy *phy, int tx_power)
3381
+
{
3382
+
struct mt76_phy *mphy = phy->mt76;
3383
+
struct ieee80211_channel *chan = mphy->main_chandef.chan;
3384
+
int chain_idx, val, e2p_power_limit = 0;
3385
+
3386
+
if (!chan) {
3387
+
mphy->txpower_cur = tx_power;
3388
+
return;
3389
+
}
3390
+
3391
+
for (chain_idx = 0; chain_idx < hweight16(mphy->chainmask); chain_idx++) {
3392
+
val = mt7915_eeprom_get_target_power(phy->dev, chan, chain_idx);
3393
+
val += mt7915_eeprom_get_power_delta(phy->dev, chan->band);
3394
+
3395
+
e2p_power_limit = max_t(int, e2p_power_limit, val);
3396
+
}
3397
+
3398
+
if (phy->sku_limit_en)
3399
+
mphy->txpower_cur = min_t(int, e2p_power_limit, tx_power);
3400
+
else
3401
+
mphy->txpower_cur = e2p_power_limit;
3402
+
}
3403
+
3380
3404
int mt7915_mcu_set_txpower_sku(struct mt7915_phy *phy)
3381
3405
{
3406
+
#define TX_POWER_LIMIT_TABLE_RATE 0
3407
+
#define TX_POWER_LIMIT_TABLE_PATH 1
3382
3408
struct mt7915_dev *dev = phy->dev;
3383
3409
struct mt76_phy *mphy = phy->mt76;
3384
3410
struct ieee80211_hw *hw = mphy->hw;
3385
-
struct mt7915_mcu_txpower_sku req = {
3411
+
struct mt7915_sku_val {
3412
+
u8 format_id;
3413
+
u8 limit_type;
3414
+
u8 band_idx;
3415
+
} __packed hdr = {
3386
3416
.format_id = TX_POWER_LIMIT_TABLE,
3417
+
.limit_type = TX_POWER_LIMIT_TABLE_RATE,
3387
3418
.band_idx = phy->mt76->band_idx,
3388
3419
};
3389
-
struct mt76_power_limits limits_array;
3390
-
s8 *la = (s8 *)&limits_array;
3391
-
int i, idx;
3392
-
int tx_power;
3420
+
int i, ret, tx_power;
3421
+
const u8 *len = mt7915_sku_group_len;
3422
+
struct mt76_power_limits la = {};
3423
+
struct sk_buff *skb;
3393
3424
3394
3425
tx_power = mt76_get_power_bound(mphy, hw->conf.power_level);
3395
-
tx_power = mt76_get_rate_power_limits(mphy, mphy->chandef.chan,
3396
-
&limits_array, tx_power);
3397
-
mphy->txpower_cur = tx_power;
3398
-
3399
-
for (i = 0, idx = 0; i < ARRAY_SIZE(mt7915_sku_group_len); i++) {
3400
-
u8 mcs_num, len = mt7915_sku_group_len[i];
3401
-
int j;
3402
-
3403
-
if (i >= SKU_HT_BW20 && i <= SKU_VHT_BW160) {
3404
-
mcs_num = 10;
3405
-
3406
-
if (i == SKU_HT_BW20 || i == SKU_VHT_BW20)
3407
-
la = (s8 *)&limits_array + 12;
3408
-
} else {
3409
-
mcs_num = len;
3410
-
}
3411
-
3412
-
for (j = 0; j < min_t(u8, mcs_num, len); j++)
3413
-
req.txpower_sku[idx + j] = la[j];
3414
-
3415
-
la += mcs_num;
3416
-
idx += len;
3426
+
if (phy->sku_limit_en) {
3427
+
tx_power = mt76_get_rate_power_limits(mphy, mphy->chandef.chan,
3428
+
&la, tx_power);
3429
+
mt7915_update_txpower(phy, tx_power);
3430
+
} else {
3431
+
mt7915_update_txpower(phy, tx_power);
3432
+
return 0;
3417
3433
}
3418
3434
3419
-
return mt76_mcu_send_msg(&dev->mt76,
3420
-
MCU_EXT_CMD(TX_POWER_FEATURE_CTRL), &req,
3421
-
sizeof(req), true);
3435
+
skb = mt76_mcu_msg_alloc(&dev->mt76, NULL,
3436
+
sizeof(hdr) + MT7915_SKU_RATE_NUM);
3437
+
if (!skb)
3438
+
return -ENOMEM;
3439
+
3440
+
skb_put_data(skb, &hdr, sizeof(hdr));
3441
+
skb_put_data(skb, &la.cck, len[SKU_CCK] + len[SKU_OFDM]);
3442
+
skb_put_data(skb, &la.mcs[0], len[SKU_HT_BW20]);
3443
+
skb_put_data(skb, &la.mcs[1], len[SKU_HT_BW40]);
3444
+
3445
+
/* vht */
3446
+
for (i = 0; i < 4; i++) {
3447
+
skb_put_data(skb, &la.mcs[i], sizeof(la.mcs[i]));
3448
+
skb_put_zero(skb, 2); /* padding */
3449
+
}
3450
+
3451
+
/* he */
3452
+
skb_put_data(skb, &la.ru[0], sizeof(la.ru));
3453
+
ret = mt76_mcu_skb_send_msg(&dev->mt76, skb,
3454
+
MCU_EXT_CMD(TX_POWER_FEATURE_CTRL), true);
3455
+
if (ret)
3456
+
return ret;
3457
+
3458
+
/* only set per-path power table when it's configured */
3459
+
if (!phy->sku_path_en)
3460
+
return 0;
3461
+
3462
+
skb = mt76_mcu_msg_alloc(&dev->mt76, NULL,
3463
+
sizeof(hdr) + MT7915_SKU_PATH_NUM);
3464
+
if (!skb)
3465
+
return -ENOMEM;
3466
+
3467
+
hdr.limit_type = TX_POWER_LIMIT_TABLE_PATH;
3468
+
skb_put_data(skb, &hdr, sizeof(hdr));
3469
+
skb_put_data(skb, &la.path.cck, sizeof(la.path.cck));
3470
+
skb_put_data(skb, &la.path.ofdm, sizeof(la.path.ofdm));
3471
+
skb_put_data(skb, &la.path.ofdm_bf[1], sizeof(la.path.ofdm_bf) - 1);
3472
+
3473
+
/* HT20 and HT40 */
3474
+
skb_put_data(skb, &la.path.ru[3], sizeof(la.path.ru[3]));
3475
+
skb_put_data(skb, &la.path.ru_bf[3][1], sizeof(la.path.ru_bf[3]) - 1);
3476
+
skb_put_data(skb, &la.path.ru[4], sizeof(la.path.ru[4]));
3477
+
skb_put_data(skb, &la.path.ru_bf[4][1], sizeof(la.path.ru_bf[4]) - 1);
3478
+
3479
+
/* start from non-bf and bf fields of
3480
+
* BW20/RU242, BW40/RU484, BW80/RU996, BW160/RU2x996,
3481
+
* RU26, RU52, and RU106
3482
+
*/
3483
+
3484
+
for (i = 0; i < 8; i++) {
3485
+
bool bf = i % 2;
3486
+
u8 idx = (i + 6) / 2;
3487
+
s8 *buf = bf ? la.path.ru_bf[idx] : la.path.ru[idx];
3488
+
/* The non-bf fields of RU26 to RU106 are special cases */
3489
+
if (bf)
3490
+
skb_put_data(skb, buf + 1, 9);
3491
+
else
3492
+
skb_put_data(skb, buf, 10);
3493
+
}
3494
+
3495
+
for (i = 0; i < 6; i++) {
3496
+
bool bf = i % 2;
3497
+
u8 idx = i / 2;
3498
+
s8 *buf = bf ? la.path.ru_bf[idx] : la.path.ru[idx];
3499
+
3500
+
skb_put_data(skb, buf, 10);
3501
+
}
3502
+
3503
+
return mt76_mcu_skb_send_msg(&dev->mt76, skb,
3504
+
MCU_EXT_CMD(TX_POWER_FEATURE_CTRL), true);
3422
3505
}
3423
3506
3424
-
int mt7915_mcu_get_txpower_sku(struct mt7915_phy *phy, s8 *txpower, int len)
3507
+
int mt7915_mcu_get_txpower_sku(struct mt7915_phy *phy, s8 *txpower, int len,
3508
+
u8 category)
3425
3509
{
3426
3510
#define RATE_POWER_INFO 2
3427
3511
struct mt7915_dev *dev = phy->dev;
···
3517
3431
u8 _rsv;
3518
3432
} __packed req = {
3519
3433
.format_id = TX_POWER_LIMIT_INFO,
3520
-
.category = RATE_POWER_INFO,
3434
+
.category = category,
3521
3435
.band_idx = phy->mt76->band_idx,
3522
3436
};
3523
-
s8 txpower_sku[MT7915_SKU_RATE_NUM][2];
3524
3437
struct sk_buff *skb;
3525
3438
int ret, i;
3526
3439
···
3529
3444
if (ret)
3530
3445
return ret;
3531
3446
3532
-
memcpy(txpower_sku, skb->data + 4, sizeof(txpower_sku));
3533
-
for (i = 0; i < len; i++)
3534
-
txpower[i] = txpower_sku[i][req.band_idx];
3447
+
if (category == TX_POWER_INFO_RATE) {
3448
+
s8 res[MT7915_SKU_RATE_NUM][2];
3449
+
3450
+
memcpy(res, skb->data + 4, sizeof(res));
3451
+
for (i = 0; i < len; i++)
3452
+
txpower[i] = res[i][req.band_idx];
3453
+
} else if (category == TX_POWER_INFO_PATH) {
3454
+
memcpy(txpower, skb->data + 4, len);
3455
+
}
3535
3456
3536
3457
dev_kfree_skb(skb);
3537
3458
···
3566
3475
sizeof(req), false);
3567
3476
}
3568
3477
3569
-
int mt7915_mcu_set_sku_en(struct mt7915_phy *phy, bool enable)
3478
+
int mt7915_mcu_set_sku_en(struct mt7915_phy *phy)
3570
3479
{
3571
3480
struct mt7915_dev *dev = phy->dev;
3572
3481
struct mt7915_sku {
···
3575
3484
u8 band_idx;
3576
3485
u8 rsv;
3577
3486
} __packed req = {
3578
-
.format_id = TX_POWER_LIMIT_ENABLE,
3579
3487
.band_idx = phy->mt76->band_idx,
3580
-
.sku_enable = enable,
3581
3488
};
3489
+
int ret;
3490
+
3491
+
req.sku_enable = phy->sku_limit_en;
3492
+
req.format_id = TX_POWER_LIMIT_ENABLE;
3493
+
3494
+
ret = mt76_mcu_send_msg(&dev->mt76,
3495
+
MCU_EXT_CMD(TX_POWER_FEATURE_CTRL), &req,
3496
+
sizeof(req), true);
3497
+
if (ret)
3498
+
return ret;
3499
+
3500
+
req.sku_enable = phy->sku_path_en;
3501
+
req.format_id = TX_POWER_LIMIT_PATH_ENABLE;
3582
3502
3583
3503
return mt76_mcu_send_msg(&dev->mt76,
3584
3504
MCU_EXT_CMD(TX_POWER_FEATURE_CTRL), &req,
+6
drivers/net/wireless/mediatek/mt76/mt7915/mcu.h
+6
drivers/net/wireless/mediatek/mt76/mt7915/mcu.h
···
429
429
430
430
enum {
431
431
TX_POWER_LIMIT_ENABLE,
432
+
TX_POWER_LIMIT_PATH_ENABLE = 0x3,
432
433
TX_POWER_LIMIT_TABLE = 0x4,
433
434
TX_POWER_LIMIT_INFO = 0x7,
434
435
TX_POWER_LIMIT_FRAME = 0x11,
435
436
TX_POWER_LIMIT_FRAME_MIN = 0x12,
437
+
};
438
+
439
+
enum {
440
+
TX_POWER_INFO_PATH = 1,
441
+
TX_POWER_INFO_RATE,
436
442
};
437
443
438
444
enum {
+7
-2
drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h
+7
-2
drivers/net/wireless/mediatek/mt76/mt7915/mt7915.h
···
70
70
#define MT7915_CDEV_THROTTLE_MAX 99
71
71
72
72
#define MT7915_SKU_RATE_NUM 161
73
+
#define MT7915_SKU_PATH_NUM 185
73
74
74
75
#define MT7915_MAX_TWT_AGRT 16
75
76
#define MT7915_MAX_STA_TWT_AGRT 8
···
223
222
224
223
struct mt76_mib_stats mib;
225
224
struct mt76_channel_state state_ts;
225
+
226
+
bool sku_limit_en:1;
227
+
bool sku_path_en:1;
226
228
227
229
#ifdef CONFIG_NL80211_TESTMODE
228
230
struct {
···
495
491
int mt7915_mcu_set_test_param(struct mt7915_dev *dev, u8 param, bool test_mode,
496
492
u8 en);
497
493
int mt7915_mcu_set_ser(struct mt7915_dev *dev, u8 action, u8 set, u8 band);
498
-
int mt7915_mcu_set_sku_en(struct mt7915_phy *phy, bool enable);
494
+
int mt7915_mcu_set_sku_en(struct mt7915_phy *phy);
499
495
int mt7915_mcu_set_txpower_sku(struct mt7915_phy *phy);
500
-
int mt7915_mcu_get_txpower_sku(struct mt7915_phy *phy, s8 *txpower, int len);
496
+
int mt7915_mcu_get_txpower_sku(struct mt7915_phy *phy, s8 *txpower, int len,
497
+
u8 category);
501
498
int mt7915_mcu_set_txpower_frame_min(struct mt7915_phy *phy, s8 txpower);
502
499
int mt7915_mcu_set_txpower_frame(struct mt7915_phy *phy,
503
500
struct ieee80211_vif *vif,
+1
-1
drivers/net/wireless/mediatek/mt76/mt7915/testmode.c
+1
-1
drivers/net/wireless/mediatek/mt76/mt7915/testmode.c