2 * Copyright (C) 2015 Jakub Kicinski <kubakici@wp.pl>
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
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.
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/usb.h>
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) },
42 bool mt7601u_usb_alloc_buf(struct mt7601u_dev
*dev
, size_t len
,
43 struct mt7601u_dma_buf
*buf
)
45 struct usb_device
*usb_dev
= mt7601u_to_usb_dev(dev
);
48 buf
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
49 buf
->buf
= usb_alloc_coherent(usb_dev
, buf
->len
, GFP_KERNEL
, &buf
->dma
);
51 return !buf
->urb
|| !buf
->buf
;
54 void mt7601u_usb_free_buf(struct mt7601u_dev
*dev
, struct mt7601u_dma_buf
*buf
)
56 struct usb_device
*usb_dev
= mt7601u_to_usb_dev(dev
);
58 usb_free_coherent(usb_dev
, buf
->len
, buf
->buf
, buf
->dma
);
59 usb_free_urb(buf
->urb
);
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
)
66 struct usb_device
*usb_dev
= mt7601u_to_usb_dev(dev
);
70 if (dir
== USB_DIR_IN
)
71 pipe
= usb_rcvbulkpipe(usb_dev
, dev
->in_eps
[ep_idx
]);
73 pipe
= usb_sndbulkpipe(usb_dev
, dev
->out_eps
[ep_idx
]);
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
;
80 trace_mt_submit_urb(dev
, buf
->urb
);
81 ret
= usb_submit_urb(buf
->urb
, gfp
);
83 dev_err(dev
->dev
, "Error: submit URB dir:%d ep:%d failed:%d\n",
88 void mt7601u_complete_urb(struct urb
*urb
)
90 struct completion
*cmpl
= urb
->context
;
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
)
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);
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
,
113 if (ret
>= 0 || ret
== -ENODEV
)
119 dev_err(dev
->dev
, "Vendor request req:%02x off:%04x failed:%d\n",
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
)
132 mutex_lock(&dev
->vendor_req_mutex
);
134 ret
= __mt7601u_vendor_request(dev
, req
, direction
, val
, offset
,
137 set_bit(MT7601U_STATE_REMOVED
, &dev
->state
);
139 mutex_unlock(&dev
->vendor_req_mutex
);
144 void mt7601u_vendor_reset(struct mt7601u_dev
*dev
)
146 mt7601u_vendor_request(dev
, MT_VEND_DEV_MODE
, USB_DIR_OUT
,
147 MT_VEND_DEV_MODE_RESET
, 0, NULL
, 0);
150 u32
mt7601u_rr(struct mt7601u_dev
*dev
, u32 offset
)
156 WARN_ONCE(offset
> USHRT_MAX
, "read high off:%08x", offset
);
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",
167 trace_reg_read(dev
, offset
, val
);
171 int mt7601u_vendor_single_wr(struct mt7601u_dev
*dev
, const u8 req
,
172 const u16 offset
, const u32 val
)
176 ret
= mt7601u_vendor_request(dev
, req
, USB_DIR_OUT
,
177 val
& 0xffff, offset
, NULL
, 0);
180 return mt7601u_vendor_request(dev
, req
, USB_DIR_OUT
,
181 val
>> 16, offset
+ 2, NULL
, 0);
184 void mt7601u_wr(struct mt7601u_dev
*dev
, u32 offset
, u32 val
)
186 WARN_ONCE(offset
> USHRT_MAX
, "write high off:%08x", offset
);
188 mt7601u_vendor_single_wr(dev
, MT_VEND_WRITE
, offset
, val
);
189 trace_reg_write(dev
, offset
, val
);
192 u32
mt7601u_rmw(struct mt7601u_dev
*dev
, u32 offset
, u32 mask
, u32 val
)
194 val
|= mt7601u_rr(dev
, offset
) & ~mask
;
195 mt7601u_wr(dev
, offset
, val
);
199 u32
mt7601u_rmc(struct mt7601u_dev
*dev
, u32 offset
, u32 mask
, u32 val
)
201 u32 reg
= mt7601u_rr(dev
, offset
);
205 mt7601u_wr(dev
, offset
, val
);
209 void mt7601u_wr_copy(struct mt7601u_dev
*dev
, u32 offset
,
210 const void *data
, int len
)
212 WARN_ONCE(offset
& 3, "unaligned write copy off:%08x", offset
);
213 WARN_ONCE(len
& 3, "short write copy off:%08x", offset
);
215 mt7601u_burst_write_regs(dev
, offset
, data
, len
/ 4);
218 void mt7601u_addr_wr(struct mt7601u_dev
*dev
, const u32 offset
, const u8
*addr
)
220 mt7601u_wr(dev
, offset
, get_unaligned_le32(addr
));
221 mt7601u_wr(dev
, offset
+ 4, addr
[4] | addr
[5] << 8);
224 static int mt7601u_assign_pipes(struct usb_interface
*usb_intf
,
225 struct mt7601u_dev
*dev
)
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;
231 BUILD_BUG_ON(sizeof(dev
->in_eps
) < __MT_EP_IN_MAX
);
232 BUILD_BUG_ON(sizeof(dev
->out_eps
) < __MT_EP_OUT_MAX
);
234 for (i
= 0; i
< intf_desc
->desc
.bNumEndpoints
; i
++) {
235 ep_desc
= &intf_desc
->endpoint
[i
].desc
;
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.
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
);
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",
261 static int mt7601u_probe(struct usb_interface
*usb_intf
,
262 const struct usb_device_id
*id
)
264 struct usb_device
*usb_dev
= interface_to_usbdev(usb_intf
);
265 struct mt7601u_dev
*dev
;
266 u32 asic_rev
, mac_rev
;
269 dev
= mt7601u_alloc_device(&usb_intf
->dev
);
273 usb_dev
= usb_get_dev(usb_dev
);
274 usb_reset_device(usb_dev
);
276 usb_set_intfdata(usb_intf
, dev
);
278 ret
= mt7601u_assign_pipes(usb_intf
, dev
);
281 ret
= mt7601u_wait_asic_ready(dev
);
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",
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");
294 ret
= mt7601u_init_hardware(dev
);
297 ret
= mt7601u_register_device(dev
);
301 set_bit(MT7601U_STATE_INITIALIZED
, &dev
->state
);
305 mt7601u_cleanup(dev
);
307 usb_set_intfdata(usb_intf
, NULL
);
308 usb_put_dev(interface_to_usbdev(usb_intf
));
310 destroy_workqueue(dev
->stat_wq
);
311 ieee80211_free_hw(dev
->hw
);
315 static void mt7601u_disconnect(struct usb_interface
*usb_intf
)
317 struct mt7601u_dev
*dev
= usb_get_intfdata(usb_intf
);
319 ieee80211_unregister_hw(dev
->hw
);
320 mt7601u_cleanup(dev
);
322 usb_set_intfdata(usb_intf
, NULL
);
323 usb_put_dev(interface_to_usbdev(usb_intf
));
325 destroy_workqueue(dev
->stat_wq
);
326 ieee80211_free_hw(dev
->hw
);
329 static int mt7601u_suspend(struct usb_interface
*usb_intf
, pm_message_t state
)
331 struct mt7601u_dev
*dev
= usb_get_intfdata(usb_intf
);
333 mt7601u_cleanup(dev
);
338 static int mt7601u_resume(struct usb_interface
*usb_intf
)
340 struct mt7601u_dev
*dev
= usb_get_intfdata(usb_intf
);
342 return mt7601u_init_hardware(dev
);
345 MODULE_DEVICE_TABLE(usb
, mt7601u_device_table
);
346 MODULE_FIRMWARE(MT7601U_FIRMWARE
);
347 MODULE_LICENSE("GPL");
349 static struct usb_driver mt7601u_driver
= {
350 .name
= KBUILD_MODNAME
,
351 .id_table
= mt7601u_device_table
,
352 .probe
= mt7601u_probe
,
353 .disconnect
= mt7601u_disconnect
,
354 .suspend
= mt7601u_suspend
,
355 .resume
= mt7601u_resume
,
356 .reset_resume
= mt7601u_resume
,
358 .disable_hub_initiated_lpm
= 1,
360 module_usb_driver(mt7601u_driver
);