1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* Copyright (C) 2023 MediaTek Inc. 3 * 4 * Author: Lorenzo Bianconi <lorenzo@kernel.org> 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/module.h> 9 #include <linux/usb.h> 10 11 #include "mt792x.h" 12 #include "mt76_connac2_mac.h" 13 14 #define MT792X_USB_TX_TIMEOUT_LIMIT 50000 15 #define MT792X_USB_UDMA_IDLE_TIMEOUT 1000 16 17 static int mt792xu_read32(struct mt76_dev *dev, u32 addr, void *buf) 18 { 19 return __mt76u_vendor_request(dev, MT_VEND_READ_EXT, 20 USB_DIR_IN | MT_USB_TYPE_VENDOR, 21 (u16)(addr >> 16), (u16)addr, 22 buf, sizeof(__le32)); 23 } 24 25 static void mt792xu_reset_work(struct work_struct *work) 26 { 27 struct mt792x_dev *dev = 28 container_of(work, struct mt792x_dev, usb_reset_work); 29 struct usb_interface *usb_intf = to_usb_interface(dev->mt76.dev); 30 31 if (usb_intf && usb_get_intfdata(usb_intf) == dev) 32 usb_queue_reset_device(usb_intf); 33 34 atomic_set(&dev->usb_reset_pending, 0); 35 } 36 37 static void mt792xu_queue_usb_reset(struct mt792x_dev *dev, int err) 38 { 39 if (!atomic_xchg(&dev->usb_reset_pending, 1)) { 40 dev_warn(dev->mt76.dev, 41 "USB transport access failed (%d), queueing device reset\n", 42 err); 43 44 schedule_work(&dev->usb_reset_work); 45 } 46 } 47 48 static u32 mt792xu_bus_hung_rr(struct mt76_dev *mdev, u32 offset) 49 { 50 return 0; 51 } 52 53 static void mt792xu_bus_hung_wr(struct mt76_dev *mdev, u32 offset, u32 val) 54 { 55 } 56 57 static u32 mt792xu_bus_hung_rmw(struct mt76_dev *mdev, u32 offset, 58 u32 mask, u32 val) 59 { 60 return 0; 61 } 62 63 static void mt792xu_bus_hung_write_copy(struct mt76_dev *mdev, u32 offset, 64 const void *data, int len) 65 { 66 } 67 68 static void mt792xu_bus_hung_read_copy(struct mt76_dev *mdev, u32 offset, 69 void *data, int len) 70 { 71 memset(data, 0, len); 72 } 73 74 static const struct mt76_bus_ops mt792xu_bus_hung_ops = { 75 .rr = mt792xu_bus_hung_rr, 76 .wr = mt792xu_bus_hung_wr, 77 .rmw = mt792xu_bus_hung_rmw, 78 .write_copy = mt792xu_bus_hung_write_copy, 79 .read_copy = mt792xu_bus_hung_read_copy, 80 .type = MT76_BUS_USB, 81 }; 82 83 static void mt792xu_set_bus_hung(struct mt792x_dev *dev) 84 { 85 atomic_set(&dev->mt76.bus_hung, true); 86 87 if (READ_ONCE(dev->mt76.bus) == &mt792xu_bus_hung_ops) 88 return; 89 90 WRITE_ONCE(dev->mt76.bus, &mt792xu_bus_hung_ops); 91 } 92 93 static void mt792xu_ctrl_timeout(struct mt76_dev *mdev, int err) 94 { 95 struct mt792x_dev *dev = container_of(mdev, struct mt792x_dev, mt76); 96 97 mt792xu_set_bus_hung(dev); 98 mt792xu_queue_usb_reset(dev, err); 99 } 100 101 void mt792xu_reset_work_init(struct mt792x_dev *dev) 102 { 103 INIT_WORK(&dev->usb_reset_work, mt792xu_reset_work); 104 atomic_set(&dev->usb_reset_pending, 0); 105 dev->mt76.usb.ctrl_timeout = mt792xu_ctrl_timeout; 106 } 107 EXPORT_SYMBOL_GPL(mt792xu_reset_work_init); 108 109 void mt792xu_reset_work_cleanup(struct mt792x_dev *dev) 110 { 111 cancel_work_sync(&dev->usb_reset_work); 112 atomic_set(&dev->usb_reset_pending, 0); 113 } 114 EXPORT_SYMBOL_GPL(mt792xu_reset_work_cleanup); 115 116 int mt792xu_check_bus(struct mt792x_dev *dev) 117 { 118 int ret; 119 120 mutex_lock(&dev->mt76.usb.usb_ctrl_mtx); 121 ret = mt792xu_read32(&dev->mt76, MT_HW_CHIPID, dev->mt76.usb.data); 122 mutex_unlock(&dev->mt76.usb.usb_ctrl_mtx); 123 124 if (ret == sizeof(__le32)) 125 return 0; 126 127 return ret < 0 ? ret : -EIO; 128 } 129 EXPORT_SYMBOL_GPL(mt792xu_check_bus); 130 131 int mt792xu_reset_on_bus_error(struct mt792x_dev *dev) 132 { 133 int err; 134 135 /* Once hung, the no-op bus ops stay installed until the queued USB 136 * reset re-probes the device. Do not clear bus_hung here, or the caller 137 * would run a full reset over dropped register I/O and report success. 138 */ 139 if (atomic_read(&dev->mt76.bus_hung)) 140 return -EIO; 141 142 err = mt792xu_check_bus(dev); 143 if (err) { 144 mt792xu_set_bus_hung(dev); 145 mt792xu_queue_usb_reset(dev, err); 146 147 return err; 148 } 149 150 return 0; 151 } 152 EXPORT_SYMBOL_GPL(mt792xu_reset_on_bus_error); 153 154 u32 mt792xu_rr(struct mt76_dev *dev, u32 addr) 155 { 156 u32 ret; 157 158 mutex_lock(&dev->usb.usb_ctrl_mtx); 159 ret = ___mt76u_rr(dev, MT_VEND_READ_EXT, 160 USB_DIR_IN | MT_USB_TYPE_VENDOR, addr); 161 mutex_unlock(&dev->usb.usb_ctrl_mtx); 162 163 return ret; 164 } 165 EXPORT_SYMBOL_GPL(mt792xu_rr); 166 167 void mt792xu_wr(struct mt76_dev *dev, u32 addr, u32 val) 168 { 169 mutex_lock(&dev->usb.usb_ctrl_mtx); 170 ___mt76u_wr(dev, MT_VEND_WRITE_EXT, 171 USB_DIR_OUT | MT_USB_TYPE_VENDOR, addr, val); 172 mutex_unlock(&dev->usb.usb_ctrl_mtx); 173 } 174 EXPORT_SYMBOL_GPL(mt792xu_wr); 175 176 u32 mt792xu_rmw(struct mt76_dev *dev, u32 addr, u32 mask, u32 val) 177 { 178 mutex_lock(&dev->usb.usb_ctrl_mtx); 179 val |= ___mt76u_rr(dev, MT_VEND_READ_EXT, 180 USB_DIR_IN | MT_USB_TYPE_VENDOR, addr) & ~mask; 181 ___mt76u_wr(dev, MT_VEND_WRITE_EXT, 182 USB_DIR_OUT | MT_USB_TYPE_VENDOR, addr, val); 183 mutex_unlock(&dev->usb.usb_ctrl_mtx); 184 185 return val; 186 } 187 EXPORT_SYMBOL_GPL(mt792xu_rmw); 188 189 void mt792xu_copy(struct mt76_dev *dev, u32 offset, const void *data, int len) 190 { 191 struct mt76_usb *usb = &dev->usb; 192 int ret, i = 0, batch_len; 193 const u8 *val = data; 194 195 len = round_up(len, 4); 196 197 mutex_lock(&usb->usb_ctrl_mtx); 198 while (i < len) { 199 batch_len = min_t(int, usb->data_len, len - i); 200 memcpy(usb->data, val + i, batch_len); 201 ret = __mt76u_vendor_request(dev, MT_VEND_WRITE_EXT, 202 USB_DIR_OUT | MT_USB_TYPE_VENDOR, 203 (offset + i) >> 16, offset + i, 204 usb->data, batch_len); 205 if (ret < 0) 206 break; 207 208 i += batch_len; 209 } 210 mutex_unlock(&usb->usb_ctrl_mtx); 211 } 212 EXPORT_SYMBOL_GPL(mt792xu_copy); 213 214 int mt792xu_mcu_power_on(struct mt792x_dev *dev) 215 { 216 int ret; 217 218 ret = mt76u_vendor_request(&dev->mt76, MT_VEND_POWER_ON, 219 USB_DIR_OUT | MT_USB_TYPE_VENDOR, 220 0x0, 0x1, NULL, 0); 221 if (ret) 222 return ret; 223 224 if (!mt76_poll_msec(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_PWR_ON, 225 MT_TOP_MISC2_FW_PWR_ON, 500)) { 226 dev_err(dev->mt76.dev, "Timeout for power on\n"); 227 ret = -EIO; 228 } 229 230 return ret; 231 } 232 EXPORT_SYMBOL_GPL(mt792xu_mcu_power_on); 233 234 static void mt792xu_cleanup(struct mt792x_dev *dev) 235 { 236 clear_bit(MT76_STATE_INITIALIZED, &dev->mphy.state); 237 skb_queue_purge(&dev->mt76.mcu.res_q); 238 mt76u_queues_deinit(&dev->mt76); 239 mt792xu_wfsys_reset(dev); 240 } 241 242 static u32 mt792xu_uhw_rr(struct mt76_dev *dev, u32 addr) 243 { 244 u32 ret; 245 246 mutex_lock(&dev->usb.usb_ctrl_mtx); 247 ret = ___mt76u_rr(dev, MT_VEND_DEV_MODE, 248 USB_DIR_IN | MT_USB_TYPE_UHW_VENDOR, addr); 249 mutex_unlock(&dev->usb.usb_ctrl_mtx); 250 251 return ret; 252 } 253 254 static void mt792xu_uhw_wr(struct mt76_dev *dev, u32 addr, u32 val) 255 { 256 mutex_lock(&dev->usb.usb_ctrl_mtx); 257 ___mt76u_wr(dev, MT_VEND_WRITE, 258 USB_DIR_OUT | MT_USB_TYPE_UHW_VENDOR, addr, val); 259 mutex_unlock(&dev->usb.usb_ctrl_mtx); 260 } 261 262 static void mt792xu_dma_prefetch(struct mt792x_dev *dev) 263 { 264 #define DMA_PREFETCH_CONF(_idx_, _cnt_, _base_) \ 265 mt76_rmw(dev, MT_UWFDMA0_TX_RING_EXT_CTRL((_idx_)), \ 266 MT_WPDMA0_MAX_CNT_MASK | MT_WPDMA0_BASE_PTR_MASK, \ 267 FIELD_PREP(MT_WPDMA0_MAX_CNT_MASK, (_cnt_)) | \ 268 FIELD_PREP(MT_WPDMA0_BASE_PTR_MASK, (_base_))) 269 270 DMA_PREFETCH_CONF(0, 4, 0x080); 271 DMA_PREFETCH_CONF(1, 4, 0x0c0); 272 DMA_PREFETCH_CONF(2, 4, 0x100); 273 DMA_PREFETCH_CONF(3, 4, 0x140); 274 DMA_PREFETCH_CONF(4, 4, 0x180); 275 DMA_PREFETCH_CONF(16, 4, 0x280); 276 DMA_PREFETCH_CONF(17, 4, 0x2c0); 277 } 278 279 static void mt792xu_wfdma_init(struct mt792x_dev *dev) 280 { 281 int i; 282 283 mt792xu_dma_prefetch(dev); 284 285 mt76_clear(dev, MT_UWFDMA0_GLO_CFG, MT_WFDMA0_GLO_CFG_OMIT_RX_INFO); 286 mt76_set(dev, MT_UWFDMA0_GLO_CFG, 287 MT_WFDMA0_GLO_CFG_OMIT_TX_INFO | 288 MT_WFDMA0_GLO_CFG_OMIT_RX_INFO_PFET2 | 289 MT_WFDMA0_GLO_CFG_FW_DWLD_BYPASS_DMASHDL | 290 MT_WFDMA0_GLO_CFG_TX_DMA_EN | 291 MT_WFDMA0_GLO_CFG_RX_DMA_EN); 292 293 mt76_rmw(dev, MT_DMASHDL_REFILL, MT_DMASHDL_REFILL_MASK, 0xffe00000); 294 mt76_clear(dev, MT_DMASHDL_PAGE, MT_DMASHDL_GROUP_SEQ_ORDER); 295 mt76_rmw(dev, MT_DMASHDL_PKT_MAX_SIZE, 296 MT_DMASHDL_PKT_MAX_SIZE_PLE | MT_DMASHDL_PKT_MAX_SIZE_PSE, 297 FIELD_PREP(MT_DMASHDL_PKT_MAX_SIZE_PLE, 1) | 298 FIELD_PREP(MT_DMASHDL_PKT_MAX_SIZE_PSE, 0)); 299 for (i = 0; i < 5; i++) 300 mt76_wr(dev, MT_DMASHDL_GROUP_QUOTA(i), 301 FIELD_PREP(MT_DMASHDL_GROUP_QUOTA_MIN, 0x3) | 302 FIELD_PREP(MT_DMASHDL_GROUP_QUOTA_MAX, 0xfff)); 303 for (i = 5; i < 16; i++) 304 mt76_wr(dev, MT_DMASHDL_GROUP_QUOTA(i), 305 FIELD_PREP(MT_DMASHDL_GROUP_QUOTA_MIN, 0x0) | 306 FIELD_PREP(MT_DMASHDL_GROUP_QUOTA_MAX, 0x0)); 307 mt76_wr(dev, MT_DMASHDL_Q_MAP(0), 0x32013201); 308 mt76_wr(dev, MT_DMASHDL_Q_MAP(1), 0x32013201); 309 mt76_wr(dev, MT_DMASHDL_Q_MAP(2), 0x55555444); 310 mt76_wr(dev, MT_DMASHDL_Q_MAP(3), 0x55555444); 311 312 mt76_wr(dev, MT_DMASHDL_SCHED_SET(0), 0x76540132); 313 mt76_wr(dev, MT_DMASHDL_SCHED_SET(1), 0xFEDCBA98); 314 315 mt76_set(dev, MT_WFDMA_DUMMY_CR, MT_WFDMA_NEED_REINIT); 316 } 317 318 static int mt792xu_dma_rx_evt_ep4(struct mt792x_dev *dev) 319 { 320 if (!mt76_poll(dev, MT_UWFDMA0_GLO_CFG, 321 MT_WFDMA0_GLO_CFG_RX_DMA_BUSY, 0, 1000)) 322 return -ETIMEDOUT; 323 324 mt76_clear(dev, MT_UWFDMA0_GLO_CFG, MT_WFDMA0_GLO_CFG_RX_DMA_EN); 325 mt76_set(dev, MT_WFDMA_HOST_CONFIG, 326 MT_WFDMA_HOST_CONFIG_USB_RXEVT_EP4_EN); 327 mt76_set(dev, MT_UWFDMA0_GLO_CFG, MT_WFDMA0_GLO_CFG_RX_DMA_EN); 328 329 return 0; 330 } 331 332 static void mt792xu_epctl_rst_opt(struct mt792x_dev *dev, bool reset) 333 { 334 u32 val; 335 336 /* usb endpoint reset opt 337 * bits[4,9]: out blk ep 4-9 338 * bits[20,21]: in blk ep 4-5 339 * bits[22]: in int ep 6 340 */ 341 val = mt792xu_uhw_rr(&dev->mt76, MT_SSUSB_EPCTL_CSR_EP_RST_OPT); 342 if (reset) 343 val |= GENMASK(9, 4) | GENMASK(22, 20); 344 else 345 val &= ~(GENMASK(9, 4) | GENMASK(22, 20)); 346 mt792xu_uhw_wr(&dev->mt76, MT_SSUSB_EPCTL_CSR_EP_RST_OPT, val); 347 } 348 349 static void mt792xu_wait_udma_idle(struct mt792x_dev *dev) 350 { 351 u32 mask = MT_WL_RX_BUSY | MT_WL_TX_BUSY; 352 u32 val; 353 354 mt76_set(dev, MT_UDMA_WLCFG_0, MT_WL_RX_FLUSH); 355 356 if (mt76_poll_msec(dev, MT_UDMA_WLCFG_0, mask, 0, 357 MT792X_USB_UDMA_IDLE_TIMEOUT)) 358 return; 359 360 val = mt76_rr(dev, MT_UDMA_WLCFG_0); 361 362 dev_warn(dev->mt76.dev, 363 "UDMA busy before WFSYS reset: WLCFG0=0x%08x\n", val); 364 } 365 366 struct mt792xu_wfsys_desc { 367 u32 rst_reg; 368 u32 done_reg; 369 u32 done_mask; 370 u32 done_val; 371 u32 delay_ms; 372 bool need_status_sel; 373 }; 374 375 static const struct mt792xu_wfsys_desc mt7921_wfsys_desc = { 376 .rst_reg = MT_CBTOP_RGU_WF_SUBSYS_RST, 377 .done_reg = MT_UDMA_CONN_INFRA_STATUS, 378 .done_mask = MT_UDMA_CONN_WFSYS_INIT_DONE, 379 .done_val = MT_UDMA_CONN_WFSYS_INIT_DONE, 380 .delay_ms = 0, 381 .need_status_sel = true, 382 }; 383 384 static const struct mt792xu_wfsys_desc mt7925_wfsys_desc = { 385 .rst_reg = MT7925_CBTOP_RGU_WF_SUBSYS_RST, 386 .done_reg = MT7925_WFSYS_INIT_DONE_ADDR, 387 .done_mask = U32_MAX, 388 .done_val = MT7925_WFSYS_INIT_DONE, 389 .delay_ms = 20, 390 .need_status_sel = false, 391 }; 392 393 int mt792xu_dma_init(struct mt792x_dev *dev, bool resume) 394 { 395 int err; 396 397 mt792xu_wfdma_init(dev); 398 399 mt76_clear(dev, MT_UDMA_WLCFG_0, MT_WL_RX_FLUSH); 400 401 mt76_set(dev, MT_UDMA_WLCFG_0, 402 MT_WL_RX_EN | MT_WL_TX_EN | 403 MT_WL_RX_MPSZ_PAD0 | MT_TICK_1US_EN); 404 mt76_rmw(dev, MT_UDMA_WLCFG_1, MT_WL_TX_TMOUT_LMT, 405 FIELD_PREP(MT_WL_TX_TMOUT_LMT, 406 MT792X_USB_TX_TIMEOUT_LIMIT)); 407 mt76_set(dev, MT_UDMA_WLCFG_0, MT_WL_TX_TMOUT_FUNC_EN); 408 mt76_clear(dev, MT_UDMA_WLCFG_0, 409 MT_WL_RX_AGG_TO | MT_WL_RX_AGG_LMT); 410 mt76_clear(dev, MT_UDMA_WLCFG_1, MT_WL_RX_AGG_PKT_LMT); 411 412 if (resume) 413 return 0; 414 415 err = mt792xu_dma_rx_evt_ep4(dev); 416 if (err) 417 return err; 418 419 mt792xu_epctl_rst_opt(dev, false); 420 421 return 0; 422 } 423 EXPORT_SYMBOL_GPL(mt792xu_dma_init); 424 425 int mt792xu_wfsys_reset(struct mt792x_dev *dev) 426 { 427 const struct mt792xu_wfsys_desc *desc = is_connac3(&dev->mt76) ? 428 &mt7925_wfsys_desc : 429 &mt7921_wfsys_desc; 430 u32 val; 431 int i; 432 433 if (atomic_read(&dev->mt76.bus_hung)) 434 return -EIO; 435 436 mt792xu_wait_udma_idle(dev); 437 mt792xu_epctl_rst_opt(dev, false); 438 439 val = mt792xu_uhw_rr(&dev->mt76, desc->rst_reg); 440 val |= MT_CBTOP_RGU_WF_SUBSYS_RST_WF_WHOLE_PATH; 441 mt792xu_uhw_wr(&dev->mt76, desc->rst_reg, val); 442 443 if (desc->delay_ms) 444 msleep(desc->delay_ms); 445 else 446 usleep_range(10, 20); 447 448 val = mt792xu_uhw_rr(&dev->mt76, desc->rst_reg); 449 val &= ~MT_CBTOP_RGU_WF_SUBSYS_RST_WF_WHOLE_PATH; 450 mt792xu_uhw_wr(&dev->mt76, desc->rst_reg, val); 451 452 if (desc->need_status_sel) 453 mt792xu_uhw_wr(&dev->mt76, MT_UDMA_CONN_INFRA_STATUS_SEL, 0); 454 455 for (i = 0; i < MT792x_WFSYS_INIT_RETRY_COUNT; i++) { 456 val = mt792xu_uhw_rr(&dev->mt76, desc->done_reg); 457 if ((val & desc->done_mask) == desc->done_val) 458 break; 459 460 msleep(100); 461 } 462 463 if (i == MT792x_WFSYS_INIT_RETRY_COUNT) 464 return -ETIMEDOUT; 465 466 return 0; 467 } 468 EXPORT_SYMBOL_GPL(mt792xu_wfsys_reset); 469 470 int mt792xu_init_reset(struct mt792x_dev *dev) 471 { 472 set_bit(MT76_RESET, &dev->mphy.state); 473 474 wake_up(&dev->mt76.mcu.wait); 475 skb_queue_purge(&dev->mt76.mcu.res_q); 476 477 mt76u_stop_rx(&dev->mt76); 478 mt76u_stop_tx(&dev->mt76); 479 480 mt792xu_wfsys_reset(dev); 481 482 clear_bit(MT76_RESET, &dev->mphy.state); 483 484 return mt76u_resume_rx(&dev->mt76); 485 } 486 EXPORT_SYMBOL_GPL(mt792xu_init_reset); 487 488 void mt792xu_stop(struct ieee80211_hw *hw, bool suspend) 489 { 490 struct mt792x_dev *dev = mt792x_hw_dev(hw); 491 492 mt76u_stop_tx(&dev->mt76); 493 mt792x_stop(hw, false); 494 } 495 EXPORT_SYMBOL_GPL(mt792xu_stop); 496 497 void mt792xu_disconnect(struct usb_interface *usb_intf) 498 { 499 struct mt792x_dev *dev = usb_get_intfdata(usb_intf); 500 501 if (!dev) 502 return; 503 504 set_bit(MT76_RESET, &dev->mphy.state); 505 set_bit(MT76_MCU_RESET, &dev->mphy.state); 506 clear_bit(MT76_STATE_RUNNING, &dev->mphy.state); 507 wake_up(&dev->mt76.mcu.wait); 508 skb_queue_purge(&dev->mt76.mcu.res_q); 509 510 cancel_work_sync(&dev->reset_work); 511 cancel_work_sync(&dev->init_work); 512 mt76_worker_disable(&dev->mt76.tx_worker); 513 mt792xu_reset_work_cleanup(dev); 514 if (!test_bit(MT76_STATE_INITIALIZED, &dev->mphy.state)) { 515 set_bit(MT76_REMOVED, &dev->mphy.state); 516 return; 517 } 518 519 mt76_unregister_device(&dev->mt76); 520 mt792xu_cleanup(dev); 521 set_bit(MT76_REMOVED, &dev->mphy.state); 522 523 usb_set_intfdata(usb_intf, NULL); 524 525 mt76_free_device(&dev->mt76); 526 } 527 EXPORT_SYMBOL_GPL(mt792xu_disconnect); 528 529 MODULE_DESCRIPTION("MediaTek MT792x USB helpers"); 530 MODULE_LICENSE("Dual BSD/GPL"); 531 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo@kernel.org>"); 532