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