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