1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 * Linux device driver for RTL8192U
5 * Based on the r8187 driver, which is:
6 * Copyright 2004-2005 Andrea Merello <andrea.merello@gmail.com>, et al.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 * The full GNU General Public License is included in this distribution in the
21 * file called LICENSE.
23 * Contact Information:
24 * Jerry chuang <wlanfae@realtek.com>
27 #ifndef CONFIG_FORCE_HARD_FLOAT
28 double __floatsidf(int i)
33 unsigned int __fixunsdfsi(double d)
38 double __adddf3(double a, double b)
43 double __addsf3(float a, float b)
48 double __subdf3(double a, double b)
53 double __extendsfdf2(float a)
59 #define CONFIG_RTL8192_IO_MAP
61 #include <asm/uaccess.h>
62 #include "r8192U_hw.h"
64 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
65 #include "r8180_93cx6.h" /* Card EEPROM */
66 #include "r8192U_wx.h"
67 #include "r819xU_phy.h" //added by WB 4.30.2008
68 #include "r819xU_phyreg.h"
69 #include "r819xU_cmdpkt.h"
70 #include "r8192U_dm.h"
71 #include <linux/usb.h>
72 #include <linux/slab.h>
73 #include <linux/proc_fs.h>
74 #include <linux/seq_file.h>
75 // FIXME: check if 2.6.7 is ok
78 //set here to open your trace code. //WB
79 u32 rt_global_debug_component = COMP_DOWN |
81 COMP_ERR; //always open err flags on
83 #define TOTAL_CAM_ENTRY 32
84 #define CAM_CONTENT_COUNT 8
86 static const struct usb_device_id rtl8192_usb_id_tbl[] = {
88 {USB_DEVICE(0x0bda, 0x8709)},
90 {USB_DEVICE(0x07aa, 0x0043)},
92 {USB_DEVICE(0x050d, 0x805E)},
94 {USB_DEVICE(0x0df6, 0x0031)},
96 {USB_DEVICE(0x1740, 0x9201)},
98 {USB_DEVICE(0x2001, 0x3301)},
100 {USB_DEVICE(0x5a57, 0x0290)},
102 {USB_DEVICE(0x043e, 0x7a01)},
106 MODULE_LICENSE("GPL");
107 MODULE_VERSION("V 1.1");
108 MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
109 MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
111 static char *ifname = "wlan%d";
112 static int hwwep = 1; //default use hw. set 0 to use software security
113 static int channels = 0x3fff;
117 module_param(ifname, charp, S_IRUGO|S_IWUSR);
118 module_param(hwwep, int, S_IRUGO|S_IWUSR);
119 module_param(channels, int, S_IRUGO|S_IWUSR);
121 MODULE_PARM_DESC(ifname, " Net interface name, wlan%d=default");
122 MODULE_PARM_DESC(hwwep, " Try to use hardware security support. ");
123 MODULE_PARM_DESC(channels, " Channel bitmask for specific locales. NYI");
125 static int rtl8192_usb_probe(struct usb_interface *intf,
126 const struct usb_device_id *id);
127 static void rtl8192_usb_disconnect(struct usb_interface *intf);
130 static struct usb_driver rtl8192_usb_driver = {
131 .name = RTL819xU_MODULE_NAME, /* Driver name */
132 .id_table = rtl8192_usb_id_tbl, /* PCI_ID table */
133 .probe = rtl8192_usb_probe, /* probe fn */
134 .disconnect = rtl8192_usb_disconnect, /* remove fn */
135 .suspend = NULL, /* PM suspend fn */
136 .resume = NULL, /* PM resume fn */
140 struct CHANNEL_LIST {
145 static struct CHANNEL_LIST ChannelPlan[] = {
146 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 36, 40, 44, 48, 52, 56, 60, 64, 149, 153, 157, 161, 165}, 24}, //FCC
147 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, 11}, //IC
148 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 36, 40, 44, 48, 52, 56, 60, 64}, 21}, //ETSI
149 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}, 13}, //Spain. Change to ETSI.
150 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}, 13}, //France. Change to ETSI.
151 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 36, 40, 44, 48, 52, 56, 60, 64}, 22}, //MKK //MKK
152 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 36, 40, 44, 48, 52, 56, 60, 64}, 22},//MKK1
153 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}, 13}, //Israel.
154 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 36, 40, 44, 48, 52, 56, 60, 64}, 22}, // For 11a , TELEC
155 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 36, 40, 44, 48, 52, 56, 60, 64}, 22}, //MIC
156 {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, 14} //For Global Domain. 1-11:active scan, 12-14 passive scan. //+YJ, 080626
159 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv *priv)
161 int i, max_chan = -1, min_chan = -1;
162 struct ieee80211_device *ieee = priv->ieee80211;
163 switch (channel_plan) {
164 case COUNTRY_CODE_FCC:
165 case COUNTRY_CODE_IC:
166 case COUNTRY_CODE_ETSI:
167 case COUNTRY_CODE_SPAIN:
168 case COUNTRY_CODE_FRANCE:
169 case COUNTRY_CODE_MKK:
170 case COUNTRY_CODE_MKK1:
171 case COUNTRY_CODE_ISRAEL:
172 case COUNTRY_CODE_TELEC:
173 case COUNTRY_CODE_MIC:
175 ieee->bGlobalDomain = false;
176 //actually 8225 & 8256 rf chips only support B,G,24N mode
177 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256)) {
181 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __func__);
183 if (ChannelPlan[channel_plan].Len != 0) {
184 // Clear old channel map
185 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
186 // Set new channel map
187 for (i = 0; i < ChannelPlan[channel_plan].Len; i++) {
188 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
190 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
195 case COUNTRY_CODE_GLOBAL_DOMAIN:
196 GET_DOT11D_INFO(ieee)->bEnabled = 0;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
198 ieee->bGlobalDomain = true;
209 static void CamResetAllEntry(struct net_device *dev)
212 //2004/02/11 In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
213 // However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
214 // In this condition, Cam can not be reset because upper layer will not set this static key again.
215 ulcommand |= BIT31|BIT30;
216 write_nic_dword(dev, RWCAM, ulcommand);
221 void write_cam(struct net_device *dev, u8 addr, u32 data)
223 write_nic_dword(dev, WCAMI, data);
224 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff));
227 u32 read_cam(struct net_device *dev, u8 addr)
231 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff));
232 read_nic_dword(dev, 0xa8, &data);
236 void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
239 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
240 struct usb_device *udev = priv->udev;
242 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
243 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
244 indx|0xfe00, 0, &data, 1, HZ / 2);
247 netdev_err(dev, "write_nic_byte_E TimeOut! status: %d\n", status);
250 int read_nic_byte_E(struct net_device *dev, int indx, u8 *data)
253 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
254 struct usb_device *udev = priv->udev;
256 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
257 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
258 indx|0xfe00, 0, data, 1, HZ / 2);
261 netdev_err(dev, "%s failure status: %d\n", __func__, status);
267 //as 92U has extend page from 4 to 16, so modify functions below.
268 void write_nic_byte(struct net_device *dev, int indx, u8 data)
272 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
273 struct usb_device *udev = priv->udev;
275 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
276 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
277 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
280 netdev_err(dev, "write_nic_byte TimeOut! status: %d\n", status);
286 void write_nic_word(struct net_device *dev, int indx, u16 data)
291 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
292 struct usb_device *udev = priv->udev;
294 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
295 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
296 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 2, HZ / 2);
299 netdev_err(dev, "write_nic_word TimeOut! status: %d\n", status);
304 void write_nic_dword(struct net_device *dev, int indx, u32 data)
309 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
310 struct usb_device *udev = priv->udev;
312 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
313 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
314 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 4, HZ / 2);
318 netdev_err(dev, "write_nic_dword TimeOut! status: %d\n", status);
324 int read_nic_byte(struct net_device *dev, int indx, u8 *data)
327 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
328 struct usb_device *udev = priv->udev;
330 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
331 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
332 (indx&0xff)|0xff00, (indx>>8)&0x0f, data, 1, HZ / 2);
335 netdev_err(dev, "%s failure status: %d\n", __func__, status);
344 int read_nic_word(struct net_device *dev, int indx, u16 *data)
347 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
348 struct usb_device *udev = priv->udev;
350 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
351 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
352 (indx&0xff)|0xff00, (indx>>8)&0x0f,
356 netdev_err(dev, "%s failure status: %d\n", __func__, status);
363 static int read_nic_word_E(struct net_device *dev, int indx, u16 *data)
366 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
367 struct usb_device *udev = priv->udev;
369 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
370 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
371 indx|0xfe00, 0, data, 2, HZ / 2);
374 netdev_err(dev, "%s failure status: %d\n", __func__, status);
381 int read_nic_dword(struct net_device *dev, int indx, u32 *data)
385 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
386 struct usb_device *udev = priv->udev;
388 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
389 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
390 (indx&0xff)|0xff00, (indx>>8)&0x0f,
394 netdev_err(dev, "%s failure status: %d\n", __func__, status);
401 /* u8 read_phy_cck(struct net_device *dev, u8 adr); */
402 /* u8 read_phy_ofdm(struct net_device *dev, u8 adr); */
403 /* this might still called in what was the PHY rtl8185/rtl8192 common code
404 * plans are to possibility turn it again in one common code...
406 inline void force_pci_posting(struct net_device *dev)
410 static struct net_device_stats *rtl8192_stats(struct net_device *dev);
411 void rtl8192_commit(struct net_device *dev);
412 void rtl8192_restart(struct work_struct *work);
413 void watch_dog_timer_callback(unsigned long data);
415 /****************************************************************************
416 * -----------------------------PROCFS STUFF-------------------------
417 *****************************************************************************
420 static struct proc_dir_entry *rtl8192_proc;
422 static int proc_get_stats_ap(struct seq_file *m, void *v)
424 struct net_device *dev = m->private;
425 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
426 struct ieee80211_device *ieee = priv->ieee80211;
427 struct ieee80211_network *target;
429 list_for_each_entry(target, &ieee->network_list, list) {
430 const char *wpa = "non_WPA";
431 if (target->wpa_ie_len > 0 || target->rsn_ie_len > 0)
434 seq_printf(m, "%s %s\n", target->ssid, wpa);
440 static int proc_get_registers(struct seq_file *m, void *v)
442 struct net_device *dev = m->private;
443 int i, n, max = 0xff;
446 seq_puts(m, "\n####################page 0##################\n ");
448 for (n = 0; n <= max;) {
449 seq_printf(m, "\nD: %2x > ", n);
451 for (i = 0; i < 16 && n <= max; i++, n++) {
452 read_nic_byte(dev, 0x000|n, &byte_rd);
453 seq_printf(m, "%2x ", byte_rd);
457 seq_puts(m, "\n####################page 1##################\n ");
458 for (n = 0; n <= max;) {
459 seq_printf(m, "\nD: %2x > ", n);
461 for (i = 0; i < 16 && n <= max; i++, n++) {
462 read_nic_byte(dev, 0x100|n, &byte_rd);
463 seq_printf(m, "%2x ", byte_rd);
467 seq_puts(m, "\n####################page 3##################\n ");
468 for (n = 0; n <= max;) {
469 seq_printf(m, "\nD: %2x > ", n);
471 for (i = 0; i < 16 && n <= max; i++, n++) {
472 read_nic_byte(dev, 0x300|n, &byte_rd);
473 seq_printf(m, "%2x ", byte_rd);
481 static int proc_get_stats_tx(struct seq_file *m, void *v)
483 struct net_device *dev = m->private;
484 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
487 "TX VI priority ok int: %lu\n"
488 "TX VI priority error int: %lu\n"
489 "TX VO priority ok int: %lu\n"
490 "TX VO priority error int: %lu\n"
491 "TX BE priority ok int: %lu\n"
492 "TX BE priority error int: %lu\n"
493 "TX BK priority ok int: %lu\n"
494 "TX BK priority error int: %lu\n"
495 "TX MANAGE priority ok int: %lu\n"
496 "TX MANAGE priority error int: %lu\n"
497 "TX BEACON priority ok int: %lu\n"
498 "TX BEACON priority error int: %lu\n"
499 "TX queue resume: %lu\n"
500 "TX queue stopped?: %d\n"
501 "TX fifo overflow: %lu\n"
506 "TX VI dropped: %lu\n"
507 "TX VO dropped: %lu\n"
508 "TX BE dropped: %lu\n"
509 "TX BK dropped: %lu\n"
510 "TX total data packets %lu\n",
511 priv->stats.txviokint,
513 priv->stats.txvookint,
515 priv->stats.txbeokint,
517 priv->stats.txbkokint,
519 priv->stats.txmanageokint,
520 priv->stats.txmanageerr,
521 priv->stats.txbeaconokint,
522 priv->stats.txbeaconerr,
523 priv->stats.txresumed,
524 netif_queue_stopped(dev),
525 priv->stats.txoverflow,
526 atomic_read(&(priv->tx_pending[VI_PRIORITY])),
527 atomic_read(&(priv->tx_pending[VO_PRIORITY])),
528 atomic_read(&(priv->tx_pending[BE_PRIORITY])),
529 atomic_read(&(priv->tx_pending[BK_PRIORITY])),
530 priv->stats.txvidrop,
531 priv->stats.txvodrop,
532 priv->stats.txbedrop,
533 priv->stats.txbkdrop,
534 priv->stats.txdatapkt
540 static int proc_get_stats_rx(struct seq_file *m, void *v)
542 struct net_device *dev = m->private;
543 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
547 "RX urb status error: %lu\n"
548 "RX invalid urb error: %lu\n",
549 priv->stats.rxoktotal,
550 priv->stats.rxstaterr,
551 priv->stats.rxurberr);
556 static void rtl8192_proc_module_init(void)
558 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
559 rtl8192_proc = proc_mkdir(RTL819xU_MODULE_NAME, init_net.proc_net);
563 * seq_file wrappers for procfile show routines.
565 static int rtl8192_proc_open(struct inode *inode, struct file *file)
567 struct net_device *dev = proc_get_parent_data(inode);
568 int (*show)(struct seq_file *, void *) = PDE_DATA(inode);
570 return single_open(file, show, dev);
573 static const struct file_operations rtl8192_proc_fops = {
574 .open = rtl8192_proc_open,
577 .release = single_release,
581 * Table of proc files we need to create.
583 struct rtl8192_proc_file {
585 int (*show)(struct seq_file *, void *);
588 static const struct rtl8192_proc_file rtl8192_proc_files[] = {
589 { "stats-rx", &proc_get_stats_rx },
590 { "stats-tx", &proc_get_stats_tx },
591 { "stats-ap", &proc_get_stats_ap },
592 { "registers", &proc_get_registers },
596 static void rtl8192_proc_init_one(struct net_device *dev)
598 const struct rtl8192_proc_file *f;
599 struct proc_dir_entry *dir;
602 dir = proc_mkdir_data(dev->name, 0, rtl8192_proc, dev);
604 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
609 for (f = rtl8192_proc_files; f->name[0]; f++) {
610 if (!proc_create_data(f->name, S_IFREG | S_IRUGO, dir,
611 &rtl8192_proc_fops, f->show)) {
612 RT_TRACE(COMP_ERR, "Unable to initialize "
613 "/proc/net/rtl8192/%s/%s\n",
621 static void rtl8192_proc_remove_one(struct net_device *dev)
623 remove_proc_subtree(dev->name, rtl8192_proc);
626 /****************************************************************************
627 -----------------------------MISC STUFF-------------------------
628 *****************************************************************************/
630 short check_nic_enough_desc(struct net_device *dev, int queue_index)
632 struct r8192_priv *priv = ieee80211_priv(dev);
633 int used = atomic_read(&priv->tx_pending[queue_index]);
635 return (used < MAX_TX_URB);
638 static void tx_timeout(struct net_device *dev)
640 struct r8192_priv *priv = ieee80211_priv(dev);
642 schedule_work(&priv->reset_wq);
645 void rtl8192_update_msr(struct net_device *dev)
647 struct r8192_priv *priv = ieee80211_priv(dev);
650 read_nic_byte(dev, MSR, &msr);
651 msr &= ~MSR_LINK_MASK;
653 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
654 * msr must be updated if the state is ASSOCIATING.
655 * this is intentional and make sense for ad-hoc and
656 * master (see the create BSS/IBSS func)
658 if (priv->ieee80211->state == IEEE80211_LINKED) {
660 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
661 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
662 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
663 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
664 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
665 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
668 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
671 write_nic_byte(dev, MSR, msr);
674 void rtl8192_set_chan(struct net_device *dev, short ch)
676 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
677 RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __func__, ch);
680 /* this hack should avoid frame TX during channel setting*/
682 //need to implement rf set channel here WB
684 if (priv->rf_set_chan)
685 priv->rf_set_chan(dev, priv->chan);
689 static void rtl8192_rx_isr(struct urb *urb);
691 static u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
694 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
695 + pstats->RxBufShift);
698 static int rtl8192_rx_initiate(struct net_device *dev)
700 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
703 struct rtl8192_rx_info *info;
705 /* nomal packet rx procedure */
706 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
707 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
710 entry = usb_alloc_urb(0, GFP_KERNEL);
715 usb_fill_bulk_urb(entry, priv->udev,
716 usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
717 RX_URB_SIZE, rtl8192_rx_isr, skb);
718 info = (struct rtl8192_rx_info *) skb->cb;
721 info->out_pipe = 3; //denote rx normal packet queue
722 skb_queue_tail(&priv->rx_queue, skb);
723 usb_submit_urb(entry, GFP_KERNEL);
726 /* command packet rx procedure */
727 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
728 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
731 entry = usb_alloc_urb(0, GFP_KERNEL);
736 usb_fill_bulk_urb(entry, priv->udev,
737 usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
738 RX_URB_SIZE, rtl8192_rx_isr, skb);
739 info = (struct rtl8192_rx_info *) skb->cb;
742 info->out_pipe = 9; //denote rx cmd packet queue
743 skb_queue_tail(&priv->rx_queue, skb);
744 usb_submit_urb(entry, GFP_KERNEL);
750 void rtl8192_set_rxconf(struct net_device *dev)
752 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
755 read_nic_dword(dev, RCR, &rxconf);
756 rxconf = rxconf & ~MAC_FILTER_MASK;
757 rxconf = rxconf | RCR_AMF;
758 rxconf = rxconf | RCR_ADF;
759 rxconf = rxconf | RCR_AB;
760 rxconf = rxconf | RCR_AM;
762 if (dev->flags & IFF_PROMISC)
763 DMESG("NIC in promisc mode");
765 if (priv->ieee80211->iw_mode == IW_MODE_MONITOR ||
766 dev->flags & IFF_PROMISC) {
767 rxconf = rxconf | RCR_AAP;
769 rxconf = rxconf | RCR_APM;
770 rxconf = rxconf | RCR_CBSSID;
774 if (priv->ieee80211->iw_mode == IW_MODE_MONITOR) {
775 rxconf = rxconf | RCR_AICV;
776 rxconf = rxconf | RCR_APWRMGT;
779 if (priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
780 rxconf = rxconf | RCR_ACRC32;
783 rxconf = rxconf & ~RX_FIFO_THRESHOLD_MASK;
784 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
785 rxconf = rxconf & ~MAX_RX_DMA_MASK;
786 rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
788 rxconf = rxconf | RCR_ONLYERLPKT;
790 write_nic_dword(dev, RCR, rxconf);
793 void rtl8192_rx_enable(struct net_device *dev)
795 rtl8192_rx_initiate(dev);
799 void rtl8192_tx_enable(struct net_device *dev)
805 void rtl8192_rtx_disable(struct net_device *dev)
808 struct r8192_priv *priv = ieee80211_priv(dev);
810 struct rtl8192_rx_info *info;
812 read_nic_byte(dev, CMDR, &cmd);
813 write_nic_byte(dev, CMDR, cmd & ~(CR_TE|CR_RE));
814 force_pci_posting(dev);
817 while ((skb = __skb_dequeue(&priv->rx_queue))) {
818 info = (struct rtl8192_rx_info *) skb->cb;
822 usb_kill_urb(info->urb);
826 if (skb_queue_len(&priv->skb_queue))
827 netdev_warn(dev, "skb_queue not empty\n");
829 skb_queue_purge(&priv->skb_queue);
833 inline u16 ieeerate2rtlrate(int rate)
865 static u16 rtl_rate[] = {10, 20, 55, 110, 60, 90, 120, 180, 240, 360, 480, 540};
866 inline u16 rtl8192_rate2rate(short rate)
870 return rtl_rate[rate];
874 /* The prototype of rx_isr has changed since one version of Linux Kernel */
875 static void rtl8192_rx_isr(struct urb *urb)
877 struct sk_buff *skb = (struct sk_buff *) urb->context;
878 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
879 struct net_device *dev = info->dev;
880 struct r8192_priv *priv = ieee80211_priv(dev);
881 int out_pipe = info->out_pipe;
885 if (unlikely(urb->status)) {
887 priv->stats.rxstaterr++;
888 priv->ieee80211->stats.rx_errors++;
892 skb_unlink(skb, &priv->rx_queue);
893 skb_put(skb, urb->actual_length);
895 skb_queue_tail(&priv->skb_queue, skb);
896 tasklet_schedule(&priv->irq_rx_tasklet);
898 skb = dev_alloc_skb(RX_URB_SIZE);
899 if (unlikely(!skb)) {
901 netdev_err(dev, "%s(): can't alloc skb\n", __func__);
902 /* TODO check rx queue length and refill *somewhere* */
906 usb_fill_bulk_urb(urb, priv->udev,
907 usb_rcvbulkpipe(priv->udev, out_pipe), skb_tail_pointer(skb),
908 RX_URB_SIZE, rtl8192_rx_isr, skb);
910 info = (struct rtl8192_rx_info *) skb->cb;
913 info->out_pipe = out_pipe;
915 urb->transfer_buffer = skb_tail_pointer(skb);
917 skb_queue_tail(&priv->rx_queue, skb);
918 err = usb_submit_urb(urb, GFP_ATOMIC);
919 if (err && err != EPERM)
920 netdev_err(dev, "can not submit rxurb, err is %x, URB status is %x\n", err, urb->status);
923 static u32 rtl819xusb_rx_command_packet(struct net_device *dev,
924 struct ieee80211_rx_stats *pstats)
928 status = cmpk_message_handle_rx(dev, pstats);
930 DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
936 static void rtl8192_data_hard_stop(struct net_device *dev)
942 static void rtl8192_data_hard_resume(struct net_device *dev)
947 /* this function TX data frames when the ieee80211 stack requires this.
948 * It checks also if we need to stop the ieee tx queue, eventually do it
950 static void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
952 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
955 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
956 u8 queue_index = tcb_desc->queue_index;
958 /* shall not be referred by command packet */
959 RTL8192U_ASSERT(queue_index != TXCMD_QUEUE);
961 spin_lock_irqsave(&priv->tx_lock, flags);
963 memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
964 tcb_desc->bTxEnableFwCalcDur = 1;
965 skb_push(skb, priv->ieee80211->tx_headroom);
966 ret = rtl8192_tx(dev, skb);
968 spin_unlock_irqrestore(&priv->tx_lock, flags);
973 /* This is a rough attempt to TX a frame
974 * This is called by the ieee 80211 stack to TX management frames.
975 * If the ring is full packet are dropped (for data frame the queue
976 * is stopped before this can happen).
978 static int rtl8192_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
980 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
983 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
984 u8 queue_index = tcb_desc->queue_index;
987 spin_lock_irqsave(&priv->tx_lock, flags);
989 memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
990 if (queue_index == TXCMD_QUEUE) {
991 skb_push(skb, USB_HWDESC_HEADER_LEN);
992 rtl819xU_tx_cmd(dev, skb);
994 spin_unlock_irqrestore(&priv->tx_lock, flags);
997 skb_push(skb, priv->ieee80211->tx_headroom);
998 ret = rtl8192_tx(dev, skb);
1001 spin_unlock_irqrestore(&priv->tx_lock, flags);
1007 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1009 static void rtl8192_tx_isr(struct urb *tx_urb)
1011 struct sk_buff *skb = (struct sk_buff *)tx_urb->context;
1012 struct net_device *dev = (struct net_device *)(skb->cb);
1013 struct r8192_priv *priv = NULL;
1014 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1015 u8 queue_index = tcb_desc->queue_index;
1017 priv = ieee80211_priv(dev);
1019 if (tcb_desc->queue_index != TXCMD_QUEUE) {
1020 if (tx_urb->status == 0) {
1021 dev->trans_start = jiffies;
1022 priv->stats.txoktotal++;
1023 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
1024 priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
1026 priv->ieee80211->stats.tx_errors++;
1031 /* free skb and tx_urb */
1033 dev_kfree_skb_any(skb);
1034 usb_free_urb(tx_urb);
1035 atomic_dec(&priv->tx_pending[queue_index]);
1039 // Handle HW Beacon:
1040 // We had transfer our beacon frame to host controller at this moment.
1044 // Handling the wait queue of command packets.
1045 // For Tx command packets, we must not do TCB fragment because it is not handled right now.
1046 // We must cut the packets to match the size of TX_CMD_PKT before we send it.
1049 /* Handle MPDU in wait queue. */
1050 if (queue_index != BEACON_QUEUE) {
1051 /* Don't send data frame during scanning.*/
1052 if ((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0) &&
1053 (!(priv->ieee80211->queue_stop))) {
1054 skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]));
1056 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1058 return; //modified by david to avoid further processing AMSDU
1064 static void rtl8192_config_rate(struct net_device *dev, u16 *rate_config)
1066 struct r8192_priv *priv = ieee80211_priv(dev);
1067 struct ieee80211_network *net;
1068 u8 i = 0, basic_rate = 0;
1069 net = &priv->ieee80211->current_network;
1071 for (i = 0; i < net->rates_len; i++) {
1072 basic_rate = net->rates[i]&0x7f;
1073 switch (basic_rate) {
1075 *rate_config |= RRSR_1M;
1078 *rate_config |= RRSR_2M;
1081 *rate_config |= RRSR_5_5M;
1084 *rate_config |= RRSR_11M;
1087 *rate_config |= RRSR_6M;
1090 *rate_config |= RRSR_9M;
1093 *rate_config |= RRSR_12M;
1096 *rate_config |= RRSR_18M;
1099 *rate_config |= RRSR_24M;
1102 *rate_config |= RRSR_36M;
1105 *rate_config |= RRSR_48M;
1108 *rate_config |= RRSR_54M;
1112 for (i = 0; i < net->rates_ex_len; i++) {
1113 basic_rate = net->rates_ex[i]&0x7f;
1114 switch (basic_rate) {
1116 *rate_config |= RRSR_1M;
1119 *rate_config |= RRSR_2M;
1122 *rate_config |= RRSR_5_5M;
1125 *rate_config |= RRSR_11M;
1128 *rate_config |= RRSR_6M;
1131 *rate_config |= RRSR_9M;
1134 *rate_config |= RRSR_12M;
1137 *rate_config |= RRSR_18M;
1140 *rate_config |= RRSR_24M;
1143 *rate_config |= RRSR_36M;
1146 *rate_config |= RRSR_48M;
1149 *rate_config |= RRSR_54M;
1156 #define SHORT_SLOT_TIME 9
1157 #define NON_SHORT_SLOT_TIME 20
1159 static void rtl8192_update_cap(struct net_device *dev, u16 cap)
1162 struct r8192_priv *priv = ieee80211_priv(dev);
1163 struct ieee80211_network *net = &priv->ieee80211->current_network;
1164 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1165 tmp = priv->basic_rate;
1166 if (priv->short_preamble)
1167 tmp |= BRSR_AckShortPmb;
1168 write_nic_dword(dev, RRSR, tmp);
1170 if (net->mode & (IEEE_G|IEEE_N_24G)) {
1172 if ((cap & WLAN_CAPABILITY_SHORT_SLOT) && (!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime)) /* short slot time */
1173 slot_time = SHORT_SLOT_TIME;
1174 else //long slot time
1175 slot_time = NON_SHORT_SLOT_TIME;
1176 priv->slot_time = slot_time;
1177 write_nic_byte(dev, SLOT_TIME, slot_time);
1181 static void rtl8192_net_update(struct net_device *dev)
1184 struct r8192_priv *priv = ieee80211_priv(dev);
1185 struct ieee80211_network *net;
1186 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1187 u16 rate_config = 0;
1188 net = &priv->ieee80211->current_network;
1190 rtl8192_config_rate(dev, &rate_config);
1191 priv->basic_rate = rate_config & 0x15f;
1193 write_nic_dword(dev, BSSIDR, ((u32 *)net->bssid)[0]);
1194 write_nic_word(dev, BSSIDR+4, ((u16 *)net->bssid)[2]);
1196 rtl8192_update_msr(dev);
1197 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC) {
1198 write_nic_word(dev, ATIMWND, 2);
1199 write_nic_word(dev, BCN_DMATIME, 1023);
1200 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1201 write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
1202 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1203 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1204 // TODO: BcnIFS may required to be changed on ASIC
1205 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1207 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1214 //temporary hw beacon is not used any more.
1215 //open it when necessary
1216 void rtl819xusb_beacon_tx(struct net_device *dev, u16 tx_rate)
1220 inline u8 rtl8192_IsWirelessBMode(u16 rate)
1222 if (((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220))
1228 u16 N_DBPSOfRate(u16 DataRate);
1231 u16 N_DBPSOfRate(u16 DataRate)
1275 short rtl819xU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1277 struct r8192_priv *priv = ieee80211_priv(dev);
1280 unsigned int idx_pipe;
1281 tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
1282 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1283 u8 queue_index = tcb_desc->queue_index;
1285 atomic_inc(&priv->tx_pending[queue_index]);
1286 tx_urb = usb_alloc_urb(0, GFP_ATOMIC);
1292 memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
1293 /* Tx descriptor ought to be set according to the skb->cb */
1294 pdesc->FirstSeg = 1;//bFirstSeg;
1295 pdesc->LastSeg = 1;//bLastSeg;
1296 pdesc->CmdInit = tcb_desc->bCmdOrInit;
1297 pdesc->TxBufferSize = tcb_desc->txbuf_size;
1299 pdesc->LINIP = tcb_desc->bLastIniPkt;
1301 //----------------------------------------------------------------------------
1302 // Fill up USB_OUT_CONTEXT.
1303 //----------------------------------------------------------------------------
1305 usb_fill_bulk_urb(tx_urb, priv->udev, usb_sndbulkpipe(priv->udev, idx_pipe),
1306 skb->data, skb->len, rtl8192_tx_isr, skb);
1308 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
1313 DMESGE("Error TX CMD URB, error %d", status);
1319 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1320 * in TxFwInfo data structure
1321 * 2006.10.30 by Emily
1323 * \param QUEUEID Software Queue
1325 static u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1327 u8 QueueSelect = 0x0; //defualt set to
1331 QueueSelect = QSLT_BE;
1335 QueueSelect = QSLT_BK;
1339 QueueSelect = QSLT_VO;
1343 QueueSelect = QSLT_VI;
1346 QueueSelect = QSLT_MGNT;
1350 QueueSelect = QSLT_BEACON;
1353 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
1354 // TODO: Remove Assertions
1356 QueueSelect = QSLT_CMD;
1359 QueueSelect = QSLT_HIGH;
1363 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
1369 static u8 MRateToHwRate8190Pci(u8 rate)
1371 u8 ret = DESC90_RATE1M;
1375 ret = DESC90_RATE1M;
1378 ret = DESC90_RATE2M;
1381 ret = DESC90_RATE5_5M;
1384 ret = DESC90_RATE11M;
1387 ret = DESC90_RATE6M;
1390 ret = DESC90_RATE9M;
1393 ret = DESC90_RATE12M;
1396 ret = DESC90_RATE18M;
1399 ret = DESC90_RATE24M;
1402 ret = DESC90_RATE36M;
1405 ret = DESC90_RATE48M;
1408 ret = DESC90_RATE54M;
1411 /* HT rate since here */
1413 ret = DESC90_RATEMCS0;
1416 ret = DESC90_RATEMCS1;
1419 ret = DESC90_RATEMCS2;
1422 ret = DESC90_RATEMCS3;
1425 ret = DESC90_RATEMCS4;
1428 ret = DESC90_RATEMCS5;
1431 ret = DESC90_RATEMCS6;
1434 ret = DESC90_RATEMCS7;
1437 ret = DESC90_RATEMCS8;
1440 ret = DESC90_RATEMCS9;
1443 ret = DESC90_RATEMCS10;
1446 ret = DESC90_RATEMCS11;
1449 ret = DESC90_RATEMCS12;
1452 ret = DESC90_RATEMCS13;
1455 ret = DESC90_RATEMCS14;
1458 ret = DESC90_RATEMCS15;
1461 ret = DESC90_RATEMCS32;
1471 static u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1475 tmp_Short = (TxHT == 1) ? ((tcb_desc->bUseShortGI) ? 1 : 0) : ((tcb_desc->bUseShortPreamble) ? 1 : 0);
1477 if (TxHT == 1 && TxRate != DESC90_RATEMCS15)
1483 static void tx_zero_isr(struct urb *tx_urb)
1489 * The tx procedure is just as following,
1490 * skb->cb will contain all the following information,
1491 * priority, morefrag, rate, &dev.
1493 short rtl8192_tx(struct net_device *dev, struct sk_buff *skb)
1495 struct r8192_priv *priv = ieee80211_priv(dev);
1496 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1497 tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
1498 tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);
1499 struct usb_device *udev = priv->udev;
1502 struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
1503 unsigned int idx_pipe;
1504 pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
1505 /* we are locked here so the two atomic_read and inc are executed
1506 * without interleaves
1507 * !!! For debug purpose
1509 if (pend > MAX_TX_URB) {
1510 netdev_dbg(dev, "To discard skb packet!\n");
1511 dev_kfree_skb_any(skb);
1515 tx_urb = usb_alloc_urb(0, GFP_ATOMIC);
1517 dev_kfree_skb_any(skb);
1521 /* Fill Tx firmware info */
1522 memset(tx_fwinfo, 0, sizeof(tx_fwinfo_819x_usb));
1524 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80) ? 1 : 0;
1525 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
1526 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1527 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
1528 if (tcb_desc->bAMPDUEnable) { /* AMPDU enabled */
1529 tx_fwinfo->AllowAggregation = 1;
1531 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
1532 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
1534 tx_fwinfo->AllowAggregation = 0;
1536 tx_fwinfo->RxMF = 0;
1537 tx_fwinfo->RxAMD = 0;
1540 /* Protection mode related */
1541 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable) ? 1 : 0;
1542 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable) ? 1 : 0;
1543 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC) ? 1 : 0;
1544 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80) ? 1 : 0;
1545 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1546 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT == 0) ? (tcb_desc->RTSSC) : 0;
1547 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT == 1) ? ((tcb_desc->bRTSBW) ? 1 : 0) : 0;
1548 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT == 0) ? (tcb_desc->bRTSUseShortPreamble ? 1 : 0) :
1549 (tcb_desc->bRTSUseShortGI ? 1 : 0);
1551 /* Set Bandwidth and sub-channel settings. */
1552 if (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40) {
1553 if (tcb_desc->bPacketBW) {
1554 tx_fwinfo->TxBandwidth = 1;
1555 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
1557 tx_fwinfo->TxBandwidth = 0;
1558 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1561 tx_fwinfo->TxBandwidth = 0;
1562 tx_fwinfo->TxSubCarrier = 0;
1565 /* Fill Tx descriptor */
1566 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
1569 tx_desc->CmdInit = 1;
1570 tx_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
1571 tx_desc->PktSize = (skb->len - TX_PACKET_SHIFT_BYTES) & 0xffff;
1574 tx_desc->SecCAMID = 0;
1575 tx_desc->RATid = tcb_desc->RATRIndex;
1577 tx_desc->SecType = 0x0;
1578 if (tcb_desc->bHwSec) {
1579 switch (priv->ieee80211->pairwise_key_type) {
1580 case KEY_TYPE_WEP40:
1581 case KEY_TYPE_WEP104:
1582 tx_desc->SecType = 0x1;
1586 tx_desc->SecType = 0x2;
1590 tx_desc->SecType = 0x3;
1594 tx_desc->SecType = 0x0;
1600 tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1601 tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
1603 tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
1604 tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1606 /* Fill fields that are required to be initialized in all of the descriptors */
1608 tx_desc->FirstSeg = 1;
1609 tx_desc->LastSeg = 1;
1613 tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
1616 /* To submit bulk urb */
1617 usb_fill_bulk_urb(tx_urb, udev,
1618 usb_sndbulkpipe(udev, idx_pipe), skb->data,
1619 skb->len, rtl8192_tx_isr, skb);
1621 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
1623 //we need to send 0 byte packet whenever 512N bytes/64N(HIGN SPEED/NORMAL SPEED) bytes packet has been transmitted. Otherwise, it will be halt to wait for another packet. WB. 2008.08.27
1624 bool bSend0Byte = false;
1626 if (udev->speed == USB_SPEED_HIGH) {
1627 if (skb->len > 0 && skb->len % 512 == 0)
1630 if (skb->len > 0 && skb->len % 64 == 0)
1634 tx_urb_zero = usb_alloc_urb(0, GFP_ATOMIC);
1636 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
1639 usb_fill_bulk_urb(tx_urb_zero, udev,
1640 usb_sndbulkpipe(udev, idx_pipe), &zero,
1641 0, tx_zero_isr, dev);
1642 status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
1644 RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
1648 dev->trans_start = jiffies;
1649 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
1652 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
1658 static short rtl8192_usb_initendpoints(struct net_device *dev)
1660 struct r8192_priv *priv = ieee80211_priv(dev);
1662 priv->rx_urb = kmalloc(sizeof(struct urb *) * (MAX_RX_URB+1),
1664 if (priv->rx_urb == NULL)
1667 #ifndef JACKSON_NEW_RX
1668 for (i = 0; i < (MAX_RX_URB+1); i++) {
1670 priv->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL);
1672 priv->rx_urb[i]->transfer_buffer = kmalloc(RX_URB_SIZE, GFP_KERNEL);
1674 priv->rx_urb[i]->transfer_buffer_length = RX_URB_SIZE;
1678 #ifdef THOMAS_BEACON
1681 void *oldaddr, *newaddr;
1683 priv->rx_urb[16] = usb_alloc_urb(0, GFP_KERNEL);
1684 priv->oldaddr = kmalloc(16, GFP_KERNEL);
1685 oldaddr = priv->oldaddr;
1686 align = ((long)oldaddr) & 3;
1688 newaddr = oldaddr + 4 - align;
1689 priv->rx_urb[16]->transfer_buffer_length = 16 - 4 + align;
1692 priv->rx_urb[16]->transfer_buffer_length = 16;
1694 priv->rx_urb[16]->transfer_buffer = newaddr;
1698 memset(priv->rx_urb, 0, sizeof(struct urb *) * MAX_RX_URB);
1699 priv->pp_rxskb = kcalloc(MAX_RX_URB, sizeof(struct sk_buff *),
1701 if (!priv->pp_rxskb) {
1702 kfree(priv->rx_urb);
1704 priv->pp_rxskb = NULL;
1705 priv->rx_urb = NULL;
1707 DMESGE("Endpoint Alloc Failure");
1711 netdev_dbg(dev, "End of initendpoints\n");
1715 #ifdef THOMAS_BEACON
1716 static void rtl8192_usb_deleteendpoints(struct net_device *dev)
1719 struct r8192_priv *priv = ieee80211_priv(dev);
1722 for (i = 0; i < (MAX_RX_URB+1); i++) {
1723 usb_kill_urb(priv->rx_urb[i]);
1724 usb_free_urb(priv->rx_urb[i]);
1726 kfree(priv->rx_urb);
1727 priv->rx_urb = NULL;
1729 kfree(priv->oldaddr);
1730 priv->oldaddr = NULL;
1731 if (priv->pp_rxskb) {
1732 kfree(priv->pp_rxskb);
1733 priv->pp_rxskb = NULL;
1737 void rtl8192_usb_deleteendpoints(struct net_device *dev)
1740 struct r8192_priv *priv = ieee80211_priv(dev);
1742 #ifndef JACKSON_NEW_RX
1745 for (i = 0; i < (MAX_RX_URB+1); i++) {
1746 usb_kill_urb(priv->rx_urb[i]);
1747 kfree(priv->rx_urb[i]->transfer_buffer);
1748 usb_free_urb(priv->rx_urb[i]);
1750 kfree(priv->rx_urb);
1751 priv->rx_urb = NULL;
1755 kfree(priv->rx_urb);
1756 priv->rx_urb = NULL;
1757 kfree(priv->oldaddr);
1758 priv->oldaddr = NULL;
1759 if (priv->pp_rxskb) {
1760 kfree(priv->pp_rxskb);
1769 extern void rtl8192_update_ratr_table(struct net_device *dev);
1770 static void rtl8192_link_change(struct net_device *dev)
1772 struct r8192_priv *priv = ieee80211_priv(dev);
1773 struct ieee80211_device *ieee = priv->ieee80211;
1774 if (ieee->state == IEEE80211_LINKED) {
1775 rtl8192_net_update(dev);
1776 rtl8192_update_ratr_table(dev);
1777 //add this as in pure N mode, wep encryption will use software way, but there is no chance to set this as wep will not set group key in wext. WB.2008.07.08
1778 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
1779 EnableHWSecurityConfig8192(dev);
1781 /*update timing params*/
1782 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC) {
1784 read_nic_dword(dev, RCR, ®);
1785 if (priv->ieee80211->state == IEEE80211_LINKED)
1786 priv->ReceiveConfig = reg |= RCR_CBSSID;
1788 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
1789 write_nic_dword(dev, RCR, reg);
1793 static struct ieee80211_qos_parameters def_qos_parameters = {
1794 {cpu_to_le16(3), cpu_to_le16(3), cpu_to_le16(3), cpu_to_le16(3)},
1795 {cpu_to_le16(7), cpu_to_le16(7), cpu_to_le16(7), cpu_to_le16(7)},
1796 {2, 2, 2, 2},/* aifs */
1797 {0, 0, 0, 0},/* flags */
1798 {0, 0, 0, 0} /* tx_op_limit */
1802 static void rtl8192_update_beacon(struct work_struct *work)
1804 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
1805 struct net_device *dev = priv->ieee80211->dev;
1806 struct ieee80211_device *ieee = priv->ieee80211;
1807 struct ieee80211_network *net = &ieee->current_network;
1809 if (ieee->pHTInfo->bCurrentHTSupport)
1810 HTUpdateSelfAndPeerSetting(ieee, net);
1811 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
1812 rtl8192_update_cap(dev, net->capability);
1815 * background support to run QoS activate functionality
1817 static int WDCAPARA_ADD[] = {EDCAPARA_BE, EDCAPARA_BK, EDCAPARA_VI, EDCAPARA_VO};
1818 static void rtl8192_qos_activate(struct work_struct *work)
1820 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
1821 struct net_device *dev = priv->ieee80211->dev;
1822 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
1823 u8 mode = priv->ieee80211->current_network.mode;
1831 mutex_lock(&priv->mutex);
1832 if (priv->ieee80211->state != IEEE80211_LINKED)
1834 RT_TRACE(COMP_QOS, "qos active process with associate response received\n");
1835 /* It better set slot time at first */
1836 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
1837 /* update the ac parameter to related registers */
1838 for (i = 0; i < QOS_QUEUE_NUM; i++) {
1839 //Mode G/A: slotTimeTimer = 9; Mode B: 20
1840 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ? 9 : 20) + aSifsTime;
1841 u1bAIFS <<= AC_PARAM_AIFS_OFFSET;
1842 op_limit = (u32)le16_to_cpu(qos_parameters->tx_op_limit[i]);
1843 op_limit <<= AC_PARAM_TXOP_LIMIT_OFFSET;
1844 cw_max = (u32)le16_to_cpu(qos_parameters->cw_max[i]);
1845 cw_max <<= AC_PARAM_ECW_MAX_OFFSET;
1846 cw_min = (u32)le16_to_cpu(qos_parameters->cw_min[i]);
1847 cw_min <<= AC_PARAM_ECW_MIN_OFFSET;
1848 u4bAcParam = op_limit | cw_max | cw_min | u1bAIFS;
1849 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
1853 mutex_unlock(&priv->mutex);
1856 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
1858 struct ieee80211_network *network)
1861 u32 size = sizeof(struct ieee80211_qos_parameters);
1863 if (priv->ieee80211->state != IEEE80211_LINKED)
1866 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1869 if (network->flags & NETWORK_HAS_QOS_MASK) {
1870 if (active_network &&
1871 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
1872 network->qos_data.active = network->qos_data.supported;
1874 if ((network->qos_data.active == 1) && (active_network == 1) &&
1875 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
1876 (network->qos_data.old_param_count !=
1877 network->qos_data.param_count)) {
1878 network->qos_data.old_param_count =
1879 network->qos_data.param_count;
1880 queue_work(priv->priv_wq, &priv->qos_activate);
1881 RT_TRACE(COMP_QOS, "QoS parameters change call "
1885 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1886 &def_qos_parameters, size);
1888 if ((network->qos_data.active == 1) && (active_network == 1)) {
1889 queue_work(priv->priv_wq, &priv->qos_activate);
1890 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
1892 network->qos_data.active = 0;
1893 network->qos_data.supported = 0;
1899 /* handle and manage frame from beacon and probe response */
1900 static int rtl8192_handle_beacon(struct net_device *dev,
1901 struct ieee80211_beacon *beacon,
1902 struct ieee80211_network *network)
1904 struct r8192_priv *priv = ieee80211_priv(dev);
1906 rtl8192_qos_handle_probe_response(priv, 1, network);
1907 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
1913 * handling the beaconing responses. if we get different QoS setting
1914 * off the network from the associated setting, adjust the QoS
1917 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
1918 struct ieee80211_network *network)
1920 unsigned long flags;
1921 u32 size = sizeof(struct ieee80211_qos_parameters);
1922 int set_qos_param = 0;
1924 if ((priv == NULL) || (network == NULL))
1927 if (priv->ieee80211->state != IEEE80211_LINKED)
1930 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1933 spin_lock_irqsave(&priv->ieee80211->lock, flags);
1934 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
1935 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1936 &network->qos_data.parameters,
1937 sizeof(struct ieee80211_qos_parameters));
1938 priv->ieee80211->current_network.qos_data.active = 1;
1940 /* update qos parameter for current network */
1941 priv->ieee80211->current_network.qos_data.old_param_count =
1942 priv->ieee80211->current_network.qos_data.param_count;
1943 priv->ieee80211->current_network.qos_data.param_count =
1944 network->qos_data.param_count;
1946 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1947 &def_qos_parameters, size);
1948 priv->ieee80211->current_network.qos_data.active = 0;
1949 priv->ieee80211->current_network.qos_data.supported = 0;
1953 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
1955 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n", __func__, network->flags, priv->ieee80211->current_network.qos_data.active);
1956 if (set_qos_param == 1)
1957 queue_work(priv->priv_wq, &priv->qos_activate);
1964 static int rtl8192_handle_assoc_response(struct net_device *dev,
1965 struct ieee80211_assoc_response_frame *resp,
1966 struct ieee80211_network *network)
1968 struct r8192_priv *priv = ieee80211_priv(dev);
1969 rtl8192_qos_association_resp(priv, network);
1974 void rtl8192_update_ratr_table(struct net_device *dev)
1976 struct r8192_priv *priv = ieee80211_priv(dev);
1977 struct ieee80211_device *ieee = priv->ieee80211;
1978 u8 *pMcsRate = ieee->dot11HTOperationalRateSet;
1981 rtl8192_config_rate(dev, (u16 *)(&ratr_value));
1982 ratr_value |= (*(u16 *)(pMcsRate)) << 12;
1983 switch (ieee->mode) {
1985 ratr_value &= 0x00000FF0;
1988 ratr_value &= 0x0000000F;
1991 ratr_value &= 0x00000FF7;
1995 if (ieee->pHTInfo->PeerMimoPs == 0) { /* MIMO_PS_STATIC */
1996 ratr_value &= 0x0007F007;
1998 if (priv->rf_type == RF_1T2R)
1999 ratr_value &= 0x000FF007;
2001 ratr_value &= 0x0F81F007;
2007 ratr_value &= 0x0FFFFFFF;
2008 if (ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz)
2009 ratr_value |= 0x80000000;
2010 else if (!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz)
2011 ratr_value |= 0x80000000;
2012 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2013 write_nic_byte(dev, UFWP, 1);
2016 static u8 ccmp_ie[4] = {0x00, 0x50, 0xf2, 0x04};
2017 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2018 static bool GetNmodeSupportBySecCfg8192(struct net_device *dev)
2020 struct r8192_priv *priv = ieee80211_priv(dev);
2021 struct ieee80211_device *ieee = priv->ieee80211;
2022 struct ieee80211_network *network = &ieee->current_network;
2023 int wpa_ie_len = ieee->wpa_ie_len;
2024 struct ieee80211_crypt_data *crypt;
2027 crypt = ieee->crypt[ieee->tx_keyidx];
2028 //we use connecting AP's capability instead of only security config on our driver to distinguish whether it should use N mode or G mode
2029 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name, "WEP")));
2032 if (encrypt && (wpa_ie_len == 0)) {
2033 /* wep encryption, no N mode setting */
2035 } else if ((wpa_ie_len != 0)) {
2036 /* parse pairwise key type */
2037 if (((ieee->wpa_ie[0] == 0xdd) && (!memcmp(&(ieee->wpa_ie[14]), ccmp_ie, 4))) || ((ieee->wpa_ie[0] == 0x30) && (!memcmp(&ieee->wpa_ie[10], ccmp_rsn_ie, 4))))
2048 static bool GetHalfNmodeSupportByAPs819xUsb(struct net_device *dev)
2051 struct r8192_priv *priv = ieee80211_priv(dev);
2052 struct ieee80211_device *ieee = priv->ieee80211;
2054 if (ieee->bHalfWirelessN24GMode == true)
2062 static void rtl8192_refresh_supportrate(struct r8192_priv *priv)
2064 struct ieee80211_device *ieee = priv->ieee80211;
2065 //we do not consider set support rate for ABG mode, only HT MCS rate is set here.
2066 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2067 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2069 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2073 static u8 rtl8192_getSupportedWireleeMode(struct net_device *dev)
2075 struct r8192_priv *priv = ieee80211_priv(dev);
2077 switch (priv->rf_chip) {
2081 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2084 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2087 ret = WIRELESS_MODE_B;
2092 static void rtl8192_SetWirelessMode(struct net_device *dev, u8 wireless_mode)
2094 struct r8192_priv *priv = ieee80211_priv(dev);
2095 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2097 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode) == 0)) {
2098 if (bSupportMode & WIRELESS_MODE_N_24G) {
2099 wireless_mode = WIRELESS_MODE_N_24G;
2100 } else if (bSupportMode & WIRELESS_MODE_N_5G) {
2101 wireless_mode = WIRELESS_MODE_N_5G;
2102 } else if ((bSupportMode & WIRELESS_MODE_A)) {
2103 wireless_mode = WIRELESS_MODE_A;
2104 } else if ((bSupportMode & WIRELESS_MODE_G)) {
2105 wireless_mode = WIRELESS_MODE_G;
2106 } else if ((bSupportMode & WIRELESS_MODE_B)) {
2107 wireless_mode = WIRELESS_MODE_B;
2109 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __func__, bSupportMode);
2110 wireless_mode = WIRELESS_MODE_B;
2113 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2114 ActUpdateChannelAccessSetting(pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting);
2116 priv->ieee80211->mode = wireless_mode;
2118 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2119 priv->ieee80211->pHTInfo->bEnableHT = 1;
2121 priv->ieee80211->pHTInfo->bEnableHT = 0;
2122 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2123 rtl8192_refresh_supportrate(priv);
2126 //init priv variables here. only non_zero value should be initialized here.
2127 static void rtl8192_init_priv_variable(struct net_device *dev)
2129 struct r8192_priv *priv = ieee80211_priv(dev);
2131 priv->card_8192 = NIC_8192U;
2132 priv->chan = 1; //set to channel 1
2133 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2134 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2135 priv->ieee80211->ieee_up = 0;
2136 priv->retry_rts = DEFAULT_RETRY_RTS;
2137 priv->retry_data = DEFAULT_RETRY_DATA;
2138 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2139 priv->ieee80211->rate = 110; //11 mbps
2140 priv->ieee80211->short_slot = 1;
2141 priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
2144 priv->IrpPendingCount = 1;
2145 priv->ResetProgress = RESET_TYPE_NORESET;
2146 priv->bForcedSilentReset = 0;
2147 priv->bDisableNormalResetCheck = false;
2148 priv->force_reset = false;
2150 priv->ieee80211->FwRWRF = 0; //we don't use FW read/write RF until stable firmware is available.
2151 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2152 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2153 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2154 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
2155 IEEE_SOFTMAC_BEACONS;//added by amy 080604
2157 priv->ieee80211->active_scan = 1;
2158 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2159 priv->ieee80211->host_encrypt = 1;
2160 priv->ieee80211->host_decrypt = 1;
2161 priv->ieee80211->start_send_beacons = NULL; //-by amy 080604
2162 priv->ieee80211->stop_send_beacons = NULL; //-by amy 080604
2163 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2164 priv->ieee80211->set_chan = rtl8192_set_chan;
2165 priv->ieee80211->link_change = rtl8192_link_change;
2166 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2167 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2168 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2169 priv->ieee80211->init_wmmparam_flag = 0;
2170 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2171 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2172 priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
2173 priv->ieee80211->qos_support = 1;
2176 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2177 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2178 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2180 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
2181 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
2182 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2184 priv->ieee80211->InitialGainHandler = InitialGain819xUsb;
2185 priv->card_type = USB;
2187 if (Adapter->bInHctTest) {
2188 pHalData->ShortRetryLimit = 7;
2189 pHalData->LongRetryLimit = 7;
2192 priv->ShortRetryLimit = 0x30;
2193 priv->LongRetryLimit = 0x30;
2194 priv->EarlyRxThreshold = 7;
2195 priv->enable_gpio0 = 0;
2196 priv->TransmitConfig =
2197 (TCR_MXDMA_2048<<TCR_MXDMA_OFFSET)| // Max DMA Burst Size per Tx DMA Burst, 7: reserved.
2198 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)| // Short retry limit
2199 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
2200 (false ? TCR_SAT : 0); // FALSE: HW provides PLCP length and LENGEXT, TRUE: SW provides them
2202 if (Adapter->bInHctTest)
2203 pHalData->ReceiveConfig = pHalData->CSMethod |
2204 RCR_AMF | RCR_ADF | //accept management/data
2206 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2207 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2208 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2209 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2210 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
2211 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt : 0);
2215 priv->ReceiveConfig =
2216 RCR_AMF | RCR_ADF | //accept management/data
2217 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2218 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2219 ((u32)7<<RCR_MXDMA_OFFSET)| // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2220 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) | // Rx FIFO Threshold, 7: No Rx threshold.
2221 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT : 0);
2223 priv->AcmControl = 0;
2224 priv->pFirmware = kzalloc(sizeof(rt_firmware), GFP_KERNEL);
2226 /* rx related queue */
2227 skb_queue_head_init(&priv->rx_queue);
2228 skb_queue_head_init(&priv->skb_queue);
2230 /* Tx related queue */
2231 for (i = 0; i < MAX_QUEUE_SIZE; i++)
2232 skb_queue_head_init(&priv->ieee80211->skb_waitQ[i]);
2233 for (i = 0; i < MAX_QUEUE_SIZE; i++)
2234 skb_queue_head_init(&priv->ieee80211->skb_aggQ[i]);
2235 for (i = 0; i < MAX_QUEUE_SIZE; i++)
2236 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ[i]);
2237 priv->rf_set_chan = rtl8192_phy_SwChnl;
2241 static void rtl8192_init_priv_lock(struct r8192_priv *priv)
2243 spin_lock_init(&priv->tx_lock);
2244 spin_lock_init(&priv->irq_lock);//added by thomas
2245 sema_init(&priv->wx_sem, 1);
2246 sema_init(&priv->rf_sem, 1);
2247 mutex_init(&priv->mutex);
2250 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
2252 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2253 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2254 #define DRV_NAME "wlan0"
2255 static void rtl8192_init_priv_task(struct net_device *dev)
2257 struct r8192_priv *priv = ieee80211_priv(dev);
2259 priv->priv_wq = create_workqueue(DRV_NAME);
2261 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2263 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2264 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2265 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2266 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2267 INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
2268 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2270 tasklet_init(&priv->irq_rx_tasklet,
2271 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2272 (unsigned long)priv);
2275 static void rtl8192_get_eeprom_size(struct net_device *dev)
2278 struct r8192_priv *priv = ieee80211_priv(dev);
2279 RT_TRACE(COMP_EPROM, "===========>%s()\n", __func__);
2280 read_nic_word_E(dev, EPROM_CMD, &curCR);
2281 RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
2282 //whether need I consider BIT5?
2283 priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2284 RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __func__, priv->epromtype);
2287 //used to swap endian. as ntohl & htonl are not necessary to swap endian, so use this instead.
2288 static inline u16 endian_swap(u16 *data)
2291 *data = (tmp >> 8) | (tmp << 8);
2294 static void rtl8192_read_eeprom_info(struct net_device *dev)
2297 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
2298 u8 bLoad_From_EEPOM = false;
2299 struct r8192_priv *priv = ieee80211_priv(dev);
2302 RT_TRACE(COMP_EPROM, "===========>%s()\n", __func__);
2303 wEPROM_ID = eprom_read(dev, 0); //first read EEPROM ID out;
2304 RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
2306 if (wEPROM_ID != RTL8190_EEPROM_ID) {
2307 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", wEPROM_ID, RTL8190_EEPROM_ID);
2309 bLoad_From_EEPOM = true;
2312 if (bLoad_From_EEPOM) {
2313 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
2314 priv->eeprom_vid = endian_swap(&tmpValue);
2315 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
2316 tmpValue = eprom_read(dev, (EEPROM_ChannelPlan>>1));
2317 priv->eeprom_ChannelPlan = ((tmpValue&0xff00)>>8);
2318 priv->btxpowerdata_readfromEEPORM = true;
2319 priv->eeprom_CustomerID = eprom_read(dev, (EEPROM_Customer_ID>>1)) >>8;
2321 priv->eeprom_vid = 0;
2322 priv->eeprom_pid = 0;
2323 priv->card_8192_version = VERSION_819xU_B;
2324 priv->eeprom_ChannelPlan = 0;
2325 priv->eeprom_CustomerID = 0;
2327 RT_TRACE(COMP_EPROM, "vid:0x%4x, pid:0x%4x, CustomID:0x%2x, ChanPlan:0x%x\n", priv->eeprom_vid, priv->eeprom_pid, priv->eeprom_CustomerID, priv->eeprom_ChannelPlan);
2328 //set channelplan from eeprom
2329 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2330 if (bLoad_From_EEPOM) {
2332 for (i = 0; i < 6; i += 2) {
2334 tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
2335 *(u16 *)(&dev->dev_addr[i]) = tmp;
2338 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2339 //should I set IDR0 here?
2341 RT_TRACE(COMP_EPROM, "MAC addr:%pM\n", dev->dev_addr);
2342 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
2343 priv->rf_chip = RF_8256;
2345 if (priv->card_8192_version == (u8)VERSION_819xU_A) {
2346 //read Tx power gain offset of legacy OFDM to HT rate
2347 if (bLoad_From_EEPOM)
2348 priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff>>1))&0xff00) >> 8;
2350 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
2351 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
2352 //read ThermalMeter from EEPROM
2353 if (bLoad_From_EEPOM)
2354 priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter>>1))&0x00ff);
2356 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2357 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
2358 //vivi, for tx power track
2359 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2360 //read antenna tx power offset of B/C/D to A from EEPROM
2361 if (bLoad_From_EEPOM)
2362 priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff>>1))&0x0f00)>>8;
2364 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
2365 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
2366 // Read CrystalCap from EEPROM
2367 if (bLoad_From_EEPOM)
2368 priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap>>1))&0x0f);
2370 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
2371 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
2372 //get per-channel Tx power level
2373 if (bLoad_From_EEPOM)
2374 priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver>>1))&0xff00)>>8;
2376 priv->EEPROM_Def_Ver = 1;
2377 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
2378 if (priv->EEPROM_Def_Ver == 0) { /* old eeprom definition */
2380 if (bLoad_From_EEPOM)
2381 priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK>>1))&0xff) >> 8;
2383 priv->EEPROMTxPowerLevelCCK = 0x10;
2384 RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
2385 for (i = 0; i < 3; i++) {
2386 if (bLoad_From_EEPOM) {
2387 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G+i)>>1);
2388 if (((EEPROM_TxPwIndex_OFDM_24G+i) % 2) == 0)
2389 tmpValue = tmpValue & 0x00ff;
2391 tmpValue = (tmpValue & 0xff00) >> 8;
2395 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8) tmpValue;
2396 RT_TRACE(COMP_EPROM, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK);
2398 } else if (priv->EEPROM_Def_Ver == 1) {
2399 if (bLoad_From_EEPOM) {
2400 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1>>1));
2401 tmpValue = (tmpValue & 0xff00) >> 8;
2405 priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
2407 if (bLoad_From_EEPOM)
2408 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2)>>1);
2411 *((u16 *)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
2412 if (bLoad_From_EEPOM)
2413 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1>>1));
2416 *((u16 *)(&priv->EEPROMTxPowerLevelOFDM24G[0])) = tmpValue;
2417 if (bLoad_From_EEPOM)
2418 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1+2)>>1);
2421 priv->EEPROMTxPowerLevelOFDM24G[2] = (u8)tmpValue;
2422 }//endif EEPROM_Def_Ver == 1
2424 //update HAL variables
2426 for (i = 0; i < 14; i++) {
2428 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[0];
2429 else if (i >= 4 && i <= 9)
2430 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[1];
2432 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[2];
2435 for (i = 0; i < 14; i++) {
2436 if (priv->EEPROM_Def_Ver == 0) {
2438 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[0] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
2439 else if (i >= 4 && i <= 9)
2440 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK;
2442 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[2] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
2443 } else if (priv->EEPROM_Def_Ver == 1) {
2445 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[0];
2446 else if (i >= 4 && i <= 9)
2447 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[1];
2449 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[2];
2452 priv->TxPowerDiff = priv->EEPROMPwDiff;
2453 // Antenna B gain offset to antenna A, bit0~3
2454 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
2455 // Antenna C gain offset to antenna A, bit4~7
2456 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
2457 // CrystalCap, bit12~15
2458 priv->CrystalCap = priv->EEPROMCrystalCap;
2459 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2460 // 92U does not enable TX power tracking.
2461 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
2462 }//end if VersionID == VERSION_819xU_A
2464 //added by vivi, for dlink led, 20080416
2465 switch (priv->eeprom_CustomerID) {
2466 case EEPROM_CID_RUNTOP:
2467 priv->CustomerID = RT_CID_819x_RUNTOP;
2470 case EEPROM_CID_DLINK:
2471 priv->CustomerID = RT_CID_DLINK;
2475 priv->CustomerID = RT_CID_DEFAULT;
2480 switch (priv->CustomerID) {
2481 case RT_CID_819x_RUNTOP:
2482 priv->LedStrategy = SW_LED_MODE2;
2486 priv->LedStrategy = SW_LED_MODE4;
2490 priv->LedStrategy = SW_LED_MODE0;
2496 if (priv->rf_type == RF_1T2R) {
2497 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
2499 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
2502 // 2008/01/16 MH We can only know RF type in the function. So we have to init
2503 // DIG RATR table again.
2504 init_rate_adaptive(dev);
2505 //we need init DIG RATR table here again.
2507 RT_TRACE(COMP_EPROM, "<===========%s()\n", __func__);
2511 static short rtl8192_get_channel_map(struct net_device *dev)
2513 struct r8192_priv *priv = ieee80211_priv(dev);
2514 if (priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN) {
2515 netdev_err(dev, "rtl8180_init: Error channel plan! Set to default.\n");
2516 priv->ChannelPlan = 0;
2518 RT_TRACE(COMP_INIT, "Channel plan is %d\n", priv->ChannelPlan);
2520 rtl819x_set_channel_map(priv->ChannelPlan, priv);
2524 static short rtl8192_init(struct net_device *dev)
2527 struct r8192_priv *priv = ieee80211_priv(dev);
2529 memset(&(priv->stats), 0, sizeof(struct Stats));
2530 memset(priv->txqueue_to_outpipemap, 0, 9);
2534 u8 queuetopipe[] = {3, 2, 1, 0, 4, 8, 7, 6, 5};
2535 memcpy(priv->txqueue_to_outpipemap, queuetopipe, 9);
2539 u8 queuetopipe[] = {3, 2, 1, 0, 4, 4, 0, 4, 4};
2540 memcpy(priv->txqueue_to_outpipemap, queuetopipe, 9);
2543 rtl8192_init_priv_variable(dev);
2544 rtl8192_init_priv_lock(priv);
2545 rtl8192_init_priv_task(dev);
2546 rtl8192_get_eeprom_size(dev);
2547 rtl8192_read_eeprom_info(dev);
2548 rtl8192_get_channel_map(dev);
2550 init_timer(&priv->watch_dog_timer);
2551 priv->watch_dog_timer.data = (unsigned long)dev;
2552 priv->watch_dog_timer.function = watch_dog_timer_callback;
2553 if (rtl8192_usb_initendpoints(dev) != 0) {
2554 DMESG("Endopoints initialization failed");
2561 /******************************************************************************
2562 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
2563 * not to do all the hw config as its name says
2564 * input: net_device dev
2567 * notice: This part need to modified according to the rate set we filtered
2568 * ****************************************************************************/
2569 static void rtl8192_hwconfig(struct net_device *dev)
2571 u32 regRATR = 0, regRRSR = 0;
2572 u8 regBwOpMode = 0, regTmp = 0;
2573 struct r8192_priv *priv = ieee80211_priv(dev);
2576 // Set RRSR, RATR, and BW_OPMODE registers
2578 switch (priv->ieee80211->mode) {
2579 case WIRELESS_MODE_B:
2580 regBwOpMode = BW_OPMODE_20MHZ;
2581 regRATR = RATE_ALL_CCK;
2582 regRRSR = RATE_ALL_CCK;
2584 case WIRELESS_MODE_A:
2585 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
2586 regRATR = RATE_ALL_OFDM_AG;
2587 regRRSR = RATE_ALL_OFDM_AG;
2589 case WIRELESS_MODE_G:
2590 regBwOpMode = BW_OPMODE_20MHZ;
2591 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2592 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2594 case WIRELESS_MODE_AUTO:
2596 if (Adapter->bInHctTest) {
2597 regBwOpMode = BW_OPMODE_20MHZ;
2598 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2599 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2604 regBwOpMode = BW_OPMODE_20MHZ;
2605 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2606 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2609 case WIRELESS_MODE_N_24G:
2610 // It support CCK rate by default.
2611 // CCK rate will be filtered out only when associated AP does not support it.
2612 regBwOpMode = BW_OPMODE_20MHZ;
2613 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2614 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2616 case WIRELESS_MODE_N_5G:
2617 regBwOpMode = BW_OPMODE_5G;
2618 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2619 regRRSR = RATE_ALL_OFDM_AG;
2623 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
2624 ratr_value = regRATR;
2625 if (priv->rf_type == RF_1T2R)
2626 ratr_value &= ~(RATE_ALL_OFDM_2SS);
2627 write_nic_dword(dev, RATR0, ratr_value);
2628 write_nic_byte(dev, UFWP, 1);
2629 read_nic_byte(dev, 0x313, ®Tmp);
2630 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
2631 write_nic_dword(dev, RRSR, regRRSR);
2634 // Set Retry Limit here
2636 write_nic_word(dev, RETRY_LIMIT,
2637 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT |
2638 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
2639 // Set Contention Window here
2643 // Set Tx Antenna including Feedback control
2645 // Set Auto Rate fallback control
2651 //InitializeAdapter and PhyCfg
2652 static bool rtl8192_adapter_start(struct net_device *dev)
2654 struct r8192_priv *priv = ieee80211_priv(dev);
2656 bool init_status = true;
2657 u8 SECR_value = 0x0;
2659 RT_TRACE(COMP_INIT, "====>%s()\n", __func__);
2660 priv->Rf_Mode = RF_OP_By_SW_3wire;
2661 //for ASIC power on sequence
2662 write_nic_byte_E(dev, 0x5f, 0x80);
2664 write_nic_byte_E(dev, 0x5f, 0xf0);
2665 write_nic_byte_E(dev, 0x5d, 0x00);
2666 write_nic_byte_E(dev, 0x5e, 0x80);
2667 write_nic_byte(dev, 0x17, 0x37);
2669 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
2670 //config CPUReset Register
2671 //Firmware Reset or not?
2672 read_nic_dword(dev, CPU_GEN, &dwRegRead);
2673 if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
2674 dwRegRead |= CPU_GEN_SYSTEM_RESET; //do nothing here?
2675 else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY)
2676 dwRegRead |= CPU_GEN_FIRMWARE_RESET;
2678 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __func__, priv->pFirmware->firmware_status);
2680 write_nic_dword(dev, CPU_GEN, dwRegRead);
2682 rtl8192_BBConfig(dev);
2684 //Loopback mode or not
2685 priv->LoopbackMode = RTL819xU_NO_LOOPBACK;
2687 read_nic_dword(dev, CPU_GEN, &dwRegRead);
2688 if (priv->LoopbackMode == RTL819xU_NO_LOOPBACK)
2689 dwRegRead = ((dwRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
2690 else if (priv->LoopbackMode == RTL819xU_MAC_LOOPBACK)
2691 dwRegRead |= CPU_CCK_LOOPBACK;
2693 RT_TRACE(COMP_ERR, "Serious error in %s(): wrong loopback mode setting(%d)\n", __func__, priv->LoopbackMode);
2695 write_nic_dword(dev, CPU_GEN, dwRegRead);
2697 //after reset cpu, we need wait for a seconds to write in register.
2700 //xiong add for new bitfile:usb suspend reset pin set to 1. //do we need?
2701 read_nic_byte_E(dev, 0x5f, &tmp);
2702 write_nic_byte_E(dev, 0x5f, tmp|0x20);
2705 rtl8192_hwconfig(dev);
2708 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
2711 write_nic_dword(dev, MAC0, ((u32 *)dev->dev_addr)[0]);
2712 write_nic_word(dev, MAC4, ((u16 *)(dev->dev_addr + 4))[0]);
2715 write_nic_dword(dev, RCR, priv->ReceiveConfig);
2717 //Initialize Number of Reserved Pages in Firmware Queue
2718 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
2719 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
2720 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
2721 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
2722 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT |
2723 NUM_OF_PAGE_IN_FW_QUEUE_CMD << RSVD_FW_QUEUE_PAGE_CMD_SHIFT);
2724 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
2725 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT);
2726 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
2729 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
2730 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
2732 if (priv->ResetProgress == RESET_TYPE_NORESET)
2733 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
2734 if (priv->ResetProgress == RESET_TYPE_NORESET) {
2735 CamResetAllEntry(dev);
2736 SECR_value |= SCR_TxEncEnable;
2737 SECR_value |= SCR_RxDecEnable;
2738 SECR_value |= SCR_NoSKMC;
2739 write_nic_byte(dev, SECR, SECR_value);
2743 write_nic_word(dev, ATIMWND, 2);
2744 write_nic_word(dev, BCN_INTERVAL, 100);
2746 #define DEFAULT_EDCA 0x005e4332
2749 for (i = 0; i < QOS_QUEUE_NUM; i++)
2750 write_nic_dword(dev, WDCAPARA_ADD[i], DEFAULT_EDCA);
2753 rtl8192_phy_configmac(dev);
2755 if (priv->card_8192_version == (u8) VERSION_819xU_A) {
2756 rtl8192_phy_getTxPower(dev);
2757 rtl8192_phy_setTxPower(dev, priv->chan);
2761 init_status = init_firmware(dev);
2763 RT_TRACE(COMP_ERR, "ERR!!! %s(): Firmware download is failed\n", __func__);
2766 RT_TRACE(COMP_INIT, "%s():after firmware download\n", __func__);
2769 if (Adapter->ResetProgress == RESET_TYPE_NORESET) {
2770 if (pMgntInfo->RegRfOff == TRUE) { /* User disable RF via registry. */
2771 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
2772 MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
2773 // Those actions will be discard in MgntActSet_RF_State because of the same state
2774 for (eRFPath = 0; eRFPath < pHalData->NumTotalRFPath; eRFPath++)
2775 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
2776 } else if (pMgntInfo->RfOffReason > RF_CHANGE_BY_PS) { /* H/W or S/W RF OFF before sleep. */
2777 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RfOffReason(%d) ----------\n", pMgntInfo->RfOffReason));
2778 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
2780 pHalData->eRFPowerState = eRfOn;
2781 pMgntInfo->RfOffReason = 0;
2782 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): RF is on ----------\n"));
2785 if (pHalData->eRFPowerState == eRfOff) {
2786 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
2787 // Those actions will be discard in MgntActSet_RF_State because of the same state
2788 for (eRFPath = 0; eRFPath < pHalData->NumTotalRFPath; eRFPath++)
2789 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
2794 if (priv->ResetProgress == RESET_TYPE_NORESET) {
2795 rtl8192_phy_RFConfig(dev);
2796 RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __func__);
2800 if (priv->ieee80211->FwRWRF)
2801 // We can force firmware to do RF-R/W
2802 priv->Rf_Mode = RF_OP_By_FW;
2804 priv->Rf_Mode = RF_OP_By_SW_3wire;
2807 rtl8192_phy_updateInitGain(dev);
2808 /*--set CCK and OFDM Block "ON"--*/
2809 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
2810 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
2812 if (priv->ResetProgress == RESET_TYPE_NORESET) {
2815 read_nic_byte(dev, 0x301, &tmpvalue);
2816 if (tmpvalue == 0x03) {
2818 RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
2820 priv->bDcut = FALSE;
2821 RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
2823 dm_initialize_txpower_tracking(dev);
2825 if (priv->bDcut == TRUE) {
2827 u32 tmpRegA = rtl8192_QueryBBReg(dev, rOFDM0_XATxIQImbalance, bMaskDWord);
2828 for (i = 0; i < TxBBGainTableLength; i++) {
2829 if (tmpRegA == priv->txbbgain_table[i].txbbgain_value) {
2830 priv->rfa_txpowertrackingindex = (u8)i;
2831 priv->rfa_txpowertrackingindex_real = (u8)i;
2832 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
2837 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
2839 for (i = 0; i < CCKTxBBGainTableLength; i++) {
2841 if (TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0]) {
2842 priv->cck_present_attentuation_20Mdefault = (u8) i;
2846 priv->cck_present_attentuation_40Mdefault = 0;
2847 priv->cck_present_attentuation_difference = 0;
2848 priv->cck_present_attentuation = priv->cck_present_attentuation_20Mdefault;
2852 write_nic_byte(dev, 0x87, 0x0);
2858 /* this configures registers for beacon tx and enables it via
2859 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
2860 * be used to stop beacon transmission
2862 /***************************************************************************
2863 -------------------------------NET STUFF---------------------------
2864 ***************************************************************************/
2866 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
2868 struct r8192_priv *priv = ieee80211_priv(dev);
2870 return &priv->ieee80211->stats;
2873 static bool HalTxCheckStuck819xUsb(struct net_device *dev)
2875 struct r8192_priv *priv = ieee80211_priv(dev);
2877 bool bStuck = FALSE;
2878 read_nic_word(dev, 0x128, &RegTxCounter);
2879 RT_TRACE(COMP_RESET, "%s():RegTxCounter is %d,TxCounter is %d\n", __func__, RegTxCounter, priv->TxCounter);
2880 if (priv->TxCounter == RegTxCounter)
2883 priv->TxCounter = RegTxCounter;
2889 * <Assumption: RT_TX_SPINLOCK is acquired.>
2890 * First added: 2006.11.19 by emily
2892 static RESET_TYPE TxCheckStuck(struct net_device *dev)
2894 struct r8192_priv *priv = ieee80211_priv(dev);
2896 bool bCheckFwTxCnt = false;
2899 // Decide such threshold according to current power save mode
2902 for (QueueID = 0; QueueID <= BEACON_QUEUE; QueueID++) {
2903 if (QueueID == TXCMD_QUEUE)
2905 if ((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
2908 bCheckFwTxCnt = true;
2910 if (bCheckFwTxCnt) {
2911 if (HalTxCheckStuck819xUsb(dev)) {
2912 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
2913 return RESET_TYPE_SILENT;
2916 return RESET_TYPE_NORESET;
2919 static bool HalRxCheckStuck819xUsb(struct net_device *dev)
2922 struct r8192_priv *priv = ieee80211_priv(dev);
2923 bool bStuck = FALSE;
2924 static u8 rx_chk_cnt;
2925 read_nic_word(dev, 0x130, &RegRxCounter);
2926 RT_TRACE(COMP_RESET, "%s(): RegRxCounter is %d,RxCounter is %d\n", __func__, RegRxCounter, priv->RxCounter);
2927 // If rssi is small, we should check rx for long time because of bad rx.
2928 // or maybe it will continuous silent reset every 2 seconds.
2930 if (priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5)) {
2931 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
2932 } else if (priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
2933 ((priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_40M) ||
2934 (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_20M))) {
2939 } else if (((priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb < RateAdaptiveTH_Low_40M) ||
2940 (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb < RateAdaptiveTH_Low_20M)) &&
2941 priv->undecorated_smoothed_pwdb >= VeryLowRSSI) {
2953 if (priv->RxCounter == RegRxCounter)
2956 priv->RxCounter = RegRxCounter;
2961 static RESET_TYPE RxCheckStuck(struct net_device *dev)
2963 struct r8192_priv *priv = ieee80211_priv(dev);
2964 bool bRxCheck = FALSE;
2966 if (priv->IrpPendingCount > 1)
2970 if (HalRxCheckStuck819xUsb(dev)) {
2971 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
2972 return RESET_TYPE_SILENT;
2975 return RESET_TYPE_NORESET;
2980 * This function is called by Checkforhang to check whether we should ask OS to reset driver
2982 * \param pAdapter The adapter context for this miniport
2984 * Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
2985 * to judge whether there is tx stuck.
2986 * Note: This function may be required to be rewrite for Vista OS.
2987 * <<<Assumption: Tx spinlock has been acquired >>>
2989 * 8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
2991 static RESET_TYPE rtl819x_ifcheck_resetornot(struct net_device *dev)
2993 struct r8192_priv *priv = ieee80211_priv(dev);
2994 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
2995 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
2996 RT_RF_POWER_STATE rfState;
2998 rfState = priv->ieee80211->eRFPowerState;
3000 TxResetType = TxCheckStuck(dev);
3001 if (rfState != eRfOff ||
3002 (priv->ieee80211->iw_mode != IW_MODE_ADHOC)) {
3003 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3004 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3005 // if driver is in firmware download failure status, driver should initialize RF in the following
3006 // silent reset procedure Emily, 2008.01.21
3008 // Driver should not check RX stuck in IBSS mode because it is required to
3009 // set Check BSSID in order to send beacon, however, if check BSSID is
3010 // set, STA cannot hear any packet at all. Emily, 2008.04.12
3011 RxResetType = RxCheckStuck(dev);
3013 if (TxResetType == RESET_TYPE_NORMAL || RxResetType == RESET_TYPE_NORMAL) {
3014 return RESET_TYPE_NORMAL;
3015 } else if (TxResetType == RESET_TYPE_SILENT || RxResetType == RESET_TYPE_SILENT) {
3016 RT_TRACE(COMP_RESET, "%s():silent reset\n", __func__);
3017 return RESET_TYPE_SILENT;
3019 return RESET_TYPE_NORESET;
3024 void rtl8192_cancel_deferred_work(struct r8192_priv *priv);
3025 int _rtl8192_up(struct net_device *dev);
3026 int rtl8192_close(struct net_device *dev);
3030 static void CamRestoreAllEntry(struct net_device *dev)
3033 struct r8192_priv *priv = ieee80211_priv(dev);
3034 u8 *MacAddr = priv->ieee80211->current_network.bssid;
3036 static u8 CAM_CONST_ADDR[4][6] = {
3037 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3038 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3039 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3040 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03} };
3041 static u8 CAM_CONST_BROAD[] = {
3042 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3044 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3047 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40) ||
3048 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104)) {
3050 for (EntryId = 0; EntryId < 4; EntryId++) {
3051 MacAddr = CAM_CONST_ADDR[EntryId];
3052 setKey(dev, EntryId, EntryId,
3053 priv->ieee80211->pairwise_key_type,
3057 } else if (priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP) {
3059 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3060 setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3061 (u8 *)dev->dev_addr, 0, NULL);
3063 setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3065 } else if (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP) {
3067 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3068 setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3069 (u8 *)dev->dev_addr, 0, NULL);
3071 setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3077 if (priv->ieee80211->group_key_type == KEY_TYPE_TKIP) {
3078 MacAddr = CAM_CONST_BROAD;
3079 for (EntryId = 1; EntryId < 4; EntryId++) {
3080 setKey(dev, EntryId, EntryId,
3081 priv->ieee80211->group_key_type,
3084 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3085 setKey(dev, 0, 0, priv->ieee80211->group_key_type,
3086 CAM_CONST_ADDR[0], 0, NULL);
3087 } else if (priv->ieee80211->group_key_type == KEY_TYPE_CCMP) {
3088 MacAddr = CAM_CONST_BROAD;
3089 for (EntryId = 1; EntryId < 4; EntryId++) {
3090 setKey(dev, EntryId, EntryId,
3091 priv->ieee80211->group_key_type,
3095 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3096 setKey(dev, 0, 0, priv->ieee80211->group_key_type,
3097 CAM_CONST_ADDR[0], 0, NULL);
3100 //////////////////////////////////////////////////////////////
3101 // This function is used to fix Tx/Rx stop bug temporarily.
3102 // This function will do "system reset" to NIC when Tx or Rx is stuck.
3103 // The method checking Tx/Rx stuck of this function is supported by FW,
3104 // which reports Tx and Rx counter to register 0x128 and 0x130.
3105 //////////////////////////////////////////////////////////////
3106 static void rtl819x_ifsilentreset(struct net_device *dev)
3108 struct r8192_priv *priv = ieee80211_priv(dev);
3110 int reset_status = 0;
3111 struct ieee80211_device *ieee = priv->ieee80211;
3114 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3115 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3117 if (priv->ResetProgress == RESET_TYPE_NORESET) {
3120 RT_TRACE(COMP_RESET, "=========>Reset progress!! \n");
3122 // Set the variable for reset.
3123 priv->ResetProgress = RESET_TYPE_SILENT;
3124 down(&priv->wx_sem);
3125 if (priv->up == 0) {
3126 RT_TRACE(COMP_ERR, "%s():the driver is not up! return\n", __func__);
3131 RT_TRACE(COMP_RESET, "%s():======>start to down the driver\n", __func__);
3133 rtl8192_rtx_disable(dev);
3134 rtl8192_cancel_deferred_work(priv);
3136 del_timer_sync(&priv->watch_dog_timer);
3138 ieee->sync_scan_hurryup = 1;
3139 if (ieee->state == IEEE80211_LINKED) {
3140 down(&ieee->wx_sem);
3141 netdev_dbg(dev, "ieee->state is IEEE80211_LINKED\n");
3142 ieee80211_stop_send_beacons(priv->ieee80211);
3143 del_timer_sync(&ieee->associate_timer);
3144 cancel_delayed_work(&ieee->associate_retry_wq);
3145 ieee80211_stop_scan(ieee);
3146 netif_carrier_off(dev);
3149 netdev_dbg(dev, "ieee->state is NOT LINKED\n");
3150 ieee80211_softmac_stop_protocol(priv->ieee80211);
3153 RT_TRACE(COMP_RESET, "%s():<==========down process is finished\n", __func__);
3154 RT_TRACE(COMP_RESET, "%s():===========>start up the driver\n", __func__);
3155 reset_status = _rtl8192_up(dev);
3157 RT_TRACE(COMP_RESET, "%s():<===========up process is finished\n", __func__);
3158 if (reset_status == -EAGAIN) {
3159 if (reset_times < 3) {
3163 RT_TRACE(COMP_ERR, " ERR!!! %s(): Reset Failed!!\n", __func__);
3166 ieee->is_silent_reset = 1;
3167 EnableHWSecurityConfig8192(dev);
3168 if (ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA) {
3169 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3171 queue_work(ieee->wq, &ieee->associate_complete_wq);
3173 } else if (ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC) {
3174 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3175 ieee->link_change(ieee->dev);
3177 ieee80211_start_send_beacons(ieee);
3179 if (ieee->data_hard_resume)
3180 ieee->data_hard_resume(ieee->dev);
3181 netif_carrier_on(ieee->dev);
3184 CamRestoreAllEntry(dev);
3186 priv->ResetProgress = RESET_TYPE_NORESET;
3187 priv->reset_count++;
3189 priv->bForcedSilentReset = false;
3190 priv->bResetInProgress = false;
3192 // For test --> force write UFWP.
3193 write_nic_byte(dev, UFWP, 1);
3194 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
3198 static void rtl819x_update_rxcounts(struct r8192_priv *priv, u32 *TotalRxBcnNum,
3199 u32 *TotalRxDataNum)
3205 *TotalRxDataNum = 0;
3207 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
3208 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
3209 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
3210 for (i = 0; i < priv->ieee80211->LinkDetectInfo.SlotNum; i++) {
3211 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
3212 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
3217 void rtl819x_watchdog_wqcallback(struct work_struct *work)
3219 struct delayed_work *dwork = container_of(work, struct delayed_work, work);
3220 struct r8192_priv *priv = container_of(dwork, struct r8192_priv, watch_dog_wq);
3221 struct net_device *dev = priv->ieee80211->dev;
3222 struct ieee80211_device *ieee = priv->ieee80211;
3223 RESET_TYPE ResetType = RESET_TYPE_NORESET;
3224 static u8 check_reset_cnt;
3225 bool bBusyTraffic = false;
3226 u32 TotalRxBcnNum = 0;
3227 u32 TotalRxDataNum = 0;
3231 hal_dm_watchdog(dev);
3233 //to get busy traffic condition
3234 if (ieee->state == IEEE80211_LINKED) {
3235 if (ieee->LinkDetectInfo.NumRxOkInPeriod > 666 ||
3236 ieee->LinkDetectInfo.NumTxOkInPeriod > 666 ) {
3237 bBusyTraffic = true;
3239 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
3240 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
3241 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
3243 //added by amy for AP roaming
3244 if (priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA) {
3246 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
3247 if ((TotalRxBcnNum+TotalRxDataNum) == 0) {
3249 if (rfState == eRfOff)
3250 RT_TRACE(COMP_ERR, "========>%s()\n", __func__);
3252 netdev_dbg(dev, "===>%s(): AP is power off, connect another one\n", __func__);
3253 priv->ieee80211->state = IEEE80211_ASSOCIATING;
3254 notify_wx_assoc_event(priv->ieee80211);
3255 RemovePeerTS(priv->ieee80211, priv->ieee80211->current_network.bssid);
3256 priv->ieee80211->link_change(dev);
3257 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
3261 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod = 0;
3262 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod = 0;
3263 //check if reset the driver
3264 if (check_reset_cnt++ >= 3) {
3265 ResetType = rtl819x_ifcheck_resetornot(dev);
3266 check_reset_cnt = 3;
3268 if ((priv->force_reset) || (priv->ResetProgress == RESET_TYPE_NORESET &&
3269 (priv->bForcedSilentReset ||
3270 (!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_SILENT)))) { /* This is control by OID set in Pomelo */
3271 RT_TRACE(COMP_RESET, "%s():priv->force_reset is %d,priv->ResetProgress is %d, priv->bForcedSilentReset is %d,priv->bDisableNormalResetCheck is %d,ResetType is %d\n", __func__, priv->force_reset, priv->ResetProgress, priv->bForcedSilentReset, priv->bDisableNormalResetCheck, ResetType);
3272 rtl819x_ifsilentreset(dev);
3274 priv->force_reset = false;
3275 priv->bForcedSilentReset = false;
3276 priv->bResetInProgress = false;
3277 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
3281 void watch_dog_timer_callback(unsigned long data)
3283 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
3284 queue_delayed_work(priv->priv_wq, &priv->watch_dog_wq, 0);
3285 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
3287 int _rtl8192_up(struct net_device *dev)
3289 struct r8192_priv *priv = ieee80211_priv(dev);
3290 int init_status = 0;
3292 priv->ieee80211->ieee_up = 1;
3293 RT_TRACE(COMP_INIT, "Bringing up iface");
3294 init_status = rtl8192_adapter_start(dev);
3296 RT_TRACE(COMP_ERR, "ERR!!! %s(): initialization failed!\n", __func__);
3297 priv->up = priv->ieee80211->ieee_up = 0;
3300 RT_TRACE(COMP_INIT, "start adapter finished\n");
3301 rtl8192_rx_enable(dev);
3302 if (priv->ieee80211->state != IEEE80211_LINKED)
3303 ieee80211_softmac_start_protocol(priv->ieee80211);
3304 ieee80211_reset_queue(priv->ieee80211);
3305 watch_dog_timer_callback((unsigned long) dev);
3306 if (!netif_queue_stopped(dev))
3307 netif_start_queue(dev);
3309 netif_wake_queue(dev);
3315 static int rtl8192_open(struct net_device *dev)
3317 struct r8192_priv *priv = ieee80211_priv(dev);
3319 down(&priv->wx_sem);
3320 ret = rtl8192_up(dev);
3327 int rtl8192_up(struct net_device *dev)
3329 struct r8192_priv *priv = ieee80211_priv(dev);
3334 return _rtl8192_up(dev);
3338 int rtl8192_close(struct net_device *dev)
3340 struct r8192_priv *priv = ieee80211_priv(dev);
3343 down(&priv->wx_sem);
3345 ret = rtl8192_down(dev);
3353 int rtl8192_down(struct net_device *dev)
3355 struct r8192_priv *priv = ieee80211_priv(dev);
3362 priv->ieee80211->ieee_up = 0;
3363 RT_TRACE(COMP_DOWN, "==========>%s()\n", __func__);
3365 if (!netif_queue_stopped(dev))
3366 netif_stop_queue(dev);
3368 rtl8192_rtx_disable(dev);
3370 /* Tx related queue release */
3371 for (i = 0; i < MAX_QUEUE_SIZE; i++)
3372 skb_queue_purge(&priv->ieee80211->skb_waitQ[i]);
3373 for (i = 0; i < MAX_QUEUE_SIZE; i++)
3374 skb_queue_purge(&priv->ieee80211->skb_aggQ[i]);
3376 for (i = 0; i < MAX_QUEUE_SIZE; i++)
3377 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ[i]);
3379 //as cancel_delayed_work will del work->timer, so if work is not defined as struct delayed_work, it will corrupt
3380 rtl8192_cancel_deferred_work(priv);
3382 del_timer_sync(&priv->watch_dog_timer);
3385 ieee80211_softmac_stop_protocol(priv->ieee80211);
3386 memset(&priv->ieee80211->current_network, 0, offsetof(struct ieee80211_network, list));
3387 RT_TRACE(COMP_DOWN, "<==========%s()\n", __func__);
3393 void rtl8192_commit(struct net_device *dev)
3395 struct r8192_priv *priv = ieee80211_priv(dev);
3396 int reset_status = 0;
3401 rtl8192_cancel_deferred_work(priv);
3402 del_timer_sync(&priv->watch_dog_timer);
3404 ieee80211_softmac_stop_protocol(priv->ieee80211);
3406 rtl8192_rtx_disable(dev);
3407 reset_status = _rtl8192_up(dev);
3411 void rtl8192_restart(struct work_struct *work)
3413 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
3414 struct net_device *dev = priv->ieee80211->dev;
3416 down(&priv->wx_sem);
3418 rtl8192_commit(dev);
3423 static void r8192_set_multicast(struct net_device *dev)
3425 struct r8192_priv *priv = ieee80211_priv(dev);
3430 promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
3432 if (promisc != priv->promisc)
3434 priv->promisc = promisc;
3438 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
3440 struct r8192_priv *priv = ieee80211_priv(dev);
3441 struct sockaddr *addr = mac;
3443 down(&priv->wx_sem);
3445 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
3447 schedule_work(&priv->reset_wq);
3453 /* based on ipw2200 driver */
3454 static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3456 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3457 struct iwreq *wrq = (struct iwreq *)rq;
3459 struct ieee80211_device *ieee = priv->ieee80211;
3461 u8 broadcast_addr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3462 struct iw_point *p = &wrq->u.data;
3463 struct ieee_param *ipw = NULL;
3465 down(&priv->wx_sem);
3468 if (p->length < sizeof(struct ieee_param) || !p->pointer) {
3473 ipw = memdup_user(p->pointer, p->length);
3480 case RTL_IOCTL_WPA_SUPPLICANT:
3481 //parse here for HW security
3482 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION) {
3483 if (ipw->u.crypt.set_tx) {
3484 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) {
3485 ieee->pairwise_key_type = KEY_TYPE_CCMP;
3486 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) {
3487 ieee->pairwise_key_type = KEY_TYPE_TKIP;
3488 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
3489 if (ipw->u.crypt.key_len == 13)
3490 ieee->pairwise_key_type = KEY_TYPE_WEP104;
3491 else if (ipw->u.crypt.key_len == 5)
3492 ieee->pairwise_key_type = KEY_TYPE_WEP40;
3494 ieee->pairwise_key_type = KEY_TYPE_NA;
3497 if (ieee->pairwise_key_type) {
3498 memcpy((u8 *)key, ipw->u.crypt.key, 16);
3499 EnableHWSecurityConfig8192(dev);
3500 //we fill both index entry and 4th entry for pairwise key as in IPW interface, adhoc will only get here, so we need index entry for its default key serching!
3502 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8 *)ieee->ap_mac_addr, 0, key);
3503 if (ieee->auth_mode != 2)
3504 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8 *)ieee->ap_mac_addr, 0, key);
3507 memcpy((u8 *)key, ipw->u.crypt.key, 16);
3508 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) {
3509 ieee->group_key_type = KEY_TYPE_CCMP;
3510 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) {
3511 ieee->group_key_type = KEY_TYPE_TKIP;
3512 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
3513 if (ipw->u.crypt.key_len == 13)
3514 ieee->group_key_type = KEY_TYPE_WEP104;
3515 else if (ipw->u.crypt.key_len == 5)
3516 ieee->group_key_type = KEY_TYPE_WEP40;
3518 ieee->group_key_type = KEY_TYPE_NA;
3521 if (ieee->group_key_type) {
3522 setKey(dev, ipw->u.crypt.idx,
3523 ipw->u.crypt.idx, //KeyIndex
3524 ieee->group_key_type, //KeyType
3525 broadcast_addr, //MacAddr
3531 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
3545 static u8 HwRateToMRate90(bool bIsHT, u8 rate)
3557 case DESC90_RATE5_5M:
3558 ret_rate = MGN_5_5M;
3560 case DESC90_RATE11M:
3569 case DESC90_RATE12M:
3572 case DESC90_RATE18M:
3575 case DESC90_RATE24M:
3578 case DESC90_RATE36M:
3581 case DESC90_RATE48M:
3584 case DESC90_RATE54M:
3590 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
3596 case DESC90_RATEMCS0:
3597 ret_rate = MGN_MCS0;
3599 case DESC90_RATEMCS1:
3600 ret_rate = MGN_MCS1;
3602 case DESC90_RATEMCS2:
3603 ret_rate = MGN_MCS2;
3605 case DESC90_RATEMCS3:
3606 ret_rate = MGN_MCS3;
3608 case DESC90_RATEMCS4:
3609 ret_rate = MGN_MCS4;
3611 case DESC90_RATEMCS5:
3612 ret_rate = MGN_MCS5;
3614 case DESC90_RATEMCS6:
3615 ret_rate = MGN_MCS6;
3617 case DESC90_RATEMCS7:
3618 ret_rate = MGN_MCS7;
3620 case DESC90_RATEMCS8:
3621 ret_rate = MGN_MCS8;
3623 case DESC90_RATEMCS9:
3624 ret_rate = MGN_MCS9;
3626 case DESC90_RATEMCS10:
3627 ret_rate = MGN_MCS10;
3629 case DESC90_RATEMCS11:
3630 ret_rate = MGN_MCS11;
3632 case DESC90_RATEMCS12:
3633 ret_rate = MGN_MCS12;
3635 case DESC90_RATEMCS13:
3636 ret_rate = MGN_MCS13;
3638 case DESC90_RATEMCS14:
3639 ret_rate = MGN_MCS14;
3641 case DESC90_RATEMCS15:
3642 ret_rate = MGN_MCS15;
3644 case DESC90_RATEMCS32:
3645 ret_rate = (0x80|0x20);
3650 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
3659 * Function: UpdateRxPktTimeStamp
3660 * Overview: Record the TSF time stamp when receiving a packet
3668 * (pRfd->Status.TimeStampHigh is updated)
3669 * (pRfd->Status.TimeStampLow is updated)
3673 static void UpdateRxPktTimeStamp8190(struct net_device *dev,
3674 struct ieee80211_rx_stats *stats)
3676 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3678 if (stats->bIsAMPDU && !stats->bFirstMPDU) {
3679 stats->mac_time[0] = priv->LastRxDescTSFLow;
3680 stats->mac_time[1] = priv->LastRxDescTSFHigh;
3682 priv->LastRxDescTSFLow = stats->mac_time[0];
3683 priv->LastRxDescTSFHigh = stats->mac_time[1];
3689 static long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
3691 long signal_power; // in dBm.
3693 // Translate to dBm (x=0.5y-95).
3694 signal_power = (long)((signal_strength_index + 1) >> 1);
3697 return signal_power;
3701 /* 2008/01/22 MH We can not declare RSSI/EVM total value of sliding window to
3702 be a local static. Otherwise, it may increase when we return from S3/S4. The
3703 value will be kept in memory or disk. Declare the value in the adaptor
3704 and it will be reinitialized when returned from S3/S4. */
3705 static void rtl8192_process_phyinfo(struct r8192_priv *priv, u8 *buffer,
3706 struct ieee80211_rx_stats *pprevious_stats,
3707 struct ieee80211_rx_stats *pcurrent_stats)
3709 bool bcheck = false;
3711 u32 nspatial_stream, tmp_val;
3712 static u32 slide_rssi_index, slide_rssi_statistics;
3713 static u32 slide_evm_index, slide_evm_statistics;
3714 static u32 last_rssi, last_evm;
3716 static u32 slide_beacon_adc_pwdb_index, slide_beacon_adc_pwdb_statistics;
3717 static u32 last_beacon_adc_pwdb;
3719 struct ieee80211_hdr_3addr *hdr;
3721 unsigned int frag, seq;
3722 hdr = (struct ieee80211_hdr_3addr *)buffer;
3723 sc = le16_to_cpu(hdr->seq_ctl);
3724 frag = WLAN_GET_SEQ_FRAG(sc);
3725 seq = WLAN_GET_SEQ_SEQ(sc);
3726 //cosa add 04292008 to record the sequence number
3727 pcurrent_stats->Seq_Num = seq;
3729 // Check whether we should take the previous packet into accounting
3731 if (!pprevious_stats->bIsAMPDU) {
3732 // if previous packet is not aggregated packet
3736 if (slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX) {
3737 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
3738 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
3739 priv->stats.slide_rssi_total -= last_rssi;
3741 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
3743 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
3744 if (slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
3745 slide_rssi_index = 0;
3747 // <1> Showed on UI for user, in dbm
3748 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
3749 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
3750 pcurrent_stats->rssi = priv->stats.signal_strength;
3752 // If the previous packet does not match the criteria, neglect it
3754 if (!pprevious_stats->bPacketMatchBSSID) {
3755 if (!pprevious_stats->bToSelfBA)
3763 //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
3768 priv->stats.num_process_phyinfo++;
3770 /* record the general signal strength to the sliding window. */
3773 // <2> Showed on UI for engineering
3774 // hardware does not provide rssi information for each rf path in CCK
3775 if (!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA)) {
3776 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++) {
3777 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
3780 //Fixed by Jacken 2008-03-20
3781 if (priv->stats.rx_rssi_percentage[rfpath] == 0)
3782 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
3783 if (pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath]) {
3784 priv->stats.rx_rssi_percentage[rfpath] =
3785 ((priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
3786 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
3787 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
3789 priv->stats.rx_rssi_percentage[rfpath] =
3790 ((priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
3791 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
3793 RT_TRACE(COMP_DBG, "priv->stats.rx_rssi_percentage[rfPath] = %d \n", priv->stats.rx_rssi_percentage[rfpath]);
3801 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
3802 pprevious_stats->bIsCCK ? "CCK" : "OFDM",
3803 pprevious_stats->RxPWDBAll);
3805 if (pprevious_stats->bPacketBeacon) {
3806 /* record the beacon pwdb to the sliding window. */
3807 if (slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX) {
3808 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
3809 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
3810 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
3812 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
3813 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
3814 slide_beacon_adc_pwdb_index++;
3815 if (slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
3816 slide_beacon_adc_pwdb_index = 0;
3817 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
3818 if (pprevious_stats->RxPWDBAll >= 3)
3819 pprevious_stats->RxPWDBAll -= 3;
3822 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
3823 pprevious_stats->bIsCCK ? "CCK" : "OFDM",
3824 pprevious_stats->RxPWDBAll);
3827 if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
3828 if (priv->undecorated_smoothed_pwdb < 0) /* initialize */
3829 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
3830 if (pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb) {
3831 priv->undecorated_smoothed_pwdb =
3832 (((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
3833 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
3834 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
3836 priv->undecorated_smoothed_pwdb =
3837 (((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
3838 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
3846 /* record the general EVM to the sliding window. */
3847 if (pprevious_stats->SignalQuality) {
3848 if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
3849 if (slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX) {
3850 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
3851 last_evm = priv->stats.slide_evm[slide_evm_index];
3852 priv->stats.slide_evm_total -= last_evm;
3855 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
3857 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
3858 if (slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
3859 slide_evm_index = 0;
3861 // <1> Showed on UI for user, in percentage.
3862 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
3863 priv->stats.signal_quality = tmp_val;
3864 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
3865 priv->stats.last_signal_strength_inpercent = tmp_val;
3868 // <2> Showed on UI for engineering
3869 if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
3870 for (nspatial_stream = 0; nspatial_stream < 2; nspatial_stream++) { /* 2 spatial stream */
3871 if (pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1) {
3872 if (priv->stats.rx_evm_percentage[nspatial_stream] == 0) /* initialize */
3873 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
3874 priv->stats.rx_evm_percentage[nspatial_stream] =
3875 ((priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
3876 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
3885 /*-----------------------------------------------------------------------------
3886 * Function: rtl819x_query_rxpwrpercentage()
3890 * Input: char antpower
3894 * Return: 0-100 percentage
3898 * 05/26/2008 amy Create Version 0 porting from windows code.
3900 *---------------------------------------------------------------------------*/
3901 static u8 rtl819x_query_rxpwrpercentage(char antpower)
3903 if ((antpower <= -100) || (antpower >= 20))
3905 else if (antpower >= 0)
3908 return 100 + antpower;
3910 } /* QueryRxPwrPercentage */
3912 static u8 rtl819x_evm_dbtopercentage(char value)
3922 ret_val = 0 - ret_val;
3930 // We want good-looking for signal strength/quality
3931 // 2007/7/19 01:09, by cosa.
3933 static long rtl819x_signal_scale_mapping(long currsig)
3937 // Step 1. Scale mapping.
3938 if (currsig >= 61 && currsig <= 100)
3939 retsig = 90 + ((currsig - 60) / 4);
3940 else if (currsig >= 41 && currsig <= 60)
3941 retsig = 78 + ((currsig - 40) / 2);
3942 else if (currsig >= 31 && currsig <= 40)
3943 retsig = 66 + (currsig - 30);
3944 else if (currsig >= 21 && currsig <= 30)
3945 retsig = 54 + (currsig - 20);
3946 else if (currsig >= 5 && currsig <= 20)
3947 retsig = 42 + (((currsig - 5) * 2) / 3);
3948 else if (currsig == 4)
3950 else if (currsig == 3)
3952 else if (currsig == 2)
3954 else if (currsig == 1)
3962 static inline bool rx_hal_is_cck_rate(struct rx_drvinfo_819x_usb *pdrvinfo)
3967 switch (pdrvinfo->RxRate) {
3970 case DESC90_RATE5_5M:
3971 case DESC90_RATE11M:
3978 static void rtl8192_query_rxphystatus(struct r8192_priv *priv,
3979 struct ieee80211_rx_stats *pstats,
3980 rx_drvinfo_819x_usb *pdrvinfo,
3981 struct ieee80211_rx_stats *precord_stats,
3982 bool bpacket_match_bssid,
3983 bool bpacket_toself,
3987 phy_sts_ofdm_819xusb_t *pofdm_buf;
3988 phy_sts_cck_819xusb_t *pcck_buf;
3989 phy_ofdm_rx_status_rxsc_sgien_exintfflag *prxsc;
3991 u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
3992 char rx_pwr[4], rx_pwr_all = 0;
3993 char rx_snrX, rx_evmX;
3995 u32 RSSI, total_rssi = 0;
4001 priv->stats.numqry_phystatus++;
4003 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
4005 // Record it for next packet processing
4006 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
4007 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
4008 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
4009 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;
4010 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
4011 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
4013 prxpkt = (u8 *)pdrvinfo;
4015 /* Move pointer to the 16th bytes. Phy status start address. */
4016 prxpkt += sizeof(rx_drvinfo_819x_usb);
4018 /* Initial the cck and ofdm buffer pointer */
4019 pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
4020 pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
4022 pstats->RxMIMOSignalQuality[0] = -1;
4023 pstats->RxMIMOSignalQuality[1] = -1;
4024 precord_stats->RxMIMOSignalQuality[0] = -1;
4025 precord_stats->RxMIMOSignalQuality[1] = -1;
4029 // (1)Hardware does not provide RSSI for CCK
4033 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4037 priv->stats.numqry_phystatusCCK++;
4039 if (!priv->bCckHighPower) {
4040 report = pcck_buf->cck_agc_rpt & 0xc0;
4043 //Fixed by Jacken from Bryant 2008-03-20
4044 //Original value is -38 , -26 , -14 , -2
4045 //Fixed value is -35 , -23 , -11 , 6
4047 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
4050 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
4053 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
4056 rx_pwr_all = 6 - (pcck_buf->cck_agc_rpt & 0x3e);
4060 report = pcck_buf->cck_agc_rpt & 0x60;
4064 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4067 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4070 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4073 rx_pwr_all = 6 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4078 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
4079 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
4080 pstats->RecvSignalPower = pwdb_all;
4083 // (3) Get Signal Quality (EVM)
4086 if (pstats->RxPWDBAll > 40) {
4089 sq = pcck_buf->sq_rpt;
4091 if (pcck_buf->sq_rpt > 64)
4093 else if (pcck_buf->sq_rpt < 20)
4096 sq = ((64-sq) * 100) / 44;
4098 pstats->SignalQuality = precord_stats->SignalQuality = sq;
4099 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
4100 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
4103 priv->stats.numqry_phystatusHT++;
4105 // (1)Get RSSI for HT rate
4107 for (i = RF90_PATH_A; i < priv->NumTotalRFPath; i++) {
4108 // 2008/01/30 MH we will judge RF RX path now.
4109 if (priv->brfpath_rxenable[i])
4114 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
4117 //Fixed by Jacken from Bryant 2008-03-20
4118 //Original value is 106
4119 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
4121 //Get Rx snr value in DB
4122 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
4123 rx_snrX = (char)(tmp_rxsnr);
4125 priv->stats.rxSNRdB[i] = (long)rx_snrX;
4127 /* Translate DBM to percentage. */
4128 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
4131 /* Record Signal Strength for next packet */
4132 pstats->RxMIMOSignalStrength[i] = (u8) RSSI;
4133 precord_stats->RxMIMOSignalStrength[i] = (u8) RSSI;
4138 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4140 //Fixed by Jacken from Bryant 2008-03-20
4141 //Original value is 106
4142 rx_pwr_all = (((pofdm_buf->pwdb_all) >> 1)& 0x7f) -106;
4143 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
4145 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
4146 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
4149 // (3)EVM of HT rate
4151 if (pdrvinfo->RxHT && pdrvinfo->RxRate >= DESC90_RATEMCS8 &&
4152 pdrvinfo->RxRate <= DESC90_RATEMCS15)
4153 max_spatial_stream = 2; //both spatial stream make sense
4155 max_spatial_stream = 1; //only spatial stream 1 makes sense
4157 for (i = 0; i < max_spatial_stream; i++) {
4158 tmp_rxevm = pofdm_buf->rxevm_X[i];
4159 rx_evmX = (char)(tmp_rxevm);
4161 // Do not use shift operation like "rx_evmX >>= 1" because the compiler of free build environment
4162 // will set the most significant bit to "zero" when doing shifting operation which may change a negative
4163 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
4166 evm = rtl819x_evm_dbtopercentage(rx_evmX);
4167 if (i == 0) /* Fill value in RFD, Get the first spatial stream only */
4168 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
4169 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
4173 /* record rx statistics for debug */
4174 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
4175 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
4176 if (pdrvinfo->BW) /* 40M channel */
4177 priv->stats.received_bwtype[1+prxsc->rxsc]++;
4179 priv->stats.received_bwtype[0]++;
4182 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
4183 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
4185 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));
4187 // We can judge RX path number now.
4189 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi /= rf_rx_num)));
4191 } /* QueryRxPhyStatus8190Pci */
4193 static void rtl8192_record_rxdesc_forlateruse(struct ieee80211_rx_stats *psrc_stats,
4194 struct ieee80211_rx_stats *ptarget_stats)
4196 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
4197 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
4198 ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
4202 static void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
4203 struct ieee80211_rx_stats *pstats,
4204 rx_drvinfo_819x_usb *pdrvinfo)
4206 // TODO: We must only check packet for current MAC address. Not finish
4207 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4208 struct net_device *dev = info->dev;
4209 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4210 bool bpacket_match_bssid, bpacket_toself;
4211 bool bPacketBeacon = FALSE, bToSelfBA = FALSE;
4212 static struct ieee80211_rx_stats previous_stats;
4213 struct ieee80211_hdr_3addr *hdr;//by amy
4216 // Get Signal Quality for only RX data queue (but not command queue)
4221 /* Get MAC frame start address. */
4222 tmp_buf = (u8 *)skb->data;
4224 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
4225 fc = le16_to_cpu(hdr->frame_ctl);
4226 type = WLAN_FC_GET_TYPE(fc);
4227 praddr = hdr->addr1;
4229 /* Check if the received packet is acceptable. */
4230 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
4231 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS) ? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS) ? hdr->addr2 : hdr->addr3))
4232 && (!pstats->bHwError) && (!pstats->bCRC) && (!pstats->bICV));
4233 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
4235 if (WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BEACON)
4236 bPacketBeacon = true;
4237 if (WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK) {
4238 if ((eqMacAddr(praddr, dev->dev_addr)))
4244 if (bpacket_match_bssid)
4245 priv->stats.numpacket_matchbssid++;
4247 priv->stats.numpacket_toself++;
4249 // Process PHY information for previous packet (RSSI/PWDB/EVM)
4251 // Because phy information is contained in the last packet of AMPDU only, so driver
4252 // should process phy information of previous packet
4253 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
4254 rtl8192_query_rxphystatus(priv, pstats, pdrvinfo, &previous_stats, bpacket_match_bssid, bpacket_toself, bPacketBeacon, bToSelfBA);
4255 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
4260 * Function: UpdateReceivedRateHistogramStatistics
4261 * Overview: Record the received data rate
4264 * struct net_device *dev
4265 * struct ieee80211_rx_stats *stats
4269 * (priv->stats.ReceivedRateHistogram[] is updated)
4274 UpdateReceivedRateHistogramStatistics8190(struct net_device *dev,
4275 struct ieee80211_rx_stats *stats)
4277 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4278 u32 rcvType = 1; //0: Total, 1:OK, 2:CRC, 3:ICV
4280 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
4285 else if (stats->bICV)
4288 if (stats->bShortPreamble)
4289 preamble_guardinterval = 1;// short
4291 preamble_guardinterval = 0;// long
4293 switch (stats->rate) {
4307 /* Legacy OFDM rate */
4332 /* 11n High throughput rate */
4385 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
4386 priv->stats.received_rate_histogram[0][rateIndex]++; //total
4387 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
4391 static void query_rxdesc_status(struct sk_buff *skb,
4392 struct ieee80211_rx_stats *stats,
4393 bool bIsRxAggrSubframe)
4395 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4396 struct net_device *dev = info->dev;
4397 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4398 rx_drvinfo_819x_usb *driver_info = NULL;
4401 //Get Rx Descriptor Information
4403 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
4405 stats->Length = desc->Length;
4406 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
4407 stats->RxBufShift = 0;
4408 stats->bICV = desc->ICV;
4409 stats->bCRC = desc->CRC32;
4410 stats->bHwError = stats->bCRC|stats->bICV;
4411 /* RTL8190 set this bit to indicate that Hw does not decrypt packet */
4412 stats->Decrypted = !desc->SWDec;
4414 if ((priv->ieee80211->pHTInfo->bCurrentHTSupport == true) && (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP))
4415 stats->bHwError = false;
4417 stats->bHwError = stats->bCRC|stats->bICV;
4419 if (stats->Length < 24 || stats->Length > MAX_8192U_RX_SIZE)
4420 stats->bHwError |= 1;
4424 // TODO: Need to verify it on FGPA platform
4425 //Driver info are written to the RxBuffer following rx desc
4426 if (stats->RxDrvInfoSize != 0) {
4427 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) +
4431 if (!stats->bHwError) {
4433 ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
4434 if (ret_rate == 0xff) {
4435 // Abnormal Case: Receive CRC OK packet with Rx descriptor indicating non supported rate.
4436 // Special Error Handling here, 2008.05.16, by Emily
4438 stats->bHwError = 1;
4439 stats->rate = MGN_1M; //Set 1M rate by default
4441 stats->rate = ret_rate;
4447 stats->bShortPreamble = driver_info->SPLCP;
4450 UpdateReceivedRateHistogramStatistics8190(dev, stats);
4452 stats->bIsAMPDU = (driver_info->PartAggr == 1);
4453 stats->bFirstMPDU = (driver_info->PartAggr == 1) && (driver_info->FirstAGGR == 1);
4454 stats->TimeStampLow = driver_info->TSFL;
4455 // xiong mask it, 070514
4457 UpdateRxPktTimeStamp8190(dev, stats);
4462 if (driver_info->FirstAGGR == 1 || driver_info->PartAggr == 1)
4463 RT_TRACE(COMP_RXDESC, "driver_info->FirstAGGR = %d, driver_info->PartAggr = %d\n",
4464 driver_info->FirstAGGR, driver_info->PartAggr);
4468 skb_pull(skb, sizeof(rx_desc_819x_usb));
4470 // Get Total offset of MPDU Frame Body
4472 if ((stats->RxBufShift + stats->RxDrvInfoSize) > 0) {
4474 skb_pull(skb, stats->RxBufShift + stats->RxDrvInfoSize);
4477 /* for debug 2008.5.29 */
4479 //added by vivi, for MP, 20080108
4480 stats->RxIs40MHzPacket = driver_info->BW;
4481 if (stats->RxDrvInfoSize != 0)
4482 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
4486 static void rtl8192_rx_nomal(struct sk_buff *skb)
4488 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4489 struct net_device *dev = info->dev;
4490 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4491 struct ieee80211_rx_stats stats = {
4495 .freq = IEEE80211_24GHZ_BAND,
4498 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
4499 bool unicast_packet = false;
4501 /* 20 is for ps-poll */
4502 if ((skb->len >= (20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
4503 /* first packet should not contain Rx aggregation header */
4504 query_rxdesc_status(skb, &stats, false);
4506 /* hardware related info */
4507 /* Process the MPDU received */
4508 skb_trim(skb, skb->len - 4/*sCrcLng*/);
4510 rx_pkt_len = skb->len;
4511 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
4512 unicast_packet = false;
4513 if (is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
4515 } else if (is_multicast_ether_addr(ieee80211_hdr->addr1)) {
4518 /* unicast packet */
4519 unicast_packet = true;
4522 if (!ieee80211_rx(priv->ieee80211, skb, &stats)) {
4523 dev_kfree_skb_any(skb);
4525 priv->stats.rxoktotal++;
4527 priv->stats.rxbytesunicast += rx_pkt_len;
4530 priv->stats.rxurberr++;
4531 netdev_dbg(dev, "actual_length: %d\n", skb->len);
4532 dev_kfree_skb_any(skb);
4537 static void rtl819xusb_process_received_packet(struct net_device *dev,
4538 struct ieee80211_rx_stats *pstats)
4542 struct r8192_priv *priv = ieee80211_priv(dev);
4544 // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
4545 //porting by amy 080508
4546 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
4547 frame = pstats->virtual_address;
4548 frame_len = pstats->packetlength;
4549 #ifdef TODO // by amy about HCT
4550 if (!Adapter->bInHctTest)
4551 CountRxErrStatistics(Adapter, pRfd);
4553 #ifdef ENABLE_PS //by amy for adding ps function in future
4554 RT_RF_POWER_STATE rtState;
4555 // When RF is off, we should not count the packet for hw/sw synchronize
4556 // reason, ie. there may be a duration while sw switch is changed and hw
4557 // switch is being changed. 2006.12.04, by shien chang.
4558 Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8 *)(&rtState));
4559 if (rtState == eRfOff)
4562 priv->stats.rxframgment++;
4565 RmMonitorSignalStrength(Adapter, pRfd);
4567 /* 2007/01/16 MH Add RX command packet handle here. */
4568 /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
4569 if (rtl819xusb_rx_command_packet(dev, pstats))
4579 static void query_rx_cmdpkt_desc_status(struct sk_buff *skb,
4580 struct ieee80211_rx_stats *stats)
4582 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
4585 //Get Rx Descriptor Information
4587 stats->virtual_address = (u8 *)skb->data;
4588 stats->Length = desc->Length;
4589 stats->RxDrvInfoSize = 0;
4590 stats->RxBufShift = 0;
4591 stats->packetlength = stats->Length-scrclng;
4592 stats->fraglength = stats->packetlength;
4593 stats->fragoffset = 0;
4594 stats->ntotalfrag = 1;
4598 static void rtl8192_rx_cmd(struct sk_buff *skb)
4600 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4601 struct net_device *dev = info->dev;
4603 struct ieee80211_rx_stats stats = {
4607 .freq = IEEE80211_24GHZ_BAND,
4610 if ((skb->len >= (20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
4612 query_rx_cmdpkt_desc_status(skb, &stats);
4613 // this is to be done by amy 080508 prfd->queue_id = 1;
4617 // Process the command packet received.
4620 rtl819xusb_process_received_packet(dev, &stats);
4622 dev_kfree_skb_any(skb);
4626 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
4628 struct sk_buff *skb;
4629 struct rtl8192_rx_info *info;
4631 while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
4632 info = (struct rtl8192_rx_info *)skb->cb;
4633 switch (info->out_pipe) {
4634 /* Nomal packet pipe */
4636 priv->IrpPendingCount--;
4637 rtl8192_rx_nomal(skb);
4640 /* Command packet pipe */
4642 RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",
4645 rtl8192_rx_cmd(skb);
4648 default: /* should never get here! */
4649 RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",
4658 static const struct net_device_ops rtl8192_netdev_ops = {
4659 .ndo_open = rtl8192_open,
4660 .ndo_stop = rtl8192_close,
4661 .ndo_get_stats = rtl8192_stats,
4662 .ndo_tx_timeout = tx_timeout,
4663 .ndo_do_ioctl = rtl8192_ioctl,
4664 .ndo_set_rx_mode = r8192_set_multicast,
4665 .ndo_set_mac_address = r8192_set_mac_adr,
4666 .ndo_validate_addr = eth_validate_addr,
4667 .ndo_change_mtu = eth_change_mtu,
4668 .ndo_start_xmit = ieee80211_xmit,
4672 /****************************************************************************
4673 ---------------------------- USB_STUFF---------------------------
4674 *****************************************************************************/
4676 static int rtl8192_usb_probe(struct usb_interface *intf,
4677 const struct usb_device_id *id)
4679 struct net_device *dev = NULL;
4680 struct r8192_priv *priv = NULL;
4681 struct usb_device *udev = interface_to_usbdev(intf);
4683 RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
4685 dev = alloc_ieee80211(sizeof(struct r8192_priv));
4689 usb_set_intfdata(intf, dev);
4690 SET_NETDEV_DEV(dev, &intf->dev);
4691 priv = ieee80211_priv(dev);
4692 priv->ieee80211 = netdev_priv(dev);
4695 dev->netdev_ops = &rtl8192_netdev_ops;
4697 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
4699 dev->type = ARPHRD_ETHER;
4701 dev->watchdog_timeo = HZ*3; //modified by john, 0805
4703 if (dev_alloc_name(dev, ifname) < 0) {
4704 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
4706 dev_alloc_name(dev, ifname);
4709 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
4710 if (rtl8192_init(dev) != 0) {
4711 RT_TRACE(COMP_ERR, "Initialization failed");
4715 netif_carrier_off(dev);
4716 netif_stop_queue(dev);
4718 ret = register_netdev(dev);
4722 RT_TRACE(COMP_INIT, "dev name=======> %s\n", dev->name);
4723 rtl8192_proc_init_one(dev);
4726 RT_TRACE(COMP_INIT, "Driver probe completed\n");
4731 kfree(priv->pFirmware);
4732 priv->pFirmware = NULL;
4733 rtl8192_usb_deleteendpoints(dev);
4734 destroy_workqueue(priv->priv_wq);
4737 free_ieee80211(dev);
4739 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
4743 //detach all the work and timer structure declared or inititialize in r8192U_init function.
4744 void rtl8192_cancel_deferred_work(struct r8192_priv *priv)
4747 cancel_work_sync(&priv->reset_wq);
4748 cancel_delayed_work(&priv->watch_dog_wq);
4749 cancel_delayed_work(&priv->update_beacon_wq);
4750 cancel_work_sync(&priv->qos_activate);
4754 static void rtl8192_usb_disconnect(struct usb_interface *intf)
4756 struct net_device *dev = usb_get_intfdata(intf);
4758 struct r8192_priv *priv = ieee80211_priv(dev);
4761 unregister_netdev(dev);
4763 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
4764 rtl8192_proc_remove_one(dev);
4767 kfree(priv->pFirmware);
4768 priv->pFirmware = NULL;
4769 rtl8192_usb_deleteendpoints(dev);
4770 destroy_workqueue(priv->priv_wq);
4774 free_ieee80211(dev);
4775 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
4778 static int __init rtl8192_usb_module_init(void)
4782 #ifdef CONFIG_IEEE80211_DEBUG
4783 ret = ieee80211_debug_init();
4785 pr_err("ieee80211_debug_init() failed %d\n", ret);
4789 ret = ieee80211_crypto_init();
4791 pr_err("ieee80211_crypto_init() failed %d\n", ret);
4795 ret = ieee80211_crypto_tkip_init();
4797 pr_err("ieee80211_crypto_tkip_init() failed %d\n", ret);
4801 ret = ieee80211_crypto_ccmp_init();
4803 pr_err("ieee80211_crypto_ccmp_init() failed %d\n", ret);
4807 ret = ieee80211_crypto_wep_init();
4809 pr_err("ieee80211_crypto_wep_init() failed %d\n", ret);
4813 pr_info("\nLinux kernel driver for RTL8192 based WLAN cards\n");
4814 pr_info("Copyright (c) 2007-2008, Realsil Wlan\n");
4815 RT_TRACE(COMP_INIT, "Initializing module");
4816 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
4817 rtl8192_proc_module_init();
4818 return usb_register(&rtl8192_usb_driver);
4822 static void __exit rtl8192_usb_module_exit(void)
4824 usb_deregister(&rtl8192_usb_driver);
4826 RT_TRACE(COMP_DOWN, "Exiting");
4830 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
4832 unsigned long flags;
4834 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4836 spin_lock_irqsave(&priv->tx_lock, flags);
4837 enough_desc = check_nic_enough_desc(dev, pri);
4838 spin_unlock_irqrestore(&priv->tx_lock, flags);
4841 ieee80211_wake_queue(priv->ieee80211);
4844 void EnableHWSecurityConfig8192(struct net_device *dev)
4846 u8 SECR_value = 0x0;
4847 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4848 struct ieee80211_device *ieee = priv->ieee80211;
4849 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
4850 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2)) {
4851 SECR_value |= SCR_RxUseDK;
4852 SECR_value |= SCR_TxUseDK;
4853 } else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP))) {
4854 SECR_value |= SCR_RxUseDK;
4855 SECR_value |= SCR_TxUseDK;
4857 //add HWSec active enable here.
4858 //default using hwsec. when peer AP is in N mode only and pairwise_key_type is none_aes(which HT_IOT_ACT_PURE_N_MODE indicates it), use software security. when peer AP is in b,g,n mode mixed and pairwise_key_type is none_aes, use g mode hw security. WB on 2008.7.4
4860 ieee->hwsec_active = 1;
4862 if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep) { /* add hwsec_support flag to totol control hw_sec on/off */
4863 ieee->hwsec_active = 0;
4864 SECR_value &= ~SCR_RxDecEnable;
4866 RT_TRACE(COMP_SEC, "%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __func__,
4867 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
4868 write_nic_byte(dev, SECR, SECR_value);
4872 void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType,
4873 u8 *MacAddr, u8 DefaultKey, u32 *KeyContent)
4875 u32 TargetCommand = 0;
4876 u32 TargetContent = 0;
4879 if (EntryNo >= TOTAL_CAM_ENTRY)
4880 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
4882 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev, EntryNo, KeyIndex, KeyType, MacAddr);
4885 usConfig |= BIT15 | (KeyType<<2);
4887 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
4890 for (i = 0; i < CAM_CONTENT_COUNT; i++) {
4891 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
4892 TargetCommand |= BIT31|BIT16;
4894 if (i == 0) { /* MAC|Config */
4895 TargetContent = (u32)(*(MacAddr+0)) << 16|
4896 (u32)(*(MacAddr+1)) << 24|
4899 write_nic_dword(dev, WCAMI, TargetContent);
4900 write_nic_dword(dev, RWCAM, TargetCommand);
4901 } else if (i == 1) { /* MAC */
4902 TargetContent = (u32)(*(MacAddr+2)) |
4903 (u32)(*(MacAddr+3)) << 8|
4904 (u32)(*(MacAddr+4)) << 16|
4905 (u32)(*(MacAddr+5)) << 24;
4906 write_nic_dword(dev, WCAMI, TargetContent);
4907 write_nic_dword(dev, RWCAM, TargetCommand);
4910 if (KeyContent != NULL) {
4911 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)));
4912 write_nic_dword(dev, RWCAM, TargetCommand);
4919 /***************************************************************************
4920 ------------------- module init / exit stubs ----------------
4921 ****************************************************************************/
4922 module_init(rtl8192_usb_module_init);
4923 module_exit(rtl8192_usb_module_exit);