2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
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.
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.
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.
21 * Purpose: driver entry for initial, open, close, tx and rx.
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.
37 #include <linux/etherdevice.h>
38 #include <linux/file.h>
54 * define module options
57 /* version information */
58 #define DRIVER_AUTHOR \
59 "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
60 MODULE_AUTHOR(DRIVER_AUTHOR
);
61 MODULE_LICENSE("GPL");
62 MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM
);
64 #define RX_DESC_DEF0 64
65 static int vnt_rx_buffers
= RX_DESC_DEF0
;
66 module_param_named(rx_buffers
, vnt_rx_buffers
, int, 0644);
67 MODULE_PARM_DESC(rx_buffers
, "Number of receive usb rx buffers");
69 #define TX_DESC_DEF0 64
70 static int vnt_tx_buffers
= TX_DESC_DEF0
;
71 module_param_named(tx_buffers
, vnt_tx_buffers
, int, 0644);
72 MODULE_PARM_DESC(tx_buffers
, "Number of receive usb tx buffers");
74 #define RTS_THRESH_DEF 2347
75 #define FRAG_THRESH_DEF 2346
76 #define SHORT_RETRY_DEF 8
77 #define LONG_RETRY_DEF 4
79 /* BasebandType[] baseband type selected
80 0: indicate 802.11a type
81 1: indicate 802.11b type
82 2: indicate 802.11g type
85 #define BBP_TYPE_DEF 2
88 * Static vars definitions
91 static struct usb_device_id vt6656_table
[] = {
92 {USB_DEVICE(VNT_USB_VENDOR_ID
, VNT_USB_PRODUCT_ID
)},
96 static void vnt_set_options(struct vnt_private
*priv
)
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
;
102 priv
->num_tx_context
= vnt_tx_buffers
;
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
;
108 priv
->num_rcb
= vnt_rx_buffers
;
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;
121 * initialization of MAC & BBP registers
123 static int vnt_init_registers(struct vnt_private
*priv
)
125 struct vnt_cmd_card_init
*init_cmd
= &priv
->init_command
;
126 struct vnt_rsp_card_init
*init_rsp
= &priv
->init_response
;
129 int status
= STATUS_SUCCESS
;
131 u8 calib_tx_iq
= 0, calib_tx_dc
= 0, calib_rx_iq
= 0;
133 dev_dbg(&priv
->usb
->dev
, "---->INIbInitAdapter. [%d][%d]\n",
134 DEVICE_INIT_COLD
, priv
->packet_type
);
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");
144 dev_dbg(&priv
->usb
->dev
, "FIRMWAREbDownload fail\n");
149 if (!vnt_vt3184_init(priv
)) {
150 dev_dbg(&priv
->usb
->dev
, "vnt_vt3184_init fail\n");
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
;
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");
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");
178 /* local ID for AES functions */
179 status
= vnt_control_in(priv
, MESSAGE_TYPE_READ
,
180 MAC_REG_LOCALID
, MESSAGE_REQUEST_MACREG
, 1,
182 if (status
!= STATUS_SUCCESS
)
185 /* do MACbSoftwareReset in MACvInitialize */
187 priv
->top_ofdm_basic_rate
= RATE_24M
;
188 priv
->top_cck_basic_rate
= RATE_1M
;
190 /* target to IF pin while programming to RF chip */
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
;
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
;
209 * original zonetype is USA, but custom zonetype is Europe,
210 * then need to recover 12, 13, 14 channels with 11 channel
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];
217 priv
->ofdm_pwr_a
= 0x34; /* same as RFbMA2829SelectChannel */
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
];
224 if (priv
->ofdm_a_pwr_tbl
[ii
] == 0)
225 priv
->ofdm_a_pwr_tbl
[ii
] = priv
->ofdm_pwr_a
;
228 antenna
= priv
->eeprom
[EEP_OFS_ANTENNA
];
230 if (antenna
& EEP_ANTINV
)
231 priv
->tx_rx_ant_inv
= true;
233 priv
->tx_rx_ant_inv
= false;
235 antenna
&= (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
);
237 if (antenna
== 0) /* if not set default is both */
238 antenna
= (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
);
240 if (antenna
== (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
)) {
241 priv
->tx_antenna_mode
= ANT_B
;
242 priv
->rx_antenna_sel
= 1;
244 if (priv
->tx_rx_ant_inv
== true)
245 priv
->rx_antenna_mode
= ANT_A
;
247 priv
->rx_antenna_mode
= ANT_B
;
249 priv
->rx_antenna_sel
= 0;
251 if (antenna
& EEP_ANTENNA_AUX
) {
252 priv
->tx_antenna_mode
= ANT_A
;
254 if (priv
->tx_rx_ant_inv
== true)
255 priv
->rx_antenna_mode
= ANT_B
;
257 priv
->rx_antenna_mode
= ANT_A
;
259 priv
->tx_antenna_mode
= ANT_B
;
261 if (priv
->tx_rx_ant_inv
== true)
262 priv
->rx_antenna_mode
= ANT_A
;
264 priv
->rx_antenna_mode
= ANT_B
;
268 /* Set initial antenna mode */
269 vnt_set_antenna_mode(priv
, priv
->rx_antenna_mode
);
271 /* get Auto Fall Back type */
272 priv
->auto_fb_ctrl
= AUTO_FB_0
;
274 /* default Auto Mode */
275 priv
->bb_type
= BB_TYPE_11G
;
278 priv
->rf_type
= init_rsp
->rf_type
;
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)) {
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
,
295 /* CR251, TX I/Q Imbalance Calibration */
296 vnt_control_out_u8(priv
,
297 MESSAGE_REQUEST_BBREG
,
300 /* CR252, TX DC-Offset Calibration */
301 vnt_control_out_u8(priv
,
302 MESSAGE_REQUEST_BBREG
,
305 /* CR253, RX I/Q Imbalance Calibration */
306 vnt_control_out_u8(priv
,
307 MESSAGE_REQUEST_BBREG
,
312 BB Calibration compensation */
313 vnt_control_out_u8(priv
,
314 MESSAGE_REQUEST_BBREG
,
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
);
325 /* if exist SW network address, use it */
326 dev_dbg(&priv
->usb
->dev
, "Network address = %pM\n",
327 priv
->current_net_addr
);
330 * set BB and packet type at the same time
331 * set Short Slot Time, xIFS, and RSPINF
333 if (priv
->bb_type
== BB_TYPE_11A
)
334 priv
->short_slot_time
= true;
336 priv
->short_slot_time
= false;
338 vnt_set_short_slot_time(priv
);
340 priv
->radio_ctl
= priv
->eeprom
[EEP_OFS_RADIOCTL
];
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
);
346 if (status
!= STATUS_SUCCESS
)
349 if ((tmp
& GPIO3_DATA
) == 0)
350 vnt_mac_reg_bits_on(priv
, MAC_REG_GPIOCTL1
,
353 vnt_mac_reg_bits_off(priv
, MAC_REG_GPIOCTL1
,
357 vnt_mac_set_led(priv
, LEDSTS_TMLEN
, 0x38);
359 vnt_mac_set_led(priv
, LEDSTS_STS
, LEDSTS_SLOW
);
361 vnt_mac_reg_bits_on(priv
, MAC_REG_GPIOCTL0
, 0x01);
363 vnt_radio_power_on(priv
);
365 dev_dbg(&priv
->usb
->dev
, "<----INIbInitAdapter Exit\n");
370 static void vnt_free_tx_bufs(struct vnt_private
*priv
)
372 struct vnt_usb_send_context
*tx_context
;
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
);
387 static void vnt_free_rx_bufs(struct vnt_private
*priv
)
392 for (ii
= 0; ii
< priv
->num_rcb
; ii
++) {
397 /* deallocate URBs */
399 usb_kill_urb(rcb
->urb
);
400 usb_free_urb(rcb
->urb
);
405 dev_kfree_skb(rcb
->skb
);
411 static void usb_device_reset(struct vnt_private
*priv
)
415 status
= usb_reset_device(priv
->usb
);
417 dev_warn(&priv
->usb
->dev
,
418 "usb_device_reset fail status=%d\n", status
);
421 static void vnt_free_int_bufs(struct vnt_private
*priv
)
423 kfree(priv
->int_buf
.data_buf
);
426 static bool vnt_alloc_bufs(struct vnt_private
*priv
)
428 struct vnt_usb_send_context
*tx_context
;
432 for (ii
= 0; ii
< priv
->num_tx_context
; ii
++) {
433 tx_context
= kmalloc(sizeof(struct vnt_usb_send_context
),
435 if (tx_context
== NULL
)
438 priv
->tx_context
[ii
] = tx_context
;
439 tx_context
->priv
= priv
;
440 tx_context
->pkt_no
= ii
;
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");
449 tx_context
->in_use
= false;
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
);
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");
471 rcb
->skb
= dev_alloc_skb(priv
->rx_buf_sz
);
472 if (rcb
->skb
== NULL
)
478 if (vnt_submit_rx_urb(priv
, rcb
))
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");
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
);
497 vnt_free_rx_bufs(priv
);
500 vnt_free_tx_bufs(priv
);
505 static void vnt_tx_80211(struct ieee80211_hw
*hw
,
506 struct ieee80211_tx_control
*control
, struct sk_buff
*skb
)
508 struct vnt_private
*priv
= hw
->priv
;
510 ieee80211_stop_queues(hw
);
512 if (vnt_tx_packet(priv
, skb
)) {
513 ieee80211_free_txskb(hw
, skb
);
515 ieee80211_wake_queues(hw
);
519 static int vnt_start(struct ieee80211_hw
*hw
)
521 struct vnt_private
*priv
= hw
->priv
;
523 priv
->rx_buf_sz
= MAX_TOTAL_SIZE_WITH_ALL_HEADERS
;
525 if (vnt_alloc_bufs(priv
) == false) {
526 dev_dbg(&priv
->usb
->dev
, "vnt_alloc_bufs fail...\n");
530 clear_bit(DEVICE_FLAGS_DISCONNECTED
, &priv
->flags
);
532 if (vnt_init_registers(priv
) == false) {
533 dev_dbg(&priv
->usb
->dev
, " init register fail\n");
537 priv
->int_interval
= 1; /* bInterval is set to 1 */
539 vnt_int_start_interrupt(priv
);
541 ieee80211_wake_queues(hw
);
546 vnt_free_rx_bufs(priv
);
547 vnt_free_tx_bufs(priv
);
548 vnt_free_int_bufs(priv
);
550 usb_kill_urb(priv
->interrupt_urb
);
551 usb_free_urb(priv
->interrupt_urb
);
556 static void vnt_stop(struct ieee80211_hw
*hw
)
558 struct vnt_private
*priv
= hw
->priv
;
564 for (i
= 0; i
< MAX_KEY_TABLE
; i
++)
565 vnt_mac_disable_keyentry(priv
, i
);
568 priv
->key_entry_inuse
= 0;
570 if (!test_bit(DEVICE_FLAGS_UNPLUG
, &priv
->flags
))
571 vnt_mac_shutdown(priv
);
573 ieee80211_stop_queues(hw
);
575 set_bit(DEVICE_FLAGS_DISCONNECTED
, &priv
->flags
);
577 cancel_delayed_work_sync(&priv
->run_command_work
);
579 priv
->cmd_running
= false;
581 vnt_free_tx_bufs(priv
);
582 vnt_free_rx_bufs(priv
);
583 vnt_free_int_bufs(priv
);
585 usb_kill_urb(priv
->interrupt_urb
);
586 usb_free_urb(priv
->interrupt_urb
);
589 static int vnt_add_interface(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
591 struct vnt_private
*priv
= hw
->priv
;
596 case NL80211_IFTYPE_STATION
:
598 case NL80211_IFTYPE_ADHOC
:
599 vnt_mac_reg_bits_off(priv
, MAC_REG_RCR
, RCR_UNICAST
);
601 vnt_mac_reg_bits_on(priv
, MAC_REG_HOSTCR
, HOSTCR_ADHOC
);
604 case NL80211_IFTYPE_AP
:
605 vnt_mac_reg_bits_off(priv
, MAC_REG_RCR
, RCR_UNICAST
);
607 vnt_mac_reg_bits_on(priv
, MAC_REG_HOSTCR
, HOSTCR_AP
);
614 priv
->op_mode
= vif
->type
;
616 vnt_set_bss_mode(priv
);
618 /* LED blink on TX */
619 vnt_mac_set_led(priv
, LEDSTS_STS
, LEDSTS_INTER
);
624 static void vnt_remove_interface(struct ieee80211_hw
*hw
,
625 struct ieee80211_vif
*vif
)
627 struct vnt_private
*priv
= hw
->priv
;
630 case NL80211_IFTYPE_STATION
:
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
);
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
);
646 vnt_radio_power_off(priv
);
648 priv
->op_mode
= NL80211_IFTYPE_UNSPECIFIED
;
651 vnt_mac_set_led(priv
, LEDSTS_STS
, LEDSTS_SLOW
);
654 static int vnt_config(struct ieee80211_hw
*hw
, u32 changed
)
656 struct vnt_private
*priv
= hw
->priv
;
657 struct ieee80211_conf
*conf
= &hw
->conf
;
660 if (changed
& IEEE80211_CONF_CHANGE_PS
) {
661 if (conf
->flags
& IEEE80211_CONF_PS
)
662 vnt_enable_power_saving(priv
, conf
->listen_interval
);
664 vnt_disable_power_saving(priv
);
667 if ((changed
& IEEE80211_CONF_CHANGE_CHANNEL
) ||
668 (conf
->flags
& IEEE80211_CONF_OFFCHANNEL
)) {
669 vnt_set_channel(priv
, conf
->chandef
.chan
->hw_value
);
671 if (conf
->chandef
.chan
->band
== IEEE80211_BAND_5GHZ
)
672 bb_type
= BB_TYPE_11A
;
674 bb_type
= BB_TYPE_11G
;
676 if (priv
->bb_type
!= bb_type
) {
677 priv
->bb_type
= bb_type
;
679 vnt_set_bss_mode(priv
);
683 if (changed
& IEEE80211_CONF_CHANGE_POWER
) {
684 if (priv
->bb_type
== BB_TYPE_11B
)
685 priv
->current_rate
= RATE_1M
;
687 priv
->current_rate
= RATE_54M
;
689 vnt_rf_setpower(priv
, priv
->current_rate
,
690 conf
->chandef
.chan
->hw_value
);
696 static void vnt_bss_info_changed(struct ieee80211_hw
*hw
,
697 struct ieee80211_vif
*vif
, struct ieee80211_bss_conf
*conf
,
700 struct vnt_private
*priv
= hw
->priv
;
702 priv
->current_aid
= conf
->aid
;
704 if (changed
& BSS_CHANGED_BSSID
)
705 vnt_mac_set_bssid_addr(priv
, (u8
*)conf
->bssid
);
708 if (changed
& BSS_CHANGED_BASIC_RATES
) {
709 priv
->basic_rates
= conf
->basic_rates
;
711 vnt_update_top_rates(priv
);
713 dev_dbg(&priv
->usb
->dev
, "basic rates %x\n", conf
->basic_rates
);
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;
721 vnt_mac_disable_barker_preamble_mode(priv
);
722 priv
->preamble_type
= false;
726 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
727 if (conf
->use_cts_prot
)
728 vnt_mac_enable_protect_mode(priv
);
730 vnt_mac_disable_protect_mode(priv
);
733 if (changed
& BSS_CHANGED_ERP_SLOT
) {
734 if (conf
->use_short_slot
)
735 priv
->short_slot_time
= true;
737 priv
->short_slot_time
= false;
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);
744 if (changed
& BSS_CHANGED_TXPOWER
)
745 vnt_rf_setpower(priv
, priv
->current_rate
,
746 conf
->chandef
.chan
->hw_value
);
748 if (changed
& BSS_CHANGED_BEACON_ENABLED
) {
749 dev_dbg(&priv
->usb
->dev
,
750 "Beacon enable %d\n", conf
->enable_beacon
);
752 if (conf
->enable_beacon
) {
753 vnt_beacon_enable(priv
, vif
, conf
);
755 vnt_mac_reg_bits_on(priv
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
757 vnt_mac_reg_bits_off(priv
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
762 static u64
vnt_prepare_multicast(struct ieee80211_hw
*hw
,
763 struct netdev_hw_addr_list
*mc_list
)
765 struct vnt_private
*priv
= hw
->priv
;
766 struct netdev_hw_addr
*ha
;
770 netdev_hw_addr_list_for_each(ha
, mc_list
) {
771 bit_nr
= ether_crc(ETH_ALEN
, ha
->addr
) >> 26;
773 mc_filter
|= 1ULL << (bit_nr
& 0x3f);
776 priv
->mc_list_count
= mc_list
->count
;
781 static void vnt_configure(struct ieee80211_hw
*hw
,
782 unsigned int changed_flags
, unsigned int *total_flags
, u64 multicast
)
784 struct vnt_private
*priv
= hw
->priv
;
788 *total_flags
&= FIF_ALLMULTI
| FIF_OTHER_BSS
| FIF_BCN_PRBRESP_PROMISC
;
790 rc
= vnt_control_in(priv
, MESSAGE_TYPE_READ
, MAC_REG_RCR
,
791 MESSAGE_REQUEST_MACREG
, sizeof(u8
), &rx_mode
);
794 rx_mode
= RCR_MULTICAST
| RCR_BROADCAST
;
796 dev_dbg(&priv
->usb
->dev
, "rx mode in = %x\n", rx_mode
);
798 if (changed_flags
& FIF_ALLMULTI
) {
799 if (*total_flags
& FIF_ALLMULTI
) {
800 if (priv
->mc_list_count
> 2)
801 vnt_mac_set_filter(priv
, ~0);
803 vnt_mac_set_filter(priv
, multicast
);
805 rx_mode
|= RCR_MULTICAST
| RCR_BROADCAST
;
807 rx_mode
&= ~(RCR_MULTICAST
| RCR_BROADCAST
);
812 if (changed_flags
& (FIF_OTHER_BSS
| FIF_BCN_PRBRESP_PROMISC
)) {
813 if (*total_flags
& (FIF_OTHER_BSS
| FIF_BCN_PRBRESP_PROMISC
))
814 rx_mode
&= ~RCR_BSSID
;
816 rx_mode
|= RCR_BSSID
;
819 vnt_control_out_u8(priv
, MESSAGE_REQUEST_MACREG
, MAC_REG_RCR
, rx_mode
);
821 dev_dbg(&priv
->usb
->dev
, "rx mode out= %x\n", rx_mode
);
824 static int vnt_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
825 struct ieee80211_vif
*vif
, struct ieee80211_sta
*sta
,
826 struct ieee80211_key_conf
*key
)
828 struct vnt_private
*priv
= hw
->priv
;
832 if (vnt_set_keys(hw
, sta
, vif
, key
))
836 if (test_bit(key
->hw_key_idx
, &priv
->key_entry_inuse
))
837 clear_bit(key
->hw_key_idx
, &priv
->key_entry_inuse
);
845 static void vnt_sw_scan_start(struct ieee80211_hw
*hw
,
846 struct ieee80211_vif
*vif
,
849 struct vnt_private
*priv
= hw
->priv
;
851 vnt_set_bss_mode(priv
);
852 /* Set max sensitivity*/
853 vnt_update_pre_ed_threshold(priv
, true);
856 static void vnt_sw_scan_complete(struct ieee80211_hw
*hw
,
857 struct ieee80211_vif
*vif
)
859 struct vnt_private
*priv
= hw
->priv
;
861 /* Return sensitivity to channel level*/
862 vnt_update_pre_ed_threshold(priv
, false);
865 static int vnt_get_stats(struct ieee80211_hw
*hw
,
866 struct ieee80211_low_level_stats
*stats
)
868 struct vnt_private
*priv
= hw
->priv
;
870 memcpy(stats
, &priv
->low_stats
, sizeof(*stats
));
875 static u64
vnt_get_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
877 struct vnt_private
*priv
= hw
->priv
;
879 return priv
->current_tsf
;
882 static void vnt_set_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
885 struct vnt_private
*priv
= hw
->priv
;
887 vnt_update_next_tbtt(priv
, tsf
, vif
->bss_conf
.beacon_int
);
890 static void vnt_reset_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
892 struct vnt_private
*priv
= hw
->priv
;
894 vnt_mac_reg_bits_off(priv
, MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
896 vnt_clear_current_tsf(priv
);
899 static const struct ieee80211_ops vnt_mac_ops
= {
903 .add_interface
= vnt_add_interface
,
904 .remove_interface
= vnt_remove_interface
,
905 .config
= vnt_config
,
906 .bss_info_changed
= vnt_bss_info_changed
,
907 .prepare_multicast
= vnt_prepare_multicast
,
908 .configure_filter
= vnt_configure
,
909 .set_key
= vnt_set_key
,
910 .sw_scan_start
= vnt_sw_scan_start
,
911 .sw_scan_complete
= vnt_sw_scan_complete
,
912 .get_stats
= vnt_get_stats
,
913 .get_tsf
= vnt_get_tsf
,
914 .set_tsf
= vnt_set_tsf
,
915 .reset_tsf
= vnt_reset_tsf
,
918 int vnt_init(struct vnt_private
*priv
)
921 if (!(vnt_init_registers(priv
)))
924 SET_IEEE80211_PERM_ADDR(priv
->hw
, priv
->permanent_net_addr
);
926 vnt_init_bands(priv
);
928 if (ieee80211_register_hw(priv
->hw
))
933 vnt_radio_power_off(priv
);
939 vt6656_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
941 struct usb_device
*udev
;
942 struct vnt_private
*priv
;
943 struct ieee80211_hw
*hw
;
947 udev
= usb_get_dev(interface_to_usbdev(intf
));
949 dev_notice(&udev
->dev
, "%s Ver. %s\n",
950 DEVICE_FULL_DRV_NAM
, DEVICE_VERSION
);
951 dev_notice(&udev
->dev
,
952 "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
954 hw
= ieee80211_alloc_hw(sizeof(struct vnt_private
), &vnt_mac_ops
);
956 dev_err(&udev
->dev
, "could not register ieee80211_hw\n");
965 vnt_set_options(priv
);
967 spin_lock_init(&priv
->lock
);
968 mutex_init(&priv
->usb_lock
);
970 INIT_DELAYED_WORK(&priv
->run_command_work
, vnt_run_command
);
972 usb_set_intfdata(intf
, priv
);
974 wiphy
= priv
->hw
->wiphy
;
976 wiphy
->frag_threshold
= FRAG_THRESH_DEF
;
977 wiphy
->rts_threshold
= RTS_THRESH_DEF
;
978 wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
979 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
);
981 ieee80211_hw_set(priv
->hw
, TIMING_BEACON_ONLY
);
982 ieee80211_hw_set(priv
->hw
, SIGNAL_DBM
);
983 ieee80211_hw_set(priv
->hw
, RX_INCLUDES_FCS
);
984 ieee80211_hw_set(priv
->hw
, REPORTS_TX_ACK_STATUS
);
986 priv
->hw
->max_signal
= 100;
988 SET_IEEE80211_DEV(priv
->hw
, &intf
->dev
);
990 usb_device_reset(priv
);
992 clear_bit(DEVICE_FLAGS_DISCONNECTED
, &priv
->flags
);
993 vnt_reset_command_timer(priv
);
995 vnt_schedule_command(priv
, WLAN_CMD_INIT_MAC80211
);
1005 static void vt6656_disconnect(struct usb_interface
*intf
)
1007 struct vnt_private
*priv
= usb_get_intfdata(intf
);
1013 ieee80211_unregister_hw(priv
->hw
);
1015 usb_set_intfdata(intf
, NULL
);
1016 usb_put_dev(interface_to_usbdev(intf
));
1018 set_bit(DEVICE_FLAGS_UNPLUG
, &priv
->flags
);
1020 ieee80211_free_hw(priv
->hw
);
1025 static int vt6656_suspend(struct usb_interface
*intf
, pm_message_t message
)
1030 static int vt6656_resume(struct usb_interface
*intf
)
1035 #endif /* CONFIG_PM */
1037 MODULE_DEVICE_TABLE(usb
, vt6656_table
);
1039 static struct usb_driver vt6656_driver
= {
1040 .name
= DEVICE_NAME
,
1041 .probe
= vt6656_probe
,
1042 .disconnect
= vt6656_disconnect
,
1043 .id_table
= vt6656_table
,
1045 .suspend
= vt6656_suspend
,
1046 .resume
= vt6656_resume
,
1047 #endif /* CONFIG_PM */
1050 module_usb_driver(vt6656_driver
);