| 1 |
// SPDX-License-Identifier: GPL-2.0-only |
| 2 |
/* |
| 3 |
* (c) Copyright 2002-2010, Ralink Technology, Inc. |
| 4 |
* Copyright (C) 2014 Felix Fietkau <[email protected]> |
| 5 |
* Copyright (C) 2015 Jakub Kicinski <[email protected]> |
| 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 |
} |