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 */ 38int 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} 78EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request); 79 80int 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} 109EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock); 110 111int 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} 140EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff); 141 142int 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} 165EXPORT_SYMBOL_GPL(rt2x00usb_regbusy_read); 166 167/* 168 * TX data handlers. 169 */ 170static 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 199static 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 223void 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} 258EXPORT_SYMBOL_GPL(rt2x00usb_kick_tx_queue); 259 260void 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} 293EXPORT_SYMBOL_GPL(rt2x00usb_kill_tx_queue); 294 295static 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 334void 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} 343EXPORT_SYMBOL_GPL(rt2x00usb_watchdog); 344 345/* 346 * RX data handlers. 347 */ 348static 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 */ 385void 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} 396EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio); 397 398/* 399 * Device initialization handlers. 400 */ 401void 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} 420EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry); 421 422static 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 442static 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 492static 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 525static 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 557int 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 580exit: 581 rt2x00usb_uninitialize(rt2x00dev); 582 583 return status; 584} 585EXPORT_SYMBOL_GPL(rt2x00usb_initialize); 586 587void 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} 594EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize); 595 596/* 597 * USB driver handlers. 598 */ 599static 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 611static 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 627exit: 628 ERROR_PROBE("Failed to allocate registers.\n"); 629 630 rt2x00usb_free_reg(rt2x00dev); 631 632 return -ENOMEM; 633} 634 635int 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 672exit_free_reg: 673 rt2x00usb_free_reg(rt2x00dev); 674 675exit_free_device: 676 ieee80211_free_hw(hw); 677 678exit_put_device: 679 usb_put_dev(usb_dev); 680 681 usb_set_intfdata(usb_intf, NULL); 682 683 return retval; 684} 685EXPORT_SYMBOL_GPL(rt2x00usb_probe); 686 687void 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} 705EXPORT_SYMBOL_GPL(rt2x00usb_disconnect); 706 707#ifdef CONFIG_PM 708int 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} 725EXPORT_SYMBOL_GPL(rt2x00usb_suspend); 726 727int 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} 736EXPORT_SYMBOL_GPL(rt2x00usb_resume); 737#endif /* CONFIG_PM */ 738 739/* 740 * rt2x00usb module information. 741 */ 742MODULE_AUTHOR(DRV_PROJECT); 743MODULE_VERSION(DRV_VERSION); 744MODULE_DESCRIPTION("rt2x00 usb library"); 745MODULE_LICENSE("GPL"); 746