drivers/net/wireless/mediatek/mt7601u/init.c

   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 }