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 {3, 3, 3, 3},/* cw_min */
1795 {7, 7, 7, 7},/* cw_max */
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;
1828 mutex_lock(&priv->mutex);
1829 if (priv->ieee80211->state != IEEE80211_LINKED)
1831 RT_TRACE(COMP_QOS, "qos active process with associate response received\n");
1832 /* It better set slot time at first */
1833 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
1834 /* update the ac parameter to related registers */
1835 for (i = 0; i < QOS_QUEUE_NUM; i++) {
1836 //Mode G/A: slotTimeTimer = 9; Mode B: 20
1837 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ? 9 : 20) + aSifsTime;
1838 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
1839 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
1840 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
1841 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
1843 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
1847 mutex_unlock(&priv->mutex);
1850 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
1852 struct ieee80211_network *network)
1855 u32 size = sizeof(struct ieee80211_qos_parameters);
1857 if (priv->ieee80211->state != IEEE80211_LINKED)
1860 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1863 if (network->flags & NETWORK_HAS_QOS_MASK) {
1864 if (active_network &&
1865 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
1866 network->qos_data.active = network->qos_data.supported;
1868 if ((network->qos_data.active == 1) && (active_network == 1) &&
1869 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
1870 (network->qos_data.old_param_count !=
1871 network->qos_data.param_count)) {
1872 network->qos_data.old_param_count =
1873 network->qos_data.param_count;
1874 queue_work(priv->priv_wq, &priv->qos_activate);
1875 RT_TRACE(COMP_QOS, "QoS parameters change call "
1879 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1880 &def_qos_parameters, size);
1882 if ((network->qos_data.active == 1) && (active_network == 1)) {
1883 queue_work(priv->priv_wq, &priv->qos_activate);
1884 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
1886 network->qos_data.active = 0;
1887 network->qos_data.supported = 0;
1893 /* handle and manage frame from beacon and probe response */
1894 static int rtl8192_handle_beacon(struct net_device *dev,
1895 struct ieee80211_beacon *beacon,
1896 struct ieee80211_network *network)
1898 struct r8192_priv *priv = ieee80211_priv(dev);
1900 rtl8192_qos_handle_probe_response(priv, 1, network);
1901 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
1907 * handling the beaconing responses. if we get different QoS setting
1908 * off the network from the associated setting, adjust the QoS
1911 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
1912 struct ieee80211_network *network)
1914 unsigned long flags;
1915 u32 size = sizeof(struct ieee80211_qos_parameters);
1916 int set_qos_param = 0;
1918 if ((priv == NULL) || (network == NULL))
1921 if (priv->ieee80211->state != IEEE80211_LINKED)
1924 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
1927 spin_lock_irqsave(&priv->ieee80211->lock, flags);
1928 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
1929 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1930 &network->qos_data.parameters,
1931 sizeof(struct ieee80211_qos_parameters));
1932 priv->ieee80211->current_network.qos_data.active = 1;
1934 /* update qos parameter for current network */
1935 priv->ieee80211->current_network.qos_data.old_param_count =
1936 priv->ieee80211->current_network.qos_data.param_count;
1937 priv->ieee80211->current_network.qos_data.param_count =
1938 network->qos_data.param_count;
1940 memcpy(&priv->ieee80211->current_network.qos_data.parameters,
1941 &def_qos_parameters, size);
1942 priv->ieee80211->current_network.qos_data.active = 0;
1943 priv->ieee80211->current_network.qos_data.supported = 0;
1947 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
1949 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n", __func__, network->flags, priv->ieee80211->current_network.qos_data.active);
1950 if (set_qos_param == 1)
1951 queue_work(priv->priv_wq, &priv->qos_activate);
1958 static int rtl8192_handle_assoc_response(struct net_device *dev,
1959 struct ieee80211_assoc_response_frame *resp,
1960 struct ieee80211_network *network)
1962 struct r8192_priv *priv = ieee80211_priv(dev);
1963 rtl8192_qos_association_resp(priv, network);
1968 void rtl8192_update_ratr_table(struct net_device *dev)
1970 struct r8192_priv *priv = ieee80211_priv(dev);
1971 struct ieee80211_device *ieee = priv->ieee80211;
1972 u8 *pMcsRate = ieee->dot11HTOperationalRateSet;
1975 rtl8192_config_rate(dev, (u16 *)(&ratr_value));
1976 ratr_value |= (*(u16 *)(pMcsRate)) << 12;
1977 switch (ieee->mode) {
1979 ratr_value &= 0x00000FF0;
1982 ratr_value &= 0x0000000F;
1985 ratr_value &= 0x00000FF7;
1989 if (ieee->pHTInfo->PeerMimoPs == 0) { /* MIMO_PS_STATIC */
1990 ratr_value &= 0x0007F007;
1992 if (priv->rf_type == RF_1T2R)
1993 ratr_value &= 0x000FF007;
1995 ratr_value &= 0x0F81F007;
2001 ratr_value &= 0x0FFFFFFF;
2002 if (ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz)
2003 ratr_value |= 0x80000000;
2004 else if (!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz)
2005 ratr_value |= 0x80000000;
2006 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2007 write_nic_byte(dev, UFWP, 1);
2010 static u8 ccmp_ie[4] = {0x00, 0x50, 0xf2, 0x04};
2011 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2012 static bool GetNmodeSupportBySecCfg8192(struct net_device *dev)
2014 struct r8192_priv *priv = ieee80211_priv(dev);
2015 struct ieee80211_device *ieee = priv->ieee80211;
2016 struct ieee80211_network *network = &ieee->current_network;
2017 int wpa_ie_len = ieee->wpa_ie_len;
2018 struct ieee80211_crypt_data *crypt;
2021 crypt = ieee->crypt[ieee->tx_keyidx];
2022 //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
2023 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name, "WEP")));
2026 if (encrypt && (wpa_ie_len == 0)) {
2027 /* wep encryption, no N mode setting */
2029 } else if ((wpa_ie_len != 0)) {
2030 /* parse pairwise key type */
2031 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))))
2042 static bool GetHalfNmodeSupportByAPs819xUsb(struct net_device *dev)
2045 struct r8192_priv *priv = ieee80211_priv(dev);
2046 struct ieee80211_device *ieee = priv->ieee80211;
2048 if (ieee->bHalfWirelessN24GMode == true)
2056 static void rtl8192_refresh_supportrate(struct r8192_priv *priv)
2058 struct ieee80211_device *ieee = priv->ieee80211;
2059 //we do not consider set support rate for ABG mode, only HT MCS rate is set here.
2060 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2061 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2063 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2067 static u8 rtl8192_getSupportedWireleeMode(struct net_device *dev)
2069 struct r8192_priv *priv = ieee80211_priv(dev);
2071 switch (priv->rf_chip) {
2075 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2078 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2081 ret = WIRELESS_MODE_B;
2086 static void rtl8192_SetWirelessMode(struct net_device *dev, u8 wireless_mode)
2088 struct r8192_priv *priv = ieee80211_priv(dev);
2089 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2091 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode) == 0)) {
2092 if (bSupportMode & WIRELESS_MODE_N_24G) {
2093 wireless_mode = WIRELESS_MODE_N_24G;
2094 } else if (bSupportMode & WIRELESS_MODE_N_5G) {
2095 wireless_mode = WIRELESS_MODE_N_5G;
2096 } else if ((bSupportMode & WIRELESS_MODE_A)) {
2097 wireless_mode = WIRELESS_MODE_A;
2098 } else if ((bSupportMode & WIRELESS_MODE_G)) {
2099 wireless_mode = WIRELESS_MODE_G;
2100 } else if ((bSupportMode & WIRELESS_MODE_B)) {
2101 wireless_mode = WIRELESS_MODE_B;
2103 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __func__, bSupportMode);
2104 wireless_mode = WIRELESS_MODE_B;
2107 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2108 ActUpdateChannelAccessSetting(pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting);
2110 priv->ieee80211->mode = wireless_mode;
2112 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2113 priv->ieee80211->pHTInfo->bEnableHT = 1;
2115 priv->ieee80211->pHTInfo->bEnableHT = 0;
2116 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2117 rtl8192_refresh_supportrate(priv);
2120 //init priv variables here. only non_zero value should be initialized here.
2121 static void rtl8192_init_priv_variable(struct net_device *dev)
2123 struct r8192_priv *priv = ieee80211_priv(dev);
2125 priv->card_8192 = NIC_8192U;
2126 priv->chan = 1; //set to channel 1
2127 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2128 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2129 priv->ieee80211->ieee_up = 0;
2130 priv->retry_rts = DEFAULT_RETRY_RTS;
2131 priv->retry_data = DEFAULT_RETRY_DATA;
2132 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2133 priv->ieee80211->rate = 110; //11 mbps
2134 priv->ieee80211->short_slot = 1;
2135 priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
2138 priv->IrpPendingCount = 1;
2139 priv->ResetProgress = RESET_TYPE_NORESET;
2140 priv->bForcedSilentReset = 0;
2141 priv->bDisableNormalResetCheck = false;
2142 priv->force_reset = false;
2144 priv->ieee80211->FwRWRF = 0; //we don't use FW read/write RF until stable firmware is available.
2145 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2146 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2147 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2148 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
2149 IEEE_SOFTMAC_BEACONS;//added by amy 080604
2151 priv->ieee80211->active_scan = 1;
2152 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2153 priv->ieee80211->host_encrypt = 1;
2154 priv->ieee80211->host_decrypt = 1;
2155 priv->ieee80211->start_send_beacons = NULL; //-by amy 080604
2156 priv->ieee80211->stop_send_beacons = NULL; //-by amy 080604
2157 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2158 priv->ieee80211->set_chan = rtl8192_set_chan;
2159 priv->ieee80211->link_change = rtl8192_link_change;
2160 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2161 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2162 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2163 priv->ieee80211->init_wmmparam_flag = 0;
2164 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2165 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2166 priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
2167 priv->ieee80211->qos_support = 1;
2170 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2171 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2172 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2174 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
2175 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
2176 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2178 priv->ieee80211->InitialGainHandler = InitialGain819xUsb;
2179 priv->card_type = USB;
2181 if (Adapter->bInHctTest) {
2182 pHalData->ShortRetryLimit = 7;
2183 pHalData->LongRetryLimit = 7;
2186 priv->ShortRetryLimit = 0x30;
2187 priv->LongRetryLimit = 0x30;
2188 priv->EarlyRxThreshold = 7;
2189 priv->enable_gpio0 = 0;
2190 priv->TransmitConfig =
2191 (TCR_MXDMA_2048<<TCR_MXDMA_OFFSET)| // Max DMA Burst Size per Tx DMA Burst, 7: reserved.
2192 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)| // Short retry limit
2193 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
2194 (false ? TCR_SAT : 0); // FALSE: HW provides PLCP length and LENGEXT, TRUE: SW provides them
2196 if (Adapter->bInHctTest)
2197 pHalData->ReceiveConfig = pHalData->CSMethod |
2198 RCR_AMF | RCR_ADF | //accept management/data
2200 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2201 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2202 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2203 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2204 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
2205 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt : 0);
2209 priv->ReceiveConfig =
2210 RCR_AMF | RCR_ADF | //accept management/data
2211 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2212 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2213 ((u32)7<<RCR_MXDMA_OFFSET)| // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2214 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) | // Rx FIFO Threshold, 7: No Rx threshold.
2215 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT : 0);
2217 priv->AcmControl = 0;
2218 priv->pFirmware = kzalloc(sizeof(rt_firmware), GFP_KERNEL);
2220 /* rx related queue */
2221 skb_queue_head_init(&priv->rx_queue);
2222 skb_queue_head_init(&priv->skb_queue);
2224 /* Tx related queue */
2225 for (i = 0; i < MAX_QUEUE_SIZE; i++)
2226 skb_queue_head_init(&priv->ieee80211->skb_waitQ[i]);
2227 for (i = 0; i < MAX_QUEUE_SIZE; i++)
2228 skb_queue_head_init(&priv->ieee80211->skb_aggQ[i]);
2229 for (i = 0; i < MAX_QUEUE_SIZE; i++)
2230 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ[i]);
2231 priv->rf_set_chan = rtl8192_phy_SwChnl;
2235 static void rtl8192_init_priv_lock(struct r8192_priv *priv)
2237 spin_lock_init(&priv->tx_lock);
2238 spin_lock_init(&priv->irq_lock);//added by thomas
2239 sema_init(&priv->wx_sem, 1);
2240 sema_init(&priv->rf_sem, 1);
2241 mutex_init(&priv->mutex);
2244 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
2246 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2247 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2248 #define DRV_NAME "wlan0"
2249 static void rtl8192_init_priv_task(struct net_device *dev)
2251 struct r8192_priv *priv = ieee80211_priv(dev);
2253 priv->priv_wq = create_workqueue(DRV_NAME);
2255 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2257 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2258 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2259 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2260 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2261 INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
2262 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2264 tasklet_init(&priv->irq_rx_tasklet,
2265 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2266 (unsigned long)priv);
2269 static void rtl8192_get_eeprom_size(struct net_device *dev)
2272 struct r8192_priv *priv = ieee80211_priv(dev);
2273 RT_TRACE(COMP_EPROM, "===========>%s()\n", __func__);
2274 read_nic_word_E(dev, EPROM_CMD, &curCR);
2275 RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
2276 //whether need I consider BIT5?
2277 priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2278 RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __func__, priv->epromtype);
2281 //used to swap endian. as ntohl & htonl are not necessary to swap endian, so use this instead.
2282 static inline u16 endian_swap(u16 *data)
2285 *data = (tmp >> 8) | (tmp << 8);
2288 static void rtl8192_read_eeprom_info(struct net_device *dev)
2291 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
2292 u8 bLoad_From_EEPOM = false;
2293 struct r8192_priv *priv = ieee80211_priv(dev);
2296 RT_TRACE(COMP_EPROM, "===========>%s()\n", __func__);
2297 wEPROM_ID = eprom_read(dev, 0); //first read EEPROM ID out;
2298 RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
2300 if (wEPROM_ID != RTL8190_EEPROM_ID) {
2301 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", wEPROM_ID, RTL8190_EEPROM_ID);
2303 bLoad_From_EEPOM = true;
2306 if (bLoad_From_EEPOM) {
2307 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
2308 priv->eeprom_vid = endian_swap(&tmpValue);
2309 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
2310 tmpValue = eprom_read(dev, (EEPROM_ChannelPlan>>1));
2311 priv->eeprom_ChannelPlan = ((tmpValue&0xff00)>>8);
2312 priv->btxpowerdata_readfromEEPORM = true;
2313 priv->eeprom_CustomerID = eprom_read(dev, (EEPROM_Customer_ID>>1)) >>8;
2315 priv->eeprom_vid = 0;
2316 priv->eeprom_pid = 0;
2317 priv->card_8192_version = VERSION_819xU_B;
2318 priv->eeprom_ChannelPlan = 0;
2319 priv->eeprom_CustomerID = 0;
2321 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);
2322 //set channelplan from eeprom
2323 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2324 if (bLoad_From_EEPOM) {
2326 for (i = 0; i < 6; i += 2) {
2328 tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
2329 *(u16 *)(&dev->dev_addr[i]) = tmp;
2332 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2333 //should I set IDR0 here?
2335 RT_TRACE(COMP_EPROM, "MAC addr:%pM\n", dev->dev_addr);
2336 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
2337 priv->rf_chip = RF_8256;
2339 if (priv->card_8192_version == (u8)VERSION_819xU_A) {
2340 //read Tx power gain offset of legacy OFDM to HT rate
2341 if (bLoad_From_EEPOM)
2342 priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff>>1))&0xff00) >> 8;
2344 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
2345 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
2346 //read ThermalMeter from EEPROM
2347 if (bLoad_From_EEPOM)
2348 priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter>>1))&0x00ff);
2350 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2351 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
2352 //vivi, for tx power track
2353 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2354 //read antenna tx power offset of B/C/D to A from EEPROM
2355 if (bLoad_From_EEPOM)
2356 priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff>>1))&0x0f00)>>8;
2358 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
2359 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
2360 // Read CrystalCap from EEPROM
2361 if (bLoad_From_EEPOM)
2362 priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap>>1))&0x0f);
2364 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
2365 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
2366 //get per-channel Tx power level
2367 if (bLoad_From_EEPOM)
2368 priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver>>1))&0xff00)>>8;
2370 priv->EEPROM_Def_Ver = 1;
2371 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
2372 if (priv->EEPROM_Def_Ver == 0) { /* old eeprom definition */
2374 if (bLoad_From_EEPOM)
2375 priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK>>1))&0xff) >> 8;
2377 priv->EEPROMTxPowerLevelCCK = 0x10;
2378 RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
2379 for (i = 0; i < 3; i++) {
2380 if (bLoad_From_EEPOM) {
2381 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G+i)>>1);
2382 if (((EEPROM_TxPwIndex_OFDM_24G+i) % 2) == 0)
2383 tmpValue = tmpValue & 0x00ff;
2385 tmpValue = (tmpValue & 0xff00) >> 8;
2389 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8) tmpValue;
2390 RT_TRACE(COMP_EPROM, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK);
2392 } else if (priv->EEPROM_Def_Ver == 1) {
2393 if (bLoad_From_EEPOM) {
2394 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1>>1));
2395 tmpValue = (tmpValue & 0xff00) >> 8;
2399 priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
2401 if (bLoad_From_EEPOM)
2402 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2)>>1);
2405 *((u16 *)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
2406 if (bLoad_From_EEPOM)
2407 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1>>1));
2410 *((u16 *)(&priv->EEPROMTxPowerLevelOFDM24G[0])) = tmpValue;
2411 if (bLoad_From_EEPOM)
2412 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1+2)>>1);
2415 priv->EEPROMTxPowerLevelOFDM24G[2] = (u8)tmpValue;
2416 }//endif EEPROM_Def_Ver == 1
2418 //update HAL variables
2420 for (i = 0; i < 14; i++) {
2422 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[0];
2423 else if (i >= 4 && i <= 9)
2424 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[1];
2426 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[2];
2429 for (i = 0; i < 14; i++) {
2430 if (priv->EEPROM_Def_Ver == 0) {
2432 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[0] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
2433 else if (i >= 4 && i <= 9)
2434 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK;
2436 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[2] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
2437 } else if (priv->EEPROM_Def_Ver == 1) {
2439 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[0];
2440 else if (i >= 4 && i <= 9)
2441 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[1];
2443 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[2];
2446 priv->TxPowerDiff = priv->EEPROMPwDiff;
2447 // Antenna B gain offset to antenna A, bit0~3
2448 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
2449 // Antenna C gain offset to antenna A, bit4~7
2450 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
2451 // CrystalCap, bit12~15
2452 priv->CrystalCap = priv->EEPROMCrystalCap;
2453 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
2454 // 92U does not enable TX power tracking.
2455 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
2456 }//end if VersionID == VERSION_819xU_A
2458 //added by vivi, for dlink led, 20080416
2459 switch (priv->eeprom_CustomerID) {
2460 case EEPROM_CID_RUNTOP:
2461 priv->CustomerID = RT_CID_819x_RUNTOP;
2464 case EEPROM_CID_DLINK:
2465 priv->CustomerID = RT_CID_DLINK;
2469 priv->CustomerID = RT_CID_DEFAULT;
2474 switch (priv->CustomerID) {
2475 case RT_CID_819x_RUNTOP:
2476 priv->LedStrategy = SW_LED_MODE2;
2480 priv->LedStrategy = SW_LED_MODE4;
2484 priv->LedStrategy = SW_LED_MODE0;
2490 if (priv->rf_type == RF_1T2R) {
2491 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
2493 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
2496 // 2008/01/16 MH We can only know RF type in the function. So we have to init
2497 // DIG RATR table again.
2498 init_rate_adaptive(dev);
2499 //we need init DIG RATR table here again.
2501 RT_TRACE(COMP_EPROM, "<===========%s()\n", __func__);
2505 static short rtl8192_get_channel_map(struct net_device *dev)
2507 struct r8192_priv *priv = ieee80211_priv(dev);
2508 if (priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN) {
2509 netdev_err(dev, "rtl8180_init: Error channel plan! Set to default.\n");
2510 priv->ChannelPlan = 0;
2512 RT_TRACE(COMP_INIT, "Channel plan is %d\n", priv->ChannelPlan);
2514 rtl819x_set_channel_map(priv->ChannelPlan, priv);
2518 static short rtl8192_init(struct net_device *dev)
2521 struct r8192_priv *priv = ieee80211_priv(dev);
2523 memset(&(priv->stats), 0, sizeof(struct Stats));
2524 memset(priv->txqueue_to_outpipemap, 0, 9);
2528 u8 queuetopipe[] = {3, 2, 1, 0, 4, 8, 7, 6, 5};
2529 memcpy(priv->txqueue_to_outpipemap, queuetopipe, 9);
2533 u8 queuetopipe[] = {3, 2, 1, 0, 4, 4, 0, 4, 4};
2534 memcpy(priv->txqueue_to_outpipemap, queuetopipe, 9);
2537 rtl8192_init_priv_variable(dev);
2538 rtl8192_init_priv_lock(priv);
2539 rtl8192_init_priv_task(dev);
2540 rtl8192_get_eeprom_size(dev);
2541 rtl8192_read_eeprom_info(dev);
2542 rtl8192_get_channel_map(dev);
2544 init_timer(&priv->watch_dog_timer);
2545 priv->watch_dog_timer.data = (unsigned long)dev;
2546 priv->watch_dog_timer.function = watch_dog_timer_callback;
2547 if (rtl8192_usb_initendpoints(dev) != 0) {
2548 DMESG("Endopoints initialization failed");
2555 /******************************************************************************
2556 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
2557 * not to do all the hw config as its name says
2558 * input: net_device dev
2561 * notice: This part need to modified according to the rate set we filtered
2562 * ****************************************************************************/
2563 static void rtl8192_hwconfig(struct net_device *dev)
2565 u32 regRATR = 0, regRRSR = 0;
2566 u8 regBwOpMode = 0, regTmp = 0;
2567 struct r8192_priv *priv = ieee80211_priv(dev);
2570 // Set RRSR, RATR, and BW_OPMODE registers
2572 switch (priv->ieee80211->mode) {
2573 case WIRELESS_MODE_B:
2574 regBwOpMode = BW_OPMODE_20MHZ;
2575 regRATR = RATE_ALL_CCK;
2576 regRRSR = RATE_ALL_CCK;
2578 case WIRELESS_MODE_A:
2579 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
2580 regRATR = RATE_ALL_OFDM_AG;
2581 regRRSR = RATE_ALL_OFDM_AG;
2583 case WIRELESS_MODE_G:
2584 regBwOpMode = BW_OPMODE_20MHZ;
2585 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2586 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2588 case WIRELESS_MODE_AUTO:
2590 if (Adapter->bInHctTest) {
2591 regBwOpMode = BW_OPMODE_20MHZ;
2592 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2593 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2598 regBwOpMode = BW_OPMODE_20MHZ;
2599 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2600 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2603 case WIRELESS_MODE_N_24G:
2604 // It support CCK rate by default.
2605 // CCK rate will be filtered out only when associated AP does not support it.
2606 regBwOpMode = BW_OPMODE_20MHZ;
2607 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2608 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
2610 case WIRELESS_MODE_N_5G:
2611 regBwOpMode = BW_OPMODE_5G;
2612 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
2613 regRRSR = RATE_ALL_OFDM_AG;
2617 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
2618 ratr_value = regRATR;
2619 if (priv->rf_type == RF_1T2R)
2620 ratr_value &= ~(RATE_ALL_OFDM_2SS);
2621 write_nic_dword(dev, RATR0, ratr_value);
2622 write_nic_byte(dev, UFWP, 1);
2623 read_nic_byte(dev, 0x313, ®Tmp);
2624 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
2625 write_nic_dword(dev, RRSR, regRRSR);
2628 // Set Retry Limit here
2630 write_nic_word(dev, RETRY_LIMIT,
2631 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT |
2632 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
2633 // Set Contention Window here
2637 // Set Tx Antenna including Feedback control
2639 // Set Auto Rate fallback control
2645 //InitializeAdapter and PhyCfg
2646 static bool rtl8192_adapter_start(struct net_device *dev)
2648 struct r8192_priv *priv = ieee80211_priv(dev);
2650 bool init_status = true;
2651 u8 SECR_value = 0x0;
2653 RT_TRACE(COMP_INIT, "====>%s()\n", __func__);
2654 priv->Rf_Mode = RF_OP_By_SW_3wire;
2655 //for ASIC power on sequence
2656 write_nic_byte_E(dev, 0x5f, 0x80);
2658 write_nic_byte_E(dev, 0x5f, 0xf0);
2659 write_nic_byte_E(dev, 0x5d, 0x00);
2660 write_nic_byte_E(dev, 0x5e, 0x80);
2661 write_nic_byte(dev, 0x17, 0x37);
2663 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
2664 //config CPUReset Register
2665 //Firmware Reset or not?
2666 read_nic_dword(dev, CPU_GEN, &dwRegRead);
2667 if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
2668 dwRegRead |= CPU_GEN_SYSTEM_RESET; //do nothing here?
2669 else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY)
2670 dwRegRead |= CPU_GEN_FIRMWARE_RESET;
2672 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __func__, priv->pFirmware->firmware_status);
2674 write_nic_dword(dev, CPU_GEN, dwRegRead);
2676 rtl8192_BBConfig(dev);
2678 //Loopback mode or not
2679 priv->LoopbackMode = RTL819xU_NO_LOOPBACK;
2681 read_nic_dword(dev, CPU_GEN, &dwRegRead);
2682 if (priv->LoopbackMode == RTL819xU_NO_LOOPBACK)
2683 dwRegRead = ((dwRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
2684 else if (priv->LoopbackMode == RTL819xU_MAC_LOOPBACK)
2685 dwRegRead |= CPU_CCK_LOOPBACK;
2687 RT_TRACE(COMP_ERR, "Serious error in %s(): wrong loopback mode setting(%d)\n", __func__, priv->LoopbackMode);
2689 write_nic_dword(dev, CPU_GEN, dwRegRead);
2691 //after reset cpu, we need wait for a seconds to write in register.
2694 //xiong add for new bitfile:usb suspend reset pin set to 1. //do we need?
2695 read_nic_byte_E(dev, 0x5f, &tmp);
2696 write_nic_byte_E(dev, 0x5f, tmp|0x20);
2699 rtl8192_hwconfig(dev);
2702 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
2705 write_nic_dword(dev, MAC0, ((u32 *)dev->dev_addr)[0]);
2706 write_nic_word(dev, MAC4, ((u16 *)(dev->dev_addr + 4))[0]);
2709 write_nic_dword(dev, RCR, priv->ReceiveConfig);
2711 //Initialize Number of Reserved Pages in Firmware Queue
2712 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |
2713 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT |
2714 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT |
2715 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
2716 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT |
2717 NUM_OF_PAGE_IN_FW_QUEUE_CMD << RSVD_FW_QUEUE_PAGE_CMD_SHIFT);
2718 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW|
2719 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT);
2720 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
2723 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
2724 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
2726 if (priv->ResetProgress == RESET_TYPE_NORESET)
2727 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
2728 if (priv->ResetProgress == RESET_TYPE_NORESET) {
2729 CamResetAllEntry(dev);
2730 SECR_value |= SCR_TxEncEnable;
2731 SECR_value |= SCR_RxDecEnable;
2732 SECR_value |= SCR_NoSKMC;
2733 write_nic_byte(dev, SECR, SECR_value);
2737 write_nic_word(dev, ATIMWND, 2);
2738 write_nic_word(dev, BCN_INTERVAL, 100);
2740 #define DEFAULT_EDCA 0x005e4332
2743 for (i = 0; i < QOS_QUEUE_NUM; i++)
2744 write_nic_dword(dev, WDCAPARA_ADD[i], DEFAULT_EDCA);
2747 rtl8192_phy_configmac(dev);
2749 if (priv->card_8192_version == (u8) VERSION_819xU_A) {
2750 rtl8192_phy_getTxPower(dev);
2751 rtl8192_phy_setTxPower(dev, priv->chan);
2755 init_status = init_firmware(dev);
2757 RT_TRACE(COMP_ERR, "ERR!!! %s(): Firmware download is failed\n", __func__);
2760 RT_TRACE(COMP_INIT, "%s():after firmware download\n", __func__);
2763 if (Adapter->ResetProgress == RESET_TYPE_NORESET) {
2764 if (pMgntInfo->RegRfOff == TRUE) { /* User disable RF via registry. */
2765 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
2766 MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
2767 // Those actions will be discard in MgntActSet_RF_State because of the same state
2768 for (eRFPath = 0; eRFPath < pHalData->NumTotalRFPath; eRFPath++)
2769 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
2770 } else if (pMgntInfo->RfOffReason > RF_CHANGE_BY_PS) { /* H/W or S/W RF OFF before sleep. */
2771 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RfOffReason(%d) ----------\n", pMgntInfo->RfOffReason));
2772 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
2774 pHalData->eRFPowerState = eRfOn;
2775 pMgntInfo->RfOffReason = 0;
2776 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): RF is on ----------\n"));
2779 if (pHalData->eRFPowerState == eRfOff) {
2780 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
2781 // Those actions will be discard in MgntActSet_RF_State because of the same state
2782 for (eRFPath = 0; eRFPath < pHalData->NumTotalRFPath; eRFPath++)
2783 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
2788 if (priv->ResetProgress == RESET_TYPE_NORESET) {
2789 rtl8192_phy_RFConfig(dev);
2790 RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __func__);
2794 if (priv->ieee80211->FwRWRF)
2795 // We can force firmware to do RF-R/W
2796 priv->Rf_Mode = RF_OP_By_FW;
2798 priv->Rf_Mode = RF_OP_By_SW_3wire;
2801 rtl8192_phy_updateInitGain(dev);
2802 /*--set CCK and OFDM Block "ON"--*/
2803 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
2804 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
2806 if (priv->ResetProgress == RESET_TYPE_NORESET) {
2809 read_nic_byte(dev, 0x301, &tmpvalue);
2810 if (tmpvalue == 0x03) {
2812 RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
2814 priv->bDcut = FALSE;
2815 RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
2817 dm_initialize_txpower_tracking(dev);
2819 if (priv->bDcut == TRUE) {
2821 u32 tmpRegA = rtl8192_QueryBBReg(dev, rOFDM0_XATxIQImbalance, bMaskDWord);
2822 for (i = 0; i < TxBBGainTableLength; i++) {
2823 if (tmpRegA == priv->txbbgain_table[i].txbbgain_value) {
2824 priv->rfa_txpowertrackingindex = (u8)i;
2825 priv->rfa_txpowertrackingindex_real = (u8)i;
2826 priv->rfa_txpowertracking_default = priv->rfa_txpowertrackingindex;
2831 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
2833 for (i = 0; i < CCKTxBBGainTableLength; i++) {
2835 if (TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0]) {
2836 priv->cck_present_attentuation_20Mdefault = (u8) i;
2840 priv->cck_present_attentuation_40Mdefault = 0;
2841 priv->cck_present_attentuation_difference = 0;
2842 priv->cck_present_attentuation = priv->cck_present_attentuation_20Mdefault;
2846 write_nic_byte(dev, 0x87, 0x0);
2852 /* this configures registers for beacon tx and enables it via
2853 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
2854 * be used to stop beacon transmission
2856 /***************************************************************************
2857 -------------------------------NET STUFF---------------------------
2858 ***************************************************************************/
2860 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
2862 struct r8192_priv *priv = ieee80211_priv(dev);
2864 return &priv->ieee80211->stats;
2867 static bool HalTxCheckStuck819xUsb(struct net_device *dev)
2869 struct r8192_priv *priv = ieee80211_priv(dev);
2871 bool bStuck = FALSE;
2872 read_nic_word(dev, 0x128, &RegTxCounter);
2873 RT_TRACE(COMP_RESET, "%s():RegTxCounter is %d,TxCounter is %d\n", __func__, RegTxCounter, priv->TxCounter);
2874 if (priv->TxCounter == RegTxCounter)
2877 priv->TxCounter = RegTxCounter;
2883 * <Assumption: RT_TX_SPINLOCK is acquired.>
2884 * First added: 2006.11.19 by emily
2886 static RESET_TYPE TxCheckStuck(struct net_device *dev)
2888 struct r8192_priv *priv = ieee80211_priv(dev);
2890 bool bCheckFwTxCnt = false;
2893 // Decide such threshold according to current power save mode
2896 for (QueueID = 0; QueueID <= BEACON_QUEUE; QueueID++) {
2897 if (QueueID == TXCMD_QUEUE)
2899 if ((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
2902 bCheckFwTxCnt = true;
2904 if (bCheckFwTxCnt) {
2905 if (HalTxCheckStuck819xUsb(dev)) {
2906 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
2907 return RESET_TYPE_SILENT;
2910 return RESET_TYPE_NORESET;
2913 static bool HalRxCheckStuck819xUsb(struct net_device *dev)
2916 struct r8192_priv *priv = ieee80211_priv(dev);
2917 bool bStuck = FALSE;
2918 static u8 rx_chk_cnt;
2919 read_nic_word(dev, 0x130, &RegRxCounter);
2920 RT_TRACE(COMP_RESET, "%s(): RegRxCounter is %d,RxCounter is %d\n", __func__, RegRxCounter, priv->RxCounter);
2921 // If rssi is small, we should check rx for long time because of bad rx.
2922 // or maybe it will continuous silent reset every 2 seconds.
2924 if (priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5)) {
2925 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
2926 } else if (priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
2927 ((priv->CurrentChannelBW != HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_40M) ||
2928 (priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20 && priv->undecorated_smoothed_pwdb >= RateAdaptiveTH_Low_20M))) {
2933 } else if (((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)) &&
2935 priv->undecorated_smoothed_pwdb >= VeryLowRSSI) {
2947 if (priv->RxCounter == RegRxCounter)
2950 priv->RxCounter = RegRxCounter;
2955 static RESET_TYPE RxCheckStuck(struct net_device *dev)
2957 struct r8192_priv *priv = ieee80211_priv(dev);
2958 bool bRxCheck = FALSE;
2960 if (priv->IrpPendingCount > 1)
2964 if (HalRxCheckStuck819xUsb(dev)) {
2965 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
2966 return RESET_TYPE_SILENT;
2969 return RESET_TYPE_NORESET;
2974 * This function is called by Checkforhang to check whether we should ask OS to reset driver
2976 * \param pAdapter The adapter context for this miniport
2978 * Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
2979 * to judge whether there is tx stuck.
2980 * Note: This function may be required to be rewrite for Vista OS.
2981 * <<<Assumption: Tx spinlock has been acquired >>>
2983 * 8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
2985 static RESET_TYPE rtl819x_ifcheck_resetornot(struct net_device *dev)
2987 struct r8192_priv *priv = ieee80211_priv(dev);
2988 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
2989 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
2990 RT_RF_POWER_STATE rfState;
2992 rfState = priv->ieee80211->eRFPowerState;
2994 TxResetType = TxCheckStuck(dev);
2995 if (rfState != eRfOff ||
2996 (priv->ieee80211->iw_mode != IW_MODE_ADHOC)) {
2997 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
2998 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
2999 // if driver is in firmware download failure status, driver should initialize RF in the following
3000 // silent reset procedure Emily, 2008.01.21
3002 // Driver should not check RX stuck in IBSS mode because it is required to
3003 // set Check BSSID in order to send beacon, however, if check BSSID is
3004 // set, STA cannot hear any packet at all. Emily, 2008.04.12
3005 RxResetType = RxCheckStuck(dev);
3007 if (TxResetType == RESET_TYPE_NORMAL || RxResetType == RESET_TYPE_NORMAL) {
3008 return RESET_TYPE_NORMAL;
3009 } else if (TxResetType == RESET_TYPE_SILENT || RxResetType == RESET_TYPE_SILENT) {
3010 RT_TRACE(COMP_RESET, "%s():silent reset\n", __func__);
3011 return RESET_TYPE_SILENT;
3013 return RESET_TYPE_NORESET;
3018 void rtl8192_cancel_deferred_work(struct r8192_priv *priv);
3019 int _rtl8192_up(struct net_device *dev);
3020 int rtl8192_close(struct net_device *dev);
3024 static void CamRestoreAllEntry(struct net_device *dev)
3027 struct r8192_priv *priv = ieee80211_priv(dev);
3028 u8 *MacAddr = priv->ieee80211->current_network.bssid;
3030 static u8 CAM_CONST_ADDR[4][6] = {
3031 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3032 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3033 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3034 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03} };
3035 static u8 CAM_CONST_BROAD[] = {
3036 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3038 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3041 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40) ||
3042 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104)) {
3044 for (EntryId = 0; EntryId < 4; EntryId++) {
3045 MacAddr = CAM_CONST_ADDR[EntryId];
3046 setKey(dev, EntryId, EntryId,
3047 priv->ieee80211->pairwise_key_type,
3051 } else if (priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP) {
3053 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3054 setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3055 (u8 *)dev->dev_addr, 0, NULL);
3057 setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3059 } else if (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP) {
3061 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3062 setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3063 (u8 *)dev->dev_addr, 0, NULL);
3065 setKey(dev, 4, 0, priv->ieee80211->pairwise_key_type,
3071 if (priv->ieee80211->group_key_type == KEY_TYPE_TKIP) {
3072 MacAddr = CAM_CONST_BROAD;
3073 for (EntryId = 1; EntryId < 4; EntryId++) {
3074 setKey(dev, EntryId, EntryId,
3075 priv->ieee80211->group_key_type,
3078 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3079 setKey(dev, 0, 0, priv->ieee80211->group_key_type,
3080 CAM_CONST_ADDR[0], 0, NULL);
3081 } else if (priv->ieee80211->group_key_type == KEY_TYPE_CCMP) {
3082 MacAddr = CAM_CONST_BROAD;
3083 for (EntryId = 1; EntryId < 4; EntryId++) {
3084 setKey(dev, EntryId, EntryId,
3085 priv->ieee80211->group_key_type,
3089 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3090 setKey(dev, 0, 0, priv->ieee80211->group_key_type,
3091 CAM_CONST_ADDR[0], 0, NULL);
3094 //////////////////////////////////////////////////////////////
3095 // This function is used to fix Tx/Rx stop bug temporarily.
3096 // This function will do "system reset" to NIC when Tx or Rx is stuck.
3097 // The method checking Tx/Rx stuck of this function is supported by FW,
3098 // which reports Tx and Rx counter to register 0x128 and 0x130.
3099 //////////////////////////////////////////////////////////////
3100 static void rtl819x_ifsilentreset(struct net_device *dev)
3102 struct r8192_priv *priv = ieee80211_priv(dev);
3104 int reset_status = 0;
3105 struct ieee80211_device *ieee = priv->ieee80211;
3108 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3109 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3111 if (priv->ResetProgress == RESET_TYPE_NORESET) {
3114 RT_TRACE(COMP_RESET, "=========>Reset progress!! \n");
3116 // Set the variable for reset.
3117 priv->ResetProgress = RESET_TYPE_SILENT;
3118 down(&priv->wx_sem);
3119 if (priv->up == 0) {
3120 RT_TRACE(COMP_ERR, "%s():the driver is not up! return\n", __func__);
3125 RT_TRACE(COMP_RESET, "%s():======>start to down the driver\n", __func__);
3127 rtl8192_rtx_disable(dev);
3128 rtl8192_cancel_deferred_work(priv);
3130 del_timer_sync(&priv->watch_dog_timer);
3132 ieee->sync_scan_hurryup = 1;
3133 if (ieee->state == IEEE80211_LINKED) {
3134 down(&ieee->wx_sem);
3135 netdev_dbg(dev, "ieee->state is IEEE80211_LINKED\n");
3136 ieee80211_stop_send_beacons(priv->ieee80211);
3137 del_timer_sync(&ieee->associate_timer);
3138 cancel_delayed_work(&ieee->associate_retry_wq);
3139 ieee80211_stop_scan(ieee);
3140 netif_carrier_off(dev);
3143 netdev_dbg(dev, "ieee->state is NOT LINKED\n");
3144 ieee80211_softmac_stop_protocol(priv->ieee80211);
3147 RT_TRACE(COMP_RESET, "%s():<==========down process is finished\n", __func__);
3148 RT_TRACE(COMP_RESET, "%s():===========>start up the driver\n", __func__);
3149 reset_status = _rtl8192_up(dev);
3151 RT_TRACE(COMP_RESET, "%s():<===========up process is finished\n", __func__);
3152 if (reset_status == -EAGAIN) {
3153 if (reset_times < 3) {
3157 RT_TRACE(COMP_ERR, " ERR!!! %s(): Reset Failed!!\n", __func__);
3160 ieee->is_silent_reset = 1;
3161 EnableHWSecurityConfig8192(dev);
3162 if (ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA) {
3163 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3165 queue_work(ieee->wq, &ieee->associate_complete_wq);
3167 } else if (ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC) {
3168 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3169 ieee->link_change(ieee->dev);
3171 ieee80211_start_send_beacons(ieee);
3173 if (ieee->data_hard_resume)
3174 ieee->data_hard_resume(ieee->dev);
3175 netif_carrier_on(ieee->dev);
3178 CamRestoreAllEntry(dev);
3180 priv->ResetProgress = RESET_TYPE_NORESET;
3181 priv->reset_count++;
3183 priv->bForcedSilentReset = false;
3184 priv->bResetInProgress = false;
3186 // For test --> force write UFWP.
3187 write_nic_byte(dev, UFWP, 1);
3188 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
3192 static void rtl819x_update_rxcounts(struct r8192_priv *priv, u32 *TotalRxBcnNum,
3193 u32 *TotalRxDataNum)
3199 *TotalRxDataNum = 0;
3201 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
3202 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
3203 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
3204 for (i = 0; i < priv->ieee80211->LinkDetectInfo.SlotNum; i++) {
3205 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
3206 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
3211 void rtl819x_watchdog_wqcallback(struct work_struct *work)
3213 struct delayed_work *dwork = container_of(work, struct delayed_work, work);
3214 struct r8192_priv *priv = container_of(dwork, struct r8192_priv, watch_dog_wq);
3215 struct net_device *dev = priv->ieee80211->dev;
3216 struct ieee80211_device *ieee = priv->ieee80211;
3217 RESET_TYPE ResetType = RESET_TYPE_NORESET;
3218 static u8 check_reset_cnt;
3219 bool bBusyTraffic = false;
3220 u32 TotalRxBcnNum = 0;
3221 u32 TotalRxDataNum = 0;
3225 hal_dm_watchdog(dev);
3227 //to get busy traffic condition
3228 if (ieee->state == IEEE80211_LINKED) {
3229 if (ieee->LinkDetectInfo.NumRxOkInPeriod > 666 ||
3230 ieee->LinkDetectInfo.NumTxOkInPeriod > 666 ) {
3231 bBusyTraffic = true;
3233 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
3234 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
3235 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
3237 //added by amy for AP roaming
3238 if (priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA) {
3240 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
3241 if ((TotalRxBcnNum+TotalRxDataNum) == 0) {
3243 if (rfState == eRfOff)
3244 RT_TRACE(COMP_ERR, "========>%s()\n", __func__);
3246 netdev_dbg(dev, "===>%s(): AP is power off, connect another one\n", __func__);
3247 priv->ieee80211->state = IEEE80211_ASSOCIATING;
3248 notify_wx_assoc_event(priv->ieee80211);
3249 RemovePeerTS(priv->ieee80211, priv->ieee80211->current_network.bssid);
3250 priv->ieee80211->link_change(dev);
3251 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
3255 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod = 0;
3256 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod = 0;
3257 //check if reset the driver
3258 if (check_reset_cnt++ >= 3) {
3259 ResetType = rtl819x_ifcheck_resetornot(dev);
3260 check_reset_cnt = 3;
3262 if ((priv->force_reset) || (priv->ResetProgress == RESET_TYPE_NORESET &&
3263 (priv->bForcedSilentReset ||
3264 (!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_SILENT)))) { /* This is control by OID set in Pomelo */
3265 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);
3266 rtl819x_ifsilentreset(dev);
3268 priv->force_reset = false;
3269 priv->bForcedSilentReset = false;
3270 priv->bResetInProgress = false;
3271 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
3275 void watch_dog_timer_callback(unsigned long data)
3277 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
3278 queue_delayed_work(priv->priv_wq, &priv->watch_dog_wq, 0);
3279 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
3281 int _rtl8192_up(struct net_device *dev)
3283 struct r8192_priv *priv = ieee80211_priv(dev);
3284 int init_status = 0;
3286 priv->ieee80211->ieee_up = 1;
3287 RT_TRACE(COMP_INIT, "Bringing up iface");
3288 init_status = rtl8192_adapter_start(dev);
3290 RT_TRACE(COMP_ERR, "ERR!!! %s(): initialization failed!\n", __func__);
3291 priv->up = priv->ieee80211->ieee_up = 0;
3294 RT_TRACE(COMP_INIT, "start adapter finished\n");
3295 rtl8192_rx_enable(dev);
3296 if (priv->ieee80211->state != IEEE80211_LINKED)
3297 ieee80211_softmac_start_protocol(priv->ieee80211);
3298 ieee80211_reset_queue(priv->ieee80211);
3299 watch_dog_timer_callback((unsigned long) dev);
3300 if (!netif_queue_stopped(dev))
3301 netif_start_queue(dev);
3303 netif_wake_queue(dev);
3309 static int rtl8192_open(struct net_device *dev)
3311 struct r8192_priv *priv = ieee80211_priv(dev);
3313 down(&priv->wx_sem);
3314 ret = rtl8192_up(dev);
3321 int rtl8192_up(struct net_device *dev)
3323 struct r8192_priv *priv = ieee80211_priv(dev);
3328 return _rtl8192_up(dev);
3332 int rtl8192_close(struct net_device *dev)
3334 struct r8192_priv *priv = ieee80211_priv(dev);
3337 down(&priv->wx_sem);
3339 ret = rtl8192_down(dev);
3347 int rtl8192_down(struct net_device *dev)
3349 struct r8192_priv *priv = ieee80211_priv(dev);
3356 priv->ieee80211->ieee_up = 0;
3357 RT_TRACE(COMP_DOWN, "==========>%s()\n", __func__);
3359 if (!netif_queue_stopped(dev))
3360 netif_stop_queue(dev);
3362 rtl8192_rtx_disable(dev);
3364 /* Tx related queue release */
3365 for (i = 0; i < MAX_QUEUE_SIZE; i++)
3366 skb_queue_purge(&priv->ieee80211->skb_waitQ[i]);
3367 for (i = 0; i < MAX_QUEUE_SIZE; i++)
3368 skb_queue_purge(&priv->ieee80211->skb_aggQ[i]);
3370 for (i = 0; i < MAX_QUEUE_SIZE; i++)
3371 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ[i]);
3373 //as cancel_delayed_work will del work->timer, so if work is not defined as struct delayed_work, it will corrupt
3374 rtl8192_cancel_deferred_work(priv);
3376 del_timer_sync(&priv->watch_dog_timer);
3379 ieee80211_softmac_stop_protocol(priv->ieee80211);
3380 memset(&priv->ieee80211->current_network, 0, offsetof(struct ieee80211_network, list));
3381 RT_TRACE(COMP_DOWN, "<==========%s()\n", __func__);
3387 void rtl8192_commit(struct net_device *dev)
3389 struct r8192_priv *priv = ieee80211_priv(dev);
3390 int reset_status = 0;
3395 rtl8192_cancel_deferred_work(priv);
3396 del_timer_sync(&priv->watch_dog_timer);
3398 ieee80211_softmac_stop_protocol(priv->ieee80211);
3400 rtl8192_rtx_disable(dev);
3401 reset_status = _rtl8192_up(dev);
3405 void rtl8192_restart(struct work_struct *work)
3407 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
3408 struct net_device *dev = priv->ieee80211->dev;
3410 down(&priv->wx_sem);
3412 rtl8192_commit(dev);
3417 static void r8192_set_multicast(struct net_device *dev)
3419 struct r8192_priv *priv = ieee80211_priv(dev);
3424 promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
3426 if (promisc != priv->promisc)
3428 priv->promisc = promisc;
3432 static int r8192_set_mac_adr(struct net_device *dev, void *mac)
3434 struct r8192_priv *priv = ieee80211_priv(dev);
3435 struct sockaddr *addr = mac;
3437 down(&priv->wx_sem);
3439 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
3441 schedule_work(&priv->reset_wq);
3447 /* based on ipw2200 driver */
3448 static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3450 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3451 struct iwreq *wrq = (struct iwreq *)rq;
3453 struct ieee80211_device *ieee = priv->ieee80211;
3455 u8 broadcast_addr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3456 struct iw_point *p = &wrq->u.data;
3457 struct ieee_param *ipw = NULL;
3459 down(&priv->wx_sem);
3462 if (p->length < sizeof(struct ieee_param) || !p->pointer) {
3467 ipw = memdup_user(p->pointer, p->length);
3474 case RTL_IOCTL_WPA_SUPPLICANT:
3475 //parse here for HW security
3476 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION) {
3477 if (ipw->u.crypt.set_tx) {
3478 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) {
3479 ieee->pairwise_key_type = KEY_TYPE_CCMP;
3480 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) {
3481 ieee->pairwise_key_type = KEY_TYPE_TKIP;
3482 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
3483 if (ipw->u.crypt.key_len == 13)
3484 ieee->pairwise_key_type = KEY_TYPE_WEP104;
3485 else if (ipw->u.crypt.key_len == 5)
3486 ieee->pairwise_key_type = KEY_TYPE_WEP40;
3488 ieee->pairwise_key_type = KEY_TYPE_NA;
3491 if (ieee->pairwise_key_type) {
3492 memcpy((u8 *)key, ipw->u.crypt.key, 16);
3493 EnableHWSecurityConfig8192(dev);
3494 //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!
3496 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8 *)ieee->ap_mac_addr, 0, key);
3497 if (ieee->auth_mode != 2)
3498 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8 *)ieee->ap_mac_addr, 0, key);
3501 memcpy((u8 *)key, ipw->u.crypt.key, 16);
3502 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0) {
3503 ieee->group_key_type = KEY_TYPE_CCMP;
3504 } else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0) {
3505 ieee->group_key_type = KEY_TYPE_TKIP;
3506 } else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
3507 if (ipw->u.crypt.key_len == 13)
3508 ieee->group_key_type = KEY_TYPE_WEP104;
3509 else if (ipw->u.crypt.key_len == 5)
3510 ieee->group_key_type = KEY_TYPE_WEP40;
3512 ieee->group_key_type = KEY_TYPE_NA;
3515 if (ieee->group_key_type) {
3516 setKey(dev, ipw->u.crypt.idx,
3517 ipw->u.crypt.idx, //KeyIndex
3518 ieee->group_key_type, //KeyType
3519 broadcast_addr, //MacAddr
3525 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
3539 static u8 HwRateToMRate90(bool bIsHT, u8 rate)
3551 case DESC90_RATE5_5M:
3552 ret_rate = MGN_5_5M;
3554 case DESC90_RATE11M:
3563 case DESC90_RATE12M:
3566 case DESC90_RATE18M:
3569 case DESC90_RATE24M:
3572 case DESC90_RATE36M:
3575 case DESC90_RATE48M:
3578 case DESC90_RATE54M:
3584 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
3590 case DESC90_RATEMCS0:
3591 ret_rate = MGN_MCS0;
3593 case DESC90_RATEMCS1:
3594 ret_rate = MGN_MCS1;
3596 case DESC90_RATEMCS2:
3597 ret_rate = MGN_MCS2;
3599 case DESC90_RATEMCS3:
3600 ret_rate = MGN_MCS3;
3602 case DESC90_RATEMCS4:
3603 ret_rate = MGN_MCS4;
3605 case DESC90_RATEMCS5:
3606 ret_rate = MGN_MCS5;
3608 case DESC90_RATEMCS6:
3609 ret_rate = MGN_MCS6;
3611 case DESC90_RATEMCS7:
3612 ret_rate = MGN_MCS7;
3614 case DESC90_RATEMCS8:
3615 ret_rate = MGN_MCS8;
3617 case DESC90_RATEMCS9:
3618 ret_rate = MGN_MCS9;
3620 case DESC90_RATEMCS10:
3621 ret_rate = MGN_MCS10;
3623 case DESC90_RATEMCS11:
3624 ret_rate = MGN_MCS11;
3626 case DESC90_RATEMCS12:
3627 ret_rate = MGN_MCS12;
3629 case DESC90_RATEMCS13:
3630 ret_rate = MGN_MCS13;
3632 case DESC90_RATEMCS14:
3633 ret_rate = MGN_MCS14;
3635 case DESC90_RATEMCS15:
3636 ret_rate = MGN_MCS15;
3638 case DESC90_RATEMCS32:
3639 ret_rate = (0x80|0x20);
3644 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
3653 * Function: UpdateRxPktTimeStamp
3654 * Overview: Record the TSF time stamp when receiving a packet
3662 * (pRfd->Status.TimeStampHigh is updated)
3663 * (pRfd->Status.TimeStampLow is updated)
3667 static void UpdateRxPktTimeStamp8190(struct net_device *dev,
3668 struct ieee80211_rx_stats *stats)
3670 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
3672 if (stats->bIsAMPDU && !stats->bFirstMPDU) {
3673 stats->mac_time[0] = priv->LastRxDescTSFLow;
3674 stats->mac_time[1] = priv->LastRxDescTSFHigh;
3676 priv->LastRxDescTSFLow = stats->mac_time[0];
3677 priv->LastRxDescTSFHigh = stats->mac_time[1];
3683 static long rtl819x_translate_todbm(u8 signal_strength_index)// 0-100 index.
3685 long signal_power; // in dBm.
3687 // Translate to dBm (x=0.5y-95).
3688 signal_power = (long)((signal_strength_index + 1) >> 1);
3691 return signal_power;
3695 /* 2008/01/22 MH We can not declare RSSI/EVM total value of sliding window to
3696 be a local static. Otherwise, it may increase when we return from S3/S4. The
3697 value will be kept in memory or disk. Declare the value in the adaptor
3698 and it will be reinitialized when returned from S3/S4. */
3699 static void rtl8192_process_phyinfo(struct r8192_priv *priv, u8 *buffer,
3700 struct ieee80211_rx_stats *pprevious_stats,
3701 struct ieee80211_rx_stats *pcurrent_stats)
3703 bool bcheck = false;
3705 u32 nspatial_stream, tmp_val;
3706 static u32 slide_rssi_index, slide_rssi_statistics;
3707 static u32 slide_evm_index, slide_evm_statistics;
3708 static u32 last_rssi, last_evm;
3710 static u32 slide_beacon_adc_pwdb_index, slide_beacon_adc_pwdb_statistics;
3711 static u32 last_beacon_adc_pwdb;
3713 struct ieee80211_hdr_3addr *hdr;
3715 unsigned int frag, seq;
3716 hdr = (struct ieee80211_hdr_3addr *)buffer;
3717 sc = le16_to_cpu(hdr->seq_ctl);
3718 frag = WLAN_GET_SEQ_FRAG(sc);
3719 seq = WLAN_GET_SEQ_SEQ(sc);
3720 //cosa add 04292008 to record the sequence number
3721 pcurrent_stats->Seq_Num = seq;
3723 // Check whether we should take the previous packet into accounting
3725 if (!pprevious_stats->bIsAMPDU) {
3726 // if previous packet is not aggregated packet
3730 if (slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX) {
3731 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
3732 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
3733 priv->stats.slide_rssi_total -= last_rssi;
3735 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
3737 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
3738 if (slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
3739 slide_rssi_index = 0;
3741 // <1> Showed on UI for user, in dbm
3742 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
3743 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
3744 pcurrent_stats->rssi = priv->stats.signal_strength;
3746 // If the previous packet does not match the criteria, neglect it
3748 if (!pprevious_stats->bPacketMatchBSSID) {
3749 if (!pprevious_stats->bToSelfBA)
3757 //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
3762 priv->stats.num_process_phyinfo++;
3764 /* record the general signal strength to the sliding window. */
3767 // <2> Showed on UI for engineering
3768 // hardware does not provide rssi information for each rf path in CCK
3769 if (!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA)) {
3770 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++) {
3771 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
3774 //Fixed by Jacken 2008-03-20
3775 if (priv->stats.rx_rssi_percentage[rfpath] == 0)
3776 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
3777 if (pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath]) {
3778 priv->stats.rx_rssi_percentage[rfpath] =
3779 ((priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
3780 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
3781 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
3783 priv->stats.rx_rssi_percentage[rfpath] =
3784 ((priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
3785 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
3787 RT_TRACE(COMP_DBG, "priv->stats.rx_rssi_percentage[rfPath] = %d \n", priv->stats.rx_rssi_percentage[rfpath]);
3795 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
3796 pprevious_stats->bIsCCK ? "CCK" : "OFDM",
3797 pprevious_stats->RxPWDBAll);
3799 if (pprevious_stats->bPacketBeacon) {
3800 /* record the beacon pwdb to the sliding window. */
3801 if (slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX) {
3802 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
3803 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
3804 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
3806 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
3807 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
3808 slide_beacon_adc_pwdb_index++;
3809 if (slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
3810 slide_beacon_adc_pwdb_index = 0;
3811 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
3812 if (pprevious_stats->RxPWDBAll >= 3)
3813 pprevious_stats->RxPWDBAll -= 3;
3816 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
3817 pprevious_stats->bIsCCK ? "CCK" : "OFDM",
3818 pprevious_stats->RxPWDBAll);
3821 if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
3822 if (priv->undecorated_smoothed_pwdb < 0) /* initialize */
3823 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
3824 if (pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb) {
3825 priv->undecorated_smoothed_pwdb =
3826 (((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
3827 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
3828 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
3830 priv->undecorated_smoothed_pwdb =
3831 (((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
3832 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
3840 /* record the general EVM to the sliding window. */
3841 if (pprevious_stats->SignalQuality) {
3842 if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
3843 if (slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX) {
3844 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
3845 last_evm = priv->stats.slide_evm[slide_evm_index];
3846 priv->stats.slide_evm_total -= last_evm;
3849 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
3851 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
3852 if (slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
3853 slide_evm_index = 0;
3855 // <1> Showed on UI for user, in percentage.
3856 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
3857 priv->stats.signal_quality = tmp_val;
3858 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
3859 priv->stats.last_signal_strength_inpercent = tmp_val;
3862 // <2> Showed on UI for engineering
3863 if (pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA) {
3864 for (nspatial_stream = 0; nspatial_stream < 2; nspatial_stream++) { /* 2 spatial stream */
3865 if (pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1) {
3866 if (priv->stats.rx_evm_percentage[nspatial_stream] == 0) /* initialize */
3867 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
3868 priv->stats.rx_evm_percentage[nspatial_stream] =
3869 ((priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
3870 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
3879 /*-----------------------------------------------------------------------------
3880 * Function: rtl819x_query_rxpwrpercentage()
3884 * Input: char antpower
3888 * Return: 0-100 percentage
3892 * 05/26/2008 amy Create Version 0 porting from windows code.
3894 *---------------------------------------------------------------------------*/
3895 static u8 rtl819x_query_rxpwrpercentage(char antpower)
3897 if ((antpower <= -100) || (antpower >= 20))
3899 else if (antpower >= 0)
3902 return 100 + antpower;
3904 } /* QueryRxPwrPercentage */
3906 static u8 rtl819x_evm_dbtopercentage(char value)
3916 ret_val = 0 - ret_val;
3924 // We want good-looking for signal strength/quality
3925 // 2007/7/19 01:09, by cosa.
3927 static long rtl819x_signal_scale_mapping(long currsig)
3931 // Step 1. Scale mapping.
3932 if (currsig >= 61 && currsig <= 100)
3933 retsig = 90 + ((currsig - 60) / 4);
3934 else if (currsig >= 41 && currsig <= 60)
3935 retsig = 78 + ((currsig - 40) / 2);
3936 else if (currsig >= 31 && currsig <= 40)
3937 retsig = 66 + (currsig - 30);
3938 else if (currsig >= 21 && currsig <= 30)
3939 retsig = 54 + (currsig - 20);
3940 else if (currsig >= 5 && currsig <= 20)
3941 retsig = 42 + (((currsig - 5) * 2) / 3);
3942 else if (currsig == 4)
3944 else if (currsig == 3)
3946 else if (currsig == 2)
3948 else if (currsig == 1)
3956 static inline bool rx_hal_is_cck_rate(struct rx_drvinfo_819x_usb *pdrvinfo)
3961 switch (pdrvinfo->RxRate) {
3964 case DESC90_RATE5_5M:
3965 case DESC90_RATE11M:
3972 static void rtl8192_query_rxphystatus(struct r8192_priv *priv,
3973 struct ieee80211_rx_stats *pstats,
3974 rx_drvinfo_819x_usb *pdrvinfo,
3975 struct ieee80211_rx_stats *precord_stats,
3976 bool bpacket_match_bssid,
3977 bool bpacket_toself,
3981 phy_sts_ofdm_819xusb_t *pofdm_buf;
3982 phy_sts_cck_819xusb_t *pcck_buf;
3983 phy_ofdm_rx_status_rxsc_sgien_exintfflag *prxsc;
3985 u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
3986 char rx_pwr[4], rx_pwr_all = 0;
3987 char rx_snrX, rx_evmX;
3989 u32 RSSI, total_rssi = 0;
3995 priv->stats.numqry_phystatus++;
3997 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
3999 // Record it for next packet processing
4000 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
4001 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
4002 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
4003 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;
4004 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
4005 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
4007 prxpkt = (u8 *)pdrvinfo;
4009 /* Move pointer to the 16th bytes. Phy status start address. */
4010 prxpkt += sizeof(rx_drvinfo_819x_usb);
4012 /* Initial the cck and ofdm buffer pointer */
4013 pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
4014 pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
4016 pstats->RxMIMOSignalQuality[0] = -1;
4017 pstats->RxMIMOSignalQuality[1] = -1;
4018 precord_stats->RxMIMOSignalQuality[0] = -1;
4019 precord_stats->RxMIMOSignalQuality[1] = -1;
4023 // (1)Hardware does not provide RSSI for CCK
4027 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4031 priv->stats.numqry_phystatusCCK++;
4033 if (!priv->bCckHighPower) {
4034 report = pcck_buf->cck_agc_rpt & 0xc0;
4037 //Fixed by Jacken from Bryant 2008-03-20
4038 //Original value is -38 , -26 , -14 , -2
4039 //Fixed value is -35 , -23 , -11 , 6
4041 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
4044 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
4047 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
4050 rx_pwr_all = 6 - (pcck_buf->cck_agc_rpt & 0x3e);
4054 report = pcck_buf->cck_agc_rpt & 0x60;
4058 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4061 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4064 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4067 rx_pwr_all = 6 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4072 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
4073 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
4074 pstats->RecvSignalPower = pwdb_all;
4077 // (3) Get Signal Quality (EVM)
4080 if (pstats->RxPWDBAll > 40) {
4083 sq = pcck_buf->sq_rpt;
4085 if (pcck_buf->sq_rpt > 64)
4087 else if (pcck_buf->sq_rpt < 20)
4090 sq = ((64-sq) * 100) / 44;
4092 pstats->SignalQuality = precord_stats->SignalQuality = sq;
4093 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
4094 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
4097 priv->stats.numqry_phystatusHT++;
4099 // (1)Get RSSI for HT rate
4101 for (i = RF90_PATH_A; i < priv->NumTotalRFPath; i++) {
4102 // 2008/01/30 MH we will judge RF RX path now.
4103 if (priv->brfpath_rxenable[i])
4108 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
4111 //Fixed by Jacken from Bryant 2008-03-20
4112 //Original value is 106
4113 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
4115 //Get Rx snr value in DB
4116 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
4117 rx_snrX = (char)(tmp_rxsnr);
4119 priv->stats.rxSNRdB[i] = (long)rx_snrX;
4121 /* Translate DBM to percentage. */
4122 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
4125 /* Record Signal Strength for next packet */
4126 pstats->RxMIMOSignalStrength[i] = (u8) RSSI;
4127 precord_stats->RxMIMOSignalStrength[i] = (u8) RSSI;
4132 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4134 //Fixed by Jacken from Bryant 2008-03-20
4135 //Original value is 106
4136 rx_pwr_all = (((pofdm_buf->pwdb_all) >> 1)& 0x7f) -106;
4137 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
4139 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
4140 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
4143 // (3)EVM of HT rate
4145 if (pdrvinfo->RxHT && pdrvinfo->RxRate >= DESC90_RATEMCS8 &&
4146 pdrvinfo->RxRate <= DESC90_RATEMCS15)
4147 max_spatial_stream = 2; //both spatial stream make sense
4149 max_spatial_stream = 1; //only spatial stream 1 makes sense
4151 for (i = 0; i < max_spatial_stream; i++) {
4152 tmp_rxevm = pofdm_buf->rxevm_X[i];
4153 rx_evmX = (char)(tmp_rxevm);
4155 // Do not use shift operation like "rx_evmX >>= 1" because the compiler of free build environment
4156 // will set the most significant bit to "zero" when doing shifting operation which may change a negative
4157 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
4160 evm = rtl819x_evm_dbtopercentage(rx_evmX);
4161 if (i == 0) /* Fill value in RFD, Get the first spatial stream only */
4162 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
4163 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
4167 /* record rx statistics for debug */
4168 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
4169 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
4170 if (pdrvinfo->BW) /* 40M channel */
4171 priv->stats.received_bwtype[1+prxsc->rxsc]++;
4173 priv->stats.received_bwtype[0]++;
4176 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
4177 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
4179 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));
4181 // We can judge RX path number now.
4183 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi /= rf_rx_num)));
4185 } /* QueryRxPhyStatus8190Pci */
4187 static void rtl8192_record_rxdesc_forlateruse(struct ieee80211_rx_stats *psrc_stats,
4188 struct ieee80211_rx_stats *ptarget_stats)
4190 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
4191 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
4192 ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
4196 static void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
4197 struct ieee80211_rx_stats *pstats,
4198 rx_drvinfo_819x_usb *pdrvinfo)
4200 // TODO: We must only check packet for current MAC address. Not finish
4201 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4202 struct net_device *dev = info->dev;
4203 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4204 bool bpacket_match_bssid, bpacket_toself;
4205 bool bPacketBeacon = FALSE, bToSelfBA = FALSE;
4206 static struct ieee80211_rx_stats previous_stats;
4207 struct ieee80211_hdr_3addr *hdr;//by amy
4210 // Get Signal Quality for only RX data queue (but not command queue)
4215 /* Get MAC frame start address. */
4216 tmp_buf = (u8 *)skb->data;
4218 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
4219 fc = le16_to_cpu(hdr->frame_ctl);
4220 type = WLAN_FC_GET_TYPE(fc);
4221 praddr = hdr->addr1;
4223 /* Check if the received packet is acceptable. */
4224 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
4225 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS) ? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS) ? hdr->addr2 : hdr->addr3))
4226 && (!pstats->bHwError) && (!pstats->bCRC) && (!pstats->bICV));
4227 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
4229 if (WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BEACON)
4230 bPacketBeacon = true;
4231 if (WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK) {
4232 if ((eqMacAddr(praddr, dev->dev_addr)))
4238 if (bpacket_match_bssid)
4239 priv->stats.numpacket_matchbssid++;
4241 priv->stats.numpacket_toself++;
4243 // Process PHY information for previous packet (RSSI/PWDB/EVM)
4245 // Because phy information is contained in the last packet of AMPDU only, so driver
4246 // should process phy information of previous packet
4247 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
4248 rtl8192_query_rxphystatus(priv, pstats, pdrvinfo, &previous_stats, bpacket_match_bssid, bpacket_toself, bPacketBeacon, bToSelfBA);
4249 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
4254 * Function: UpdateReceivedRateHistogramStatistics
4255 * Overview: Record the received data rate
4258 * struct net_device *dev
4259 * struct ieee80211_rx_stats *stats
4263 * (priv->stats.ReceivedRateHistogram[] is updated)
4268 UpdateReceivedRateHistogramStatistics8190(struct net_device *dev,
4269 struct ieee80211_rx_stats *stats)
4271 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4272 u32 rcvType = 1; //0: Total, 1:OK, 2:CRC, 3:ICV
4274 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
4279 else if (stats->bICV)
4282 if (stats->bShortPreamble)
4283 preamble_guardinterval = 1;// short
4285 preamble_guardinterval = 0;// long
4287 switch (stats->rate) {
4301 /* Legacy OFDM rate */
4326 /* 11n High throughput rate */
4379 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
4380 priv->stats.received_rate_histogram[0][rateIndex]++; //total
4381 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
4385 static void query_rxdesc_status(struct sk_buff *skb,
4386 struct ieee80211_rx_stats *stats,
4387 bool bIsRxAggrSubframe)
4389 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4390 struct net_device *dev = info->dev;
4391 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4392 rx_drvinfo_819x_usb *driver_info = NULL;
4395 //Get Rx Descriptor Information
4397 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
4399 stats->Length = desc->Length;
4400 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
4401 stats->RxBufShift = 0;
4402 stats->bICV = desc->ICV;
4403 stats->bCRC = desc->CRC32;
4404 stats->bHwError = stats->bCRC|stats->bICV;
4405 /* RTL8190 set this bit to indicate that Hw does not decrypt packet */
4406 stats->Decrypted = !desc->SWDec;
4408 if ((priv->ieee80211->pHTInfo->bCurrentHTSupport == true) && (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP))
4409 stats->bHwError = false;
4411 stats->bHwError = stats->bCRC|stats->bICV;
4413 if (stats->Length < 24 || stats->Length > MAX_8192U_RX_SIZE)
4414 stats->bHwError |= 1;
4418 // TODO: Need to verify it on FGPA platform
4419 //Driver info are written to the RxBuffer following rx desc
4420 if (stats->RxDrvInfoSize != 0) {
4421 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) +
4425 if (!stats->bHwError) {
4427 ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
4428 if (ret_rate == 0xff) {
4429 // Abnormal Case: Receive CRC OK packet with Rx descriptor indicating non supported rate.
4430 // Special Error Handling here, 2008.05.16, by Emily
4432 stats->bHwError = 1;
4433 stats->rate = MGN_1M; //Set 1M rate by default
4435 stats->rate = ret_rate;
4441 stats->bShortPreamble = driver_info->SPLCP;
4444 UpdateReceivedRateHistogramStatistics8190(dev, stats);
4446 stats->bIsAMPDU = (driver_info->PartAggr == 1);
4447 stats->bFirstMPDU = (driver_info->PartAggr == 1) && (driver_info->FirstAGGR == 1);
4448 stats->TimeStampLow = driver_info->TSFL;
4449 // xiong mask it, 070514
4451 UpdateRxPktTimeStamp8190(dev, stats);
4456 if (driver_info->FirstAGGR == 1 || driver_info->PartAggr == 1)
4457 RT_TRACE(COMP_RXDESC, "driver_info->FirstAGGR = %d, driver_info->PartAggr = %d\n",
4458 driver_info->FirstAGGR, driver_info->PartAggr);
4462 skb_pull(skb, sizeof(rx_desc_819x_usb));
4464 // Get Total offset of MPDU Frame Body
4466 if ((stats->RxBufShift + stats->RxDrvInfoSize) > 0) {
4468 skb_pull(skb, stats->RxBufShift + stats->RxDrvInfoSize);
4471 /* for debug 2008.5.29 */
4473 //added by vivi, for MP, 20080108
4474 stats->RxIs40MHzPacket = driver_info->BW;
4475 if (stats->RxDrvInfoSize != 0)
4476 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
4480 static void rtl8192_rx_nomal(struct sk_buff *skb)
4482 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4483 struct net_device *dev = info->dev;
4484 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4485 struct ieee80211_rx_stats stats = {
4489 .freq = IEEE80211_24GHZ_BAND,
4492 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
4493 bool unicast_packet = false;
4495 /* 20 is for ps-poll */
4496 if ((skb->len >= (20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
4497 /* first packet should not contain Rx aggregation header */
4498 query_rxdesc_status(skb, &stats, false);
4500 /* hardware related info */
4501 /* Process the MPDU received */
4502 skb_trim(skb, skb->len - 4/*sCrcLng*/);
4504 rx_pkt_len = skb->len;
4505 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
4506 unicast_packet = false;
4507 if (is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
4509 } else if (is_multicast_ether_addr(ieee80211_hdr->addr1)) {
4512 /* unicast packet */
4513 unicast_packet = true;
4516 if (!ieee80211_rx(priv->ieee80211, skb, &stats)) {
4517 dev_kfree_skb_any(skb);
4519 priv->stats.rxoktotal++;
4521 priv->stats.rxbytesunicast += rx_pkt_len;
4524 priv->stats.rxurberr++;
4525 netdev_dbg(dev, "actual_length: %d\n", skb->len);
4526 dev_kfree_skb_any(skb);
4531 static void rtl819xusb_process_received_packet(struct net_device *dev,
4532 struct ieee80211_rx_stats *pstats)
4536 struct r8192_priv *priv = ieee80211_priv(dev);
4538 // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
4539 //porting by amy 080508
4540 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
4541 frame = pstats->virtual_address;
4542 frame_len = pstats->packetlength;
4543 #ifdef TODO // by amy about HCT
4544 if (!Adapter->bInHctTest)
4545 CountRxErrStatistics(Adapter, pRfd);
4547 #ifdef ENABLE_PS //by amy for adding ps function in future
4548 RT_RF_POWER_STATE rtState;
4549 // When RF is off, we should not count the packet for hw/sw synchronize
4550 // reason, ie. there may be a duration while sw switch is changed and hw
4551 // switch is being changed. 2006.12.04, by shien chang.
4552 Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8 *)(&rtState));
4553 if (rtState == eRfOff)
4556 priv->stats.rxframgment++;
4559 RmMonitorSignalStrength(Adapter, pRfd);
4561 /* 2007/01/16 MH Add RX command packet handle here. */
4562 /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
4563 if (rtl819xusb_rx_command_packet(dev, pstats))
4573 static void query_rx_cmdpkt_desc_status(struct sk_buff *skb,
4574 struct ieee80211_rx_stats *stats)
4576 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
4579 //Get Rx Descriptor Information
4581 stats->virtual_address = (u8 *)skb->data;
4582 stats->Length = desc->Length;
4583 stats->RxDrvInfoSize = 0;
4584 stats->RxBufShift = 0;
4585 stats->packetlength = stats->Length-scrclng;
4586 stats->fraglength = stats->packetlength;
4587 stats->fragoffset = 0;
4588 stats->ntotalfrag = 1;
4592 static void rtl8192_rx_cmd(struct sk_buff *skb)
4594 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
4595 struct net_device *dev = info->dev;
4597 struct ieee80211_rx_stats stats = {
4601 .freq = IEEE80211_24GHZ_BAND,
4604 if ((skb->len >= (20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
4606 query_rx_cmdpkt_desc_status(skb, &stats);
4607 // this is to be done by amy 080508 prfd->queue_id = 1;
4611 // Process the command packet received.
4614 rtl819xusb_process_received_packet(dev, &stats);
4616 dev_kfree_skb_any(skb);
4620 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
4622 struct sk_buff *skb;
4623 struct rtl8192_rx_info *info;
4625 while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
4626 info = (struct rtl8192_rx_info *)skb->cb;
4627 switch (info->out_pipe) {
4628 /* Nomal packet pipe */
4630 priv->IrpPendingCount--;
4631 rtl8192_rx_nomal(skb);
4634 /* Command packet pipe */
4636 RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",
4639 rtl8192_rx_cmd(skb);
4642 default: /* should never get here! */
4643 RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",
4652 static const struct net_device_ops rtl8192_netdev_ops = {
4653 .ndo_open = rtl8192_open,
4654 .ndo_stop = rtl8192_close,
4655 .ndo_get_stats = rtl8192_stats,
4656 .ndo_tx_timeout = tx_timeout,
4657 .ndo_do_ioctl = rtl8192_ioctl,
4658 .ndo_set_rx_mode = r8192_set_multicast,
4659 .ndo_set_mac_address = r8192_set_mac_adr,
4660 .ndo_validate_addr = eth_validate_addr,
4661 .ndo_change_mtu = eth_change_mtu,
4662 .ndo_start_xmit = ieee80211_xmit,
4666 /****************************************************************************
4667 ---------------------------- USB_STUFF---------------------------
4668 *****************************************************************************/
4670 static int rtl8192_usb_probe(struct usb_interface *intf,
4671 const struct usb_device_id *id)
4673 struct net_device *dev = NULL;
4674 struct r8192_priv *priv = NULL;
4675 struct usb_device *udev = interface_to_usbdev(intf);
4677 RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
4679 dev = alloc_ieee80211(sizeof(struct r8192_priv));
4683 usb_set_intfdata(intf, dev);
4684 SET_NETDEV_DEV(dev, &intf->dev);
4685 priv = ieee80211_priv(dev);
4686 priv->ieee80211 = netdev_priv(dev);
4689 dev->netdev_ops = &rtl8192_netdev_ops;
4691 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
4693 dev->type = ARPHRD_ETHER;
4695 dev->watchdog_timeo = HZ*3; //modified by john, 0805
4697 if (dev_alloc_name(dev, ifname) < 0) {
4698 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
4700 dev_alloc_name(dev, ifname);
4703 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
4704 if (rtl8192_init(dev) != 0) {
4705 RT_TRACE(COMP_ERR, "Initialization failed");
4709 netif_carrier_off(dev);
4710 netif_stop_queue(dev);
4712 ret = register_netdev(dev);
4716 RT_TRACE(COMP_INIT, "dev name=======> %s\n", dev->name);
4717 rtl8192_proc_init_one(dev);
4720 RT_TRACE(COMP_INIT, "Driver probe completed\n");
4725 kfree(priv->pFirmware);
4726 priv->pFirmware = NULL;
4727 rtl8192_usb_deleteendpoints(dev);
4728 destroy_workqueue(priv->priv_wq);
4731 free_ieee80211(dev);
4733 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
4737 //detach all the work and timer structure declared or inititialize in r8192U_init function.
4738 void rtl8192_cancel_deferred_work(struct r8192_priv *priv)
4741 cancel_work_sync(&priv->reset_wq);
4742 cancel_delayed_work(&priv->watch_dog_wq);
4743 cancel_delayed_work(&priv->update_beacon_wq);
4744 cancel_work_sync(&priv->qos_activate);
4748 static void rtl8192_usb_disconnect(struct usb_interface *intf)
4750 struct net_device *dev = usb_get_intfdata(intf);
4752 struct r8192_priv *priv = ieee80211_priv(dev);
4755 unregister_netdev(dev);
4757 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
4758 rtl8192_proc_remove_one(dev);
4761 kfree(priv->pFirmware);
4762 priv->pFirmware = NULL;
4763 rtl8192_usb_deleteendpoints(dev);
4764 destroy_workqueue(priv->priv_wq);
4768 free_ieee80211(dev);
4769 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
4772 static int __init rtl8192_usb_module_init(void)
4776 #ifdef CONFIG_IEEE80211_DEBUG
4777 ret = ieee80211_debug_init();
4779 pr_err("ieee80211_debug_init() failed %d\n", ret);
4783 ret = ieee80211_crypto_init();
4785 pr_err("ieee80211_crypto_init() failed %d\n", ret);
4789 ret = ieee80211_crypto_tkip_init();
4791 pr_err("ieee80211_crypto_tkip_init() failed %d\n", ret);
4795 ret = ieee80211_crypto_ccmp_init();
4797 pr_err("ieee80211_crypto_ccmp_init() failed %d\n", ret);
4801 ret = ieee80211_crypto_wep_init();
4803 pr_err("ieee80211_crypto_wep_init() failed %d\n", ret);
4807 pr_info("\nLinux kernel driver for RTL8192 based WLAN cards\n");
4808 pr_info("Copyright (c) 2007-2008, Realsil Wlan\n");
4809 RT_TRACE(COMP_INIT, "Initializing module");
4810 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
4811 rtl8192_proc_module_init();
4812 return usb_register(&rtl8192_usb_driver);
4816 static void __exit rtl8192_usb_module_exit(void)
4818 usb_deregister(&rtl8192_usb_driver);
4820 RT_TRACE(COMP_DOWN, "Exiting");
4824 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
4826 unsigned long flags;
4828 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4830 spin_lock_irqsave(&priv->tx_lock, flags);
4831 enough_desc = check_nic_enough_desc(dev, pri);
4832 spin_unlock_irqrestore(&priv->tx_lock, flags);
4835 ieee80211_wake_queue(priv->ieee80211);
4838 void EnableHWSecurityConfig8192(struct net_device *dev)
4840 u8 SECR_value = 0x0;
4841 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4842 struct ieee80211_device *ieee = priv->ieee80211;
4843 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
4844 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2)) {
4845 SECR_value |= SCR_RxUseDK;
4846 SECR_value |= SCR_TxUseDK;
4847 } else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP))) {
4848 SECR_value |= SCR_RxUseDK;
4849 SECR_value |= SCR_TxUseDK;
4851 //add HWSec active enable here.
4852 //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
4854 ieee->hwsec_active = 1;
4856 if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep) { /* add hwsec_support flag to totol control hw_sec on/off */
4857 ieee->hwsec_active = 0;
4858 SECR_value &= ~SCR_RxDecEnable;
4860 RT_TRACE(COMP_SEC, "%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __func__,
4861 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
4862 write_nic_byte(dev, SECR, SECR_value);
4866 void setKey(struct net_device *dev, u8 EntryNo, u8 KeyIndex, u16 KeyType,
4867 u8 *MacAddr, u8 DefaultKey, u32 *KeyContent)
4869 u32 TargetCommand = 0;
4870 u32 TargetContent = 0;
4873 if (EntryNo >= TOTAL_CAM_ENTRY)
4874 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
4876 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev, EntryNo, KeyIndex, KeyType, MacAddr);
4879 usConfig |= BIT15 | (KeyType<<2);
4881 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
4884 for (i = 0; i < CAM_CONTENT_COUNT; i++) {
4885 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
4886 TargetCommand |= BIT31|BIT16;
4888 if (i == 0) { /* MAC|Config */
4889 TargetContent = (u32)(*(MacAddr+0)) << 16|
4890 (u32)(*(MacAddr+1)) << 24|
4893 write_nic_dword(dev, WCAMI, TargetContent);
4894 write_nic_dword(dev, RWCAM, TargetCommand);
4895 } else if (i == 1) { /* MAC */
4896 TargetContent = (u32)(*(MacAddr+2)) |
4897 (u32)(*(MacAddr+3)) << 8|
4898 (u32)(*(MacAddr+4)) << 16|
4899 (u32)(*(MacAddr+5)) << 24;
4900 write_nic_dword(dev, WCAMI, TargetContent);
4901 write_nic_dword(dev, RWCAM, TargetCommand);
4904 if (KeyContent != NULL) {
4905 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)));
4906 write_nic_dword(dev, RWCAM, TargetCommand);
4913 /***************************************************************************
4914 ------------------- module init / exit stubs ----------------
4915 ****************************************************************************/
4916 module_init(rtl8192_usb_module_init);
4917 module_exit(rtl8192_usb_module_exit);