1/* 2 Copyright (C) 2010 Willow Garage <http://www.willowgarage.com> 3 Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com> 4 <http://rt2x00.serialmonkey.com> 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the 18 Free Software Foundation, Inc., 19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 20 */ 21 22/* 23 Module: rt2x00usb 24 Abstract: rt2x00 generic usb device routines. 25 */ 26 27#include <linux/kernel.h> 28#include <linux/module.h> 29#include <linux/slab.h> 30#include <linux/usb.h> 31#include <linux/bug.h> 32 33#include "rt2x00.h" 34#include "rt2x00usb.h" 35 36/* 37 * Interfacing with the HW. 38 */ 39int rt2x00usb_vendor_request(struct rt2x00_dev *rt2x00dev, 40 const u8 request, const u8 requesttype, 41 const u16 offset, const u16 value, 42 void *buffer, const u16 buffer_length, 43 const int timeout) 44{ 45 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev); 46 int status; 47 unsigned int i; 48 unsigned int pipe = 49 (requesttype == USB_VENDOR_REQUEST_IN) ? 50 usb_rcvctrlpipe(usb_dev, 0) : usb_sndctrlpipe(usb_dev, 0); 51 52 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 53 return -ENODEV; 54 55 for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 56 status = usb_control_msg(usb_dev, pipe, request, requesttype, 57 value, offset, buffer, buffer_length, 58 timeout); 59 if (status >= 0) 60 return 0; 61 62 /* 63 * Check for errors 64 * -ENODEV: Device has disappeared, no point continuing. 65 * All other errors: Try again. 66 */ 67 else if (status == -ENODEV) { 68 clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); 69 break; 70 } 71 } 72 73 ERROR(rt2x00dev, 74 "Vendor Request 0x%02x failed for offset 0x%04x with error %d.\n", 75 request, offset, status); 76 77 return status; 78} 79EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request); 80 81int rt2x00usb_vendor_req_buff_lock(struct rt2x00_dev *rt2x00dev, 82 const u8 request, const u8 requesttype, 83 const u16 offset, void *buffer, 84 const u16 buffer_length, const int timeout) 85{ 86 int status; 87 88 BUG_ON(!mutex_is_locked(&rt2x00dev->csr_mutex)); 89 90 /* 91 * Check for Cache availability. 92 */ 93 if (unlikely(!rt2x00dev->csr.cache || buffer_length > CSR_CACHE_SIZE)) { 94 ERROR(rt2x00dev, "CSR cache not available.\n"); 95 return -ENOMEM; 96 } 97 98 if (requesttype == USB_VENDOR_REQUEST_OUT) 99 memcpy(rt2x00dev->csr.cache, buffer, buffer_length); 100 101 status = rt2x00usb_vendor_request(rt2x00dev, request, requesttype, 102 offset, 0, rt2x00dev->csr.cache, 103 buffer_length, timeout); 104 105 if (!status && requesttype == USB_VENDOR_REQUEST_IN) 106 memcpy(buffer, rt2x00dev->csr.cache, buffer_length); 107 108 return status; 109} 110EXPORT_SYMBOL_GPL(rt2x00usb_vendor_req_buff_lock); 111 112int rt2x00usb_vendor_request_buff(struct rt2x00_dev *rt2x00dev, 113 const u8 request, const u8 requesttype, 114 const u16 offset, void *buffer, 115 const u16 buffer_length, const int timeout) 116{ 117 int status = 0; 118 unsigned char *tb; 119 u16 off, len, bsize; 120 121 mutex_lock(&rt2x00dev->csr_mutex); 122 123 tb = (char *)buffer; 124 off = offset; 125 len = buffer_length; 126 while (len && !status) { 127 bsize = min_t(u16, CSR_CACHE_SIZE, len); 128 status = rt2x00usb_vendor_req_buff_lock(rt2x00dev, request, 129 requesttype, off, tb, 130 bsize, timeout); 131 132 tb += bsize; 133 len -= bsize; 134 off += bsize; 135 } 136 137 mutex_unlock(&rt2x00dev->csr_mutex); 138 139 return status; 140} 141EXPORT_SYMBOL_GPL(rt2x00usb_vendor_request_buff); 142 143int rt2x00usb_regbusy_read(struct rt2x00_dev *rt2x00dev, 144 const unsigned int offset, 145 const struct rt2x00_field32 field, 146 u32 *reg) 147{ 148 unsigned int i; 149 150 if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags)) 151 return -ENODEV; 152 153 for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 154 rt2x00usb_register_read_lock(rt2x00dev, offset, reg); 155 if (!rt2x00_get_field32(*reg, field)) 156 return 1; 157 udelay(REGISTER_BUSY_DELAY); 158 } 159 160 ERROR(rt2x00dev, "Indirect register access failed: " 161 "offset=0x%.08x, value=0x%.08x\n", offset, *reg); 162 *reg = ~0; 163 164 return 0; 165} 166EXPORT_SYMBOL_GPL(rt2x00usb_regbusy_read); 167 168 169struct rt2x00_async_read_data { 170 __le32 reg; 171 struct usb_ctrlrequest cr; 172 struct rt2x00_dev *rt2x00dev; 173 bool (*callback)(struct rt2x00_dev *, int, u32); 174}; 175 176static void rt2x00usb_register_read_async_cb(struct urb *urb) 177{ 178 struct rt2x00_async_read_data *rd = urb->context; 179 if (rd->callback(rd->rt2x00dev, urb->status, le32_to_cpu(rd->reg))) { 180 if (usb_submit_urb(urb, GFP_ATOMIC) < 0) 181 kfree(rd); 182 } else 183 kfree(rd); 184} 185 186void rt2x00usb_register_read_async(struct rt2x00_dev *rt2x00dev, 187 const unsigned int offset, 188 bool (*callback)(struct rt2x00_dev*, int, u32)) 189{ 190 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev); 191 struct urb *urb; 192 struct rt2x00_async_read_data *rd; 193 194 rd = kmalloc(sizeof(*rd), GFP_ATOMIC); 195 if (!rd) 196 return; 197 198 urb = usb_alloc_urb(0, GFP_ATOMIC); 199 if (!urb) { 200 kfree(rd); 201 return; 202 } 203 204 rd->rt2x00dev = rt2x00dev; 205 rd->callback = callback; 206 rd->cr.bRequestType = USB_VENDOR_REQUEST_IN; 207 rd->cr.bRequest = USB_MULTI_READ; 208 rd->cr.wValue = 0; 209 rd->cr.wIndex = cpu_to_le16(offset); 210 rd->cr.wLength = cpu_to_le16(sizeof(u32)); 211 212 usb_fill_control_urb(urb, usb_dev, usb_rcvctrlpipe(usb_dev, 0), 213 (unsigned char *)(&rd->cr), &rd->reg, sizeof(rd->reg), 214 rt2x00usb_register_read_async_cb, rd); 215 if (usb_submit_urb(urb, GFP_ATOMIC) < 0) 216 kfree(rd); 217 usb_free_urb(urb); 218} 219EXPORT_SYMBOL_GPL(rt2x00usb_register_read_async); 220 221/* 222 * TX data handlers. 223 */ 224static void rt2x00usb_work_txdone_entry(struct queue_entry *entry) 225{ 226 /* 227 * If the transfer to hardware succeeded, it does not mean the 228 * frame was send out correctly. It only means the frame 229 * was successfully pushed to the hardware, we have no 230 * way to determine the transmission status right now. 231 * (Only indirectly by looking at the failed TX counters 232 * in the register). 233 */ 234 if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags)) 235 rt2x00lib_txdone_noinfo(entry, TXDONE_FAILURE); 236 else 237 rt2x00lib_txdone_noinfo(entry, TXDONE_UNKNOWN); 238} 239 240static void rt2x00usb_work_txdone(struct work_struct *work) 241{ 242 struct rt2x00_dev *rt2x00dev = 243 container_of(work, struct rt2x00_dev, txdone_work); 244 struct data_queue *queue; 245 struct queue_entry *entry; 246 247 tx_queue_for_each(rt2x00dev, queue) { 248 while (!rt2x00queue_empty(queue)) { 249 entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE); 250 251 if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) || 252 !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags)) 253 break; 254 255 rt2x00usb_work_txdone_entry(entry); 256 } 257 } 258} 259 260static void rt2x00usb_interrupt_txdone(struct urb *urb) 261{ 262 struct queue_entry *entry = (struct queue_entry *)urb->context; 263 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 264 265 if (!test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags)) 266 return; 267 /* 268 * Check if the frame was correctly uploaded 269 */ 270 if (urb->status) 271 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags); 272 /* 273 * Report the frame as DMA done 274 */ 275 rt2x00lib_dmadone(entry); 276 277 if (rt2x00dev->ops->lib->tx_dma_done) 278 rt2x00dev->ops->lib->tx_dma_done(entry); 279 /* 280 * Schedule the delayed work for reading the TX status 281 * from the device. 282 */ 283 if (!test_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags) || 284 !kfifo_is_empty(&rt2x00dev->txstatus_fifo)) 285 queue_work(rt2x00dev->workqueue, &rt2x00dev->txdone_work); 286} 287 288static bool rt2x00usb_kick_tx_entry(struct queue_entry *entry, void* data) 289{ 290 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 291 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev); 292 struct queue_entry_priv_usb *entry_priv = entry->priv_data; 293 u32 length; 294 int status; 295 296 if (!test_and_clear_bit(ENTRY_DATA_PENDING, &entry->flags) || 297 test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags)) 298 return false; 299 300 /* 301 * USB devices require certain padding at the end of each frame 302 * and urb. Those paddings are not included in skbs. Pass entry 303 * to the driver to determine what the overall length should be. 304 */ 305 length = rt2x00dev->ops->lib->get_tx_data_len(entry); 306 307 status = skb_padto(entry->skb, length); 308 if (unlikely(status)) { 309 /* TODO: report something more appropriate than IO_FAILED. */ 310 WARNING(rt2x00dev, "TX SKB padding error, out of memory\n"); 311 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags); 312 rt2x00lib_dmadone(entry); 313 314 return false; 315 } 316 317 usb_fill_bulk_urb(entry_priv->urb, usb_dev, 318 usb_sndbulkpipe(usb_dev, entry->queue->usb_endpoint), 319 entry->skb->data, length, 320 rt2x00usb_interrupt_txdone, entry); 321 322 status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC); 323 if (status) { 324 if (status == -ENODEV) 325 clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); 326 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags); 327 rt2x00lib_dmadone(entry); 328 } 329 330 return false; 331} 332 333/* 334 * RX data handlers. 335 */ 336static void rt2x00usb_work_rxdone(struct work_struct *work) 337{ 338 struct rt2x00_dev *rt2x00dev = 339 container_of(work, struct rt2x00_dev, rxdone_work); 340 struct queue_entry *entry; 341 struct skb_frame_desc *skbdesc; 342 u8 rxd[32]; 343 344 while (!rt2x00queue_empty(rt2x00dev->rx)) { 345 entry = rt2x00queue_get_entry(rt2x00dev->rx, Q_INDEX_DONE); 346 347 if (test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) || 348 !test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags)) 349 break; 350 351 /* 352 * Fill in desc fields of the skb descriptor 353 */ 354 skbdesc = get_skb_frame_desc(entry->skb); 355 skbdesc->desc = rxd; 356 skbdesc->desc_len = entry->queue->desc_size; 357 358 /* 359 * Send the frame to rt2x00lib for further processing. 360 */ 361 rt2x00lib_rxdone(entry); 362 } 363} 364 365static void rt2x00usb_interrupt_rxdone(struct urb *urb) 366{ 367 struct queue_entry *entry = (struct queue_entry *)urb->context; 368 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 369 370 if (!test_and_clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags)) 371 return; 372 373 /* 374 * Report the frame as DMA done 375 */ 376 rt2x00lib_dmadone(entry); 377 378 /* 379 * Check if the received data is simply too small 380 * to be actually valid, or if the urb is signaling 381 * a problem. 382 */ 383 if (urb->actual_length < entry->queue->desc_size || urb->status) 384 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags); 385 386 /* 387 * Schedule the delayed work for reading the RX status 388 * from the device. 389 */ 390 queue_work(rt2x00dev->workqueue, &rt2x00dev->rxdone_work); 391} 392 393static bool rt2x00usb_kick_rx_entry(struct queue_entry *entry, void* data) 394{ 395 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 396 struct usb_device *usb_dev = to_usb_device_intf(rt2x00dev->dev); 397 struct queue_entry_priv_usb *entry_priv = entry->priv_data; 398 int status; 399 400 if (test_and_set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags) || 401 test_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags)) 402 return false; 403 404 rt2x00lib_dmastart(entry); 405 406 usb_fill_bulk_urb(entry_priv->urb, usb_dev, 407 usb_rcvbulkpipe(usb_dev, entry->queue->usb_endpoint), 408 entry->skb->data, entry->skb->len, 409 rt2x00usb_interrupt_rxdone, entry); 410 411 status = usb_submit_urb(entry_priv->urb, GFP_ATOMIC); 412 if (status) { 413 if (status == -ENODEV) 414 clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags); 415 set_bit(ENTRY_DATA_IO_FAILED, &entry->flags); 416 rt2x00lib_dmadone(entry); 417 } 418 419 return false; 420} 421 422void rt2x00usb_kick_queue(struct data_queue *queue) 423{ 424 switch (queue->qid) { 425 case QID_AC_VO: 426 case QID_AC_VI: 427 case QID_AC_BE: 428 case QID_AC_BK: 429 if (!rt2x00queue_empty(queue)) 430 rt2x00queue_for_each_entry(queue, 431 Q_INDEX_DONE, 432 Q_INDEX, 433 NULL, 434 rt2x00usb_kick_tx_entry); 435 break; 436 case QID_RX: 437 if (!rt2x00queue_full(queue)) 438 rt2x00queue_for_each_entry(queue, 439 Q_INDEX_DONE, 440 Q_INDEX, 441 NULL, 442 rt2x00usb_kick_rx_entry); 443 break; 444 default: 445 break; 446 } 447} 448EXPORT_SYMBOL_GPL(rt2x00usb_kick_queue); 449 450static bool rt2x00usb_flush_entry(struct queue_entry *entry, void* data) 451{ 452 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev; 453 struct queue_entry_priv_usb *entry_priv = entry->priv_data; 454 struct queue_entry_priv_usb_bcn *bcn_priv = entry->priv_data; 455 456 if (!test_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags)) 457 return false; 458 459 usb_kill_urb(entry_priv->urb); 460 461 /* 462 * Kill guardian urb (if required by driver). 463 */ 464 if ((entry->queue->qid == QID_BEACON) && 465 (test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags))) 466 usb_kill_urb(bcn_priv->guardian_urb); 467 468 return false; 469} 470 471void rt2x00usb_flush_queue(struct data_queue *queue, bool drop) 472{ 473 struct work_struct *completion; 474 unsigned int i; 475 476 if (drop) 477 rt2x00queue_for_each_entry(queue, Q_INDEX_DONE, Q_INDEX, NULL, 478 rt2x00usb_flush_entry); 479 480 /* 481 * Obtain the queue completion handler 482 */ 483 switch (queue->qid) { 484 case QID_AC_VO: 485 case QID_AC_VI: 486 case QID_AC_BE: 487 case QID_AC_BK: 488 completion = &queue->rt2x00dev->txdone_work; 489 break; 490 case QID_RX: 491 completion = &queue->rt2x00dev->rxdone_work; 492 break; 493 default: 494 return; 495 } 496 497 for (i = 0; i < 10; i++) { 498 /* 499 * Check if the driver is already done, otherwise we 500 * have to sleep a little while to give the driver/hw 501 * the oppurtunity to complete interrupt process itself. 502 */ 503 if (rt2x00queue_empty(queue)) 504 break; 505 506 /* 507 * Schedule the completion handler manually, when this 508 * worker function runs, it should cleanup the queue. 509 */ 510 queue_work(queue->rt2x00dev->workqueue, completion); 511 512 /* 513 * Wait for a little while to give the driver 514 * the oppurtunity to recover itself. 515 */ 516 msleep(10); 517 } 518} 519EXPORT_SYMBOL_GPL(rt2x00usb_flush_queue); 520 521static void rt2x00usb_watchdog_tx_dma(struct data_queue *queue) 522{ 523 WARNING(queue->rt2x00dev, "TX queue %d DMA timed out," 524 " invoke forced forced reset\n", queue->qid); 525 526 rt2x00queue_flush_queue(queue, true); 527} 528 529static void rt2x00usb_watchdog_tx_status(struct data_queue *queue) 530{ 531 WARNING(queue->rt2x00dev, "TX queue %d status timed out," 532 " invoke forced tx handler\n", queue->qid); 533 534 queue_work(queue->rt2x00dev->workqueue, &queue->rt2x00dev->txdone_work); 535} 536 537static int rt2x00usb_status_timeout(struct data_queue *queue) 538{ 539 struct queue_entry *entry; 540 541 entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE); 542 return rt2x00queue_status_timeout(entry); 543} 544 545static int rt2x00usb_dma_timeout(struct data_queue *queue) 546{ 547 struct queue_entry *entry; 548 549 entry = rt2x00queue_get_entry(queue, Q_INDEX_DMA_DONE); 550 return rt2x00queue_dma_timeout(entry); 551} 552 553void rt2x00usb_watchdog(struct rt2x00_dev *rt2x00dev) 554{ 555 struct data_queue *queue; 556 557 tx_queue_for_each(rt2x00dev, queue) { 558 if (!rt2x00queue_empty(queue)) { 559 if (rt2x00usb_dma_timeout(queue)) 560 rt2x00usb_watchdog_tx_dma(queue); 561 if (rt2x00usb_status_timeout(queue)) 562 rt2x00usb_watchdog_tx_status(queue); 563 } 564 } 565} 566EXPORT_SYMBOL_GPL(rt2x00usb_watchdog); 567 568/* 569 * Radio handlers 570 */ 571void rt2x00usb_disable_radio(struct rt2x00_dev *rt2x00dev) 572{ 573 rt2x00usb_vendor_request_sw(rt2x00dev, USB_RX_CONTROL, 0, 0, 574 REGISTER_TIMEOUT); 575} 576EXPORT_SYMBOL_GPL(rt2x00usb_disable_radio); 577 578/* 579 * Device initialization handlers. 580 */ 581void rt2x00usb_clear_entry(struct queue_entry *entry) 582{ 583 entry->flags = 0; 584 585 if (entry->queue->qid == QID_RX) 586 rt2x00usb_kick_rx_entry(entry, NULL); 587} 588EXPORT_SYMBOL_GPL(rt2x00usb_clear_entry); 589 590static void rt2x00usb_assign_endpoint(struct data_queue *queue, 591 struct usb_endpoint_descriptor *ep_desc) 592{ 593 struct usb_device *usb_dev = to_usb_device_intf(queue->rt2x00dev->dev); 594 int pipe; 595 596 queue->usb_endpoint = usb_endpoint_num(ep_desc); 597 598 if (queue->qid == QID_RX) { 599 pipe = usb_rcvbulkpipe(usb_dev, queue->usb_endpoint); 600 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 0); 601 } else { 602 pipe = usb_sndbulkpipe(usb_dev, queue->usb_endpoint); 603 queue->usb_maxpacket = usb_maxpacket(usb_dev, pipe, 1); 604 } 605 606 if (!queue->usb_maxpacket) 607 queue->usb_maxpacket = 1; 608} 609 610static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev) 611{ 612 struct usb_interface *intf = to_usb_interface(rt2x00dev->dev); 613 struct usb_host_interface *intf_desc = intf->cur_altsetting; 614 struct usb_endpoint_descriptor *ep_desc; 615 struct data_queue *queue = rt2x00dev->tx; 616 struct usb_endpoint_descriptor *tx_ep_desc = NULL; 617 unsigned int i; 618 619 /* 620 * Walk through all available endpoints to search for "bulk in" 621 * and "bulk out" endpoints. When we find such endpoints collect 622 * the information we need from the descriptor and assign it 623 * to the queue. 624 */ 625 for (i = 0; i < intf_desc->desc.bNumEndpoints; i++) { 626 ep_desc = &intf_desc->endpoint[i].desc; 627 628 if (usb_endpoint_is_bulk_in(ep_desc)) { 629 rt2x00usb_assign_endpoint(rt2x00dev->rx, ep_desc); 630 } else if (usb_endpoint_is_bulk_out(ep_desc) && 631 (queue != queue_end(rt2x00dev))) { 632 rt2x00usb_assign_endpoint(queue, ep_desc); 633 queue = queue_next(queue); 634 635 tx_ep_desc = ep_desc; 636 } 637 } 638 639 /* 640 * At least 1 endpoint for RX and 1 endpoint for TX must be available. 641 */ 642 if (!rt2x00dev->rx->usb_endpoint || !rt2x00dev->tx->usb_endpoint) { 643 ERROR(rt2x00dev, "Bulk-in/Bulk-out endpoints not found\n"); 644 return -EPIPE; 645 } 646 647 /* 648 * It might be possible not all queues have a dedicated endpoint. 649 * Loop through all TX queues and copy the endpoint information 650 * which we have gathered from already assigned endpoints. 651 */ 652 txall_queue_for_each(rt2x00dev, queue) { 653 if (!queue->usb_endpoint) 654 rt2x00usb_assign_endpoint(queue, tx_ep_desc); 655 } 656 657 return 0; 658} 659 660static int rt2x00usb_alloc_entries(struct data_queue *queue) 661{ 662 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev; 663 struct queue_entry_priv_usb *entry_priv; 664 struct queue_entry_priv_usb_bcn *bcn_priv; 665 unsigned int i; 666 667 for (i = 0; i < queue->limit; i++) { 668 entry_priv = queue->entries[i].priv_data; 669 entry_priv->urb = usb_alloc_urb(0, GFP_KERNEL); 670 if (!entry_priv->urb) 671 return -ENOMEM; 672 } 673 674 /* 675 * If this is not the beacon queue or 676 * no guardian byte was required for the beacon, 677 * then we are done. 678 */ 679 if (queue->qid != QID_BEACON || 680 !test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags)) 681 return 0; 682 683 for (i = 0; i < queue->limit; i++) { 684 bcn_priv = queue->entries[i].priv_data; 685 bcn_priv->guardian_urb = usb_alloc_urb(0, GFP_KERNEL); 686 if (!bcn_priv->guardian_urb) 687 return -ENOMEM; 688 } 689 690 return 0; 691} 692 693static void rt2x00usb_free_entries(struct data_queue *queue) 694{ 695 struct rt2x00_dev *rt2x00dev = queue->rt2x00dev; 696 struct queue_entry_priv_usb *entry_priv; 697 struct queue_entry_priv_usb_bcn *bcn_priv; 698 unsigned int i; 699 700 if (!queue->entries) 701 return; 702 703 for (i = 0; i < queue->limit; i++) { 704 entry_priv = queue->entries[i].priv_data; 705 usb_kill_urb(entry_priv->urb); 706 usb_free_urb(entry_priv->urb); 707 } 708 709 /* 710 * If this is not the beacon queue or 711 * no guardian byte was required for the beacon, 712 * then we are done. 713 */ 714 if (queue->qid != QID_BEACON || 715 !test_bit(REQUIRE_BEACON_GUARD, &rt2x00dev->cap_flags)) 716 return; 717 718 for (i = 0; i < queue->limit; i++) { 719 bcn_priv = queue->entries[i].priv_data; 720 usb_kill_urb(bcn_priv->guardian_urb); 721 usb_free_urb(bcn_priv->guardian_urb); 722 } 723} 724 725int rt2x00usb_initialize(struct rt2x00_dev *rt2x00dev) 726{ 727 struct data_queue *queue; 728 int status; 729 730 /* 731 * Find endpoints for each queue 732 */ 733 status = rt2x00usb_find_endpoints(rt2x00dev); 734 if (status) 735 goto exit; 736 737 /* 738 * Allocate DMA 739 */ 740 queue_for_each(rt2x00dev, queue) { 741 status = rt2x00usb_alloc_entries(queue); 742 if (status) 743 goto exit; 744 } 745 746 return 0; 747 748exit: 749 rt2x00usb_uninitialize(rt2x00dev); 750 751 return status; 752} 753EXPORT_SYMBOL_GPL(rt2x00usb_initialize); 754 755void rt2x00usb_uninitialize(struct rt2x00_dev *rt2x00dev) 756{ 757 struct data_queue *queue; 758 759 queue_for_each(rt2x00dev, queue) 760 rt2x00usb_free_entries(queue); 761} 762EXPORT_SYMBOL_GPL(rt2x00usb_uninitialize); 763 764/* 765 * USB driver handlers. 766 */ 767static void rt2x00usb_free_reg(struct rt2x00_dev *rt2x00dev) 768{ 769 kfree(rt2x00dev->rf); 770 rt2x00dev->rf = NULL; 771 772 kfree(rt2x00dev->eeprom); 773 rt2x00dev->eeprom = NULL; 774 775 kfree(rt2x00dev->csr.cache); 776 rt2x00dev->csr.cache = NULL; 777} 778 779static int rt2x00usb_alloc_reg(struct rt2x00_dev *rt2x00dev) 780{ 781 rt2x00dev->csr.cache = kzalloc(CSR_CACHE_SIZE, GFP_KERNEL); 782 if (!rt2x00dev->csr.cache) 783 goto exit; 784 785 rt2x00dev->eeprom = kzalloc(rt2x00dev->ops->eeprom_size, GFP_KERNEL); 786 if (!rt2x00dev->eeprom) 787 goto exit; 788 789 rt2x00dev->rf = kzalloc(rt2x00dev->ops->rf_size, GFP_KERNEL); 790 if (!rt2x00dev->rf) 791 goto exit; 792 793 return 0; 794 795exit: 796 ERROR_PROBE("Failed to allocate registers.\n"); 797 798 rt2x00usb_free_reg(rt2x00dev); 799 800 return -ENOMEM; 801} 802 803int rt2x00usb_probe(struct usb_interface *usb_intf, 804 const struct rt2x00_ops *ops) 805{ 806 struct usb_device *usb_dev = interface_to_usbdev(usb_intf); 807 struct ieee80211_hw *hw; 808 struct rt2x00_dev *rt2x00dev; 809 int retval; 810 811 usb_dev = usb_get_dev(usb_dev); 812 usb_reset_device(usb_dev); 813 814 hw = ieee80211_alloc_hw(sizeof(struct rt2x00_dev), ops->hw); 815 if (!hw) { 816 ERROR_PROBE("Failed to allocate hardware.\n"); 817 retval = -ENOMEM; 818 goto exit_put_device; 819 } 820 821 usb_set_intfdata(usb_intf, hw); 822 823 rt2x00dev = hw->priv; 824 rt2x00dev->dev = &usb_intf->dev; 825 rt2x00dev->ops = ops; 826 rt2x00dev->hw = hw; 827 828 rt2x00_set_chip_intf(rt2x00dev, RT2X00_CHIP_INTF_USB); 829 830 INIT_WORK(&rt2x00dev->rxdone_work, rt2x00usb_work_rxdone); 831 INIT_WORK(&rt2x00dev->txdone_work, rt2x00usb_work_txdone); 832 init_timer(&rt2x00dev->txstatus_timer); 833 834 retval = rt2x00usb_alloc_reg(rt2x00dev); 835 if (retval) 836 goto exit_free_device; 837 838 retval = rt2x00lib_probe_dev(rt2x00dev); 839 if (retval) 840 goto exit_free_reg; 841 842 return 0; 843 844exit_free_reg: 845 rt2x00usb_free_reg(rt2x00dev); 846 847exit_free_device: 848 ieee80211_free_hw(hw); 849 850exit_put_device: 851 usb_put_dev(usb_dev); 852 853 usb_set_intfdata(usb_intf, NULL); 854 855 return retval; 856} 857EXPORT_SYMBOL_GPL(rt2x00usb_probe); 858 859void rt2x00usb_disconnect(struct usb_interface *usb_intf) 860{ 861 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf); 862 struct rt2x00_dev *rt2x00dev = hw->priv; 863 864 /* 865 * Free all allocated data. 866 */ 867 rt2x00lib_remove_dev(rt2x00dev); 868 rt2x00usb_free_reg(rt2x00dev); 869 ieee80211_free_hw(hw); 870 871 /* 872 * Free the USB device data. 873 */ 874 usb_set_intfdata(usb_intf, NULL); 875 usb_put_dev(interface_to_usbdev(usb_intf)); 876} 877EXPORT_SYMBOL_GPL(rt2x00usb_disconnect); 878 879#ifdef CONFIG_PM 880int rt2x00usb_suspend(struct usb_interface *usb_intf, pm_message_t state) 881{ 882 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf); 883 struct rt2x00_dev *rt2x00dev = hw->priv; 884 885 return rt2x00lib_suspend(rt2x00dev, state); 886} 887EXPORT_SYMBOL_GPL(rt2x00usb_suspend); 888 889int rt2x00usb_resume(struct usb_interface *usb_intf) 890{ 891 struct ieee80211_hw *hw = usb_get_intfdata(usb_intf); 892 struct rt2x00_dev *rt2x00dev = hw->priv; 893 894 return rt2x00lib_resume(rt2x00dev); 895} 896EXPORT_SYMBOL_GPL(rt2x00usb_resume); 897#endif /* CONFIG_PM */ 898 899/* 900 * rt2x00usb module information. 901 */ 902MODULE_AUTHOR(DRV_PROJECT); 903MODULE_VERSION(DRV_VERSION); 904MODULE_DESCRIPTION("rt2x00 usb library"); 905MODULE_LICENSE("GPL"); 906