1 // SPDX-License-Identifier: ISC
2 /* Copyright (C) 2022 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 "mt7921.h"
12 #include "mcu.h"
13 #include "../mt76_connac2_mac.h"
14
15 static const struct usb_device_id mt7921u_device_table[] = {
16 { USB_DEVICE_AND_INTERFACE_INFO(0x0e8d, 0x7961, 0xff, 0xff, 0xff),
17 .driver_info = (kernel_ulong_t)MT7921_FIRMWARE_WM },
18 /* Comfast CF-952AX */
19 { USB_DEVICE_AND_INTERFACE_INFO(0x3574, 0x6211, 0xff, 0xff, 0xff),
20 .driver_info = (kernel_ulong_t)MT7921_FIRMWARE_WM },
21 /* Netgear, Inc. [A8000,AXE3000] */
22 { USB_DEVICE_AND_INTERFACE_INFO(0x0846, 0x9060, 0xff, 0xff, 0xff),
23 .driver_info = (kernel_ulong_t)MT7921_FIRMWARE_WM },
24 /* TP-Link TXE50UH */
25 { USB_DEVICE_AND_INTERFACE_INFO(0x35bc, 0x0107, 0xff, 0xff, 0xff),
26 .driver_info = (kernel_ulong_t)MT7921_FIRMWARE_WM },
27 { },
28 };
29
30 static int
mt7921u_mcu_send_message(struct mt76_dev * mdev,struct sk_buff * skb,int cmd,int * seq)31 mt7921u_mcu_send_message(struct mt76_dev *mdev, struct sk_buff *skb,
32 int cmd, int *seq)
33 {
34 struct mt792x_dev *dev = container_of(mdev, struct mt792x_dev, mt76);
35 u32 pad, ep;
36 int ret;
37
38 ret = mt76_connac2_mcu_fill_message(mdev, skb, cmd, seq);
39 if (ret)
40 return ret;
41
42 mdev->mcu.timeout = 3 * HZ;
43
44 if (cmd != MCU_CMD(FW_SCATTER))
45 ep = MT_EP_OUT_INBAND_CMD;
46 else
47 ep = MT_EP_OUT_AC_BE;
48
49 mt7921_skb_add_usb_sdio_hdr(dev, skb, 0);
50 pad = round_up(skb->len, 4) + 4 - skb->len;
51 __skb_put_zero(skb, pad);
52
53 ret = mt76u_bulk_msg(&dev->mt76, skb->data, skb->len, NULL,
54 1000, ep);
55 dev_kfree_skb(skb);
56
57 return ret;
58 }
59
mt7921u_mcu_init(struct mt792x_dev * dev)60 static int mt7921u_mcu_init(struct mt792x_dev *dev)
61 {
62 static const struct mt76_mcu_ops mcu_ops = {
63 .headroom = MT_SDIO_HDR_SIZE +
64 sizeof(struct mt76_connac2_mcu_txd),
65 .tailroom = MT_USB_TAIL_SIZE,
66 .mcu_skb_send_msg = mt7921u_mcu_send_message,
67 .mcu_parse_response = mt7921_mcu_parse_response,
68 };
69 int ret;
70
71 dev->mt76.mcu_ops = &mcu_ops;
72
73 mt76_set(dev, MT_UDMA_TX_QSEL, MT_FW_DL_EN);
74 ret = mt7921_run_firmware(dev);
75 if (ret)
76 return ret;
77
78 set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
79 mt76_clear(dev, MT_UDMA_TX_QSEL, MT_FW_DL_EN);
80
81 return 0;
82 }
83
mt7921u_mac_reset(struct mt792x_dev * dev)84 static int mt7921u_mac_reset(struct mt792x_dev *dev)
85 {
86 int err;
87
88 mt76_txq_schedule_all(&dev->mphy);
89 mt76_worker_disable(&dev->mt76.tx_worker);
90
91 set_bit(MT76_RESET, &dev->mphy.state);
92 set_bit(MT76_MCU_RESET, &dev->mphy.state);
93
94 wake_up(&dev->mt76.mcu.wait);
95 skb_queue_purge(&dev->mt76.mcu.res_q);
96
97 mt76u_stop_rx(&dev->mt76);
98 mt76u_stop_tx(&dev->mt76);
99
100 mt792xu_wfsys_reset(dev);
101
102 clear_bit(MT76_MCU_RESET, &dev->mphy.state);
103 err = mt76u_resume_rx(&dev->mt76);
104 if (err)
105 goto out;
106
107 err = mt792xu_mcu_power_on(dev);
108 if (err)
109 goto out;
110
111 err = mt792xu_dma_init(dev, false);
112 if (err)
113 goto out;
114
115 mt76_wr(dev, MT_SWDEF_MODE, MT_SWDEF_NORMAL_MODE);
116 mt76_set(dev, MT_UDMA_TX_QSEL, MT_FW_DL_EN);
117
118 err = mt7921_run_firmware(dev);
119 if (err)
120 goto out;
121
122 mt76_clear(dev, MT_UDMA_TX_QSEL, MT_FW_DL_EN);
123
124 err = mt7921_mcu_set_eeprom(dev);
125 if (err)
126 goto out;
127
128 err = mt7921_mac_init(dev);
129 if (err)
130 goto out;
131
132 err = __mt7921_start(&dev->phy);
133 out:
134 clear_bit(MT76_RESET, &dev->mphy.state);
135
136 mt76_worker_enable(&dev->mt76.tx_worker);
137
138 return err;
139 }
140
mt7921u_stop(struct ieee80211_hw * hw)141 static void mt7921u_stop(struct ieee80211_hw *hw)
142 {
143 struct mt792x_dev *dev = mt792x_hw_dev(hw);
144
145 mt76u_stop_tx(&dev->mt76);
146 mt7921_stop(hw);
147 }
148
mt7921u_probe(struct usb_interface * usb_intf,const struct usb_device_id * id)149 static int mt7921u_probe(struct usb_interface *usb_intf,
150 const struct usb_device_id *id)
151 {
152 static const struct mt76_driver_ops drv_ops = {
153 .txwi_size = MT_SDIO_TXD_SIZE,
154 .drv_flags = MT_DRV_RX_DMA_HDR | MT_DRV_HW_MGMT_TXQ |
155 MT_DRV_AMSDU_OFFLOAD,
156 .survey_flags = SURVEY_INFO_TIME_TX |
157 SURVEY_INFO_TIME_RX |
158 SURVEY_INFO_TIME_BSS_RX,
159 .tx_prepare_skb = mt7921_usb_sdio_tx_prepare_skb,
160 .tx_complete_skb = mt7921_usb_sdio_tx_complete_skb,
161 .tx_status_data = mt7921_usb_sdio_tx_status_data,
162 .rx_skb = mt7921_queue_rx_skb,
163 .rx_check = mt7921_rx_check,
164 .sta_add = mt7921_mac_sta_add,
165 .sta_assoc = mt7921_mac_sta_assoc,
166 .sta_remove = mt7921_mac_sta_remove,
167 .update_survey = mt792x_update_channel,
168 };
169 static const struct mt792x_hif_ops hif_ops = {
170 .mcu_init = mt7921u_mcu_init,
171 .init_reset = mt792xu_init_reset,
172 .reset = mt7921u_mac_reset,
173 };
174 static struct mt76_bus_ops bus_ops = {
175 .rr = mt792xu_rr,
176 .wr = mt792xu_wr,
177 .rmw = mt792xu_rmw,
178 .read_copy = mt76u_read_copy,
179 .write_copy = mt792xu_copy,
180 .type = MT76_BUS_USB,
181 };
182 struct usb_device *udev = interface_to_usbdev(usb_intf);
183 struct ieee80211_ops *ops;
184 struct ieee80211_hw *hw;
185 struct mt792x_dev *dev;
186 struct mt76_dev *mdev;
187 u8 features;
188 int ret;
189
190 ops = mt792x_get_mac80211_ops(&usb_intf->dev, &mt7921_ops,
191 (void *)id->driver_info, &features);
192 if (!ops)
193 return -ENOMEM;
194
195 ops->stop = mt7921u_stop;
196 mdev = mt76_alloc_device(&usb_intf->dev, sizeof(*dev), ops, &drv_ops);
197 if (!mdev)
198 return -ENOMEM;
199
200 dev = container_of(mdev, struct mt792x_dev, mt76);
201 dev->fw_features = features;
202 dev->hif_ops = &hif_ops;
203
204 udev = usb_get_dev(udev);
205 usb_reset_device(udev);
206
207 usb_set_intfdata(usb_intf, dev);
208
209 ret = __mt76u_init(mdev, usb_intf, &bus_ops);
210 if (ret < 0)
211 goto error;
212
213 mdev->rev = (mt76_rr(dev, MT_HW_CHIPID) << 16) |
214 (mt76_rr(dev, MT_HW_REV) & 0xff);
215 dev_dbg(mdev->dev, "ASIC revision: %04x\n", mdev->rev);
216
217 if (mt76_get_field(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_N9_RDY)) {
218 ret = mt792xu_wfsys_reset(dev);
219 if (ret)
220 goto error;
221 }
222
223 ret = mt792xu_mcu_power_on(dev);
224 if (ret)
225 goto error;
226
227 ret = mt76u_alloc_mcu_queue(&dev->mt76);
228 if (ret)
229 goto error;
230
231 ret = mt76u_alloc_queues(&dev->mt76);
232 if (ret)
233 goto error;
234
235 ret = mt792xu_dma_init(dev, false);
236 if (ret)
237 goto error;
238
239 hw = mt76_hw(dev);
240 /* check hw sg support in order to enable AMSDU */
241 hw->max_tx_fragments = mdev->usb.sg_en ? MT_HW_TXP_MAX_BUF_NUM : 1;
242
243 ret = mt7921_register_device(dev);
244 if (ret)
245 goto error;
246
247 return 0;
248
249 error:
250 mt76u_queues_deinit(&dev->mt76);
251
252 usb_set_intfdata(usb_intf, NULL);
253 usb_put_dev(interface_to_usbdev(usb_intf));
254
255 mt76_free_device(&dev->mt76);
256
257 return ret;
258 }
259
260 #ifdef CONFIG_PM
mt7921u_suspend(struct usb_interface * intf,pm_message_t state)261 static int mt7921u_suspend(struct usb_interface *intf, pm_message_t state)
262 {
263 struct mt792x_dev *dev = usb_get_intfdata(intf);
264 struct mt76_connac_pm *pm = &dev->pm;
265 int err;
266
267 pm->suspended = true;
268 flush_work(&dev->reset_work);
269
270 err = mt76_connac_mcu_set_hif_suspend(&dev->mt76, true);
271 if (err)
272 goto failed;
273
274 mt76u_stop_rx(&dev->mt76);
275 mt76u_stop_tx(&dev->mt76);
276
277 return 0;
278
279 failed:
280 pm->suspended = false;
281
282 if (err < 0)
283 mt792x_reset(&dev->mt76);
284
285 return err;
286 }
287
mt7921u_resume(struct usb_interface * intf)288 static int mt7921u_resume(struct usb_interface *intf)
289 {
290 struct mt792x_dev *dev = usb_get_intfdata(intf);
291 struct mt76_connac_pm *pm = &dev->pm;
292 bool reinit = true;
293 int err, i;
294
295 for (i = 0; i < 10; i++) {
296 u32 val = mt76_rr(dev, MT_WF_SW_DEF_CR_USB_MCU_EVENT);
297
298 if (!(val & MT_WF_SW_SER_TRIGGER_SUSPEND)) {
299 reinit = false;
300 break;
301 }
302 if (val & MT_WF_SW_SER_DONE_SUSPEND) {
303 mt76_wr(dev, MT_WF_SW_DEF_CR_USB_MCU_EVENT, 0);
304 break;
305 }
306
307 msleep(20);
308 }
309
310 if (reinit || mt792x_dma_need_reinit(dev)) {
311 err = mt792xu_dma_init(dev, true);
312 if (err)
313 goto failed;
314 }
315
316 err = mt76u_resume_rx(&dev->mt76);
317 if (err < 0)
318 goto failed;
319
320 err = mt76_connac_mcu_set_hif_suspend(&dev->mt76, false);
321 failed:
322 pm->suspended = false;
323
324 if (err < 0)
325 mt792x_reset(&dev->mt76);
326
327 return err;
328 }
329 #endif /* CONFIG_PM */
330
331 MODULE_DEVICE_TABLE(usb, mt7921u_device_table);
332 MODULE_FIRMWARE(MT7921_FIRMWARE_WM);
333 MODULE_FIRMWARE(MT7921_ROM_PATCH);
334
335 static struct usb_driver mt7921u_driver = {
336 .name = KBUILD_MODNAME,
337 .id_table = mt7921u_device_table,
338 .probe = mt7921u_probe,
339 .disconnect = mt792xu_disconnect,
340 #ifdef CONFIG_PM
341 .suspend = mt7921u_suspend,
342 .resume = mt7921u_resume,
343 .reset_resume = mt7921u_resume,
344 #endif /* CONFIG_PM */
345 .soft_unbind = 1,
346 .disable_hub_initiated_lpm = 1,
347 };
348 module_usb_driver(mt7921u_driver);
349
350 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo@kernel.org>");
351 MODULE_LICENSE("Dual BSD/GPL");
352