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