1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * (c) Copyright 2002-2010, Ralink Technology, Inc. 4 * Copyright (C) 2014 Felix Fietkau <nbd@openwrt.org> 5 * Copyright (C) 2015 Jakub Kicinski <kubakici@wp.pl> 6 */ 7 8 #include "mt7601u.h" 9 #include "eeprom.h" 10 #include "trace.h" 11 #include "mcu.h" 12 13 #include "initvals.h" 14 15 static void 16 mt7601u_set_wlan_state(struct mt7601u_dev *dev, u32 val, bool enable) 17 { 18 int i; 19 20 /* Note: we don't turn off WLAN_CLK because that makes the device 21 * not respond properly on the probe path. 22 * In case anyone (PSM?) wants to use this function we can 23 * bring the clock stuff back and fixup the probe path. 24 */ 25 26 if (enable) 27 val |= (MT_WLAN_FUN_CTRL_WLAN_EN | 28 MT_WLAN_FUN_CTRL_WLAN_CLK_EN); 29 else 30 val &= ~(MT_WLAN_FUN_CTRL_WLAN_EN); 31 32 mt7601u_wr(dev, MT_WLAN_FUN_CTRL, val); 33 udelay(20); 34 35 if (enable) { 36 set_bit(MT7601U_STATE_WLAN_RUNNING, &dev->state); 37 } else { 38 clear_bit(MT7601U_STATE_WLAN_RUNNING, &dev->state); 39 return; 40 } 41 42 for (i = 200; i; i--) { 43 val = mt7601u_rr(dev, MT_CMB_CTRL); 44 45 if (val & MT_CMB_CTRL_XTAL_RDY && val & MT_CMB_CTRL_PLL_LD) 46 break; 47 48 udelay(20); 49 } 50 51 /* Note: vendor driver tries to disable/enable wlan here and retry 52 * but the code which does it is so buggy it must have never 53 * triggered, so don't bother. 54 */ 55 if (!i) 56 dev_err(dev->dev, "Error: PLL and XTAL check failed!\n"); 57 } 58 59 static void mt7601u_chip_onoff(struct mt7601u_dev *dev, bool enable, bool reset) 60 { 61 u32 val; 62 63 mutex_lock(&dev->hw_atomic_mutex); 64 65 val = mt7601u_rr(dev, MT_WLAN_FUN_CTRL); 66 67 if (reset) { 68 val |= MT_WLAN_FUN_CTRL_GPIO_OUT_EN; 69 val &= ~MT_WLAN_FUN_CTRL_FRC_WL_ANT_SEL; 70 71 if (val & MT_WLAN_FUN_CTRL_WLAN_EN) { 72 val |= (MT_WLAN_FUN_CTRL_WLAN_RESET | 73 MT_WLAN_FUN_CTRL_WLAN_RESET_RF); 74 mt7601u_wr(dev, MT_WLAN_FUN_CTRL, val); 75 udelay(20); 76 77 val &= ~(MT_WLAN_FUN_CTRL_WLAN_RESET | 78 MT_WLAN_FUN_CTRL_WLAN_RESET_RF); 79 } 80 } 81 82 mt7601u_wr(dev, MT_WLAN_FUN_CTRL, val); 83 udelay(20); 84 85 mt7601u_set_wlan_state(dev, val, enable); 86 87 mutex_unlock(&dev->hw_atomic_mutex); 88 } 89 90 static void mt7601u_reset_csr_bbp(struct mt7601u_dev *dev) 91 { 92 mt7601u_wr(dev, MT_MAC_SYS_CTRL, (MT_MAC_SYS_CTRL_RESET_CSR | 93 MT_MAC_SYS_CTRL_RESET_BBP)); 94 mt7601u_wr(dev, MT_USB_DMA_CFG, 0); 95 msleep(1); 96 mt7601u_wr(dev, MT_MAC_SYS_CTRL, 0); 97 } 98 99 static void mt7601u_init_usb_dma(struct mt7601u_dev *dev) 100 { 101 u32 val; 102 103 val = FIELD_PREP(MT_USB_DMA_CFG_RX_BULK_AGG_TOUT, MT_USB_AGGR_TIMEOUT) | 104 FIELD_PREP(MT_USB_DMA_CFG_RX_BULK_AGG_LMT, 105 MT_USB_AGGR_SIZE_LIMIT) | 106 MT_USB_DMA_CFG_RX_BULK_EN | 107 MT_USB_DMA_CFG_TX_BULK_EN; 108 if (dev->in_max_packet == 512) 109 val |= MT_USB_DMA_CFG_RX_BULK_AGG_EN; 110 mt7601u_wr(dev, MT_USB_DMA_CFG, val); 111 112 val |= MT_USB_DMA_CFG_UDMA_RX_WL_DROP; 113 mt7601u_wr(dev, MT_USB_DMA_CFG, val); 114 val &= ~MT_USB_DMA_CFG_UDMA_RX_WL_DROP; 115 mt7601u_wr(dev, MT_USB_DMA_CFG, val); 116 } 117 118 static int mt7601u_init_bbp(struct mt7601u_dev *dev) 119 { 120 int ret; 121 122 ret = mt7601u_wait_bbp_ready(dev); 123 if (ret) 124 return ret; 125 126 ret = mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_BBP, bbp_common_vals, 127 ARRAY_SIZE(bbp_common_vals)); 128 if (ret) 129 return ret; 130 131 return mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_BBP, bbp_chip_vals, 132 ARRAY_SIZE(bbp_chip_vals)); 133 } 134 135 static void 136 mt76_init_beacon_offsets(struct mt7601u_dev *dev) 137 { 138 u16 base = MT_BEACON_BASE; 139 u32 regs[4] = {}; 140 int i; 141 142 for (i = 0; i < 16; i++) { 143 u16 addr = dev->beacon_offsets[i]; 144 145 regs[i / 4] |= ((addr - base) / 64) << (8 * (i % 4)); 146 } 147 148 for (i = 0; i < 4; i++) 149 mt7601u_wr(dev, MT_BCN_OFFSET(i), regs[i]); 150 } 151 152 static int mt7601u_write_mac_initvals(struct mt7601u_dev *dev) 153 { 154 int ret; 155 156 ret = mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_WLAN, mac_common_vals, 157 ARRAY_SIZE(mac_common_vals)); 158 if (ret) 159 return ret; 160 ret = mt7601u_write_reg_pairs(dev, MT_MCU_MEMMAP_WLAN, 161 mac_chip_vals, ARRAY_SIZE(mac_chip_vals)); 162 if (ret) 163 return ret; 164 165 mt76_init_beacon_offsets(dev); 166 167 mt7601u_wr(dev, MT_AUX_CLK_CFG, 0); 168 169 return 0; 170 } 171 172 static int mt7601u_init_wcid_mem(struct mt7601u_dev *dev) 173 { 174 u32 *vals; 175 int i, ret; 176 177 vals = kmalloc(sizeof(*vals) * N_WCIDS * 2, GFP_KERNEL); 178 if (!vals) 179 return -ENOMEM; 180 181 for (i = 0; i < N_WCIDS; i++) { 182 vals[i * 2] = 0xffffffff; 183 vals[i * 2 + 1] = 0x00ffffff; 184 } 185 186 ret = mt7601u_burst_write_regs(dev, MT_WCID_ADDR_BASE, 187 vals, N_WCIDS * 2); 188 kfree(vals); 189 190 return ret; 191 } 192 193 static int mt7601u_init_key_mem(struct mt7601u_dev *dev) 194 { 195 u32 vals[4] = {}; 196 197 return mt7601u_burst_write_regs(dev, MT_SKEY_MODE_BASE_0, 198 vals, ARRAY_SIZE(vals)); 199 } 200 201 static int mt7601u_init_wcid_attr_mem(struct mt7601u_dev *dev) 202 { 203 u32 *vals; 204 int i, ret; 205 206 vals = kmalloc(sizeof(*vals) * N_WCIDS * 2, GFP_KERNEL); 207 if (!vals) 208 return -ENOMEM; 209 210 for (i = 0; i < N_WCIDS * 2; i++) 211 vals[i] = 1; 212 213 ret = mt7601u_burst_write_regs(dev, MT_WCID_ATTR_BASE, 214 vals, N_WCIDS * 2); 215 kfree(vals); 216 217 return ret; 218 } 219 220 static void mt7601u_reset_counters(struct mt7601u_dev *dev) 221 { 222 mt7601u_rr(dev, MT_RX_STA_CNT0); 223 mt7601u_rr(dev, MT_RX_STA_CNT1); 224 mt7601u_rr(dev, MT_RX_STA_CNT2); 225 mt7601u_rr(dev, MT_TX_STA_CNT0); 226 mt7601u_rr(dev, MT_TX_STA_CNT1); 227 mt7601u_rr(dev, MT_TX_STA_CNT2); 228 } 229 230 int mt7601u_mac_start(struct mt7601u_dev *dev) 231 { 232 mt7601u_wr(dev, MT_MAC_SYS_CTRL, MT_MAC_SYS_CTRL_ENABLE_TX); 233 234 if (!mt76_poll(dev, MT_WPDMA_GLO_CFG, MT_WPDMA_GLO_CFG_TX_DMA_BUSY | 235 MT_WPDMA_GLO_CFG_RX_DMA_BUSY, 0, 200000)) 236 return -ETIMEDOUT; 237 238 dev->rxfilter = MT_RX_FILTR_CFG_CRC_ERR | 239 MT_RX_FILTR_CFG_PHY_ERR | MT_RX_FILTR_CFG_PROMISC | 240 MT_RX_FILTR_CFG_VER_ERR | MT_RX_FILTR_CFG_DUP | 241 MT_RX_FILTR_CFG_CFACK | MT_RX_FILTR_CFG_CFEND | 242 MT_RX_FILTR_CFG_ACK | MT_RX_FILTR_CFG_CTS | 243 MT_RX_FILTR_CFG_RTS | MT_RX_FILTR_CFG_PSPOLL | 244 MT_RX_FILTR_CFG_BA | MT_RX_FILTR_CFG_CTRL_RSV; 245 mt7601u_wr(dev, MT_RX_FILTR_CFG, dev->rxfilter); 246 247 mt7601u_wr(dev, MT_MAC_SYS_CTRL, 248 MT_MAC_SYS_CTRL_ENABLE_TX | MT_MAC_SYS_CTRL_ENABLE_RX); 249 250 if (!mt76_poll(dev, MT_WPDMA_GLO_CFG, MT_WPDMA_GLO_CFG_TX_DMA_BUSY | 251 MT_WPDMA_GLO_CFG_RX_DMA_BUSY, 0, 50)) 252 return -ETIMEDOUT; 253 254 return 0; 255 } 256 257 static void mt7601u_mac_stop_hw(struct mt7601u_dev *dev) 258 { 259 int i, ok; 260 261 if (test_bit(MT7601U_STATE_REMOVED, &dev->state)) 262 return; 263 264 mt76_clear(dev, MT_BEACON_TIME_CFG, MT_BEACON_TIME_CFG_TIMER_EN | 265 MT_BEACON_TIME_CFG_SYNC_MODE | MT_BEACON_TIME_CFG_TBTT_EN | 266 MT_BEACON_TIME_CFG_BEACON_TX); 267 268 if (!mt76_poll(dev, MT_USB_DMA_CFG, MT_USB_DMA_CFG_TX_BUSY, 0, 1000)) 269 dev_warn(dev->dev, "Warning: TX DMA did not stop!\n"); 270 271 /* Page count on TxQ */ 272 i = 200; 273 while (i-- && ((mt76_rr(dev, 0x0438) & 0xffffffff) || 274 (mt76_rr(dev, 0x0a30) & 0x000000ff) || 275 (mt76_rr(dev, 0x0a34) & 0x00ff00ff))) 276 msleep(10); 277 278 if (!mt76_poll(dev, MT_MAC_STATUS, MT_MAC_STATUS_TX, 0, 1000)) 279 dev_warn(dev->dev, "Warning: MAC TX did not stop!\n"); 280 281 mt76_clear(dev, MT_MAC_SYS_CTRL, MT_MAC_SYS_CTRL_ENABLE_RX | 282 MT_MAC_SYS_CTRL_ENABLE_TX); 283 284 /* Page count on RxQ */ 285 ok = 0; 286 i = 200; 287 while (i--) { 288 if (!(mt76_rr(dev, MT_RXQ_STA) & 0x00ff0000) && 289 !mt76_rr(dev, 0x0a30) && 290 !mt76_rr(dev, 0x0a34)) { 291 if (ok++ > 5) 292 break; 293 continue; 294 } 295 msleep(1); 296 } 297 298 if (!mt76_poll(dev, MT_MAC_STATUS, MT_MAC_STATUS_RX, 0, 1000)) 299 dev_warn(dev->dev, "Warning: MAC RX did not stop!\n"); 300 301 if (!mt76_poll(dev, MT_USB_DMA_CFG, MT_USB_DMA_CFG_RX_BUSY, 0, 1000)) 302 dev_warn(dev->dev, "Warning: RX DMA did not stop!\n"); 303 } 304 305 void mt7601u_mac_stop(struct mt7601u_dev *dev) 306 { 307 mt7601u_mac_stop_hw(dev); 308 flush_delayed_work(&dev->stat_work); 309 cancel_delayed_work_sync(&dev->stat_work); 310 } 311 312 static void mt7601u_stop_hardware(struct mt7601u_dev *dev) 313 { 314 mt7601u_chip_onoff(dev, false, false); 315 } 316 317 int mt7601u_init_hardware(struct mt7601u_dev *dev) 318 { 319 static const u16 beacon_offsets[16] = { 320 /* 512 byte per beacon */ 321 0xc000, 0xc200, 0xc400, 0xc600, 322 0xc800, 0xca00, 0xcc00, 0xce00, 323 0xd000, 0xd200, 0xd400, 0xd600, 324 0xd800, 0xda00, 0xdc00, 0xde00 325 }; 326 int ret; 327 328 dev->beacon_offsets = beacon_offsets; 329 330 mt7601u_chip_onoff(dev, true, false); 331 332 ret = mt7601u_wait_asic_ready(dev); 333 if (ret) 334 goto err; 335 ret = mt7601u_mcu_init(dev); 336 if (ret) 337 goto err; 338 339 if (!mt76_poll_msec(dev, MT_WPDMA_GLO_CFG, 340 MT_WPDMA_GLO_CFG_TX_DMA_BUSY | 341 MT_WPDMA_GLO_CFG_RX_DMA_BUSY, 0, 100)) { 342 ret = -EIO; 343 goto err; 344 } 345 346 /* Wait for ASIC ready after FW load. */ 347 ret = mt7601u_wait_asic_ready(dev); 348 if (ret) 349 goto err; 350 351 mt7601u_reset_csr_bbp(dev); 352 mt7601u_init_usb_dma(dev); 353 354 ret = mt7601u_mcu_cmd_init(dev); 355 if (ret) 356 goto err; 357 ret = mt7601u_dma_init(dev); 358 if (ret) 359 goto err_mcu; 360 ret = mt7601u_write_mac_initvals(dev); 361 if (ret) 362 goto err_rx; 363 364 if (!mt76_poll_msec(dev, MT_MAC_STATUS, 365 MT_MAC_STATUS_TX | MT_MAC_STATUS_RX, 0, 100)) { 366 ret = -EIO; 367 goto err_rx; 368 } 369 370 ret = mt7601u_init_bbp(dev); 371 if (ret) 372 goto err_rx; 373 ret = mt7601u_init_wcid_mem(dev); 374 if (ret) 375 goto err_rx; 376 ret = mt7601u_init_key_mem(dev); 377 if (ret) 378 goto err_rx; 379 ret = mt7601u_init_wcid_attr_mem(dev); 380 if (ret) 381 goto err_rx; 382 383 mt76_clear(dev, MT_BEACON_TIME_CFG, (MT_BEACON_TIME_CFG_TIMER_EN | 384 MT_BEACON_TIME_CFG_SYNC_MODE | 385 MT_BEACON_TIME_CFG_TBTT_EN | 386 MT_BEACON_TIME_CFG_BEACON_TX)); 387 388 mt7601u_reset_counters(dev); 389 390 mt7601u_rmw(dev, MT_US_CYC_CFG, MT_US_CYC_CNT, 0x1e); 391 392 mt7601u_wr(dev, MT_TXOP_CTRL_CFG, 393 FIELD_PREP(MT_TXOP_TRUN_EN, 0x3f) | 394 FIELD_PREP(MT_TXOP_EXT_CCA_DLY, 0x58)); 395 396 ret = mt7601u_eeprom_init(dev); 397 if (ret) 398 goto err_rx; 399 400 ret = mt7601u_phy_init(dev); 401 if (ret) 402 goto err_rx; 403 404 mt7601u_set_rx_path(dev, 0); 405 mt7601u_set_tx_dac(dev, 0); 406 407 mt7601u_mac_set_ctrlch(dev, false); 408 mt7601u_bbp_set_ctrlch(dev, false); 409 mt7601u_bbp_set_bw(dev, MT_BW_20); 410 411 return 0; 412 413 err_rx: 414 mt7601u_dma_cleanup(dev); 415 err_mcu: 416 mt7601u_mcu_cmd_deinit(dev); 417 err: 418 mt7601u_chip_onoff(dev, false, false); 419 return ret; 420 } 421 422 void mt7601u_cleanup(struct mt7601u_dev *dev) 423 { 424 if (!test_and_clear_bit(MT7601U_STATE_INITIALIZED, &dev->state)) 425 return; 426 427 mt7601u_stop_hardware(dev); 428 mt7601u_dma_cleanup(dev); 429 mt7601u_mcu_cmd_deinit(dev); 430 } 431 432 struct mt7601u_dev *mt7601u_alloc_device(struct device *pdev) 433 { 434 struct ieee80211_hw *hw; 435 struct mt7601u_dev *dev; 436 437 hw = ieee80211_alloc_hw(sizeof(*dev), &mt7601u_ops); 438 if (!hw) 439 return NULL; 440 441 dev = hw->priv; 442 dev->dev = pdev; 443 dev->hw = hw; 444 mutex_init(&dev->vendor_req_mutex); 445 mutex_init(&dev->reg_atomic_mutex); 446 mutex_init(&dev->hw_atomic_mutex); 447 mutex_init(&dev->mutex); 448 spin_lock_init(&dev->tx_lock); 449 spin_lock_init(&dev->rx_lock); 450 spin_lock_init(&dev->lock); 451 spin_lock_init(&dev->mac_lock); 452 spin_lock_init(&dev->con_mon_lock); 453 atomic_set(&dev->avg_ampdu_len, 1); 454 skb_queue_head_init(&dev->tx_skb_done); 455 456 dev->stat_wq = alloc_workqueue("mt7601u", WQ_UNBOUND, 0); 457 if (!dev->stat_wq) { 458 ieee80211_free_hw(hw); 459 return NULL; 460 } 461 462 return dev; 463 } 464 465 #define CHAN2G(_idx, _freq) { \ 466 .band = NL80211_BAND_2GHZ, \ 467 .center_freq = (_freq), \ 468 .hw_value = (_idx), \ 469 .max_power = 30, \ 470 } 471 472 static const struct ieee80211_channel mt76_channels_2ghz[] = { 473 CHAN2G(1, 2412), 474 CHAN2G(2, 2417), 475 CHAN2G(3, 2422), 476 CHAN2G(4, 2427), 477 CHAN2G(5, 2432), 478 CHAN2G(6, 2437), 479 CHAN2G(7, 2442), 480 CHAN2G(8, 2447), 481 CHAN2G(9, 2452), 482 CHAN2G(10, 2457), 483 CHAN2G(11, 2462), 484 CHAN2G(12, 2467), 485 CHAN2G(13, 2472), 486 CHAN2G(14, 2484), 487 }; 488 489 #define CCK_RATE(_idx, _rate) { \ 490 .bitrate = _rate, \ 491 .flags = IEEE80211_RATE_SHORT_PREAMBLE, \ 492 .hw_value = (MT_PHY_TYPE_CCK << 8) | _idx, \ 493 .hw_value_short = (MT_PHY_TYPE_CCK << 8) | (8 + _idx), \ 494 } 495 496 #define OFDM_RATE(_idx, _rate) { \ 497 .bitrate = _rate, \ 498 .hw_value = (MT_PHY_TYPE_OFDM << 8) | _idx, \ 499 .hw_value_short = (MT_PHY_TYPE_OFDM << 8) | _idx, \ 500 } 501 502 static struct ieee80211_rate mt76_rates[] = { 503 CCK_RATE(0, 10), 504 CCK_RATE(1, 20), 505 CCK_RATE(2, 55), 506 CCK_RATE(3, 110), 507 OFDM_RATE(0, 60), 508 OFDM_RATE(1, 90), 509 OFDM_RATE(2, 120), 510 OFDM_RATE(3, 180), 511 OFDM_RATE(4, 240), 512 OFDM_RATE(5, 360), 513 OFDM_RATE(6, 480), 514 OFDM_RATE(7, 540), 515 }; 516 517 static int 518 mt76_init_sband(struct mt7601u_dev *dev, struct ieee80211_supported_band *sband, 519 const struct ieee80211_channel *chan, int n_chan, 520 struct ieee80211_rate *rates, int n_rates) 521 { 522 struct ieee80211_sta_ht_cap *ht_cap; 523 void *chanlist; 524 int size; 525 526 size = n_chan * sizeof(*chan); 527 chanlist = devm_kmemdup(dev->dev, chan, size, GFP_KERNEL); 528 if (!chanlist) 529 return -ENOMEM; 530 531 sband->channels = chanlist; 532 sband->n_channels = n_chan; 533 sband->bitrates = rates; 534 sband->n_bitrates = n_rates; 535 536 ht_cap = &sband->ht_cap; 537 ht_cap->ht_supported = true; 538 ht_cap->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 | 539 IEEE80211_HT_CAP_GRN_FLD | 540 IEEE80211_HT_CAP_SGI_20 | 541 IEEE80211_HT_CAP_SGI_40 | 542 (1 << IEEE80211_HT_CAP_RX_STBC_SHIFT); 543 544 ht_cap->mcs.rx_mask[0] = 0xff; 545 ht_cap->mcs.rx_mask[4] = 0x1; 546 ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED; 547 ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K; 548 ht_cap->ampdu_density = IEEE80211_HT_MPDU_DENSITY_2; 549 550 dev->chandef.chan = &sband->channels[0]; 551 552 return 0; 553 } 554 555 static int 556 mt76_init_sband_2g(struct mt7601u_dev *dev) 557 { 558 dev->sband_2g = devm_kzalloc(dev->dev, sizeof(*dev->sband_2g), 559 GFP_KERNEL); 560 if (!dev->sband_2g) 561 return -ENOMEM; 562 563 dev->hw->wiphy->bands[NL80211_BAND_2GHZ] = dev->sband_2g; 564 565 WARN_ON(dev->ee->reg.start - 1 + dev->ee->reg.num > 566 ARRAY_SIZE(mt76_channels_2ghz)); 567 568 return mt76_init_sband(dev, dev->sband_2g, 569 &mt76_channels_2ghz[dev->ee->reg.start - 1], 570 dev->ee->reg.num, 571 mt76_rates, ARRAY_SIZE(mt76_rates)); 572 } 573 574 int mt7601u_register_device(struct mt7601u_dev *dev) 575 { 576 struct ieee80211_hw *hw = dev->hw; 577 struct wiphy *wiphy = hw->wiphy; 578 int ret; 579 580 /* Reserve WCID 0 for mcast - thanks to this APs WCID will go to 581 * entry no. 1 like it does in the vendor driver. 582 */ 583 dev->wcid_mask[0] |= 1; 584 585 /* init fake wcid for monitor interfaces */ 586 dev->mon_wcid = devm_kmalloc(dev->dev, sizeof(*dev->mon_wcid), 587 GFP_KERNEL); 588 if (!dev->mon_wcid) 589 return -ENOMEM; 590 dev->mon_wcid->idx = 0xff; 591 dev->mon_wcid->hw_key_idx = -1; 592 593 SET_IEEE80211_DEV(hw, dev->dev); 594 595 hw->queues = 4; 596 ieee80211_hw_set(hw, SIGNAL_DBM); 597 ieee80211_hw_set(hw, PS_NULLFUNC_STACK); 598 ieee80211_hw_set(hw, SUPPORTS_HT_CCK_RATES); 599 ieee80211_hw_set(hw, AMPDU_AGGREGATION); 600 ieee80211_hw_set(hw, SUPPORTS_RC_TABLE); 601 ieee80211_hw_set(hw, MFP_CAPABLE); 602 hw->max_rates = 1; 603 hw->max_report_rates = 7; 604 hw->max_rate_tries = 1; 605 606 hw->sta_data_size = sizeof(struct mt76_sta); 607 hw->vif_data_size = sizeof(struct mt76_vif); 608 609 SET_IEEE80211_PERM_ADDR(hw, dev->macaddr); 610 611 wiphy->features |= NL80211_FEATURE_ACTIVE_MONITOR; 612 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION); 613 wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS; 614 615 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST); 616 617 ret = mt76_init_sband_2g(dev); 618 if (ret) 619 return ret; 620 621 INIT_DELAYED_WORK(&dev->mac_work, mt7601u_mac_work); 622 INIT_DELAYED_WORK(&dev->stat_work, mt7601u_tx_stat); 623 624 ret = ieee80211_register_hw(hw); 625 if (ret) 626 return ret; 627 628 mt7601u_init_debugfs(dev); 629 630 return 0; 631 } 632