mt76/mt7921/usb.c

0001 // SPDX-License-Identifier: ISC
0002 /* Copyright (C) 2022 MediaTek Inc.
0003  *
0004  * Author: Lorenzo Bianconi <lorenzo@kernel.org>
0005  */
0006
0007 #include <linux/kernel.h>
0008 #include <linux/module.h>
0009 #include <linux/usb.h>
0010
0011 #include "mt7921.h"
0012 #include "mcu.h"
0013 #include "mac.h"
0014
0015 static const struct usb_device_id mt7921u_device_table[] = {
0016     { USB_DEVICE_AND_INTERFACE_INFO(0x0e8d, 0x7961, 0xff, 0xff, 0xff) },
0017     { },
0018 };
0019
0020 static u32 mt7921u_rr(struct mt76_dev *dev, u32 addr)
0021 {
0022     u32 ret;
0023
0024     mutex_lock(&dev->usb.usb_ctrl_mtx);
0025     ret = ___mt76u_rr(dev, MT_VEND_READ_EXT,
0026               USB_DIR_IN | MT_USB_TYPE_VENDOR, addr);
0027     mutex_unlock(&dev->usb.usb_ctrl_mtx);
0028
0029     return ret;
0030 }
0031
0032 static void mt7921u_wr(struct mt76_dev *dev, u32 addr, u32 val)
0033 {
0034     mutex_lock(&dev->usb.usb_ctrl_mtx);
0035     ___mt76u_wr(dev, MT_VEND_WRITE_EXT,
0036             USB_DIR_OUT | MT_USB_TYPE_VENDOR, addr, val);
0037     mutex_unlock(&dev->usb.usb_ctrl_mtx);
0038 }
0039
0040 static u32 mt7921u_rmw(struct mt76_dev *dev, u32 addr,
0041                u32 mask, u32 val)
0042 {
0043     mutex_lock(&dev->usb.usb_ctrl_mtx);
0044     val |= ___mt76u_rr(dev, MT_VEND_READ_EXT,
0045                USB_DIR_IN | MT_USB_TYPE_VENDOR, addr) & ~mask;
0046     ___mt76u_wr(dev, MT_VEND_WRITE_EXT,
0047             USB_DIR_OUT | MT_USB_TYPE_VENDOR, addr, val);
0048     mutex_unlock(&dev->usb.usb_ctrl_mtx);
0049
0050     return val;
0051 }
0052
0053 static void mt7921u_copy(struct mt76_dev *dev, u32 offset,
0054              const void *data, int len)
0055 {
0056     struct mt76_usb *usb = &dev->usb;
0057     int ret, i = 0, batch_len;
0058     const u8 *val = data;
0059
0060     len = round_up(len, 4);
0061
0062     mutex_lock(&usb->usb_ctrl_mtx);
0063     while (i < len) {
0064         batch_len = min_t(int, usb->data_len, len - i);
0065         memcpy(usb->data, val + i, batch_len);
0066         ret = __mt76u_vendor_request(dev, MT_VEND_WRITE_EXT,
0067                          USB_DIR_OUT | MT_USB_TYPE_VENDOR,
0068                          (offset + i) >> 16, offset + i,
0069                          usb->data, batch_len);
0070         if (ret < 0)
0071             break;
0072
0073         i += batch_len;
0074     }
0075     mutex_unlock(&usb->usb_ctrl_mtx);
0076 }
0077
0078 int mt7921u_mcu_power_on(struct mt7921_dev *dev)
0079 {
0080     int ret;
0081
0082     ret = mt76u_vendor_request(&dev->mt76, MT_VEND_POWER_ON,
0083                    USB_DIR_OUT | MT_USB_TYPE_VENDOR,
0084                    0x0, 0x1, NULL, 0);
0085     if (ret)
0086         return ret;
0087
0088     if (!mt76_poll_msec(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_PWR_ON,
0089                 MT_TOP_MISC2_FW_PWR_ON, 500)) {
0090         dev_err(dev->mt76.dev, "Timeout for power on\n");
0091         ret = -EIO;
0092     }
0093
0094     return ret;
0095 }
0096
0097 static int
0098 mt7921u_mcu_send_message(struct mt76_dev *mdev, struct sk_buff *skb,
0099              int cmd, int *seq)
0100 {
0101     struct mt7921_dev *dev = container_of(mdev, struct mt7921_dev, mt76);
0102     u32 pad, ep;
0103     int ret;
0104
0105     ret = mt76_connac2_mcu_fill_message(mdev, skb, cmd, seq);
0106     if (ret)
0107         return ret;
0108
0109     if (cmd == MCU_UNI_CMD(HIF_CTRL) ||
0110         cmd == MCU_UNI_CMD(SUSPEND) ||
0111         cmd == MCU_UNI_CMD(OFFLOAD))
0112         mdev->mcu.timeout = HZ;
0113     else
0114         mdev->mcu.timeout = 3 * HZ;
0115
0116     if (cmd != MCU_CMD(FW_SCATTER))
0117         ep = MT_EP_OUT_INBAND_CMD;
0118     else
0119         ep = MT_EP_OUT_AC_BE;
0120
0121     mt7921_skb_add_usb_sdio_hdr(dev, skb, 0);
0122     pad = round_up(skb->len, 4) + 4 - skb->len;
0123     __skb_put_zero(skb, pad);
0124
0125     ret = mt76u_bulk_msg(&dev->mt76, skb->data, skb->len, NULL,
0126                  1000, ep);
0127     dev_kfree_skb(skb);
0128
0129     return ret;
0130 }
0131
0132 static int mt7921u_mcu_init(struct mt7921_dev *dev)
0133 {
0134     static const struct mt76_mcu_ops mcu_ops = {
0135         .headroom = MT_SDIO_HDR_SIZE +
0136                 sizeof(struct mt76_connac2_mcu_txd),
0137         .tailroom = MT_USB_TAIL_SIZE,
0138         .mcu_skb_send_msg = mt7921u_mcu_send_message,
0139         .mcu_parse_response = mt7921_mcu_parse_response,
0140         .mcu_restart = mt76_connac_mcu_restart,
0141     };
0142     int ret;
0143
0144     dev->mt76.mcu_ops = &mcu_ops;
0145
0146     mt76_set(dev, MT_UDMA_TX_QSEL, MT_FW_DL_EN);
0147     ret = mt7921_run_firmware(dev);
0148     if (ret)
0149         return ret;
0150
0151     set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
0152     mt76_clear(dev, MT_UDMA_TX_QSEL, MT_FW_DL_EN);
0153
0154     return 0;
0155 }
0156
0157 static void mt7921u_stop(struct ieee80211_hw *hw)
0158 {
0159     struct mt7921_dev *dev = mt7921_hw_dev(hw);
0160
0161     mt76u_stop_tx(&dev->mt76);
0162     mt7921_stop(hw);
0163 }
0164
0165 static void mt7921u_cleanup(struct mt7921_dev *dev)
0166 {
0167     clear_bit(MT76_STATE_INITIALIZED, &dev->mphy.state);
0168     mt7921u_wfsys_reset(dev);
0169     skb_queue_purge(&dev->mt76.mcu.res_q);
0170     mt76u_queues_deinit(&dev->mt76);
0171 }
0172
0173 static int mt7921u_probe(struct usb_interface *usb_intf,
0174              const struct usb_device_id *id)
0175 {
0176     static const struct mt76_driver_ops drv_ops = {
0177         .txwi_size = MT_SDIO_TXD_SIZE,
0178         .drv_flags = MT_DRV_RX_DMA_HDR | MT_DRV_HW_MGMT_TXQ,
0179         .survey_flags = SURVEY_INFO_TIME_TX |
0180                 SURVEY_INFO_TIME_RX |
0181                 SURVEY_INFO_TIME_BSS_RX,
0182         .tx_prepare_skb = mt7921_usb_sdio_tx_prepare_skb,
0183         .tx_complete_skb = mt7921_usb_sdio_tx_complete_skb,
0184         .tx_status_data = mt7921_usb_sdio_tx_status_data,
0185         .rx_skb = mt7921_queue_rx_skb,
0186         .sta_ps = mt7921_sta_ps,
0187         .sta_add = mt7921_mac_sta_add,
0188         .sta_assoc = mt7921_mac_sta_assoc,
0189         .sta_remove = mt7921_mac_sta_remove,
0190         .update_survey = mt7921_update_channel,
0191     };
0192     static const struct mt7921_hif_ops hif_ops = {
0193         .mcu_init = mt7921u_mcu_init,
0194         .init_reset = mt7921u_init_reset,
0195         .reset = mt7921u_mac_reset,
0196     };
0197     static struct mt76_bus_ops bus_ops = {
0198         .rr = mt7921u_rr,
0199         .wr = mt7921u_wr,
0200         .rmw = mt7921u_rmw,
0201         .read_copy = mt76u_read_copy,
0202         .write_copy = mt7921u_copy,
0203         .type = MT76_BUS_USB,
0204     };
0205     struct usb_device *udev = interface_to_usbdev(usb_intf);
0206     struct ieee80211_ops *ops;
0207     struct ieee80211_hw *hw;
0208     struct mt7921_dev *dev;
0209     struct mt76_dev *mdev;
0210     int ret;
0211
0212     ops = devm_kmemdup(&usb_intf->dev, &mt7921_ops, sizeof(mt7921_ops),
0213                GFP_KERNEL);
0214     if (!ops)
0215         return -ENOMEM;
0216
0217     ops->stop = mt7921u_stop;
0218
0219     mdev = mt76_alloc_device(&usb_intf->dev, sizeof(*dev), ops, &drv_ops);
0220     if (!mdev)
0221         return -ENOMEM;
0222
0223     dev = container_of(mdev, struct mt7921_dev, mt76);
0224     dev->hif_ops = &hif_ops;
0225
0226     udev = usb_get_dev(udev);
0227     usb_reset_device(udev);
0228
0229     usb_set_intfdata(usb_intf, dev);
0230
0231     ret = __mt76u_init(mdev, usb_intf, &bus_ops);
0232     if (ret < 0)
0233         goto error;
0234
0235     mdev->rev = (mt76_rr(dev, MT_HW_CHIPID) << 16) |
0236             (mt76_rr(dev, MT_HW_REV) & 0xff);
0237     dev_dbg(mdev->dev, "ASIC revision: %04x\n", mdev->rev);
0238
0239     if (mt76_get_field(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_N9_RDY)) {
0240         ret = mt7921u_wfsys_reset(dev);
0241         if (ret)
0242             goto error;
0243     }
0244
0245     ret = mt7921u_mcu_power_on(dev);
0246     if (ret)
0247         goto error;
0248
0249     ret = mt76u_alloc_mcu_queue(&dev->mt76);
0250     if (ret)
0251         goto error;
0252
0253     ret = mt76u_alloc_queues(&dev->mt76);
0254     if (ret)
0255         goto error;
0256
0257     ret = mt7921u_dma_init(dev, false);
0258     if (ret)
0259         return ret;
0260
0261     hw = mt76_hw(dev);
0262     /* check hw sg support in order to enable AMSDU */
0263     hw->max_tx_fragments = mdev->usb.sg_en ? MT_HW_TXP_MAX_BUF_NUM : 1;
0264
0265     ret = mt7921_register_device(dev);
0266     if (ret)
0267         goto error;
0268
0269     return 0;
0270
0271 error:
0272     mt76u_queues_deinit(&dev->mt76);
0273
0274     usb_set_intfdata(usb_intf, NULL);
0275     usb_put_dev(interface_to_usbdev(usb_intf));
0276
0277     mt76_free_device(&dev->mt76);
0278
0279     return ret;
0280 }
0281
0282 static void mt7921u_disconnect(struct usb_interface *usb_intf)
0283 {
0284     struct mt7921_dev *dev = usb_get_intfdata(usb_intf);
0285
0286     cancel_work_sync(&dev->init_work);
0287     if (!test_bit(MT76_STATE_INITIALIZED, &dev->mphy.state))
0288         return;
0289
0290     mt76_unregister_device(&dev->mt76);
0291     mt7921u_cleanup(dev);
0292
0293     usb_set_intfdata(usb_intf, NULL);
0294     usb_put_dev(interface_to_usbdev(usb_intf));
0295
0296     mt76_free_device(&dev->mt76);
0297 }
0298
0299 #ifdef CONFIG_PM
0300 static int mt7921u_suspend(struct usb_interface *intf, pm_message_t state)
0301 {
0302     struct mt7921_dev *dev = usb_get_intfdata(intf);
0303     int err;
0304
0305     err = mt76_connac_mcu_set_hif_suspend(&dev->mt76, true);
0306     if (err)
0307         return err;
0308
0309     mt76u_stop_rx(&dev->mt76);
0310     mt76u_stop_tx(&dev->mt76);
0311
0312     set_bit(MT76_STATE_SUSPEND, &dev->mphy.state);
0313
0314     return 0;
0315 }
0316
0317 static int mt7921u_resume(struct usb_interface *intf)
0318 {
0319     struct mt7921_dev *dev = usb_get_intfdata(intf);
0320     bool reinit = true;
0321     int err, i;
0322
0323     for (i = 0; i < 10; i++) {
0324         u32 val = mt76_rr(dev, MT_WF_SW_DEF_CR_USB_MCU_EVENT);
0325
0326         if (!(val & MT_WF_SW_SER_TRIGGER_SUSPEND)) {
0327             reinit = false;
0328             break;
0329         }
0330         if (val & MT_WF_SW_SER_DONE_SUSPEND) {
0331             mt76_wr(dev, MT_WF_SW_DEF_CR_USB_MCU_EVENT, 0);
0332             break;
0333         }
0334
0335         msleep(20);
0336     }
0337
0338     if (reinit || mt7921_dma_need_reinit(dev)) {
0339         err = mt7921u_dma_init(dev, true);
0340         if (err)
0341             return err;
0342     }
0343
0344     clear_bit(MT76_STATE_SUSPEND, &dev->mphy.state);
0345
0346     err = mt76u_resume_rx(&dev->mt76);
0347     if (err < 0)
0348         return err;
0349
0350     return mt76_connac_mcu_set_hif_suspend(&dev->mt76, false);
0351 }
0352 #endif /* CONFIG_PM */
0353
0354 MODULE_DEVICE_TABLE(usb, mt7921u_device_table);
0355 MODULE_FIRMWARE(MT7921_FIRMWARE_WM);
0356 MODULE_FIRMWARE(MT7921_ROM_PATCH);
0357
0358 static struct usb_driver mt7921u_driver = {
0359     .name       = KBUILD_MODNAME,
0360     .id_table   = mt7921u_device_table,
0361     .probe      = mt7921u_probe,
0362     .disconnect = mt7921u_disconnect,
0363 #ifdef CONFIG_PM
0364     .suspend    = mt7921u_suspend,
0365     .resume     = mt7921u_resume,
0366     .reset_resume   = mt7921u_resume,
0367 #endif /* CONFIG_PM */
0368     .soft_unbind    = 1,
0369     .disable_hub_initiated_lpm = 1,
0370 };
0371 module_usb_driver(mt7921u_driver);
0372
0373 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo@kernel.org>");
0374 MODULE_LICENSE("Dual BSD/GPL");