drivers/net/wireless/rt2x00/rt2x00usb.c

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