Commit | Line | Data |
---|---|---|
eff1a59c MW |
1 | |
2 | /* | |
3 | * Linux device driver for USB based Prism54 | |
4 | * | |
5 | * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net> | |
6 | * | |
7 | * Based on the islsm (softmac prism54) driver, which is: | |
8 | * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al. | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License version 2 as | |
12 | * published by the Free Software Foundation. | |
13 | */ | |
14 | ||
15 | #include <linux/init.h> | |
16 | #include <linux/usb.h> | |
17 | #include <linux/pci.h> | |
5a0e3ad6 | 18 | #include <linux/slab.h> |
eff1a59c MW |
19 | #include <linux/firmware.h> |
20 | #include <linux/etherdevice.h> | |
21 | #include <linux/delay.h> | |
22 | #include <linux/crc32.h> | |
9d9779e7 | 23 | #include <linux/module.h> |
eff1a59c MW |
24 | #include <net/mac80211.h> |
25 | ||
26 | #include "p54.h" | |
d8c92107 | 27 | #include "lmac.h" |
eff1a59c MW |
28 | #include "p54usb.h" |
29 | ||
30 | MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>"); | |
31 | MODULE_DESCRIPTION("Prism54 USB wireless driver"); | |
32 | MODULE_LICENSE("GPL"); | |
33 | MODULE_ALIAS("prism54usb"); | |
9a8675d7 CL |
34 | MODULE_FIRMWARE("isl3886usb"); |
35 | MODULE_FIRMWARE("isl3887usb"); | |
eff1a59c | 36 | |
1a92795d CL |
37 | /* |
38 | * Note: | |
39 | * | |
40 | * Always update our wiki's device list (located at: | |
41 | * http://wireless.kernel.org/en/users/Drivers/p54/devices ), | |
42 | * whenever you add a new device. | |
43 | */ | |
44 | ||
b9c4167c | 45 | static struct usb_device_id p54u_table[] = { |
eff1a59c | 46 | /* Version 1 devices (pci chip + net2280) */ |
16cad7fb | 47 | {USB_DEVICE(0x0411, 0x0050)}, /* Buffalo WLI2-USB2-G54 */ |
1a92795d | 48 | {USB_DEVICE(0x045e, 0x00c2)}, /* Microsoft MN-710 */ |
eff1a59c | 49 | {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */ |
4010fe21 | 50 | {USB_DEVICE(0x0675, 0x0530)}, /* DrayTek Vigor 530 */ |
05a9a161 | 51 | {USB_DEVICE(0x06b9, 0x0120)}, /* Thomson SpeedTouch 120g */ |
eff1a59c | 52 | {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */ |
15a69a81 | 53 | {USB_DEVICE(0x07aa, 0x001c)}, /* Corega CG-WLUSB2GT */ |
eff1a59c MW |
54 | {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */ |
55 | {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */ | |
1a17582e | 56 | {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */ |
eff1a59c MW |
57 | {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */ |
58 | {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */ | |
59 | {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */ | |
ec366eba | 60 | {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */ |
22010761 | 61 | {USB_DEVICE(0x0bf8, 0x1007)}, /* Fujitsu E-5400 USB */ |
eff1a59c | 62 | {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */ |
16cad7fb | 63 | {USB_DEVICE(0x0db0, 0x6826)}, /* MSI UB54G (MS-6826) */ |
1a92795d | 64 | {USB_DEVICE(0x107b, 0x55f2)}, /* Gateway WGU-210 (Gemtek) */ |
eff1a59c | 65 | {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */ |
16cad7fb | 66 | {USB_DEVICE(0x1435, 0x0210)}, /* Inventel UR054G */ |
56e6417b | 67 | {USB_DEVICE(0x15a9, 0x0002)}, /* Gemtek WUBI-100GW 802.11g */ |
1a92795d | 68 | {USB_DEVICE(0x1630, 0x0005)}, /* 2Wire 802.11g USB (v1) / Z-Com */ |
16cad7fb | 69 | {USB_DEVICE(0x182d, 0x096b)}, /* Sitecom WL-107 */ |
eff1a59c MW |
70 | {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */ |
71 | {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */ | |
72 | {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */ | |
73 | {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */ | |
22010761 | 74 | {USB_DEVICE(0x2001, 0x3762)}, /* Conceptronic C54U */ |
eff1a59c MW |
75 | {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */ |
76 | {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */ | |
77 | ||
78 | /* Version 2 devices (3887) */ | |
4546002c | 79 | {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */ |
eff1a59c MW |
80 | {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */ |
81 | {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */ | |
82 | {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */ | |
1a92795d | 83 | {USB_DEVICE(0x06a9, 0x000e)}, /* Westell 802.11g USB (A90-211WG-01) */ |
878e6a43 | 84 | {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */ |
eff1a59c | 85 | {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */ |
1e43692c | 86 | {USB_DEVICE(0x07aa, 0x0020)}, /* Corega WLUSB2GTST USB */ |
4010fe21 | 87 | {USB_DEVICE(0x0803, 0x4310)}, /* Zoom 4410a */ |
eff1a59c | 88 | {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */ |
008e33f7 | 89 | {USB_DEVICE(0x083a, 0x4531)}, /* T-Com Sinus 154 data II */ |
9368a9a2 | 90 | {USB_DEVICE(0x083a, 0xc501)}, /* Zoom Wireless-G 4410 */ |
5b9a919a | 91 | {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */ |
eff1a59c MW |
92 | {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */ |
93 | {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */ | |
94 | {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */ | |
95 | {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/ | |
96 | {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/ | |
7484bdc0 LO |
97 | /* {USB_DEVICE(0x0cde, 0x0006)}, * Medion MD40900 already listed above, |
98 | * just noting it here for clarity */ | |
eff1a59c | 99 | {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */ |
f7f71173 | 100 | {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */ |
eff1a59c | 101 | {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */ |
43557e15 | 102 | {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */ |
ec366eba | 103 | {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */ |
387e100a | 104 | {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */ |
c1098103 | 105 | {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */ |
e3062403 | 106 | {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */ |
eff1a59c | 107 | {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */ |
4010fe21 | 108 | /* {USB_DEVICE(0x15a9, 0x0002)}, * Also SparkLAN WL-682 with 3887 */ |
1a92795d | 109 | {USB_DEVICE(0x1668, 0x1050)}, /* Actiontec 802UIG-1 */ |
2b799a6b | 110 | {USB_DEVICE(0x1740, 0x1000)}, /* Senao NUB-350 */ |
eff1a59c | 111 | {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */ |
16cad7fb | 112 | {USB_DEVICE(0x2001, 0x3705)}, /* D-Link DWL-G120 rev C1 */ |
0f666a08 | 113 | {USB_DEVICE(0x413c, 0x5513)}, /* Dell WLA3310 USB Wireless Adapter */ |
eff1a59c MW |
114 | {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */ |
115 | {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */ | |
116 | {} | |
117 | }; | |
118 | ||
119 | MODULE_DEVICE_TABLE(usb, p54u_table); | |
120 | ||
1ca5f2e9 CL |
121 | static const struct { |
122 | u32 intf; | |
123 | enum p54u_hw_type type; | |
328d84fb | 124 | const char *fw; |
1ca5f2e9 CL |
125 | char hw[20]; |
126 | } p54u_fwlist[__NUM_P54U_HWTYPES] = { | |
127 | { | |
128 | .type = P54U_NET2280, | |
129 | .intf = FW_LM86, | |
130 | .fw = "isl3886usb", | |
1ca5f2e9 CL |
131 | .hw = "ISL3886 + net2280", |
132 | }, | |
133 | { | |
134 | .type = P54U_3887, | |
135 | .intf = FW_LM87, | |
136 | .fw = "isl3887usb", | |
1ca5f2e9 CL |
137 | .hw = "ISL3887", |
138 | }, | |
139 | }; | |
140 | ||
eff1a59c MW |
141 | static void p54u_rx_cb(struct urb *urb) |
142 | { | |
143 | struct sk_buff *skb = (struct sk_buff *) urb->context; | |
144 | struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb; | |
145 | struct ieee80211_hw *dev = info->dev; | |
146 | struct p54u_priv *priv = dev->priv; | |
147 | ||
dd397dc9 CL |
148 | skb_unlink(skb, &priv->rx_queue); |
149 | ||
eff1a59c | 150 | if (unlikely(urb->status)) { |
dd397dc9 | 151 | dev_kfree_skb_irq(skb); |
eff1a59c MW |
152 | return; |
153 | } | |
154 | ||
eff1a59c | 155 | skb_put(skb, urb->actual_length); |
2b80848e CL |
156 | |
157 | if (priv->hw_type == P54U_NET2280) | |
158 | skb_pull(skb, priv->common.tx_hdr_len); | |
159 | if (priv->common.fw_interface == FW_LM87) { | |
160 | skb_pull(skb, 4); | |
161 | skb_put(skb, 4); | |
162 | } | |
eff1a59c MW |
163 | |
164 | if (p54_rx(dev, skb)) { | |
4e416a6f | 165 | skb = dev_alloc_skb(priv->common.rx_mtu + 32); |
eff1a59c | 166 | if (unlikely(!skb)) { |
eff1a59c MW |
167 | /* TODO check rx queue length and refill *somewhere* */ |
168 | return; | |
169 | } | |
170 | ||
171 | info = (struct p54u_rx_info *) skb->cb; | |
172 | info->urb = urb; | |
173 | info->dev = dev; | |
174 | urb->transfer_buffer = skb_tail_pointer(skb); | |
175 | urb->context = skb; | |
eff1a59c | 176 | } else { |
2b80848e CL |
177 | if (priv->hw_type == P54U_NET2280) |
178 | skb_push(skb, priv->common.tx_hdr_len); | |
179 | if (priv->common.fw_interface == FW_LM87) { | |
180 | skb_push(skb, 4); | |
181 | skb_put(skb, 4); | |
182 | } | |
d47c3ceb | 183 | skb_reset_tail_pointer(skb); |
eff1a59c | 184 | skb_trim(skb, 0); |
1ca5f2e9 | 185 | urb->transfer_buffer = skb_tail_pointer(skb); |
eff1a59c | 186 | } |
dd397dc9 CL |
187 | skb_queue_tail(&priv->rx_queue, skb); |
188 | usb_anchor_urb(urb, &priv->submitted); | |
189 | if (usb_submit_urb(urb, GFP_ATOMIC)) { | |
190 | skb_unlink(skb, &priv->rx_queue); | |
191 | usb_unanchor_urb(urb); | |
192 | dev_kfree_skb_irq(skb); | |
193 | } | |
eff1a59c MW |
194 | } |
195 | ||
0a5ec96a | 196 | static void p54u_tx_cb(struct urb *urb) |
b92f30d6 CL |
197 | { |
198 | struct sk_buff *skb = urb->context; | |
b2767363 | 199 | struct ieee80211_hw *dev = |
b92f30d6 CL |
200 | usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0)); |
201 | ||
e2fe154e | 202 | p54_free_skb(dev, skb); |
dd397dc9 CL |
203 | } |
204 | ||
205 | static void p54u_tx_dummy_cb(struct urb *urb) { } | |
206 | ||
207 | static void p54u_free_urbs(struct ieee80211_hw *dev) | |
208 | { | |
209 | struct p54u_priv *priv = dev->priv; | |
210 | usb_kill_anchored_urbs(&priv->submitted); | |
b92f30d6 CL |
211 | } |
212 | ||
5612a508 LF |
213 | static void p54u_stop(struct ieee80211_hw *dev) |
214 | { | |
215 | /* | |
216 | * TODO: figure out how to reliably stop the 3887 and net2280 so | |
217 | * the hardware is still usable next time we want to start it. | |
218 | * until then, we just stop listening to the hardware.. | |
219 | */ | |
220 | p54u_free_urbs(dev); | |
221 | } | |
222 | ||
eff1a59c MW |
223 | static int p54u_init_urbs(struct ieee80211_hw *dev) |
224 | { | |
225 | struct p54u_priv *priv = dev->priv; | |
dd397dc9 | 226 | struct urb *entry = NULL; |
eff1a59c MW |
227 | struct sk_buff *skb; |
228 | struct p54u_rx_info *info; | |
dd397dc9 | 229 | int ret = 0; |
eff1a59c MW |
230 | |
231 | while (skb_queue_len(&priv->rx_queue) < 32) { | |
4e416a6f | 232 | skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL); |
dd397dc9 CL |
233 | if (!skb) { |
234 | ret = -ENOMEM; | |
235 | goto err; | |
236 | } | |
eff1a59c MW |
237 | entry = usb_alloc_urb(0, GFP_KERNEL); |
238 | if (!entry) { | |
dd397dc9 CL |
239 | ret = -ENOMEM; |
240 | goto err; | |
eff1a59c | 241 | } |
dd397dc9 | 242 | |
4e416a6f CL |
243 | usb_fill_bulk_urb(entry, priv->udev, |
244 | usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), | |
245 | skb_tail_pointer(skb), | |
246 | priv->common.rx_mtu + 32, p54u_rx_cb, skb); | |
eff1a59c MW |
247 | info = (struct p54u_rx_info *) skb->cb; |
248 | info->urb = entry; | |
249 | info->dev = dev; | |
250 | skb_queue_tail(&priv->rx_queue, skb); | |
dd397dc9 CL |
251 | |
252 | usb_anchor_urb(entry, &priv->submitted); | |
253 | ret = usb_submit_urb(entry, GFP_KERNEL); | |
254 | if (ret) { | |
255 | skb_unlink(skb, &priv->rx_queue); | |
256 | usb_unanchor_urb(entry); | |
257 | goto err; | |
258 | } | |
259 | usb_free_urb(entry); | |
260 | entry = NULL; | |
eff1a59c MW |
261 | } |
262 | ||
263 | return 0; | |
eff1a59c | 264 | |
dd397dc9 CL |
265 | err: |
266 | usb_free_urb(entry); | |
267 | kfree_skb(skb); | |
268 | p54u_free_urbs(dev); | |
269 | return ret; | |
eff1a59c MW |
270 | } |
271 | ||
5612a508 LF |
272 | static int p54u_open(struct ieee80211_hw *dev) |
273 | { | |
274 | /* | |
275 | * TODO: Because we don't know how to reliably stop the 3887 and | |
276 | * the isl3886+net2280, other than brutally cut off all | |
277 | * communications. We have to reinitialize the urbs on every start. | |
278 | */ | |
279 | return p54u_init_urbs(dev); | |
280 | } | |
281 | ||
c9127659 | 282 | static __le32 p54u_lm87_chksum(const __le32 *data, size_t length) |
2b80848e | 283 | { |
1f1c0e33 | 284 | u32 chk = 0; |
2b80848e CL |
285 | |
286 | length >>= 2; | |
287 | while (length--) { | |
c9127659 | 288 | chk ^= le32_to_cpu(*data++); |
2b80848e CL |
289 | chk = (chk >> 5) ^ (chk << 3); |
290 | } | |
291 | ||
1f1c0e33 | 292 | return cpu_to_le32(chk); |
2b80848e CL |
293 | } |
294 | ||
0a5ec96a | 295 | static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb) |
2b80848e CL |
296 | { |
297 | struct p54u_priv *priv = dev->priv; | |
298 | struct urb *data_urb; | |
e2fe154e | 299 | struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr); |
2b80848e CL |
300 | |
301 | data_urb = usb_alloc_urb(0, GFP_ATOMIC); | |
6d541a68 CL |
302 | if (!data_urb) { |
303 | p54_free_skb(dev, skb); | |
2b80848e | 304 | return; |
6d541a68 | 305 | } |
2b80848e | 306 | |
e2fe154e CL |
307 | hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len); |
308 | hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id; | |
2b80848e CL |
309 | |
310 | usb_fill_bulk_urb(data_urb, priv->udev, | |
b92f30d6 | 311 | usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), |
e2fe154e CL |
312 | hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ? |
313 | p54u_tx_cb : p54u_tx_dummy_cb, skb); | |
00627f22 | 314 | data_urb->transfer_flags |= URB_ZERO_PACKET; |
2b80848e | 315 | |
dd397dc9 CL |
316 | usb_anchor_urb(data_urb, &priv->submitted); |
317 | if (usb_submit_urb(data_urb, GFP_ATOMIC)) { | |
318 | usb_unanchor_urb(data_urb); | |
dd397dc9 CL |
319 | p54_free_skb(dev, skb); |
320 | } | |
321 | usb_free_urb(data_urb); | |
2b80848e CL |
322 | } |
323 | ||
0a5ec96a | 324 | static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb) |
eff1a59c MW |
325 | { |
326 | struct p54u_priv *priv = dev->priv; | |
6d541a68 | 327 | struct urb *int_urb = NULL, *data_urb = NULL; |
e2fe154e | 328 | struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr); |
6d541a68 CL |
329 | struct net2280_reg_write *reg = NULL; |
330 | int err = -ENOMEM; | |
eff1a59c MW |
331 | |
332 | reg = kmalloc(sizeof(*reg), GFP_ATOMIC); | |
333 | if (!reg) | |
6d541a68 | 334 | goto out; |
eff1a59c MW |
335 | |
336 | int_urb = usb_alloc_urb(0, GFP_ATOMIC); | |
6d541a68 CL |
337 | if (!int_urb) |
338 | goto out; | |
eff1a59c MW |
339 | |
340 | data_urb = usb_alloc_urb(0, GFP_ATOMIC); | |
6d541a68 CL |
341 | if (!data_urb) |
342 | goto out; | |
eff1a59c MW |
343 | |
344 | reg->port = cpu_to_le16(NET2280_DEV_U32); | |
345 | reg->addr = cpu_to_le32(P54U_DEV_BASE); | |
346 | reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA); | |
347 | ||
eff1a59c | 348 | memset(hdr, 0, sizeof(*hdr)); |
e2fe154e CL |
349 | hdr->len = cpu_to_le16(skb->len); |
350 | hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id; | |
eff1a59c MW |
351 | |
352 | usb_fill_bulk_urb(int_urb, priv->udev, | |
353 | usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg), | |
dd397dc9 CL |
354 | p54u_tx_dummy_cb, dev); |
355 | ||
356 | /* | |
6d541a68 CL |
357 | * URB_FREE_BUFFER triggers a code path in the USB subsystem that will |
358 | * free what is inside the transfer_buffer after the last reference to | |
359 | * the int_urb is dropped. | |
dd397dc9 | 360 | */ |
b4068a80 | 361 | int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET; |
6d541a68 | 362 | reg = NULL; |
eff1a59c MW |
363 | |
364 | usb_fill_bulk_urb(data_urb, priv->udev, | |
b92f30d6 | 365 | usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), |
e2fe154e CL |
366 | hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ? |
367 | p54u_tx_cb : p54u_tx_dummy_cb, skb); | |
b4068a80 | 368 | data_urb->transfer_flags |= URB_ZERO_PACKET; |
dd397dc9 CL |
369 | |
370 | usb_anchor_urb(int_urb, &priv->submitted); | |
371 | err = usb_submit_urb(int_urb, GFP_ATOMIC); | |
372 | if (err) { | |
373 | usb_unanchor_urb(int_urb); | |
374 | goto out; | |
375 | } | |
376 | ||
377 | usb_anchor_urb(data_urb, &priv->submitted); | |
378 | err = usb_submit_urb(data_urb, GFP_ATOMIC); | |
379 | if (err) { | |
380 | usb_unanchor_urb(data_urb); | |
381 | goto out; | |
382 | } | |
6d541a68 | 383 | out: |
dd397dc9 CL |
384 | usb_free_urb(int_urb); |
385 | usb_free_urb(data_urb); | |
386 | ||
387 | if (err) { | |
6d541a68 | 388 | kfree(reg); |
dd397dc9 CL |
389 | p54_free_skb(dev, skb); |
390 | } | |
eff1a59c MW |
391 | } |
392 | ||
393 | static int p54u_write(struct p54u_priv *priv, | |
394 | struct net2280_reg_write *buf, | |
395 | enum net2280_op_type type, | |
396 | __le32 addr, __le32 val) | |
397 | { | |
398 | unsigned int ep; | |
399 | int alen; | |
400 | ||
401 | if (type & 0x0800) | |
402 | ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV); | |
403 | else | |
404 | ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG); | |
405 | ||
406 | buf->port = cpu_to_le16(type); | |
407 | buf->addr = addr; | |
408 | buf->val = val; | |
409 | ||
410 | return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000); | |
411 | } | |
412 | ||
413 | static int p54u_read(struct p54u_priv *priv, void *buf, | |
414 | enum net2280_op_type type, | |
415 | __le32 addr, __le32 *val) | |
416 | { | |
417 | struct net2280_reg_read *read = buf; | |
418 | __le32 *reg = buf; | |
419 | unsigned int ep; | |
420 | int alen, err; | |
421 | ||
422 | if (type & 0x0800) | |
423 | ep = P54U_PIPE_DEV; | |
424 | else | |
425 | ep = P54U_PIPE_BRG; | |
426 | ||
427 | read->port = cpu_to_le16(type); | |
428 | read->addr = addr; | |
429 | ||
430 | err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep), | |
431 | read, sizeof(*read), &alen, 1000); | |
432 | if (err) | |
433 | return err; | |
434 | ||
435 | err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep), | |
436 | reg, sizeof(*reg), &alen, 1000); | |
437 | if (err) | |
438 | return err; | |
439 | ||
440 | *val = *reg; | |
441 | return 0; | |
442 | } | |
443 | ||
444 | static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep, | |
445 | void *data, size_t len) | |
446 | { | |
447 | int alen; | |
448 | return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep), | |
449 | data, len, &alen, 2000); | |
450 | } | |
451 | ||
1ca5f2e9 | 452 | static int p54u_device_reset(struct ieee80211_hw *dev) |
6982869d CL |
453 | { |
454 | struct p54u_priv *priv = dev->priv; | |
c88a768d | 455 | int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING); |
6982869d | 456 | |
c88a768d CL |
457 | if (lock) { |
458 | ret = usb_lock_device_for_reset(priv->udev, priv->intf); | |
459 | if (ret < 0) { | |
460 | dev_err(&priv->udev->dev, "(p54usb) unable to lock " | |
1ca5f2e9 | 461 | "device for reset (%d)!\n", ret); |
c88a768d CL |
462 | return ret; |
463 | } | |
6982869d CL |
464 | } |
465 | ||
466 | ret = usb_reset_device(priv->udev); | |
467 | if (lock) | |
468 | usb_unlock_device(priv->udev); | |
469 | ||
1ca5f2e9 | 470 | if (ret) |
6982869d | 471 | dev_err(&priv->udev->dev, "(p54usb) unable to reset " |
1ca5f2e9 CL |
472 | "device (%d)!\n", ret); |
473 | ||
474 | return ret; | |
475 | } | |
476 | ||
477 | static const char p54u_romboot_3887[] = "~~~~"; | |
478 | static int p54u_firmware_reset_3887(struct ieee80211_hw *dev) | |
479 | { | |
480 | struct p54u_priv *priv = dev->priv; | |
21d6c270 | 481 | u8 *buf; |
1ca5f2e9 | 482 | int ret; |
6982869d | 483 | |
27b81bbe | 484 | buf = kmemdup(p54u_romboot_3887, 4, GFP_KERNEL); |
21d6c270 LF |
485 | if (!buf) |
486 | return -ENOMEM; | |
6982869d | 487 | ret = p54u_bulk_msg(priv, P54U_PIPE_DATA, |
21d6c270 LF |
488 | buf, 4); |
489 | kfree(buf); | |
6982869d CL |
490 | if (ret) |
491 | dev_err(&priv->udev->dev, "(p54usb) unable to jump to " | |
1ca5f2e9 | 492 | "boot ROM (%d)!\n", ret); |
6982869d CL |
493 | |
494 | return ret; | |
495 | } | |
496 | ||
1ca5f2e9 | 497 | static const char p54u_firmware_upload_3887[] = "<\r"; |
eff1a59c MW |
498 | static int p54u_upload_firmware_3887(struct ieee80211_hw *dev) |
499 | { | |
eff1a59c | 500 | struct p54u_priv *priv = dev->priv; |
eff1a59c MW |
501 | int err, alen; |
502 | u8 carry = 0; | |
8b72eb43 DW |
503 | u8 *buf, *tmp; |
504 | const u8 *data; | |
eff1a59c MW |
505 | unsigned int left, remains, block_size; |
506 | struct x2_header *hdr; | |
507 | unsigned long timeout; | |
508 | ||
1ca5f2e9 CL |
509 | err = p54u_firmware_reset_3887(dev); |
510 | if (err) | |
511 | return err; | |
512 | ||
eff1a59c | 513 | tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL); |
0d2e7a5c | 514 | if (!buf) |
1ca5f2e9 | 515 | return -ENOMEM; |
e365f160 | 516 | |
1ca5f2e9 | 517 | left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size); |
6982869d CL |
518 | strcpy(buf, p54u_firmware_upload_3887); |
519 | left -= strlen(p54u_firmware_upload_3887); | |
520 | tmp += strlen(p54u_firmware_upload_3887); | |
eff1a59c | 521 | |
1ca5f2e9 CL |
522 | data = priv->fw->data; |
523 | remains = priv->fw->size; | |
eff1a59c | 524 | |
6982869d | 525 | hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887)); |
eff1a59c MW |
526 | memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE); |
527 | hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR); | |
1ca5f2e9 | 528 | hdr->fw_length = cpu_to_le32(priv->fw->size); |
eff1a59c MW |
529 | hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr, |
530 | sizeof(u32)*2)); | |
531 | left -= sizeof(*hdr); | |
532 | tmp += sizeof(*hdr); | |
533 | ||
534 | while (remains) { | |
535 | while (left--) { | |
536 | if (carry) { | |
537 | *tmp++ = carry; | |
538 | carry = 0; | |
539 | remains--; | |
540 | continue; | |
541 | } | |
542 | switch (*data) { | |
543 | case '~': | |
544 | *tmp++ = '}'; | |
545 | carry = '^'; | |
546 | break; | |
547 | case '}': | |
548 | *tmp++ = '}'; | |
549 | carry = ']'; | |
550 | break; | |
551 | default: | |
552 | *tmp++ = *data; | |
553 | remains--; | |
554 | break; | |
555 | } | |
556 | data++; | |
557 | } | |
558 | ||
559 | err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size); | |
560 | if (err) { | |
02e37ba1 CL |
561 | dev_err(&priv->udev->dev, "(p54usb) firmware " |
562 | "upload failed!\n"); | |
eff1a59c MW |
563 | goto err_upload_failed; |
564 | } | |
565 | ||
566 | tmp = buf; | |
567 | left = block_size = min((unsigned int)P54U_FW_BLOCK, remains); | |
568 | } | |
569 | ||
1ca5f2e9 CL |
570 | *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data, |
571 | priv->fw->size)); | |
eff1a59c MW |
572 | err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32)); |
573 | if (err) { | |
02e37ba1 | 574 | dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n"); |
eff1a59c MW |
575 | goto err_upload_failed; |
576 | } | |
eff1a59c MW |
577 | timeout = jiffies + msecs_to_jiffies(1000); |
578 | while (!(err = usb_bulk_msg(priv->udev, | |
579 | usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) { | |
580 | if (alen > 2 && !memcmp(buf, "OK", 2)) | |
581 | break; | |
582 | ||
583 | if (alen > 5 && !memcmp(buf, "ERROR", 5)) { | |
eff1a59c MW |
584 | err = -EINVAL; |
585 | break; | |
586 | } | |
587 | ||
588 | if (time_after(jiffies, timeout)) { | |
02e37ba1 CL |
589 | dev_err(&priv->udev->dev, "(p54usb) firmware boot " |
590 | "timed out!\n"); | |
eff1a59c MW |
591 | err = -ETIMEDOUT; |
592 | break; | |
593 | } | |
594 | } | |
02e37ba1 CL |
595 | if (err) { |
596 | dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n"); | |
eff1a59c | 597 | goto err_upload_failed; |
02e37ba1 | 598 | } |
eff1a59c MW |
599 | |
600 | buf[0] = 'g'; | |
601 | buf[1] = '\r'; | |
602 | err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2); | |
603 | if (err) { | |
02e37ba1 | 604 | dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n"); |
eff1a59c MW |
605 | goto err_upload_failed; |
606 | } | |
607 | ||
608 | timeout = jiffies + msecs_to_jiffies(1000); | |
609 | while (!(err = usb_bulk_msg(priv->udev, | |
610 | usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) { | |
611 | if (alen > 0 && buf[0] == 'g') | |
612 | break; | |
613 | ||
614 | if (time_after(jiffies, timeout)) { | |
615 | err = -ETIMEDOUT; | |
616 | break; | |
617 | } | |
618 | } | |
619 | if (err) | |
620 | goto err_upload_failed; | |
621 | ||
1ca5f2e9 | 622 | err_upload_failed: |
eff1a59c | 623 | kfree(buf); |
eff1a59c MW |
624 | return err; |
625 | } | |
626 | ||
627 | static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev) | |
628 | { | |
629 | struct p54u_priv *priv = dev->priv; | |
eff1a59c MW |
630 | const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE; |
631 | int err, alen; | |
632 | void *buf; | |
633 | __le32 reg; | |
634 | unsigned int remains, offset; | |
8b72eb43 | 635 | const u8 *data; |
eff1a59c MW |
636 | |
637 | buf = kmalloc(512, GFP_KERNEL); | |
0d2e7a5c | 638 | if (!buf) |
eff1a59c | 639 | return -ENOMEM; |
eff1a59c | 640 | |
eff1a59c MW |
641 | #define P54U_WRITE(type, addr, data) \ |
642 | do {\ | |
643 | err = p54u_write(priv, buf, type,\ | |
644 | cpu_to_le32((u32)(unsigned long)addr), data);\ | |
645 | if (err) \ | |
646 | goto fail;\ | |
647 | } while (0) | |
648 | ||
649 | #define P54U_READ(type, addr) \ | |
650 | do {\ | |
651 | err = p54u_read(priv, buf, type,\ | |
652 | cpu_to_le32((u32)(unsigned long)addr), ®);\ | |
653 | if (err)\ | |
654 | goto fail;\ | |
655 | } while (0) | |
656 | ||
657 | /* power down net2280 bridge */ | |
658 | P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL); | |
659 | reg |= cpu_to_le32(P54U_BRG_POWER_DOWN); | |
660 | reg &= cpu_to_le32(~P54U_BRG_POWER_UP); | |
661 | P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg); | |
662 | ||
663 | mdelay(100); | |
664 | ||
665 | /* power up bridge */ | |
666 | reg |= cpu_to_le32(P54U_BRG_POWER_UP); | |
667 | reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN); | |
668 | P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg); | |
669 | ||
670 | mdelay(100); | |
671 | ||
672 | P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT, | |
673 | cpu_to_le32(NET2280_CLK_30Mhz | | |
674 | NET2280_PCI_ENABLE | | |
675 | NET2280_PCI_SOFT_RESET)); | |
676 | ||
677 | mdelay(20); | |
678 | ||
679 | P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND, | |
680 | cpu_to_le32(PCI_COMMAND_MEMORY | | |
681 | PCI_COMMAND_MASTER)); | |
682 | ||
683 | P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0, | |
684 | cpu_to_le32(NET2280_BASE)); | |
685 | ||
686 | P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS); | |
687 | reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT); | |
688 | P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg); | |
689 | ||
690 | // TODO: we really need this? | |
691 | P54U_READ(NET2280_BRG_U32, NET2280_RELNUM); | |
692 | ||
693 | P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP, | |
694 | cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE)); | |
695 | P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP, | |
696 | cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE)); | |
697 | ||
698 | P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2, | |
699 | cpu_to_le32(NET2280_BASE2)); | |
700 | ||
701 | /* finally done setting up the bridge */ | |
702 | ||
703 | P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND, | |
704 | cpu_to_le32(PCI_COMMAND_MEMORY | | |
705 | PCI_COMMAND_MASTER)); | |
706 | ||
707 | P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0); | |
708 | P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0, | |
709 | cpu_to_le32(P54U_DEV_BASE)); | |
710 | ||
711 | P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0); | |
712 | P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1, | |
713 | cpu_to_le32(NET2280_PCI_INTA_INTERRUPT)); | |
714 | ||
715 | /* do romboot */ | |
716 | P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0); | |
717 | ||
718 | P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat); | |
719 | reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET); | |
720 | reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT); | |
721 | reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN); | |
722 | P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg); | |
723 | ||
724 | mdelay(20); | |
725 | ||
726 | reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET); | |
727 | P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg); | |
728 | ||
729 | mdelay(20); | |
730 | ||
731 | reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET); | |
732 | P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg); | |
733 | ||
734 | mdelay(100); | |
735 | ||
736 | P54U_READ(NET2280_DEV_U32, &devreg->int_ident); | |
737 | P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg); | |
738 | ||
739 | /* finally, we can upload firmware now! */ | |
1ca5f2e9 CL |
740 | remains = priv->fw->size; |
741 | data = priv->fw->data; | |
eff1a59c MW |
742 | offset = ISL38XX_DEV_FIRMWARE_ADDR; |
743 | ||
744 | while (remains) { | |
745 | unsigned int block_len = min(remains, (unsigned int)512); | |
746 | memcpy(buf, data, block_len); | |
747 | ||
748 | err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len); | |
749 | if (err) { | |
02e37ba1 CL |
750 | dev_err(&priv->udev->dev, "(p54usb) firmware block " |
751 | "upload failed\n"); | |
eff1a59c MW |
752 | goto fail; |
753 | } | |
754 | ||
755 | P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base, | |
756 | cpu_to_le32(0xc0000f00)); | |
757 | ||
758 | P54U_WRITE(NET2280_DEV_U32, | |
759 | 0x0020 | (unsigned long)&devreg->direct_mem_win, 0); | |
760 | P54U_WRITE(NET2280_DEV_U32, | |
761 | 0x0020 | (unsigned long)&devreg->direct_mem_win, | |
762 | cpu_to_le32(1)); | |
763 | ||
764 | P54U_WRITE(NET2280_DEV_U32, | |
765 | 0x0024 | (unsigned long)&devreg->direct_mem_win, | |
766 | cpu_to_le32(block_len)); | |
767 | P54U_WRITE(NET2280_DEV_U32, | |
768 | 0x0028 | (unsigned long)&devreg->direct_mem_win, | |
769 | cpu_to_le32(offset)); | |
770 | ||
771 | P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr, | |
772 | cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR)); | |
773 | P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len, | |
774 | cpu_to_le32(block_len >> 2)); | |
775 | P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl, | |
776 | cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER)); | |
777 | ||
778 | mdelay(10); | |
779 | ||
780 | P54U_READ(NET2280_DEV_U32, | |
781 | 0x002C | (unsigned long)&devreg->direct_mem_win); | |
782 | if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) || | |
783 | !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) { | |
02e37ba1 CL |
784 | dev_err(&priv->udev->dev, "(p54usb) firmware DMA " |
785 | "transfer failed\n"); | |
eff1a59c MW |
786 | goto fail; |
787 | } | |
788 | ||
789 | P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT, | |
790 | cpu_to_le32(NET2280_FIFO_FLUSH)); | |
791 | ||
792 | remains -= block_len; | |
793 | data += block_len; | |
794 | offset += block_len; | |
795 | } | |
796 | ||
797 | /* do ramboot */ | |
798 | P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat); | |
799 | reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET); | |
800 | reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN); | |
801 | reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT); | |
802 | P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg); | |
803 | ||
804 | mdelay(20); | |
805 | ||
806 | reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET); | |
807 | P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg); | |
808 | ||
809 | reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET); | |
810 | P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg); | |
811 | ||
812 | mdelay(100); | |
813 | ||
814 | P54U_READ(NET2280_DEV_U32, &devreg->int_ident); | |
815 | P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg); | |
816 | ||
817 | /* start up the firmware */ | |
818 | P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, | |
819 | cpu_to_le32(ISL38XX_INT_IDENT_INIT)); | |
820 | ||
821 | P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1, | |
822 | cpu_to_le32(NET2280_PCI_INTA_INTERRUPT)); | |
823 | ||
824 | P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, | |
825 | cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE | | |
826 | NET2280_USB_INTERRUPT_ENABLE)); | |
827 | ||
828 | P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int, | |
829 | cpu_to_le32(ISL38XX_DEV_INT_RESET)); | |
830 | ||
831 | err = usb_interrupt_msg(priv->udev, | |
832 | usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT), | |
833 | buf, sizeof(__le32), &alen, 1000); | |
834 | if (err || alen != sizeof(__le32)) | |
835 | goto fail; | |
836 | ||
837 | P54U_READ(NET2280_DEV_U32, &devreg->int_ident); | |
838 | P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg); | |
839 | ||
840 | if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT))) | |
841 | err = -EINVAL; | |
842 | ||
843 | P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0); | |
844 | P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1, | |
845 | cpu_to_le32(NET2280_PCI_INTA_INTERRUPT)); | |
846 | ||
847 | #undef P54U_WRITE | |
848 | #undef P54U_READ | |
849 | ||
1ca5f2e9 | 850 | fail: |
eff1a59c MW |
851 | kfree(buf); |
852 | return err; | |
853 | } | |
854 | ||
5612a508 | 855 | static int p54_find_type(struct p54u_priv *priv) |
1ca5f2e9 | 856 | { |
5612a508 | 857 | int i; |
1ca5f2e9 CL |
858 | |
859 | for (i = 0; i < __NUM_P54U_HWTYPES; i++) | |
860 | if (p54u_fwlist[i].type == priv->hw_type) | |
861 | break; | |
1ca5f2e9 CL |
862 | if (i == __NUM_P54U_HWTYPES) |
863 | return -EOPNOTSUPP; | |
864 | ||
5612a508 LF |
865 | return i; |
866 | } | |
1ca5f2e9 | 867 | |
5612a508 LF |
868 | static int p54u_start_ops(struct p54u_priv *priv) |
869 | { | |
870 | struct ieee80211_hw *dev = priv->common.hw; | |
871 | int ret; | |
1ca5f2e9 | 872 | |
5612a508 LF |
873 | ret = p54_parse_firmware(dev, priv->fw); |
874 | if (ret) | |
875 | goto err_out; | |
876 | ||
877 | ret = p54_find_type(priv); | |
878 | if (ret < 0) | |
879 | goto err_out; | |
1ca5f2e9 | 880 | |
5612a508 | 881 | if (priv->common.fw_interface != p54u_fwlist[ret].intf) { |
1ca5f2e9 CL |
882 | dev_err(&priv->udev->dev, "wrong firmware, please get " |
883 | "a firmware for \"%s\" and try again.\n", | |
5612a508 LF |
884 | p54u_fwlist[ret].hw); |
885 | ret = -ENODEV; | |
886 | goto err_out; | |
1ca5f2e9 CL |
887 | } |
888 | ||
5612a508 LF |
889 | ret = priv->upload_fw(dev); |
890 | if (ret) | |
891 | goto err_out; | |
1ca5f2e9 | 892 | |
5612a508 LF |
893 | ret = p54u_open(dev); |
894 | if (ret) | |
895 | goto err_out; | |
896 | ||
897 | ret = p54_read_eeprom(dev); | |
898 | if (ret) | |
899 | goto err_stop; | |
900 | ||
901 | p54u_stop(dev); | |
902 | ||
903 | ret = p54_register_common(dev, &priv->udev->dev); | |
904 | if (ret) | |
905 | goto err_stop; | |
906 | ||
907 | return 0; | |
908 | ||
909 | err_stop: | |
910 | p54u_stop(dev); | |
911 | ||
912 | err_out: | |
913 | /* | |
914 | * p54u_disconnect will do the rest of the | |
915 | * cleanup | |
916 | */ | |
917 | return ret; | |
1ca5f2e9 CL |
918 | } |
919 | ||
5612a508 LF |
920 | static void p54u_load_firmware_cb(const struct firmware *firmware, |
921 | void *context) | |
eff1a59c | 922 | { |
5612a508 LF |
923 | struct p54u_priv *priv = context; |
924 | struct usb_device *udev = priv->udev; | |
eff1a59c MW |
925 | int err; |
926 | ||
5612a508 LF |
927 | complete(&priv->fw_wait_load); |
928 | if (firmware) { | |
929 | priv->fw = firmware; | |
930 | err = p54u_start_ops(priv); | |
931 | } else { | |
932 | err = -ENOENT; | |
933 | dev_err(&udev->dev, "Firmware not found.\n"); | |
eff1a59c MW |
934 | } |
935 | ||
5612a508 LF |
936 | if (err) { |
937 | struct device *parent = priv->udev->dev.parent; | |
eff1a59c | 938 | |
5612a508 LF |
939 | dev_err(&udev->dev, "failed to initialize device (%d)\n", err); |
940 | ||
941 | if (parent) | |
942 | device_lock(parent); | |
943 | ||
944 | device_release_driver(&udev->dev); | |
945 | /* | |
946 | * At this point p54u_disconnect has already freed | |
947 | * the "priv" context. Do not use it anymore! | |
948 | */ | |
949 | priv = NULL; | |
950 | ||
951 | if (parent) | |
952 | device_unlock(parent); | |
953 | } | |
954 | ||
955 | usb_put_dev(udev); | |
eff1a59c MW |
956 | } |
957 | ||
5612a508 LF |
958 | static int p54u_load_firmware(struct ieee80211_hw *dev, |
959 | struct usb_interface *intf) | |
eff1a59c | 960 | { |
5612a508 LF |
961 | struct usb_device *udev = interface_to_usbdev(intf); |
962 | struct p54u_priv *priv = dev->priv; | |
963 | struct device *device = &udev->dev; | |
964 | int err, i; | |
965 | ||
966 | BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES); | |
967 | ||
968 | init_completion(&priv->fw_wait_load); | |
969 | i = p54_find_type(priv); | |
970 | if (i < 0) | |
971 | return i; | |
972 | ||
973 | dev_info(&priv->udev->dev, "Loading firmware file %s\n", | |
974 | p54u_fwlist[i].fw); | |
975 | ||
976 | usb_get_dev(udev); | |
977 | err = request_firmware_nowait(THIS_MODULE, 1, p54u_fwlist[i].fw, | |
978 | device, GFP_KERNEL, priv, | |
979 | p54u_load_firmware_cb); | |
980 | if (err) { | |
981 | dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s " | |
982 | "(%d)!\n", p54u_fwlist[i].fw, err); | |
e78641c1 | 983 | usb_put_dev(udev); |
5612a508 LF |
984 | } |
985 | ||
986 | return err; | |
eff1a59c MW |
987 | } |
988 | ||
337b563f | 989 | static int p54u_probe(struct usb_interface *intf, |
eff1a59c MW |
990 | const struct usb_device_id *id) |
991 | { | |
992 | struct usb_device *udev = interface_to_usbdev(intf); | |
993 | struct ieee80211_hw *dev; | |
994 | struct p54u_priv *priv; | |
995 | int err; | |
996 | unsigned int i, recognized_pipes; | |
eff1a59c MW |
997 | |
998 | dev = p54_init_common(sizeof(*priv)); | |
02e37ba1 | 999 | |
eff1a59c | 1000 | if (!dev) { |
02e37ba1 | 1001 | dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n"); |
eff1a59c MW |
1002 | return -ENOMEM; |
1003 | } | |
1004 | ||
1005 | priv = dev->priv; | |
1ca5f2e9 | 1006 | priv->hw_type = P54U_INVALID_HW; |
eff1a59c MW |
1007 | |
1008 | SET_IEEE80211_DEV(dev, &intf->dev); | |
1009 | usb_set_intfdata(intf, dev); | |
1010 | priv->udev = udev; | |
6982869d CL |
1011 | priv->intf = intf; |
1012 | skb_queue_head_init(&priv->rx_queue); | |
1013 | init_usb_anchor(&priv->submitted); | |
eff1a59c MW |
1014 | |
1015 | usb_get_dev(udev); | |
1016 | ||
1017 | /* really lazy and simple way of figuring out if we're a 3887 */ | |
1018 | /* TODO: should just stick the identification in the device table */ | |
1019 | i = intf->altsetting->desc.bNumEndpoints; | |
1020 | recognized_pipes = 0; | |
1021 | while (i--) { | |
1022 | switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) { | |
1023 | case P54U_PIPE_DATA: | |
1024 | case P54U_PIPE_MGMT: | |
1025 | case P54U_PIPE_BRG: | |
1026 | case P54U_PIPE_DEV: | |
1027 | case P54U_PIPE_DATA | USB_DIR_IN: | |
1028 | case P54U_PIPE_MGMT | USB_DIR_IN: | |
1029 | case P54U_PIPE_BRG | USB_DIR_IN: | |
1030 | case P54U_PIPE_DEV | USB_DIR_IN: | |
1031 | case P54U_PIPE_INT | USB_DIR_IN: | |
1032 | recognized_pipes++; | |
1033 | } | |
1034 | } | |
1035 | priv->common.open = p54u_open; | |
2b80848e | 1036 | priv->common.stop = p54u_stop; |
eff1a59c | 1037 | if (recognized_pipes < P54U_PIPE_NUMBER) { |
13792578 | 1038 | #ifdef CONFIG_PM |
1ca5f2e9 CL |
1039 | /* ISL3887 needs a full reset on resume */ |
1040 | udev->reset_resume = 1; | |
11791a6f | 1041 | #endif /* CONFIG_PM */ |
1ca5f2e9 CL |
1042 | err = p54u_device_reset(dev); |
1043 | ||
eff1a59c | 1044 | priv->hw_type = P54U_3887; |
a406ac0d CL |
1045 | dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr); |
1046 | priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr); | |
1047 | priv->common.tx = p54u_tx_lm87; | |
1ca5f2e9 | 1048 | priv->upload_fw = p54u_upload_firmware_3887; |
eff1a59c | 1049 | } else { |
2b80848e | 1050 | priv->hw_type = P54U_NET2280; |
eff1a59c MW |
1051 | dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr); |
1052 | priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr); | |
1053 | priv->common.tx = p54u_tx_net2280; | |
1ca5f2e9 | 1054 | priv->upload_fw = p54u_upload_firmware_net2280; |
2b80848e | 1055 | } |
5612a508 | 1056 | err = p54u_load_firmware(dev, intf); |
eff1a59c MW |
1057 | return err; |
1058 | } | |
1059 | ||
337b563f | 1060 | static void p54u_disconnect(struct usb_interface *intf) |
eff1a59c MW |
1061 | { |
1062 | struct ieee80211_hw *dev = usb_get_intfdata(intf); | |
1063 | struct p54u_priv *priv; | |
1064 | ||
1065 | if (!dev) | |
1066 | return; | |
1067 | ||
5612a508 LF |
1068 | priv = dev->priv; |
1069 | wait_for_completion(&priv->fw_wait_load); | |
d8c92107 | 1070 | p54_unregister_common(dev); |
eff1a59c | 1071 | |
eff1a59c | 1072 | usb_put_dev(interface_to_usbdev(intf)); |
1ca5f2e9 | 1073 | release_firmware(priv->fw); |
eff1a59c | 1074 | p54_free_common(dev); |
eff1a59c MW |
1075 | } |
1076 | ||
6982869d CL |
1077 | static int p54u_pre_reset(struct usb_interface *intf) |
1078 | { | |
1ca5f2e9 CL |
1079 | struct ieee80211_hw *dev = usb_get_intfdata(intf); |
1080 | ||
1081 | if (!dev) | |
1082 | return -ENODEV; | |
1083 | ||
1084 | p54u_stop(dev); | |
6982869d CL |
1085 | return 0; |
1086 | } | |
1087 | ||
1ca5f2e9 CL |
1088 | static int p54u_resume(struct usb_interface *intf) |
1089 | { | |
1090 | struct ieee80211_hw *dev = usb_get_intfdata(intf); | |
1091 | struct p54u_priv *priv; | |
1092 | ||
1093 | if (!dev) | |
1094 | return -ENODEV; | |
1095 | ||
1096 | priv = dev->priv; | |
1097 | if (unlikely(!(priv->upload_fw && priv->fw))) | |
1098 | return 0; | |
1099 | ||
1100 | return priv->upload_fw(dev); | |
1101 | } | |
1102 | ||
6982869d CL |
1103 | static int p54u_post_reset(struct usb_interface *intf) |
1104 | { | |
1ca5f2e9 CL |
1105 | struct ieee80211_hw *dev = usb_get_intfdata(intf); |
1106 | struct p54u_priv *priv; | |
1107 | int err; | |
1108 | ||
1109 | err = p54u_resume(intf); | |
1110 | if (err) | |
1111 | return err; | |
1112 | ||
1113 | /* reinitialize old device state */ | |
1114 | priv = dev->priv; | |
1115 | if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED) | |
1116 | ieee80211_restart_hw(dev); | |
1117 | ||
6982869d CL |
1118 | return 0; |
1119 | } | |
1120 | ||
1ca5f2e9 CL |
1121 | #ifdef CONFIG_PM |
1122 | ||
1123 | static int p54u_suspend(struct usb_interface *intf, pm_message_t message) | |
1124 | { | |
1125 | return p54u_pre_reset(intf); | |
1126 | } | |
1127 | ||
1128 | #endif /* CONFIG_PM */ | |
1129 | ||
eff1a59c | 1130 | static struct usb_driver p54u_driver = { |
32ddf071 | 1131 | .name = "p54usb", |
eff1a59c MW |
1132 | .id_table = p54u_table, |
1133 | .probe = p54u_probe, | |
337b563f | 1134 | .disconnect = p54u_disconnect, |
6982869d CL |
1135 | .pre_reset = p54u_pre_reset, |
1136 | .post_reset = p54u_post_reset, | |
1ca5f2e9 CL |
1137 | #ifdef CONFIG_PM |
1138 | .suspend = p54u_suspend, | |
1139 | .resume = p54u_resume, | |
1140 | .reset_resume = p54u_resume, | |
1141 | #endif /* CONFIG_PM */ | |
fbf95296 | 1142 | .soft_unbind = 1, |
e1f12eb6 | 1143 | .disable_hub_initiated_lpm = 1, |
eff1a59c MW |
1144 | }; |
1145 | ||
d632eb1b | 1146 | module_usb_driver(p54u_driver); |