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.
18 * Purpose: driver entry for initial, open, close, tx and rx.
26 * vt6656_probe - module initial (insmod) driver entry
27 * vnt_free_tx_bufs - free tx buffer function
28 * vnt_init_registers- initial MAC & BBP & RF internal registers.
34 #include <linux/etherdevice.h>
35 #include <linux/file.h>
51 * define module options
54 /* version information */
55 #define DRIVER_AUTHOR \
56 "VIA Networking Technologies, Inc., <lyndonchen@vntek.com.tw>"
57 MODULE_AUTHOR(DRIVER_AUTHOR
);
58 MODULE_LICENSE("GPL");
59 MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM
);
61 #define RX_DESC_DEF0 64
62 static int vnt_rx_buffers
= RX_DESC_DEF0
;
63 module_param_named(rx_buffers
, vnt_rx_buffers
, int, 0644);
64 MODULE_PARM_DESC(rx_buffers
, "Number of receive usb rx buffers");
66 #define TX_DESC_DEF0 64
67 static int vnt_tx_buffers
= TX_DESC_DEF0
;
68 module_param_named(tx_buffers
, vnt_tx_buffers
, int, 0644);
69 MODULE_PARM_DESC(tx_buffers
, "Number of receive usb tx buffers");
71 #define RTS_THRESH_DEF 2347
72 #define FRAG_THRESH_DEF 2346
73 #define SHORT_RETRY_DEF 8
74 #define LONG_RETRY_DEF 4
76 /* BasebandType[] baseband type selected
77 * 0: indicate 802.11a type
78 * 1: indicate 802.11b type
79 * 2: indicate 802.11g type
82 #define BBP_TYPE_DEF 2
85 * Static vars definitions
88 static const struct usb_device_id vt6656_table
[] = {
89 {USB_DEVICE(VNT_USB_VENDOR_ID
, VNT_USB_PRODUCT_ID
)},
93 static void vnt_set_options(struct vnt_private
*priv
)
95 /* Set number of TX buffers */
96 if (vnt_tx_buffers
< CB_MIN_TX_DESC
|| vnt_tx_buffers
> CB_MAX_TX_DESC
)
97 priv
->num_tx_context
= TX_DESC_DEF0
;
99 priv
->num_tx_context
= vnt_tx_buffers
;
101 /* Set number of RX buffers */
102 if (vnt_rx_buffers
< CB_MIN_RX_DESC
|| vnt_rx_buffers
> CB_MAX_RX_DESC
)
103 priv
->num_rcb
= RX_DESC_DEF0
;
105 priv
->num_rcb
= vnt_rx_buffers
;
107 priv
->short_retry_limit
= SHORT_RETRY_DEF
;
108 priv
->long_retry_limit
= LONG_RETRY_DEF
;
109 priv
->op_mode
= NL80211_IFTYPE_UNSPECIFIED
;
110 priv
->bb_type
= BBP_TYPE_DEF
;
111 priv
->packet_type
= priv
->bb_type
;
112 priv
->auto_fb_ctrl
= AUTO_FB_0
;
113 priv
->preamble_type
= 0;
114 priv
->exist_sw_net_addr
= false;
118 * initialization of MAC & BBP registers
120 static int vnt_init_registers(struct vnt_private
*priv
)
122 struct vnt_cmd_card_init
*init_cmd
= &priv
->init_command
;
123 struct vnt_rsp_card_init
*init_rsp
= &priv
->init_response
;
126 int status
= STATUS_SUCCESS
;
128 u8 calib_tx_iq
= 0, calib_tx_dc
= 0, calib_rx_iq
= 0;
130 dev_dbg(&priv
->usb
->dev
, "---->INIbInitAdapter. [%d][%d]\n",
131 DEVICE_INIT_COLD
, priv
->packet_type
);
133 if (!vnt_check_firmware_version(priv
)) {
134 if (vnt_download_firmware(priv
) == true) {
135 if (vnt_firmware_branch_to_sram(priv
) == false) {
136 dev_dbg(&priv
->usb
->dev
,
137 " vnt_firmware_branch_to_sram fail\n");
141 dev_dbg(&priv
->usb
->dev
, "FIRMWAREbDownload fail\n");
146 if (!vnt_vt3184_init(priv
)) {
147 dev_dbg(&priv
->usb
->dev
, "vnt_vt3184_init fail\n");
151 init_cmd
->init_class
= DEVICE_INIT_COLD
;
152 init_cmd
->exist_sw_net_addr
= priv
->exist_sw_net_addr
;
153 for (ii
= 0; ii
< 6; ii
++)
154 init_cmd
->sw_net_addr
[ii
] = priv
->current_net_addr
[ii
];
155 init_cmd
->short_retry_limit
= priv
->short_retry_limit
;
156 init_cmd
->long_retry_limit
= priv
->long_retry_limit
;
158 /* issue card_init command to device */
159 status
= vnt_control_out(priv
, MESSAGE_TYPE_CARDINIT
, 0, 0,
160 sizeof(struct vnt_cmd_card_init
),
162 if (status
!= STATUS_SUCCESS
) {
163 dev_dbg(&priv
->usb
->dev
, "Issue Card init fail\n");
167 status
= vnt_control_in(priv
, MESSAGE_TYPE_INIT_RSP
, 0, 0,
168 sizeof(struct vnt_rsp_card_init
),
170 if (status
!= STATUS_SUCCESS
) {
171 dev_dbg(&priv
->usb
->dev
,
172 "Cardinit request in status fail!\n");
176 /* local ID for AES functions */
177 status
= vnt_control_in(priv
, MESSAGE_TYPE_READ
, MAC_REG_LOCALID
,
178 MESSAGE_REQUEST_MACREG
, 1, &priv
->local_id
);
179 if (status
!= STATUS_SUCCESS
)
182 /* do MACbSoftwareReset in MACvInitialize */
184 priv
->top_ofdm_basic_rate
= RATE_24M
;
185 priv
->top_cck_basic_rate
= RATE_1M
;
187 /* target to IF pin while programming to RF chip */
190 priv
->cck_pwr
= priv
->eeprom
[EEP_OFS_PWR_CCK
];
191 priv
->ofdm_pwr_g
= priv
->eeprom
[EEP_OFS_PWR_OFDMG
];
192 /* load power table */
193 for (ii
= 0; ii
< 14; ii
++) {
194 priv
->cck_pwr_tbl
[ii
] =
195 priv
->eeprom
[ii
+ EEP_OFS_CCK_PWR_TBL
];
196 if (priv
->cck_pwr_tbl
[ii
] == 0)
197 priv
->cck_pwr_tbl
[ii
] = priv
->cck_pwr
;
199 priv
->ofdm_pwr_tbl
[ii
] =
200 priv
->eeprom
[ii
+ EEP_OFS_OFDM_PWR_TBL
];
201 if (priv
->ofdm_pwr_tbl
[ii
] == 0)
202 priv
->ofdm_pwr_tbl
[ii
] = priv
->ofdm_pwr_g
;
206 * original zonetype is USA, but custom zonetype is Europe,
207 * then need to recover 12, 13, 14 channels with 11 channel
209 for (ii
= 11; ii
< 14; ii
++) {
210 priv
->cck_pwr_tbl
[ii
] = priv
->cck_pwr_tbl
[10];
211 priv
->ofdm_pwr_tbl
[ii
] = priv
->ofdm_pwr_tbl
[10];
214 priv
->ofdm_pwr_a
= 0x34; /* same as RFbMA2829SelectChannel */
216 /* load OFDM A power table */
217 for (ii
= 0; ii
< CB_MAX_CHANNEL_5G
; ii
++) {
218 priv
->ofdm_a_pwr_tbl
[ii
] =
219 priv
->eeprom
[ii
+ EEP_OFS_OFDMA_PWR_TBL
];
221 if (priv
->ofdm_a_pwr_tbl
[ii
] == 0)
222 priv
->ofdm_a_pwr_tbl
[ii
] = priv
->ofdm_pwr_a
;
225 antenna
= priv
->eeprom
[EEP_OFS_ANTENNA
];
227 if (antenna
& EEP_ANTINV
)
228 priv
->tx_rx_ant_inv
= true;
230 priv
->tx_rx_ant_inv
= false;
232 antenna
&= (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
);
234 if (antenna
== 0) /* if not set default is both */
235 antenna
= (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
);
237 if (antenna
== (EEP_ANTENNA_AUX
| EEP_ANTENNA_MAIN
)) {
238 priv
->tx_antenna_mode
= ANT_B
;
239 priv
->rx_antenna_sel
= 1;
241 if (priv
->tx_rx_ant_inv
)
242 priv
->rx_antenna_mode
= ANT_A
;
244 priv
->rx_antenna_mode
= ANT_B
;
246 priv
->rx_antenna_sel
= 0;
248 if (antenna
& EEP_ANTENNA_AUX
) {
249 priv
->tx_antenna_mode
= ANT_A
;
251 if (priv
->tx_rx_ant_inv
)
252 priv
->rx_antenna_mode
= ANT_B
;
254 priv
->rx_antenna_mode
= ANT_A
;
256 priv
->tx_antenna_mode
= ANT_B
;
258 if (priv
->tx_rx_ant_inv
)
259 priv
->rx_antenna_mode
= ANT_A
;
261 priv
->rx_antenna_mode
= ANT_B
;
265 /* Set initial antenna mode */
266 vnt_set_antenna_mode(priv
, priv
->rx_antenna_mode
);
268 /* get Auto Fall Back type */
269 priv
->auto_fb_ctrl
= AUTO_FB_0
;
271 /* default Auto Mode */
272 priv
->bb_type
= BB_TYPE_11G
;
275 priv
->rf_type
= init_rsp
->rf_type
;
277 /* load vt3266 calibration parameters in EEPROM */
278 if (priv
->rf_type
== RF_VT3226D0
) {
279 if ((priv
->eeprom
[EEP_OFS_MAJOR_VER
] == 0x1) &&
280 (priv
->eeprom
[EEP_OFS_MINOR_VER
] >= 0x4)) {
281 calib_tx_iq
= priv
->eeprom
[EEP_OFS_CALIB_TX_IQ
];
282 calib_tx_dc
= priv
->eeprom
[EEP_OFS_CALIB_TX_DC
];
283 calib_rx_iq
= priv
->eeprom
[EEP_OFS_CALIB_RX_IQ
];
284 if (calib_tx_iq
|| calib_tx_dc
|| calib_rx_iq
) {
285 /* CR255, enable TX/RX IQ and
286 * DC compensation mode
288 vnt_control_out_u8(priv
,
289 MESSAGE_REQUEST_BBREG
,
292 /* CR251, TX I/Q Imbalance Calibration */
293 vnt_control_out_u8(priv
,
294 MESSAGE_REQUEST_BBREG
,
297 /* CR252, TX DC-Offset Calibration */
298 vnt_control_out_u8(priv
,
299 MESSAGE_REQUEST_BBREG
,
302 /* CR253, RX I/Q Imbalance Calibration */
303 vnt_control_out_u8(priv
,
304 MESSAGE_REQUEST_BBREG
,
309 * BB Calibration compensation
311 vnt_control_out_u8(priv
,
312 MESSAGE_REQUEST_BBREG
,
319 /* get permanent network address */
320 memcpy(priv
->permanent_net_addr
, init_rsp
->net_addr
, 6);
321 ether_addr_copy(priv
->current_net_addr
, priv
->permanent_net_addr
);
323 /* if exist SW network address, use it */
324 dev_dbg(&priv
->usb
->dev
, "Network address = %pM\n",
325 priv
->current_net_addr
);
328 * set BB and packet type at the same time
329 * set Short Slot Time, xIFS, and RSPINF
331 if (priv
->bb_type
== BB_TYPE_11A
)
332 priv
->short_slot_time
= true;
334 priv
->short_slot_time
= false;
336 vnt_set_short_slot_time(priv
);
338 priv
->radio_ctl
= priv
->eeprom
[EEP_OFS_RADIOCTL
];
340 if ((priv
->radio_ctl
& EEP_RADIOCTL_ENABLE
) != 0) {
341 status
= vnt_control_in(priv
, MESSAGE_TYPE_READ
,
343 MESSAGE_REQUEST_MACREG
, 1, &tmp
);
345 if (status
!= STATUS_SUCCESS
)
348 if ((tmp
& GPIO3_DATA
) == 0)
349 vnt_mac_reg_bits_on(priv
, MAC_REG_GPIOCTL1
,
352 vnt_mac_reg_bits_off(priv
, MAC_REG_GPIOCTL1
,
356 vnt_mac_set_led(priv
, LEDSTS_TMLEN
, 0x38);
358 vnt_mac_set_led(priv
, LEDSTS_STS
, LEDSTS_SLOW
);
360 vnt_mac_reg_bits_on(priv
, MAC_REG_GPIOCTL0
, 0x01);
362 vnt_radio_power_on(priv
);
364 dev_dbg(&priv
->usb
->dev
, "<----INIbInitAdapter Exit\n");
369 static void vnt_free_tx_bufs(struct vnt_private
*priv
)
371 struct vnt_usb_send_context
*tx_context
;
374 for (ii
= 0; ii
< priv
->num_tx_context
; ii
++) {
375 tx_context
= priv
->tx_context
[ii
];
376 /* deallocate URBs */
377 if (tx_context
->urb
) {
378 usb_kill_urb(tx_context
->urb
);
379 usb_free_urb(tx_context
->urb
);
386 static void vnt_free_rx_bufs(struct vnt_private
*priv
)
391 for (ii
= 0; ii
< priv
->num_rcb
; ii
++) {
396 /* deallocate URBs */
398 usb_kill_urb(rcb
->urb
);
399 usb_free_urb(rcb
->urb
);
404 dev_kfree_skb(rcb
->skb
);
410 static void vnt_free_int_bufs(struct vnt_private
*priv
)
412 kfree(priv
->int_buf
.data_buf
);
415 static bool vnt_alloc_bufs(struct vnt_private
*priv
)
417 struct vnt_usb_send_context
*tx_context
;
421 for (ii
= 0; ii
< priv
->num_tx_context
; ii
++) {
422 tx_context
= kmalloc(sizeof(struct vnt_usb_send_context
),
427 priv
->tx_context
[ii
] = tx_context
;
428 tx_context
->priv
= priv
;
429 tx_context
->pkt_no
= ii
;
432 tx_context
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
433 if (!tx_context
->urb
)
436 tx_context
->in_use
= false;
439 for (ii
= 0; ii
< priv
->num_rcb
; ii
++) {
440 priv
->rcb
[ii
] = kzalloc(sizeof(struct vnt_rcb
), GFP_KERNEL
);
441 if (!priv
->rcb
[ii
]) {
442 dev_err(&priv
->usb
->dev
,
443 "failed to allocate rcb no %d\n", ii
);
452 rcb
->urb
= usb_alloc_urb(0, GFP_KERNEL
);
456 rcb
->skb
= dev_alloc_skb(priv
->rx_buf_sz
);
463 if (vnt_submit_rx_urb(priv
, rcb
))
467 priv
->interrupt_urb
= usb_alloc_urb(0, GFP_KERNEL
);
468 if (!priv
->interrupt_urb
)
471 priv
->int_buf
.data_buf
= kmalloc(MAX_INTERRUPT_SIZE
, GFP_KERNEL
);
472 if (!priv
->int_buf
.data_buf
) {
473 usb_free_urb(priv
->interrupt_urb
);
480 vnt_free_rx_bufs(priv
);
483 vnt_free_tx_bufs(priv
);
488 static void vnt_tx_80211(struct ieee80211_hw
*hw
,
489 struct ieee80211_tx_control
*control
,
492 struct vnt_private
*priv
= hw
->priv
;
494 if (vnt_tx_packet(priv
, skb
))
495 ieee80211_free_txskb(hw
, skb
);
498 static int vnt_start(struct ieee80211_hw
*hw
)
500 struct vnt_private
*priv
= hw
->priv
;
502 priv
->rx_buf_sz
= MAX_TOTAL_SIZE_WITH_ALL_HEADERS
;
504 if (!vnt_alloc_bufs(priv
)) {
505 dev_dbg(&priv
->usb
->dev
, "vnt_alloc_bufs fail...\n");
509 clear_bit(DEVICE_FLAGS_DISCONNECTED
, &priv
->flags
);
511 if (vnt_init_registers(priv
) == false) {
512 dev_dbg(&priv
->usb
->dev
, " init register fail\n");
516 priv
->int_interval
= 1; /* bInterval is set to 1 */
518 vnt_int_start_interrupt(priv
);
520 ieee80211_wake_queues(hw
);
525 vnt_free_rx_bufs(priv
);
526 vnt_free_tx_bufs(priv
);
527 vnt_free_int_bufs(priv
);
529 usb_kill_urb(priv
->interrupt_urb
);
530 usb_free_urb(priv
->interrupt_urb
);
535 static void vnt_stop(struct ieee80211_hw
*hw
)
537 struct vnt_private
*priv
= hw
->priv
;
543 for (i
= 0; i
< MAX_KEY_TABLE
; i
++)
544 vnt_mac_disable_keyentry(priv
, i
);
547 priv
->key_entry_inuse
= 0;
549 if (!test_bit(DEVICE_FLAGS_UNPLUG
, &priv
->flags
))
550 vnt_mac_shutdown(priv
);
552 ieee80211_stop_queues(hw
);
554 set_bit(DEVICE_FLAGS_DISCONNECTED
, &priv
->flags
);
556 cancel_delayed_work_sync(&priv
->run_command_work
);
558 priv
->cmd_running
= false;
560 vnt_free_tx_bufs(priv
);
561 vnt_free_rx_bufs(priv
);
562 vnt_free_int_bufs(priv
);
564 usb_kill_urb(priv
->interrupt_urb
);
565 usb_free_urb(priv
->interrupt_urb
);
568 static int vnt_add_interface(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
570 struct vnt_private
*priv
= hw
->priv
;
575 case NL80211_IFTYPE_STATION
:
577 case NL80211_IFTYPE_ADHOC
:
578 vnt_mac_reg_bits_off(priv
, MAC_REG_RCR
, RCR_UNICAST
);
580 vnt_mac_reg_bits_on(priv
, MAC_REG_HOSTCR
, HOSTCR_ADHOC
);
583 case NL80211_IFTYPE_AP
:
584 vnt_mac_reg_bits_off(priv
, MAC_REG_RCR
, RCR_UNICAST
);
586 vnt_mac_reg_bits_on(priv
, MAC_REG_HOSTCR
, HOSTCR_AP
);
593 priv
->op_mode
= vif
->type
;
595 vnt_set_bss_mode(priv
);
597 /* LED blink on TX */
598 vnt_mac_set_led(priv
, LEDSTS_STS
, LEDSTS_INTER
);
603 static void vnt_remove_interface(struct ieee80211_hw
*hw
,
604 struct ieee80211_vif
*vif
)
606 struct vnt_private
*priv
= hw
->priv
;
609 case NL80211_IFTYPE_STATION
:
611 case NL80211_IFTYPE_ADHOC
:
612 vnt_mac_reg_bits_off(priv
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
613 vnt_mac_reg_bits_off(priv
, MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
614 vnt_mac_reg_bits_off(priv
, MAC_REG_HOSTCR
, HOSTCR_ADHOC
);
616 case NL80211_IFTYPE_AP
:
617 vnt_mac_reg_bits_off(priv
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
618 vnt_mac_reg_bits_off(priv
, MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
619 vnt_mac_reg_bits_off(priv
, MAC_REG_HOSTCR
, HOSTCR_AP
);
625 vnt_radio_power_off(priv
);
627 priv
->op_mode
= NL80211_IFTYPE_UNSPECIFIED
;
630 vnt_mac_set_led(priv
, LEDSTS_STS
, LEDSTS_SLOW
);
633 static int vnt_config(struct ieee80211_hw
*hw
, u32 changed
)
635 struct vnt_private
*priv
= hw
->priv
;
636 struct ieee80211_conf
*conf
= &hw
->conf
;
639 if (changed
& IEEE80211_CONF_CHANGE_PS
) {
640 if (conf
->flags
& IEEE80211_CONF_PS
)
641 vnt_enable_power_saving(priv
, conf
->listen_interval
);
643 vnt_disable_power_saving(priv
);
646 if ((changed
& IEEE80211_CONF_CHANGE_CHANNEL
) ||
647 (conf
->flags
& IEEE80211_CONF_OFFCHANNEL
)) {
648 vnt_set_channel(priv
, conf
->chandef
.chan
->hw_value
);
650 if (conf
->chandef
.chan
->band
== NL80211_BAND_5GHZ
)
651 bb_type
= BB_TYPE_11A
;
653 bb_type
= BB_TYPE_11G
;
655 if (priv
->bb_type
!= bb_type
) {
656 priv
->bb_type
= bb_type
;
658 vnt_set_bss_mode(priv
);
662 if (changed
& IEEE80211_CONF_CHANGE_POWER
) {
663 if (priv
->bb_type
== BB_TYPE_11B
)
664 priv
->current_rate
= RATE_1M
;
666 priv
->current_rate
= RATE_54M
;
668 vnt_rf_setpower(priv
, priv
->current_rate
,
669 conf
->chandef
.chan
->hw_value
);
675 static void vnt_bss_info_changed(struct ieee80211_hw
*hw
,
676 struct ieee80211_vif
*vif
,
677 struct ieee80211_bss_conf
*conf
, u32 changed
)
679 struct vnt_private
*priv
= hw
->priv
;
681 priv
->current_aid
= conf
->aid
;
683 if (changed
& BSS_CHANGED_BSSID
&& conf
->bssid
)
684 vnt_mac_set_bssid_addr(priv
, (u8
*)conf
->bssid
);
686 if (changed
& BSS_CHANGED_BASIC_RATES
) {
687 priv
->basic_rates
= conf
->basic_rates
;
689 vnt_update_top_rates(priv
);
691 dev_dbg(&priv
->usb
->dev
, "basic rates %x\n", conf
->basic_rates
);
694 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
695 if (conf
->use_short_preamble
) {
696 vnt_mac_enable_barker_preamble_mode(priv
);
697 priv
->preamble_type
= true;
699 vnt_mac_disable_barker_preamble_mode(priv
);
700 priv
->preamble_type
= false;
704 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
705 if (conf
->use_cts_prot
)
706 vnt_mac_enable_protect_mode(priv
);
708 vnt_mac_disable_protect_mode(priv
);
711 if (changed
& BSS_CHANGED_ERP_SLOT
) {
712 if (conf
->use_short_slot
)
713 priv
->short_slot_time
= true;
715 priv
->short_slot_time
= false;
717 vnt_set_short_slot_time(priv
);
718 vnt_set_vga_gain_offset(priv
, priv
->bb_vga
[0]);
719 vnt_update_pre_ed_threshold(priv
, false);
722 if (changed
& BSS_CHANGED_TXPOWER
)
723 vnt_rf_setpower(priv
, priv
->current_rate
,
724 conf
->chandef
.chan
->hw_value
);
726 if (changed
& BSS_CHANGED_BEACON_ENABLED
) {
727 dev_dbg(&priv
->usb
->dev
,
728 "Beacon enable %d\n", conf
->enable_beacon
);
730 if (conf
->enable_beacon
) {
731 vnt_beacon_enable(priv
, vif
, conf
);
733 vnt_mac_reg_bits_on(priv
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
735 vnt_mac_reg_bits_off(priv
, MAC_REG_TCR
, TCR_AUTOBCNTX
);
739 if (changed
& (BSS_CHANGED_ASSOC
| BSS_CHANGED_BEACON_INFO
) &&
740 priv
->op_mode
!= NL80211_IFTYPE_AP
) {
741 if (conf
->assoc
&& conf
->beacon_rate
) {
742 vnt_mac_reg_bits_on(priv
, MAC_REG_TFTCTL
,
745 vnt_adjust_tsf(priv
, conf
->beacon_rate
->hw_value
,
746 conf
->sync_tsf
, priv
->current_tsf
);
748 vnt_mac_set_beacon_interval(priv
, conf
->beacon_int
);
750 vnt_reset_next_tbtt(priv
, conf
->beacon_int
);
752 vnt_clear_current_tsf(priv
);
754 vnt_mac_reg_bits_off(priv
, MAC_REG_TFTCTL
,
760 static u64
vnt_prepare_multicast(struct ieee80211_hw
*hw
,
761 struct netdev_hw_addr_list
*mc_list
)
763 struct vnt_private
*priv
= hw
->priv
;
764 struct netdev_hw_addr
*ha
;
768 netdev_hw_addr_list_for_each(ha
, mc_list
) {
769 bit_nr
= ether_crc(ETH_ALEN
, ha
->addr
) >> 26;
771 mc_filter
|= 1ULL << (bit_nr
& 0x3f);
774 priv
->mc_list_count
= mc_list
->count
;
779 static void vnt_configure(struct ieee80211_hw
*hw
,
780 unsigned int changed_flags
,
781 unsigned int *total_flags
, u64 multicast
)
783 struct vnt_private
*priv
= hw
->priv
;
787 *total_flags
&= FIF_ALLMULTI
| FIF_OTHER_BSS
| FIF_BCN_PRBRESP_PROMISC
;
789 rc
= vnt_control_in(priv
, MESSAGE_TYPE_READ
, MAC_REG_RCR
,
790 MESSAGE_REQUEST_MACREG
, sizeof(u8
), &rx_mode
);
793 rx_mode
= RCR_MULTICAST
| RCR_BROADCAST
;
795 dev_dbg(&priv
->usb
->dev
, "rx mode in = %x\n", rx_mode
);
797 if (changed_flags
& FIF_ALLMULTI
) {
798 if (*total_flags
& FIF_ALLMULTI
) {
799 if (priv
->mc_list_count
> 2)
800 vnt_mac_set_filter(priv
, ~0);
802 vnt_mac_set_filter(priv
, multicast
);
804 rx_mode
|= RCR_MULTICAST
| RCR_BROADCAST
;
806 rx_mode
&= ~(RCR_MULTICAST
| RCR_BROADCAST
);
810 if (changed_flags
& (FIF_OTHER_BSS
| FIF_BCN_PRBRESP_PROMISC
)) {
811 if (*total_flags
& (FIF_OTHER_BSS
| FIF_BCN_PRBRESP_PROMISC
))
812 rx_mode
&= ~RCR_BSSID
;
814 rx_mode
|= RCR_BSSID
;
817 vnt_control_out_u8(priv
, MESSAGE_REQUEST_MACREG
, MAC_REG_RCR
, rx_mode
);
819 dev_dbg(&priv
->usb
->dev
, "rx mode out= %x\n", rx_mode
);
822 static int vnt_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
823 struct ieee80211_vif
*vif
, struct ieee80211_sta
*sta
,
824 struct ieee80211_key_conf
*key
)
826 struct vnt_private
*priv
= hw
->priv
;
830 if (vnt_set_keys(hw
, sta
, vif
, key
))
834 if (test_bit(key
->hw_key_idx
, &priv
->key_entry_inuse
))
835 clear_bit(key
->hw_key_idx
, &priv
->key_entry_inuse
);
843 static void vnt_sw_scan_start(struct ieee80211_hw
*hw
,
844 struct ieee80211_vif
*vif
,
847 struct vnt_private
*priv
= hw
->priv
;
849 vnt_set_bss_mode(priv
);
850 /* Set max sensitivity*/
851 vnt_update_pre_ed_threshold(priv
, true);
854 static void vnt_sw_scan_complete(struct ieee80211_hw
*hw
,
855 struct ieee80211_vif
*vif
)
857 struct vnt_private
*priv
= hw
->priv
;
859 /* Return sensitivity to channel level*/
860 vnt_update_pre_ed_threshold(priv
, false);
863 static int vnt_get_stats(struct ieee80211_hw
*hw
,
864 struct ieee80211_low_level_stats
*stats
)
866 struct vnt_private
*priv
= hw
->priv
;
868 memcpy(stats
, &priv
->low_stats
, sizeof(*stats
));
873 static u64
vnt_get_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
875 struct vnt_private
*priv
= hw
->priv
;
877 return priv
->current_tsf
;
880 static void vnt_set_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
883 struct vnt_private
*priv
= hw
->priv
;
885 vnt_update_next_tbtt(priv
, tsf
, vif
->bss_conf
.beacon_int
);
888 static void vnt_reset_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
890 struct vnt_private
*priv
= hw
->priv
;
892 vnt_mac_reg_bits_off(priv
, MAC_REG_TFTCTL
, TFTCTL_TSFCNTREN
);
894 vnt_clear_current_tsf(priv
);
897 static const struct ieee80211_ops vnt_mac_ops
= {
901 .add_interface
= vnt_add_interface
,
902 .remove_interface
= vnt_remove_interface
,
903 .config
= vnt_config
,
904 .bss_info_changed
= vnt_bss_info_changed
,
905 .prepare_multicast
= vnt_prepare_multicast
,
906 .configure_filter
= vnt_configure
,
907 .set_key
= vnt_set_key
,
908 .sw_scan_start
= vnt_sw_scan_start
,
909 .sw_scan_complete
= vnt_sw_scan_complete
,
910 .get_stats
= vnt_get_stats
,
911 .get_tsf
= vnt_get_tsf
,
912 .set_tsf
= vnt_set_tsf
,
913 .reset_tsf
= vnt_reset_tsf
,
916 int vnt_init(struct vnt_private
*priv
)
918 if (!(vnt_init_registers(priv
)))
921 SET_IEEE80211_PERM_ADDR(priv
->hw
, priv
->permanent_net_addr
);
923 vnt_init_bands(priv
);
925 if (ieee80211_register_hw(priv
->hw
))
930 vnt_radio_power_off(priv
);
936 vt6656_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
938 struct usb_device
*udev
;
939 struct vnt_private
*priv
;
940 struct ieee80211_hw
*hw
;
944 udev
= usb_get_dev(interface_to_usbdev(intf
));
946 dev_notice(&udev
->dev
, "%s Ver. %s\n",
947 DEVICE_FULL_DRV_NAM
, DEVICE_VERSION
);
948 dev_notice(&udev
->dev
,
949 "Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
951 hw
= ieee80211_alloc_hw(sizeof(struct vnt_private
), &vnt_mac_ops
);
953 dev_err(&udev
->dev
, "could not register ieee80211_hw\n");
962 vnt_set_options(priv
);
964 spin_lock_init(&priv
->lock
);
965 mutex_init(&priv
->usb_lock
);
967 INIT_DELAYED_WORK(&priv
->run_command_work
, vnt_run_command
);
969 usb_set_intfdata(intf
, priv
);
971 wiphy
= priv
->hw
->wiphy
;
973 wiphy
->frag_threshold
= FRAG_THRESH_DEF
;
974 wiphy
->rts_threshold
= RTS_THRESH_DEF
;
975 wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
976 BIT(NL80211_IFTYPE_ADHOC
) | BIT(NL80211_IFTYPE_AP
);
978 ieee80211_hw_set(priv
->hw
, TIMING_BEACON_ONLY
);
979 ieee80211_hw_set(priv
->hw
, SIGNAL_DBM
);
980 ieee80211_hw_set(priv
->hw
, RX_INCLUDES_FCS
);
981 ieee80211_hw_set(priv
->hw
, REPORTS_TX_ACK_STATUS
);
982 ieee80211_hw_set(priv
->hw
, SUPPORTS_PS
);
984 priv
->hw
->max_signal
= 100;
986 SET_IEEE80211_DEV(priv
->hw
, &intf
->dev
);
988 rc
= usb_reset_device(priv
->usb
);
990 dev_warn(&priv
->usb
->dev
,
991 "%s reset fail status=%d\n", __func__
, rc
);
993 clear_bit(DEVICE_FLAGS_DISCONNECTED
, &priv
->flags
);
994 vnt_reset_command_timer(priv
);
996 vnt_schedule_command(priv
, WLAN_CMD_INIT_MAC80211
);
1006 static void vt6656_disconnect(struct usb_interface
*intf
)
1008 struct vnt_private
*priv
= usb_get_intfdata(intf
);
1014 ieee80211_unregister_hw(priv
->hw
);
1016 usb_set_intfdata(intf
, NULL
);
1017 usb_put_dev(interface_to_usbdev(intf
));
1019 set_bit(DEVICE_FLAGS_UNPLUG
, &priv
->flags
);
1021 ieee80211_free_hw(priv
->hw
);
1026 static int vt6656_suspend(struct usb_interface
*intf
, pm_message_t message
)
1031 static int vt6656_resume(struct usb_interface
*intf
)
1036 #endif /* CONFIG_PM */
1038 MODULE_DEVICE_TABLE(usb
, vt6656_table
);
1040 static struct usb_driver vt6656_driver
= {
1041 .name
= DEVICE_NAME
,
1042 .probe
= vt6656_probe
,
1043 .disconnect
= vt6656_disconnect
,
1044 .id_table
= vt6656_table
,
1046 .suspend
= vt6656_suspend
,
1047 .resume
= vt6656_resume
,
1048 #endif /* CONFIG_PM */
1051 module_usb_driver(vt6656_driver
);