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 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 static int 96 __mt7601u_vendor_request(struct mt7601u_dev *dev, const u8 req, 97 const u8 direction, const u16 val, const u16 offset, 98 void *buf, const size_t buflen) 99 { 100 int i, ret; 101 struct usb_device *usb_dev = mt7601u_to_usb_dev(dev); 102 const u8 req_type = direction | USB_TYPE_VENDOR | USB_RECIP_DEVICE; 103 const unsigned int pipe = (direction == USB_DIR_IN) ? 104 usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0); 105 106 for (i = 0; i < MT_VEND_REQ_MAX_RETRY; i++) { 107 ret = usb_control_msg(usb_dev, pipe, req, req_type, 108 val, offset, buf, buflen, 109 MT_VEND_REQ_TOUT_MS); 110 trace_mt_vend_req(dev, pipe, req, req_type, val, offset, 111 buf, buflen, ret); 112 113 if (ret >= 0 || ret == -ENODEV) 114 return ret; 115 116 msleep(5); 117 } 118 119 dev_err(dev->dev, "Vendor request req:%02x off:%04x failed:%d\n", 120 req, offset, ret); 121 122 return ret; 123 } 124 125 int 126 mt7601u_vendor_request(struct mt7601u_dev *dev, const u8 req, 127 const u8 direction, const u16 val, const u16 offset, 128 void *buf, const size_t buflen) 129 { 130 int ret; 131 132 mutex_lock(&dev->vendor_req_mutex); 133 134 ret = __mt7601u_vendor_request(dev, req, direction, val, offset, 135 buf, buflen); 136 if (ret == -ENODEV) 137 set_bit(MT7601U_STATE_REMOVED, &dev->state); 138 139 mutex_unlock(&dev->vendor_req_mutex); 140 141 return ret; 142 } 143 144 void mt7601u_vendor_reset(struct mt7601u_dev *dev) 145 { 146 mt7601u_vendor_request(dev, MT_VEND_DEV_MODE, USB_DIR_OUT, 147 MT_VEND_DEV_MODE_RESET, 0, NULL, 0); 148 } 149 150 u32 mt7601u_rr(struct mt7601u_dev *dev, u32 offset) 151 { 152 int ret; 153 __le32 reg; 154 u32 val; 155 156 WARN_ONCE(offset > USHRT_MAX, "read high off:%08x", offset); 157 158 ret = mt7601u_vendor_request(dev, MT_VEND_MULTI_READ, USB_DIR_IN, 159 0, offset, ®, sizeof(reg)); 160 val = le32_to_cpu(reg); 161 if (ret > 0 && ret != sizeof(reg)) { 162 dev_err(dev->dev, "Error: wrong size read:%d off:%08x\n", 163 ret, offset); 164 val = ~0; 165 } 166 167 trace_reg_read(dev, offset, val); 168 return val; 169 } 170 171 int mt7601u_vendor_single_wr(struct mt7601u_dev *dev, const u8 req, 172 const u16 offset, const u32 val) 173 { 174 int ret; 175 176 ret = mt7601u_vendor_request(dev, req, USB_DIR_OUT, 177 val & 0xffff, offset, NULL, 0); 178 if (ret) 179 return ret; 180 return mt7601u_vendor_request(dev, req, USB_DIR_OUT, 181 val >> 16, offset + 2, NULL, 0); 182 } 183 184 void mt7601u_wr(struct mt7601u_dev *dev, u32 offset, u32 val) 185 { 186 WARN_ONCE(offset > USHRT_MAX, "write high off:%08x", offset); 187 188 mt7601u_vendor_single_wr(dev, MT_VEND_WRITE, offset, val); 189 trace_reg_write(dev, offset, val); 190 } 191 192 u32 mt7601u_rmw(struct mt7601u_dev *dev, u32 offset, u32 mask, u32 val) 193 { 194 val |= mt7601u_rr(dev, offset) & ~mask; 195 mt7601u_wr(dev, offset, val); 196 return val; 197 } 198 199 u32 mt7601u_rmc(struct mt7601u_dev *dev, u32 offset, u32 mask, u32 val) 200 { 201 u32 reg = mt7601u_rr(dev, offset); 202 203 val |= reg & ~mask; 204 if (reg != val) 205 mt7601u_wr(dev, offset, val); 206 return val; 207 } 208 209 void mt7601u_wr_copy(struct mt7601u_dev *dev, u32 offset, 210 const void *data, int len) 211 { 212 WARN_ONCE(offset & 3, "unaligned write copy off:%08x", offset); 213 WARN_ONCE(len & 3, "short write copy off:%08x", offset); 214 215 mt7601u_burst_write_regs(dev, offset, data, len / 4); 216 } 217 218 void mt7601u_addr_wr(struct mt7601u_dev *dev, const u32 offset, const u8 *addr) 219 { 220 mt7601u_wr(dev, offset, get_unaligned_le32(addr)); 221 mt7601u_wr(dev, offset + 4, addr[4] | addr[5] << 8); 222 } 223 224 static int mt7601u_assign_pipes(struct usb_interface *usb_intf, 225 struct mt7601u_dev *dev) 226 { 227 struct usb_endpoint_descriptor *ep_desc; 228 struct usb_host_interface *intf_desc = usb_intf->cur_altsetting; 229 unsigned i, ep_i = 0, ep_o = 0; 230 231 BUILD_BUG_ON(sizeof(dev->in_eps) < __MT_EP_IN_MAX); 232 BUILD_BUG_ON(sizeof(dev->out_eps) < __MT_EP_OUT_MAX); 233 234 for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) { 235 ep_desc = &intf_desc->endpoint[i].desc; 236 237 if (usb_endpoint_is_bulk_in(ep_desc) && 238 ep_i++ < __MT_EP_IN_MAX) { 239 dev->in_eps[ep_i - 1] = usb_endpoint_num(ep_desc); 240 dev->in_max_packet = usb_endpoint_maxp(ep_desc); 241 /* Note: this is ignored by usb sub-system but vendor 242 * code does it. We can drop this at some point. 243 */ 244 dev->in_eps[ep_i - 1] |= USB_DIR_IN; 245 } else if (usb_endpoint_is_bulk_out(ep_desc) && 246 ep_o++ < __MT_EP_OUT_MAX) { 247 dev->out_eps[ep_o - 1] = usb_endpoint_num(ep_desc); 248 dev->out_max_packet = usb_endpoint_maxp(ep_desc); 249 } 250 } 251 252 if (ep_i != __MT_EP_IN_MAX || ep_o != __MT_EP_OUT_MAX) { 253 dev_err(dev->dev, "Error: wrong pipe number in:%d out:%d\n", 254 ep_i, ep_o); 255 return -EINVAL; 256 } 257 258 return 0; 259 } 260 261 static int mt7601u_probe(struct usb_interface *usb_intf, 262 const struct usb_device_id *id) 263 { 264 struct usb_device *usb_dev = interface_to_usbdev(usb_intf); 265 struct mt7601u_dev *dev; 266 u32 asic_rev, mac_rev; 267 int ret; 268 269 dev = mt7601u_alloc_device(&usb_intf->dev); 270 if (!dev) 271 return -ENOMEM; 272 273 usb_dev = usb_get_dev(usb_dev); 274 usb_reset_device(usb_dev); 275 276 usb_set_intfdata(usb_intf, dev); 277 278 ret = mt7601u_assign_pipes(usb_intf, dev); 279 if (ret) 280 goto err; 281 ret = mt7601u_wait_asic_ready(dev); 282 if (ret) 283 goto err; 284 285 asic_rev = mt7601u_rr(dev, MT_ASIC_VERSION); 286 mac_rev = mt7601u_rr(dev, MT_MAC_CSR0); 287 dev_info(dev->dev, "ASIC revision: %08x MAC revision: %08x\n", 288 asic_rev, mac_rev); 289 290 /* Note: vendor driver skips this check for MT7601U */ 291 if (!(mt7601u_rr(dev, MT_EFUSE_CTRL) & MT_EFUSE_CTRL_SEL)) 292 dev_warn(dev->dev, "Warning: eFUSE not present\n"); 293 294 ret = mt7601u_init_hardware(dev); 295 if (ret) 296 goto err; 297 ret = mt7601u_register_device(dev); 298 if (ret) 299 goto err_hw; 300 301 set_bit(MT7601U_STATE_INITIALIZED, &dev->state); 302 303 return 0; 304 err_hw: 305 mt7601u_cleanup(dev); 306 err: 307 usb_set_intfdata(usb_intf, NULL); 308 usb_put_dev(interface_to_usbdev(usb_intf)); 309 310 destroy_workqueue(dev->stat_wq); 311 ieee80211_free_hw(dev->hw); 312 return ret; 313 } 314 315 static void mt7601u_disconnect(struct usb_interface *usb_intf) 316 { 317 struct mt7601u_dev *dev = usb_get_intfdata(usb_intf); 318 319 ieee80211_unregister_hw(dev->hw); 320 mt7601u_cleanup(dev); 321 322 usb_set_intfdata(usb_intf, NULL); 323 usb_put_dev(interface_to_usbdev(usb_intf)); 324 325 destroy_workqueue(dev->stat_wq); 326 ieee80211_free_hw(dev->hw); 327 } 328 329 static int mt7601u_suspend(struct usb_interface *usb_intf, pm_message_t state) 330 { 331 struct mt7601u_dev *dev = usb_get_intfdata(usb_intf); 332 333 mt7601u_cleanup(dev); 334 335 return 0; 336 } 337 338 static int mt7601u_resume(struct usb_interface *usb_intf) 339 { 340 struct mt7601u_dev *dev = usb_get_intfdata(usb_intf); 341 int ret; 342 343 ret = mt7601u_init_hardware(dev); 344 if (ret) 345 return ret; 346 347 set_bit(MT7601U_STATE_INITIALIZED, &dev->state); 348 349 return 0; 350 } 351 352 MODULE_DEVICE_TABLE(usb, mt7601u_device_table); 353 MODULE_FIRMWARE(MT7601U_FIRMWARE); 354 MODULE_LICENSE("GPL"); 355 356 static struct usb_driver mt7601u_driver = { 357 .name = KBUILD_MODNAME, 358 .id_table = mt7601u_device_table, 359 .probe = mt7601u_probe, 360 .disconnect = mt7601u_disconnect, 361 .suspend = mt7601u_suspend, 362 .resume = mt7601u_resume, 363 .reset_resume = mt7601u_resume, 364 .soft_unbind = 1, 365 .disable_hub_initiated_lpm = 1, 366 }; 367 module_usb_driver(mt7601u_driver); 368