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