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
 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         if (priv->common.fw_interface != FW_LM87) {
 502                 dev_err(&priv->udev->dev, "wrong firmware, "
 503                         "please get a LM87 firmware and try again.\n");
 504                 err = -EINVAL;
 505                 goto err_upload_failed;
 506         }
 507
 508         left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);
 509         strcpy(buf, p54u_firmware_upload_3887);
 510         left -= strlen(p54u_firmware_upload_3887);
 511         tmp += strlen(p54u_firmware_upload_3887);
 512
 513         data = fw_entry->data;
 514         remains = fw_entry->size;
 515
 516         hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
 517         memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
 518         hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
 519         hdr->fw_length = cpu_to_le32(fw_entry->size);
 520         hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
 521                                          sizeof(u32)*2));
 522         left -= sizeof(*hdr);
 523         tmp += sizeof(*hdr);
 524
 525         while (remains) {
 526                 while (left--) {
 527                         if (carry) {
 528                                 *tmp++ = carry;
 529                                 carry = 0;
 530                                 remains--;
 531                                 continue;
 532                         }
 533                         switch (*data) {
 534                         case '~':
 535                                 *tmp++ = '}';
 536                                 carry = '^';
 537                                 break;
 538                         case '}':
 539                                 *tmp++ = '}';
 540                                 carry = ']';
 541                                 break;
 542                         default:
 543                                 *tmp++ = *data;
 544                                 remains--;
 545                                 break;
 546                         }
 547                         data++;
 548                 }
 549
 550                 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
 551                 if (err) {
 552                         dev_err(&priv->udev->dev, "(p54usb) firmware "
 553                                                   "upload failed!\n");
 554                         goto err_upload_failed;
 555                 }
 556
 557                 tmp = buf;
 558                 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
 559         }
 560
 561         *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));
 562         err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
 563         if (err) {
 564                 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
 565                 goto err_upload_failed;
 566         }
 567         timeout = jiffies + msecs_to_jiffies(1000);
 568         while (!(err = usb_bulk_msg(priv->udev,
 569                 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
 570                 if (alen > 2 && !memcmp(buf, "OK", 2))
 571                         break;
 572
 573                 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
 574                         err = -EINVAL;
 575                         break;
 576                 }
 577
 578                 if (time_after(jiffies, timeout)) {
 579                         dev_err(&priv->udev->dev, "(p54usb) firmware boot "
 580                                                   "timed out!\n");
 581                         err = -ETIMEDOUT;
 582                         break;
 583                 }
 584         }
 585         if (err) {
 586                 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
 587                 goto err_upload_failed;
 588         }
 589
 590         buf[0] = 'g';
 591         buf[1] = '\r';
 592         err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
 593         if (err) {
 594                 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
 595                 goto err_upload_failed;
 596         }
 597
 598         timeout = jiffies + msecs_to_jiffies(1000);
 599         while (!(err = usb_bulk_msg(priv->udev,
 600                 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
 601                 if (alen > 0 && buf[0] == 'g')
 602                         break;
 603
 604                 if (time_after(jiffies, timeout)) {
 605                         err = -ETIMEDOUT;
 606                         break;
 607                 }
 608         }
 609         if (err)
 610                 goto err_upload_failed;
 611
 612   err_upload_failed:
 613         release_firmware(fw_entry);
 614   err_req_fw_failed:
 615   err_reset:
 616         kfree(buf);
 617   err_bufalloc:
 618         return err;
 619 }
 620
 621 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
 622 {
 623         struct p54u_priv *priv = dev->priv;
 624         const struct firmware *fw_entry = NULL;
 625         const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
 626         int err, alen;
 627         void *buf;
 628         __le32 reg;
 629         unsigned int remains, offset;
 630         const u8 *data;
 631
 632         buf = kmalloc(512, GFP_KERNEL);
 633         if (!buf) {
 634                 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
 635                                           "alloc failed!\n");
 636                 return -ENOMEM;
 637         }
 638
 639         err = request_firmware(&fw_entry, "isl3886usb", &priv->udev->dev);
 640         if (err) {
 641                 dev_err(&priv->udev->dev, "(p54usb) cannot find firmware "
 642                                           "(isl3886usb)\n");
 643                 err = request_firmware(&fw_entry, "isl3890usb",
 644                         &priv->udev->dev);
 645                 if (err) {
 646                         kfree(buf);
 647                         return err;
 648                         }
 649         }
 650
 651         err = p54_parse_firmware(dev, fw_entry);
 652         if (err) {
 653                 kfree(buf);
 654                 release_firmware(fw_entry);
 655                 return err;
 656         }
 657
 658         if (priv->common.fw_interface != FW_LM86) {
 659                 dev_err(&priv->udev->dev, "wrong firmware, "
 660                         "please get a LM86(USB) firmware and try again.\n");
 661                 kfree(buf);
 662                 release_firmware(fw_entry);
 663                 return -EINVAL;
 664         }
 665
 666 #define P54U_WRITE(type, addr, data) \
 667         do {\
 668                 err = p54u_write(priv, buf, type,\
 669                                  cpu_to_le32((u32)(unsigned long)addr), data);\
 670                 if (err) \
 671                         goto fail;\
 672         } while (0)
 673
 674 #define P54U_READ(type, addr) \
 675         do {\
 676                 err = p54u_read(priv, buf, type,\
 677                                 cpu_to_le32((u32)(unsigned long)addr), &reg);\
 678                 if (err)\
 679                         goto fail;\
 680         } while (0)
 681
 682         /* power down net2280 bridge */
 683         P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
 684         reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
 685         reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
 686         P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
 687
 688         mdelay(100);
 689
 690         /* power up bridge */
 691         reg |= cpu_to_le32(P54U_BRG_POWER_UP);
 692         reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
 693         P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
 694
 695         mdelay(100);
 696
 697         P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
 698                    cpu_to_le32(NET2280_CLK_30Mhz |
 699                                NET2280_PCI_ENABLE |
 700                                NET2280_PCI_SOFT_RESET));
 701
 702         mdelay(20);
 703
 704         P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
 705                    cpu_to_le32(PCI_COMMAND_MEMORY |
 706                                PCI_COMMAND_MASTER));
 707
 708         P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
 709                    cpu_to_le32(NET2280_BASE));
 710
 711         P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
 712         reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
 713         P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
 714
 715         // TODO: we really need this?
 716         P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
 717
 718         P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
 719                    cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
 720         P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
 721                    cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
 722
 723         P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
 724                    cpu_to_le32(NET2280_BASE2));
 725
 726         /* finally done setting up the bridge */
 727
 728         P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
 729                    cpu_to_le32(PCI_COMMAND_MEMORY |
 730                                PCI_COMMAND_MASTER));
 731
 732         P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
 733         P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
 734                    cpu_to_le32(P54U_DEV_BASE));
 735
 736         P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
 737         P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
 738                    cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
 739
 740         /* do romboot */
 741         P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
 742
 743         P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
 744         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
 745         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
 746         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
 747         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 748
 749         mdelay(20);
 750
 751         reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
 752         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 753
 754         mdelay(20);
 755
 756         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
 757         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 758
 759         mdelay(100);
 760
 761         P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
 762         P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
 763
 764         /* finally, we can upload firmware now! */
 765         remains = fw_entry->size;
 766         data = fw_entry->data;
 767         offset = ISL38XX_DEV_FIRMWARE_ADDR;
 768
 769         while (remains) {
 770                 unsigned int block_len = min(remains, (unsigned int)512);
 771                 memcpy(buf, data, block_len);
 772
 773                 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
 774                 if (err) {
 775                         dev_err(&priv->udev->dev, "(p54usb) firmware block "
 776                                                   "upload failed\n");
 777                         goto fail;
 778                 }
 779
 780                 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
 781                            cpu_to_le32(0xc0000f00));
 782
 783                 P54U_WRITE(NET2280_DEV_U32,
 784                            0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
 785                 P54U_WRITE(NET2280_DEV_U32,
 786                            0x0020 | (unsigned long)&devreg->direct_mem_win,
 787                            cpu_to_le32(1));
 788
 789                 P54U_WRITE(NET2280_DEV_U32,
 790                            0x0024 | (unsigned long)&devreg->direct_mem_win,
 791                            cpu_to_le32(block_len));
 792                 P54U_WRITE(NET2280_DEV_U32,
 793                            0x0028 | (unsigned long)&devreg->direct_mem_win,
 794                            cpu_to_le32(offset));
 795
 796                 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
 797                            cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
 798                 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
 799                            cpu_to_le32(block_len >> 2));
 800                 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
 801                            cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
 802
 803                 mdelay(10);
 804
 805                 P54U_READ(NET2280_DEV_U32,
 806                           0x002C | (unsigned long)&devreg->direct_mem_win);
 807                 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
 808                     !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
 809                         dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
 810                                                   "transfer failed\n");
 811                         goto fail;
 812                 }
 813
 814                 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
 815                            cpu_to_le32(NET2280_FIFO_FLUSH));
 816
 817                 remains -= block_len;
 818                 data += block_len;
 819                 offset += block_len;
 820         }
 821
 822         /* do ramboot */
 823         P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
 824         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
 825         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
 826         reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
 827         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 828
 829         mdelay(20);
 830
 831         reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
 832         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 833
 834         reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
 835         P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
 836
 837         mdelay(100);
 838
 839         P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
 840         P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
 841
 842         /* start up the firmware */
 843         P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
 844                    cpu_to_le32(ISL38XX_INT_IDENT_INIT));
 845
 846         P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
 847                    cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
 848
 849         P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
 850                    cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
 851                                NET2280_USB_INTERRUPT_ENABLE));
 852
 853         P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
 854                    cpu_to_le32(ISL38XX_DEV_INT_RESET));
 855
 856         err = usb_interrupt_msg(priv->udev,
 857                                 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
 858                                 buf, sizeof(__le32), &alen, 1000);
 859         if (err || alen != sizeof(__le32))
 860                 goto fail;
 861
 862         P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
 863         P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
 864
 865         if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
 866                 err = -EINVAL;
 867
 868         P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
 869         P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
 870                    cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
 871
 872 #undef P54U_WRITE
 873 #undef P54U_READ
 874
 875  fail:
 876         release_firmware(fw_entry);
 877         kfree(buf);
 878         return err;
 879 }
 880
 881 static int p54u_open(struct ieee80211_hw *dev)
 882 {
 883         struct p54u_priv *priv = dev->priv;
 884         int err;
 885
 886         err = p54u_init_urbs(dev);
 887         if (err) {
 888                 return err;
 889         }
 890
 891         priv->common.open = p54u_init_urbs;
 892
 893         return 0;
 894 }
 895
 896 static void p54u_stop(struct ieee80211_hw *dev)
 897 {
 898         /* TODO: figure out how to reliably stop the 3887 and net2280 so
 899            the hardware is still usable next time we want to start it.
 900            until then, we just stop listening to the hardware.. */
 901         p54u_free_urbs(dev);
 902         return;
 903 }
 904
 905 static int __devinit p54u_probe(struct usb_interface *intf,
 906                                 const struct usb_device_id *id)
 907 {
 908         struct usb_device *udev = interface_to_usbdev(intf);
 909         struct ieee80211_hw *dev;
 910         struct p54u_priv *priv;
 911         int err;
 912         unsigned int i, recognized_pipes;
 913
 914         dev = p54_init_common(sizeof(*priv));
 915
 916         if (!dev) {
 917                 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
 918                 return -ENOMEM;
 919         }
 920
 921         priv = dev->priv;
 922
 923         SET_IEEE80211_DEV(dev, &intf->dev);
 924         usb_set_intfdata(intf, dev);
 925         priv->udev = udev;
 926         priv->intf = intf;
 927         skb_queue_head_init(&priv->rx_queue);
 928         init_usb_anchor(&priv->submitted);
 929
 930         usb_get_dev(udev);
 931
 932         /* really lazy and simple way of figuring out if we're a 3887 */
 933         /* TODO: should just stick the identification in the device table */
 934         i = intf->altsetting->desc.bNumEndpoints;
 935         recognized_pipes = 0;
 936         while (i--) {
 937                 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
 938                 case P54U_PIPE_DATA:
 939                 case P54U_PIPE_MGMT:
 940                 case P54U_PIPE_BRG:
 941                 case P54U_PIPE_DEV:
 942                 case P54U_PIPE_DATA | USB_DIR_IN:
 943                 case P54U_PIPE_MGMT | USB_DIR_IN:
 944                 case P54U_PIPE_BRG | USB_DIR_IN:
 945                 case P54U_PIPE_DEV | USB_DIR_IN:
 946                 case P54U_PIPE_INT | USB_DIR_IN:
 947                         recognized_pipes++;
 948                 }
 949         }
 950         priv->common.open = p54u_open;
 951         priv->common.stop = p54u_stop;
 952         if (recognized_pipes < P54U_PIPE_NUMBER) {
 953                 priv->hw_type = P54U_3887;
 954                 err = p54u_upload_firmware_3887(dev);
 955                 if (priv->common.fw_interface == FW_LM87) {
 956                         dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
 957                         priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
 958                         priv->common.tx = p54u_tx_lm87;
 959                 } else
 960                         priv->common.tx = p54u_tx_3887;
 961         } else {
 962                 priv->hw_type = P54U_NET2280;
 963                 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
 964                 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
 965                 priv->common.tx = p54u_tx_net2280;
 966                 err = p54u_upload_firmware_net2280(dev);
 967         }
 968         if (err)
 969                 goto err_free_dev;
 970
 971         p54u_open(dev);
 972         err = p54_read_eeprom(dev);
 973         p54u_stop(dev);
 974         if (err)
 975                 goto err_free_dev;
 976
 977         err = ieee80211_register_hw(dev);
 978         if (err) {
 979                 dev_err(&udev->dev, "(p54usb) Cannot register netdevice\n");
 980                 goto err_free_dev;
 981         }
 982
 983         return 0;
 984
 985  err_free_dev:
 986         ieee80211_free_hw(dev);
 987         usb_set_intfdata(intf, NULL);
 988         usb_put_dev(udev);
 989         return err;
 990 }
 991
 992 static void __devexit p54u_disconnect(struct usb_interface *intf)
 993 {
 994         struct ieee80211_hw *dev = usb_get_intfdata(intf);
 995         struct p54u_priv *priv;
 996
 997         if (!dev)
 998                 return;
 999
1000         ieee80211_unregister_hw(dev);
1001
1002         priv = dev->priv;
1003         usb_put_dev(interface_to_usbdev(intf));
1004         p54_free_common(dev);
1005         ieee80211_free_hw(dev);
1006 }
1007
1008 static int p54u_pre_reset(struct usb_interface *intf)
1009 {
1010         return 0;
1011 }
1012
1013 static int p54u_post_reset(struct usb_interface *intf)
1014 {
1015         return 0;
1016 }
1017
1018 static struct usb_driver p54u_driver = {
1019         .name   = "p54usb",
1020         .id_table = p54u_table,
1021         .probe = p54u_probe,
1022         .disconnect = p54u_disconnect,
1023         .pre_reset = p54u_pre_reset,
1024         .post_reset = p54u_post_reset,
1025 };
1026
1027 static int __init p54u_init(void)
1028 {
1029         return usb_register(&p54u_driver);
1030 }
1031
1032 static void __exit p54u_exit(void)
1033 {
1034         usb_deregister(&p54u_driver);
1035 }
1036
1037 module_init(p54u_init);
1038 module_exit(p54u_exit);