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