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 "lmac.h"
  26 #include "p54usb.h"
  27
  28 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
  29 MODULE_DESCRIPTION("Prism54 USB wireless driver");
  30 MODULE_LICENSE("GPL");
  31 MODULE_ALIAS("prism54usb");
  32 MODULE_FIRMWARE("isl3886usb");
  33 MODULE_FIRMWARE("isl3887usb");
  34
  35 static struct usb_device_id p54u_table[] __devinitdata = {
  36         /* Version 1 devices (pci chip + net2280) */
  37         {USB_DEVICE(0x0506, 0x0a11)},   /* 3COM 3CRWE254G72 */
  38         {USB_DEVICE(0x0707, 0xee06)},   /* SMC 2862W-G */
  39         {USB_DEVICE(0x083a, 0x4501)},   /* Accton 802.11g WN4501 USB */
  40         {USB_DEVICE(0x083a, 0x4502)},   /* Siemens Gigaset USB Adapter */
  41         {USB_DEVICE(0x083a, 0x5501)},   /* Phillips CPWUA054 */
  42         {USB_DEVICE(0x0846, 0x4200)},   /* Netgear WG121 */
  43         {USB_DEVICE(0x0846, 0x4210)},   /* Netgear WG121 the second ? */
  44         {USB_DEVICE(0x0846, 0x4220)},   /* Netgear WG111 */
  45         {USB_DEVICE(0x09aa, 0x1000)},   /* Spinnaker Proto board */
  46         {USB_DEVICE(0x0cde, 0x0006)},   /* Medion 40900, Roper Europe */
  47         {USB_DEVICE(0x124a, 0x4023)},   /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
  48         {USB_DEVICE(0x1915, 0x2234)},   /* Linksys WUSB54G OEM */
  49         {USB_DEVICE(0x1915, 0x2235)},   /* Linksys WUSB54G Portable OEM */
  50         {USB_DEVICE(0x2001, 0x3701)},   /* DLink DWL-G120 Spinnaker */
  51         {USB_DEVICE(0x2001, 0x3703)},   /* DLink DWL-G122 */
  52         {USB_DEVICE(0x5041, 0x2234)},   /* Linksys WUSB54G */
  53         {USB_DEVICE(0x5041, 0x2235)},   /* Linksys WUSB54G Portable */
  54
  55         /* Version 2 devices (3887) */
  56         {USB_DEVICE(0x0471, 0x1230)},   /* Philips CPWUA054/00 */
  57         {USB_DEVICE(0x050d, 0x7050)},   /* Belkin F5D7050 ver 1000 */
  58         {USB_DEVICE(0x0572, 0x2000)},   /* Cohiba Proto board */
  59         {USB_DEVICE(0x0572, 0x2002)},   /* Cohiba Proto board */
  60         {USB_DEVICE(0x06b9, 0x0121)},   /* Thomson SpeedTouch 121g */
  61         {USB_DEVICE(0x0707, 0xee13)},   /* SMC 2862W-G version 2 */
  62         {USB_DEVICE(0x083a, 0x4521)},   /* Siemens Gigaset USB Adapter 54 version 2 */
  63         {USB_DEVICE(0x0846, 0x4240)},   /* Netgear WG111 (v2) */
  64         {USB_DEVICE(0x0915, 0x2000)},   /* Cohiba Proto board */
  65         {USB_DEVICE(0x0915, 0x2002)},   /* Cohiba Proto board */
  66         {USB_DEVICE(0x0baf, 0x0118)},   /* U.S. Robotics U5 802.11g Adapter*/
  67         {USB_DEVICE(0x0bf8, 0x1009)},   /* FUJITSU E-5400 USB D1700*/
  68         {USB_DEVICE(0x0cde, 0x0006)},   /* Medion MD40900 */
  69         {USB_DEVICE(0x0cde, 0x0008)},   /* Sagem XG703A */
  70         {USB_DEVICE(0x0cde, 0x0015)},   /* Zcomax XG-705A */
  71         {USB_DEVICE(0x0d8e, 0x3762)},   /* DLink DWL-G120 Cohiba */
  72         {USB_DEVICE(0x124a, 0x4025)},   /* IOGear GWU513 (GW3887IK chip) */
  73         {USB_DEVICE(0x1260, 0xee22)},   /* SMC 2862W-G version 2 */
  74         {USB_DEVICE(0x13b1, 0x000a)},   /* Linksys WUSB54G ver 2 */
  75         {USB_DEVICE(0x13B1, 0x000C)},   /* Linksys WUSB54AG */
  76         {USB_DEVICE(0x1413, 0x5400)},   /* Telsey 802.11g USB2.0 Adapter */
  77         {USB_DEVICE(0x1435, 0x0427)},   /* Inventel UR054G */
  78         {USB_DEVICE(0x2001, 0x3704)},   /* DLink DWL-G122 rev A2 */
  79         {USB_DEVICE(0x413c, 0x8102)},   /* Spinnaker DUT */
  80         {USB_DEVICE(0x413c, 0x8104)},   /* Cohiba Proto board */
  81         {}
  82 };
  83
  84 MODULE_DEVICE_TABLE(usb, p54u_table);
  85
  86 static const struct {
  87         u32 intf;
  88         enum p54u_hw_type type;
  89         const char *fw;
  90         const char *fw_legacy;
  91         char hw[20];
  92 } p54u_fwlist[__NUM_P54U_HWTYPES] = {
  93         {
  94                 .type = P54U_NET2280,
  95                 .intf = FW_LM86,
  96                 .fw = "isl3886usb",
  97                 .fw_legacy = "isl3890usb",
  98                 .hw = "ISL3886 + net2280",
  99         },
 100         {
 101                 .type = P54U_3887,
 102                 .intf = FW_LM87,
 103                 .fw = "isl3887usb",
 104                 .fw_legacy = "isl3887usb_bare",
 105                 .hw = "ISL3887",
 106         },
 107 };
 108
 109 static void p54u_rx_cb(struct urb *urb)
 110 {
 111         struct sk_buff *skb = (struct sk_buff *) urb->context;
 112         struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
 113         struct ieee80211_hw *dev = info->dev;
 114         struct p54u_priv *priv = dev->priv;
 115
 116         skb_unlink(skb, &priv->rx_queue);
 117
 118         if (unlikely(urb->status)) {
 119                 dev_kfree_skb_irq(skb);
 120                 return;
 121         }
 122
 123         skb_put(skb, urb->actual_length);
 124
 125         if (priv->hw_type == P54U_NET2280)
 126                 skb_pull(skb, priv->common.tx_hdr_len);
 127         if (priv->common.fw_interface == FW_LM87) {
 128                 skb_pull(skb, 4);
 129                 skb_put(skb, 4);
 130         }
 131
 132         if (p54_rx(dev, skb)) {
 133                 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
 134                 if (unlikely(!skb)) {
 135                         /* TODO check rx queue length and refill *somewhere* */
 136                         return;
 137                 }
 138
 139                 info = (struct p54u_rx_info *) skb->cb;
 140                 info->urb = urb;
 141                 info->dev = dev;
 142                 urb->transfer_buffer = skb_tail_pointer(skb);
 143                 urb->context = skb;
 144         } else {
 145                 if (priv->hw_type == P54U_NET2280)
 146                         skb_push(skb, priv->common.tx_hdr_len);
 147                 if (priv->common.fw_interface == FW_LM87) {
 148                         skb_push(skb, 4);
 149                         skb_put(skb, 4);
 150                 }
 151                 skb_reset_tail_pointer(skb);
 152                 skb_trim(skb, 0);
 153                 urb->transfer_buffer = skb_tail_pointer(skb);
 154         }
 155         skb_queue_tail(&priv->rx_queue, skb);
 156         usb_anchor_urb(urb, &priv->submitted);
 157         if (usb_submit_urb(urb, GFP_ATOMIC)) {
 158                 skb_unlink(skb, &priv->rx_queue);
 159                 usb_unanchor_urb(urb);
 160                 dev_kfree_skb_irq(skb);
 161         }
 162 }
 163
 164 static void p54u_tx_cb(struct urb *urb)
 165 {
 166         struct sk_buff *skb = urb->context;
 167         struct ieee80211_hw *dev = (struct ieee80211_hw *)
 168                 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
 169
 170         p54_free_skb(dev, skb);
 171 }
 172
 173 static void p54u_tx_dummy_cb(struct urb *urb) { }
 174
 175 static void p54u_free_urbs(struct ieee80211_hw *dev)
 176 {
 177         struct p54u_priv *priv = dev->priv;
 178         usb_kill_anchored_urbs(&priv->submitted);
 179 }
 180
 181 static int p54u_init_urbs(struct ieee80211_hw *dev)
 182 {
 183         struct p54u_priv *priv = dev->priv;
 184         struct urb *entry = NULL;
 185         struct sk_buff *skb;
 186         struct p54u_rx_info *info;
 187         int ret = 0;
 188
 189         while (skb_queue_len(&priv->rx_queue) < 32) {
 190                 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
 191                 if (!skb) {
 192                         ret = -ENOMEM;
 193                         goto err;
 194                 }
 195                 entry = usb_alloc_urb(0, GFP_KERNEL);
 196                 if (!entry) {
 197                         ret = -ENOMEM;
 198                         goto err;
 199                 }
 200
 201                 usb_fill_bulk_urb(entry, priv->udev,
 202                                   usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
 203                                   skb_tail_pointer(skb),
 204                                   priv->common.rx_mtu + 32, p54u_rx_cb, skb);
 205                 info = (struct p54u_rx_info *) skb->cb;
 206                 info->urb = entry;
 207                 info->dev = dev;
 208                 skb_queue_tail(&priv->rx_queue, skb);
 209
 210                 usb_anchor_urb(entry, &priv->submitted);
 211                 ret = usb_submit_urb(entry, GFP_KERNEL);
 212                 if (ret) {
 213                         skb_unlink(skb, &priv->rx_queue);
 214                         usb_unanchor_urb(entry);
 215                         goto err;
 216                 }
 217                 usb_free_urb(entry);
 218                 entry = NULL;
 219         }
 220
 221         return 0;
 222
 223  err:
 224         usb_free_urb(entry);
 225         kfree_skb(skb);
 226         p54u_free_urbs(dev);
 227         return ret;
 228 }
 229
 230 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
 231 {
 232         u32 chk = 0;
 233
 234         length >>= 2;
 235         while (length--) {
 236                 chk ^= le32_to_cpu(*data++);
 237                 chk = (chk >> 5) ^ (chk << 3);
 238         }
 239
 240         return cpu_to_le32(chk);
 241 }
 242
 243 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
 244 {
 245         struct p54u_priv *priv = dev->priv;
 246         struct urb *data_urb;
 247         struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
 248
 249         data_urb = usb_alloc_urb(0, GFP_ATOMIC);
 250         if (!data_urb) {
 251                 p54_free_skb(dev, skb);
 252                 return;
 253         }
 254
 255         hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
 256         hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
 257
 258         usb_fill_bulk_urb(data_urb, priv->udev,
 259                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
 260                           hdr, skb->len + sizeof(*hdr),  FREE_AFTER_TX(skb) ?
 261                           p54u_tx_cb : p54u_tx_dummy_cb, skb);
 262         data_urb->transfer_flags |= URB_ZERO_PACKET;
 263
 264         usb_anchor_urb(data_urb, &priv->submitted);
 265         if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
 266                 usb_unanchor_urb(data_urb);
 267                 p54_free_skb(dev, skb);
 268         }
 269         usb_free_urb(data_urb);
 270 }
 271
 272 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
 273 {
 274         struct p54u_priv *priv = dev->priv;
 275         struct urb *int_urb = NULL, *data_urb = NULL;
 276         struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
 277         struct net2280_reg_write *reg = NULL;
 278         int err = -ENOMEM;
 279
 280         reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
 281         if (!reg)
 282                 goto out;
 283
 284         int_urb = usb_alloc_urb(0, GFP_ATOMIC);
 285         if (!int_urb)
 286                 goto out;
 287
 288         data_urb = usb_alloc_urb(0, GFP_ATOMIC);
 289         if (!data_urb)
 290                 goto out;
 291
 292         reg->port = cpu_to_le16(NET2280_DEV_U32);
 293         reg->addr = cpu_to_le32(P54U_DEV_BASE);
 294         reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
 295
 296         memset(hdr, 0, sizeof(*hdr));
 297         hdr->len = cpu_to_le16(skb->len);
 298         hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
 299
 300         usb_fill_bulk_urb(int_urb, priv->udev,
 301                 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
 302                 p54u_tx_dummy_cb, dev);
 303
 304         /*
 305          * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
 306          * free what is inside the transfer_buffer after the last reference to
 307          * the int_urb is dropped.
 308          */
 309         int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
 310         reg = NULL;
 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                 kfree(reg);
 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         p54_free_common(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         p54_unregister_common(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 }
 985
 986 static int p54u_pre_reset(struct usb_interface *intf)
 987 {
 988         struct ieee80211_hw *dev = usb_get_intfdata(intf);
 989
 990         if (!dev)
 991                 return -ENODEV;
 992
 993         p54u_stop(dev);
 994         return 0;
 995 }
 996
 997 static int p54u_resume(struct usb_interface *intf)
 998 {
 999         struct ieee80211_hw *dev = usb_get_intfdata(intf);
1000         struct p54u_priv *priv;
1001
1002         if (!dev)
1003                 return -ENODEV;
1004
1005         priv = dev->priv;
1006         if (unlikely(!(priv->upload_fw && priv->fw)))
1007                 return 0;
1008
1009         return priv->upload_fw(dev);
1010 }
1011
1012 static int p54u_post_reset(struct usb_interface *intf)
1013 {
1014         struct ieee80211_hw *dev = usb_get_intfdata(intf);
1015         struct p54u_priv *priv;
1016         int err;
1017
1018         err = p54u_resume(intf);
1019         if (err)
1020                 return err;
1021
1022         /* reinitialize old device state */
1023         priv = dev->priv;
1024         if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1025                 ieee80211_restart_hw(dev);
1026
1027         return 0;
1028 }
1029
1030 #ifdef CONFIG_PM
1031
1032 static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1033 {
1034         return p54u_pre_reset(intf);
1035 }
1036
1037 #endif /* CONFIG_PM */
1038
1039 static struct usb_driver p54u_driver = {
1040         .name   = "p54usb",
1041         .id_table = p54u_table,
1042         .probe = p54u_probe,
1043         .disconnect = p54u_disconnect,
1044         .pre_reset = p54u_pre_reset,
1045         .post_reset = p54u_post_reset,
1046 #ifdef CONFIG_PM
1047         .suspend = p54u_suspend,
1048         .resume = p54u_resume,
1049         .reset_resume = p54u_resume,
1050 #endif /* CONFIG_PM */
1051         .soft_unbind = 1,
1052 };
1053
1054 static int __init p54u_init(void)
1055 {
1056         return usb_register(&p54u_driver);
1057 }
1058
1059 static void __exit p54u_exit(void)
1060 {
1061         usb_deregister(&p54u_driver);
1062 }
1063
1064 module_init(p54u_init);
1065 module_exit(p54u_exit);