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 <net/mac80211.h>
  24
  25 #include "p54.h"
  26 #include "lmac.h"
  27 #include "p54usb.h"
  28
  29 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
  30 MODULE_DESCRIPTION("Prism54 USB wireless driver");
  31 MODULE_LICENSE("GPL");
  32 MODULE_ALIAS("prism54usb");
  33 MODULE_FIRMWARE("isl3886usb");
  34 MODULE_FIRMWARE("isl3887usb");
  35
  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
  44 static struct usb_device_id p54u_table[] __devinitdata = {
  45         /* Version 1 devices (pci chip + net2280) */
  46         {USB_DEVICE(0x0411, 0x0050)},   /* Buffalo WLI2-USB2-G54 */
  47         {USB_DEVICE(0x045e, 0x00c2)},   /* Microsoft MN-710 */
  48         {USB_DEVICE(0x0506, 0x0a11)},   /* 3COM 3CRWE254G72 */
  49         {USB_DEVICE(0x06b9, 0x0120)},   /* Thomson SpeedTouch 120g */
  50         {USB_DEVICE(0x0707, 0xee06)},   /* SMC 2862W-G */
  51         {USB_DEVICE(0x07aa, 0x001c)},   /* Corega CG-WLUSB2GT */
  52         {USB_DEVICE(0x083a, 0x4501)},   /* Accton 802.11g WN4501 USB */
  53         {USB_DEVICE(0x083a, 0x4502)},   /* Siemens Gigaset USB Adapter */
  54         {USB_DEVICE(0x083a, 0x5501)},   /* Phillips CPWUA054 */
  55         {USB_DEVICE(0x0846, 0x4200)},   /* Netgear WG121 */
  56         {USB_DEVICE(0x0846, 0x4210)},   /* Netgear WG121 the second ? */
  57         {USB_DEVICE(0x0846, 0x4220)},   /* Netgear WG111 */
  58         {USB_DEVICE(0x09aa, 0x1000)},   /* Spinnaker Proto board */
  59         {USB_DEVICE(0x0cde, 0x0006)},   /* Medion 40900, Roper Europe */
  60         {USB_DEVICE(0x0db0, 0x6826)},   /* MSI UB54G (MS-6826) */
  61         {USB_DEVICE(0x107b, 0x55f2)},   /* Gateway WGU-210 (Gemtek) */
  62         {USB_DEVICE(0x124a, 0x4023)},   /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
  63         {USB_DEVICE(0x1435, 0x0210)},   /* Inventel UR054G */
  64         {USB_DEVICE(0x15a9, 0x0002)},   /* Gemtek WUBI-100GW 802.11g */
  65         {USB_DEVICE(0x1630, 0x0005)},   /* 2Wire 802.11g USB (v1) / Z-Com */
  66         {USB_DEVICE(0x182d, 0x096b)},   /* Sitecom WL-107 */
  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) */
  75         {USB_DEVICE(0x0471, 0x1230)},   /* Philips CPWUA054/00 */
  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 */
  79         {USB_DEVICE(0x06a9, 0x000e)},   /* Westell 802.11g USB (A90-211WG-01) */
  80         {USB_DEVICE(0x06b9, 0x0121)},   /* Thomson SpeedTouch 121g */
  81         {USB_DEVICE(0x0707, 0xee13)},   /* SMC 2862W-G version 2 */
  82         {USB_DEVICE(0x083a, 0x4521)},   /* Siemens Gigaset USB Adapter 54 version 2 */
  83         {USB_DEVICE(0x083a, 0xf503)},   /* Accton FD7050E ver 1010ec  */
  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*/
  89         /* {USB_DEVICE(0x0cde, 0x0006)}, * Medion MD40900 already listed above,
  90                                          * just noting it here for clarity */
  91         {USB_DEVICE(0x0cde, 0x0008)},   /* Sagem XG703A */
  92         {USB_DEVICE(0x0cde, 0x0015)},   /* Zcomax XG-705A */
  93         {USB_DEVICE(0x0d8e, 0x3762)},   /* DLink DWL-G120 Cohiba */
  94         {USB_DEVICE(0x124a, 0x4025)},   /* IOGear GWU513 (GW3887IK chip) */
  95         {USB_DEVICE(0x1260, 0xee22)},   /* SMC 2862W-G version 2 */
  96         {USB_DEVICE(0x13b1, 0x000a)},   /* Linksys WUSB54G ver 2 */
  97         {USB_DEVICE(0x13B1, 0x000C)},   /* Linksys WUSB54AG */
  98         {USB_DEVICE(0x1413, 0x5400)},   /* Telsey 802.11g USB2.0 Adapter */
  99         {USB_DEVICE(0x1435, 0x0427)},   /* Inventel UR054G */
 100         {USB_DEVICE(0x1668, 0x1050)},   /* Actiontec 802UIG-1 */
 101         {USB_DEVICE(0x1740, 0x1000)},   /* Senao NUB-350 */
 102         {USB_DEVICE(0x2001, 0x3704)},   /* DLink DWL-G122 rev A2 */
 103         {USB_DEVICE(0x2001, 0x3705)},   /* D-Link DWL-G120 rev C1 */
 104         {USB_DEVICE(0x413c, 0x5513)},   /* Dell WLA3310 USB Wireless Adapter */
 105         {USB_DEVICE(0x413c, 0x8102)},   /* Spinnaker DUT */
 106         {USB_DEVICE(0x413c, 0x8104)},   /* Cohiba Proto board */
 107         {}
 108 };
 109
 110 MODULE_DEVICE_TABLE(usb, p54u_table);
 111
 112 static const struct {
 113         u32 intf;
 114         enum p54u_hw_type type;
 115         const char *fw;
 116         const char *fw_legacy;
 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
 135 static 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
 142         skb_unlink(skb, &priv->rx_queue);
 143
 144         if (unlikely(urb->status)) {
 145                 dev_kfree_skb_irq(skb);
 146                 return;
 147         }
 148
 149         skb_put(skb, urb->actual_length);
 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         }
 157
 158         if (p54_rx(dev, skb)) {
 159                 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
 160                 if (unlikely(!skb)) {
 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;
 170         } else {
 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                 }
 177                 skb_reset_tail_pointer(skb);
 178                 skb_trim(skb, 0);
 179                 urb->transfer_buffer = skb_tail_pointer(skb);
 180         }
 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         }
 188 }
 189
 190 static void p54u_tx_cb(struct urb *urb)
 191 {
 192         struct sk_buff *skb = urb->context;
 193         struct ieee80211_hw *dev =
 194                 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
 195
 196         p54_free_skb(dev, skb);
 197 }
 198
 199 static void p54u_tx_dummy_cb(struct urb *urb) { }
 200
 201 static void p54u_free_urbs(struct ieee80211_hw *dev)
 202 {
 203         struct p54u_priv *priv = dev->priv;
 204         usb_kill_anchored_urbs(&priv->submitted);
 205 }
 206
 207 static int p54u_init_urbs(struct ieee80211_hw *dev)
 208 {
 209         struct p54u_priv *priv = dev->priv;
 210         struct urb *entry = NULL;
 211         struct sk_buff *skb;
 212         struct p54u_rx_info *info;
 213         int ret = 0;
 214
 215         while (skb_queue_len(&priv->rx_queue) < 32) {
 216                 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
 217                 if (!skb) {
 218                         ret = -ENOMEM;
 219                         goto err;
 220                 }
 221                 entry = usb_alloc_urb(0, GFP_KERNEL);
 222                 if (!entry) {
 223                         ret = -ENOMEM;
 224                         goto err;
 225                 }
 226
 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);
 231                 info = (struct p54u_rx_info *) skb->cb;
 232                 info->urb = entry;
 233                 info->dev = dev;
 234                 skb_queue_tail(&priv->rx_queue, skb);
 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;
 245         }
 246
 247         return 0;
 248
 249  err:
 250         usb_free_urb(entry);
 251         kfree_skb(skb);
 252         p54u_free_urbs(dev);
 253         return ret;
 254 }
 255
 256 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
 257 {
 258         u32 chk = 0;
 259
 260         length >>= 2;
 261         while (length--) {
 262                 chk ^= le32_to_cpu(*data++);
 263                 chk = (chk >> 5) ^ (chk << 3);
 264         }
 265
 266         return cpu_to_le32(chk);
 267 }
 268
 269 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
 270 {
 271         struct p54u_priv *priv = dev->priv;
 272         struct urb *data_urb;
 273         struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
 274
 275         data_urb = usb_alloc_urb(0, GFP_ATOMIC);
 276         if (!data_urb) {
 277                 p54_free_skb(dev, skb);
 278                 return;
 279         }
 280
 281         hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
 282         hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
 283
 284         usb_fill_bulk_urb(data_urb, priv->udev,
 285                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
 286                           hdr, skb->len + sizeof(*hdr),  FREE_AFTER_TX(skb) ?
 287                           p54u_tx_cb : p54u_tx_dummy_cb, skb);
 288         data_urb->transfer_flags |= URB_ZERO_PACKET;
 289
 290         usb_anchor_urb(data_urb, &priv->submitted);
 291         if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
 292                 usb_unanchor_urb(data_urb);
 293                 p54_free_skb(dev, skb);
 294         }
 295         usb_free_urb(data_urb);
 296 }
 297
 298 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
 299 {
 300         struct p54u_priv *priv = dev->priv;
 301         struct urb *int_urb = NULL, *data_urb = NULL;
 302         struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
 303         struct net2280_reg_write *reg = NULL;
 304         int err = -ENOMEM;
 305
 306         reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
 307         if (!reg)
 308                 goto out;
 309
 310         int_urb = usb_alloc_urb(0, GFP_ATOMIC);
 311         if (!int_urb)
 312                 goto out;
 313
 314         data_urb = usb_alloc_urb(0, GFP_ATOMIC);
 315         if (!data_urb)
 316                 goto out;
 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
 322         memset(hdr, 0, sizeof(*hdr));
 323         hdr->len = cpu_to_le16(skb->len);
 324         hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
 325
 326         usb_fill_bulk_urb(int_urb, priv->udev,
 327                 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
 328                 p54u_tx_dummy_cb, dev);
 329
 330         /*
 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.
 334          */
 335         int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
 336         reg = NULL;
 337
 338         usb_fill_bulk_urb(data_urb, priv->udev,
 339                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
 340                           hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
 341                           p54u_tx_cb : p54u_tx_dummy_cb, skb);
 342         data_urb->transfer_flags |= URB_ZERO_PACKET;
 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         }
 357 out:
 358         usb_free_urb(int_urb);
 359         usb_free_urb(data_urb);
 360
 361         if (err) {
 362                 kfree(reg);
 363                 p54_free_skb(dev, skb);
 364         }
 365 }
 366
 367 static 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
 387 static 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
 418 static 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
 426 static int p54u_device_reset(struct ieee80211_hw *dev)
 427 {
 428         struct p54u_priv *priv = dev->priv;
 429         int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
 430
 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 "
 435                                 "device for reset (%d)!\n", ret);
 436                         return ret;
 437                 }
 438         }
 439
 440         ret = usb_reset_device(priv->udev);
 441         if (lock)
 442                 usb_unlock_device(priv->udev);
 443
 444         if (ret)
 445                 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
 446                         "device (%d)!\n", ret);
 447
 448         return ret;
 449 }
 450
 451 static const char p54u_romboot_3887[] = "~~~~";
 452 static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
 453 {
 454         struct p54u_priv *priv = dev->priv;
 455         u8 *buf;
 456         int ret;
 457
 458         buf = kmemdup(p54u_romboot_3887, 4, GFP_KERNEL);
 459         if (!buf)
 460                 return -ENOMEM;
 461         ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
 462                             buf, 4);
 463         kfree(buf);
 464         if (ret)
 465                 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
 466                         "boot ROM (%d)!\n", ret);
 467
 468         return ret;
 469 }
 470
 471 static const char p54u_firmware_upload_3887[] = "<\r";
 472 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
 473 {
 474         struct p54u_priv *priv = dev->priv;
 475         int err, alen;
 476         u8 carry = 0;
 477         u8 *buf, *tmp;
 478         const u8 *data;
 479         unsigned int left, remains, block_size;
 480         struct x2_header *hdr;
 481         unsigned long timeout;
 482
 483         err = p54u_firmware_reset_3887(dev);
 484         if (err)
 485                 return err;
 486
 487         tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
 488         if (!buf) {
 489                 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
 490                                           "upload buffer!\n");
 491                 return -ENOMEM;
 492         }
 493
 494         left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
 495         strcpy(buf, p54u_firmware_upload_3887);
 496         left -= strlen(p54u_firmware_upload_3887);
 497         tmp += strlen(p54u_firmware_upload_3887);
 498
 499         data = priv->fw->data;
 500         remains = priv->fw->size;
 501
 502         hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
 503         memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
 504         hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
 505         hdr->fw_length = cpu_to_le32(priv->fw->size);
 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) {
 538                         dev_err(&priv->udev->dev, "(p54usb) firmware "
 539                                                   "upload failed!\n");
 540                         goto err_upload_failed;
 541                 }
 542
 543                 tmp = buf;
 544                 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
 545         }
 546
 547         *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
 548                                                  priv->fw->size));
 549         err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
 550         if (err) {
 551                 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
 552                 goto err_upload_failed;
 553         }
 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)) {
 561                         err = -EINVAL;
 562                         break;
 563                 }
 564
 565                 if (time_after(jiffies, timeout)) {
 566                         dev_err(&priv->udev->dev, "(p54usb) firmware boot "
 567                                                   "timed out!\n");
 568                         err = -ETIMEDOUT;
 569                         break;
 570                 }
 571         }
 572         if (err) {
 573                 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
 574                 goto err_upload_failed;
 575         }
 576
 577         buf[0] = 'g';
 578         buf[1] = '\r';
 579         err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
 580         if (err) {
 581                 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
 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
 599 err_upload_failed:
 600         kfree(buf);
 601         return err;
 602 }
 603
 604 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
 605 {
 606         struct p54u_priv *priv = dev->priv;
 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;
 612         const u8 *data;
 613
 614         buf = kmalloc(512, GFP_KERNEL);
 615         if (!buf) {
 616                 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
 617                                           "alloc failed!\n");
 618                 return -ENOMEM;
 619         }
 620
 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! */
 720         remains = priv->fw->size;
 721         data = priv->fw->data;
 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) {
 730                         dev_err(&priv->udev->dev, "(p54usb) firmware block "
 731                                                   "upload failed\n");
 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))) {
 764                         dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
 765                                                   "transfer failed\n");
 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
 830 fail:
 831         kfree(buf);
 832         return err;
 833 }
 834
 835 static 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
 871 out:
 872         if (err)
 873                 release_firmware(priv->fw);
 874
 875         return err;
 876 }
 877
 878 static 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
 893 static 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);
 899 }
 900
 901 static 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;
 909
 910         dev = p54_init_common(sizeof(*priv));
 911
 912         if (!dev) {
 913                 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
 914                 return -ENOMEM;
 915         }
 916
 917         priv = dev->priv;
 918         priv->hw_type = P54U_INVALID_HW;
 919
 920         SET_IEEE80211_DEV(dev, &intf->dev);
 921         usb_set_intfdata(intf, dev);
 922         priv->udev = udev;
 923         priv->intf = intf;
 924         skb_queue_head_init(&priv->rx_queue);
 925         init_usb_anchor(&priv->submitted);
 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;
 948         priv->common.stop = p54u_stop;
 949         if (recognized_pipes < P54U_PIPE_NUMBER) {
 950 #ifdef CONFIG_PM
 951                 /* ISL3887 needs a full reset on resume */
 952                 udev->reset_resume = 1;
 953 #endif /* CONFIG_PM */
 954                 err = p54u_device_reset(dev);
 955
 956                 priv->hw_type = P54U_3887;
 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;
 960                 priv->upload_fw = p54u_upload_firmware_3887;
 961         } else {
 962                 priv->hw_type = P54U_NET2280;
 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;
 966                 priv->upload_fw = p54u_upload_firmware_net2280;
 967         }
 968         err = p54u_load_firmware(dev);
 969         if (err)
 970                 goto err_free_dev;
 971
 972         err = priv->upload_fw(dev);
 973         if (err)
 974                 goto err_free_fw;
 975
 976         p54u_open(dev);
 977         err = p54_read_eeprom(dev);
 978         p54u_stop(dev);
 979         if (err)
 980                 goto err_free_fw;
 981
 982         err = p54_register_common(dev, &udev->dev);
 983         if (err)
 984                 goto err_free_fw;
 985
 986         return 0;
 987
 988 err_free_fw:
 989         release_firmware(priv->fw);
 990
 991 err_free_dev:
 992         p54_free_common(dev);
 993         usb_set_intfdata(intf, NULL);
 994         usb_put_dev(udev);
 995         return err;
 996 }
 997
 998 static 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
1006         p54_unregister_common(dev);
1007
1008         priv = dev->priv;
1009         usb_put_dev(interface_to_usbdev(intf));
1010         release_firmware(priv->fw);
1011         p54_free_common(dev);
1012 }
1013
1014 static int p54u_pre_reset(struct usb_interface *intf)
1015 {
1016         struct ieee80211_hw *dev = usb_get_intfdata(intf);
1017
1018         if (!dev)
1019                 return -ENODEV;
1020
1021         p54u_stop(dev);
1022         return 0;
1023 }
1024
1025 static 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
1040 static int p54u_post_reset(struct usb_interface *intf)
1041 {
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
1055         return 0;
1056 }
1057
1058 #ifdef CONFIG_PM
1059
1060 static 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
1067 static struct usb_driver p54u_driver = {
1068         .name   = "p54usb",
1069         .id_table = p54u_table,
1070         .probe = p54u_probe,
1071         .disconnect = p54u_disconnect,
1072         .pre_reset = p54u_pre_reset,
1073         .post_reset = p54u_post_reset,
1074 #ifdef CONFIG_PM
1075         .suspend = p54u_suspend,
1076         .resume = p54u_resume,
1077         .reset_resume = p54u_resume,
1078 #endif /* CONFIG_PM */
1079         .soft_unbind = 1,
1080 };
1081
1082 static int __init p54u_init(void)
1083 {
1084         return usb_register(&p54u_driver);
1085 }
1086
1087 static void __exit p54u_exit(void)
1088 {
1089         usb_deregister(&p54u_driver);
1090 }
1091
1092 module_init(p54u_init);
1093 module_exit(p54u_exit);