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