1/* 2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc. 3 * All rights reserved. 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 along 16 * with this program; if not, write to the Free Software Foundation, Inc., 17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * File: main_usb.c 20 * 21 * Purpose: driver entry for initial, open, close, tx and rx. 22 * 23 * Author: Lyndon Chen 24 * 25 * Date: Dec 8, 2005 26 * 27 * Functions: 28 * 29 * vt6656_probe - module initial (insmod) driver entry 30 * vnt_free_tx_bufs - free tx buffer function 31 * vnt_init_registers- initial MAC & BBP & RF internal registers. 32 * 33 * Revision History: 34 */ 35#undef __NO_VERSION__ 36 37#include <linux/etherdevice.h> 38#include <linux/file.h> 39#include "device.h" 40#include "card.h" 41#include "baseband.h" 42#include "mac.h" 43#include "power.h" 44#include "wcmd.h" 45#include "rxtx.h" 46#include "dpc.h" 47#include "rf.h" 48#include "firmware.h" 49#include "usbpipe.h" 50#include "channel.h" 51#include "int.h" 52 53/* 54 * define module options 55 */ 56 57/* version information */ 58#define DRIVER_AUTHOR \ 59 "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>" 60MODULE_AUTHOR(DRIVER_AUTHOR); 61MODULE_LICENSE("GPL"); 62MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM); 63 64#define RX_DESC_DEF0 64 65static int vnt_rx_buffers = RX_DESC_DEF0; 66module_param_named(rx_buffers, vnt_rx_buffers, int, 0644); 67MODULE_PARM_DESC(rx_buffers, "Number of receive usb rx buffers"); 68 69#define TX_DESC_DEF0 64 70static int vnt_tx_buffers = TX_DESC_DEF0; 71module_param_named(tx_buffers, vnt_tx_buffers, int, 0644); 72MODULE_PARM_DESC(tx_buffers, "Number of receive usb tx buffers"); 73 74#define RTS_THRESH_DEF 2347 75#define FRAG_THRESH_DEF 2346 76#define SHORT_RETRY_DEF 8 77#define LONG_RETRY_DEF 4 78 79/* BasebandType[] baseband type selected 80 0: indicate 802.11a type 81 1: indicate 802.11b type 82 2: indicate 802.11g type 83*/ 84 85#define BBP_TYPE_DEF 2 86 87/* 88 * Static vars definitions 89 */ 90 91static struct usb_device_id vt6656_table[] = { 92 {USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)}, 93 {} 94}; 95 96static void vnt_set_options(struct vnt_private *priv) 97{ 98 /* Set number of TX buffers */ 99 if (vnt_tx_buffers < CB_MIN_TX_DESC || vnt_tx_buffers > CB_MAX_TX_DESC) 100 priv->num_tx_context = TX_DESC_DEF0; 101 else 102 priv->num_tx_context = vnt_tx_buffers; 103 104 /* Set number of RX buffers */ 105 if (vnt_rx_buffers < CB_MIN_RX_DESC || vnt_rx_buffers > CB_MAX_RX_DESC) 106 priv->num_rcb = RX_DESC_DEF0; 107 else 108 priv->num_rcb = vnt_rx_buffers; 109 110 priv->short_retry_limit = SHORT_RETRY_DEF; 111 priv->long_retry_limit = LONG_RETRY_DEF; 112 priv->op_mode = NL80211_IFTYPE_UNSPECIFIED; 113 priv->bb_type = BBP_TYPE_DEF; 114 priv->packet_type = priv->bb_type; 115 priv->auto_fb_ctrl = AUTO_FB_0; 116 priv->preamble_type = 0; 117 priv->exist_sw_net_addr = false; 118} 119 120/* 121 * initialization of MAC & BBP registers 122 */ 123static int vnt_init_registers(struct vnt_private *priv) 124{ 125 struct vnt_cmd_card_init *init_cmd = &priv->init_command; 126 struct vnt_rsp_card_init *init_rsp = &priv->init_response; 127 u8 antenna; 128 int ii; 129 int status = STATUS_SUCCESS; 130 u8 tmp; 131 u8 calib_tx_iq = 0, calib_tx_dc = 0, calib_rx_iq = 0; 132 133 dev_dbg(&priv->usb->dev, "---->INIbInitAdapter. [%d][%d]\n", 134 DEVICE_INIT_COLD, priv->packet_type); 135 136 if (!vnt_check_firmware_version(priv)) { 137 if (vnt_download_firmware(priv) == true) { 138 if (vnt_firmware_branch_to_sram(priv) == false) { 139 dev_dbg(&priv->usb->dev, 140 " vnt_firmware_branch_to_sram fail\n"); 141 return false; 142 } 143 } else { 144 dev_dbg(&priv->usb->dev, "FIRMWAREbDownload fail\n"); 145 return false; 146 } 147 } 148 149 if (!vnt_vt3184_init(priv)) { 150 dev_dbg(&priv->usb->dev, "vnt_vt3184_init fail\n"); 151 return false; 152 } 153 154 init_cmd->init_class = DEVICE_INIT_COLD; 155 init_cmd->exist_sw_net_addr = priv->exist_sw_net_addr; 156 for (ii = 0; ii < 6; ii++) 157 init_cmd->sw_net_addr[ii] = priv->current_net_addr[ii]; 158 init_cmd->short_retry_limit = priv->short_retry_limit; 159 init_cmd->long_retry_limit = priv->long_retry_limit; 160 161 /* issue card_init command to device */ 162 status = vnt_control_out(priv, 163 MESSAGE_TYPE_CARDINIT, 0, 0, 164 sizeof(struct vnt_cmd_card_init), (u8 *)init_cmd); 165 if (status != STATUS_SUCCESS) { 166 dev_dbg(&priv->usb->dev, "Issue Card init fail\n"); 167 return false; 168 } 169 170 status = vnt_control_in(priv, MESSAGE_TYPE_INIT_RSP, 0, 0, 171 sizeof(struct vnt_rsp_card_init), (u8 *)init_rsp); 172 if (status != STATUS_SUCCESS) { 173 dev_dbg(&priv->usb->dev, 174 "Cardinit request in status fail!\n"); 175 return false; 176 } 177 178 /* local ID for AES functions */ 179 status = vnt_control_in(priv, MESSAGE_TYPE_READ, 180 MAC_REG_LOCALID, MESSAGE_REQUEST_MACREG, 1, 181 &priv->local_id); 182 if (status != STATUS_SUCCESS) 183 return false; 184 185 /* do MACbSoftwareReset in MACvInitialize */ 186 187 priv->top_ofdm_basic_rate = RATE_24M; 188 priv->top_cck_basic_rate = RATE_1M; 189 190 /* target to IF pin while programming to RF chip */ 191 priv->power = 0xFF; 192 193 priv->cck_pwr = priv->eeprom[EEP_OFS_PWR_CCK]; 194 priv->ofdm_pwr_g = priv->eeprom[EEP_OFS_PWR_OFDMG]; 195 /* load power table */ 196 for (ii = 0; ii < 14; ii++) { 197 priv->cck_pwr_tbl[ii] = 198 priv->eeprom[ii + EEP_OFS_CCK_PWR_TBL]; 199 if (priv->cck_pwr_tbl[ii] == 0) 200 priv->cck_pwr_tbl[ii] = priv->cck_pwr; 201 202 priv->ofdm_pwr_tbl[ii] = 203 priv->eeprom[ii + EEP_OFS_OFDM_PWR_TBL]; 204 if (priv->ofdm_pwr_tbl[ii] == 0) 205 priv->ofdm_pwr_tbl[ii] = priv->ofdm_pwr_g; 206 } 207 208 /* 209 * original zonetype is USA, but custom zonetype is Europe, 210 * then need to recover 12, 13, 14 channels with 11 channel 211 */ 212 for (ii = 11; ii < 14; ii++) { 213 priv->cck_pwr_tbl[ii] = priv->cck_pwr_tbl[10]; 214 priv->ofdm_pwr_tbl[ii] = priv->ofdm_pwr_tbl[10]; 215 } 216 217 priv->ofdm_pwr_a = 0x34; /* same as RFbMA2829SelectChannel */ 218 219 /* load OFDM A power table */ 220 for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) { 221 priv->ofdm_a_pwr_tbl[ii] = 222 priv->eeprom[ii + EEP_OFS_OFDMA_PWR_TBL]; 223 224 if (priv->ofdm_a_pwr_tbl[ii] == 0) 225 priv->ofdm_a_pwr_tbl[ii] = priv->ofdm_pwr_a; 226 } 227 228 antenna = priv->eeprom[EEP_OFS_ANTENNA]; 229 230 if (antenna & EEP_ANTINV) 231 priv->tx_rx_ant_inv = true; 232 else 233 priv->tx_rx_ant_inv = false; 234 235 antenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN); 236 237 if (antenna == 0) /* if not set default is both */ 238 antenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN); 239 240 if (antenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) { 241 priv->tx_antenna_mode = ANT_B; 242 priv->rx_antenna_sel = 1; 243 244 if (priv->tx_rx_ant_inv == true) 245 priv->rx_antenna_mode = ANT_A; 246 else 247 priv->rx_antenna_mode = ANT_B; 248 } else { 249 priv->rx_antenna_sel = 0; 250 251 if (antenna & EEP_ANTENNA_AUX) { 252 priv->tx_antenna_mode = ANT_A; 253 254 if (priv->tx_rx_ant_inv == true) 255 priv->rx_antenna_mode = ANT_B; 256 else 257 priv->rx_antenna_mode = ANT_A; 258 } else { 259 priv->tx_antenna_mode = ANT_B; 260 261 if (priv->tx_rx_ant_inv == true) 262 priv->rx_antenna_mode = ANT_A; 263 else 264 priv->rx_antenna_mode = ANT_B; 265 } 266 } 267 268 /* Set initial antenna mode */ 269 vnt_set_antenna_mode(priv, priv->rx_antenna_mode); 270 271 /* get Auto Fall Back type */ 272 priv->auto_fb_ctrl = AUTO_FB_0; 273 274 /* default Auto Mode */ 275 priv->bb_type = BB_TYPE_11G; 276 277 /* get RFType */ 278 priv->rf_type = init_rsp->rf_type; 279 280 /* load vt3266 calibration parameters in EEPROM */ 281 if (priv->rf_type == RF_VT3226D0) { 282 if ((priv->eeprom[EEP_OFS_MAJOR_VER] == 0x1) && 283 (priv->eeprom[EEP_OFS_MINOR_VER] >= 0x4)) { 284 285 calib_tx_iq = priv->eeprom[EEP_OFS_CALIB_TX_IQ]; 286 calib_tx_dc = priv->eeprom[EEP_OFS_CALIB_TX_DC]; 287 calib_rx_iq = priv->eeprom[EEP_OFS_CALIB_RX_IQ]; 288 if (calib_tx_iq || calib_tx_dc || calib_rx_iq) { 289 /* CR255, enable TX/RX IQ and 290 DC compensation mode */ 291 vnt_control_out_u8(priv, 292 MESSAGE_REQUEST_BBREG, 293 0xff, 294 0x03); 295 /* CR251, TX I/Q Imbalance Calibration */ 296 vnt_control_out_u8(priv, 297 MESSAGE_REQUEST_BBREG, 298 0xfb, 299 calib_tx_iq); 300 /* CR252, TX DC-Offset Calibration */ 301 vnt_control_out_u8(priv, 302 MESSAGE_REQUEST_BBREG, 303 0xfC, 304 calib_tx_dc); 305 /* CR253, RX I/Q Imbalance Calibration */ 306 vnt_control_out_u8(priv, 307 MESSAGE_REQUEST_BBREG, 308 0xfd, 309 calib_rx_iq); 310 } else { 311 /* CR255, turn off 312 BB Calibration compensation */ 313 vnt_control_out_u8(priv, 314 MESSAGE_REQUEST_BBREG, 315 0xff, 316 0x0); 317 } 318 } 319 } 320 321 /* get permanent network address */ 322 memcpy(priv->permanent_net_addr, init_rsp->net_addr, 6); 323 ether_addr_copy(priv->current_net_addr, priv->permanent_net_addr); 324 325 /* if exist SW network address, use it */ 326 dev_dbg(&priv->usb->dev, "Network address = %pM\n", 327 priv->current_net_addr); 328 329 /* 330 * set BB and packet type at the same time 331 * set Short Slot Time, xIFS, and RSPINF 332 */ 333 if (priv->bb_type == BB_TYPE_11A) 334 priv->short_slot_time = true; 335 else 336 priv->short_slot_time = false; 337 338 vnt_set_short_slot_time(priv); 339 340 priv->radio_ctl = priv->eeprom[EEP_OFS_RADIOCTL]; 341 342 if ((priv->radio_ctl & EEP_RADIOCTL_ENABLE) != 0) { 343 status = vnt_control_in(priv, MESSAGE_TYPE_READ, 344 MAC_REG_GPIOCTL1, MESSAGE_REQUEST_MACREG, 1, &tmp); 345 346 if (status != STATUS_SUCCESS) 347 return false; 348 349 if ((tmp & GPIO3_DATA) == 0) 350 vnt_mac_reg_bits_on(priv, MAC_REG_GPIOCTL1, 351 GPIO3_INTMD); 352 else 353 vnt_mac_reg_bits_off(priv, MAC_REG_GPIOCTL1, 354 GPIO3_INTMD); 355 } 356 357 vnt_mac_set_led(priv, LEDSTS_TMLEN, 0x38); 358 359 vnt_mac_set_led(priv, LEDSTS_STS, LEDSTS_SLOW); 360 361 vnt_mac_reg_bits_on(priv, MAC_REG_GPIOCTL0, 0x01); 362 363 vnt_radio_power_on(priv); 364 365 dev_dbg(&priv->usb->dev, "<----INIbInitAdapter Exit\n"); 366 367 return true; 368} 369 370static void vnt_free_tx_bufs(struct vnt_private *priv) 371{ 372 struct vnt_usb_send_context *tx_context; 373 int ii; 374 375 for (ii = 0; ii < priv->num_tx_context; ii++) { 376 tx_context = priv->tx_context[ii]; 377 /* deallocate URBs */ 378 if (tx_context->urb) { 379 usb_kill_urb(tx_context->urb); 380 usb_free_urb(tx_context->urb); 381 } 382 383 kfree(tx_context); 384 } 385} 386 387static void vnt_free_rx_bufs(struct vnt_private *priv) 388{ 389 struct vnt_rcb *rcb; 390 int ii; 391 392 for (ii = 0; ii < priv->num_rcb; ii++) { 393 rcb = priv->rcb[ii]; 394 if (!rcb) 395 continue; 396 397 /* deallocate URBs */ 398 if (rcb->urb) { 399 usb_kill_urb(rcb->urb); 400 usb_free_urb(rcb->urb); 401 } 402 403 /* deallocate skb */ 404 if (rcb->skb) 405 dev_kfree_skb(rcb->skb); 406 407 kfree(rcb); 408 } 409} 410 411static void usb_device_reset(struct vnt_private *priv) 412{ 413 int status; 414 415 status = usb_reset_device(priv->usb); 416 if (status) 417 dev_warn(&priv->usb->dev, 418 "usb_device_reset fail status=%d\n", status); 419} 420 421static void vnt_free_int_bufs(struct vnt_private *priv) 422{ 423 kfree(priv->int_buf.data_buf); 424} 425 426static bool vnt_alloc_bufs(struct vnt_private *priv) 427{ 428 struct vnt_usb_send_context *tx_context; 429 struct vnt_rcb *rcb; 430 int ii; 431 432 for (ii = 0; ii < priv->num_tx_context; ii++) { 433 tx_context = kmalloc(sizeof(struct vnt_usb_send_context), 434 GFP_KERNEL); 435 if (tx_context == NULL) 436 goto free_tx; 437 438 priv->tx_context[ii] = tx_context; 439 tx_context->priv = priv; 440 tx_context->pkt_no = ii; 441 442 /* allocate URBs */ 443 tx_context->urb = usb_alloc_urb(0, GFP_ATOMIC); 444 if (!tx_context->urb) { 445 dev_err(&priv->usb->dev, "alloc tx urb failed\n"); 446 goto free_tx; 447 } 448 449 tx_context->in_use = false; 450 } 451 452 for (ii = 0; ii < priv->num_rcb; ii++) { 453 priv->rcb[ii] = kzalloc(sizeof(struct vnt_rcb), GFP_KERNEL); 454 if (!priv->rcb[ii]) { 455 dev_err(&priv->usb->dev, 456 "failed to allocate rcb no %d\n", ii); 457 goto free_rx_tx; 458 } 459 460 rcb = priv->rcb[ii]; 461 462 rcb->priv = priv; 463 464 /* allocate URBs */ 465 rcb->urb = usb_alloc_urb(0, GFP_ATOMIC); 466 if (rcb->urb == NULL) { 467 dev_err(&priv->usb->dev, "Failed to alloc rx urb\n"); 468 goto free_rx_tx; 469 } 470 471 rcb->skb = dev_alloc_skb(priv->rx_buf_sz); 472 if (rcb->skb == NULL) 473 goto free_rx_tx; 474 475 rcb->in_use = false; 476 477 /* submit rx urb */ 478 if (vnt_submit_rx_urb(priv, rcb)) 479 goto free_rx_tx; 480 } 481 482 priv->interrupt_urb = usb_alloc_urb(0, GFP_ATOMIC); 483 if (priv->interrupt_urb == NULL) { 484 dev_err(&priv->usb->dev, "Failed to alloc int urb\n"); 485 goto free_rx_tx; 486 } 487 488 priv->int_buf.data_buf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL); 489 if (priv->int_buf.data_buf == NULL) { 490 usb_free_urb(priv->interrupt_urb); 491 goto free_rx_tx; 492 } 493 494 return true; 495 496free_rx_tx: 497 vnt_free_rx_bufs(priv); 498 499free_tx: 500 vnt_free_tx_bufs(priv); 501 502 return false; 503} 504 505static void vnt_tx_80211(struct ieee80211_hw *hw, 506 struct ieee80211_tx_control *control, struct sk_buff *skb) 507{ 508 struct vnt_private *priv = hw->priv; 509 510 ieee80211_stop_queues(hw); 511 512 if (vnt_tx_packet(priv, skb)) { 513 ieee80211_free_txskb(hw, skb); 514 515 ieee80211_wake_queues(hw); 516 } 517} 518 519static int vnt_start(struct ieee80211_hw *hw) 520{ 521 struct vnt_private *priv = hw->priv; 522 523 priv->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS; 524 525 if (vnt_alloc_bufs(priv) == false) { 526 dev_dbg(&priv->usb->dev, "vnt_alloc_bufs fail...\n"); 527 return -ENOMEM; 528 } 529 530 clear_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags); 531 532 if (vnt_init_registers(priv) == false) { 533 dev_dbg(&priv->usb->dev, " init register fail\n"); 534 goto free_all; 535 } 536 537 priv->int_interval = 1; /* bInterval is set to 1 */ 538 539 vnt_int_start_interrupt(priv); 540 541 ieee80211_wake_queues(hw); 542 543 return 0; 544 545free_all: 546 vnt_free_rx_bufs(priv); 547 vnt_free_tx_bufs(priv); 548 vnt_free_int_bufs(priv); 549 550 usb_kill_urb(priv->interrupt_urb); 551 usb_free_urb(priv->interrupt_urb); 552 553 return -ENOMEM; 554} 555 556static void vnt_stop(struct ieee80211_hw *hw) 557{ 558 struct vnt_private *priv = hw->priv; 559 int i; 560 561 if (!priv) 562 return; 563 564 for (i = 0; i < MAX_KEY_TABLE; i++) 565 vnt_mac_disable_keyentry(priv, i); 566 567 /* clear all keys */ 568 priv->key_entry_inuse = 0; 569 570 if (!test_bit(DEVICE_FLAGS_UNPLUG, &priv->flags)) 571 vnt_mac_shutdown(priv); 572 573 ieee80211_stop_queues(hw); 574 575 set_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags); 576 577 cancel_delayed_work_sync(&priv->run_command_work); 578 579 priv->cmd_running = false; 580 581 vnt_free_tx_bufs(priv); 582 vnt_free_rx_bufs(priv); 583 vnt_free_int_bufs(priv); 584 585 usb_kill_urb(priv->interrupt_urb); 586 usb_free_urb(priv->interrupt_urb); 587} 588 589static int vnt_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 590{ 591 struct vnt_private *priv = hw->priv; 592 593 priv->vif = vif; 594 595 switch (vif->type) { 596 case NL80211_IFTYPE_STATION: 597 break; 598 case NL80211_IFTYPE_ADHOC: 599 vnt_mac_reg_bits_off(priv, MAC_REG_RCR, RCR_UNICAST); 600 601 vnt_mac_reg_bits_on(priv, MAC_REG_HOSTCR, HOSTCR_ADHOC); 602 603 break; 604 case NL80211_IFTYPE_AP: 605 vnt_mac_reg_bits_off(priv, MAC_REG_RCR, RCR_UNICAST); 606 607 vnt_mac_reg_bits_on(priv, MAC_REG_HOSTCR, HOSTCR_AP); 608 609 break; 610 default: 611 return -EOPNOTSUPP; 612 } 613 614 priv->op_mode = vif->type; 615 616 vnt_set_bss_mode(priv); 617 618 /* LED blink on TX */ 619 vnt_mac_set_led(priv, LEDSTS_STS, LEDSTS_INTER); 620 621 return 0; 622} 623 624static void vnt_remove_interface(struct ieee80211_hw *hw, 625 struct ieee80211_vif *vif) 626{ 627 struct vnt_private *priv = hw->priv; 628 629 switch (vif->type) { 630 case NL80211_IFTYPE_STATION: 631 break; 632 case NL80211_IFTYPE_ADHOC: 633 vnt_mac_reg_bits_off(priv, MAC_REG_TCR, TCR_AUTOBCNTX); 634 vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN); 635 vnt_mac_reg_bits_off(priv, MAC_REG_HOSTCR, HOSTCR_ADHOC); 636 break; 637 case NL80211_IFTYPE_AP: 638 vnt_mac_reg_bits_off(priv, MAC_REG_TCR, TCR_AUTOBCNTX); 639 vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN); 640 vnt_mac_reg_bits_off(priv, MAC_REG_HOSTCR, HOSTCR_AP); 641 break; 642 default: 643 break; 644 } 645 646 vnt_radio_power_off(priv); 647 648 priv->op_mode = NL80211_IFTYPE_UNSPECIFIED; 649 650 /* LED slow blink */ 651 vnt_mac_set_led(priv, LEDSTS_STS, LEDSTS_SLOW); 652} 653 654static int vnt_config(struct ieee80211_hw *hw, u32 changed) 655{ 656 struct vnt_private *priv = hw->priv; 657 struct ieee80211_conf *conf = &hw->conf; 658 u8 bb_type; 659 660 if (changed & IEEE80211_CONF_CHANGE_PS) { 661 if (conf->flags & IEEE80211_CONF_PS) 662 vnt_enable_power_saving(priv, conf->listen_interval); 663 else 664 vnt_disable_power_saving(priv); 665 } 666 667 if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || 668 (conf->flags & IEEE80211_CONF_OFFCHANNEL)) { 669 vnt_set_channel(priv, conf->chandef.chan->hw_value); 670 671 if (conf->chandef.chan->band == IEEE80211_BAND_5GHZ) 672 bb_type = BB_TYPE_11A; 673 else 674 bb_type = BB_TYPE_11G; 675 676 if (priv->bb_type != bb_type) { 677 priv->bb_type = bb_type; 678 679 vnt_set_bss_mode(priv); 680 } 681 } 682 683 if (changed & IEEE80211_CONF_CHANGE_POWER) { 684 if (priv->bb_type == BB_TYPE_11B) 685 priv->current_rate = RATE_1M; 686 else 687 priv->current_rate = RATE_54M; 688 689 vnt_rf_setpower(priv, priv->current_rate, 690 conf->chandef.chan->hw_value); 691 } 692 693 return 0; 694} 695 696static void vnt_bss_info_changed(struct ieee80211_hw *hw, 697 struct ieee80211_vif *vif, struct ieee80211_bss_conf *conf, 698 u32 changed) 699{ 700 struct vnt_private *priv = hw->priv; 701 702 priv->current_aid = conf->aid; 703 704 if (changed & BSS_CHANGED_BSSID && conf->bssid) 705 vnt_mac_set_bssid_addr(priv, (u8 *)conf->bssid); 706 707 708 if (changed & BSS_CHANGED_BASIC_RATES) { 709 priv->basic_rates = conf->basic_rates; 710 711 vnt_update_top_rates(priv); 712 713 dev_dbg(&priv->usb->dev, "basic rates %x\n", conf->basic_rates); 714 } 715 716 if (changed & BSS_CHANGED_ERP_PREAMBLE) { 717 if (conf->use_short_preamble) { 718 vnt_mac_enable_barker_preamble_mode(priv); 719 priv->preamble_type = true; 720 } else { 721 vnt_mac_disable_barker_preamble_mode(priv); 722 priv->preamble_type = false; 723 } 724 } 725 726 if (changed & BSS_CHANGED_ERP_CTS_PROT) { 727 if (conf->use_cts_prot) 728 vnt_mac_enable_protect_mode(priv); 729 else 730 vnt_mac_disable_protect_mode(priv); 731 } 732 733 if (changed & BSS_CHANGED_ERP_SLOT) { 734 if (conf->use_short_slot) 735 priv->short_slot_time = true; 736 else 737 priv->short_slot_time = false; 738 739 vnt_set_short_slot_time(priv); 740 vnt_set_vga_gain_offset(priv, priv->bb_vga[0]); 741 vnt_update_pre_ed_threshold(priv, false); 742 } 743 744 if (changed & BSS_CHANGED_TXPOWER) 745 vnt_rf_setpower(priv, priv->current_rate, 746 conf->chandef.chan->hw_value); 747 748 if (changed & BSS_CHANGED_BEACON_ENABLED) { 749 dev_dbg(&priv->usb->dev, 750 "Beacon enable %d\n", conf->enable_beacon); 751 752 if (conf->enable_beacon) { 753 vnt_beacon_enable(priv, vif, conf); 754 755 vnt_mac_reg_bits_on(priv, MAC_REG_TCR, TCR_AUTOBCNTX); 756 } else { 757 vnt_mac_reg_bits_off(priv, MAC_REG_TCR, TCR_AUTOBCNTX); 758 } 759 } 760} 761 762static u64 vnt_prepare_multicast(struct ieee80211_hw *hw, 763 struct netdev_hw_addr_list *mc_list) 764{ 765 struct vnt_private *priv = hw->priv; 766 struct netdev_hw_addr *ha; 767 u64 mc_filter = 0; 768 u32 bit_nr = 0; 769 770 netdev_hw_addr_list_for_each(ha, mc_list) { 771 bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26; 772 773 mc_filter |= 1ULL << (bit_nr & 0x3f); 774 } 775 776 priv->mc_list_count = mc_list->count; 777 778 return mc_filter; 779} 780 781static void vnt_configure(struct ieee80211_hw *hw, 782 unsigned int changed_flags, unsigned int *total_flags, u64 multicast) 783{ 784 struct vnt_private *priv = hw->priv; 785 u8 rx_mode = 0; 786 int rc; 787 788 *total_flags &= FIF_ALLMULTI | FIF_OTHER_BSS | FIF_PROMISC_IN_BSS | 789 FIF_BCN_PRBRESP_PROMISC; 790 791 rc = vnt_control_in(priv, MESSAGE_TYPE_READ, MAC_REG_RCR, 792 MESSAGE_REQUEST_MACREG, sizeof(u8), &rx_mode); 793 794 if (!rc) 795 rx_mode = RCR_MULTICAST | RCR_BROADCAST; 796 797 dev_dbg(&priv->usb->dev, "rx mode in = %x\n", rx_mode); 798 799 if (changed_flags & FIF_PROMISC_IN_BSS) { 800 /* unconditionally log net taps */ 801 if (*total_flags & FIF_PROMISC_IN_BSS) 802 rx_mode |= RCR_UNICAST; 803 else 804 rx_mode &= ~RCR_UNICAST; 805 } 806 807 if (changed_flags & FIF_ALLMULTI) { 808 if (*total_flags & FIF_ALLMULTI) { 809 if (priv->mc_list_count > 2) 810 vnt_mac_set_filter(priv, ~0); 811 else 812 vnt_mac_set_filter(priv, multicast); 813 814 rx_mode |= RCR_MULTICAST | RCR_BROADCAST; 815 } else { 816 rx_mode &= ~(RCR_MULTICAST | RCR_BROADCAST); 817 } 818 819 } 820 821 if (changed_flags & (FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC)) { 822 if (*total_flags & (FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC)) 823 rx_mode &= ~RCR_BSSID; 824 else 825 rx_mode |= RCR_BSSID; 826 } 827 828 vnt_control_out_u8(priv, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, rx_mode); 829 830 dev_dbg(&priv->usb->dev, "rx mode out= %x\n", rx_mode); 831} 832 833static int vnt_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 834 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 835 struct ieee80211_key_conf *key) 836{ 837 struct vnt_private *priv = hw->priv; 838 839 switch (cmd) { 840 case SET_KEY: 841 if (vnt_set_keys(hw, sta, vif, key)) 842 return -EOPNOTSUPP; 843 break; 844 case DISABLE_KEY: 845 if (test_bit(key->hw_key_idx, &priv->key_entry_inuse)) 846 clear_bit(key->hw_key_idx, &priv->key_entry_inuse); 847 default: 848 break; 849 } 850 851 return 0; 852} 853 854static void vnt_sw_scan_start(struct ieee80211_hw *hw, 855 struct ieee80211_vif *vif, 856 const u8 *addr) 857{ 858 struct vnt_private *priv = hw->priv; 859 860 vnt_set_bss_mode(priv); 861 /* Set max sensitivity*/ 862 vnt_update_pre_ed_threshold(priv, true); 863} 864 865static void vnt_sw_scan_complete(struct ieee80211_hw *hw, 866 struct ieee80211_vif *vif) 867{ 868 struct vnt_private *priv = hw->priv; 869 870 /* Return sensitivity to channel level*/ 871 vnt_update_pre_ed_threshold(priv, false); 872} 873 874static int vnt_get_stats(struct ieee80211_hw *hw, 875 struct ieee80211_low_level_stats *stats) 876{ 877 struct vnt_private *priv = hw->priv; 878 879 memcpy(stats, &priv->low_stats, sizeof(*stats)); 880 881 return 0; 882} 883 884static u64 vnt_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 885{ 886 struct vnt_private *priv = hw->priv; 887 888 return priv->current_tsf; 889} 890 891static void vnt_set_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 892 u64 tsf) 893{ 894 struct vnt_private *priv = hw->priv; 895 896 vnt_update_next_tbtt(priv, tsf, vif->bss_conf.beacon_int); 897} 898 899static void vnt_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 900{ 901 struct vnt_private *priv = hw->priv; 902 903 vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN); 904 905 vnt_clear_current_tsf(priv); 906} 907 908static const struct ieee80211_ops vnt_mac_ops = { 909 .tx = vnt_tx_80211, 910 .start = vnt_start, 911 .stop = vnt_stop, 912 .add_interface = vnt_add_interface, 913 .remove_interface = vnt_remove_interface, 914 .config = vnt_config, 915 .bss_info_changed = vnt_bss_info_changed, 916 .prepare_multicast = vnt_prepare_multicast, 917 .configure_filter = vnt_configure, 918 .set_key = vnt_set_key, 919 .sw_scan_start = vnt_sw_scan_start, 920 .sw_scan_complete = vnt_sw_scan_complete, 921 .get_stats = vnt_get_stats, 922 .get_tsf = vnt_get_tsf, 923 .set_tsf = vnt_set_tsf, 924 .reset_tsf = vnt_reset_tsf, 925}; 926 927int vnt_init(struct vnt_private *priv) 928{ 929 930 if (!(vnt_init_registers(priv))) 931 return -EAGAIN; 932 933 SET_IEEE80211_PERM_ADDR(priv->hw, priv->permanent_net_addr); 934 935 vnt_init_bands(priv); 936 937 if (ieee80211_register_hw(priv->hw)) 938 return -ENODEV; 939 940 priv->mac_hw = true; 941 942 vnt_radio_power_off(priv); 943 944 return 0; 945} 946 947static int 948vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id) 949{ 950 struct usb_device *udev; 951 struct vnt_private *priv; 952 struct ieee80211_hw *hw; 953 struct wiphy *wiphy; 954 int rc = 0; 955 956 udev = usb_get_dev(interface_to_usbdev(intf)); 957 958 dev_notice(&udev->dev, "%s Ver. %s\n", 959 DEVICE_FULL_DRV_NAM, DEVICE_VERSION); 960 dev_notice(&udev->dev, 961 "Copyright (c) 2004 VIA Networking Technologies, Inc.\n"); 962 963 hw = ieee80211_alloc_hw(sizeof(struct vnt_private), &vnt_mac_ops); 964 if (!hw) { 965 dev_err(&udev->dev, "could not register ieee80211_hw\n"); 966 rc = -ENOMEM; 967 goto err_nomem; 968 } 969 970 priv = hw->priv; 971 priv->hw = hw; 972 priv->usb = udev; 973 974 vnt_set_options(priv); 975 976 spin_lock_init(&priv->lock); 977 mutex_init(&priv->usb_lock); 978 979 INIT_DELAYED_WORK(&priv->run_command_work, vnt_run_command); 980 981 usb_set_intfdata(intf, priv); 982 983 wiphy = priv->hw->wiphy; 984 985 wiphy->frag_threshold = FRAG_THRESH_DEF; 986 wiphy->rts_threshold = RTS_THRESH_DEF; 987 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 988 BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP); 989 990 priv->hw->flags = IEEE80211_HW_RX_INCLUDES_FCS | 991 IEEE80211_HW_REPORTS_TX_ACK_STATUS | 992 IEEE80211_HW_SIGNAL_DBM | 993 IEEE80211_HW_TIMING_BEACON_ONLY; 994 995 priv->hw->max_signal = 100; 996 997 SET_IEEE80211_DEV(priv->hw, &intf->dev); 998 999 usb_device_reset(priv); 1000 1001 clear_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags); 1002 vnt_reset_command_timer(priv); 1003 1004 vnt_schedule_command(priv, WLAN_CMD_INIT_MAC80211); 1005 1006 return 0; 1007 1008err_nomem: 1009 usb_put_dev(udev); 1010 1011 return rc; 1012} 1013 1014static void vt6656_disconnect(struct usb_interface *intf) 1015{ 1016 struct vnt_private *priv = usb_get_intfdata(intf); 1017 1018 if (!priv) 1019 return; 1020 1021 if (priv->mac_hw) 1022 ieee80211_unregister_hw(priv->hw); 1023 1024 usb_set_intfdata(intf, NULL); 1025 usb_put_dev(interface_to_usbdev(intf)); 1026 1027 set_bit(DEVICE_FLAGS_UNPLUG, &priv->flags); 1028 1029 ieee80211_free_hw(priv->hw); 1030} 1031 1032#ifdef CONFIG_PM 1033 1034static int vt6656_suspend(struct usb_interface *intf, pm_message_t message) 1035{ 1036 return 0; 1037} 1038 1039static int vt6656_resume(struct usb_interface *intf) 1040{ 1041 return 0; 1042} 1043 1044#endif /* CONFIG_PM */ 1045 1046MODULE_DEVICE_TABLE(usb, vt6656_table); 1047 1048static struct usb_driver vt6656_driver = { 1049 .name = DEVICE_NAME, 1050 .probe = vt6656_probe, 1051 .disconnect = vt6656_disconnect, 1052 .id_table = vt6656_table, 1053#ifdef CONFIG_PM 1054 .suspend = vt6656_suspend, 1055 .resume = vt6656_resume, 1056#endif /* CONFIG_PM */ 1057}; 1058 1059module_usb_driver(vt6656_driver); 1060