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