1 /* 2 * Copyright (C) 2015 Jakub Kicinski <kubakici@wp.pl> 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License version 2 6 * as published by the Free Software Foundation 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/usb.h> 17 18 #include "mt7601u.h" 19 #include "usb.h" 20 #include "trace.h" 21 22 static const struct usb_device_id mt7601u_device_table[] = { 23 { USB_DEVICE(0x0b05, 0x17d3) }, 24 { USB_DEVICE(0x0e8d, 0x760a) }, 25 { USB_DEVICE(0x0e8d, 0x760b) }, 26 { USB_DEVICE(0x13d3, 0x3431) }, 27 { USB_DEVICE(0x13d3, 0x3434) }, 28 { USB_DEVICE(0x148f, 0x7601) }, 29 { USB_DEVICE(0x148f, 0x760a) }, 30 { USB_DEVICE(0x148f, 0x760b) }, 31 { USB_DEVICE(0x148f, 0x760c) }, 32 { USB_DEVICE(0x148f, 0x760d) }, 33 { USB_DEVICE(0x2001, 0x3d04) }, 34 { USB_DEVICE(0x2717, 0x4106) }, 35 { USB_DEVICE(0x2955, 0x0001) }, 36 { USB_DEVICE(0x2955, 0x1001) }, 37 { USB_DEVICE(0x2a5f, 0x1000) }, 38 { USB_DEVICE(0x7392, 0x7710) }, 39 { 0, } 40 }; 41 42 bool mt7601u_usb_alloc_buf(struct mt7601u_dev *dev, size_t len, 43 struct mt7601u_dma_buf *buf) 44 { 45 struct usb_device *usb_dev = mt7601u_to_usb_dev(dev); 46 47 buf->len = len; 48 buf->urb = usb_alloc_urb(0, GFP_KERNEL); 49 buf->buf = usb_alloc_coherent(usb_dev, buf->len, GFP_KERNEL, &buf->dma); 50 51 return !buf->urb || !buf->buf; 52 } 53 54 void mt7601u_usb_free_buf(struct mt7601u_dev *dev, struct mt7601u_dma_buf *buf) 55 { 56 struct usb_device *usb_dev = mt7601u_to_usb_dev(dev); 57 58 usb_free_coherent(usb_dev, buf->len, buf->buf, buf->dma); 59 usb_free_urb(buf->urb); 60 } 61 62 int mt7601u_usb_submit_buf(struct mt7601u_dev *dev, int dir, int ep_idx, 63 struct mt7601u_dma_buf *buf, gfp_t gfp, 64 usb_complete_t complete_fn, void *context) 65 { 66 struct usb_device *usb_dev = mt7601u_to_usb_dev(dev); 67 unsigned pipe; 68 int ret; 69 70 if (dir == USB_DIR_IN) 71 pipe = usb_rcvbulkpipe(usb_dev, dev->in_eps[ep_idx]); 72 else 73 pipe = usb_sndbulkpipe(usb_dev, dev->out_eps[ep_idx]); 74 75 usb_fill_bulk_urb(buf->urb, usb_dev, pipe, buf->buf, buf->len, 76 complete_fn, context); 77 buf->urb->transfer_dma = buf->dma; 78 buf->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 79 80 trace_mt_submit_urb(dev, buf->urb); 81 ret = usb_submit_urb(buf->urb, gfp); 82 if (ret) 83 dev_err(dev->dev, "Error: submit URB dir:%d ep:%d failed:%d\n", 84 dir, ep_idx, ret); 85 return ret; 86 } 87 88 void mt7601u_complete_urb(struct urb *urb) 89 { 90 struct completion *cmpl = urb->context; 91 92 complete(cmpl); 93 } 94 95 int mt7601u_vendor_request(struct mt7601u_dev *dev, const u8 req, 96 const u8 direction, const u16 val, const u16 offset, 97 void *buf, const size_t buflen) 98 { 99 int i, ret; 100 struct usb_device *usb_dev = mt7601u_to_usb_dev(dev); 101 const u8 req_type = direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE; 102 const unsigned int pipe = (direction == USB_DIR_IN) ? 103 usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0); 104 105 for (i = 0; i < MT_VEND_REQ_MAX_RETRY; i++) { 106 ret = usb_control_msg(usb_dev, pipe, req, req_type, 107 val, offset, buf, buflen, 108 MT_VEND_REQ_TOUT_MS); 109 trace_mt_vend_req(dev, pipe, req, req_type, val, offset, 110 buf, buflen, ret); 111 112 if (ret == -ENODEV) 113 set_bit(MT7601U_STATE_REMOVED, &dev->state); 114 if (ret >= 0 || ret == -ENODEV) 115 return ret; 116 117 msleep(5); 118 } 119 120 dev_err(dev->dev, "Vendor request req:%02x off:%04x failed:%d\n", 121 req, offset, ret); 122 123 return ret; 124 } 125 126 void mt7601u_vendor_reset(struct mt7601u_dev *dev) 127 { 128 mt7601u_vendor_request(dev, MT_VEND_DEV_MODE, USB_DIR_OUT, 129 MT_VEND_DEV_MODE_RESET, 0, NULL, 0); 130 } 131 132 u32 mt7601u_rr(struct mt7601u_dev *dev, u32 offset) 133 { 134 int ret; 135 u32 val = ~0; 136 137 WARN_ONCE(offset > USHRT_MAX, "read high off:%08x", offset); 138 139 mutex_lock(&dev->vendor_req_mutex); 140 141 ret = mt7601u_vendor_request(dev, MT_VEND_MULTI_READ, USB_DIR_IN, 142 0, offset, dev->vend_buf, MT_VEND_BUF); 143 if (ret == MT_VEND_BUF) 144 val = get_unaligned_le32(dev->vend_buf); 145 else if (ret > 0) 146 dev_err(dev->dev, "Error: wrong size read:%d off:%08x\n", 147 ret, offset); 148 149 mutex_unlock(&dev->vendor_req_mutex); 150 151 trace_reg_read(dev, offset, val); 152 return val; 153 } 154 155 int mt7601u_vendor_single_wr(struct mt7601u_dev *dev, const u8 req, 156 const u16 offset, const u32 val) 157 { 158 int ret; 159 160 mutex_lock(&dev->vendor_req_mutex); 161 162 ret = mt7601u_vendor_request(dev, req, USB_DIR_OUT, 163 val & 0xffff, offset, NULL, 0); 164 if (!ret) 165 ret = mt7601u_vendor_request(dev, req, USB_DIR_OUT, 166 val >> 16, offset + 2, NULL, 0); 167 168 mutex_unlock(&dev->vendor_req_mutex); 169 170 return ret; 171 } 172 173 void mt7601u_wr(struct mt7601u_dev *dev, u32 offset, u32 val) 174 { 175 WARN_ONCE(offset > USHRT_MAX, "write high off:%08x", offset); 176 177 mt7601u_vendor_single_wr(dev, MT_VEND_WRITE, offset, val); 178 trace_reg_write(dev, offset, val); 179 } 180 181 u32 mt7601u_rmw(struct mt7601u_dev *dev, u32 offset, u32 mask, u32 val) 182 { 183 val |= mt7601u_rr(dev, offset) & ~mask; 184 mt7601u_wr(dev, offset, val); 185 return val; 186 } 187 188 u32 mt7601u_rmc(struct mt7601u_dev *dev, u32 offset, u32 mask, u32 val) 189 { 190 u32 reg = mt7601u_rr(dev, offset); 191 192 val |= reg & ~mask; 193 if (reg != val) 194 mt7601u_wr(dev, offset, val); 195 return val; 196 } 197 198 void mt7601u_wr_copy(struct mt7601u_dev *dev, u32 offset, 199 const void *data, int len) 200 { 201 WARN_ONCE(offset & 3, "unaligned write copy off:%08x", offset); 202 WARN_ONCE(len & 3, "short write copy off:%08x", offset); 203 204 mt7601u_burst_write_regs(dev, offset, data, len / 4); 205 } 206 207 void mt7601u_addr_wr(struct mt7601u_dev *dev, const u32 offset, const u8 *addr) 208 { 209 mt7601u_wr(dev, offset, get_unaligned_le32(addr)); 210 mt7601u_wr(dev, offset + 4, addr[4] | addr[5] << 8); 211 } 212 213 static int mt7601u_assign_pipes(struct usb_interface *usb_intf, 214 struct mt7601u_dev *dev) 215 { 216 struct usb_endpoint_descriptor *ep_desc; 217 struct usb_host_interface *intf_desc = usb_intf->cur_altsetting; 218 unsigned i, ep_i = 0, ep_o = 0; 219 220 BUILD_BUG_ON(sizeof(dev->in_eps) < __MT_EP_IN_MAX); 221 BUILD_BUG_ON(sizeof(dev->out_eps) < __MT_EP_OUT_MAX); 222 223 for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) { 224 ep_desc = &intf_desc->endpoint[i].desc; 225 226 if (usb_endpoint_is_bulk_in(ep_desc) && 227 ep_i++ < __MT_EP_IN_MAX) { 228 dev->in_eps[ep_i - 1] = usb_endpoint_num(ep_desc); 229 dev->in_max_packet = usb_endpoint_maxp(ep_desc); 230 /* Note: this is ignored by usb sub-system but vendor 231 * code does it. We can drop this at some point. 232 */ 233 dev->in_eps[ep_i - 1] |= USB_DIR_IN; 234 } else if (usb_endpoint_is_bulk_out(ep_desc) && 235 ep_o++ < __MT_EP_OUT_MAX) { 236 dev->out_eps[ep_o - 1] = usb_endpoint_num(ep_desc); 237 dev->out_max_packet = usb_endpoint_maxp(ep_desc); 238 } 239 } 240 241 if (ep_i != __MT_EP_IN_MAX || ep_o != __MT_EP_OUT_MAX) { 242 dev_err(dev->dev, "Error: wrong pipe number in:%d out:%d\n", 243 ep_i, ep_o); 244 return -EINVAL; 245 } 246 247 return 0; 248 } 249 250 static int mt7601u_probe(struct usb_interface *usb_intf, 251 const struct usb_device_id *id) 252 { 253 struct usb_device *usb_dev = interface_to_usbdev(usb_intf); 254 struct mt7601u_dev *dev; 255 u32 asic_rev, mac_rev; 256 int ret; 257 258 dev = mt7601u_alloc_device(&usb_intf->dev); 259 if (!dev) 260 return -ENOMEM; 261 262 usb_dev = usb_get_dev(usb_dev); 263 usb_reset_device(usb_dev); 264 265 usb_set_intfdata(usb_intf, dev); 266 267 dev->vend_buf = devm_kmalloc(dev->dev, MT_VEND_BUF, GFP_KERNEL); 268 if (!dev->vend_buf) { 269 ret = -ENOMEM; 270 goto err; 271 } 272 273 ret = mt7601u_assign_pipes(usb_intf, dev); 274 if (ret) 275 goto err; 276 ret = mt7601u_wait_asic_ready(dev); 277 if (ret) 278 goto err; 279 280 asic_rev = mt7601u_rr(dev, MT_ASIC_VERSION); 281 mac_rev = mt7601u_rr(dev, MT_MAC_CSR0); 282 dev_info(dev->dev, "ASIC revision: %08x MAC revision: %08x\n", 283 asic_rev, mac_rev); 284 285 /* Note: vendor driver skips this check for MT7601U */ 286 if (!(mt7601u_rr(dev, MT_EFUSE_CTRL) & MT_EFUSE_CTRL_SEL)) 287 dev_warn(dev->dev, "Warning: eFUSE not present\n"); 288 289 ret = mt7601u_init_hardware(dev); 290 if (ret) 291 goto err; 292 ret = mt7601u_register_device(dev); 293 if (ret) 294 goto err_hw; 295 296 set_bit(MT7601U_STATE_INITIALIZED, &dev->state); 297 298 return 0; 299 err_hw: 300 mt7601u_cleanup(dev); 301 err: 302 usb_set_intfdata(usb_intf, NULL); 303 usb_put_dev(interface_to_usbdev(usb_intf)); 304 305 destroy_workqueue(dev->stat_wq); 306 ieee80211_free_hw(dev->hw); 307 return ret; 308 } 309 310 static void mt7601u_disconnect(struct usb_interface *usb_intf) 311 { 312 struct mt7601u_dev *dev = usb_get_intfdata(usb_intf); 313 314 ieee80211_unregister_hw(dev->hw); 315 mt7601u_cleanup(dev); 316 317 usb_set_intfdata(usb_intf, NULL); 318 usb_put_dev(interface_to_usbdev(usb_intf)); 319 320 destroy_workqueue(dev->stat_wq); 321 ieee80211_free_hw(dev->hw); 322 } 323 324 static int mt7601u_suspend(struct usb_interface *usb_intf, pm_message_t state) 325 { 326 struct mt7601u_dev *dev = usb_get_intfdata(usb_intf); 327 328 mt7601u_cleanup(dev); 329 330 return 0; 331 } 332 333 static int mt7601u_resume(struct usb_interface *usb_intf) 334 { 335 struct mt7601u_dev *dev = usb_get_intfdata(usb_intf); 336 int ret; 337 338 ret = mt7601u_init_hardware(dev); 339 if (ret) 340 return ret; 341 342 set_bit(MT7601U_STATE_INITIALIZED, &dev->state); 343 344 return 0; 345 } 346 347 MODULE_DEVICE_TABLE(usb, mt7601u_device_table); 348 MODULE_FIRMWARE(MT7601U_FIRMWARE); 349 MODULE_LICENSE("GPL"); 350 351 static struct usb_driver mt7601u_driver = { 352 .name = KBUILD_MODNAME, 353 .id_table = mt7601u_device_table, 354 .probe = mt7601u_probe, 355 .disconnect = mt7601u_disconnect, 356 .suspend = mt7601u_suspend, 357 .resume = mt7601u_resume, 358 .reset_resume = mt7601u_resume, 359 .soft_unbind = 1, 360 .disable_hub_initiated_lpm = 1, 361 }; 362 module_usb_driver(mt7601u_driver); 363