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
mt792xu_read32(struct mt76_dev * dev,u32 addr,void * buf)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
mt792xu_reset_work(struct work_struct * work)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
mt792xu_queue_usb_reset(struct mt792x_dev * dev,int err)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
mt792xu_bus_hung_rr(struct mt76_dev * mdev,u32 offset)48 static u32 mt792xu_bus_hung_rr(struct mt76_dev *mdev, u32 offset)
49 {
50 return 0;
51 }
52
mt792xu_bus_hung_wr(struct mt76_dev * mdev,u32 offset,u32 val)53 static void mt792xu_bus_hung_wr(struct mt76_dev *mdev, u32 offset, u32 val)
54 {
55 }
56
mt792xu_bus_hung_rmw(struct mt76_dev * mdev,u32 offset,u32 mask,u32 val)57 static u32 mt792xu_bus_hung_rmw(struct mt76_dev *mdev, u32 offset,
58 u32 mask, u32 val)
59 {
60 return 0;
61 }
62
mt792xu_bus_hung_write_copy(struct mt76_dev * mdev,u32 offset,const void * data,int len)63 static void mt792xu_bus_hung_write_copy(struct mt76_dev *mdev, u32 offset,
64 const void *data, int len)
65 {
66 }
67
mt792xu_bus_hung_read_copy(struct mt76_dev * mdev,u32 offset,void * data,int len)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
mt792xu_set_bus_hung(struct mt792x_dev * dev)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
mt792xu_ctrl_timeout(struct mt76_dev * mdev,int err)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
mt792xu_reset_work_init(struct mt792x_dev * dev)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
mt792xu_reset_work_cleanup(struct mt792x_dev * dev)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
mt792xu_check_bus(struct mt792x_dev * dev)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
mt792xu_reset_on_bus_error(struct mt792x_dev * dev)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
mt792xu_rr(struct mt76_dev * dev,u32 addr)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
mt792xu_wr(struct mt76_dev * dev,u32 addr,u32 val)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
mt792xu_rmw(struct mt76_dev * dev,u32 addr,u32 mask,u32 val)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
mt792xu_copy(struct mt76_dev * dev,u32 offset,const void * data,int len)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
mt792xu_mcu_power_on(struct mt792x_dev * dev)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
mt792xu_cleanup(struct mt792x_dev * dev)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
mt792xu_uhw_rr(struct mt76_dev * dev,u32 addr)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
mt792xu_uhw_wr(struct mt76_dev * dev,u32 addr,u32 val)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
mt792xu_dma_prefetch(struct mt792x_dev * dev)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
mt792xu_wfdma_init(struct mt792x_dev * dev)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
mt792xu_dma_rx_evt_ep4(struct mt792x_dev * dev)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
mt792xu_epctl_rst_opt(struct mt792x_dev * dev,bool reset)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
mt792xu_wait_udma_idle(struct mt792x_dev * dev)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
mt792xu_dma_init(struct mt792x_dev * dev,bool resume)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
mt792xu_wfsys_reset(struct mt792x_dev * dev)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
mt792xu_init_reset(struct mt792x_dev * dev)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
mt792xu_stop(struct ieee80211_hw * hw,bool suspend)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
mt792xu_disconnect(struct usb_interface * usb_intf)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