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

   1 /*
   2         Copyright (C) 2004 - 2009 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 void rt2x00usb_kill_tx_queue(struct rt2x00_dev *rt2x00dev,
 300                              const enum data_queue_qid qid)
 301 {
 302         struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, qid);
 303         struct queue_entry_priv_usb *entry_priv;
 304         struct queue_entry_priv_usb_bcn *bcn_priv;
 305         unsigned int i;
 306         bool kill_guard;
 307
 308         /*
 309          * When killing the beacon queue, we must also kill
 310          * the beacon guard byte.
 311          */
 312         kill_guard =
 313             (qid == QID_BEACON) &&
 314             (test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags));
 315
 316         /*
 317          * Cancel all entries.
 318          */
 319         for (i = 0; i < queue->limit; i++) {
 320                 entry_priv = queue->entries[i].priv_data;
 321                 usb_kill_urb(entry_priv->urb);
 322
 323                 /*
 324                  * Kill guardian urb (if required by driver).
 325                  */
 326                 if (kill_guard) {
 327                         bcn_priv = queue->entries[i].priv_data;
 328                         usb_kill_urb(bcn_priv->guardian_urb);
 329                 }
 330         }
 331 }
 332 EXPORT_SYMBOL_GPL(rt2x00usb_kill_tx_queue);
 333
 334 /*
 335  * RX data handlers.
 336  */
 337 static void rt2x00usb_interrupt_rxdone(struct urb *urb)
 338 {
 339         struct queue_entry *entry = (struct queue_entry *)urb->context;
 340         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
 341         struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
 342         u8 rxd[32];
 343
 344         if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags) ||
 345             !test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags))
 346                 return;
 347
 348         /*
 349          * Check if the received data is simply too small
 350          * to be actually valid, or if the urb is signaling
 351          * a problem.
 352          */
 353         if (urb->actual_length < entry->queue->desc_size || urb->status) {
 354                 set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
 355                 usb_submit_urb(urb, GFP_ATOMIC);
 356                 return;
 357         }
 358
 359         /*
 360          * Fill in desc fields of the skb descriptor
 361          */
 362         skbdesc->desc = rxd;
 363         skbdesc->desc_len = entry->queue->desc_size;
 364
 365         /*
 366          * Send the frame to rt2x00lib for further processing.
 367          */
 368         rt2x00lib_rxdone(rt2x00dev, entry);
 369 }
 370
 371 /*
 372  * Radio handlers
 373  */
 374 void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev)
 375 {
 376         rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0,
 377                                     REGISTER_TIMEOUT);
 378
 379         /*
 380          * The USB version of kill_tx_queue also works
 381          * on the RX queue.
 382          */
 383         rt2x00dev->ops->lib->kill_tx_queue(rt2x00dev, QID_RX);
 384 }
 385 EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio);
 386
 387 /*
 388  * Device initialization handlers.
 389  */
 390 void rt2x00usb_clear_entry(struct queue_entry *entry)
 391 {
 392         struct usb_device *usb_dev =
 393             to_usb_device_intf(entry->queue->rt2x00dev->dev);
 394         struct queue_entry_priv_usb *entry_priv = entry->priv_data;
 395         int pipe;
 396
 397         if (entry->queue->qid == QID_RX) {
 398                 pipe = usb_rcvbulkpipe(usb_dev, entry->queue->usb_endpoint);
 399                 usb_fill_bulk_urb(entry_priv->urb, usb_dev, pipe,
 400                                 entry->skb->data, entry->skb->len,
 401                                 rt2x00usb_interrupt_rxdone, entry);
 402
 403                 set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
 404                 usb_submit_urb(entry_priv->urb, GFP_ATOMIC);
 405         } else {
 406                 entry->flags = 0;
 407         }
 408 }
 409 EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry);
 410
 411 static void rt2x00usb_assign_endpoint(struct data_queue *queue,
 412                                       struct usb_endpoint_descriptor *ep_desc)
 413 {
 414         struct usb_device *usb_dev = to_usb_device_intf(queue->rt2x00dev->dev);
 415         int pipe;
 416
 417         queue->usb_endpoint = usb_endpoint_num(ep_desc);
 418
 419         if (queue->qid == QID_RX) {
 420                 pipe = usb_rcvbulkpipe(usb_dev, queue->usb_endpoint);
 421                 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 0);
 422         } else {
 423                 pipe = usb_sndbulkpipe(usb_dev, queue->usb_endpoint);
 424                 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 1);
 425         }
 426
 427         if (!queue->usb_maxpacket)
 428                 queue->usb_maxpacket = 1;
 429 }
 430
 431 static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev)
 432 {
 433         struct usb_interface *intf = to_usb_interface(rt2x00dev->dev);
 434         struct usb_host_interface *intf_desc = intf->cur_altsetting;
 435         struct usb_endpoint_descriptor *ep_desc;
 436         struct data_queue *queue = rt2x00dev->tx;
 437         struct usb_endpoint_descriptor *tx_ep_desc = NULL;
 438         unsigned int i;
 439
 440         /*
 441          * Walk through all available endpoints to search for "bulk in"
 442          * and "bulk out" endpoints. When we find such endpoints collect
 443          * the information we need from the descriptor and assign it
 444          * to the queue.
 445          */
 446         for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) {
 447                 ep_desc = &intf_desc->endpoint[i].desc;
 448
 449                 if (usb_endpoint_is_bulk_in(ep_desc)) {
 450                         rt2x00usb_assign_endpoint(rt2x00dev->rx, ep_desc);
 451                 } else if (usb_endpoint_is_bulk_out(ep_desc) &&
 452                            (queue != queue_end(rt2x00dev))) {
 453                         rt2x00usb_assign_endpoint(queue, ep_desc);
 454                         queue = queue_next(queue);
 455
 456                         tx_ep_desc = ep_desc;
 457                 }
 458         }
 459
 460         /*
 461          * At least 1 endpoint for RX and 1 endpoint for TX must be available.
 462          */
 463         if (!rt2x00dev->rx->usb_endpoint || !rt2x00dev->tx->usb_endpoint) {
 464                 ERROR(rt2x00dev, "Bulk-in/Bulk-out endpoints not found\n");
 465                 return -EPIPE;
 466         }
 467
 468         /*
 469          * It might be possible not all queues have a dedicated endpoint.
 470          * Loop through all TX queues and copy the endpoint information
 471          * which we have gathered from already assigned endpoints.
 472          */
 473         txall_queue_for_each(rt2x00dev, queue) {
 474                 if (!queue->usb_endpoint)
 475                         rt2x00usb_assign_endpoint(queue, tx_ep_desc);
 476         }
 477
 478         return 0;
 479 }
 480
 481 static int rt2x00usb_alloc_urb(struct rt2x00_dev *rt2x00dev,
 482                                struct data_queue *queue)
 483 {
 484         struct queue_entry_priv_usb *entry_priv;
 485         struct queue_entry_priv_usb_bcn *bcn_priv;
 486         unsigned int i;
 487
 488         for (i = 0; i < queue->limit; i++) {
 489                 entry_priv = queue->entries[i].priv_data;
 490                 entry_priv->urb = usb_alloc_urb(0, GFP_KERNEL);
 491                 if (!entry_priv->urb)
 492                         return -ENOMEM;
 493         }
 494
 495         /*
 496          * If this is not the beacon queue or
 497          * no guardian byte was required for the beacon,
 498          * then we are done.
 499          */
 500         if (rt2x00dev->bcn != queue ||
 501             !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
 502                 return 0;
 503
 504         for (i = 0; i < queue->limit; i++) {
 505                 bcn_priv = queue->entries[i].priv_data;
 506                 bcn_priv->guardian_urb = usb_alloc_urb(0, GFP_KERNEL);
 507                 if (!bcn_priv->guardian_urb)
 508                         return -ENOMEM;
 509         }
 510
 511         return 0;
 512 }
 513
 514 static void rt2x00usb_free_urb(struct rt2x00_dev *rt2x00dev,
 515                                struct data_queue *queue)
 516 {
 517         struct queue_entry_priv_usb *entry_priv;
 518         struct queue_entry_priv_usb_bcn *bcn_priv;
 519         unsigned int i;
 520
 521         if (!queue->entries)
 522                 return;
 523
 524         for (i = 0; i < queue->limit; i++) {
 525                 entry_priv = queue->entries[i].priv_data;
 526                 usb_kill_urb(entry_priv->urb);
 527                 usb_free_urb(entry_priv->urb);
 528         }
 529
 530         /*
 531          * If this is not the beacon queue or
 532          * no guardian byte was required for the beacon,
 533          * then we are done.
 534          */
 535         if (rt2x00dev->bcn != queue ||
 536             !test_bit(DRIVER_REQUIRE_BEACON_GUARD, &rt2x00dev->flags))
 537                 return;
 538
 539         for (i = 0; i < queue->limit; i++) {
 540                 bcn_priv = queue->entries[i].priv_data;
 541                 usb_kill_urb(bcn_priv->guardian_urb);
 542                 usb_free_urb(bcn_priv->guardian_urb);
 543         }
 544 }
 545
 546 int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev)
 547 {
 548         struct data_queue *queue;
 549         int status;
 550
 551         /*
 552          * Find endpoints for each queue
 553          */
 554         status = rt2x00usb_find_endpoints(rt2x00dev);
 555         if (status)
 556                 goto exit;
 557
 558         /*
 559          * Allocate DMA
 560          */
 561         queue_for_each(rt2x00dev, queue) {
 562                 status = rt2x00usb_alloc_urb(rt2x00dev, queue);
 563                 if (status)
 564                         goto exit;
 565         }
 566
 567         return 0;
 568
 569 exit:
 570         rt2x00usb_uninitialize(rt2x00dev);
 571
 572         return status;
 573 }
 574 EXPORT_SYMBOL_GPL(rt2x00usb_initialize);
 575
 576 void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev)
 577 {
 578         struct data_queue *queue;
 579
 580         queue_for_each(rt2x00dev, queue)
 581                 rt2x00usb_free_urb(rt2x00dev, queue);
 582 }
 583 EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize);
 584
 585 /*
 586  * USB driver handlers.
 587  */
 588 static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev)
 589 {
 590         kfree(rt2x00dev->rf);
 591         rt2x00dev->rf = NULL;
 592
 593         kfree(rt2x00dev->eeprom);
 594         rt2x00dev->eeprom = NULL;
 595
 596         kfree(rt2x00dev->csr.cache);
 597         rt2x00dev->csr.cache = NULL;
 598 }
 599
 600 static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev)
 601 {
 602         rt2x00dev->csr.cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL);
 603         if (!rt2x00dev->csr.cache)
 604                 goto exit;
 605
 606         rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL);
 607         if (!rt2x00dev->eeprom)
 608                 goto exit;
 609
 610         rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL);
 611         if (!rt2x00dev->rf)
 612                 goto exit;
 613
 614         return 0;
 615
 616 exit:
 617         ERROR_PROBE("Failed to allocate registers.\n");
 618
 619         rt2x00usb_free_reg(rt2x00dev);
 620
 621         return -ENOMEM;
 622 }
 623
 624 int rt2x00usb_probe(struct usb_interface *usb_intf,
 625                     const struct usb_device_id *id)
 626 {
 627         struct usb_device *usb_dev = interface_to_usbdev(usb_intf);
 628         struct rt2x00_ops *ops = (struct rt2x00_ops *)id->driver_info;
 629         struct ieee80211_hw *hw;
 630         struct rt2x00_dev *rt2x00dev;
 631         int retval;
 632
 633         usb_dev = usb_get_dev(usb_dev);
 634
 635         hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw);
 636         if (!hw) {
 637                 ERROR_PROBE("Failed to allocate hardware.\n");
 638                 retval = -ENOMEM;
 639                 goto exit_put_device;
 640         }
 641
 642         usb_set_intfdata(usb_intf, hw);
 643
 644         rt2x00dev = hw->priv;
 645         rt2x00dev->dev = &usb_intf->dev;
 646         rt2x00dev->ops = ops;
 647         rt2x00dev->hw = hw;
 648
 649         retval = rt2x00usb_alloc_reg(rt2x00dev);
 650         if (retval)
 651                 goto exit_free_device;
 652
 653         retval = rt2x00lib_probe_dev(rt2x00dev);
 654         if (retval)
 655                 goto exit_free_reg;
 656
 657         return 0;
 658
 659 exit_free_reg:
 660         rt2x00usb_free_reg(rt2x00dev);
 661
 662 exit_free_device:
 663         ieee80211_free_hw(hw);
 664
 665 exit_put_device:
 666         usb_put_dev(usb_dev);
 667
 668         usb_set_intfdata(usb_intf, NULL);
 669
 670         return retval;
 671 }
 672 EXPORT_SYMBOL_GPL(rt2x00usb_probe);
 673
 674 void rt2x00usb_disconnect(struct usb_interface *usb_intf)
 675 {
 676         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
 677         struct rt2x00_dev *rt2x00dev = hw->priv;
 678
 679         /*
 680          * Free all allocated data.
 681          */
 682         rt2x00lib_remove_dev(rt2x00dev);
 683         rt2x00usb_free_reg(rt2x00dev);
 684         ieee80211_free_hw(hw);
 685
 686         /*
 687          * Free the USB device data.
 688          */
 689         usb_set_intfdata(usb_intf, NULL);
 690         usb_put_dev(interface_to_usbdev(usb_intf));
 691 }
 692 EXPORT_SYMBOL_GPL(rt2x00usb_disconnect);
 693
 694 #ifdef CONFIG_PM
 695 int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state)
 696 {
 697         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
 698         struct rt2x00_dev *rt2x00dev = hw->priv;
 699         int retval;
 700
 701         retval = rt2x00lib_suspend(rt2x00dev, state);
 702         if (retval)
 703                 return retval;
 704
 705         rt2x00usb_free_reg(rt2x00dev);
 706
 707         /*
 708          * Decrease usbdev refcount.
 709          */
 710         usb_put_dev(interface_to_usbdev(usb_intf));
 711
 712         return 0;
 713 }
 714 EXPORT_SYMBOL_GPL(rt2x00usb_suspend);
 715
 716 int rt2x00usb_resume(struct usb_interface *usb_intf)
 717 {
 718         struct ieee80211_hw *hw = usb_get_intfdata(usb_intf);
 719         struct rt2x00_dev *rt2x00dev = hw->priv;
 720         int retval;
 721
 722         usb_get_dev(interface_to_usbdev(usb_intf));
 723
 724         retval = rt2x00usb_alloc_reg(rt2x00dev);
 725         if (retval)
 726                 return retval;
 727
 728         retval = rt2x00lib_resume(rt2x00dev);
 729         if (retval)
 730                 goto exit_free_reg;
 731
 732         return 0;
 733
 734 exit_free_reg:
 735         rt2x00usb_free_reg(rt2x00dev);
 736
 737         return retval;
 738 }
 739 EXPORT_SYMBOL_GPL(rt2x00usb_resume);
 740 #endif /* CONFIG_PM */
 741
 742 /*
 743  * rt2x00usb module information.
 744  */
 745 MODULE_AUTHOR(DRV_PROJECT);
 746 MODULE_VERSION(DRV_VERSION);
 747 MODULE_DESCRIPTION("rt2x00 usb library");
 748 MODULE_LICENSE("GPL");