git.oblomov.eu Git - linux-2.6/blob - drivers/net/wireless/rt2x00/rt2x00usb.c

   1 /*
   2         Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
   3         <http://rt2x00.serialmonkey.com>
   4
   5         This program is free software; you can redistribute it and/or modify
   6         it under the terms of the GNU General Public License as published by
   7         the Free Software Foundation; either version 2 of the License, or
   8         (at your option) any later version.
   9
  10         This program is distributed in the hope that it will be useful,
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13         GNU General Public License for more details.
  14
  15         You should have received a copy of the GNU General Public License
  16         along with this program; if not, write to the
  17         Free Software Foundation, Inc.,
  18         59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  */
  20
  21 /*
  22         Module: rt2x00usb
  23         Abstract: rt2x00 generic usb device routines.
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28 #include <linux/usb.h>
  29 #include <linux/bug.h>
  30
  31 #include "rt2x00.h"
  32 #include "rt2x00usb.h"
  33
  34 /*
  35  * Interfacing with the HW.
  36  */
  37 int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev,
  38                              const u8 request, const u8 requesttype,
  39                              const u16 offset, const u16 value,
  40                              void *buffer, const u16 buffer_length,
  41                              const int timeout)
  42 {
  43         struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
  44         int status;
  45         unsigned int i;
  46         unsigned int pipe =
  47             (requesttype == USB_VENDOR_REQUEST_IN) ?
  48             usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0);
  49
  50
  51         for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
  52                 status = usb_control_msg(usb_dev, pipe, request, requesttype,
  53                                          value, offset, buffer, buffer_length,
  54                                          timeout);
  55                 if (status >= 0)
  56                         return 0;
  57
  58                 /*
  59                  * Check for errors
  60                  * -ENODEV: Device has disappeared, no point continuing.
  61                  * All other errors: Try again.
  62                  */
  63                 else if (status == -ENODEV)
  64                         break;
  65         }
  66
  67         ERROR(rt2x00dev,
  68               "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n",
  69               request, offset, status);
  70
  71         return status;
  72 }
  73 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request);
  74
  75 int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev *rt2x00dev,
  76                                    const u8 request, const u8 requesttype,
  77                                    const u16 offset, void *buffer,
  78                                    const u16 buffer_length, const int timeout)
  79 {
  80         int status;
  81
  82         BUG_ON(!mutex_is_locked(&rt2x00dev->csr_mutex));
  83
  84         /*
  85          * Check for Cache availability.
  86          */
  87         if (unlikely(!rt2x00dev->csr.cache || buffer_length > CSR_CACHE_SIZE)) {
  88                 ERROR(rt2x00dev, "CSR cache not available.\n");
  89                 return -ENOMEM;
  90         }
  91
  92         if (requesttype == USB_VENDOR_REQUEST_OUT)
  93                 memcpy(rt2x00dev->csr.cache, buffer, buffer_length);
  94
  95         status = rt2x00usb_vendor_request(rt2x00dev, request, requesttype,
  96                                           offset, 0, rt2x00dev->csr.cache,
  97                                           buffer_length, timeout);
  98
  99         if (!status && requesttype == USB_VENDOR_REQUEST_IN)
 100                 memcpy(buffer, rt2x00dev->csr.cache, buffer_length);
 101
 102         return status;
 103 }
 104 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock);
 105
 106 int rt2x00usb_vendor_request_buff(struct rt2x00_dev *rt2x00dev,
 107                                   const u8 request, const u8 requesttype,
 108                                   const u16 offset, void *buffer,
 109                                   const u16 buffer_length, const int timeout)
 110 {
 111         int status;
 112
 113         mutex_lock(&rt2x00dev->csr_mutex);
 114
 115         status = rt2x00usb_vendor_req_buff_lock(rt2x00dev, request,
 116                                                 requesttype, offset, buffer,
 117                                                 buffer_length, timeout);
 118
 119         mutex_unlock(&rt2x00dev->csr_mutex);
 120
 121         return status;
 122 }
 123 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff);
 124
 125 int rt2x00usb_vendor_request_large_buff(struct rt2x00_dev *rt2x00dev,
 126                                         const u8 request, const u8 requesttype,
 127                                         const u16 offset, const void *buffer,
 128                                         const u16 buffer_length,
 129                                         const int timeout)
 130 {
 131         int status = 0;
 132         unsigned char *tb;
 133         u16 off, len, bsize;
 134
 135         mutex_lock(&rt2x00dev->csr_mutex);
 136
 137         tb  = (char *)buffer;
 138         off = offset;
 139         len = buffer_length;
 140         while (len && !status) {
 141                 bsize = min_t(u16, CSR_CACHE_SIZE, len);
 142                 status = rt2x00usb_vendor_req_buff_lock(rt2x00dev, request,
 143                                                         requesttype, off, tb,
 144                                                         bsize, timeout);
 145
 146                 tb  += bsize;
 147                 len -= bsize;
 148                 off += bsize;
 149         }
 150
 151         mutex_unlock(&rt2x00dev->csr_mutex);
 152
 153         return status;
 154 }
 155 EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_large_buff);
 156
 157 int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev,
 158                            const unsigned int offset,
 159                            struct rt2x00_field32 field,
 160                            u32 *reg)
 161 {
 162         unsigned int i;
 163
 164         for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
 165                 rt2x00usb_register_read_lock(rt2x00dev, offset, reg);
 166                 if (!rt2x00_get_field32(*reg, field))
 167                         return 1;
 168                 udelay(REGISTER_BUSY_DELAY);
 169         }
 170
 171         ERROR(rt2x00dev, "Indirect register access failed: "
 172               "offset=0x%.08x, value=0x%.08x\n", offset, *reg);
 173         *reg = ~0;
 174
 175         return 0;
 176 }
 177 EXPORT_SYMBOL_GPL(rt2x00usb_regbusy_read);
 178
 179 /*
 180  * TX data handlers.
 181  */
 182 static void rt2x00usb_interrupt_txdone(struct urb *urb)
 183 {
 184         struct queue_entry *entry = (struct queue_entry *)urb->context;
 185         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
 186         struct txdone_entry_desc txdesc;
 187
 188         if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags) ||
 189             !test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
 190                 return;
 191
 192         /*
 193          * Obtain the status about this packet.
 194          * Note that when the status is 0 it does not mean the
 195          * frame was send out correctly. It only means the frame
 196          * was succesfully pushed to the hardware, we have no
 197          * way to determine the transmission status right now.
 198          * (Only indirectly by looking at the failed TX counters
 199          * in the register).
 200          */
 201         txdesc.flags = 0;
 202         if (!urb->status)
 203                 __set_bit(TXDONE_UNKNOWN, &txdesc.flags);
 204         else
 205                 __set_bit(TXDONE_FAILURE, &txdesc.flags);
 206         txdesc.retry = 0;
 207
 208         rt2x00lib_txdone(entry, &txdesc);
 209 }
 210
 211 int rt2x00usb_write_tx_data(struct queue_entry *entry)
 212 {
 213         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
 214         struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev);
 215         struct queue_entry_priv_usb *entry_priv = entry->priv_data;
 216         struct skb_frame_desc *skbdesc;
 217         u32 length;
 218
 219         /*
 220          * Add the descriptor in front of the skb.
 221          */
 222         skb_push(entry->skb, entry->queue->desc_size);
 223         memset(entry->skb->data, 0, entry->queue->desc_size);
 224
 225         /*
 226          * Fill in skb descriptor
 227          */
 228         skbdesc = get_skb_frame_desc(entry->skb);
 229         skbdesc->desc = entry->skb->data;
 230         skbdesc->desc_len = entry->queue->desc_size;
 231
 232         /*
 233          * USB devices cannot blindly pass the skb->len as the
 234          * length of the data to usb_fill_bulk_urb. Pass the skb
 235          * to the driver to determine what the length should be.
 236          */
 237         length = rt2x00dev->ops->lib->get_tx_data_len(entry);
 238
 239         usb_fill_bulk_urb(entry_priv->urb, usb_dev,
 240                           usb_sndbulkpipe(usb_dev, entry->queue->usb_endpoint),
 241                           entry->skb->data, length,
 242                           rt2x00usb_interrupt_txdone, entry);
 243
 244         /*
 245          * Make sure the skb->data pointer points to the frame, not the
 246          * descriptor.
 247          */
 248         skb_pull(entry->skb, entry->queue->desc_size);
 249
 250         return 0;
 251 }
 252 EXPORT_SYMBOL_GPL(rt2x00usb_write_tx_data);
 253
 254 static inline void rt2x00usb_kick_tx_entry(struct queue_entry *entry)
 255 {
 256         struct queue_entry_priv_usb *entry_priv = entry->priv_data;
 257
 258         if (test_and_clear_bit(ENTRY_DATA_PENDING, &entry->flags))
 259                 usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
 260 }
 261
 262 void rt2x00usb_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
 263                              const enum data_queue_qid qid)
 264 {
 265         struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
 266         unsigned long irqflags;
 267         unsigned int index;
 268         unsigned int index_done;
 269         unsigned int i;
 270
 271         /*
 272          * Only protect the range we are going to loop over,
 273          * if during our loop a extra entry is set to pending
 274          * it should not be kicked during this run, since it
 275          * is part of another TX operation.
 276          */
 277         spin_lock_irqsave(&queue->lock, irqflags);
 278         index = queue->index[Q_INDEX];
 279         index_done = queue->index[Q_INDEX_DONE];
 280         spin_unlock_irqrestore(&queue->lock, irqflags);
 281
 282         /*
 283          * Start from the TX done pointer, this guarentees that we will
 284          * send out all frames in the correct order.
 285          */
 286         if (index_done < index) {
 287                 for (i = index_done; i < index; i++)
 288                         rt2x00usb_kick_tx_entry(&queue->entries[i]);
 289         } else {
 290                 for (i = index_done; i < queue->limit; i++)
 291                         rt2x00usb_kick_tx_entry(&queue->entries[i]);
 292
 293                 for (i = 0; i < index; i++)
 294                         rt2x00usb_kick_tx_entry(&queue->entries[i]);
 295         }
 296 }
 297 EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue);
 298
 299 /*
 300  * RX data handlers.
 301  */
 302 static void rt2x00usb_interrupt_rxdone(struct urb *urb)
 303 {
 304         struct queue_entry *entry = (struct queue_entry *)urb->context;
 305         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
 306         struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
 307         u8 rxd[32];
 308
 309         if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags) ||
 310             !test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
 311                 return;
 312
 313         /*
 314          * Check if the received data is simply too small
 315          * to be actually valid, or if the urb is signaling
 316          * a problem.
 317          */
 318         if (urb->actual_length < entry->queue->desc_size || urb->status) {
 319                 set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
 320                 usb_submit_urb(urb, GFP_ATOMIC);
 321                 return;
 322         }
 323
 324         /*
 325          * Fill in desc fields of the skb descriptor
 326          */
 327         skbdesc->desc = rxd;
 328         skbdesc->desc_len = entry->queue->desc_size;
 329
 330         /*
 331          * Send the frame to rt2x00lib for further processing.
 332          */
 333         rt2x00lib_rxdone(rt2x00dev, entry);
 334 }
 335
 336 /*
 337  * Radio handlers
 338  */
 339 void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
 340 {
 341         struct queue_entry_priv_usb *entry_priv;
 342         struct queue_entry_priv_usb_bcn *bcn_priv;
 343         struct data_queue *queue;
 344         unsigned int i;
 345
 346         rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0,
 347                                     REGISTER_TIMEOUT);
 348
 349         /*
 350          * Cancel all queues.
 351          */
 352         queue_for_each(rt2x00dev, queue) {
 353                 for (i = 0; i < queue->limit; i++) {
 354                         entry_priv = queue->entries[i].priv_data;
 355                         usb_kill_urb(entry_priv->urb);
 356                 }
 357         }
 358
 359         /*
 360          * Kill guardian urb (if required by driver).
 361          */
 362         if (!test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
 363                 return;
 364
 365         for (i = 0; i < rt2x00dev->bcn->limit; i++) {
 366                 bcn_priv = rt2x00dev->bcn->entries[i].priv_data;
 367                 if (bcn_priv->guardian_urb)
 368                         usb_kill_urb(bcn_priv->guardian_urb);
 369         }
 370 }
 371 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
 372
 373 /*
 374  * Device initialization handlers.
 375  */
 376 void rt2x00usb_clear_entry(struct queue_entry *entry)
 377 {
 378         struct usb_device *usb_dev =
 379             to_usb_device_intf(entry->queue->rt2x00dev->dev);
 380         struct queue_entry_priv_usb *entry_priv = entry->priv_data;
 381         int pipe;
 382
 383         if (entry->queue->qid == QID_RX) {
 384                 pipe = usb_rcvbulkpipe(usb_dev, entry->queue->usb_endpoint);
 385                 usb_fill_bulk_urb(entry_priv->urb, usb_dev, pipe,
 386                                 entry->skb->data, entry->skb->len,
 387                                 rt2x00usb_interrupt_rxdone, entry);
 388
 389                 set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
 390                 usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
 391         } else {
 392                 entry->flags = 0;
 393         }
 394 }
 395 EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry);
 396
 397 static void rt2x00usb_assign_endpoint(struct data_queue *queue,
 398                                       struct usb_endpoint_descriptor *ep_desc)
 399 {
 400         struct usb_device *usb_dev = to_usb_device_intf(queue->rt2x00dev->dev);
 401         int pipe;
 402
 403         queue->usb_endpoint = usb_endpoint_num(ep_desc);
 404
 405         if (queue->qid == QID_RX) {
 406                 pipe = usb_rcvbulkpipe(usb_dev, queue->usb_endpoint);
 407                 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 0);
 408         } else {
 409                 pipe = usb_sndbulkpipe(usb_dev, queue->usb_endpoint);
 410                 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 1);
 411         }
 412
 413         if (!queue->usb_maxpacket)
 414                 queue->usb_maxpacket = 1;
 415 }
 416
 417 static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev)
 418 {
 419         struct usb_interface *intf = to_usb_interface(rt2x00dev->dev);
 420         struct usb_host_interface *intf_desc = intf->cur_altsetting;
 421         struct usb_endpoint_descriptor *ep_desc;
 422         struct data_queue *queue = rt2x00dev->tx;
 423         struct usb_endpoint_descriptor *tx_ep_desc = NULL;
 424         unsigned int i;
 425
 426         /*
 427          * Walk through all available endpoints to search for "bulk in"
 428          * and "bulk out" endpoints. When we find such endpoints collect
 429          * the information we need from the descriptor and assign it
 430          * to the queue.
 431          */
 432         for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
 433                 ep_desc = &intf_desc->endpoint[i].desc;
 434
 435                 if (usb_endpoint_is_bulk_in(ep_desc)) {
 436                         rt2x00usb_assign_endpoint(rt2x00dev->rx, ep_desc);
 437                 } else if (usb_endpoint_is_bulk_out(ep_desc)) {
 438                         rt2x00usb_assign_endpoint(queue, ep_desc);
 439
 440                         if (queue != queue_end(rt2x00dev))
 441                                 queue = queue_next(queue);
 442                         tx_ep_desc = ep_desc;
 443                 }
 444         }
 445
 446         /*
 447          * At least 1 endpoint for RX and 1 endpoint for TX must be available.
 448          */
 449         if (!rt2x00dev->rx->usb_endpoint || !rt2x00dev->tx->usb_endpoint) {
 450                 ERROR(rt2x00dev, "Bulk-in/Bulk-out endpoints not found\n");
 451                 return -EPIPE;
 452         }
 453
 454         /*
 455          * It might be possible not all queues have a dedicated endpoint.
 456          * Loop through all TX queues and copy the endpoint information
 457          * which we have gathered from already assigned endpoints.
 458          */
 459         txall_queue_for_each(rt2x00dev, queue) {
 460                 if (!queue->usb_endpoint)
 461                         rt2x00usb_assign_endpoint(queue, tx_ep_desc);
 462         }
 463
 464         return 0;
 465 }
 466
 467 static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
 468                                struct data_queue *queue)
 469 {
 470         struct queue_entry_priv_usb *entry_priv;
 471         struct queue_entry_priv_usb_bcn *bcn_priv;
 472         unsigned int i;
 473
 474         for (i = 0; i < queue->limit; i++) {
 475                 entry_priv = queue->entries[i].priv_data;
 476                 entry_priv->urb = usb_alloc_urb(0, GFP_KERNEL);
 477                 if (!entry_priv->urb)
 478                         return -ENOMEM;
 479         }
 480
 481         /*
 482          * If this is not the beacon queue or
 483          * no guardian byte was required for the beacon,
 484          * then we are done.
 485          */
 486         if (rt2x00dev->bcn != queue ||
 487             !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
 488                 return 0;
 489
 490         for (i = 0; i < queue->limit; i++) {
 491                 bcn_priv = queue->entries[i].priv_data;
 492                 bcn_priv->guardian_urb = usb_alloc_urb(0, GFP_KERNEL);
 493                 if (!bcn_priv->guardian_urb)
 494                         return -ENOMEM;
 495         }
 496
 497         return 0;
 498 }
 499
 500 static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev,
 501                                struct data_queue *queue)
 502 {
 503         struct queue_entry_priv_usb *entry_priv;
 504         struct queue_entry_priv_usb_bcn *bcn_priv;
 505         unsigned int i;
 506
 507         if (!queue->entries)
 508                 return;
 509
 510         for (i = 0; i < queue->limit; i++) {
 511                 entry_priv = queue->entries[i].priv_data;
 512                 usb_kill_urb(entry_priv->urb);
 513                 usb_free_urb(entry_priv->urb);
 514         }
 515
 516         /*
 517          * If this is not the beacon queue or
 518          * no guardian byte was required for the beacon,
 519          * then we are done.
 520          */
 521         if (rt2x00dev->bcn != queue ||
 522             !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
 523                 return;
 524
 525         for (i = 0; i < queue->limit; i++) {
 526                 bcn_priv = queue->entries[i].priv_data;
 527                 usb_kill_urb(bcn_priv->guardian_urb);
 528                 usb_free_urb(bcn_priv->guardian_urb);
 529         }
 530 }
 531
 532 int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
 533 {
 534         struct data_queue *queue;
 535         int status;
 536
 537         /*
 538          * Find endpoints for each queue
 539          */
 540         status = rt2x00usb_find_endpoints(rt2x00dev);
 541         if (status)
 542                 goto exit;
 543
 544         /*
 545          * Allocate DMA
 546          */
 547         queue_for_each(rt2x00dev, queue) {
 548                 status = rt2x00usb_alloc_urb(rt2x00dev, queue);
 549                 if (status)
 550                         goto exit;
 551         }
 552
 553         return 0;
 554
 555 exit:
 556         rt2x00usb_uninitialize(rt2x00dev);
 557
 558         return status;
 559 }
 560 EXPORT_SYMBOL_GPL(rt2x00usb_initialize);
 561
 562 void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev)
 563 {
 564         struct data_queue *queue;
 565
 566         queue_for_each(rt2x00dev, queue)
 567                 rt2x00usb_free_urb(rt2x00dev, queue);
 568 }
 569 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize);
 570
 571 /*
 572  * USB driver handlers.
 573  */
 574 static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev)
 575 {
 576         kfree(rt2x00dev->rf);
 577         rt2x00dev->rf = NULL;
 578
 579         kfree(rt2x00dev->eeprom);
 580         rt2x00dev->eeprom = NULL;
 581
 582         kfree(rt2x00dev->csr.cache);
 583         rt2x00dev->csr.cache = NULL;
 584 }
 585
 586 static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev)
 587 {
 588         rt2x00dev->csr.cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL);
 589         if (!rt2x00dev->csr.cache)
 590                 goto exit;
 591
 592         rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
 593         if (!rt2x00dev->eeprom)
 594                 goto exit;
 595
 596         rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
 597         if (!rt2x00dev->rf)
 598                 goto exit;
 599
 600         return 0;
 601
 602 exit:
 603         ERROR_PROBE("Failed to allocate registers.\n");
 604
 605         rt2x00usb_free_reg(rt2x00dev);
 606
 607         return -ENOMEM;
 608 }
 609
 610 int rt2x00usb_probe(struct usb_interface *usb_intf,
 611                     const struct usb_device_id *id)
 612 {
 613         struct usb_device *usb_dev = interface_to_usbdev(usb_intf);
 614         struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_info;
 615         struct ieee80211_hw *hw;
 616         struct rt2x00_dev *rt2x00dev;
 617         int retval;
 618
 619         usb_dev = usb_get_dev(usb_dev);
 620
 621         hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
 622         if (!hw) {
 623                 ERROR_PROBE("Failed to allocate hardware.\n");
 624                 retval = -ENOMEM;
 625                 goto exit_put_device;
 626         }
 627
 628         usb_set_intfdata(usb_intf, hw);
 629
 630         rt2x00dev = hw->priv;
 631         rt2x00dev->dev = &usb_intf->dev;
 632         rt2x00dev->ops = ops;
 633         rt2x00dev->hw = hw;
 634
 635         retval = rt2x00usb_alloc_reg(rt2x00dev);
 636         if (retval)
 637                 goto exit_free_device;
 638
 639         retval = rt2x00lib_probe_dev(rt2x00dev);
 640         if (retval)
 641                 goto exit_free_reg;
 642
 643         return 0;
 644
 645 exit_free_reg:
 646         rt2x00usb_free_reg(rt2x00dev);
 647
 648 exit_free_device:
 649         ieee80211_free_hw(hw);
 650
 651 exit_put_device:
 652         usb_put_dev(usb_dev);
 653
 654         usb_set_intfdata(usb_intf, NULL);
 655
 656         return retval;
 657 }
 658 EXPORT_SYMBOL_GPL(rt2x00usb_probe);
 659
 660 void rt2x00usb_disconnect(struct usb_interface *usb_intf)
 661 {
 662         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
 663         struct rt2x00_dev *rt2x00dev = hw->priv;
 664
 665         /*
 666          * Free all allocated data.
 667          */
 668         rt2x00lib_remove_dev(rt2x00dev);
 669         rt2x00usb_free_reg(rt2x00dev);
 670         ieee80211_free_hw(hw);
 671
 672         /*
 673          * Free the USB device data.
 674          */
 675         usb_set_intfdata(usb_intf, NULL);
 676         usb_put_dev(interface_to_usbdev(usb_intf));
 677 }
 678 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect);
 679
 680 #ifdef CONFIG_PM
 681 int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state)
 682 {
 683         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
 684         struct rt2x00_dev *rt2x00dev = hw->priv;
 685         int retval;
 686
 687         retval = rt2x00lib_suspend(rt2x00dev, state);
 688         if (retval)
 689                 return retval;
 690
 691         rt2x00usb_free_reg(rt2x00dev);
 692
 693         /*
 694          * Decrease usbdev refcount.
 695          */
 696         usb_put_dev(interface_to_usbdev(usb_intf));
 697
 698         return 0;
 699 }
 700 EXPORT_SYMBOL_GPL(rt2x00usb_suspend);
 701
 702 int rt2x00usb_resume(struct usb_interface *usb_intf)
 703 {
 704         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
 705         struct rt2x00_dev *rt2x00dev = hw->priv;
 706         int retval;
 707
 708         usb_get_dev(interface_to_usbdev(usb_intf));
 709
 710         retval = rt2x00usb_alloc_reg(rt2x00dev);
 711         if (retval)
 712                 return retval;
 713
 714         retval = rt2x00lib_resume(rt2x00dev);
 715         if (retval)
 716                 goto exit_free_reg;
 717
 718         return 0;
 719
 720 exit_free_reg:
 721         rt2x00usb_free_reg(rt2x00dev);
 722
 723         return retval;
 724 }
 725 EXPORT_SYMBOL_GPL(rt2x00usb_resume);
 726 #endif /* CONFIG_PM */
 727
 728 /*
 729  * rt2x00usb module information.
 730  */
 731 MODULE_AUTHOR(DRV_PROJECT);
 732 MODULE_VERSION(DRV_VERSION);
 733 MODULE_DESCRIPTION("rt2x00 usb library");
 734 MODULE_LICENSE("GPL");