drivers/net/wireless/p54/p54usb.c

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