SAFE public projects git trees. - safe/jmp/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
 148         p54_free_skb(dev, skb);
 149 }
 150
 151 static void p54u_tx_dummy_cb(struct urb *urb) { }
 152
 153 static void p54u_free_urbs(struct ieee80211_hw *dev)
 154 {
 155         struct p54u_priv *priv = dev->priv;
 156         usb_kill_anchored_urbs(&priv->submitted);
 157 }
 158
 159 static int p54u_init_urbs(struct ieee80211_hw *dev)
 160 {
 161         struct p54u_priv *priv = dev->priv;
 162         struct urb *entry = NULL;
 163         struct sk_buff *skb;
 164         struct p54u_rx_info *info;
 165         int ret = 0;
 166
 167         while (skb_queue_len(&priv->rx_queue) < 32) {
 168                 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
 169                 if (!skb) {
 170                         ret = -ENOMEM;
 171                         goto err;
 172                 }
 173                 entry = usb_alloc_urb(0, GFP_KERNEL);
 174                 if (!entry) {
 175                         ret = -ENOMEM;
 176                         goto err;
 177                 }
 178
 179                 usb_fill_bulk_urb(entry, priv->udev,
 180                                   usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
 181                                   skb_tail_pointer(skb),
 182                                   priv->common.rx_mtu + 32, p54u_rx_cb, skb);
 183                 info = (struct p54u_rx_info *) skb->cb;
 184                 info->urb = entry;
 185                 info->dev = dev;
 186                 skb_queue_tail(&priv->rx_queue, skb);
 187
 188                 usb_anchor_urb(entry, &priv->submitted);
 189                 ret = usb_submit_urb(entry, GFP_KERNEL);
 190                 if (ret) {
 191                         skb_unlink(skb, &priv->rx_queue);
 192                         usb_unanchor_urb(entry);
 193                         goto err;
 194                 }
 195                 usb_free_urb(entry);
 196                 entry = NULL;
 197         }
 198
 199         return 0;
 200
 201  err:
 202         usb_free_urb(entry);
 203         kfree_skb(skb);
 204         p54u_free_urbs(dev);
 205         return ret;
 206 }
 207
 208 static void p54u_tx_3887(struct ieee80211_hw *dev, struct sk_buff *skb)
 209 {
 210         struct p54u_priv *priv = dev->priv;
 211         struct urb *addr_urb, *data_urb;
 212         int err = 0;
 213
 214         addr_urb = usb_alloc_urb(0, GFP_ATOMIC);
 215         if (!addr_urb)
 216                 return;
 217
 218         data_urb = usb_alloc_urb(0, GFP_ATOMIC);
 219         if (!data_urb) {
 220                 usb_free_urb(addr_urb);
 221                 return;
 222         }
 223
 224         usb_fill_bulk_urb(addr_urb, priv->udev,
 225                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
 226                           &((struct p54_hdr *)skb->data)->req_id, 4,
 227                           p54u_tx_dummy_cb, dev);
 228         usb_fill_bulk_urb(data_urb, priv->udev,
 229                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
 230                           skb->data, skb->len, FREE_AFTER_TX(skb) ?
 231                           p54u_tx_cb : p54u_tx_dummy_cb, skb);
 232         addr_urb->transfer_flags |= URB_ZERO_PACKET;
 233         data_urb->transfer_flags |= URB_ZERO_PACKET;
 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(data_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 = (void *)skb->data - sizeof(*hdr);
 273
 274         data_urb = usb_alloc_urb(0, GFP_ATOMIC);
 275         if (!data_urb)
 276                 return;
 277
 278         hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
 279         hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
 280
 281         usb_fill_bulk_urb(data_urb, priv->udev,
 282                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
 283                           hdr, skb->len + sizeof(*hdr),  FREE_AFTER_TX(skb) ?
 284                           p54u_tx_cb : p54u_tx_dummy_cb, skb);
 285         data_urb->transfer_flags |= URB_ZERO_PACKET;
 286
 287         usb_anchor_urb(data_urb, &priv->submitted);
 288         if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
 289                 usb_unanchor_urb(data_urb);
 290                 p54_free_skb(dev, skb);
 291         }
 292         usb_free_urb(data_urb);
 293 }
 294
 295 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
 296 {
 297         struct p54u_priv *priv = dev->priv;
 298         struct urb *int_urb, *data_urb;
 299         struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
 300         struct net2280_reg_write *reg;
 301         int err = 0;
 302
 303         reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
 304         if (!reg)
 305                 return;
 306
 307         int_urb = usb_alloc_urb(0, GFP_ATOMIC);
 308         if (!int_urb) {
 309                 kfree(reg);
 310                 return;
 311         }
 312
 313         data_urb = usb_alloc_urb(0, GFP_ATOMIC);
 314         if (!data_urb) {
 315                 kfree(reg);
 316                 usb_free_urb(int_urb);
 317                 return;
 318         }
 319
 320         reg->port = cpu_to_le16(NET2280_DEV_U32);
 321         reg->addr = cpu_to_le32(P54U_DEV_BASE);
 322         reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
 323
 324         memset(hdr, 0, sizeof(*hdr));
 325         hdr->len = cpu_to_le16(skb->len);
 326         hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
 327
 328         usb_fill_bulk_urb(int_urb, priv->udev,
 329                 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
 330                 p54u_tx_dummy_cb, dev);
 331
 332         /*
 333          * This flag triggers a code path in the USB subsystem that will
 334          * free what's inside the transfer_buffer after the callback routine
 335          * has completed.
 336          */
 337         int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
 338
 339         usb_fill_bulk_urb(data_urb, priv->udev,
 340                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
 341                           hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
 342                           p54u_tx_cb : p54u_tx_dummy_cb, skb);
 343         data_urb->transfer_flags |= URB_ZERO_PACKET;
 344
 345         usb_anchor_urb(int_urb, &priv->submitted);
 346         err = usb_submit_urb(int_urb, GFP_ATOMIC);
 347         if (err) {
 348                 usb_unanchor_urb(int_urb);
 349                 goto out;
 350         }
 351
 352         usb_anchor_urb(data_urb, &priv->submitted);
 353         err = usb_submit_urb(data_urb, GFP_ATOMIC);
 354         if (err) {
 355                 usb_unanchor_urb(data_urb);
 356                 goto out;
 357         }
 358  out:
 359         usb_free_urb(int_urb);
 360         usb_free_urb(data_urb);
 361
 362         if (err) {
 363                 skb_pull(skb, sizeof(*hdr));
 364                 p54_free_skb(dev, skb);
 365         }
 366 }
 367
 368 static int p54u_write(struct p54u_priv *priv,
 369                       struct net2280_reg_write *buf,
 370                       enum net2280_op_type type,
 371                       __le32 addr, __le32 val)
 372 {
 373         unsigned int ep;
 374         int alen;
 375
 376         if (type & 0x0800)
 377                 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
 378         else
 379                 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
 380
 381         buf->port = cpu_to_le16(type);
 382         buf->addr = addr;
 383         buf->val = val;
 384
 385         return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
 386 }
 387
 388 static int p54u_read(struct p54u_priv *priv, void *buf,
 389                      enum net2280_op_type type,
 390                      __le32 addr, __le32 *val)
 391 {
 392         struct net2280_reg_read *read = buf;
 393         __le32 *reg = buf;
 394         unsigned int ep;
 395         int alen, err;
 396
 397         if (type & 0x0800)
 398                 ep = P54U_PIPE_DEV;
 399         else
 400                 ep = P54U_PIPE_BRG;
 401
 402         read->port = cpu_to_le16(type);
 403         read->addr = addr;
 404
 405         err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
 406                            read, sizeof(*read), &alen, 1000);
 407         if (err)
 408                 return err;
 409
 410         err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
 411                            reg, sizeof(*reg), &alen, 1000);
 412         if (err)
 413                 return err;
 414
 415         *val = *reg;
 416         return 0;
 417 }
 418
 419 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
 420                          void *data, size_t len)
 421 {
 422         int alen;
 423         return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
 424                             data, len, &alen, 2000);
 425 }
 426
 427 static const char p54u_romboot_3887[] = "~~~~";
 428 static const char p54u_firmware_upload_3887[] = "<\r";
 429
 430 static int p54u_device_reset_3887(struct ieee80211_hw *dev)
 431 {
 432         struct p54u_priv *priv = dev->priv;
 433         int ret, lock;
 434         u8 buf[4];
 435
 436         ret = lock = usb_lock_device_for_reset(priv->udev, priv->intf);
 437         if (ret < 0) {
 438                 dev_err(&priv->udev->dev, "(p54usb) unable to lock device for "
 439                         "reset: %d\n", ret);
 440                 return ret;
 441         }
 442
 443         ret = usb_reset_device(priv->udev);
 444         if (lock)
 445                 usb_unlock_device(priv->udev);
 446
 447         if (ret) {
 448                 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
 449                         "device: %d\n", ret);
 450                 return ret;
 451         }
 452
 453         memcpy(&buf, p54u_romboot_3887, sizeof(buf));
 454         ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
 455                             buf, sizeof(buf));
 456         if (ret)
 457                 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
 458                         "boot ROM: %d\n", ret);
 459
 460         return ret;
 461 }
 462
 463 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
 464 {
 465         struct p54u_priv *priv = dev->priv;
 466         const struct firmware *fw_entry = NULL;
 467         int err, alen;
 468         u8 carry = 0;
 469         u8 *buf, *tmp;
 470         const u8 *data;
 471         unsigned int left, remains, block_size;
 472         struct x2_header *hdr;
 473         unsigned long timeout;
 474
 475         tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
 476         if (!buf) {
 477                 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
 478                                           "upload buffer!\n");
 479                 err = -ENOMEM;
 480                 goto err_bufalloc;
 481         }
 482
 483         err = p54u_device_reset_3887(dev);
 484         if (err)
 485                 goto err_reset;
 486
 487         err = request_firmware(&fw_entry, "isl3887usb", &priv->udev->dev);
 488         if (err) {
 489                 dev_err(&priv->udev->dev, "p54usb: cannot find firmware "
 490                                           "(isl3887usb)\n");
 491                 err = request_firmware(&fw_entry, "isl3887usb_bare",
 492                         &priv->udev->dev);
 493                 if (err)
 494                         goto err_req_fw_failed;
 495         }
 496
 497         err = p54_parse_firmware(dev, fw_entry);
 498         if (err)
 499                 goto err_upload_failed;
 500
 501         left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);
 502         strcpy(buf, p54u_firmware_upload_3887);
 503         left -= strlen(p54u_firmware_upload_3887);
 504         tmp += strlen(p54u_firmware_upload_3887);
 505
 506         data = fw_entry->data;
 507         remains = fw_entry->size;
 508
 509         hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
 510         memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
 511         hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
 512         hdr->fw_length = cpu_to_le32(fw_entry->size);
 513         hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
 514                                          sizeof(u32)*2));
 515         left -= sizeof(*hdr);
 516         tmp += sizeof(*hdr);
 517
 518         while (remains) {
 519                 while (left--) {
 520                         if (carry) {
 521                                 *tmp++ = carry;
 522                                 carry = 0;
 523                                 remains--;
 524                                 continue;
 525                         }
 526                         switch (*data) {
 527                         case '~':
 528                                 *tmp++ = '}';
 529                                 carry = '^';
 530                                 break;
 531                         case '}':
 532                                 *tmp++ = '}';
 533                                 carry = ']';
 534                                 break;
 535                         default:
 536                                 *tmp++ = *data;
 537                                 remains--;
 538                                 break;
 539                         }
 540                         data++;
 541                 }
 542
 543                 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
 544                 if (err) {
 545                         dev_err(&priv->udev->dev, "(p54usb) firmware "
 546                                                   "upload failed!\n");
 547                         goto err_upload_failed;
 548                 }
 549
 550                 tmp = buf;
 551                 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
 552         }
 553
 554         *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));
 555         err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
 556         if (err) {
 557                 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
 558                 goto err_upload_failed;
 559         }
 560         timeout = jiffies + msecs_to_jiffies(1000);
 561         while (!(err = usb_bulk_msg(priv->udev,
 562                 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
 563                 if (alen > 2 && !memcmp(buf, "OK", 2))
 564                         break;
 565
 566                 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
 567                         err = -EINVAL;
 568                         break;
 569                 }
 570
 571                 if (time_after(jiffies, timeout)) {
 572                         dev_err(&priv->udev->dev, "(p54usb) firmware boot "
 573                                                   "timed out!\n");
 574                         err = -ETIMEDOUT;
 575                         break;
 576                 }
 577         }
 578         if (err) {
 579                 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
 580                 goto err_upload_failed;
 581         }
 582
 583         buf[0] = 'g';
 584         buf[1] = '\r';
 585         err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
 586         if (err) {
 587                 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
 588                 goto err_upload_failed;
 589         }
 590
 591         timeout = jiffies + msecs_to_jiffies(1000);
 592         while (!(err = usb_bulk_msg(priv->udev,
 593                 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
 594                 if (alen > 0 && buf[0] == 'g')
 595                         break;
 596
 597                 if (time_after(jiffies, timeout)) {
 598                         err = -ETIMEDOUT;
 599                         break;
 600                 }
 601         }
 602         if (err)
 603                 goto err_upload_failed;
 604
 605   err_upload_failed:
 606         release_firmware(fw_entry);
 607   err_req_fw_failed:
 608   err_reset:
 609         kfree(buf);
 610   err_bufalloc:
 611         return err;
 612 }
 613
 614 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
 615 {
 616         struct p54u_priv *priv = dev->priv;
 617         const struct firmware *fw_entry = NULL;
 618         const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
 619         int err, alen;
 620         void *buf;
 621         __le32 reg;
 622         unsigned int remains, offset;
 623         const u8 *data;
 624
 625         buf = kmalloc(512, GFP_KERNEL);
 626         if (!buf) {
 627                 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
 628                                           "alloc failed!\n");
 629                 return -ENOMEM;
 630         }
 631
 632         err = request_firmware(&fw_entry, "isl3886usb", &priv->udev->dev);
 633         if (err) {
 634                 dev_err(&priv->udev->dev, "(p54usb) cannot find firmware "
 635                                           "(isl3886usb)\n");
 636                 err = request_firmware(&fw_entry, "isl3890usb",
 637                         &priv->udev->dev);
 638                 if (err) {
 639                         kfree(buf);
 640                         return err;
 641                         }
 642         }
 643
 644         err = p54_parse_firmware(dev, fw_entry);
 645         if (err) {
 646                 kfree(buf);
 647                 release_firmware(fw_entry);
 648                 return err;
 649         }
 650
 651 #define P54U_WRITE(type, addr, data) \
 652         do {\
 653                 err = p54u_write(priv, buf, type,\
 654                                  cpu_to_le32((u32)(unsigned long)addr), data);\
 655                 if (err) \
 656                         goto fail;\
 657         } while (0)
 658
 659 #define P54U_READ(type, addr) \
 660         do {\
 661                 err = p54u_read(priv, buf, type,\
 662                                 cpu_to_le32((u32)(unsigned long)addr), &reg);\
 663                 if (err)\
 664                         goto fail;\
 665         } while (0)
 666
 667         /* power down net2280 bridge */
 668         P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
 669         reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
 670         reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
 671         P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
 672
 673         mdelay(100);
 674
 675         /* power up bridge */
 676         reg |= cpu_to_le32(P54U_BRG_POWER_UP);
 677         reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
 678         P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
 679
 680         mdelay(100);
 681
 682         P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
 683                    cpu_to_le32(NET2280_CLK_30Mhz |
 684                                NET2280_PCI_ENABLE |
 685                                NET2280_PCI_SOFT_RESET));
 686
 687         mdelay(20);
 688
 689         P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
 690                    cpu_to_le32(PCI_COMMAND_MEMORY |
 691                                PCI_COMMAND_MASTER));
 692
 693         P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
 694                    cpu_to_le32(NET2280_BASE));
 695
 696         P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
 697         reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
 698         P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
 699
 700         // TODO: we really need this?
 701         P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
 702
 703         P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
 704                    cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
 705         P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
 706                    cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
 707
 708         P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
 709                    cpu_to_le32(NET2280_BASE2));
 710
 711         /* finally done setting up the bridge */
 712
 713         P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
 714                    cpu_to_le32(PCI_COMMAND_MEMORY |
 715                                PCI_COMMAND_MASTER));
 716
 717         P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
 718         P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
 719                    cpu_to_le32(P54U_DEV_BASE));
 720
 721         P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
 722         P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
 723                    cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
 724
 725         /* do romboot */
 726         P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
 727
 728         P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
 729         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
 730         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
 731         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
 732         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 733
 734         mdelay(20);
 735
 736         reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
 737         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 738
 739         mdelay(20);
 740
 741         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
 742         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 743
 744         mdelay(100);
 745
 746         P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
 747         P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
 748
 749         /* finally, we can upload firmware now! */
 750         remains = fw_entry->size;
 751         data = fw_entry->data;
 752         offset = ISL38XX_DEV_FIRMWARE_ADDR;
 753
 754         while (remains) {
 755                 unsigned int block_len = min(remains, (unsigned int)512);
 756                 memcpy(buf, data, block_len);
 757
 758                 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
 759                 if (err) {
 760                         dev_err(&priv->udev->dev, "(p54usb) firmware block "
 761                                                   "upload failed\n");
 762                         goto fail;
 763                 }
 764
 765                 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
 766                            cpu_to_le32(0xc0000f00));
 767
 768                 P54U_WRITE(NET2280_DEV_U32,
 769                            0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
 770                 P54U_WRITE(NET2280_DEV_U32,
 771                            0x0020 | (unsigned long)&devreg->direct_mem_win,
 772                            cpu_to_le32(1));
 773
 774                 P54U_WRITE(NET2280_DEV_U32,
 775                            0x0024 | (unsigned long)&devreg->direct_mem_win,
 776                            cpu_to_le32(block_len));
 777                 P54U_WRITE(NET2280_DEV_U32,
 778                            0x0028 | (unsigned long)&devreg->direct_mem_win,
 779                            cpu_to_le32(offset));
 780
 781                 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
 782                            cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
 783                 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
 784                            cpu_to_le32(block_len >> 2));
 785                 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
 786                            cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
 787
 788                 mdelay(10);
 789
 790                 P54U_READ(NET2280_DEV_U32,
 791                           0x002C | (unsigned long)&devreg->direct_mem_win);
 792                 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
 793                     !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
 794                         dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
 795                                                   "transfer failed\n");
 796                         goto fail;
 797                 }
 798
 799                 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
 800                            cpu_to_le32(NET2280_FIFO_FLUSH));
 801
 802                 remains -= block_len;
 803                 data += block_len;
 804                 offset += block_len;
 805         }
 806
 807         /* do ramboot */
 808         P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
 809         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
 810         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
 811         reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
 812         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 813
 814         mdelay(20);
 815
 816         reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
 817         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 818
 819         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
 820         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 821
 822         mdelay(100);
 823
 824         P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
 825         P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
 826
 827         /* start up the firmware */
 828         P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
 829                    cpu_to_le32(ISL38XX_INT_IDENT_INIT));
 830
 831         P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
 832                    cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
 833
 834         P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
 835                    cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
 836                                NET2280_USB_INTERRUPT_ENABLE));
 837
 838         P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
 839                    cpu_to_le32(ISL38XX_DEV_INT_RESET));
 840
 841         err = usb_interrupt_msg(priv->udev,
 842                                 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
 843                                 buf, sizeof(__le32), &alen, 1000);
 844         if (err || alen != sizeof(__le32))
 845                 goto fail;
 846
 847         P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
 848         P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
 849
 850         if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
 851                 err = -EINVAL;
 852
 853         P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
 854         P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
 855                    cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
 856
 857 #undef P54U_WRITE
 858 #undef P54U_READ
 859
 860  fail:
 861         release_firmware(fw_entry);
 862         kfree(buf);
 863         return err;
 864 }
 865
 866 static int p54u_open(struct ieee80211_hw *dev)
 867 {
 868         struct p54u_priv *priv = dev->priv;
 869         int err;
 870
 871         err = p54u_init_urbs(dev);
 872         if (err) {
 873                 return err;
 874         }
 875
 876         priv->common.open = p54u_init_urbs;
 877
 878         return 0;
 879 }
 880
 881 static void p54u_stop(struct ieee80211_hw *dev)
 882 {
 883         /* TODO: figure out how to reliably stop the 3887 and net2280 so
 884            the hardware is still usable next time we want to start it.
 885            until then, we just stop listening to the hardware.. */
 886         p54u_free_urbs(dev);
 887         return;
 888 }
 889
 890 static int __devinit p54u_probe(struct usb_interface *intf,
 891                                 const struct usb_device_id *id)
 892 {
 893         struct usb_device *udev = interface_to_usbdev(intf);
 894         struct ieee80211_hw *dev;
 895         struct p54u_priv *priv;
 896         int err;
 897         unsigned int i, recognized_pipes;
 898
 899         dev = p54_init_common(sizeof(*priv));
 900
 901         if (!dev) {
 902                 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
 903                 return -ENOMEM;
 904         }
 905
 906         priv = dev->priv;
 907
 908         SET_IEEE80211_DEV(dev, &intf->dev);
 909         usb_set_intfdata(intf, dev);
 910         priv->udev = udev;
 911         priv->intf = intf;
 912         skb_queue_head_init(&priv->rx_queue);
 913         init_usb_anchor(&priv->submitted);
 914
 915         usb_get_dev(udev);
 916
 917         /* really lazy and simple way of figuring out if we're a 3887 */
 918         /* TODO: should just stick the identification in the device table */
 919         i = intf->altsetting->desc.bNumEndpoints;
 920         recognized_pipes = 0;
 921         while (i--) {
 922                 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
 923                 case P54U_PIPE_DATA:
 924                 case P54U_PIPE_MGMT:
 925                 case P54U_PIPE_BRG:
 926                 case P54U_PIPE_DEV:
 927                 case P54U_PIPE_DATA | USB_DIR_IN:
 928                 case P54U_PIPE_MGMT | USB_DIR_IN:
 929                 case P54U_PIPE_BRG | USB_DIR_IN:
 930                 case P54U_PIPE_DEV | USB_DIR_IN:
 931                 case P54U_PIPE_INT | USB_DIR_IN:
 932                         recognized_pipes++;
 933                 }
 934         }
 935         priv->common.open = p54u_open;
 936         priv->common.stop = p54u_stop;
 937         if (recognized_pipes < P54U_PIPE_NUMBER) {
 938                 priv->hw_type = P54U_3887;
 939                 err = p54u_upload_firmware_3887(dev);
 940                 if (priv->common.fw_interface == FW_LM87) {
 941                         dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
 942                         priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
 943                         priv->common.tx = p54u_tx_lm87;
 944                 } else
 945                         priv->common.tx = p54u_tx_3887;
 946         } else {
 947                 priv->hw_type = P54U_NET2280;
 948                 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
 949                 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
 950                 priv->common.tx = p54u_tx_net2280;
 951                 err = p54u_upload_firmware_net2280(dev);
 952         }
 953         if (err)
 954                 goto err_free_dev;
 955
 956         p54u_open(dev);
 957         err = p54_read_eeprom(dev);
 958         p54u_stop(dev);
 959         if (err)
 960                 goto err_free_dev;
 961
 962         err = ieee80211_register_hw(dev);
 963         if (err) {
 964                 dev_err(&udev->dev, "(p54usb) Cannot register netdevice\n");
 965                 goto err_free_dev;
 966         }
 967
 968         return 0;
 969
 970  err_free_dev:
 971         ieee80211_free_hw(dev);
 972         usb_set_intfdata(intf, NULL);
 973         usb_put_dev(udev);
 974         return err;
 975 }
 976
 977 static void __devexit p54u_disconnect(struct usb_interface *intf)
 978 {
 979         struct ieee80211_hw *dev = usb_get_intfdata(intf);
 980         struct p54u_priv *priv;
 981
 982         if (!dev)
 983                 return;
 984
 985         ieee80211_unregister_hw(dev);
 986
 987         priv = dev->priv;
 988         usb_put_dev(interface_to_usbdev(intf));
 989         p54_free_common(dev);
 990         ieee80211_free_hw(dev);
 991 }
 992
 993 static int p54u_pre_reset(struct usb_interface *intf)
 994 {
 995         return 0;
 996 }
 997
 998 static int p54u_post_reset(struct usb_interface *intf)
 999 {
1000         return 0;
1001 }
1002
1003 static struct usb_driver p54u_driver = {
1004         .name   = "p54usb",
1005         .id_table = p54u_table,
1006         .probe = p54u_probe,
1007         .disconnect = p54u_disconnect,
1008         .pre_reset = p54u_pre_reset,
1009         .post_reset = p54u_post_reset,
1010 };
1011
1012 static int __init p54u_init(void)
1013 {
1014         return usb_register(&p54u_driver);
1015 }
1016
1017 static void __exit p54u_exit(void)
1018 {
1019         usb_deregister(&p54u_driver);
1020 }
1021
1022 module_init(p54u_init);
1023 module_exit(p54u_exit);