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