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