1 // SPDX-License-Identifier: ISC 2 /* Copyright (C) 2019 MediaTek Inc. 3 * 4 * Author: Felix Fietkau <nbd@nbd.name> 5 * Lorenzo Bianconi <lorenzo@kernel.org> 6 * Sean Wang <sean.wang@mediatek.com> 7 */ 8 9 #include <linux/kernel.h> 10 #include <linux/module.h> 11 #include <linux/usb.h> 12 13 #include "mt7615.h" 14 #include "mac.h" 15 #include "mcu.h" 16 #include "regs.h" 17 18 static const struct usb_device_id mt7615_device_table[] = { 19 { USB_DEVICE_AND_INTERFACE_INFO(0x0e8d, 0x7663, 0xff, 0xff, 0xff) }, 20 { USB_DEVICE_AND_INTERFACE_INFO(0x043e, 0x310c, 0xff, 0xff, 0xff) }, 21 { }, 22 }; 23 24 static u32 mt7663u_rr(struct mt76_dev *dev, u32 addr) 25 { 26 u32 ret; 27 28 mutex_lock(&dev->usb.usb_ctrl_mtx); 29 ret = ___mt76u_rr(dev, MT_VEND_READ_EXT, 30 USB_DIR_IN | USB_TYPE_VENDOR, addr); 31 mutex_unlock(&dev->usb.usb_ctrl_mtx); 32 33 return ret; 34 } 35 36 static void mt7663u_wr(struct mt76_dev *dev, u32 addr, u32 val) 37 { 38 mutex_lock(&dev->usb.usb_ctrl_mtx); 39 ___mt76u_wr(dev, MT_VEND_WRITE_EXT, 40 USB_DIR_OUT | USB_TYPE_VENDOR, addr, val); 41 mutex_unlock(&dev->usb.usb_ctrl_mtx); 42 } 43 44 static u32 mt7663u_rmw(struct mt76_dev *dev, u32 addr, 45 u32 mask, u32 val) 46 { 47 mutex_lock(&dev->usb.usb_ctrl_mtx); 48 val |= ___mt76u_rr(dev, MT_VEND_READ_EXT, 49 USB_DIR_IN | USB_TYPE_VENDOR, addr) & ~mask; 50 ___mt76u_wr(dev, MT_VEND_WRITE_EXT, 51 USB_DIR_OUT | USB_TYPE_VENDOR, addr, val); 52 mutex_unlock(&dev->usb.usb_ctrl_mtx); 53 54 return val; 55 } 56 57 static void mt7663u_copy(struct mt76_dev *dev, u32 offset, 58 const void *data, int len) 59 { 60 struct mt76_usb *usb = &dev->usb; 61 int ret, i = 0, batch_len; 62 const u8 *val = data; 63 64 len = round_up(len, 4); 65 66 mutex_lock(&usb->usb_ctrl_mtx); 67 while (i < len) { 68 batch_len = min_t(int, usb->data_len, len - i); 69 memcpy(usb->data, val + i, batch_len); 70 ret = __mt76u_vendor_request(dev, MT_VEND_WRITE_EXT, 71 USB_DIR_OUT | USB_TYPE_VENDOR, 72 (offset + i) >> 16, offset + i, 73 usb->data, batch_len); 74 if (ret < 0) 75 break; 76 77 i += batch_len; 78 } 79 mutex_unlock(&usb->usb_ctrl_mtx); 80 } 81 82 static void mt7663u_stop(struct ieee80211_hw *hw) 83 { 84 struct mt7615_phy *phy = mt7615_hw_phy(hw); 85 struct mt7615_dev *dev = hw->priv; 86 87 clear_bit(MT76_STATE_RUNNING, &dev->mphy.state); 88 del_timer_sync(&phy->roc_timer); 89 cancel_work_sync(&phy->roc_work); 90 cancel_delayed_work_sync(&phy->scan_work); 91 cancel_delayed_work_sync(&phy->mt76->mac_work); 92 mt76u_stop_tx(&dev->mt76); 93 } 94 95 static void mt7663u_cleanup(struct mt7615_dev *dev) 96 { 97 clear_bit(MT76_STATE_INITIALIZED, &dev->mphy.state); 98 mt76u_queues_deinit(&dev->mt76); 99 } 100 101 static void mt7663u_init_work(struct work_struct *work) 102 { 103 struct mt7615_dev *dev; 104 105 dev = container_of(work, struct mt7615_dev, mcu_work); 106 if (mt7663u_mcu_init(dev)) 107 return; 108 109 mt7615_init_work(dev); 110 } 111 112 static int mt7663u_probe(struct usb_interface *usb_intf, 113 const struct usb_device_id *id) 114 { 115 static const struct mt76_driver_ops drv_ops = { 116 .txwi_size = MT_USB_TXD_SIZE, 117 .drv_flags = MT_DRV_RX_DMA_HDR | MT_DRV_HW_MGMT_TXQ, 118 .tx_prepare_skb = mt7663_usb_sdio_tx_prepare_skb, 119 .tx_complete_skb = mt7663_usb_sdio_tx_complete_skb, 120 .tx_status_data = mt7663_usb_sdio_tx_status_data, 121 .rx_skb = mt7615_queue_rx_skb, 122 .rx_check = mt7615_rx_check, 123 .sta_add = mt7615_mac_sta_add, 124 .sta_remove = mt7615_mac_sta_remove, 125 .update_survey = mt7615_update_channel, 126 }; 127 static struct mt76_bus_ops bus_ops = { 128 .rr = mt7663u_rr, 129 .wr = mt7663u_wr, 130 .rmw = mt7663u_rmw, 131 .read_copy = mt76u_read_copy, 132 .write_copy = mt7663u_copy, 133 .type = MT76_BUS_USB, 134 }; 135 struct usb_device *udev = interface_to_usbdev(usb_intf); 136 struct ieee80211_ops *ops; 137 struct mt7615_dev *dev; 138 struct mt76_dev *mdev; 139 int ret; 140 141 ops = devm_kmemdup(&usb_intf->dev, &mt7615_ops, sizeof(mt7615_ops), 142 GFP_KERNEL); 143 if (!ops) 144 return -ENOMEM; 145 146 ops->stop = mt7663u_stop; 147 148 mdev = mt76_alloc_device(&usb_intf->dev, sizeof(*dev), ops, &drv_ops); 149 if (!mdev) 150 return -ENOMEM; 151 152 dev = container_of(mdev, struct mt7615_dev, mt76); 153 udev = usb_get_dev(udev); 154 usb_reset_device(udev); 155 156 usb_set_intfdata(usb_intf, dev); 157 158 INIT_WORK(&dev->mcu_work, mt7663u_init_work); 159 dev->reg_map = mt7663_usb_sdio_reg_map; 160 dev->ops = ops; 161 ret = __mt76u_init(mdev, usb_intf, &bus_ops); 162 if (ret < 0) 163 goto error; 164 165 mdev->rev = (mt76_rr(dev, MT_HW_CHIPID) << 16) | 166 (mt76_rr(dev, MT_HW_REV) & 0xff); 167 dev_dbg(mdev->dev, "ASIC revision: %04x\n", mdev->rev); 168 169 if (!mt76_poll_msec(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_PWR_ON, 170 FW_STATE_PWR_ON << 1, 500)) { 171 ret = mt7663u_mcu_power_on(dev); 172 if (ret) 173 goto error; 174 } else { 175 set_bit(MT76_STATE_POWER_OFF, &dev->mphy.state); 176 } 177 178 ret = mt76u_alloc_mcu_queue(&dev->mt76); 179 if (ret) 180 goto error; 181 182 ret = mt76u_alloc_queues(&dev->mt76); 183 if (ret) 184 goto error; 185 186 ret = mt7663_usb_sdio_register_device(dev); 187 if (ret) 188 goto error; 189 190 return 0; 191 192 error: 193 mt76u_queues_deinit(&dev->mt76); 194 usb_set_intfdata(usb_intf, NULL); 195 usb_put_dev(interface_to_usbdev(usb_intf)); 196 197 mt76_free_device(&dev->mt76); 198 199 return ret; 200 } 201 202 static void mt7663u_disconnect(struct usb_interface *usb_intf) 203 { 204 struct mt7615_dev *dev = usb_get_intfdata(usb_intf); 205 206 if (!test_bit(MT76_STATE_INITIALIZED, &dev->mphy.state)) 207 return; 208 209 ieee80211_unregister_hw(dev->mt76.hw); 210 mt7663u_cleanup(dev); 211 212 usb_set_intfdata(usb_intf, NULL); 213 usb_put_dev(interface_to_usbdev(usb_intf)); 214 215 mt76_free_device(&dev->mt76); 216 } 217 218 #ifdef CONFIG_PM 219 static int mt7663u_suspend(struct usb_interface *intf, pm_message_t state) 220 { 221 struct mt7615_dev *dev = usb_get_intfdata(intf); 222 223 if (!test_bit(MT76_STATE_SUSPEND, &dev->mphy.state) && 224 mt7615_firmware_offload(dev)) { 225 int err; 226 227 err = mt76_connac_mcu_set_hif_suspend(&dev->mt76, true); 228 if (err < 0) 229 return err; 230 } 231 232 mt76u_stop_rx(&dev->mt76); 233 mt76u_stop_tx(&dev->mt76); 234 235 return 0; 236 } 237 238 static int mt7663u_resume(struct usb_interface *intf) 239 { 240 struct mt7615_dev *dev = usb_get_intfdata(intf); 241 int err; 242 243 err = mt76u_vendor_request(&dev->mt76, MT_VEND_FEATURE_SET, 244 USB_DIR_OUT | USB_TYPE_VENDOR, 245 0x5, 0x0, NULL, 0); 246 if (err) 247 return err; 248 249 err = mt76u_resume_rx(&dev->mt76); 250 if (err < 0) 251 return err; 252 253 if (!test_bit(MT76_STATE_SUSPEND, &dev->mphy.state) && 254 mt7615_firmware_offload(dev)) 255 err = mt76_connac_mcu_set_hif_suspend(&dev->mt76, false); 256 257 return err; 258 } 259 #endif /* CONFIG_PM */ 260 261 MODULE_DEVICE_TABLE(usb, mt7615_device_table); 262 MODULE_FIRMWARE(MT7663_OFFLOAD_FIRMWARE_N9); 263 MODULE_FIRMWARE(MT7663_OFFLOAD_ROM_PATCH); 264 MODULE_FIRMWARE(MT7663_FIRMWARE_N9); 265 MODULE_FIRMWARE(MT7663_ROM_PATCH); 266 267 static struct usb_driver mt7663u_driver = { 268 .name = KBUILD_MODNAME, 269 .id_table = mt7615_device_table, 270 .probe = mt7663u_probe, 271 .disconnect = mt7663u_disconnect, 272 #ifdef CONFIG_PM 273 .suspend = mt7663u_suspend, 274 .resume = mt7663u_resume, 275 .reset_resume = mt7663u_resume, 276 #endif /* CONFIG_PM */ 277 .soft_unbind = 1, 278 .disable_hub_initiated_lpm = 1, 279 }; 280 module_usb_driver(mt7663u_driver); 281 282 MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>"); 283 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo@kernel.org>"); 284 MODULE_DESCRIPTION("MediaTek MT7663U (USB) wireless driver"); 285 MODULE_LICENSE("Dual BSD/GPL"); 286