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