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