drivers/net/wireless/ar9170/usb.c

   1 /*
   2  * Atheros AR9170 driver
   3  *
   4  * USB - frontend
   5  *
   6  * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
   7  * Copyright 2009, Christian Lamparter <chunkeey@web.de>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; see the file COPYING.  If not, see
  21  * http://www.gnu.org/licenses/.
  22  *
  23  * This file incorporates work covered by the following copyright and
  24  * permission notice:
  25  *    Copyright (c) 2007-2008 Atheros Communications, Inc.
  26  *
  27  *    Permission to use, copy, modify, and/or distribute this software for any
  28  *    purpose with or without fee is hereby granted, provided that the above
  29  *    copyright notice and this permission notice appear in all copies.
  30  *
  31  *    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  32  *    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  33  *    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  34  *    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  35  *    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  36  *    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  37  *    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  38  */
  39
  40 #include <linux/module.h>
  41 #include <linux/usb.h>
  42 #include <linux/firmware.h>
  43 #include <linux/etherdevice.h>
  44 #include <net/mac80211.h>
  45 #include "ar9170.h"
  46 #include "cmd.h"
  47 #include "hw.h"
  48 #include "usb.h"
  49
  50 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
  51 MODULE_AUTHOR("Christian Lamparter <chunkeey@web.de>");
  52 MODULE_LICENSE("GPL");
  53 MODULE_DESCRIPTION("Atheros AR9170 802.11n USB wireless");
  54 MODULE_FIRMWARE("ar9170-1.fw");
  55 MODULE_FIRMWARE("ar9170-2.fw");
  56
  57 static struct usb_device_id ar9170_usb_ids[] = {
  58         /* Atheros 9170 */
  59         { USB_DEVICE(0x0cf3, 0x9170) },
  60         /* Atheros TG121N */
  61         { USB_DEVICE(0x0cf3, 0x1001) },
  62         /* Cace Airpcap NX */
  63         { USB_DEVICE(0xcace, 0x0300) },
  64         /* D-Link DWA 160A */
  65         { USB_DEVICE(0x07d1, 0x3c10) },
  66         /* Netgear WNDA3100 */
  67         { USB_DEVICE(0x0846, 0x9010) },
  68         /* Netgear WN111 v2 */
  69         { USB_DEVICE(0x0846, 0x9001) },
  70         /* Zydas ZD1221 */
  71         { USB_DEVICE(0x0ace, 0x1221) },
  72         /* Z-Com UB81 BG */
  73         { USB_DEVICE(0x0cde, 0x0023) },
  74         /* Z-Com UB82 ABG */
  75         { USB_DEVICE(0x0cde, 0x0026) },
  76         /* Arcadyan WN7512 */
  77         { USB_DEVICE(0x083a, 0xf522) },
  78         /* Planex GWUS300 */
  79         { USB_DEVICE(0x2019, 0x5304) },
  80         /* IO-Data WNGDNUS2 */
  81         { USB_DEVICE(0x04bb, 0x093f) },
  82
  83         /* terminate */
  84         {}
  85 };
  86 MODULE_DEVICE_TABLE(usb, ar9170_usb_ids);
  87
  88 static void ar9170_usb_tx_urb_complete_free(struct urb *urb)
  89 {
  90         struct sk_buff *skb = urb->context;
  91         struct ar9170_usb *aru = (struct ar9170_usb *)
  92               usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
  93
  94         if (!aru) {
  95                 dev_kfree_skb_irq(skb);
  96                 return ;
  97         }
  98
  99         ar9170_handle_tx_status(&aru->common, skb, false,
 100                                 AR9170_TX_STATUS_COMPLETE);
 101 }
 102
 103 static void ar9170_usb_tx_urb_complete(struct urb *urb)
 104 {
 105 }
 106
 107 static void ar9170_usb_irq_completed(struct urb *urb)
 108 {
 109         struct ar9170_usb *aru = urb->context;
 110
 111         switch (urb->status) {
 112         /* everything is fine */
 113         case 0:
 114                 break;
 115
 116         /* disconnect */
 117         case -ENOENT:
 118         case -ECONNRESET:
 119         case -ENODEV:
 120         case -ESHUTDOWN:
 121                 goto free;
 122
 123         default:
 124                 goto resubmit;
 125         }
 126
 127         print_hex_dump_bytes("ar9170 irq: ", DUMP_PREFIX_OFFSET,
 128                              urb->transfer_buffer, urb->actual_length);
 129
 130 resubmit:
 131         usb_anchor_urb(urb, &aru->rx_submitted);
 132         if (usb_submit_urb(urb, GFP_ATOMIC)) {
 133                 usb_unanchor_urb(urb);
 134                 goto free;
 135         }
 136
 137         return;
 138
 139 free:
 140         usb_buffer_free(aru->udev, 64, urb->transfer_buffer, urb->transfer_dma);
 141 }
 142
 143 static void ar9170_usb_rx_completed(struct urb *urb)
 144 {
 145         struct sk_buff *skb = urb->context;
 146         struct ar9170_usb *aru = (struct ar9170_usb *)
 147                 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
 148         int err;
 149
 150         if (!aru)
 151                 goto free;
 152
 153         switch (urb->status) {
 154         /* everything is fine */
 155         case 0:
 156                 break;
 157
 158         /* disconnect */
 159         case -ENOENT:
 160         case -ECONNRESET:
 161         case -ENODEV:
 162         case -ESHUTDOWN:
 163                 goto free;
 164
 165         default:
 166                 goto resubmit;
 167         }
 168
 169         skb_put(skb, urb->actual_length);
 170         ar9170_rx(&aru->common, skb);
 171
 172 resubmit:
 173         skb_reset_tail_pointer(skb);
 174         skb_trim(skb, 0);
 175
 176         usb_anchor_urb(urb, &aru->rx_submitted);
 177         err = usb_submit_urb(urb, GFP_ATOMIC);
 178         if (err) {
 179                 usb_unanchor_urb(urb);
 180                 dev_kfree_skb_irq(skb);
 181         }
 182
 183         return ;
 184
 185 free:
 186         dev_kfree_skb_irq(skb);
 187         return;
 188 }
 189
 190 static int ar9170_usb_prep_rx_urb(struct ar9170_usb *aru,
 191                                   struct urb *urb, gfp_t gfp)
 192 {
 193         struct sk_buff *skb;
 194
 195         skb = __dev_alloc_skb(AR9170_MAX_RX_BUFFER_SIZE + 32, gfp);
 196         if (!skb)
 197                 return -ENOMEM;
 198
 199         /* reserve some space for mac80211's radiotap */
 200         skb_reserve(skb, 32);
 201
 202         usb_fill_bulk_urb(urb, aru->udev,
 203                           usb_rcvbulkpipe(aru->udev, AR9170_EP_RX),
 204                           skb->data, min(skb_tailroom(skb),
 205                           AR9170_MAX_RX_BUFFER_SIZE),
 206                           ar9170_usb_rx_completed, skb);
 207
 208         return 0;
 209 }
 210
 211 static int ar9170_usb_alloc_rx_irq_urb(struct ar9170_usb *aru)
 212 {
 213         struct urb *urb = NULL;
 214         void *ibuf;
 215         int err = -ENOMEM;
 216
 217         /* initialize interrupt endpoint */
 218         urb = usb_alloc_urb(0, GFP_KERNEL);
 219         if (!urb)
 220                 goto out;
 221
 222         ibuf = usb_buffer_alloc(aru->udev, 64, GFP_KERNEL, &urb->transfer_dma);
 223         if (!ibuf)
 224                 goto out;
 225
 226         usb_fill_int_urb(urb, aru->udev,
 227                          usb_rcvintpipe(aru->udev, AR9170_EP_IRQ), ibuf,
 228                          64, ar9170_usb_irq_completed, aru, 1);
 229         urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
 230
 231         usb_anchor_urb(urb, &aru->rx_submitted);
 232         err = usb_submit_urb(urb, GFP_KERNEL);
 233         if (err) {
 234                 usb_unanchor_urb(urb);
 235                 usb_buffer_free(aru->udev, 64, urb->transfer_buffer,
 236                                 urb->transfer_dma);
 237         }
 238
 239 out:
 240         usb_free_urb(urb);
 241         return err;
 242 }
 243
 244 static int ar9170_usb_alloc_rx_bulk_urbs(struct ar9170_usb *aru)
 245 {
 246         struct urb *urb;
 247         int i;
 248         int err = -EINVAL;
 249
 250         for (i = 0; i < AR9170_NUM_RX_URBS; i++) {
 251                 err = -ENOMEM;
 252                 urb = usb_alloc_urb(0, GFP_KERNEL);
 253                 if (!urb)
 254                         goto err_out;
 255
 256                 err = ar9170_usb_prep_rx_urb(aru, urb, GFP_KERNEL);
 257                 if (err) {
 258                         usb_free_urb(urb);
 259                         goto err_out;
 260                 }
 261
 262                 usb_anchor_urb(urb, &aru->rx_submitted);
 263                 err = usb_submit_urb(urb, GFP_KERNEL);
 264                 if (err) {
 265                         usb_unanchor_urb(urb);
 266                         dev_kfree_skb_any((void *) urb->transfer_buffer);
 267                         usb_free_urb(urb);
 268                         goto err_out;
 269                 }
 270                 usb_free_urb(urb);
 271         }
 272
 273         /* the device now waiting for a firmware. */
 274         aru->common.state = AR9170_IDLE;
 275         return 0;
 276
 277 err_out:
 278
 279         usb_kill_anchored_urbs(&aru->rx_submitted);
 280         return err;
 281 }
 282
 283 static void ar9170_usb_cancel_urbs(struct ar9170_usb *aru)
 284 {
 285         int ret;
 286
 287         aru->common.state = AR9170_UNKNOWN_STATE;
 288
 289         usb_unlink_anchored_urbs(&aru->tx_submitted);
 290
 291         /* give the LED OFF command and the deauth frame a chance to air. */
 292         ret = usb_wait_anchor_empty_timeout(&aru->tx_submitted,
 293                                             msecs_to_jiffies(100));
 294         if (ret == 0)
 295                 dev_err(&aru->udev->dev, "kill pending tx urbs.\n");
 296         usb_poison_anchored_urbs(&aru->tx_submitted);
 297
 298         usb_poison_anchored_urbs(&aru->rx_submitted);
 299 }
 300
 301 static int ar9170_usb_exec_cmd(struct ar9170 *ar, enum ar9170_cmd cmd,
 302                                unsigned int plen, void *payload,
 303                                unsigned int outlen, void *out)
 304 {
 305         struct ar9170_usb *aru = (void *) ar;
 306         struct urb *urb = NULL;
 307         unsigned long flags;
 308         int err = -ENOMEM;
 309
 310         if (unlikely(!IS_ACCEPTING_CMD(ar)))
 311                 return -EPERM;
 312
 313         if (WARN_ON(plen > AR9170_MAX_CMD_LEN - 4))
 314                 return -EINVAL;
 315
 316         urb = usb_alloc_urb(0, GFP_ATOMIC);
 317         if (unlikely(!urb))
 318                 goto err_free;
 319
 320         ar->cmdbuf[0] = cpu_to_le32(plen);
 321         ar->cmdbuf[0] |= cpu_to_le32(cmd << 8);
 322         /* writing multiple regs fills this buffer already */
 323         if (plen && payload != (u8 *)(&ar->cmdbuf[1]))
 324                 memcpy(&ar->cmdbuf[1], payload, plen);
 325
 326         spin_lock_irqsave(&aru->common.cmdlock, flags);
 327         aru->readbuf = (u8 *)out;
 328         aru->readlen = outlen;
 329         spin_unlock_irqrestore(&aru->common.cmdlock, flags);
 330
 331         usb_fill_int_urb(urb, aru->udev,
 332                          usb_sndbulkpipe(aru->udev, AR9170_EP_CMD),
 333                          aru->common.cmdbuf, plen + 4,
 334                          ar9170_usb_tx_urb_complete, NULL, 1);
 335
 336         usb_anchor_urb(urb, &aru->tx_submitted);
 337         err = usb_submit_urb(urb, GFP_ATOMIC);
 338         if (err) {
 339                 usb_unanchor_urb(urb);
 340                 usb_free_urb(urb);
 341                 goto err_unbuf;
 342         }
 343         usb_free_urb(urb);
 344
 345         err = wait_for_completion_timeout(&aru->cmd_wait, HZ);
 346         if (err == 0) {
 347                 err = -ETIMEDOUT;
 348                 goto err_unbuf;
 349         }
 350
 351         if (outlen >= 0 && aru->readlen != outlen) {
 352                 err = -EMSGSIZE;
 353                 goto err_unbuf;
 354         }
 355
 356         return 0;
 357
 358 err_unbuf:
 359         /* Maybe the device was removed in the second we were waiting? */
 360         if (IS_STARTED(ar)) {
 361                 dev_err(&aru->udev->dev, "no command feedback "
 362                                          "received (%d).\n", err);
 363
 364                 /* provide some maybe useful debug information */
 365                 print_hex_dump_bytes("ar9170 cmd: ", DUMP_PREFIX_NONE,
 366                                      aru->common.cmdbuf, plen + 4);
 367                 dump_stack();
 368         }
 369
 370         /* invalidate to avoid completing the next prematurely */
 371         spin_lock_irqsave(&aru->common.cmdlock, flags);
 372         aru->readbuf = NULL;
 373         aru->readlen = 0;
 374         spin_unlock_irqrestore(&aru->common.cmdlock, flags);
 375
 376 err_free:
 377
 378         return err;
 379 }
 380
 381 static int ar9170_usb_tx(struct ar9170 *ar, struct sk_buff *skb,
 382                          bool txstatus_needed, unsigned int extra_len)
 383 {
 384         struct ar9170_usb *aru = (struct ar9170_usb *) ar;
 385         struct urb *urb;
 386         int err;
 387
 388         if (unlikely(!IS_STARTED(ar))) {
 389                 /* Seriously, what were you drink... err... thinking!? */
 390                 return -EPERM;
 391         }
 392
 393         urb = usb_alloc_urb(0, GFP_ATOMIC);
 394         if (unlikely(!urb))
 395                 return -ENOMEM;
 396
 397         usb_fill_bulk_urb(urb, aru->udev,
 398                           usb_sndbulkpipe(aru->udev, AR9170_EP_TX),
 399                           skb->data, skb->len + extra_len, (txstatus_needed ?
 400                           ar9170_usb_tx_urb_complete :
 401                           ar9170_usb_tx_urb_complete_free), skb);
 402         urb->transfer_flags |= URB_ZERO_PACKET;
 403
 404         usb_anchor_urb(urb, &aru->tx_submitted);
 405         err = usb_submit_urb(urb, GFP_ATOMIC);
 406         if (unlikely(err))
 407                 usb_unanchor_urb(urb);
 408
 409         usb_free_urb(urb);
 410         return err;
 411 }
 412
 413 static void ar9170_usb_callback_cmd(struct ar9170 *ar, u32 len , void *buffer)
 414 {
 415         struct ar9170_usb *aru = (void *) ar;
 416         unsigned long flags;
 417         u32 in, out;
 418
 419         if (!buffer)
 420                 return ;
 421
 422         in = le32_to_cpup((__le32 *)buffer);
 423         out = le32_to_cpu(ar->cmdbuf[0]);
 424
 425         /* mask off length byte */
 426         out &= ~0xFF;
 427
 428         if (aru->readlen >= 0) {
 429                 /* add expected length */
 430                 out |= aru->readlen;
 431         } else {
 432                 /* add obtained length */
 433                 out |= in & 0xFF;
 434         }
 435
 436         /*
 437          * Some commands (e.g: AR9170_CMD_FREQUENCY) have a variable response
 438          * length and we cannot predict the correct length in advance.
 439          * So we only check if we provided enough space for the data.
 440          */
 441         if (unlikely(out < in)) {
 442                 dev_warn(&aru->udev->dev, "received invalid command response "
 443                                           "got %d bytes, instead of %d bytes "
 444                                           "and the resp length is %d bytes\n",
 445                          in, out, len);
 446                 print_hex_dump_bytes("ar9170 invalid resp: ",
 447                                      DUMP_PREFIX_OFFSET, buffer, len);
 448                 /*
 449                  * Do not complete, then the command times out,
 450                  * and we get a stack trace from there.
 451                  */
 452                 return ;
 453         }
 454
 455         spin_lock_irqsave(&aru->common.cmdlock, flags);
 456         if (aru->readbuf && len > 0) {
 457                 memcpy(aru->readbuf, buffer + 4, len - 4);
 458                 aru->readbuf = NULL;
 459         }
 460         complete(&aru->cmd_wait);
 461         spin_unlock_irqrestore(&aru->common.cmdlock, flags);
 462 }
 463
 464 static int ar9170_usb_upload(struct ar9170_usb *aru, const void *data,
 465                              size_t len, u32 addr, bool complete)
 466 {
 467         int transfer, err;
 468         u8 *buf = kmalloc(4096, GFP_KERNEL);
 469
 470         if (!buf)
 471                 return -ENOMEM;
 472
 473         while (len) {
 474                 transfer = min_t(int, len, 4096);
 475                 memcpy(buf, data, transfer);
 476
 477                 err = usb_control_msg(aru->udev, usb_sndctrlpipe(aru->udev, 0),
 478                                       0x30 /* FW DL */, 0x40 | USB_DIR_OUT,
 479                                       addr >> 8, 0, buf, transfer, 1000);
 480
 481                 if (err < 0) {
 482                         kfree(buf);
 483                         return err;
 484                 }
 485
 486                 len -= transfer;
 487                 data += transfer;
 488                 addr += transfer;
 489         }
 490         kfree(buf);
 491
 492         if (complete) {
 493                 err = usb_control_msg(aru->udev, usb_sndctrlpipe(aru->udev, 0),
 494                                       0x31 /* FW DL COMPLETE */,
 495                                       0x40 | USB_DIR_OUT, 0, 0, NULL, 0, 5000);
 496         }
 497
 498         return 0;
 499 }
 500
 501 static int ar9170_usb_request_firmware(struct ar9170_usb *aru)
 502 {
 503         int err = 0;
 504
 505         err = request_firmware(&aru->init_values, "ar9170-1.fw",
 506                                &aru->udev->dev);
 507         if (err) {
 508                 dev_err(&aru->udev->dev, "file with init values not found.\n");
 509                 return err;
 510         }
 511
 512         err = request_firmware(&aru->firmware, "ar9170-2.fw", &aru->udev->dev);
 513         if (err) {
 514                 release_firmware(aru->init_values);
 515                 dev_err(&aru->udev->dev, "firmware file not found.\n");
 516                 return err;
 517         }
 518
 519         return err;
 520 }
 521
 522 static int ar9170_usb_reset(struct ar9170_usb *aru)
 523 {
 524         int ret, lock = (aru->intf->condition != USB_INTERFACE_BINDING);
 525
 526         if (lock) {
 527                 ret = usb_lock_device_for_reset(aru->udev, aru->intf);
 528                 if (ret < 0) {
 529                         dev_err(&aru->udev->dev, "unable to lock device "
 530                                 "for reset (%d).\n", ret);
 531                         return ret;
 532                 }
 533         }
 534
 535         ret = usb_reset_device(aru->udev);
 536         if (lock)
 537                 usb_unlock_device(aru->udev);
 538
 539         /* let it rest - for a second - */
 540         msleep(1000);
 541
 542         return ret;
 543 }
 544
 545 static int ar9170_usb_upload_firmware(struct ar9170_usb *aru)
 546 {
 547         int err;
 548
 549         /* First, upload initial values to device RAM */
 550         err = ar9170_usb_upload(aru, aru->init_values->data,
 551                                 aru->init_values->size, 0x102800, false);
 552         if (err) {
 553                 dev_err(&aru->udev->dev, "firmware part 1 "
 554                         "upload failed (%d).\n", err);
 555                 return err;
 556         }
 557
 558         /* Then, upload the firmware itself and start it */
 559         return ar9170_usb_upload(aru, aru->firmware->data, aru->firmware->size,
 560                                 0x200000, true);
 561 }
 562
 563 static int ar9170_usb_init_transport(struct ar9170_usb *aru)
 564 {
 565         struct ar9170 *ar = (void *) &aru->common;
 566         int err;
 567
 568         ar9170_regwrite_begin(ar);
 569
 570         /* Set USB Rx stream mode MAX packet number to 2 */
 571         ar9170_regwrite(AR9170_USB_REG_MAX_AGG_UPLOAD, 0x4);
 572
 573         /* Set USB Rx stream mode timeout to 10us */
 574         ar9170_regwrite(AR9170_USB_REG_UPLOAD_TIME_CTL, 0x80);
 575
 576         ar9170_regwrite_finish();
 577
 578         err = ar9170_regwrite_result();
 579         if (err)
 580                 dev_err(&aru->udev->dev, "USB setup failed (%d).\n", err);
 581
 582         return err;
 583 }
 584
 585 static void ar9170_usb_stop(struct ar9170 *ar)
 586 {
 587         struct ar9170_usb *aru = (void *) ar;
 588         int ret;
 589
 590         if (IS_ACCEPTING_CMD(ar))
 591                 aru->common.state = AR9170_STOPPED;
 592
 593         /* lets wait a while until the tx - queues are dried out */
 594         ret = usb_wait_anchor_empty_timeout(&aru->tx_submitted,
 595                                             msecs_to_jiffies(1000));
 596         if (ret == 0)
 597                 dev_err(&aru->udev->dev, "kill pending tx urbs.\n");
 598
 599         usb_poison_anchored_urbs(&aru->tx_submitted);
 600
 601         /*
 602          * Note:
 603          * So far we freed all tx urbs, but we won't dare to touch any rx urbs.
 604          * Else we would end up with a unresponsive device...
 605          */
 606 }
 607
 608 static int ar9170_usb_open(struct ar9170 *ar)
 609 {
 610         struct ar9170_usb *aru = (void *) ar;
 611         int err;
 612
 613         usb_unpoison_anchored_urbs(&aru->tx_submitted);
 614         err = ar9170_usb_init_transport(aru);
 615         if (err) {
 616                 usb_poison_anchored_urbs(&aru->tx_submitted);
 617                 return err;
 618         }
 619
 620         aru->common.state = AR9170_IDLE;
 621         return 0;
 622 }
 623
 624 static int ar9170_usb_probe(struct usb_interface *intf,
 625                         const struct usb_device_id *id)
 626 {
 627         struct ar9170_usb *aru;
 628         struct ar9170 *ar;
 629         struct usb_device *udev;
 630         int err;
 631
 632         aru = ar9170_alloc(sizeof(*aru));
 633         if (IS_ERR(aru)) {
 634                 err = PTR_ERR(aru);
 635                 goto out;
 636         }
 637
 638         udev = interface_to_usbdev(intf);
 639         usb_get_dev(udev);
 640         aru->udev = udev;
 641         aru->intf = intf;
 642         ar = &aru->common;
 643
 644         usb_set_intfdata(intf, aru);
 645         SET_IEEE80211_DEV(ar->hw, &udev->dev);
 646
 647         init_usb_anchor(&aru->rx_submitted);
 648         init_usb_anchor(&aru->tx_submitted);
 649         init_completion(&aru->cmd_wait);
 650
 651         aru->common.stop = ar9170_usb_stop;
 652         aru->common.open = ar9170_usb_open;
 653         aru->common.tx = ar9170_usb_tx;
 654         aru->common.exec_cmd = ar9170_usb_exec_cmd;
 655         aru->common.callback_cmd = ar9170_usb_callback_cmd;
 656
 657         err = ar9170_usb_reset(aru);
 658         if (err)
 659                 goto err_unlock;
 660
 661         err = ar9170_usb_request_firmware(aru);
 662         if (err)
 663                 goto err_unlock;
 664
 665         err = ar9170_usb_alloc_rx_irq_urb(aru);
 666         if (err)
 667                 goto err_freefw;
 668
 669         err = ar9170_usb_alloc_rx_bulk_urbs(aru);
 670         if (err)
 671                 goto err_unrx;
 672
 673         err = ar9170_usb_upload_firmware(aru);
 674         if (err) {
 675                 err = ar9170_echo_test(&aru->common, 0x60d43110);
 676                 if (err) {
 677                         /* force user invention, by disabling the device */
 678                         err = usb_driver_set_configuration(aru->udev, -1);
 679                         dev_err(&aru->udev->dev, "device is in a bad state. "
 680                                                  "please reconnect it!\n");
 681                         goto err_unrx;
 682                 }
 683         }
 684
 685         err = ar9170_usb_open(ar);
 686         if (err)
 687                 goto err_unrx;
 688
 689         err = ar9170_register(ar, &udev->dev);
 690
 691         ar9170_usb_stop(ar);
 692         if (err)
 693                 goto err_unrx;
 694
 695         return 0;
 696
 697 err_unrx:
 698         ar9170_usb_cancel_urbs(aru);
 699
 700 err_freefw:
 701         release_firmware(aru->init_values);
 702         release_firmware(aru->firmware);
 703
 704 err_unlock:
 705         usb_set_intfdata(intf, NULL);
 706         usb_put_dev(udev);
 707         ieee80211_free_hw(ar->hw);
 708 out:
 709         return err;
 710 }
 711
 712 static void ar9170_usb_disconnect(struct usb_interface *intf)
 713 {
 714         struct ar9170_usb *aru = usb_get_intfdata(intf);
 715
 716         if (!aru)
 717                 return;
 718
 719         aru->common.state = AR9170_IDLE;
 720         ar9170_unregister(&aru->common);
 721         ar9170_usb_cancel_urbs(aru);
 722
 723         release_firmware(aru->init_values);
 724         release_firmware(aru->firmware);
 725
 726         usb_put_dev(aru->udev);
 727         usb_set_intfdata(intf, NULL);
 728         ieee80211_free_hw(aru->common.hw);
 729 }
 730
 731 static struct usb_driver ar9170_driver = {
 732         .name = "ar9170usb",
 733         .probe = ar9170_usb_probe,
 734         .disconnect = ar9170_usb_disconnect,
 735         .id_table = ar9170_usb_ids,
 736         .soft_unbind = 1,
 737 };
 738
 739 static int __init ar9170_init(void)
 740 {
 741         return usb_register(&ar9170_driver);
 742 }
 743
 744 static void __exit ar9170_exit(void)
 745 {
 746         usb_deregister(&ar9170_driver);
 747 }
 748
 749 module_init(ar9170_init);
 750 module_exit(ar9170_exit);