1/* 2 Copyright (C) 2009 Ivo van Doorn <IvDoorn@gmail.com> 3 Copyright (C) 2009 Mattias Nissler <mattias.nissler@gmx.de> 4 Copyright (C) 2009 Felix Fietkau <nbd@openwrt.org> 5 Copyright (C) 2009 Xose Vazquez Perez <xose.vazquez@gmail.com> 6 Copyright (C) 2009 Axel Kollhofer <rain_maker@root-forum.org> 7 <http://rt2x00.serialmonkey.com> 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the 21 Free Software Foundation, Inc., 22 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 23 */ 24 25/* 26 Module: rt2800usb 27 Abstract: rt2800usb device specific routines. 28 Supported chipsets: RT2800U. 29 */ 30 31#include <linux/delay.h> 32#include <linux/etherdevice.h> 33#include <linux/init.h> 34#include <linux/kernel.h> 35#include <linux/module.h> 36#include <linux/usb.h> 37 38#include "rt2x00.h" 39#include "rt2x00usb.h" 40#include "rt2800lib.h" 41#include "rt2800.h" 42#include "rt2800usb.h" 43 44/* 45 * Allow hardware encryption to be disabled. 46 */ 47static int modparam_nohwcrypt = 0; 48module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO); 49MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption."); 50 51/* 52 * Firmware functions 53 */ 54static char *rt2800usb_get_firmware_name(struct rt2x00_dev *rt2x00dev) 55{ 56 return FIRMWARE_RT2870; 57} 58 59static int rt2800usb_write_firmware(struct rt2x00_dev *rt2x00dev, 60 const u8 *data, const size_t len) 61{ 62 int status; 63 u32 offset; 64 u32 length; 65 66 /* 67 * Check which section of the firmware we need. 68 */ 69 if (rt2x00_rt(rt2x00dev, RT2860) || 70 rt2x00_rt(rt2x00dev, RT2872) || 71 rt2x00_rt(rt2x00dev, RT3070)) { 72 offset = 0; 73 length = 4096; 74 } else { 75 offset = 4096; 76 length = 4096; 77 } 78 79 /* 80 * Write firmware to device. 81 */ 82 rt2800_register_multiwrite(rt2x00dev, FIRMWARE_IMAGE_BASE, 83 data + offset, length); 84 85 rt2800_register_write(rt2x00dev, H2M_MAILBOX_CID, ~0); 86 rt2800_register_write(rt2x00dev, H2M_MAILBOX_STATUS, ~0); 87 88 /* 89 * Send firmware request to device to load firmware, 90 * we need to specify a long timeout time. 91 */ 92 status = rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, 93 0, USB_MODE_FIRMWARE, 94 REGISTER_TIMEOUT_FIRMWARE); 95 if (status < 0) { 96 ERROR(rt2x00dev, "Failed to write Firmware to device.\n"); 97 return status; 98 } 99 100 msleep(10); 101 rt2800_register_write(rt2x00dev, H2M_MAILBOX_CSR, 0); 102 103 /* 104 * Send signal to firmware during boot time. 105 */ 106 rt2800_mcu_request(rt2x00dev, MCU_BOOT_SIGNAL, 0, 0, 0); 107 108 if (rt2x00_rt(rt2x00dev, RT3070) || 109 rt2x00_rt(rt2x00dev, RT3071) || 110 rt2x00_rt(rt2x00dev, RT3572)) { 111 udelay(200); 112 rt2800_mcu_request(rt2x00dev, MCU_CURRENT, 0, 0, 0); 113 udelay(10); 114 } 115 116 return 0; 117} 118 119/* 120 * Device state switch handlers. 121 */ 122static void rt2800usb_toggle_rx(struct rt2x00_dev *rt2x00dev, 123 enum dev_state state) 124{ 125 u32 reg; 126 127 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, ®); 128 rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_RX, 129 (state == STATE_RADIO_RX_ON) || 130 (state == STATE_RADIO_RX_ON_LINK)); 131 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 132} 133 134static int rt2800usb_init_registers(struct rt2x00_dev *rt2x00dev) 135{ 136 u32 reg; 137 int i; 138 139 /* 140 * Wait until BBP and RF are ready. 141 */ 142 for (i = 0; i < REGISTER_BUSY_COUNT; i++) { 143 rt2800_register_read(rt2x00dev, MAC_CSR0, ®); 144 if (reg && reg != ~0) 145 break; 146 msleep(1); 147 } 148 149 if (i == REGISTER_BUSY_COUNT) { 150 ERROR(rt2x00dev, "Unstable hardware.\n"); 151 return -EBUSY; 152 } 153 154 rt2800_register_read(rt2x00dev, PBF_SYS_CTRL, ®); 155 rt2800_register_write(rt2x00dev, PBF_SYS_CTRL, reg & ~0x00002000); 156 157 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, ®); 158 rt2x00_set_field32(®, MAC_SYS_CTRL_RESET_CSR, 1); 159 rt2x00_set_field32(®, MAC_SYS_CTRL_RESET_BBP, 1); 160 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 161 162 rt2800_register_write(rt2x00dev, USB_DMA_CFG, 0x00000000); 163 164 rt2x00usb_vendor_request_sw(rt2x00dev, USB_DEVICE_MODE, 0, 165 USB_MODE_RESET, REGISTER_TIMEOUT); 166 167 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, 0x00000000); 168 169 return 0; 170} 171 172static int rt2800usb_enable_radio(struct rt2x00_dev *rt2x00dev) 173{ 174 u32 reg; 175 u16 word; 176 177 /* 178 * Initialize all registers. 179 */ 180 if (unlikely(rt2800_wait_wpdma_ready(rt2x00dev) || 181 rt2800_init_registers(rt2x00dev) || 182 rt2800_init_bbp(rt2x00dev) || 183 rt2800_init_rfcsr(rt2x00dev))) 184 return -EIO; 185 186 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, ®); 187 rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_TX, 1); 188 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 189 190 udelay(50); 191 192 rt2800_register_read(rt2x00dev, WPDMA_GLO_CFG, ®); 193 rt2x00_set_field32(®, WPDMA_GLO_CFG_TX_WRITEBACK_DONE, 1); 194 rt2x00_set_field32(®, WPDMA_GLO_CFG_ENABLE_RX_DMA, 1); 195 rt2x00_set_field32(®, WPDMA_GLO_CFG_ENABLE_TX_DMA, 1); 196 rt2800_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 197 198 199 rt2800_register_read(rt2x00dev, USB_DMA_CFG, ®); 200 rt2x00_set_field32(®, USB_DMA_CFG_PHY_CLEAR, 0); 201 rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_EN, 0); 202 rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_TIMEOUT, 128); 203 /* 204 * Total room for RX frames in kilobytes, PBF might still exceed 205 * this limit so reduce the number to prevent errors. 206 */ 207 rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_AGG_LIMIT, 208 ((RX_ENTRIES * DATA_FRAME_SIZE) / 1024) - 3); 209 rt2x00_set_field32(®, USB_DMA_CFG_RX_BULK_EN, 1); 210 rt2x00_set_field32(®, USB_DMA_CFG_TX_BULK_EN, 1); 211 rt2800_register_write(rt2x00dev, USB_DMA_CFG, reg); 212 213 rt2800_register_read(rt2x00dev, MAC_SYS_CTRL, ®); 214 rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_TX, 1); 215 rt2x00_set_field32(®, MAC_SYS_CTRL_ENABLE_RX, 1); 216 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, reg); 217 218 /* 219 * Initialize LED control 220 */ 221 rt2x00_eeprom_read(rt2x00dev, EEPROM_LED1, &word); 222 rt2800_mcu_request(rt2x00dev, MCU_LED_1, 0xff, 223 word & 0xff, (word >> 8) & 0xff); 224 225 rt2x00_eeprom_read(rt2x00dev, EEPROM_LED2, &word); 226 rt2800_mcu_request(rt2x00dev, MCU_LED_2, 0xff, 227 word & 0xff, (word >> 8) & 0xff); 228 229 rt2x00_eeprom_read(rt2x00dev, EEPROM_LED3, &word); 230 rt2800_mcu_request(rt2x00dev, MCU_LED_3, 0xff, 231 word & 0xff, (word >> 8) & 0xff); 232 233 return 0; 234} 235 236static void rt2800usb_disable_radio(struct rt2x00_dev *rt2x00dev) 237{ 238 u32 reg; 239 240 rt2800_register_read(rt2x00dev, WPDMA_GLO_CFG, ®); 241 rt2x00_set_field32(®, WPDMA_GLO_CFG_ENABLE_TX_DMA, 0); 242 rt2x00_set_field32(®, WPDMA_GLO_CFG_ENABLE_RX_DMA, 0); 243 rt2800_register_write(rt2x00dev, WPDMA_GLO_CFG, reg); 244 245 rt2800_register_write(rt2x00dev, MAC_SYS_CTRL, 0); 246 rt2800_register_write(rt2x00dev, PWR_PIN_CFG, 0); 247 rt2800_register_write(rt2x00dev, TX_PIN_CFG, 0); 248 249 /* Wait for DMA, ignore error */ 250 rt2800_wait_wpdma_ready(rt2x00dev); 251 252 rt2x00usb_disable_radio(rt2x00dev); 253} 254 255static int rt2800usb_set_state(struct rt2x00_dev *rt2x00dev, 256 enum dev_state state) 257{ 258 if (state == STATE_AWAKE) 259 rt2800_mcu_request(rt2x00dev, MCU_WAKEUP, 0xff, 0, 0); 260 else 261 rt2800_mcu_request(rt2x00dev, MCU_SLEEP, 0xff, 0, 2); 262 263 return 0; 264} 265 266static int rt2800usb_set_device_state(struct rt2x00_dev *rt2x00dev, 267 enum dev_state state) 268{ 269 int retval = 0; 270 271 switch (state) { 272 case STATE_RADIO_ON: 273 /* 274 * Before the radio can be enabled, the device first has 275 * to be woken up. After that it needs a bit of time 276 * to be fully awake and then the radio can be enabled. 277 */ 278 rt2800usb_set_state(rt2x00dev, STATE_AWAKE); 279 msleep(1); 280 retval = rt2800usb_enable_radio(rt2x00dev); 281 break; 282 case STATE_RADIO_OFF: 283 /* 284 * After the radio has been disabled, the device should 285 * be put to sleep for powersaving. 286 */ 287 rt2800usb_disable_radio(rt2x00dev); 288 rt2800usb_set_state(rt2x00dev, STATE_SLEEP); 289 break; 290 case STATE_RADIO_RX_ON: 291 case STATE_RADIO_RX_ON_LINK: 292 case STATE_RADIO_RX_OFF: 293 case STATE_RADIO_RX_OFF_LINK: 294 rt2800usb_toggle_rx(rt2x00dev, state); 295 break; 296 case STATE_RADIO_IRQ_ON: 297 case STATE_RADIO_IRQ_ON_ISR: 298 case STATE_RADIO_IRQ_OFF: 299 case STATE_RADIO_IRQ_OFF_ISR: 300 /* No support, but no error either */ 301 break; 302 case STATE_DEEP_SLEEP: 303 case STATE_SLEEP: 304 case STATE_STANDBY: 305 case STATE_AWAKE: 306 retval = rt2800usb_set_state(rt2x00dev, state); 307 break; 308 default: 309 retval = -ENOTSUPP; 310 break; 311 } 312 313 if (unlikely(retval)) 314 ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n", 315 state, retval); 316 317 return retval; 318} 319 320/* 321 * TX descriptor initialization 322 */ 323static void rt2800usb_write_tx_data(struct queue_entry* entry, 324 struct txentry_desc *txdesc) 325{ 326 __le32 *txwi = (__le32 *) (entry->skb->data + TXINFO_DESC_SIZE); 327 328 rt2800_write_txwi(txwi, txdesc); 329} 330 331 332static void rt2800usb_write_tx_desc(struct rt2x00_dev *rt2x00dev, 333 struct sk_buff *skb, 334 struct txentry_desc *txdesc) 335{ 336 struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb); 337 __le32 *txi = (__le32 *) skb->data; 338 u32 word; 339 340 /* 341 * Initialize TXINFO descriptor 342 */ 343 rt2x00_desc_read(txi, 0, &word); 344 rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_PKT_LEN, 345 skb->len - TXINFO_DESC_SIZE); 346 rt2x00_set_field32(&word, TXINFO_W0_WIV, 347 !test_bit(ENTRY_TXD_ENCRYPT_IV, &txdesc->flags)); 348 rt2x00_set_field32(&word, TXINFO_W0_QSEL, 2); 349 rt2x00_set_field32(&word, TXINFO_W0_SW_USE_LAST_ROUND, 0); 350 rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_NEXT_VALID, 0); 351 rt2x00_set_field32(&word, TXINFO_W0_USB_DMA_TX_BURST, 352 test_bit(ENTRY_TXD_BURST, &txdesc->flags)); 353 rt2x00_desc_write(txi, 0, word); 354 355 /* 356 * Register descriptor details in skb frame descriptor. 357 */ 358 skbdesc->flags |= SKBDESC_DESC_IN_SKB; 359 skbdesc->desc = txi; 360 skbdesc->desc_len = TXINFO_DESC_SIZE + TXWI_DESC_SIZE; 361} 362 363/* 364 * TX data initialization 365 */ 366static int rt2800usb_get_tx_data_len(struct queue_entry *entry) 367{ 368 int length; 369 370 /* 371 * The length _must_ include 4 bytes padding, 372 * it should always be multiple of 4, 373 * but it must _not_ be a multiple of the USB packet size. 374 */ 375 length = roundup(entry->skb->len + 4, 4); 376 length += (4 * !(length % entry->queue->usb_maxpacket)); 377 378 return length; 379} 380 381/* 382 * RX control handlers 383 */ 384static void rt2800usb_fill_rxdone(struct queue_entry *entry, 385 struct rxdone_entry_desc *rxdesc) 386{ 387 struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb); 388 __le32 *rxi = (__le32 *)entry->skb->data; 389 __le32 *rxd; 390 u32 word; 391 int rx_pkt_len; 392 393 /* 394 * Copy descriptor to the skbdesc->desc buffer, making it safe from 395 * moving of frame data in rt2x00usb. 396 */ 397 memcpy(skbdesc->desc, rxi, skbdesc->desc_len); 398 399 /* 400 * RX frame format is : 401 * | RXINFO | RXWI | header | L2 pad | payload | pad | RXD | USB pad | 402 * |<------------ rx_pkt_len -------------->| 403 */ 404 rt2x00_desc_read(rxi, 0, &word); 405 rx_pkt_len = rt2x00_get_field32(word, RXINFO_W0_USB_DMA_RX_PKT_LEN); 406 407 /* 408 * Remove the RXINFO structure from the sbk. 409 */ 410 skb_pull(entry->skb, RXINFO_DESC_SIZE); 411 412 rxd = (__le32 *)(entry->skb->data + rx_pkt_len); 413 414 /* 415 * It is now safe to read the descriptor on all architectures. 416 */ 417 rt2x00_desc_read(rxd, 0, &word); 418 419 if (rt2x00_get_field32(word, RXD_W0_CRC_ERROR)) 420 rxdesc->flags |= RX_FLAG_FAILED_FCS_CRC; 421 422 rxdesc->cipher_status = rt2x00_get_field32(word, RXD_W0_CIPHER_ERROR); 423 424 if (rt2x00_get_field32(word, RXD_W0_DECRYPTED)) { 425 /* 426 * Hardware has stripped IV/EIV data from 802.11 frame during 427 * decryption. Unfortunately the descriptor doesn't contain 428 * any fields with the EIV/IV data either, so they can't 429 * be restored by rt2x00lib. 430 */ 431 rxdesc->flags |= RX_FLAG_IV_STRIPPED; 432 433 if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS) 434 rxdesc->flags |= RX_FLAG_DECRYPTED; 435 else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC) 436 rxdesc->flags |= RX_FLAG_MMIC_ERROR; 437 } 438 439 if (rt2x00_get_field32(word, RXD_W0_MY_BSS)) 440 rxdesc->dev_flags |= RXDONE_MY_BSS; 441 442 if (rt2x00_get_field32(word, RXD_W0_L2PAD)) 443 rxdesc->dev_flags |= RXDONE_L2PAD; 444 445 /* 446 * Remove RXD descriptor from end of buffer. 447 */ 448 skb_trim(entry->skb, rx_pkt_len); 449 450 /* 451 * Process the RXWI structure. 452 */ 453 rt2800_process_rxwi(entry, rxdesc); 454} 455 456/* 457 * Device probe functions. 458 */ 459static int rt2800usb_validate_eeprom(struct rt2x00_dev *rt2x00dev) 460{ 461 if (rt2800_efuse_detect(rt2x00dev)) 462 rt2800_read_eeprom_efuse(rt2x00dev); 463 else 464 rt2x00usb_eeprom_read(rt2x00dev, rt2x00dev->eeprom, 465 EEPROM_SIZE); 466 467 return rt2800_validate_eeprom(rt2x00dev); 468} 469 470static int rt2800usb_probe_hw(struct rt2x00_dev *rt2x00dev) 471{ 472 int retval; 473 474 /* 475 * Allocate eeprom data. 476 */ 477 retval = rt2800usb_validate_eeprom(rt2x00dev); 478 if (retval) 479 return retval; 480 481 retval = rt2800_init_eeprom(rt2x00dev); 482 if (retval) 483 return retval; 484 485 /* 486 * Initialize hw specifications. 487 */ 488 retval = rt2800_probe_hw_mode(rt2x00dev); 489 if (retval) 490 return retval; 491 492 /* 493 * This device has multiple filters for control frames 494 * and has a separate filter for PS Poll frames. 495 */ 496 __set_bit(DRIVER_SUPPORT_CONTROL_FILTERS, &rt2x00dev->flags); 497 __set_bit(DRIVER_SUPPORT_CONTROL_FILTER_PSPOLL, &rt2x00dev->flags); 498 499 /* 500 * This device requires firmware. 501 */ 502 __set_bit(DRIVER_REQUIRE_FIRMWARE, &rt2x00dev->flags); 503 __set_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags); 504 if (!modparam_nohwcrypt) 505 __set_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags); 506 __set_bit(DRIVER_SUPPORT_LINK_TUNING, &rt2x00dev->flags); 507 __set_bit(DRIVER_SUPPORT_WATCHDOG, &rt2x00dev->flags); 508 509 /* 510 * Set the rssi offset. 511 */ 512 rt2x00dev->rssi_offset = DEFAULT_RSSI_OFFSET; 513 514 return 0; 515} 516 517static const struct ieee80211_ops rt2800usb_mac80211_ops = { 518 .tx = rt2x00mac_tx, 519 .start = rt2x00mac_start, 520 .stop = rt2x00mac_stop, 521 .add_interface = rt2x00mac_add_interface, 522 .remove_interface = rt2x00mac_remove_interface, 523 .config = rt2x00mac_config, 524 .configure_filter = rt2x00mac_configure_filter, 525 .set_tim = rt2x00mac_set_tim, 526 .set_key = rt2x00mac_set_key, 527 .sw_scan_start = rt2x00mac_sw_scan_start, 528 .sw_scan_complete = rt2x00mac_sw_scan_complete, 529 .get_stats = rt2x00mac_get_stats, 530 .get_tkip_seq = rt2800_get_tkip_seq, 531 .set_rts_threshold = rt2800_set_rts_threshold, 532 .bss_info_changed = rt2x00mac_bss_info_changed, 533 .conf_tx = rt2800_conf_tx, 534 .get_tsf = rt2800_get_tsf, 535 .rfkill_poll = rt2x00mac_rfkill_poll, 536 .ampdu_action = rt2800_ampdu_action, 537}; 538 539static const struct rt2800_ops rt2800usb_rt2800_ops = { 540 .register_read = rt2x00usb_register_read, 541 .register_read_lock = rt2x00usb_register_read_lock, 542 .register_write = rt2x00usb_register_write, 543 .register_write_lock = rt2x00usb_register_write_lock, 544 .register_multiread = rt2x00usb_register_multiread, 545 .register_multiwrite = rt2x00usb_register_multiwrite, 546 .regbusy_read = rt2x00usb_regbusy_read, 547 .drv_write_firmware = rt2800usb_write_firmware, 548 .drv_init_registers = rt2800usb_init_registers, 549}; 550 551static const struct rt2x00lib_ops rt2800usb_rt2x00_ops = { 552 .probe_hw = rt2800usb_probe_hw, 553 .get_firmware_name = rt2800usb_get_firmware_name, 554 .check_firmware = rt2800_check_firmware, 555 .load_firmware = rt2800_load_firmware, 556 .initialize = rt2x00usb_initialize, 557 .uninitialize = rt2x00usb_uninitialize, 558 .clear_entry = rt2x00usb_clear_entry, 559 .set_device_state = rt2800usb_set_device_state, 560 .rfkill_poll = rt2800_rfkill_poll, 561 .link_stats = rt2800_link_stats, 562 .reset_tuner = rt2800_reset_tuner, 563 .link_tuner = rt2800_link_tuner, 564 .watchdog = rt2x00usb_watchdog, 565 .write_tx_desc = rt2800usb_write_tx_desc, 566 .write_tx_data = rt2800usb_write_tx_data, 567 .write_beacon = rt2800_write_beacon, 568 .get_tx_data_len = rt2800usb_get_tx_data_len, 569 .kick_tx_queue = rt2x00usb_kick_tx_queue, 570 .kill_tx_queue = rt2x00usb_kill_tx_queue, 571 .fill_rxdone = rt2800usb_fill_rxdone, 572 .config_shared_key = rt2800_config_shared_key, 573 .config_pairwise_key = rt2800_config_pairwise_key, 574 .config_filter = rt2800_config_filter, 575 .config_intf = rt2800_config_intf, 576 .config_erp = rt2800_config_erp, 577 .config_ant = rt2800_config_ant, 578 .config = rt2800_config, 579}; 580 581static const struct data_queue_desc rt2800usb_queue_rx = { 582 .entry_num = RX_ENTRIES, 583 .data_size = AGGREGATION_SIZE, 584 .desc_size = RXINFO_DESC_SIZE + RXWI_DESC_SIZE, 585 .priv_size = sizeof(struct queue_entry_priv_usb), 586}; 587 588static const struct data_queue_desc rt2800usb_queue_tx = { 589 .entry_num = TX_ENTRIES, 590 .data_size = AGGREGATION_SIZE, 591 .desc_size = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, 592 .priv_size = sizeof(struct queue_entry_priv_usb), 593}; 594 595static const struct data_queue_desc rt2800usb_queue_bcn = { 596 .entry_num = 8 * BEACON_ENTRIES, 597 .data_size = MGMT_FRAME_SIZE, 598 .desc_size = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, 599 .priv_size = sizeof(struct queue_entry_priv_usb), 600}; 601 602static const struct rt2x00_ops rt2800usb_ops = { 603 .name = KBUILD_MODNAME, 604 .max_sta_intf = 1, 605 .max_ap_intf = 8, 606 .eeprom_size = EEPROM_SIZE, 607 .rf_size = RF_SIZE, 608 .tx_queues = NUM_TX_QUEUES, 609 .extra_tx_headroom = TXINFO_DESC_SIZE + TXWI_DESC_SIZE, 610 .rx = &rt2800usb_queue_rx, 611 .tx = &rt2800usb_queue_tx, 612 .bcn = &rt2800usb_queue_bcn, 613 .lib = &rt2800usb_rt2x00_ops, 614 .drv = &rt2800usb_rt2800_ops, 615 .hw = &rt2800usb_mac80211_ops, 616#ifdef CONFIG_RT2X00_LIB_DEBUGFS 617 .debugfs = &rt2800_rt2x00debug, 618#endif /* CONFIG_RT2X00_LIB_DEBUGFS */ 619}; 620 621/* 622 * rt2800usb module information. 623 */ 624static struct usb_device_id rt2800usb_device_table[] = { 625 /* Abocom */ 626 { USB_DEVICE(0x07b8, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, 627 { USB_DEVICE(0x07b8, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, 628 { USB_DEVICE(0x1482, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, 629 /* Allwin */ 630 { USB_DEVICE(0x8516, 0x2070), USB_DEVICE_DATA(&rt2800usb_ops) }, 631 { USB_DEVICE(0x8516, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, 632 { USB_DEVICE(0x8516, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, 633 /* Amit */ 634 { USB_DEVICE(0x15c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) }, 635 /* Askey */ 636 { USB_DEVICE(0x1690, 0x0740), USB_DEVICE_DATA(&rt2800usb_ops) }, 637 /* ASUS */ 638 { USB_DEVICE(0x0b05, 0x1731), USB_DEVICE_DATA(&rt2800usb_ops) }, 639 { USB_DEVICE(0x0b05, 0x1732), USB_DEVICE_DATA(&rt2800usb_ops) }, 640 { USB_DEVICE(0x0b05, 0x1742), USB_DEVICE_DATA(&rt2800usb_ops) }, 641 /* AzureWave */ 642 { USB_DEVICE(0x13d3, 0x3247), USB_DEVICE_DATA(&rt2800usb_ops) }, 643 /* Belkin */ 644 { USB_DEVICE(0x050d, 0x8053), USB_DEVICE_DATA(&rt2800usb_ops) }, 645 { USB_DEVICE(0x050d, 0x805c), USB_DEVICE_DATA(&rt2800usb_ops) }, 646 { USB_DEVICE(0x050d, 0x815c), USB_DEVICE_DATA(&rt2800usb_ops) }, 647 /* Buffalo */ 648 { USB_DEVICE(0x0411, 0x00e8), USB_DEVICE_DATA(&rt2800usb_ops) }, 649 /* Conceptronic */ 650 { USB_DEVICE(0x14b2, 0x3c06), USB_DEVICE_DATA(&rt2800usb_ops) }, 651 { USB_DEVICE(0x14b2, 0x3c07), USB_DEVICE_DATA(&rt2800usb_ops) }, 652 { USB_DEVICE(0x14b2, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, 653 { USB_DEVICE(0x14b2, 0x3c23), USB_DEVICE_DATA(&rt2800usb_ops) }, 654 { USB_DEVICE(0x14b2, 0x3c25), USB_DEVICE_DATA(&rt2800usb_ops) }, 655 { USB_DEVICE(0x14b2, 0x3c27), USB_DEVICE_DATA(&rt2800usb_ops) }, 656 { USB_DEVICE(0x14b2, 0x3c28), USB_DEVICE_DATA(&rt2800usb_ops) }, 657 /* Corega */ 658 { USB_DEVICE(0x07aa, 0x002f), USB_DEVICE_DATA(&rt2800usb_ops) }, 659 { USB_DEVICE(0x07aa, 0x003c), USB_DEVICE_DATA(&rt2800usb_ops) }, 660 { USB_DEVICE(0x07aa, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) }, 661 /* D-Link */ 662 { USB_DEVICE(0x07d1, 0x3c09), USB_DEVICE_DATA(&rt2800usb_ops) }, 663 { USB_DEVICE(0x07d1, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) }, 664 /* Edimax */ 665 { USB_DEVICE(0x7392, 0x7717), USB_DEVICE_DATA(&rt2800usb_ops) }, 666 { USB_DEVICE(0x7392, 0x7718), USB_DEVICE_DATA(&rt2800usb_ops) }, 667 /* EnGenius */ 668 { USB_DEVICE(0x1740, 0x9701), USB_DEVICE_DATA(&rt2800usb_ops) }, 669 { USB_DEVICE(0x1740, 0x9702), USB_DEVICE_DATA(&rt2800usb_ops) }, 670 /* Gigabyte */ 671 { USB_DEVICE(0x1044, 0x800b), USB_DEVICE_DATA(&rt2800usb_ops) }, 672 /* Hawking */ 673 { USB_DEVICE(0x0e66, 0x0001), USB_DEVICE_DATA(&rt2800usb_ops) }, 674 { USB_DEVICE(0x0e66, 0x0003), USB_DEVICE_DATA(&rt2800usb_ops) }, 675 { USB_DEVICE(0x0e66, 0x0009), USB_DEVICE_DATA(&rt2800usb_ops) }, 676 { USB_DEVICE(0x0e66, 0x000b), USB_DEVICE_DATA(&rt2800usb_ops) }, 677 { USB_DEVICE(0x0e66, 0x0013), USB_DEVICE_DATA(&rt2800usb_ops) }, 678 { USB_DEVICE(0x0e66, 0x0017), USB_DEVICE_DATA(&rt2800usb_ops) }, 679 { USB_DEVICE(0x0e66, 0x0018), USB_DEVICE_DATA(&rt2800usb_ops) }, 680 /* Linksys */ 681 { USB_DEVICE(0x1737, 0x0070), USB_DEVICE_DATA(&rt2800usb_ops) }, 682 { USB_DEVICE(0x1737, 0x0071), USB_DEVICE_DATA(&rt2800usb_ops) }, 683 /* Logitec */ 684 { USB_DEVICE(0x0789, 0x0162), USB_DEVICE_DATA(&rt2800usb_ops) }, 685 { USB_DEVICE(0x0789, 0x0163), USB_DEVICE_DATA(&rt2800usb_ops) }, 686 { USB_DEVICE(0x0789, 0x0164), USB_DEVICE_DATA(&rt2800usb_ops) }, 687 /* Motorola */ 688 { USB_DEVICE(0x100d, 0x9031), USB_DEVICE_DATA(&rt2800usb_ops) }, 689 /* MSI */ 690 { USB_DEVICE(0x0db0, 0x6899), USB_DEVICE_DATA(&rt2800usb_ops) }, 691 /* Philips */ 692 { USB_DEVICE(0x0471, 0x200f), USB_DEVICE_DATA(&rt2800usb_ops) }, 693 /* Planex */ 694 { USB_DEVICE(0x2019, 0xed06), USB_DEVICE_DATA(&rt2800usb_ops) }, 695 /* Ralink */ 696 { USB_DEVICE(0x148f, 0x2770), USB_DEVICE_DATA(&rt2800usb_ops) }, 697 { USB_DEVICE(0x148f, 0x2870), USB_DEVICE_DATA(&rt2800usb_ops) }, 698 /* Samsung */ 699 { USB_DEVICE(0x04e8, 0x2018), USB_DEVICE_DATA(&rt2800usb_ops) }, 700 /* Siemens */ 701 { USB_DEVICE(0x129b, 0x1828), USB_DEVICE_DATA(&rt2800usb_ops) }, 702 /* Sitecom */ 703 { USB_DEVICE(0x0df6, 0x0017), USB_DEVICE_DATA(&rt2800usb_ops) }, 704 { USB_DEVICE(0x0df6, 0x002b), USB_DEVICE_DATA(&rt2800usb_ops) }, 705 { USB_DEVICE(0x0df6, 0x002c), USB_DEVICE_DATA(&rt2800usb_ops) }, 706 { USB_DEVICE(0x0df6, 0x002d), USB_DEVICE_DATA(&rt2800usb_ops) }, 707 { USB_DEVICE(0x0df6, 0x0039), USB_DEVICE_DATA(&rt2800usb_ops) }, 708 { USB_DEVICE(0x0df6, 0x003b), USB_DEVICE_DATA(&rt2800usb_ops) }, 709 { USB_DEVICE(0x0df6, 0x003d), USB_DEVICE_DATA(&rt2800usb_ops) }, 710 { USB_DEVICE(0x0df6, 0x003f), USB_DEVICE_DATA(&rt2800usb_ops) }, 711 /* SMC */ 712 { USB_DEVICE(0x083a, 0x6618), USB_DEVICE_DATA(&rt2800usb_ops) }, 713 { USB_DEVICE(0x083a, 0x7512), USB_DEVICE_DATA(&rt2800usb_ops) }, 714 { USB_DEVICE(0x083a, 0x7522), USB_DEVICE_DATA(&rt2800usb_ops) }, 715 { USB_DEVICE(0x083a, 0x8522), USB_DEVICE_DATA(&rt2800usb_ops) }, 716 { USB_DEVICE(0x083a, 0xa618), USB_DEVICE_DATA(&rt2800usb_ops) }, 717 { USB_DEVICE(0x083a, 0xb522), USB_DEVICE_DATA(&rt2800usb_ops) }, 718 /* Sparklan */ 719 { USB_DEVICE(0x15a9, 0x0006), USB_DEVICE_DATA(&rt2800usb_ops) }, 720 /* Sweex */ 721 { USB_DEVICE(0x177f, 0x0302), USB_DEVICE_DATA(&rt2800usb_ops) }, 722 /* U-Media*/ 723 { USB_DEVICE(0x157e, 0x300e), USB_DEVICE_DATA(&rt2800usb_ops) }, 724 /* ZCOM */ 725 { USB_DEVICE(0x0cde, 0x0022), USB_DEVICE_DATA(&rt2800usb_ops) }, 726 { USB_DEVICE(0x0cde, 0x0025), USB_DEVICE_DATA(&rt2800usb_ops) }, 727 /* Zinwell */ 728 { USB_DEVICE(0x5a57, 0x0280), USB_DEVICE_DATA(&rt2800usb_ops) }, 729 { USB_DEVICE(0x5a57, 0x0282), USB_DEVICE_DATA(&rt2800usb_ops) }, 730 /* Zyxel */ 731 { USB_DEVICE(0x0586, 0x3416), USB_DEVICE_DATA(&rt2800usb_ops) }, 732#ifdef CONFIG_RT2800USB_RT30XX 733 /* Abocom */ 734 { USB_DEVICE(0x07b8, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, 735 { USB_DEVICE(0x07b8, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, 736 { USB_DEVICE(0x07b8, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, 737 /* AirTies */ 738 { USB_DEVICE(0x1eda, 0x2310), USB_DEVICE_DATA(&rt2800usb_ops) }, 739 /* Allwin */ 740 { USB_DEVICE(0x8516, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, 741 { USB_DEVICE(0x8516, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, 742 { USB_DEVICE(0x8516, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, 743 /* ASUS */ 744 { USB_DEVICE(0x0b05, 0x1784), USB_DEVICE_DATA(&rt2800usb_ops) }, 745 /* AzureWave */ 746 { USB_DEVICE(0x13d3, 0x3273), USB_DEVICE_DATA(&rt2800usb_ops) }, 747 { USB_DEVICE(0x13d3, 0x3305), USB_DEVICE_DATA(&rt2800usb_ops) }, 748 { USB_DEVICE(0x13d3, 0x3307), USB_DEVICE_DATA(&rt2800usb_ops) }, 749 { USB_DEVICE(0x13d3, 0x3321), USB_DEVICE_DATA(&rt2800usb_ops) }, 750 /* Conceptronic */ 751 { USB_DEVICE(0x14b2, 0x3c12), USB_DEVICE_DATA(&rt2800usb_ops) }, 752 /* Corega */ 753 { USB_DEVICE(0x18c5, 0x0012), USB_DEVICE_DATA(&rt2800usb_ops) }, 754 /* D-Link */ 755 { USB_DEVICE(0x07d1, 0x3c0a), USB_DEVICE_DATA(&rt2800usb_ops) }, 756 { USB_DEVICE(0x07d1, 0x3c0d), USB_DEVICE_DATA(&rt2800usb_ops) }, 757 { USB_DEVICE(0x07d1, 0x3c0e), USB_DEVICE_DATA(&rt2800usb_ops) }, 758 { USB_DEVICE(0x07d1, 0x3c0f), USB_DEVICE_DATA(&rt2800usb_ops) }, 759 { USB_DEVICE(0x07d1, 0x3c16), USB_DEVICE_DATA(&rt2800usb_ops) }, 760 /* Draytek */ 761 { USB_DEVICE(0x07fa, 0x7712), USB_DEVICE_DATA(&rt2800usb_ops) }, 762 /* Edimax */ 763 { USB_DEVICE(0x7392, 0x7711), USB_DEVICE_DATA(&rt2800usb_ops) }, 764 /* Encore */ 765 { USB_DEVICE(0x203d, 0x1480), USB_DEVICE_DATA(&rt2800usb_ops) }, 766 { USB_DEVICE(0x203d, 0x14a9), USB_DEVICE_DATA(&rt2800usb_ops) }, 767 /* EnGenius */ 768 { USB_DEVICE(0x1740, 0x9703), USB_DEVICE_DATA(&rt2800usb_ops) }, 769 { USB_DEVICE(0x1740, 0x9705), USB_DEVICE_DATA(&rt2800usb_ops) }, 770 { USB_DEVICE(0x1740, 0x9706), USB_DEVICE_DATA(&rt2800usb_ops) }, 771 { USB_DEVICE(0x1740, 0x9707), USB_DEVICE_DATA(&rt2800usb_ops) }, 772 { USB_DEVICE(0x1740, 0x9708), USB_DEVICE_DATA(&rt2800usb_ops) }, 773 { USB_DEVICE(0x1740, 0x9709), USB_DEVICE_DATA(&rt2800usb_ops) }, 774 /* Gigabyte */ 775 { USB_DEVICE(0x1044, 0x800d), USB_DEVICE_DATA(&rt2800usb_ops) }, 776 /* I-O DATA */ 777 { USB_DEVICE(0x04bb, 0x0945), USB_DEVICE_DATA(&rt2800usb_ops) }, 778 { USB_DEVICE(0x04bb, 0x0947), USB_DEVICE_DATA(&rt2800usb_ops) }, 779 { USB_DEVICE(0x04bb, 0x0948), USB_DEVICE_DATA(&rt2800usb_ops) }, 780 /* Logitec */ 781 { USB_DEVICE(0x0789, 0x0166), USB_DEVICE_DATA(&rt2800usb_ops) }, 782 /* MSI */ 783 { USB_DEVICE(0x0db0, 0x3820), USB_DEVICE_DATA(&rt2800usb_ops) }, 784 { USB_DEVICE(0x0db0, 0x3821), USB_DEVICE_DATA(&rt2800usb_ops) }, 785 { USB_DEVICE(0x0db0, 0x3822), USB_DEVICE_DATA(&rt2800usb_ops) }, 786 { USB_DEVICE(0x0db0, 0x3870), USB_DEVICE_DATA(&rt2800usb_ops) }, 787 { USB_DEVICE(0x0db0, 0x3871), USB_DEVICE_DATA(&rt2800usb_ops) }, 788 { USB_DEVICE(0x0db0, 0x821a), USB_DEVICE_DATA(&rt2800usb_ops) }, 789 { USB_DEVICE(0x0db0, 0x822a), USB_DEVICE_DATA(&rt2800usb_ops) }, 790 { USB_DEVICE(0x0db0, 0x822b), USB_DEVICE_DATA(&rt2800usb_ops) }, 791 { USB_DEVICE(0x0db0, 0x822c), USB_DEVICE_DATA(&rt2800usb_ops) }, 792 { USB_DEVICE(0x0db0, 0x870a), USB_DEVICE_DATA(&rt2800usb_ops) }, 793 { USB_DEVICE(0x0db0, 0x871a), USB_DEVICE_DATA(&rt2800usb_ops) }, 794 { USB_DEVICE(0x0db0, 0x871b), USB_DEVICE_DATA(&rt2800usb_ops) }, 795 { USB_DEVICE(0x0db0, 0x871c), USB_DEVICE_DATA(&rt2800usb_ops) }, 796 { USB_DEVICE(0x0db0, 0x899a), USB_DEVICE_DATA(&rt2800usb_ops) }, 797 /* Para */ 798 { USB_DEVICE(0x20b8, 0x8888), USB_DEVICE_DATA(&rt2800usb_ops) }, 799 /* Pegatron */ 800 { USB_DEVICE(0x1d4d, 0x000c), USB_DEVICE_DATA(&rt2800usb_ops) }, 801 { USB_DEVICE(0x1d4d, 0x000e), USB_DEVICE_DATA(&rt2800usb_ops) }, 802 /* Planex */ 803 { USB_DEVICE(0x2019, 0xab25), USB_DEVICE_DATA(&rt2800usb_ops) }, 804 /* Quanta */ 805 { USB_DEVICE(0x1a32, 0x0304), USB_DEVICE_DATA(&rt2800usb_ops) }, 806 /* Ralink */ 807 { USB_DEVICE(0x148f, 0x2070), USB_DEVICE_DATA(&rt2800usb_ops) }, 808 { USB_DEVICE(0x148f, 0x3070), USB_DEVICE_DATA(&rt2800usb_ops) }, 809 { USB_DEVICE(0x148f, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, 810 { USB_DEVICE(0x148f, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, 811 /* Sitecom */ 812 { USB_DEVICE(0x0df6, 0x003e), USB_DEVICE_DATA(&rt2800usb_ops) }, 813 { USB_DEVICE(0x0df6, 0x0040), USB_DEVICE_DATA(&rt2800usb_ops) }, 814 { USB_DEVICE(0x0df6, 0x0042), USB_DEVICE_DATA(&rt2800usb_ops) }, 815 { USB_DEVICE(0x0df6, 0x0047), USB_DEVICE_DATA(&rt2800usb_ops) }, 816 { USB_DEVICE(0x0df6, 0x0048), USB_DEVICE_DATA(&rt2800usb_ops) }, 817 /* SMC */ 818 { USB_DEVICE(0x083a, 0x7511), USB_DEVICE_DATA(&rt2800usb_ops) }, 819 { USB_DEVICE(0x083a, 0xa701), USB_DEVICE_DATA(&rt2800usb_ops) }, 820 { USB_DEVICE(0x083a, 0xa702), USB_DEVICE_DATA(&rt2800usb_ops) }, 821 { USB_DEVICE(0x083a, 0xa703), USB_DEVICE_DATA(&rt2800usb_ops) }, 822 /* Zinwell */ 823 { USB_DEVICE(0x5a57, 0x0283), USB_DEVICE_DATA(&rt2800usb_ops) }, 824 { USB_DEVICE(0x5a57, 0x5257), USB_DEVICE_DATA(&rt2800usb_ops) }, 825#endif 826#ifdef CONFIG_RT2800USB_RT35XX 827 /* Allwin */ 828 { USB_DEVICE(0x8516, 0x3572), USB_DEVICE_DATA(&rt2800usb_ops) }, 829 /* Askey */ 830 { USB_DEVICE(0x1690, 0x0744), USB_DEVICE_DATA(&rt2800usb_ops) }, 831 /* Cisco */ 832 { USB_DEVICE(0x167b, 0x4001), USB_DEVICE_DATA(&rt2800usb_ops) }, 833 /* EnGenius */ 834 { USB_DEVICE(0x1740, 0x9801), USB_DEVICE_DATA(&rt2800usb_ops) }, 835 /* I-O DATA */ 836 { USB_DEVICE(0x04bb, 0x0944), USB_DEVICE_DATA(&rt2800usb_ops) }, 837 /* Ralink */ 838 { USB_DEVICE(0x148f, 0x3370), USB_DEVICE_DATA(&rt2800usb_ops) }, 839 { USB_DEVICE(0x148f, 0x3572), USB_DEVICE_DATA(&rt2800usb_ops) }, 840 { USB_DEVICE(0x148f, 0x8070), USB_DEVICE_DATA(&rt2800usb_ops) }, 841 /* Sitecom */ 842 { USB_DEVICE(0x0df6, 0x0041), USB_DEVICE_DATA(&rt2800usb_ops) }, 843 { USB_DEVICE(0x0df6, 0x0050), USB_DEVICE_DATA(&rt2800usb_ops) }, 844 /* Zinwell */ 845 { USB_DEVICE(0x5a57, 0x0284), USB_DEVICE_DATA(&rt2800usb_ops) }, 846#endif 847#ifdef CONFIG_RT2800USB_UNKNOWN 848 /* 849 * Unclear what kind of devices these are (they aren't supported by the 850 * vendor linux driver). 851 */ 852 /* Amigo */ 853 { USB_DEVICE(0x0e0b, 0x9031), USB_DEVICE_DATA(&rt2800usb_ops) }, 854 { USB_DEVICE(0x0e0b, 0x9041), USB_DEVICE_DATA(&rt2800usb_ops) }, 855 /* ASUS */ 856 { USB_DEVICE(0x0b05, 0x1760), USB_DEVICE_DATA(&rt2800usb_ops) }, 857 { USB_DEVICE(0x0b05, 0x1761), USB_DEVICE_DATA(&rt2800usb_ops) }, 858 { USB_DEVICE(0x0b05, 0x1790), USB_DEVICE_DATA(&rt2800usb_ops) }, 859 { USB_DEVICE(0x1761, 0x0b05), USB_DEVICE_DATA(&rt2800usb_ops) }, 860 /* AzureWave */ 861 { USB_DEVICE(0x13d3, 0x3262), USB_DEVICE_DATA(&rt2800usb_ops) }, 862 { USB_DEVICE(0x13d3, 0x3284), USB_DEVICE_DATA(&rt2800usb_ops) }, 863 { USB_DEVICE(0x13d3, 0x3322), USB_DEVICE_DATA(&rt2800usb_ops) }, 864 /* Belkin */ 865 { USB_DEVICE(0x050d, 0x825a), USB_DEVICE_DATA(&rt2800usb_ops) }, 866 /* Buffalo */ 867 { USB_DEVICE(0x0411, 0x012e), USB_DEVICE_DATA(&rt2800usb_ops) }, 868 { USB_DEVICE(0x0411, 0x0148), USB_DEVICE_DATA(&rt2800usb_ops) }, 869 { USB_DEVICE(0x0411, 0x0150), USB_DEVICE_DATA(&rt2800usb_ops) }, 870 { USB_DEVICE(0x0411, 0x015d), USB_DEVICE_DATA(&rt2800usb_ops) }, 871 /* Conceptronic */ 872 { USB_DEVICE(0x14b2, 0x3c08), USB_DEVICE_DATA(&rt2800usb_ops) }, 873 { USB_DEVICE(0x14b2, 0x3c11), USB_DEVICE_DATA(&rt2800usb_ops) }, 874 /* Corega */ 875 { USB_DEVICE(0x07aa, 0x0041), USB_DEVICE_DATA(&rt2800usb_ops) }, 876 { USB_DEVICE(0x07aa, 0x0042), USB_DEVICE_DATA(&rt2800usb_ops) }, 877 { USB_DEVICE(0x18c5, 0x0008), USB_DEVICE_DATA(&rt2800usb_ops) }, 878 /* D-Link */ 879 { USB_DEVICE(0x07d1, 0x3c0b), USB_DEVICE_DATA(&rt2800usb_ops) }, 880 { USB_DEVICE(0x07d1, 0x3c13), USB_DEVICE_DATA(&rt2800usb_ops) }, 881 { USB_DEVICE(0x07d1, 0x3c15), USB_DEVICE_DATA(&rt2800usb_ops) }, 882 { USB_DEVICE(0x07d1, 0x3c17), USB_DEVICE_DATA(&rt2800usb_ops) }, 883 /* Encore */ 884 { USB_DEVICE(0x203d, 0x14a1), USB_DEVICE_DATA(&rt2800usb_ops) }, 885 /* Gemtek */ 886 { USB_DEVICE(0x15a9, 0x0010), USB_DEVICE_DATA(&rt2800usb_ops) }, 887 /* Gigabyte */ 888 { USB_DEVICE(0x1044, 0x800c), USB_DEVICE_DATA(&rt2800usb_ops) }, 889 /* LevelOne */ 890 { USB_DEVICE(0x1740, 0x0605), USB_DEVICE_DATA(&rt2800usb_ops) }, 891 { USB_DEVICE(0x1740, 0x0615), USB_DEVICE_DATA(&rt2800usb_ops) }, 892 /* Linksys */ 893 { USB_DEVICE(0x1737, 0x0077), USB_DEVICE_DATA(&rt2800usb_ops) }, 894 { USB_DEVICE(0x1737, 0x0078), USB_DEVICE_DATA(&rt2800usb_ops) }, 895 { USB_DEVICE(0x1737, 0x0079), USB_DEVICE_DATA(&rt2800usb_ops) }, 896 /* Motorola */ 897 { USB_DEVICE(0x100d, 0x9032), USB_DEVICE_DATA(&rt2800usb_ops) }, 898 /* Ovislink */ 899 { USB_DEVICE(0x1b75, 0x3071), USB_DEVICE_DATA(&rt2800usb_ops) }, 900 { USB_DEVICE(0x1b75, 0x3072), USB_DEVICE_DATA(&rt2800usb_ops) }, 901 /* Pegatron */ 902 { USB_DEVICE(0x05a6, 0x0101), USB_DEVICE_DATA(&rt2800usb_ops) }, 903 { USB_DEVICE(0x1d4d, 0x0002), USB_DEVICE_DATA(&rt2800usb_ops) }, 904 { USB_DEVICE(0x1d4d, 0x0010), USB_DEVICE_DATA(&rt2800usb_ops) }, 905 { USB_DEVICE(0x1d4d, 0x0011), USB_DEVICE_DATA(&rt2800usb_ops) }, 906 /* Planex */ 907 { USB_DEVICE(0x2019, 0xab24), USB_DEVICE_DATA(&rt2800usb_ops) }, 908 /* Qcom */ 909 { USB_DEVICE(0x18e8, 0x6259), USB_DEVICE_DATA(&rt2800usb_ops) }, 910 /* SMC */ 911 { USB_DEVICE(0x083a, 0xa512), USB_DEVICE_DATA(&rt2800usb_ops) }, 912 { USB_DEVICE(0x083a, 0xc522), USB_DEVICE_DATA(&rt2800usb_ops) }, 913 { USB_DEVICE(0x083a, 0xd522), USB_DEVICE_DATA(&rt2800usb_ops) }, 914 { USB_DEVICE(0x083a, 0xf511), USB_DEVICE_DATA(&rt2800usb_ops) }, 915 /* Sweex */ 916 { USB_DEVICE(0x177f, 0x0153), USB_DEVICE_DATA(&rt2800usb_ops) }, 917 { USB_DEVICE(0x177f, 0x0313), USB_DEVICE_DATA(&rt2800usb_ops) }, 918 /* Zyxel */ 919 { USB_DEVICE(0x0586, 0x341a), USB_DEVICE_DATA(&rt2800usb_ops) }, 920#endif 921 { 0, } 922}; 923 924MODULE_AUTHOR(DRV_PROJECT); 925MODULE_VERSION(DRV_VERSION); 926MODULE_DESCRIPTION("Ralink RT2800 USB Wireless LAN driver."); 927MODULE_SUPPORTED_DEVICE("Ralink RT2870 USB chipset based cards"); 928MODULE_DEVICE_TABLE(usb, rt2800usb_device_table); 929MODULE_FIRMWARE(FIRMWARE_RT2870); 930MODULE_LICENSE("GPL"); 931 932static struct usb_driver rt2800usb_driver = { 933 .name = KBUILD_MODNAME, 934 .id_table = rt2800usb_device_table, 935 .probe = rt2x00usb_probe, 936 .disconnect = rt2x00usb_disconnect, 937 .suspend = rt2x00usb_suspend, 938 .resume = rt2x00usb_resume, 939}; 940 941static int __init rt2800usb_init(void) 942{ 943 return usb_register(&rt2800usb_driver); 944} 945 946static void __exit rt2800usb_exit(void) 947{ 948 usb_deregister(&rt2800usb_driver); 949} 950 951module_init(rt2800usb_init); 952module_exit(rt2800usb_exit); 953