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 <andreamrl@tiscali.it>, 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) { return i; }
29 unsigned int __fixunsdfsi (double d) { return d; }
30 double __adddf3(double a, double b) { return a+b; }
31 double __addsf3(float a, float b) { return a+b; }
32 double __subdf3(double a, double b) { return a-b; }
33 double __extendsfdf2(float a) {return a;}
40 #undef RX_DONT_PASS_UL
42 #undef DEBUG_RX_VERBOSE
48 #undef DEBUG_TX_FILLDESC
53 #undef DEBUG_REGISTERS
55 #undef DEBUG_IRQ_TASKLET
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 "r8192xU_phyreg.h"
72 #include <linux/usb.h>
73 #include <linux/slab.h>
74 // FIXME: check if 2.6.7 is ok
76 #ifdef CONFIG_RTL8192_PM
81 //set here to open your trace code. //WB
82 u32 rt_global_debug_component = \
90 // COMP_POWER_TRACKING |
101 COMP_ERR ; //always open err flags on
103 #define TOTAL_CAM_ENTRY 32
104 #define CAM_CONTENT_COUNT 8
106 static const struct usb_device_id rtl8192_usb_id_tbl[] = {
108 {USB_DEVICE(0x0bda, 0x8192)},
109 {USB_DEVICE(0x0bda, 0x8709)},
111 {USB_DEVICE(0x07aa, 0x0043)},
113 {USB_DEVICE(0x050d, 0x805E)},
115 {USB_DEVICE(0x0df6, 0x0031)},
117 {USB_DEVICE(0x1740, 0x9201)},
119 {USB_DEVICE(0x2001, 0x3301)},
121 {USB_DEVICE(0x5a57, 0x0290)},
123 {USB_DEVICE(0x043e, 0x7a01)},
127 MODULE_LICENSE("GPL");
128 MODULE_VERSION("V 1.1");
129 MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
130 MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
132 static char* ifname = "wlan%d";
133 static int hwwep = 1; //default use hw. set 0 to use software security
134 static int channels = 0x3fff;
138 module_param(ifname, charp, S_IRUGO|S_IWUSR );
139 //module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
140 module_param(hwwep,int, S_IRUGO|S_IWUSR);
141 module_param(channels,int, S_IRUGO|S_IWUSR);
143 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
144 //MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
145 MODULE_PARM_DESC(hwwep," Try to use hardware security support. ");
146 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
148 static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
149 const struct usb_device_id *id);
150 static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf);
153 static struct usb_driver rtl8192_usb_driver = {
154 .name = RTL819xU_MODULE_NAME, /* Driver name */
155 .id_table = rtl8192_usb_id_tbl, /* PCI_ID table */
156 .probe = rtl8192_usb_probe, /* probe fn */
157 .disconnect = rtl8192_usb_disconnect, /* remove fn */
158 #ifdef CONFIG_RTL8192_PM
159 .suspend = rtl8192_suspend, /* PM suspend fn */
160 .resume = rtl8192_resume, /* PM resume fn */
162 .suspend = NULL, /* PM suspend fn */
163 .resume = NULL, /* PM resume fn */
168 typedef struct _CHANNEL_LIST
172 }CHANNEL_LIST, *PCHANNEL_LIST;
174 static CHANNEL_LIST ChannelPlan[] = {
175 {{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
176 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
179 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
180 {{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
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
182 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
183 {{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
184 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
185 {{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
188 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
190 int i, max_chan=-1, min_chan=-1;
191 struct ieee80211_device* ieee = priv->ieee80211;
192 switch (channel_plan)
194 case COUNTRY_CODE_FCC:
195 case COUNTRY_CODE_IC:
196 case COUNTRY_CODE_ETSI:
197 case COUNTRY_CODE_SPAIN:
198 case COUNTRY_CODE_FRANCE:
199 case COUNTRY_CODE_MKK:
200 case COUNTRY_CODE_MKK1:
201 case COUNTRY_CODE_ISRAEL:
202 case COUNTRY_CODE_TELEC:
203 case COUNTRY_CODE_MIC:
206 ieee->bGlobalDomain = false;
207 //acturally 8225 & 8256 rf chip only support B,G,24N mode
208 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256))
215 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
217 if (ChannelPlan[channel_plan].Len != 0){
218 // Clear old channel map
219 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
220 // Set new channel map
221 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
223 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
225 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
230 case COUNTRY_CODE_GLOBAL_DOMAIN:
232 GET_DOT11D_INFO(ieee)->bEnabled = 0;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
234 ieee->bGlobalDomain = true;
244 #define rx_hal_is_cck_rate(_pdrvinfo)\
245 (_pdrvinfo->RxRate == DESC90_RATE1M ||\
246 _pdrvinfo->RxRate == DESC90_RATE2M ||\
247 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
248 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
252 void CamResetAllEntry(struct net_device *dev)
255 //2004/02/11 In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
256 // However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
257 // In this condition, Cam can not be reset because upper layer will not set this static key again.
258 //if(Adapter->EncAlgorithm == WEP_Encryption)
261 //DbgPrint("========================================\n");
262 //DbgPrint(" Call ResetAllEntry \n");
263 //DbgPrint("========================================\n\n");
264 ulcommand |= BIT31|BIT30;
265 write_nic_dword(dev, RWCAM, ulcommand);
270 void write_cam(struct net_device *dev, u8 addr, u32 data)
272 write_nic_dword(dev, WCAMI, data);
273 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
276 u32 read_cam(struct net_device *dev, u8 addr)
278 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
279 return read_nic_dword(dev, 0xa8);
282 void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
285 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
286 struct usb_device *udev = priv->udev;
288 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
289 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
290 indx|0xfe00, 0, &data, 1, HZ / 2);
294 printk("write_nic_byte_E TimeOut! status:%d\n", status);
298 u8 read_nic_byte_E(struct net_device *dev, int indx)
302 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
303 struct usb_device *udev = priv->udev;
305 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
306 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
307 indx|0xfe00, 0, &data, 1, HZ / 2);
311 printk("read_nic_byte_E TimeOut! status:%d\n", status);
316 //as 92U has extend page from 4 to 16, so modify functions below.
317 void write_nic_byte(struct net_device *dev, int indx, u8 data)
321 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
322 struct usb_device *udev = priv->udev;
324 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
325 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
326 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
330 printk("write_nic_byte TimeOut! status:%d\n", status);
337 void write_nic_word(struct net_device *dev, int indx, u16 data)
342 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
343 struct usb_device *udev = priv->udev;
345 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
346 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
347 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 2, HZ / 2);
351 printk("write_nic_word TimeOut! status:%d\n", status);
357 void write_nic_dword(struct net_device *dev, int indx, u32 data)
362 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
363 struct usb_device *udev = priv->udev;
365 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
366 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
367 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 4, HZ / 2);
372 printk("write_nic_dword TimeOut! status:%d\n", status);
379 u8 read_nic_byte(struct net_device *dev, int indx)
383 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
384 struct usb_device *udev = priv->udev;
386 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
387 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
388 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
392 printk("read_nic_byte TimeOut! status:%d\n", status);
400 u16 read_nic_word(struct net_device *dev, int indx)
404 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
405 struct usb_device *udev = priv->udev;
407 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
408 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
409 (indx&0xff)|0xff00, (indx>>8)&0x0f,
413 printk("read_nic_word TimeOut! status:%d\n", status);
418 u16 read_nic_word_E(struct net_device *dev, int indx)
422 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
423 struct usb_device *udev = priv->udev;
425 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
426 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
427 indx|0xfe00, 0, &data, 2, HZ / 2);
430 printk("read_nic_word TimeOut! status:%d\n", status);
435 u32 read_nic_dword(struct net_device *dev, int indx)
441 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
442 struct usb_device *udev = priv->udev;
444 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
445 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
446 (indx&0xff)|0xff00, (indx>>8)&0x0f,
449 * printk(KERN_WARNING "read size of data = %d\, date = %d\n",
455 printk("read_nic_dword TimeOut! status:%d\n", status);
460 /* u8 read_phy_cck(struct net_device *dev, u8 adr); */
461 /* u8 read_phy_ofdm(struct net_device *dev, u8 adr); */
462 /* this might still called in what was the PHY rtl8185/rtl8192 common code
463 * plans are to possibility turn it again in one common code...
465 inline void force_pci_posting(struct net_device *dev)
469 static struct net_device_stats *rtl8192_stats(struct net_device *dev);
470 void rtl8192_commit(struct net_device *dev);
471 /* void rtl8192_restart(struct net_device *dev); */
472 void rtl8192_restart(struct work_struct *work);
473 /* void rtl8192_rq_tx_ack(struct work_struct *work); */
474 void watch_dog_timer_callback(unsigned long data);
476 /****************************************************************************
477 * -----------------------------PROCFS STUFF-------------------------
478 *****************************************************************************
481 static struct proc_dir_entry *rtl8192_proc;
483 static int proc_get_stats_ap(char *page, char **start, off_t offset, int count,
484 int *eof, void *data)
486 struct net_device *dev = data;
487 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
488 struct ieee80211_device *ieee = priv->ieee80211;
489 struct ieee80211_network *target;
493 list_for_each_entry(target, &ieee->network_list, list) {
495 len += snprintf(page + len, count - len, "%s ", target->ssid);
497 if (target->wpa_ie_len > 0 || target->rsn_ie_len > 0)
498 len += snprintf(page + len, count - len, "WPA\n");
500 len += snprintf(page + len, count - len, "non_WPA\n");
507 static int proc_get_registers(char *page, char **start,
508 off_t offset, int count,
509 int *eof, void *data)
511 struct net_device *dev = data;
512 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
519 /* This dump the current register page */
520 len += snprintf(page + len, count - len,
521 "\n####################page 0##################\n ");
525 //printk( "\nD: %2x> ", n);
526 len += snprintf(page + len, count - len,
529 for(i=0;i<16 && n<=max;i++,n++)
530 len += snprintf(page + len, count - len,
531 "%2x ",read_nic_byte(dev,0x000|n));
533 // printk("%2x ",read_nic_byte(dev,n));
535 len += snprintf(page + len, count - len,
536 "\n####################page 1##################\n ");
539 //printk( "\nD: %2x> ", n);
540 len += snprintf(page + len, count - len,
543 for(i=0;i<16 && n<=max;i++,n++)
544 len += snprintf(page + len, count - len,
545 "%2x ",read_nic_byte(dev,0x100|n));
547 // printk("%2x ",read_nic_byte(dev,n));
549 len += snprintf(page + len, count - len,
550 "\n####################page 3##################\n ");
553 //printk( "\nD: %2x> ", n);
554 len += snprintf(page + len, count - len,
557 for(i=0;i<16 && n<=max;i++,n++)
558 len += snprintf(page + len, count - len,
559 "%2x ",read_nic_byte(dev,0x300|n));
561 // printk("%2x ",read_nic_byte(dev,n));
565 len += snprintf(page + len, count - len,"\n");
575 static int proc_get_stats_tx(char *page, char **start,
576 off_t offset, int count,
577 int *eof, void *data)
579 struct net_device *dev = data;
580 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
584 len += snprintf(page + len, count - len,
585 "TX VI priority ok int: %lu\n"
586 "TX VI priority error int: %lu\n"
587 "TX VO priority ok int: %lu\n"
588 "TX VO priority error int: %lu\n"
589 "TX BE priority ok int: %lu\n"
590 "TX BE priority error int: %lu\n"
591 "TX BK priority ok int: %lu\n"
592 "TX BK priority error int: %lu\n"
593 "TX MANAGE priority ok int: %lu\n"
594 "TX MANAGE priority error int: %lu\n"
595 "TX BEACON priority ok int: %lu\n"
596 "TX BEACON priority error int: %lu\n"
597 // "TX high priority ok int: %lu\n"
598 // "TX high priority failed error int: %lu\n"
599 "TX queue resume: %lu\n"
600 "TX queue stopped?: %d\n"
601 "TX fifo overflow: %lu\n"
602 // "TX beacon: %lu\n"
607 // "TX HW queue: %d\n"
608 "TX VI dropped: %lu\n"
609 "TX VO dropped: %lu\n"
610 "TX BE dropped: %lu\n"
611 "TX BK dropped: %lu\n"
612 "TX total data packets %lu\n",
613 // "TX beacon aborted: %lu\n",
614 priv->stats.txviokint,
616 priv->stats.txvookint,
618 priv->stats.txbeokint,
620 priv->stats.txbkokint,
622 priv->stats.txmanageokint,
623 priv->stats.txmanageerr,
624 priv->stats.txbeaconokint,
625 priv->stats.txbeaconerr,
626 // priv->stats.txhpokint,
627 // priv->stats.txhperr,
628 priv->stats.txresumed,
629 netif_queue_stopped(dev),
630 priv->stats.txoverflow,
631 // priv->stats.txbeacon,
632 atomic_read(&(priv->tx_pending[VI_PRIORITY])),
633 atomic_read(&(priv->tx_pending[VO_PRIORITY])),
634 atomic_read(&(priv->tx_pending[BE_PRIORITY])),
635 atomic_read(&(priv->tx_pending[BK_PRIORITY])),
636 // read_nic_byte(dev, TXFIFOCOUNT),
637 priv->stats.txvidrop,
638 priv->stats.txvodrop,
639 priv->stats.txbedrop,
640 priv->stats.txbkdrop,
641 priv->stats.txdatapkt
642 // priv->stats.txbeaconerr
651 static int proc_get_stats_rx(char *page, char **start,
652 off_t offset, int count,
653 int *eof, void *data)
655 struct net_device *dev = data;
656 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
660 len += snprintf(page + len, count - len,
662 "RX urb status error: %lu\n"
663 "RX invalid urb error: %lu\n",
664 priv->stats.rxoktotal,
665 priv->stats.rxstaterr,
666 priv->stats.rxurberr);
671 void rtl8192_proc_module_init(void)
673 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
674 rtl8192_proc = proc_mkdir(RTL819xU_MODULE_NAME, init_net.proc_net);
678 void rtl8192_proc_module_remove(void)
680 remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
684 void rtl8192_proc_remove_one(struct net_device *dev)
686 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
690 // remove_proc_entry("stats-hw", priv->dir_dev);
691 remove_proc_entry("stats-tx", priv->dir_dev);
692 remove_proc_entry("stats-rx", priv->dir_dev);
693 // remove_proc_entry("stats-ieee", priv->dir_dev);
694 remove_proc_entry("stats-ap", priv->dir_dev);
695 remove_proc_entry("registers", priv->dir_dev);
696 // remove_proc_entry("cck-registers",priv->dir_dev);
697 // remove_proc_entry("ofdm-registers",priv->dir_dev);
698 //remove_proc_entry(dev->name, rtl8192_proc);
699 remove_proc_entry("wlan0", rtl8192_proc);
700 priv->dir_dev = NULL;
705 void rtl8192_proc_init_one(struct net_device *dev)
707 struct proc_dir_entry *e;
708 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
709 priv->dir_dev = proc_mkdir(dev->name, rtl8192_proc);
710 if (!priv->dir_dev) {
711 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
715 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
716 priv->dir_dev, proc_get_stats_rx, dev);
719 RT_TRACE(COMP_ERR,"Unable to initialize "
720 "/proc/net/rtl8192/%s/stats-rx\n",
725 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
726 priv->dir_dev, proc_get_stats_tx, dev);
729 RT_TRACE(COMP_ERR, "Unable to initialize "
730 "/proc/net/rtl8192/%s/stats-tx\n",
734 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
735 priv->dir_dev, proc_get_stats_ap, dev);
738 RT_TRACE(COMP_ERR, "Unable to initialize "
739 "/proc/net/rtl8192/%s/stats-ap\n",
743 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
744 priv->dir_dev, proc_get_registers, dev);
746 RT_TRACE(COMP_ERR, "Unable to initialize "
747 "/proc/net/rtl8192/%s/registers\n",
751 /****************************************************************************
752 -----------------------------MISC STUFF-------------------------
753 *****************************************************************************/
755 /* this is only for debugging */
756 void print_buffer(u32 *buffer, int len)
759 u8 *buf =(u8*)buffer;
761 printk("ASCII BUFFER DUMP (len: %x):\n",len);
766 printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
774 //short check_nic_enough_desc(struct net_device *dev, priority_t priority)
775 short check_nic_enough_desc(struct net_device *dev,int queue_index)
777 struct r8192_priv *priv = ieee80211_priv(dev);
778 int used = atomic_read(&priv->tx_pending[queue_index]);
780 return (used < MAX_TX_URB);
783 void tx_timeout(struct net_device *dev)
785 struct r8192_priv *priv = ieee80211_priv(dev);
786 //rtl8192_commit(dev);
788 schedule_work(&priv->reset_wq);
789 //DMESG("TXTIMEOUT");
793 /* this is only for debug */
794 void dump_eprom(struct net_device *dev)
798 RT_TRACE(COMP_EPROM, "EEPROM addr %x : %x", i, eprom_read(dev,i));
801 /* this is only for debug */
802 void rtl8192_dump_reg(struct net_device *dev)
808 RT_TRACE(COMP_PHY, "Dumping NIC register map");
812 printk( "\nD: %2x> ", n);
813 for(i=0;i<16 && n<=max;i++,n++)
814 printk("%2x ",read_nic_byte(dev,n));
819 /****************************************************************************
820 ------------------------------HW STUFF---------------------------
821 *****************************************************************************/
824 void rtl8192_set_mode(struct net_device *dev,int mode)
827 ecmd=read_nic_byte(dev, EPROM_CMD);
828 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
829 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
830 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
831 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
832 write_nic_byte(dev, EPROM_CMD, ecmd);
836 void rtl8192_update_msr(struct net_device *dev)
838 struct r8192_priv *priv = ieee80211_priv(dev);
841 msr = read_nic_byte(dev, MSR);
842 msr &= ~ MSR_LINK_MASK;
844 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
845 * msr must be updated if the state is ASSOCIATING.
846 * this is intentional and make sense for ad-hoc and
847 * master (see the create BSS/IBSS func)
849 if (priv->ieee80211->state == IEEE80211_LINKED){
851 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
852 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
853 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
854 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
855 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
856 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
859 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
861 write_nic_byte(dev, MSR, msr);
864 void rtl8192_set_chan(struct net_device *dev,short ch)
866 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
868 RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
871 /* this hack should avoid frame TX during channel setting*/
874 // tx = read_nic_dword(dev,TX_CONF);
875 // tx &= ~TX_LOOPBACK_MASK;
878 // write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
880 //need to implement rf set channel here WB
882 if (priv->rf_set_chan)
883 priv->rf_set_chan(dev,priv->chan);
885 // write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
889 static void rtl8192_rx_isr(struct urb *urb);
890 //static void rtl8192_rx_isr(struct urb *rx_urb);
892 u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
895 #ifdef USB_RX_AGGREGATION_SUPPORT
896 if (pstats->bisrxaggrsubframe)
897 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
898 + pstats->RxBufShift + 8);
901 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
902 + pstats->RxBufShift);
905 static int rtl8192_rx_initiate(struct net_device*dev)
907 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
910 struct rtl8192_rx_info *info;
912 /* nomal packet rx procedure */
913 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
914 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
917 entry = usb_alloc_urb(0, GFP_KERNEL);
922 // printk("nomal packet IN request!\n");
923 usb_fill_bulk_urb(entry, priv->udev,
924 usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
925 RX_URB_SIZE, rtl8192_rx_isr, skb);
926 info = (struct rtl8192_rx_info *) skb->cb;
929 info->out_pipe = 3; //denote rx normal packet queue
930 skb_queue_tail(&priv->rx_queue, skb);
931 usb_submit_urb(entry, GFP_KERNEL);
934 /* command packet rx procedure */
935 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
936 // printk("command packet IN request!\n");
937 skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL);
940 entry = usb_alloc_urb(0, GFP_KERNEL);
945 usb_fill_bulk_urb(entry, priv->udev,
946 usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
947 RX_URB_SIZE, rtl8192_rx_isr, skb);
948 info = (struct rtl8192_rx_info *) skb->cb;
951 info->out_pipe = 9; //denote rx cmd packet queue
952 skb_queue_tail(&priv->rx_queue, skb);
953 usb_submit_urb(entry, GFP_KERNEL);
959 void rtl8192_set_rxconf(struct net_device *dev)
961 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
964 rxconf=read_nic_dword(dev,RCR);
965 rxconf = rxconf &~ MAC_FILTER_MASK;
966 rxconf = rxconf | RCR_AMF;
967 rxconf = rxconf | RCR_ADF;
968 rxconf = rxconf | RCR_AB;
969 rxconf = rxconf | RCR_AM;
970 //rxconf = rxconf | RCR_ACF;
972 if (dev->flags & IFF_PROMISC) {DMESG ("NIC in promisc mode");}
974 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
975 dev->flags & IFF_PROMISC){
976 rxconf = rxconf | RCR_AAP;
977 } /*else if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
978 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
979 rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
981 rxconf = rxconf | RCR_APM;
982 rxconf = rxconf | RCR_CBSSID;
986 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
987 rxconf = rxconf | RCR_AICV;
988 rxconf = rxconf | RCR_APWRMGT;
991 if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
992 rxconf = rxconf | RCR_ACRC32;
995 rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
996 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
997 rxconf = rxconf &~ MAX_RX_DMA_MASK;
998 rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
1000 // rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
1001 rxconf = rxconf | RCR_ONLYERLPKT;
1003 // rxconf = rxconf &~ RCR_CS_MASK;
1004 // rxconf = rxconf | (1<<RCR_CS_SHIFT);
1006 write_nic_dword(dev, RCR, rxconf);
1009 DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RCR));
1012 //wait to be removed
1013 void rtl8192_rx_enable(struct net_device *dev)
1017 //struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1019 rtl8192_rx_initiate(dev);
1021 // rtl8192_set_rxconf(dev);
1025 void rtl8192_tx_enable(struct net_device *dev)
1031 void rtl8192_rtx_disable(struct net_device *dev)
1034 struct r8192_priv *priv = ieee80211_priv(dev);
1035 struct sk_buff *skb;
1036 struct rtl8192_rx_info *info;
1038 cmd=read_nic_byte(dev,CMDR);
1039 write_nic_byte(dev, CMDR, cmd &~ \
1041 force_pci_posting(dev);
1044 while ((skb = __skb_dequeue(&priv->rx_queue))) {
1045 info = (struct rtl8192_rx_info *) skb->cb;
1049 usb_kill_urb(info->urb);
1053 if (skb_queue_len(&priv->skb_queue)) {
1054 printk(KERN_WARNING "skb_queue not empty\n");
1057 skb_queue_purge(&priv->skb_queue);
1062 int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
1067 inline u16 ieeerate2rtlrate(int rate)
1099 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
1100 inline u16 rtl8192_rate2rate(short rate)
1102 if (rate >11) return 0;
1103 return rtl_rate[rate];
1107 /* The protype of rx_isr has changed since one verion of Linux Kernel */
1108 static void rtl8192_rx_isr(struct urb *urb)
1110 struct sk_buff *skb = (struct sk_buff *) urb->context;
1111 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
1112 struct net_device *dev = info->dev;
1113 struct r8192_priv *priv = ieee80211_priv(dev);
1114 int out_pipe = info->out_pipe;
1118 if (unlikely(urb->status)) {
1120 priv->stats.rxstaterr++;
1121 priv->ieee80211->stats.rx_errors++;
1123 // printk("%s():rx status err\n",__FUNCTION__);
1126 skb_unlink(skb, &priv->rx_queue);
1127 skb_put(skb, urb->actual_length);
1129 skb_queue_tail(&priv->skb_queue, skb);
1130 tasklet_schedule(&priv->irq_rx_tasklet);
1132 skb = dev_alloc_skb(RX_URB_SIZE);
1133 if (unlikely(!skb)) {
1135 printk("%s():can,t alloc skb\n",__FUNCTION__);
1136 /* TODO check rx queue length and refill *somewhere* */
1140 usb_fill_bulk_urb(urb, priv->udev,
1141 usb_rcvbulkpipe(priv->udev, out_pipe), skb_tail_pointer(skb),
1142 RX_URB_SIZE, rtl8192_rx_isr, skb);
1144 info = (struct rtl8192_rx_info *) skb->cb;
1147 info->out_pipe = out_pipe;
1149 urb->transfer_buffer = skb_tail_pointer(skb);
1151 skb_queue_tail(&priv->rx_queue, skb);
1152 err = usb_submit_urb(urb, GFP_ATOMIC);
1153 if(err && err != EPERM)
1154 printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
1158 rtl819xusb_rx_command_packet(
1159 struct net_device *dev,
1160 struct ieee80211_rx_stats *pstats
1165 //RT_TRACE(COMP_RECV, DBG_TRACE, ("---> RxCommandPacketHandle819xUsb()\n"));
1167 status = cmpk_message_handle_rx(dev, pstats);
1170 DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
1174 //RT_TRACE(COMP_RECV, DBG_TRACE, ("RxCommandPacketHandle819xUsb: It is not a command packet\n"));
1177 //RT_TRACE(COMP_RECV, DBG_TRACE, ("<--- RxCommandPacketHandle819xUsb()\n"));
1182 void rtl8192_data_hard_stop(struct net_device *dev)
1188 void rtl8192_data_hard_resume(struct net_device *dev)
1193 /* this function TX data frames when the ieee80211 stack requires this.
1194 * It checks also if we need to stop the ieee tx queue, eventually do it
1196 void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
1198 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1200 unsigned long flags;
1201 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1202 u8 queue_index = tcb_desc->queue_index;
1204 /* shall not be referred by command packet */
1205 assert(queue_index != TXCMD_QUEUE);
1207 spin_lock_irqsave(&priv->tx_lock,flags);
1209 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1210 // tcb_desc->RATRIndex = 7;
1211 // tcb_desc->bTxDisableRateFallBack = 1;
1212 // tcb_desc->bTxUseDriverAssingedRate = 1;
1213 tcb_desc->bTxEnableFwCalcDur = 1;
1214 skb_push(skb, priv->ieee80211->tx_headroom);
1215 ret = rtl8192_tx(dev, skb);
1217 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1218 //priv->ieee80211->stats.tx_packets++;
1220 spin_unlock_irqrestore(&priv->tx_lock,flags);
1226 /* This is a rough attempt to TX a frame
1227 * This is called by the ieee 80211 stack to TX management frames.
1228 * If the ring is full packet are dropped (for data frame the queue
1229 * is stopped before this can happen).
1231 int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1233 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1235 unsigned long flags;
1236 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1237 u8 queue_index = tcb_desc->queue_index;
1240 spin_lock_irqsave(&priv->tx_lock,flags);
1242 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1243 if(queue_index == TXCMD_QUEUE) {
1244 skb_push(skb, USB_HWDESC_HEADER_LEN);
1245 rtl819xU_tx_cmd(dev, skb);
1247 spin_unlock_irqrestore(&priv->tx_lock,flags);
1250 skb_push(skb, priv->ieee80211->tx_headroom);
1251 ret = rtl8192_tx(dev, skb);
1254 spin_unlock_irqrestore(&priv->tx_lock,flags);
1260 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1262 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1263 u16 DrvAggr_PaddingAdd(struct net_device *dev, struct sk_buff *skb)
1265 u16 PaddingNum = 256 - ((skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES) % 256);
1266 return (PaddingNum&0xff);
1269 u8 MRateToHwRate8190Pci(u8 rate);
1270 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc);
1271 u8 MapHwQueueToFirmwareQueue(u8 QueueID);
1272 struct sk_buff *DrvAggr_Aggregation(struct net_device *dev, struct ieee80211_drv_agg_txb *pSendList)
1274 struct ieee80211_device *ieee = netdev_priv(dev);
1275 struct r8192_priv *priv = ieee80211_priv(dev);
1276 cb_desc *tcb_desc = NULL;
1279 struct sk_buff *skb;
1280 struct sk_buff *agg_skb;
1281 tx_desc_819x_usb_aggr_subframe *tx_agg_desc = NULL;
1282 tx_fwinfo_819x_usb *tx_fwinfo = NULL;
1285 // Local variable initialization.
1287 /* first skb initialization */
1288 skb = pSendList->tx_agg_frames[0];
1289 TotalLength = skb->len;
1291 /* Get the total aggregation length including the padding space and
1294 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1295 TotalLength += DrvAggr_PaddingAdd(dev, skb);
1296 skb = pSendList->tx_agg_frames[i];
1297 TotalLength += (skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1300 /* allocate skb to contain the aggregated packets */
1301 agg_skb = dev_alloc_skb(TotalLength + ieee->tx_headroom);
1302 memset(agg_skb->data, 0, agg_skb->len);
1303 skb_reserve(agg_skb, ieee->tx_headroom);
1305 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
1306 /* reserve info for first subframe Tx descriptor to be set in the tx function */
1307 skb = pSendList->tx_agg_frames[0];
1308 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1309 tcb_desc->drv_agg_enable = 1;
1310 tcb_desc->pkt_size = skb->len;
1311 tcb_desc->DrvAggrNum = pSendList->nr_drv_agg_frames;
1312 printk("DrvAggNum = %d\n", tcb_desc->DrvAggrNum);
1313 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
1314 // printk("========>skb->data ======> \n");
1315 // RT_DEBUG_DATA(COMP_SEND, skb->data, skb->len);
1316 memcpy(agg_skb->cb, skb->cb, sizeof(skb->cb));
1317 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1319 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1320 /* push the next sub frame to be 256 byte aline */
1321 skb_put(agg_skb,DrvAggr_PaddingAdd(dev,skb));
1323 /* Subframe drv Tx descriptor and firmware info setting */
1324 skb = pSendList->tx_agg_frames[i];
1325 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1326 tx_agg_desc = (tx_desc_819x_usb_aggr_subframe *)agg_skb->tail;
1327 tx_fwinfo = (tx_fwinfo_819x_usb *)(agg_skb->tail + sizeof(tx_desc_819x_usb_aggr_subframe));
1329 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
1331 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
1332 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
1333 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1334 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
1335 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
1336 tx_fwinfo->AllowAggregation = 1;
1338 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
1339 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
1341 tx_fwinfo->AllowAggregation = 0;
1343 tx_fwinfo->RxMF = 0;
1344 tx_fwinfo->RxAMD = 0;
1347 /* Protection mode related */
1348 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
1349 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
1350 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
1351 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
1352 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1353 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
1354 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
1355 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
1356 (tcb_desc->bRTSUseShortGI?1:0);
1358 /* Set Bandwidth and sub-channel settings. */
1359 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
1361 if(tcb_desc->bPacketBW) {
1362 tx_fwinfo->TxBandwidth = 1;
1363 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
1365 tx_fwinfo->TxBandwidth = 0;
1366 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1369 tx_fwinfo->TxBandwidth = 0;
1370 tx_fwinfo->TxSubCarrier = 0;
1373 /* Fill Tx descriptor */
1374 memset(tx_agg_desc, 0, sizeof(tx_desc_819x_usb_aggr_subframe));
1376 //tx_agg_desc->LINIP = 0;
1377 //tx_agg_desc->CmdInit = 1;
1378 tx_agg_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
1379 /* already raw data, need not to subtract header length */
1380 tx_agg_desc->PktSize = skb->len & 0xffff;
1383 tx_agg_desc->SecCAMID= 0;
1384 tx_agg_desc->RATid = tcb_desc->RATRIndex;
1387 tx_agg_desc->NoEnc = 1;
1389 tx_agg_desc->SecType = 0x0;
1391 if (tcb_desc->bHwSec) {
1392 switch (priv->ieee80211->pairwise_key_type)
1394 case KEY_TYPE_WEP40:
1395 case KEY_TYPE_WEP104:
1396 tx_agg_desc->SecType = 0x1;
1397 tx_agg_desc->NoEnc = 0;
1400 tx_agg_desc->SecType = 0x2;
1401 tx_agg_desc->NoEnc = 0;
1404 tx_agg_desc->SecType = 0x3;
1405 tx_agg_desc->NoEnc = 0;
1408 tx_agg_desc->SecType = 0x0;
1409 tx_agg_desc->NoEnc = 1;
1414 tx_agg_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1415 tx_agg_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
1417 tx_agg_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
1418 tx_agg_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1420 tx_agg_desc->OWN = 1;
1423 /* According windows driver, it seems that there no need to fill this field */
1424 //tx_agg_desc->TxBufferSize= (u32)(skb->len - USB_HWDESC_HEADER_LEN);
1426 /* to fill next packet */
1427 skb_put(agg_skb,TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1428 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1431 for(i = 0; i < pSendList->nr_drv_agg_frames; i++) {
1432 dev_kfree_skb_any(pSendList->tx_agg_frames[i]);
1439 This function return a list of PTCB which is proper to be aggregate with the input TCB.
1440 If no proper TCB is found to do aggregation, SendList will only contain the input TCB.
1442 u8 DrvAggr_GetAggregatibleList(struct net_device *dev, struct sk_buff *skb,
1443 struct ieee80211_drv_agg_txb *pSendList)
1445 struct ieee80211_device *ieee = netdev_priv(dev);
1446 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
1447 u16 nMaxAggrNum = pHTInfo->UsbTxAggrNum;
1448 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1449 u8 QueueID = tcb_desc->queue_index;
1452 pSendList->tx_agg_frames[pSendList->nr_drv_agg_frames++] = skb;
1453 if(pSendList->nr_drv_agg_frames >= nMaxAggrNum) {
1457 } while((skb = skb_dequeue(&ieee->skb_drv_aggQ[QueueID])));
1459 RT_TRACE(COMP_AMSDU, "DrvAggr_GetAggregatibleList, nAggrTcbNum = %d \n", pSendList->nr_drv_agg_frames);
1460 return pSendList->nr_drv_agg_frames;
1464 static void rtl8192_tx_isr(struct urb *tx_urb)
1466 struct sk_buff *skb = (struct sk_buff*)tx_urb->context;
1467 struct net_device *dev = NULL;
1468 struct r8192_priv *priv = NULL;
1469 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1470 u8 queue_index = tcb_desc->queue_index;
1471 // bool bToSend0Byte;
1472 // u16 BufLen = skb->len;
1474 memcpy(&dev,(struct net_device*)(skb->cb),sizeof(struct net_device*));
1475 priv = ieee80211_priv(dev);
1477 if(tcb_desc->queue_index != TXCMD_QUEUE) {
1478 if(tx_urb->status == 0) {
1479 dev->trans_start = jiffies;
1480 // As act as station mode, destion shall be unicast address.
1481 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1482 //priv->ieee80211->stats.tx_packets++;
1483 priv->stats.txoktotal++;
1484 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
1485 priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
1487 priv->ieee80211->stats.tx_errors++;
1488 //priv->stats.txmanageerr++;
1493 /* free skb and tx_urb */
1495 dev_kfree_skb_any(skb);
1496 usb_free_urb(tx_urb);
1497 atomic_dec(&priv->tx_pending[queue_index]);
1502 // Handle HW Beacon:
1503 // We had transfer our beacon frame to host controller at this moment.
1507 // Handling the wait queue of command packets.
1508 // For Tx command packets, we must not do TCB fragment because it is not handled right now.
1509 // We must cut the packets to match the size of TX_CMD_PKT before we send it.
1512 /* Handle MPDU in wait queue. */
1513 if(queue_index != BEACON_QUEUE) {
1514 /* Don't send data frame during scanning.*/
1515 if((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0)&&\
1516 (!(priv->ieee80211->queue_stop))) {
1517 if(NULL != (skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]))))
1518 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1520 return; //modified by david to avoid further processing AMSDU
1522 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1523 else if ((skb_queue_len(&priv->ieee80211->skb_drv_aggQ[queue_index])!= 0)&&\
1524 (!(priv->ieee80211->queue_stop))) {
1525 // Tx Driver Aggregation process
1526 /* The driver will aggregation the packets according to the following stets
1527 * 1. check whether there's tx irq available, for it's a completion return
1528 * function, it should contain enough tx irq;
1529 * 2. check pakcet type;
1530 * 3. initialize sendlist, check whether the to-be send packet no greater than 1
1531 * 4. aggregation the packets, and fill firmware info and tx desc to it, etc.
1532 * 5. check whehter the packet could be sent, otherwise just insert to wait head
1534 skb = skb_dequeue(&priv->ieee80211->skb_drv_aggQ[queue_index]);
1535 if(!check_nic_enough_desc(dev, queue_index)) {
1536 skb_queue_head(&(priv->ieee80211->skb_drv_aggQ[queue_index]), skb);
1543 u8* pHeader = skb->data;
1545 if(IsMgntQosData(pHeader) ||
1546 IsMgntQData_Ack(pHeader) ||
1547 IsMgntQData_Poll(pHeader) ||
1548 IsMgntQData_Poll_Ack(pHeader)
1552 struct ieee80211_drv_agg_txb SendList;
1554 memset(&SendList, 0, sizeof(struct ieee80211_drv_agg_txb));
1555 if(DrvAggr_GetAggregatibleList(dev, skb, &SendList) > 1) {
1556 skb = DrvAggr_Aggregation(dev, &SendList);
1560 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1569 void rtl8192_beacon_stop(struct net_device *dev)
1572 struct r8192_priv *priv = ieee80211_priv(dev);
1574 msr = read_nic_byte(dev, MSR);
1575 msrm = msr & MSR_LINK_MASK;
1576 msr2 = msr & ~MSR_LINK_MASK;
1578 if(NIC_8192U == priv->card_8192) {
1579 usb_kill_urb(priv->rx_urb[MAX_RX_URB]);
1581 if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
1582 (msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
1583 write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
1584 write_nic_byte(dev, MSR, msr);
1588 void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1590 struct r8192_priv *priv = ieee80211_priv(dev);
1591 struct ieee80211_network *net;
1592 u8 i=0, basic_rate = 0;
1593 net = & priv->ieee80211->current_network;
1595 for (i=0; i<net->rates_len; i++)
1597 basic_rate = net->rates[i]&0x7f;
1600 case MGN_1M: *rate_config |= RRSR_1M; break;
1601 case MGN_2M: *rate_config |= RRSR_2M; break;
1602 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1603 case MGN_11M: *rate_config |= RRSR_11M; break;
1604 case MGN_6M: *rate_config |= RRSR_6M; break;
1605 case MGN_9M: *rate_config |= RRSR_9M; break;
1606 case MGN_12M: *rate_config |= RRSR_12M; break;
1607 case MGN_18M: *rate_config |= RRSR_18M; break;
1608 case MGN_24M: *rate_config |= RRSR_24M; break;
1609 case MGN_36M: *rate_config |= RRSR_36M; break;
1610 case MGN_48M: *rate_config |= RRSR_48M; break;
1611 case MGN_54M: *rate_config |= RRSR_54M; break;
1614 for (i=0; i<net->rates_ex_len; i++)
1616 basic_rate = net->rates_ex[i]&0x7f;
1619 case MGN_1M: *rate_config |= RRSR_1M; break;
1620 case MGN_2M: *rate_config |= RRSR_2M; break;
1621 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1622 case MGN_11M: *rate_config |= RRSR_11M; break;
1623 case MGN_6M: *rate_config |= RRSR_6M; break;
1624 case MGN_9M: *rate_config |= RRSR_9M; break;
1625 case MGN_12M: *rate_config |= RRSR_12M; break;
1626 case MGN_18M: *rate_config |= RRSR_18M; break;
1627 case MGN_24M: *rate_config |= RRSR_24M; break;
1628 case MGN_36M: *rate_config |= RRSR_36M; break;
1629 case MGN_48M: *rate_config |= RRSR_48M; break;
1630 case MGN_54M: *rate_config |= RRSR_54M; break;
1636 #define SHORT_SLOT_TIME 9
1637 #define NON_SHORT_SLOT_TIME 20
1639 void rtl8192_update_cap(struct net_device* dev, u16 cap)
1642 struct r8192_priv *priv = ieee80211_priv(dev);
1643 struct ieee80211_network *net = &priv->ieee80211->current_network;
1644 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1645 tmp = priv->basic_rate;
1646 if (priv->short_preamble)
1647 tmp |= BRSR_AckShortPmb;
1648 write_nic_dword(dev, RRSR, tmp);
1650 if (net->mode & (IEEE_G|IEEE_N_24G))
1653 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1655 slot_time = SHORT_SLOT_TIME;
1657 else //long slot time
1658 slot_time = NON_SHORT_SLOT_TIME;
1659 priv->slot_time = slot_time;
1660 write_nic_byte(dev, SLOT_TIME, slot_time);
1664 void rtl8192_net_update(struct net_device *dev)
1667 struct r8192_priv *priv = ieee80211_priv(dev);
1668 struct ieee80211_network *net;
1669 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1670 u16 rate_config = 0;
1671 net = & priv->ieee80211->current_network;
1673 rtl8192_config_rate(dev, &rate_config);
1674 priv->basic_rate = rate_config &= 0x15f;
1676 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1677 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1678 //for(i=0;i<ETH_ALEN;i++)
1679 // write_nic_byte(dev,BSSID+i,net->bssid[i]);
1681 rtl8192_update_msr(dev);
1682 // rtl8192_update_cap(dev, net->capability);
1683 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1685 write_nic_word(dev, ATIMWND, 2);
1686 write_nic_word(dev, BCN_DMATIME, 1023);
1687 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1688 // write_nic_word(dev, BcnIntTime, 100);
1689 write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
1690 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1691 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1692 // TODO: BcnIFS may required to be changed on ASIC
1693 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1695 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1702 //temporary hw beacon is not used any more.
1703 //open it when necessary
1704 void rtl819xusb_beacon_tx(struct net_device *dev,u16 tx_rate)
1708 inline u8 rtl8192_IsWirelessBMode(u16 rate)
1710 if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
1715 u16 N_DBPSOfRate(u16 DataRate);
1720 u8 bManagementFrame,
1728 if( rtl8192_IsWirelessBMode(DataRate) )
1730 if( bManagementFrame || !bShortPreamble || DataRate == 10 )
1732 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1736 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1738 if( ( FrameLength*8 % (DataRate/10) ) != 0 ) //Get the Ceilling
1740 } else { //802.11g DSSS-OFDM PLCP length field calculation.
1741 N_DBPS = N_DBPSOfRate(DataRate);
1742 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1743 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1744 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1749 u16 N_DBPSOfRate(u16 DataRate)
1794 void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
1796 usb_free_urb(tx_cmd_urb);
1799 unsigned int txqueue2outpipe(struct r8192_priv* priv,unsigned int tx_queue) {
1803 RT_TRACE(COMP_ERR,"%s():Unknown queue ID!!!\n",__FUNCTION__);
1806 return priv->txqueue_to_outpipemap[tx_queue];
1809 short rtl819xU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1811 struct r8192_priv *priv = ieee80211_priv(dev);
1816 unsigned int idx_pipe;
1817 tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
1818 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1819 u8 queue_index = tcb_desc->queue_index;
1821 //printk("\n %s::queue_index = %d\n",__FUNCTION__, queue_index);
1822 atomic_inc(&priv->tx_pending[queue_index]);
1823 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
1829 memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
1830 /* Tx descriptor ought to be set according to the skb->cb */
1831 pdesc->FirstSeg = 1;//bFirstSeg;
1832 pdesc->LastSeg = 1;//bLastSeg;
1833 pdesc->CmdInit = tcb_desc->bCmdOrInit;
1834 pdesc->TxBufferSize = tcb_desc->txbuf_size;
1836 pdesc->LINIP = tcb_desc->bLastIniPkt;
1838 //----------------------------------------------------------------------------
1839 // Fill up USB_OUT_CONTEXT.
1840 //----------------------------------------------------------------------------
1841 // Get index to out pipe from specified QueueID.
1842 #ifndef USE_ONE_PIPE
1843 idx_pipe = txqueue2outpipe(priv,queue_index);
1847 #ifdef JOHN_DUMP_TXDESC
1849 printk("<Tx descriptor>--rate %x---",rate);
1850 for (i = 0; i < 8; i++)
1851 printk("%8x ", tx[i]);
1854 usb_fill_bulk_urb(tx_urb,priv->udev, usb_sndbulkpipe(priv->udev,idx_pipe), \
1855 skb->data, skb->len, rtl8192_tx_isr, skb);
1857 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
1862 DMESGE("Error TX CMD URB, error %d",
1869 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1870 * in TxFwInfo data structure
1871 * 2006.10.30 by Emily
1873 * \param QUEUEID Software Queue
1875 u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1877 u8 QueueSelect = 0x0; //defualt set to
1881 QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
1885 QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
1889 QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
1893 QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
1896 QueueSelect = QSLT_MGNT;
1900 QueueSelect = QSLT_BEACON;
1903 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
1904 // TODO: Remove Assertions
1905 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
1907 QueueSelect = QSLT_CMD;
1911 QueueSelect = QSLT_HIGH;
1915 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
1921 u8 MRateToHwRate8190Pci(u8 rate)
1923 u8 ret = DESC90_RATE1M;
1926 case MGN_1M: ret = DESC90_RATE1M; break;
1927 case MGN_2M: ret = DESC90_RATE2M; break;
1928 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
1929 case MGN_11M: ret = DESC90_RATE11M; break;
1930 case MGN_6M: ret = DESC90_RATE6M; break;
1931 case MGN_9M: ret = DESC90_RATE9M; break;
1932 case MGN_12M: ret = DESC90_RATE12M; break;
1933 case MGN_18M: ret = DESC90_RATE18M; break;
1934 case MGN_24M: ret = DESC90_RATE24M; break;
1935 case MGN_36M: ret = DESC90_RATE36M; break;
1936 case MGN_48M: ret = DESC90_RATE48M; break;
1937 case MGN_54M: ret = DESC90_RATE54M; break;
1939 // HT rate since here
1940 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
1941 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
1942 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
1943 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
1944 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
1945 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
1946 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
1947 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
1948 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
1949 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
1950 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1951 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1952 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1953 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1954 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1955 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1956 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1964 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1968 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1970 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1976 static void tx_zero_isr(struct urb *tx_urb)
1982 * The tx procedure is just as following,
1983 * skb->cb will contain all the following information,
1984 * priority, morefrag, rate, &dev.
1986 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
1988 struct r8192_priv *priv = ieee80211_priv(dev);
1989 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1990 tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
1991 tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);
1992 struct usb_device *udev = priv->udev;
1995 struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
1997 unsigned int idx_pipe;
1998 // RT_DEBUG_DATA(COMP_SEND, tcb_desc, sizeof(cb_desc));
1999 // printk("=============> %s\n", __FUNCTION__);
2000 pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
2001 /* we are locked here so the two atomic_read and inc are executed
2002 * without interleaves
2003 * !!! For debug purpose
2005 if( pend > MAX_TX_URB){
2006 printk("To discard skb packet!\n");
2007 dev_kfree_skb_any(skb);
2011 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
2013 dev_kfree_skb_any(skb);
2017 /* Fill Tx firmware info */
2018 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
2020 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
2021 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
2022 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
2023 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
2024 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
2025 tx_fwinfo->AllowAggregation = 1;
2027 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
2028 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
2030 tx_fwinfo->AllowAggregation = 0;
2032 tx_fwinfo->RxMF = 0;
2033 tx_fwinfo->RxAMD = 0;
2036 /* Protection mode related */
2037 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
2038 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
2039 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
2040 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
2041 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
2042 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
2043 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
2044 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
2045 (tcb_desc->bRTSUseShortGI?1:0);
2047 /* Set Bandwidth and sub-channel settings. */
2048 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
2050 if(tcb_desc->bPacketBW) {
2051 tx_fwinfo->TxBandwidth = 1;
2052 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
2054 tx_fwinfo->TxBandwidth = 0;
2055 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
2058 tx_fwinfo->TxBandwidth = 0;
2059 tx_fwinfo->TxSubCarrier = 0;
2062 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2063 if (tcb_desc->drv_agg_enable)
2065 tx_fwinfo->Tx_INFO_RSVD = (tcb_desc->DrvAggrNum & 0x1f) << 1;
2068 /* Fill Tx descriptor */
2069 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
2072 tx_desc->CmdInit = 1;
2073 tx_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
2075 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2076 if (tcb_desc->drv_agg_enable) {
2077 tx_desc->PktSize = tcb_desc->pkt_size;
2081 tx_desc->PktSize = (skb->len - TX_PACKET_SHIFT_BYTES) & 0xffff;
2085 tx_desc->SecCAMID= 0;
2086 tx_desc->RATid = tcb_desc->RATRIndex;
2091 tx_desc->SecType = 0x0;
2092 if (tcb_desc->bHwSec)
2094 switch (priv->ieee80211->pairwise_key_type)
2096 case KEY_TYPE_WEP40:
2097 case KEY_TYPE_WEP104:
2098 tx_desc->SecType = 0x1;
2102 tx_desc->SecType = 0x2;
2106 tx_desc->SecType = 0x3;
2110 tx_desc->SecType = 0x0;
2116 tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
2117 tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
2119 tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
2120 tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
2122 /* Fill fields that are required to be initialized in all of the descriptors */
2124 tx_desc->FirstSeg = 1;
2125 tx_desc->LastSeg = 1;
2128 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2129 if (tcb_desc->drv_agg_enable) {
2130 tx_desc->TxBufferSize = tcb_desc->pkt_size + sizeof(tx_fwinfo_819x_usb);
2135 tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
2137 /* Get index to out pipe from specified QueueID */
2138 #ifndef USE_ONE_PIPE
2139 idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
2144 //RT_DEBUG_DATA(COMP_SEND,tx_fwinfo,sizeof(tx_fwinfo_819x_usb));
2145 //RT_DEBUG_DATA(COMP_SEND,tx_desc,sizeof(tx_desc_819x_usb));
2147 /* To submit bulk urb */
2148 usb_fill_bulk_urb(tx_urb,udev,
2149 usb_sndbulkpipe(udev,idx_pipe), skb->data,
2150 skb->len, rtl8192_tx_isr, skb);
2152 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
2154 //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
2155 bool bSend0Byte = false;
2157 if(udev->speed == USB_SPEED_HIGH)
2159 if (skb->len > 0 && skb->len % 512 == 0)
2164 if (skb->len > 0 && skb->len % 64 == 0)
2169 tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
2171 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
2174 usb_fill_bulk_urb(tx_urb_zero,udev,
2175 usb_sndbulkpipe(udev,idx_pipe), &zero,
2176 0, tx_zero_isr, dev);
2177 status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
2179 RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
2183 dev->trans_start = jiffies;
2184 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
2187 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
2193 short rtl8192_usb_initendpoints(struct net_device *dev)
2195 struct r8192_priv *priv = ieee80211_priv(dev);
2197 priv->rx_urb = kmalloc(sizeof(struct urb *) * (MAX_RX_URB+1),
2199 if (priv->rx_urb == NULL)
2202 #ifndef JACKSON_NEW_RX
2203 for(i=0;i<(MAX_RX_URB+1);i++){
2205 priv->rx_urb[i] = usb_alloc_urb(0,GFP_KERNEL);
2207 priv->rx_urb[i]->transfer_buffer = kmalloc(RX_URB_SIZE, GFP_KERNEL);
2209 priv->rx_urb[i]->transfer_buffer_length = RX_URB_SIZE;
2213 #ifdef THOMAS_BEACON
2216 void *oldaddr, *newaddr;
2218 priv->rx_urb[16] = usb_alloc_urb(0, GFP_KERNEL);
2219 priv->oldaddr = kmalloc(16, GFP_KERNEL);
2220 oldaddr = priv->oldaddr;
2221 align = ((long)oldaddr) & 3;
2223 newaddr = oldaddr + 4 - align;
2224 priv->rx_urb[16]->transfer_buffer_length = 16 - 4 + align;
2227 priv->rx_urb[16]->transfer_buffer_length = 16;
2229 priv->rx_urb[16]->transfer_buffer = newaddr;
2233 memset(priv->rx_urb, 0, sizeof(struct urb*) * MAX_RX_URB);
2234 priv->pp_rxskb = kcalloc(MAX_RX_URB, sizeof(struct sk_buff *),
2236 if (priv->pp_rxskb == NULL)
2243 kfree(priv->pp_rxskb);
2244 kfree(priv->rx_urb);
2246 priv->pp_rxskb = NULL;
2247 priv->rx_urb = NULL;
2249 DMESGE("Endpoint Alloc Failure");
2255 printk("End of initendpoints\n");
2259 #ifdef THOMAS_BEACON
2260 void rtl8192_usb_deleteendpoints(struct net_device *dev)
2263 struct r8192_priv *priv = ieee80211_priv(dev);
2266 for(i=0;i<(MAX_RX_URB+1);i++){
2267 usb_kill_urb(priv->rx_urb[i]);
2268 usb_free_urb(priv->rx_urb[i]);
2270 kfree(priv->rx_urb);
2271 priv->rx_urb = NULL;
2273 kfree(priv->oldaddr);
2274 priv->oldaddr = NULL;
2275 if (priv->pp_rxskb) {
2276 kfree(priv->pp_rxskb);
2281 void rtl8192_usb_deleteendpoints(struct net_device *dev)
2284 struct r8192_priv *priv = ieee80211_priv(dev);
2286 #ifndef JACKSON_NEW_RX
2289 for(i=0;i<(MAX_RX_URB+1);i++){
2290 usb_kill_urb(priv->rx_urb[i]);
2291 kfree(priv->rx_urb[i]->transfer_buffer);
2292 usb_free_urb(priv->rx_urb[i]);
2294 kfree(priv->rx_urb);
2295 priv->rx_urb = NULL;
2299 kfree(priv->rx_urb);
2300 priv->rx_urb = NULL;
2301 kfree(priv->oldaddr);
2302 priv->oldaddr = NULL;
2303 if (priv->pp_rxskb) {
2304 kfree(priv->pp_rxskb);
2313 extern void rtl8192_update_ratr_table(struct net_device* dev);
2314 void rtl8192_link_change(struct net_device *dev)
2318 struct r8192_priv *priv = ieee80211_priv(dev);
2319 struct ieee80211_device* ieee = priv->ieee80211;
2320 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
2321 if (ieee->state == IEEE80211_LINKED)
2323 rtl8192_net_update(dev);
2324 rtl8192_update_ratr_table(dev);
2325 //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
2326 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
2327 EnableHWSecurityConfig8192(dev);
2329 /*update timing params*/
2330 // RT_TRACE(COMP_CH, "========>%s(), chan:%d\n", __FUNCTION__, priv->chan);
2331 // rtl8192_set_chan(dev, priv->chan);
2332 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
2335 reg = read_nic_dword(dev, RCR);
2336 if (priv->ieee80211->state == IEEE80211_LINKED)
2337 priv->ReceiveConfig = reg |= RCR_CBSSID;
2339 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
2340 write_nic_dword(dev, RCR, reg);
2343 // rtl8192_set_rxconf(dev);
2346 static struct ieee80211_qos_parameters def_qos_parameters = {
2347 {3,3,3,3},/* cw_min */
2348 {7,7,7,7},/* cw_max */
2349 {2,2,2,2},/* aifs */
2350 {0,0,0,0},/* flags */
2351 {0,0,0,0} /* tx_op_limit */
2355 void rtl8192_update_beacon(struct work_struct * work)
2357 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
2358 struct net_device *dev = priv->ieee80211->dev;
2359 struct ieee80211_device* ieee = priv->ieee80211;
2360 struct ieee80211_network* net = &ieee->current_network;
2362 if (ieee->pHTInfo->bCurrentHTSupport)
2363 HTUpdateSelfAndPeerSetting(ieee, net);
2364 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
2365 rtl8192_update_cap(dev, net->capability);
2368 * background support to run QoS activate functionality
2370 int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
2371 void rtl8192_qos_activate(struct work_struct * work)
2373 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
2374 struct net_device *dev = priv->ieee80211->dev;
2375 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
2376 u8 mode = priv->ieee80211->current_network.mode;
2377 //u32 size = sizeof(struct ieee80211_qos_parameters);
2385 mutex_lock(&priv->mutex);
2386 if(priv->ieee80211->state != IEEE80211_LINKED)
2388 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
2389 /* It better set slot time at first */
2390 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
2391 /* update the ac parameter to related registers */
2392 for(i = 0; i < QOS_QUEUE_NUM; i++) {
2393 //Mode G/A: slotTimeTimer = 9; Mode B: 20
2394 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
2395 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
2396 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
2397 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
2398 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
2400 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
2401 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
2405 mutex_unlock(&priv->mutex);
2408 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
2410 struct ieee80211_network *network)
2413 u32 size = sizeof(struct ieee80211_qos_parameters);
2415 if(priv->ieee80211->state !=IEEE80211_LINKED)
2418 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2421 if (network->flags & NETWORK_HAS_QOS_MASK) {
2422 if (active_network &&
2423 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
2424 network->qos_data.active = network->qos_data.supported;
2426 if ((network->qos_data.active == 1) && (active_network == 1) &&
2427 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
2428 (network->qos_data.old_param_count !=
2429 network->qos_data.param_count)) {
2430 network->qos_data.old_param_count =
2431 network->qos_data.param_count;
2432 queue_work(priv->priv_wq, &priv->qos_activate);
2433 RT_TRACE (COMP_QOS, "QoS parameters change call "
2437 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2438 &def_qos_parameters, size);
2440 if ((network->qos_data.active == 1) && (active_network == 1)) {
2441 queue_work(priv->priv_wq, &priv->qos_activate);
2442 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
2444 network->qos_data.active = 0;
2445 network->qos_data.supported = 0;
2451 /* handle manage frame frame beacon and probe response */
2452 static int rtl8192_handle_beacon(struct net_device * dev,
2453 struct ieee80211_beacon * beacon,
2454 struct ieee80211_network * network)
2456 struct r8192_priv *priv = ieee80211_priv(dev);
2458 rtl8192_qos_handle_probe_response(priv,1,network);
2459 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
2465 * handling the beaconing responses. if we get different QoS setting
2466 * off the network from the associated setting, adjust the QoS
2469 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
2470 struct ieee80211_network *network)
2473 unsigned long flags;
2474 u32 size = sizeof(struct ieee80211_qos_parameters);
2475 int set_qos_param = 0;
2477 if ((priv == NULL) || (network == NULL))
2480 if(priv->ieee80211->state !=IEEE80211_LINKED)
2483 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2486 spin_lock_irqsave(&priv->ieee80211->lock, flags);
2487 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
2488 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2489 &network->qos_data.parameters,\
2490 sizeof(struct ieee80211_qos_parameters));
2491 priv->ieee80211->current_network.qos_data.active = 1;
2494 /* update qos parameter for current network */
2495 priv->ieee80211->current_network.qos_data.old_param_count = \
2496 priv->ieee80211->current_network.qos_data.param_count;
2497 priv->ieee80211->current_network.qos_data.param_count = \
2498 network->qos_data.param_count;
2501 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2502 &def_qos_parameters, size);
2503 priv->ieee80211->current_network.qos_data.active = 0;
2504 priv->ieee80211->current_network.qos_data.supported = 0;
2508 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
2510 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
2511 if (set_qos_param == 1)
2512 queue_work(priv->priv_wq, &priv->qos_activate);
2519 static int rtl8192_handle_assoc_response(struct net_device *dev,
2520 struct ieee80211_assoc_response_frame *resp,
2521 struct ieee80211_network *network)
2523 struct r8192_priv *priv = ieee80211_priv(dev);
2524 rtl8192_qos_association_resp(priv, network);
2529 void rtl8192_update_ratr_table(struct net_device* dev)
2530 // POCTET_STRING posLegacyRate,
2532 // PRT_WLAN_STA pEntry)
2534 struct r8192_priv* priv = ieee80211_priv(dev);
2535 struct ieee80211_device* ieee = priv->ieee80211;
2536 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2537 //struct ieee80211_network *net = &ieee->current_network;
2540 rtl8192_config_rate(dev, (u16*)(&ratr_value));
2541 ratr_value |= (*(u16*)(pMcsRate)) << 12;
2542 // switch (net->mode)
2546 ratr_value &= 0x00000FF0;
2549 ratr_value &= 0x0000000F;
2552 ratr_value &= 0x00000FF7;
2556 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
2557 ratr_value &= 0x0007F007;
2559 if (priv->rf_type == RF_1T2R)
2560 ratr_value &= 0x000FF007;
2562 ratr_value &= 0x0F81F007;
2568 ratr_value &= 0x0FFFFFFF;
2569 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
2570 ratr_value |= 0x80000000;
2571 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
2572 ratr_value |= 0x80000000;
2574 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2575 write_nic_byte(dev, UFWP, 1);
2578 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
2579 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2580 bool GetNmodeSupportBySecCfg8192(struct net_device*dev)
2582 struct r8192_priv* priv = ieee80211_priv(dev);
2583 struct ieee80211_device* ieee = priv->ieee80211;
2584 struct ieee80211_network * network = &ieee->current_network;
2585 int wpa_ie_len= ieee->wpa_ie_len;
2586 struct ieee80211_crypt_data* crypt;
2589 crypt = ieee->crypt[ieee->tx_keyidx];
2590 //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
2591 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2594 if(encrypt && (wpa_ie_len == 0)) {
2595 /* wep encryption, no N mode setting */
2597 // } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
2598 } else if((wpa_ie_len != 0)) {
2599 /* parse pairwise key type */
2600 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
2601 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))))
2612 bool GetHalfNmodeSupportByAPs819xUsb(struct net_device* dev)
2615 struct r8192_priv* priv = ieee80211_priv(dev);
2616 struct ieee80211_device* ieee = priv->ieee80211;
2618 if(ieee->bHalfWirelessN24GMode == true)
2626 void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2628 struct ieee80211_device* ieee = priv->ieee80211;
2629 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
2630 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2632 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2633 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
2634 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
2637 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2641 u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2643 struct r8192_priv *priv = ieee80211_priv(dev);
2645 switch(priv->rf_chip)
2650 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2653 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2656 ret = WIRELESS_MODE_B;
2661 void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2663 struct r8192_priv *priv = ieee80211_priv(dev);
2664 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2666 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2668 if(bSupportMode & WIRELESS_MODE_N_24G)
2670 wireless_mode = WIRELESS_MODE_N_24G;
2672 else if(bSupportMode & WIRELESS_MODE_N_5G)
2674 wireless_mode = WIRELESS_MODE_N_5G;
2676 else if((bSupportMode & WIRELESS_MODE_A))
2678 wireless_mode = WIRELESS_MODE_A;
2680 else if((bSupportMode & WIRELESS_MODE_G))
2682 wireless_mode = WIRELESS_MODE_G;
2684 else if((bSupportMode & WIRELESS_MODE_B))
2686 wireless_mode = WIRELESS_MODE_B;
2689 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2690 wireless_mode = WIRELESS_MODE_B;
2693 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2694 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2696 priv->ieee80211->mode = wireless_mode;
2698 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2699 priv->ieee80211->pHTInfo->bEnableHT = 1;
2701 priv->ieee80211->pHTInfo->bEnableHT = 0;
2702 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2703 rtl8192_refresh_supportrate(priv);
2706 //init priv variables here. only non_zero value should be initialized here.
2707 static void rtl8192_init_priv_variable(struct net_device* dev)
2709 struct r8192_priv *priv = ieee80211_priv(dev);
2711 priv->card_8192 = NIC_8192U;
2712 priv->chan = 1; //set to channel 1
2713 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2714 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2715 priv->ieee80211->ieee_up=0;
2716 priv->retry_rts = DEFAULT_RETRY_RTS;
2717 priv->retry_data = DEFAULT_RETRY_DATA;
2718 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2719 priv->ieee80211->rate = 110; //11 mbps
2720 priv->ieee80211->short_slot = 1;
2721 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2724 priv->IrpPendingCount = 1;
2725 priv->ResetProgress = RESET_TYPE_NORESET;
2726 priv->bForcedSilentReset = 0;
2727 priv->bDisableNormalResetCheck = false;
2728 priv->force_reset = false;
2730 priv->ieee80211->FwRWRF = 0; //we don't use FW read/write RF until stable firmware is available.
2731 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2732 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2733 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2734 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2735 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
2736 IEEE_SOFTMAC_BEACONS;//added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2738 priv->ieee80211->active_scan = 1;
2739 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2740 priv->ieee80211->host_encrypt = 1;
2741 priv->ieee80211->host_decrypt = 1;
2742 priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2743 priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2744 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2745 priv->ieee80211->set_chan = rtl8192_set_chan;
2746 priv->ieee80211->link_change = rtl8192_link_change;
2747 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2748 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2749 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2750 priv->ieee80211->init_wmmparam_flag = 0;
2751 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2752 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2753 priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
2754 priv->ieee80211->qos_support = 1;
2757 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2758 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2759 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2760 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2762 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
2763 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
2764 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2766 priv->ieee80211->InitialGainHandler = InitialGain819xUsb;
2767 priv->card_type = USB;
2769 if(Adapter->bInHctTest)
2771 pHalData->ShortRetryLimit = 7;
2772 pHalData->LongRetryLimit = 7;
2776 priv->ShortRetryLimit = 0x30;
2777 priv->LongRetryLimit = 0x30;
2779 priv->EarlyRxThreshold = 7;
2780 priv->enable_gpio0 = 0;
2781 priv->TransmitConfig =
2782 // TCR_DurProcMode | //for RTL8185B, duration setting by HW
2783 //? TCR_DISReqQsize |
2784 (TCR_MXDMA_2048<<TCR_MXDMA_OFFSET)| // Max DMA Burst Size per Tx DMA Burst, 7: reservied.
2785 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)| // Short retry limit
2786 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
2787 (false ? TCR_SAT: 0); // FALSE: HW provies PLCP length and LENGEXT, TURE: SW proiveds them
2789 if(Adapter->bInHctTest)
2790 pHalData->ReceiveConfig = pHalData->CSMethod |
2791 RCR_AMF | RCR_ADF | //RCR_AAP | //accept management/data
2793 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2794 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2795 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2796 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2797 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
2798 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt:0);
2802 priv->ReceiveConfig =
2803 RCR_AMF | RCR_ADF | //accept management/data
2804 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2805 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2806 //RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2807 ((u32)7<<RCR_MXDMA_OFFSET)| // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2808 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) | // Rx FIFO Threshold, 7: No Rx threshold.
2809 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT:0);
2811 priv->AcmControl = 0;
2812 priv->pFirmware = kmalloc(sizeof(rt_firmware), GFP_KERNEL);
2813 if (priv->pFirmware)
2814 memset(priv->pFirmware, 0, sizeof(rt_firmware));
2816 /* rx related queue */
2817 skb_queue_head_init(&priv->rx_queue);
2818 skb_queue_head_init(&priv->skb_queue);
2820 /* Tx related queue */
2821 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2822 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2824 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2825 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2827 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2828 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ [i]);
2830 priv->rf_set_chan = rtl8192_phy_SwChnl;
2834 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2836 spin_lock_init(&priv->tx_lock);
2837 spin_lock_init(&priv->irq_lock);//added by thomas
2838 //spin_lock_init(&priv->rf_lock);
2839 sema_init(&priv->wx_sem,1);
2840 sema_init(&priv->rf_sem,1);
2841 mutex_init(&priv->mutex);
2844 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
2846 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2847 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2848 #define DRV_NAME "wlan0"
2849 static void rtl8192_init_priv_task(struct net_device* dev)
2851 struct r8192_priv *priv = ieee80211_priv(dev);
2853 #ifdef PF_SYNCTHREAD
2854 priv->priv_wq = create_workqueue(DRV_NAME,0);
2856 priv->priv_wq = create_workqueue(DRV_NAME);
2859 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2861 //INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2862 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2863 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2864 // INIT_DELAYED_WORK(&priv->gpio_change_rf_wq, dm_gpio_change_rf_callback);
2865 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2866 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2867 INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
2868 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2869 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2870 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2872 tasklet_init(&priv->irq_rx_tasklet,
2873 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2874 (unsigned long)priv);
2877 static void rtl8192_get_eeprom_size(struct net_device* dev)
2880 struct r8192_priv *priv = ieee80211_priv(dev);
2881 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2882 curCR = read_nic_word_E(dev,EPROM_CMD);
2883 RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
2884 //whether need I consider BIT5?
2885 priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2886 RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2889 //used to swap endian. as ntohl & htonl are not necessary to swap endian, so use this instead.
2890 static inline u16 endian_swap(u16* data)
2893 *data = (tmp >> 8) | (tmp << 8);
2896 static void rtl8192_read_eeprom_info(struct net_device* dev)
2899 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
2900 u8 bLoad_From_EEPOM = false;
2901 struct r8192_priv *priv = ieee80211_priv(dev);
2903 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2904 wEPROM_ID = eprom_read(dev, 0); //first read EEPROM ID out;
2905 RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
2907 if (wEPROM_ID != RTL8190_EEPROM_ID)
2909 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", wEPROM_ID, RTL8190_EEPROM_ID);
2912 bLoad_From_EEPOM = true;
2914 if (bLoad_From_EEPOM)
2916 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
2917 priv->eeprom_vid = endian_swap(&tmpValue);
2918 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
2919 tmpValue = eprom_read(dev, (EEPROM_ChannelPlan>>1));
2920 priv->eeprom_ChannelPlan =((tmpValue&0xff00)>>8);
2921 priv->btxpowerdata_readfromEEPORM = true;
2922 priv->eeprom_CustomerID = eprom_read(dev, (EEPROM_Customer_ID>>1)) >>8;
2926 priv->eeprom_vid = 0;
2927 priv->eeprom_pid = 0;
2928 priv->card_8192_version = VERSION_819xU_B;
2929 priv->eeprom_ChannelPlan = 0;
2930 priv->eeprom_CustomerID = 0;
2932 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);
2933 //set channelplan from eeprom
2934 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2935 if (bLoad_From_EEPOM)
2938 for (i=0; i<6; i+=2)
2941 tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
2942 *(u16*)(&dev->dev_addr[i]) = tmp;
2947 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2948 //should I set IDR0 here?
2950 RT_TRACE(COMP_EPROM, "MAC addr:%pM\n", dev->dev_addr);
2951 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
2952 priv->rf_chip = RF_8256;
2954 if (priv->card_8192_version == (u8)VERSION_819xU_A)
2956 //read Tx power gain offset of legacy OFDM to HT rate
2957 if (bLoad_From_EEPOM)
2958 priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff>>1))&0xff00) >> 8;
2960 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
2961 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
2962 //read ThermalMeter from EEPROM
2963 if (bLoad_From_EEPOM)
2964 priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter>>1))&0x00ff);
2966 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2967 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
2968 //vivi, for tx power track
2969 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2970 //read antenna tx power offset of B/C/D to A from EEPROM
2971 if (bLoad_From_EEPOM)
2972 priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff>>1))&0x0f00)>>8;
2974 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
2975 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
2976 // Read CrystalCap from EEPROM
2977 if (bLoad_From_EEPOM)
2978 priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap>>1))&0x0f);
2980 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
2981 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
2982 //get per-channel Tx power level
2983 if (bLoad_From_EEPOM)
2984 priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver>>1))&0xff00)>>8;
2986 priv->EEPROM_Def_Ver = 1;
2987 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
2988 if (priv->EEPROM_Def_Ver == 0) //old eeprom definition
2991 if (bLoad_From_EEPOM)
2992 priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK>>1))&0xff) >> 8;
2994 priv->EEPROMTxPowerLevelCCK = 0x10;
2995 RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
2998 if (bLoad_From_EEPOM)
3000 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G+i)>>1);
3001 if (((EEPROM_TxPwIndex_OFDM_24G+i) % 2) == 0)
3002 tmpValue = tmpValue & 0x00ff;
3004 tmpValue = (tmpValue & 0xff00) >> 8;
3008 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8) tmpValue;
3009 RT_TRACE(COMP_EPROM, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK);
3011 }//end if EEPROM_DEF_VER == 0
3012 else if (priv->EEPROM_Def_Ver == 1)
3014 if (bLoad_From_EEPOM)
3016 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1>>1));
3017 tmpValue = (tmpValue & 0xff00) >> 8;
3021 priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
3023 if (bLoad_From_EEPOM)
3024 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2)>>1);
3027 *((u16*)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
3028 if (bLoad_From_EEPOM)
3029 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1>>1));
3032 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[0])) = tmpValue;
3033 if (bLoad_From_EEPOM)
3034 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1+2)>>1);
3037 priv->EEPROMTxPowerLevelOFDM24G[2] = (u8)tmpValue;
3038 }//endif EEPROM_Def_Ver == 1
3040 //update HAL variables
3044 for (i=0; i<14; i++)
3047 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[0];
3048 else if (i>=4 && i<=9)
3049 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[1];
3051 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[2];
3054 for (i=0; i<14; i++)
3056 if (priv->EEPROM_Def_Ver == 0)
3059 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[0] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
3060 else if (i>=4 && i<=9)
3061 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK;
3063 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[2] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
3065 else if (priv->EEPROM_Def_Ver == 1)
3068 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[0];
3069 else if (i>=4 && i<=9)
3070 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[1];
3072 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[2];
3075 }//end update HAL variables
3076 priv->TxPowerDiff = priv->EEPROMPwDiff;
3077 // Antenna B gain offset to antenna A, bit0~3
3078 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
3079 // Antenna C gain offset to antenna A, bit4~7
3080 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
3081 // CrystalCap, bit12~15
3082 priv->CrystalCap = priv->EEPROMCrystalCap;
3083 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
3084 // 92U does not enable TX power tracking.
3085 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
3086 }//end if VersionID == VERSION_819xU_A
3088 //added by vivi, for dlink led, 20080416
3089 switch(priv->eeprom_CustomerID)
3091 case EEPROM_CID_RUNTOP:
3092 priv->CustomerID = RT_CID_819x_RUNTOP;
3095 case EEPROM_CID_DLINK:
3096 priv->CustomerID = RT_CID_DLINK;
3100 priv->CustomerID = RT_CID_DEFAULT;
3105 switch(priv->CustomerID)
3107 case RT_CID_819x_RUNTOP:
3108 priv->LedStrategy = SW_LED_MODE2;
3112 priv->LedStrategy = SW_LED_MODE4;
3116 priv->LedStrategy = SW_LED_MODE0;
3122 if(priv->rf_type == RF_1T2R)
3124 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
3128 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
3131 // 2008/01/16 MH We can only know RF type in the function. So we have to init
3132 // DIG RATR table again.
3133 init_rate_adaptive(dev);
3134 //we need init DIG RATR table here again.
3136 RT_TRACE(COMP_EPROM, "<===========%s()\n", __FUNCTION__);
3140 short rtl8192_get_channel_map(struct net_device * dev)
3142 struct r8192_priv *priv = ieee80211_priv(dev);
3143 if(priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN){
3144 printk("rtl8180_init:Error channel plan! Set to default.\n");
3145 priv->ChannelPlan= 0;
3147 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
3149 rtl819x_set_channel_map(priv->ChannelPlan, priv);
3153 short rtl8192_init(struct net_device *dev)
3156 struct r8192_priv *priv = ieee80211_priv(dev);
3158 memset(&(priv->stats),0,sizeof(struct Stats));
3159 memset(priv->txqueue_to_outpipemap,0,9);
3163 u8 queuetopipe[]={3,2,1,0,4,8,7,6,5};
3164 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3166 printk("%d ",priv->txqueue_to_outpipemap[i]);
3171 u8 queuetopipe[]={3,2,1,0,4,4,0,4,4};
3172 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3174 printk("%d ",priv->txqueue_to_outpipemap[i]);
3178 rtl8192_init_priv_variable(dev);
3179 rtl8192_init_priv_lock(priv);
3180 rtl8192_init_priv_task(dev);
3181 rtl8192_get_eeprom_size(dev);
3182 rtl8192_read_eeprom_info(dev);
3183 rtl8192_get_channel_map(dev);
3185 init_timer(&priv->watch_dog_timer);
3186 priv->watch_dog_timer.data = (unsigned long)dev;
3187 priv->watch_dog_timer.function = watch_dog_timer_callback;
3188 if(rtl8192_usb_initendpoints(dev)!=0){
3189 DMESG("Endopoints initialization failed");
3193 //rtl8192_adapter_start(dev);
3200 /******************************************************************************
3201 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
3202 * not to do all the hw config as its name says
3203 * input: net_device dev
3206 * notice: This part need to modified according to the rate set we filtered
3207 * ****************************************************************************/
3208 void rtl8192_hwconfig(struct net_device* dev)
3210 u32 regRATR = 0, regRRSR = 0;
3211 u8 regBwOpMode = 0, regTmp = 0;
3212 struct r8192_priv *priv = ieee80211_priv(dev);
3214 // Set RRSR, RATR, and BW_OPMODE registers
3216 switch(priv->ieee80211->mode)
3218 case WIRELESS_MODE_B:
3219 regBwOpMode = BW_OPMODE_20MHZ;
3220 regRATR = RATE_ALL_CCK;
3221 regRRSR = RATE_ALL_CCK;
3223 case WIRELESS_MODE_A:
3224 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
3225 regRATR = RATE_ALL_OFDM_AG;
3226 regRRSR = RATE_ALL_OFDM_AG;
3228 case WIRELESS_MODE_G:
3229 regBwOpMode = BW_OPMODE_20MHZ;
3230 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3231 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3233 case WIRELESS_MODE_AUTO:
3235 if (Adapter->bInHctTest)
3237 regBwOpMode = BW_OPMODE_20MHZ;
3238 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3239 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3244 regBwOpMode = BW_OPMODE_20MHZ;
3245 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3246 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3249 case WIRELESS_MODE_N_24G:
3250 // It support CCK rate by default.
3251 // CCK rate will be filtered out only when associated AP does not support it.
3252 regBwOpMode = BW_OPMODE_20MHZ;
3253 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3254 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3256 case WIRELESS_MODE_N_5G:
3257 regBwOpMode = BW_OPMODE_5G;
3258 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3259 regRRSR = RATE_ALL_OFDM_AG;
3263 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
3266 ratr_value = regRATR;
3267 if (priv->rf_type == RF_1T2R)
3269 ratr_value &= ~(RATE_ALL_OFDM_2SS);
3271 write_nic_dword(dev, RATR0, ratr_value);
3272 write_nic_byte(dev, UFWP, 1);
3274 regTmp = read_nic_byte(dev, 0x313);
3275 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
3276 write_nic_dword(dev, RRSR, regRRSR);
3279 // Set Retry Limit here
3281 write_nic_word(dev, RETRY_LIMIT,
3282 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | \
3283 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3284 // Set Contention Window here
3288 // Set Tx Antenna including Feedback control
3290 // Set Auto Rate fallback control
3296 //InitializeAdapter and PhyCfg
3297 bool rtl8192_adapter_start(struct net_device *dev)
3299 struct r8192_priv *priv = ieee80211_priv(dev);
3301 bool init_status = true;
3302 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3303 priv->Rf_Mode = RF_OP_By_SW_3wire;
3304 //for ASIC power on sequence
3305 write_nic_byte_E(dev, 0x5f, 0x80);
3307 write_nic_byte_E(dev, 0x5f, 0xf0);
3308 write_nic_byte_E(dev, 0x5d, 0x00);
3309 write_nic_byte_E(dev, 0x5e, 0x80);
3310 write_nic_byte(dev, 0x17, 0x37);
3313 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3314 //config CPUReset Register
3315 //Firmware Reset or not?
3316 dwRegRead = read_nic_dword(dev, CPU_GEN);
3317 if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3318 dwRegRead |= CPU_GEN_SYSTEM_RESET; //do nothing here?
3319 else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3320 dwRegRead |= CPU_GEN_FIRMWARE_RESET;
3322 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3324 write_nic_dword(dev, CPU_GEN, dwRegRead);
3327 rtl8192_BBConfig(dev);
3329 //Loopback mode or not
3330 priv->LoopbackMode = RTL819xU_NO_LOOPBACK;
3331 // priv->LoopbackMode = RTL819xU_MAC_LOOPBACK;
3333 dwRegRead = read_nic_dword(dev, CPU_GEN);
3334 if (priv->LoopbackMode == RTL819xU_NO_LOOPBACK)
3335 dwRegRead = ((dwRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3336 else if (priv->LoopbackMode == RTL819xU_MAC_LOOPBACK)
3337 dwRegRead |= CPU_CCK_LOOPBACK;
3339 RT_TRACE(COMP_ERR, "Serious error in %s(): wrong loopback mode setting(%d)\n", __FUNCTION__, priv->LoopbackMode);
3341 write_nic_dword(dev, CPU_GEN, dwRegRead);
3343 //after reset cpu, we need wait for a seconds to write in register.
3346 //xiong add for new bitfile:usb suspend reset pin set to 1. //do we need?
3347 write_nic_byte_E(dev, 0x5f, (read_nic_byte_E(dev, 0x5f)|0x20));
3350 rtl8192_hwconfig(dev);
3353 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3356 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3357 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3360 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3362 //Initialize Number of Reserved Pages in Firmware Queue
3363 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |\
3364 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT | \
3365 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT | \
3366 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3367 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT |\
3368 NUM_OF_PAGE_IN_FW_QUEUE_CMD << RSVD_FW_QUEUE_PAGE_CMD_SHIFT);
3369 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW| \
3370 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
3371 // | NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
3373 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3376 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3377 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3379 // RT_TRACE(COMP_INIT, "%s():priv->ResetProgress is %d\n", __FUNCTION__,priv->ResetProgress);
3380 if(priv->ResetProgress == RESET_TYPE_NORESET)
3381 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3382 if(priv->ResetProgress == RESET_TYPE_NORESET){
3383 CamResetAllEntry(dev);
3385 u8 SECR_value = 0x0;
3386 SECR_value |= SCR_TxEncEnable;
3387 SECR_value |= SCR_RxDecEnable;
3388 SECR_value |= SCR_NoSKMC;
3389 write_nic_byte(dev, SECR, SECR_value);
3394 write_nic_word(dev, ATIMWND, 2);
3395 write_nic_word(dev, BCN_INTERVAL, 100);
3398 #define DEFAULT_EDCA 0x005e4332
3400 for (i=0; i<QOS_QUEUE_NUM; i++)
3401 write_nic_dword(dev, WDCAPARA_ADD[i], DEFAULT_EDCA);
3403 #ifdef USB_RX_AGGREGATION_SUPPORT
3404 //3 For usb rx firmware aggregation control
3405 if(priv->ResetProgress == RESET_TYPE_NORESET)
3408 PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
3409 ulValue = (pHTInfo->UsbRxFwAggrEn<<24) | (pHTInfo->UsbRxFwAggrPageNum<<16) |
3410 (pHTInfo->UsbRxFwAggrPacketNum<<8) | (pHTInfo->UsbRxFwAggrTimeout);
3412 * If usb rx firmware aggregation is enabled,
3413 * when anyone of three threshold conditions above is reached,
3414 * firmware will send aggregated packet to driver.
3416 write_nic_dword(dev, 0x1a8, ulValue);
3417 priv->bCurrentRxAggrEnable = true;
3421 rtl8192_phy_configmac(dev);
3423 if (priv->card_8192_version == (u8) VERSION_819xU_A)
3425 rtl8192_phy_getTxPower(dev);
3426 rtl8192_phy_setTxPower(dev, priv->chan);
3430 init_status = init_firmware(dev);
3433 RT_TRACE(COMP_ERR,"ERR!!! %s(): Firmware download is failed\n", __FUNCTION__);
3436 RT_TRACE(COMP_INIT, "%s():after firmware download\n", __FUNCTION__);
3439 if(Adapter->ResetProgress == RESET_TYPE_NORESET)
3441 if(pMgntInfo->RegRfOff == TRUE)
3442 { // User disable RF via registry.
3443 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
3444 MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
3445 // Those action will be discard in MgntActSet_RF_State because off the same state
3446 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3447 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3449 else if(pMgntInfo->RfOffReason > RF_CHANGE_BY_PS)
3450 { // H/W or S/W RF OFF before sleep.
3451 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RfOffReason(%d) ----------\n", pMgntInfo->RfOffReason));
3452 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3456 pHalData->eRFPowerState = eRfOn;
3457 pMgntInfo->RfOffReason = 0;
3458 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): RF is on ----------\n"));
3463 if(pHalData->eRFPowerState == eRfOff)
3465 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3466 // Those action will be discard in MgntActSet_RF_State because off the same state
3467 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3468 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3473 if(priv->ResetProgress == RESET_TYPE_NORESET){
3474 rtl8192_phy_RFConfig(dev);
3475 RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __FUNCTION__);
3479 if(priv->ieee80211->FwRWRF)
3480 // We can force firmware to do RF-R/W
3481 priv->Rf_Mode = RF_OP_By_FW;
3483 priv->Rf_Mode = RF_OP_By_SW_3wire;
3486 rtl8192_phy_updateInitGain(dev);
3487 /*--set CCK and OFDM Block "ON"--*/
3488 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3489 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3491 if(priv->ResetProgress == RESET_TYPE_NORESET)
3494 u8 tmpvalue = read_nic_byte(dev, 0x301);
3498 RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
3502 priv->bDcut = FALSE;
3503 RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
3505 dm_initialize_txpower_tracking(dev);
3507 if(priv->bDcut == TRUE)
3510 u32 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3511 // u32 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3512 for(i = 0; i<TxBBGainTableLength; i++)
3514 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3516 priv->rfa_txpowertrackingindex= (u8)i;
3517 priv->rfa_txpowertrackingindex_real= (u8)i;
3518 priv->rfa_txpowertracking_default= priv->rfa_txpowertrackingindex;
3523 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3525 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3528 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3530 priv->cck_present_attentuation_20Mdefault=(u8) i;
3534 priv->cck_present_attentuation_40Mdefault= 0;
3535 priv->cck_present_attentuation_difference= 0;
3536 priv->cck_present_attentuation = priv->cck_present_attentuation_20Mdefault;
3538 // pMgntInfo->bTXPowerTracking = FALSE;//TEMPLY DISABLE
3541 write_nic_byte(dev, 0x87, 0x0);
3547 /* this configures registers for beacon tx and enables it via
3548 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3549 * be used to stop beacon transmission
3551 /***************************************************************************
3552 -------------------------------NET STUFF---------------------------
3553 ***************************************************************************/
3555 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
3557 struct r8192_priv *priv = ieee80211_priv(dev);
3559 return &priv->ieee80211->stats;
3563 HalTxCheckStuck819xUsb(
3564 struct net_device *dev
3567 struct r8192_priv *priv = ieee80211_priv(dev);
3568 u16 RegTxCounter = read_nic_word(dev, 0x128);
3569 bool bStuck = FALSE;
3570 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3571 if(priv->TxCounter==RegTxCounter)
3574 priv->TxCounter = RegTxCounter;
3580 * <Assumption: RT_TX_SPINLOCK is acquired.>
3581 * First added: 2006.11.19 by emily
3584 TxCheckStuck(struct net_device *dev)
3586 struct r8192_priv *priv = ieee80211_priv(dev);
3589 // u8 ResetThreshold;
3590 bool bCheckFwTxCnt = false;
3591 //unsigned long flags;
3594 // Decide Stuch threshold according to current power save mode
3597 // RT_TRACE(COMP_RESET, " ==> TxCheckStuck()\n");
3598 // PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK);
3599 // spin_lock_irqsave(&priv->ieee80211->lock,flags);
3600 for (QueueID = 0; QueueID<=BEACON_QUEUE;QueueID ++)
3602 if(QueueID == TXCMD_QUEUE)
3604 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3605 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_drv_aggQ[QueueID]) == 0))
3607 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
3611 bCheckFwTxCnt = true;
3613 // PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
3614 // spin_unlock_irqrestore(&priv->ieee80211->lock,flags);
3615 // RT_TRACE(COMP_RESET,"bCheckFwTxCnt is %d\n",bCheckFwTxCnt);
3618 if(HalTxCheckStuck819xUsb(dev))
3620 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3621 return RESET_TYPE_SILENT;
3624 return RESET_TYPE_NORESET;
3628 HalRxCheckStuck819xUsb(struct net_device *dev)
3630 u16 RegRxCounter = read_nic_word(dev, 0x130);
3631 struct r8192_priv *priv = ieee80211_priv(dev);
3632 bool bStuck = FALSE;
3633 static u8 rx_chk_cnt = 0;
3634 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3635 // If rssi is small, we should check rx for long time because of bad rx.
3636 // or maybe it will continuous silent reset every 2 seconds.
3638 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3640 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
3642 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3643 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3644 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
3655 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
3656 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
3657 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
3661 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3667 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3674 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
3680 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
3684 if(priv->RxCounter==RegRxCounter)
3687 priv->RxCounter = RegRxCounter;
3693 RxCheckStuck(struct net_device *dev)
3695 struct r8192_priv *priv = ieee80211_priv(dev);
3697 bool bRxCheck = FALSE;
3699 // RT_TRACE(COMP_RESET," ==> RxCheckStuck()\n");
3700 //PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
3702 if(priv->IrpPendingCount > 1)
3704 //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
3706 // RT_TRACE(COMP_RESET,"bRxCheck is %d \n",bRxCheck);
3709 if(HalRxCheckStuck819xUsb(dev))
3711 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
3712 return RESET_TYPE_SILENT;
3715 return RESET_TYPE_NORESET;
3720 * This function is called by Checkforhang to check whether we should ask OS to reset driver
3722 * \param pAdapter The adapter context for this miniport
3724 * Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
3725 * to judge whether there is tx stuck.
3726 * Note: This function may be required to be rewrite for Vista OS.
3727 * <<<Assumption: Tx spinlock has been acquired >>>
3729 * 8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
3732 rtl819x_ifcheck_resetornot(struct net_device *dev)
3734 struct r8192_priv *priv = ieee80211_priv(dev);
3735 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
3736 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
3737 RT_RF_POWER_STATE rfState;
3739 rfState = priv->ieee80211->eRFPowerState;
3741 TxResetType = TxCheckStuck(dev);
3742 if( rfState != eRfOff ||
3743 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3744 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
3746 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3747 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3748 // if driver is in firmware download failure status, driver should initialize RF in the following
3749 // silent reset procedure Emily, 2008.01.21
3751 // Driver should not check RX stuck in IBSS mode because it is required to
3752 // set Check BSSID in order to send beacon, however, if check BSSID is
3753 // set, STA cannot hear any packet a all. Emily, 2008.04.12
3754 RxResetType = RxCheckStuck(dev);
3756 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
3757 return RESET_TYPE_NORMAL;
3758 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT){
3759 RT_TRACE(COMP_RESET,"%s():silent reset\n",__FUNCTION__);
3760 return RESET_TYPE_SILENT;
3763 return RESET_TYPE_NORESET;
3767 void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
3768 int _rtl8192_up(struct net_device *dev);
3769 int rtl8192_close(struct net_device *dev);
3774 CamRestoreAllEntry( struct net_device *dev)
3777 struct r8192_priv *priv = ieee80211_priv(dev);
3778 u8* MacAddr = priv->ieee80211->current_network.bssid;
3780 static u8 CAM_CONST_ADDR[4][6] = {
3781 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3782 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3783 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3784 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3785 static u8 CAM_CONST_BROAD[] =
3786 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3788 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3791 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
3792 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
3795 for(EntryId=0; EntryId<4; EntryId++)
3798 MacAddr = CAM_CONST_ADDR[EntryId];
3802 priv->ieee80211->pairwise_key_type,
3810 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
3814 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3818 priv->ieee80211->pairwise_key_type,
3826 priv->ieee80211->pairwise_key_type,
3832 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
3836 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3840 priv->ieee80211->pairwise_key_type,
3848 priv->ieee80211->pairwise_key_type,
3857 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
3859 MacAddr = CAM_CONST_BROAD;
3860 for(EntryId=1 ; EntryId<4 ; EntryId++)
3866 priv->ieee80211->group_key_type,
3872 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3876 priv->ieee80211->group_key_type,
3881 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
3883 MacAddr = CAM_CONST_BROAD;
3884 for(EntryId=1; EntryId<4 ; EntryId++)
3890 priv->ieee80211->group_key_type,
3897 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3901 priv->ieee80211->group_key_type,
3907 //////////////////////////////////////////////////////////////
3908 // This function is used to fix Tx/Rx stop bug temporarily.
3909 // This function will do "system reset" to NIC when Tx or Rx is stuck.
3910 // The method checking Tx/Rx stuck of this function is supported by FW,
3911 // which reports Tx and Rx counter to register 0x128 and 0x130.
3912 //////////////////////////////////////////////////////////////
3914 rtl819x_ifsilentreset(struct net_device *dev)
3916 //OCTET_STRING asocpdu;
3917 struct r8192_priv *priv = ieee80211_priv(dev);
3919 int reset_status = 0;
3920 struct ieee80211_device *ieee = priv->ieee80211;
3923 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3924 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3926 if(priv->ResetProgress==RESET_TYPE_NORESET)
3930 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
3932 // Set the variable for reset.
3933 priv->ResetProgress = RESET_TYPE_SILENT;
3934 // rtl8192_close(dev);
3935 down(&priv->wx_sem);
3938 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
3943 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
3944 // if(!netif_queue_stopped(dev))
3945 // netif_stop_queue(dev);
3947 rtl8192_rtx_disable(dev);
3948 rtl8192_cancel_deferred_work(priv);
3950 del_timer_sync(&priv->watch_dog_timer);
3952 ieee->sync_scan_hurryup = 1;
3953 if(ieee->state == IEEE80211_LINKED)
3955 down(&ieee->wx_sem);
3956 printk("ieee->state is IEEE80211_LINKED\n");
3957 ieee80211_stop_send_beacons(priv->ieee80211);
3958 del_timer_sync(&ieee->associate_timer);
3959 cancel_delayed_work(&ieee->associate_retry_wq);
3960 ieee80211_stop_scan(ieee);
3961 netif_carrier_off(dev);
3965 printk("ieee->state is NOT LINKED\n");
3966 ieee80211_softmac_stop_protocol(priv->ieee80211); }
3968 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
3969 //rtl8192_irq_disable(dev);
3970 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
3971 reset_status = _rtl8192_up(dev);
3973 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
3974 if(reset_status == -EAGAIN)
3983 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n", __FUNCTION__);
3986 ieee->is_silent_reset = 1;
3987 EnableHWSecurityConfig8192(dev);
3988 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
3990 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3992 queue_work(ieee->wq, &ieee->associate_complete_wq);
3995 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
3997 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3998 ieee->link_change(ieee->dev);
4000 // notify_wx_assoc_event(ieee);
4002 ieee80211_start_send_beacons(ieee);
4004 if (ieee->data_hard_resume)
4005 ieee->data_hard_resume(ieee->dev);
4006 netif_carrier_on(ieee->dev);
4009 CamRestoreAllEntry(dev);
4011 priv->ResetProgress = RESET_TYPE_NORESET;
4012 priv->reset_count++;
4014 priv->bForcedSilentReset =false;
4015 priv->bResetInProgress = false;
4017 // For test --> force write UFWP.
4018 write_nic_byte(dev, UFWP, 1);
4019 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4023 void CAM_read_entry(
4024 struct net_device *dev,
4028 u32 target_command=0;
4029 u32 target_content=0;
4033 // printk("=======>start read CAM\n");
4034 for(entry_i=0;entry_i<CAM_CONTENT_COUNT;entry_i++)
4036 // polling bit, and No Write enable, and address
4037 target_command= entry_i+CAM_CONTENT_COUNT*iIndex;
4038 target_command= target_command | BIT31;
4040 //Check polling bit is clear
4044 ulStatus = read_nic_dword(dev, RWCAM);
4045 if(ulStatus & BIT31){
4052 write_nic_dword(dev, RWCAM, target_command);
4053 RT_TRACE(COMP_SEC,"CAM_read_entry(): WRITE A0: %x \n",target_command);
4054 // printk("CAM_read_entry(): WRITE A0: %lx \n",target_command);
4055 target_content = read_nic_dword(dev, RCAMO);
4056 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A8: %x \n",target_content);
4057 // printk("CAM_read_entry(): WRITE A8: %lx \n",target_content);
4062 void rtl819x_update_rxcounts(
4063 struct r8192_priv *priv,
4072 *TotalRxDataNum = 0;
4074 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4075 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4076 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4077 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4078 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4079 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4084 extern void rtl819x_watchdog_wqcallback(struct work_struct *work)
4086 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4087 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4088 struct net_device *dev = priv->ieee80211->dev;
4089 struct ieee80211_device* ieee = priv->ieee80211;
4090 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4091 static u8 check_reset_cnt=0;
4092 bool bBusyTraffic = false;
4096 hal_dm_watchdog(dev);
4098 {//to get busy traffic condition
4099 if(ieee->state == IEEE80211_LINKED)
4101 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 666 ||
4102 ieee->LinkDetectInfo.NumTxOkInPeriod> 666 ) {
4103 bBusyTraffic = true;
4105 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4106 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4107 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4110 //added by amy for AP roaming
4112 if(priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA)
4114 u32 TotalRxBcnNum = 0;
4115 u32 TotalRxDataNum = 0;
4117 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4118 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4121 if(rfState == eRfOff)
4122 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4124 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4125 // Dot11d_Reset(dev);
4126 priv->ieee80211->state = IEEE80211_ASSOCIATING;
4127 notify_wx_assoc_event(priv->ieee80211);
4128 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4129 priv->ieee80211->link_change(dev);
4130 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
4134 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod=0;
4135 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod=0;
4137 // CAM_read_entry(dev,4);
4138 //check if reset the driver
4139 if(check_reset_cnt++ >= 3)
4141 ResetType = rtl819x_ifcheck_resetornot(dev);
4142 check_reset_cnt = 3;
4143 //DbgPrint("Start to check silent reset\n");
4145 // 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",__FUNCTION__,priv->force_reset,priv->ResetProgress,priv->bForcedSilentReset,priv->bDisableNormalResetCheck,ResetType);
4146 if( (priv->force_reset) || (priv->ResetProgress==RESET_TYPE_NORESET &&
4147 (priv->bForcedSilentReset ||
4148 (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT)))) // This is control by OID set in Pomelo
4150 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",__FUNCTION__,priv->force_reset,priv->ResetProgress,priv->bForcedSilentReset,priv->bDisableNormalResetCheck,ResetType);
4151 rtl819x_ifsilentreset(dev);
4153 priv->force_reset = false;
4154 priv->bForcedSilentReset = false;
4155 priv->bResetInProgress = false;
4156 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4160 void watch_dog_timer_callback(unsigned long data)
4162 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4163 //printk("===============>watch_dog timer\n");
4164 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq, 0);
4165 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4167 int _rtl8192_up(struct net_device *dev)
4169 struct r8192_priv *priv = ieee80211_priv(dev);
4171 int init_status = 0;
4173 priv->ieee80211->ieee_up=1;
4174 RT_TRACE(COMP_INIT, "Bringing up iface");
4175 init_status = rtl8192_adapter_start(dev);
4178 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n", __FUNCTION__);
4179 priv->up=priv->ieee80211->ieee_up = 0;
4182 RT_TRACE(COMP_INIT, "start adapter finished\n");
4183 rtl8192_rx_enable(dev);
4184 // rtl8192_tx_enable(dev);
4185 if(priv->ieee80211->state != IEEE80211_LINKED)
4186 ieee80211_softmac_start_protocol(priv->ieee80211);
4187 ieee80211_reset_queue(priv->ieee80211);
4188 watch_dog_timer_callback((unsigned long) dev);
4189 if(!netif_queue_stopped(dev))
4190 netif_start_queue(dev);
4192 netif_wake_queue(dev);
4198 int rtl8192_open(struct net_device *dev)
4200 struct r8192_priv *priv = ieee80211_priv(dev);
4202 down(&priv->wx_sem);
4203 ret = rtl8192_up(dev);
4210 int rtl8192_up(struct net_device *dev)
4212 struct r8192_priv *priv = ieee80211_priv(dev);
4214 if (priv->up == 1) return -1;
4216 return _rtl8192_up(dev);
4220 int rtl8192_close(struct net_device *dev)
4222 struct r8192_priv *priv = ieee80211_priv(dev);
4225 down(&priv->wx_sem);
4227 ret = rtl8192_down(dev);
4235 int rtl8192_down(struct net_device *dev)
4237 struct r8192_priv *priv = ieee80211_priv(dev);
4240 if (priv->up == 0) return -1;
4243 priv->ieee80211->ieee_up = 0;
4244 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4246 if (!netif_queue_stopped(dev))
4247 netif_stop_queue(dev);
4249 rtl8192_rtx_disable(dev);
4250 //rtl8192_irq_disable(dev);
4252 /* Tx related queue release */
4253 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4254 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
4256 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4257 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
4260 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4261 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ [i]);
4264 //as cancel_delayed_work will del work->timer, so if work is not definedas struct delayed_work, it will corrupt
4265 // flush_scheduled_work();
4266 rtl8192_cancel_deferred_work(priv);
4268 del_timer_sync(&priv->watch_dog_timer);
4271 ieee80211_softmac_stop_protocol(priv->ieee80211);
4272 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4273 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4279 void rtl8192_commit(struct net_device *dev)
4281 struct r8192_priv *priv = ieee80211_priv(dev);
4282 int reset_status = 0;
4283 //u8 reset_times = 0;
4284 if (priv->up == 0) return ;
4287 rtl8192_cancel_deferred_work(priv);
4288 del_timer_sync(&priv->watch_dog_timer);
4289 //cancel_delayed_work(&priv->SwChnlWorkItem);
4291 ieee80211_softmac_stop_protocol(priv->ieee80211);
4293 //rtl8192_irq_disable(dev);
4294 rtl8192_rtx_disable(dev);
4295 reset_status = _rtl8192_up(dev);
4300 void rtl8192_restart(struct net_device *dev)
4302 struct r8192_priv *priv = ieee80211_priv(dev);
4304 void rtl8192_restart(struct work_struct *work)
4306 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4307 struct net_device *dev = priv->ieee80211->dev;
4309 down(&priv->wx_sem);
4311 rtl8192_commit(dev);
4316 static void r8192_set_multicast(struct net_device *dev)
4318 struct r8192_priv *priv = ieee80211_priv(dev);
4321 //down(&priv->wx_sem);
4325 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4327 if (promisc != priv->promisc)
4328 // rtl8192_commit(dev);
4330 priv->promisc = promisc;
4332 //schedule_work(&priv->reset_wq);
4333 //up(&priv->wx_sem);
4337 int r8192_set_mac_adr(struct net_device *dev, void *mac)
4339 struct r8192_priv *priv = ieee80211_priv(dev);
4340 struct sockaddr *addr = mac;
4342 down(&priv->wx_sem);
4344 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4346 schedule_work(&priv->reset_wq);
4352 /* based on ipw2200 driver */
4353 int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4355 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4356 struct iwreq *wrq = (struct iwreq *)rq;
4358 struct ieee80211_device *ieee = priv->ieee80211;
4360 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4361 struct iw_point *p = &wrq->u.data;
4362 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
4364 down(&priv->wx_sem);
4367 if (p->length < sizeof(struct ieee_param) || !p->pointer){
4372 ipw = kmalloc(p->length, GFP_KERNEL);
4377 if (copy_from_user(ipw, p->pointer, p->length)) {
4384 case RTL_IOCTL_WPA_SUPPLICANT:
4385 //parse here for HW security
4386 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
4388 if (ipw->u.crypt.set_tx)
4390 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4391 ieee->pairwise_key_type = KEY_TYPE_CCMP;
4392 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4393 ieee->pairwise_key_type = KEY_TYPE_TKIP;
4394 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4396 if (ipw->u.crypt.key_len == 13)
4397 ieee->pairwise_key_type = KEY_TYPE_WEP104;
4398 else if (ipw->u.crypt.key_len == 5)
4399 ieee->pairwise_key_type = KEY_TYPE_WEP40;
4402 ieee->pairwise_key_type = KEY_TYPE_NA;
4404 if (ieee->pairwise_key_type)
4406 memcpy((u8*)key, ipw->u.crypt.key, 16);
4407 EnableHWSecurityConfig8192(dev);
4408 //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!
4410 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4411 if (ieee->auth_mode != 2)
4412 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4415 else //if (ipw->u.crypt.idx) //group key use idx > 0
4417 memcpy((u8*)key, ipw->u.crypt.key, 16);
4418 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4419 ieee->group_key_type= KEY_TYPE_CCMP;
4420 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4421 ieee->group_key_type = KEY_TYPE_TKIP;
4422 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4424 if (ipw->u.crypt.key_len == 13)
4425 ieee->group_key_type = KEY_TYPE_WEP104;
4426 else if (ipw->u.crypt.key_len == 5)
4427 ieee->group_key_type = KEY_TYPE_WEP40;
4430 ieee->group_key_type = KEY_TYPE_NA;
4432 if (ieee->group_key_type)
4436 ipw->u.crypt.idx, //KeyIndex
4437 ieee->group_key_type, //KeyType
4438 broadcast_addr, //MacAddr
4444 #ifdef JOHN_HWSEC_DEBUG
4446 printk("@@ wrq->u pointer = ");
4447 for(i=0;i<wrq->u.data.length;i++){
4448 if(i%10==0) printk("\n");
4449 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
4452 #endif /*JOHN_HWSEC_DEBUG*/
4453 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
4467 u8 HwRateToMRate90(bool bIsHT, u8 rate)
4473 case DESC90_RATE1M: ret_rate = MGN_1M; break;
4474 case DESC90_RATE2M: ret_rate = MGN_2M; break;
4475 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
4476 case DESC90_RATE11M: ret_rate = MGN_11M; break;
4477 case DESC90_RATE6M: ret_rate = MGN_6M; break;
4478 case DESC90_RATE9M: ret_rate = MGN_9M; break;
4479 case DESC90_RATE12M: ret_rate = MGN_12M; break;
4480 case DESC90_RATE18M: ret_rate = MGN_18M; break;
4481 case DESC90_RATE24M: ret_rate = MGN_24M; break;
4482 case DESC90_RATE36M: ret_rate = MGN_36M; break;
4483 case DESC90_RATE48M: ret_rate = MGN_48M; break;
4484 case DESC90_RATE54M: ret_rate = MGN_54M; break;
4488 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
4494 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
4495 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
4496 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
4497 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
4498 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
4499 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
4500 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
4501 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
4502 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
4503 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
4504 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
4505 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
4506 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
4507 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
4508 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
4509 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
4510 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
4514 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
4523 * Function: UpdateRxPktTimeStamp
4524 * Overview: Recored down the TSF time stamp when receiving a packet
4532 * (pRfd->Status.TimeStampHigh is updated)
4533 * (pRfd->Status.TimeStampLow is updated)
4537 void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
4539 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4541 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
4542 stats->mac_time[0] = priv->LastRxDescTSFLow;
4543 stats->mac_time[1] = priv->LastRxDescTSFHigh;
4545 priv->LastRxDescTSFLow = stats->mac_time[0];
4546 priv->LastRxDescTSFHigh = stats->mac_time[1];
4552 long rtl819x_translate_todbm(u8 signal_strength_index )// 0-100 index.
4554 long signal_power; // in dBm.
4556 // Translate to dBm (x=0.5y-95).
4557 signal_power = (long)((signal_strength_index + 1) >> 1);
4560 return signal_power;
4564 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
4565 be a local static. Otherwise, it may increase when we return from S3/S4. The
4566 value will be kept in memory or disk. We must delcare the value in adapter
4567 and it will be reinitialized when return from S3/S4. */
4568 void rtl8192_process_phyinfo(struct r8192_priv * priv,u8* buffer, struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
4570 bool bcheck = false;
4572 u32 nspatial_stream, tmp_val;
4574 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
4575 static u32 slide_evm_index=0, slide_evm_statistics=0;
4576 static u32 last_rssi=0, last_evm=0;
4578 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
4579 static u32 last_beacon_adc_pwdb=0;
4581 struct ieee80211_hdr_3addr *hdr;
4583 unsigned int frag,seq;
4584 hdr = (struct ieee80211_hdr_3addr *)buffer;
4585 sc = le16_to_cpu(hdr->seq_ctl);
4586 frag = WLAN_GET_SEQ_FRAG(sc);
4587 seq = WLAN_GET_SEQ_SEQ(sc);
4588 //cosa add 04292008 to record the sequence number
4589 pcurrent_stats->Seq_Num = seq;
4591 // Check whether we should take the previous packet into accounting
4593 if(!pprevious_stats->bIsAMPDU)
4595 // if previous packet is not aggregated packet
4602 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
4604 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
4605 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
4606 priv->stats.slide_rssi_total -= last_rssi;
4608 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
4610 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
4611 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
4612 slide_rssi_index = 0;
4614 // <1> Showed on UI for user, in dbm
4615 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
4616 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
4617 pcurrent_stats->rssi = priv->stats.signal_strength;
4619 // If the previous packet does not match the criteria, neglect it
4621 if(!pprevious_stats->bPacketMatchBSSID)
4623 if(!pprevious_stats->bToSelfBA)
4631 //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
4636 priv->stats.num_process_phyinfo++;
4638 /* record the general signal strength to the sliding window. */
4641 // <2> Showed on UI for engineering
4642 // hardware does not provide rssi information for each rf path in CCK
4643 if(!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA))
4645 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++)
4647 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
4650 //Fixed by Jacken 2008-03-20
4651 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
4653 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
4654 //DbgPrint("MIMO RSSI initialize \n");
4656 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
4658 priv->stats.rx_rssi_percentage[rfpath] =
4659 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4660 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4661 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
4665 priv->stats.rx_rssi_percentage[rfpath] =
4666 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4667 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4669 RT_TRACE(COMP_DBG,"priv->stats.rx_rssi_percentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
4677 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4678 pprevious_stats->bIsCCK? "CCK": "OFDM",
4679 pprevious_stats->RxPWDBAll);
4681 if(pprevious_stats->bPacketBeacon)
4683 /* record the beacon pwdb to the sliding window. */
4684 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4686 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
4687 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
4688 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
4689 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
4690 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
4692 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
4693 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
4694 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
4695 slide_beacon_adc_pwdb_index++;
4696 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4697 slide_beacon_adc_pwdb_index = 0;
4698 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
4699 if(pprevious_stats->RxPWDBAll >= 3)
4700 pprevious_stats->RxPWDBAll -= 3;
4703 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4704 pprevious_stats->bIsCCK? "CCK": "OFDM",
4705 pprevious_stats->RxPWDBAll);
4708 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4710 if(priv->undecorated_smoothed_pwdb < 0) // initialize
4712 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
4713 //DbgPrint("First pwdb initialize \n");
4715 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
4717 priv->undecorated_smoothed_pwdb =
4718 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4719 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4720 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
4724 priv->undecorated_smoothed_pwdb =
4725 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4726 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4734 /* record the general EVM to the sliding window. */
4735 if(pprevious_stats->SignalQuality == 0)
4740 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
4741 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
4742 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
4743 last_evm = priv->stats.slide_evm[slide_evm_index];
4744 priv->stats.slide_evm_total -= last_evm;
4747 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
4749 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
4750 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
4751 slide_evm_index = 0;
4753 // <1> Showed on UI for user, in percentage.
4754 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
4755 priv->stats.signal_quality = tmp_val;
4756 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
4757 priv->stats.last_signal_strength_inpercent = tmp_val;
4760 // <2> Showed on UI for engineering
4761 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4763 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
4765 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
4767 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
4769 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
4771 priv->stats.rx_evm_percentage[nspatial_stream] =
4772 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
4773 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
4782 /*-----------------------------------------------------------------------------
4783 * Function: rtl819x_query_rxpwrpercentage()
4787 * Input: char antpower
4791 * Return: 0-100 percentage
4795 * 05/26/2008 amy Create Version 0 porting from windows code.
4797 *---------------------------------------------------------------------------*/
4798 static u8 rtl819x_query_rxpwrpercentage(
4802 if ((antpower <= -100) || (antpower >= 20))
4806 else if (antpower >= 0)
4812 return (100+antpower);
4815 } /* QueryRxPwrPercentage */
4818 rtl819x_evm_dbtopercentage(
4830 ret_val = 0 - ret_val;
4838 // We want good-looking for signal strength/quality
4839 // 2007/7/19 01:09, by cosa.
4842 rtl819x_signal_scale_mapping(
4848 // Step 1. Scale mapping.
4849 if(currsig >= 61 && currsig <= 100)
4851 retsig = 90 + ((currsig - 60) / 4);
4853 else if(currsig >= 41 && currsig <= 60)
4855 retsig = 78 + ((currsig - 40) / 2);
4857 else if(currsig >= 31 && currsig <= 40)
4859 retsig = 66 + (currsig - 30);
4861 else if(currsig >= 21 && currsig <= 30)
4863 retsig = 54 + (currsig - 20);
4865 else if(currsig >= 5 && currsig <= 20)
4867 retsig = 42 + (((currsig - 5) * 2) / 3);
4869 else if(currsig == 4)
4873 else if(currsig == 3)
4877 else if(currsig == 2)
4881 else if(currsig == 1)
4893 static void rtl8192_query_rxphystatus(
4894 struct r8192_priv * priv,
4895 struct ieee80211_rx_stats * pstats,
4896 rx_drvinfo_819x_usb * pdrvinfo,
4897 struct ieee80211_rx_stats * precord_stats,
4898 bool bpacket_match_bssid,
4899 bool bpacket_toself,
4904 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
4905 phy_sts_ofdm_819xusb_t* pofdm_buf;
4906 phy_sts_cck_819xusb_t * pcck_buf;
4907 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
4909 u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
4910 char rx_pwr[4], rx_pwr_all=0;
4911 //long rx_avg_pwr = 0;
4912 char rx_snrX, rx_evmX;
4914 u32 RSSI, total_rssi=0;//, total_evm=0;
4915 // long signal_strength_index = 0;
4920 priv->stats.numqry_phystatus++;
4922 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
4924 // Record it for next packet processing
4925 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
4926 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
4927 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
4928 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
4929 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
4930 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
4932 prxpkt = (u8*)pdrvinfo;
4934 /* Move pointer to the 16th bytes. Phy status start address. */
4935 prxpkt += sizeof(rx_drvinfo_819x_usb);
4937 /* Initial the cck and ofdm buffer pointer */
4938 pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
4939 pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
4941 pstats->RxMIMOSignalQuality[0] = -1;
4942 pstats->RxMIMOSignalQuality[1] = -1;
4943 precord_stats->RxMIMOSignalQuality[0] = -1;
4944 precord_stats->RxMIMOSignalQuality[1] = -1;
4949 // (1)Hardware does not provide RSSI for CCK
4953 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4955 u8 report;//, cck_agc_rpt;
4957 priv->stats.numqry_phystatusCCK++;
4959 if(!priv->bCckHighPower)
4961 report = pcck_buf->cck_agc_rpt & 0xc0;
4965 //Fixed by Jacken from Bryant 2008-03-20
4966 //Original value is -38 , -26 , -14 , -2
4967 //Fixed value is -35 , -23 , -11 , 6
4969 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
4972 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
4975 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
4978 rx_pwr_all = 6 - (pcck_buf->cck_agc_rpt & 0x3e);
4984 report = pcck_buf->cck_agc_rpt & 0x60;
4989 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
4992 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4995 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
4998 rx_pwr_all = 6 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5003 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5004 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5005 pstats->RecvSignalPower = pwdb_all;
5008 // (3) Get Signal Quality (EVM)
5010 //if(bpacket_match_bssid)
5014 if(pstats->RxPWDBAll > 40)
5019 sq = pcck_buf->sq_rpt;
5021 if(pcck_buf->sq_rpt > 64)
5023 else if (pcck_buf->sq_rpt < 20)
5026 sq = ((64-sq) * 100) / 44;
5028 pstats->SignalQuality = precord_stats->SignalQuality = sq;
5029 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5030 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5035 priv->stats.numqry_phystatusHT++;
5037 // (1)Get RSSI for HT rate
5039 for(i=RF90_PATH_A; i<priv->NumTotalRFPath; i++)
5041 // 2008/01/30 MH we will judge RF RX path now.
5042 if (priv->brfpath_rxenable[i])
5047 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
5050 //Fixed by Jacken from Bryant 2008-03-20
5051 //Original value is 106
5052 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5054 //Get Rx snr value in DB
5055 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5056 rx_snrX = (char)(tmp_rxsnr);
5059 priv->stats.rxSNRdB[i] = (long)rx_snrX;
5061 /* Translate DBM to percentage. */
5062 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5065 /* Record Signal Strength for next packet */
5066 //if(bpacket_match_bssid)
5068 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5069 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5075 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5077 //Fixed by Jacken from Bryant 2008-03-20
5078 //Original value is 106
5079 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5080 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5082 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5083 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5086 // (3)EVM of HT rate
5088 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5089 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5090 max_spatial_stream = 2; //both spatial stream make sense
5092 max_spatial_stream = 1; //only spatial stream 1 makes sense
5094 for(i=0; i<max_spatial_stream; i++)
5096 tmp_rxevm = pofdm_buf->rxevm_X[i];
5097 rx_evmX = (char)(tmp_rxevm);
5099 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5100 // fill most significant bit to "zero" when doing shifting operation which may change a negative
5101 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5104 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5105 //if(bpacket_match_bssid)
5107 if(i==0) // Fill value in RFD, Get the first spatial stream only
5108 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5109 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5114 /* record rx statistics for debug */
5115 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5116 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5117 if(pdrvinfo->BW) //40M channel
5118 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5120 priv->stats.received_bwtype[0]++;
5123 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5124 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5127 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5132 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u8)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u8)(total_rssi/=RF90_PATH_MAX);
5133 // We can judge RX path number now.
5135 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5137 } /* QueryRxPhyStatus8190Pci */
5140 rtl8192_record_rxdesc_forlateruse(
5141 struct ieee80211_rx_stats * psrc_stats,
5142 struct ieee80211_rx_stats * ptarget_stats
5145 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5146 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5147 ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5151 void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
5152 struct ieee80211_rx_stats * pstats,
5153 rx_drvinfo_819x_usb *pdrvinfo)
5155 // TODO: We must only check packet for current MAC address. Not finish
5156 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5157 struct net_device *dev=info->dev;
5158 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5159 bool bpacket_match_bssid, bpacket_toself;
5160 bool bPacketBeacon=FALSE, bToSelfBA=FALSE;
5161 static struct ieee80211_rx_stats previous_stats;
5162 struct ieee80211_hdr_3addr *hdr;//by amy
5165 // Get Signal Quality for only RX data queue (but not command queue)
5168 //u16 tmp_buf_len = 0;
5171 /* Get MAC frame start address. */
5172 tmp_buf = (u8*)skb->data;// + get_rxpacket_shiftbytes_819xusb(pstats);
5174 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5175 fc = le16_to_cpu(hdr->frame_ctl);
5176 type = WLAN_FC_GET_TYPE(fc);
5177 praddr = hdr->addr1;
5179 /* Check if the received packet is acceptabe. */
5180 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5181 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5182 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5183 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5185 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5187 bPacketBeacon = true;
5188 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5190 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5192 if((eqMacAddr(praddr,dev->dev_addr)))
5194 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5199 if(bpacket_match_bssid)
5201 priv->stats.numpacket_matchbssid++;
5204 priv->stats.numpacket_toself++;
5207 // Process PHY information for previous packet (RSSI/PWDB/EVM)
5209 // Because phy information is contained in the last packet of AMPDU only, so driver
5210 // should process phy information of previous packet
5211 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
5212 rtl8192_query_rxphystatus(priv, pstats, pdrvinfo, &previous_stats, bpacket_match_bssid,bpacket_toself,bPacketBeacon,bToSelfBA);
5213 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
5218 * Function: UpdateReceivedRateHistogramStatistics
5219 * Overview: Recored down the received data rate
5222 * struct net_device *dev
5223 * struct ieee80211_rx_stats *stats
5227 * (priv->stats.ReceivedRateHistogram[] is updated)
5232 UpdateReceivedRateHistogramStatistics8190(
5233 struct net_device *dev,
5234 struct ieee80211_rx_stats *stats
5237 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5238 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
5240 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
5245 else if(stats->bICV)
5248 if(stats->bShortPreamble)
5249 preamble_guardinterval = 1;// short
5251 preamble_guardinterval = 0;// long
5258 case MGN_1M: rateIndex = 0; break;
5259 case MGN_2M: rateIndex = 1; break;
5260 case MGN_5_5M: rateIndex = 2; break;
5261 case MGN_11M: rateIndex = 3; break;
5265 case MGN_6M: rateIndex = 4; break;
5266 case MGN_9M: rateIndex = 5; break;
5267 case MGN_12M: rateIndex = 6; break;
5268 case MGN_18M: rateIndex = 7; break;
5269 case MGN_24M: rateIndex = 8; break;
5270 case MGN_36M: rateIndex = 9; break;
5271 case MGN_48M: rateIndex = 10; break;
5272 case MGN_54M: rateIndex = 11; break;
5274 // 11n High throughput rate
5276 case MGN_MCS0: rateIndex = 12; break;
5277 case MGN_MCS1: rateIndex = 13; break;
5278 case MGN_MCS2: rateIndex = 14; break;
5279 case MGN_MCS3: rateIndex = 15; break;
5280 case MGN_MCS4: rateIndex = 16; break;
5281 case MGN_MCS5: rateIndex = 17; break;
5282 case MGN_MCS6: rateIndex = 18; break;
5283 case MGN_MCS7: rateIndex = 19; break;
5284 case MGN_MCS8: rateIndex = 20; break;
5285 case MGN_MCS9: rateIndex = 21; break;
5286 case MGN_MCS10: rateIndex = 22; break;
5287 case MGN_MCS11: rateIndex = 23; break;
5288 case MGN_MCS12: rateIndex = 24; break;
5289 case MGN_MCS13: rateIndex = 25; break;
5290 case MGN_MCS14: rateIndex = 26; break;
5291 case MGN_MCS15: rateIndex = 27; break;
5292 default: rateIndex = 28; break;
5294 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
5295 priv->stats.received_rate_histogram[0][rateIndex]++; //total
5296 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
5300 void query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe)
5302 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5303 struct net_device *dev=info->dev;
5304 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5305 //rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5306 rx_drvinfo_819x_usb *driver_info = NULL;
5309 //Get Rx Descriptor Information
5311 #ifdef USB_RX_AGGREGATION_SUPPORT
5312 if (bIsRxAggrSubframe)
5314 rx_desc_819x_usb_aggr_subframe *desc = (rx_desc_819x_usb_aggr_subframe *)skb->data;
5315 stats->Length = desc->Length ;
5316 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5317 stats->RxBufShift = 0; //RxBufShift = 2 in RxDesc, but usb didn't shift bytes in fact.
5318 stats->bICV = desc->ICV;
5319 stats->bCRC = desc->CRC32;
5320 stats->bHwError = stats->bCRC|stats->bICV;
5321 stats->Decrypted = !desc->SWDec;//RTL8190 set this bit to indicate that Hw does not decrypt packet
5325 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5327 stats->Length = desc->Length;
5328 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5329 stats->RxBufShift = 0;//desc->Shift&0x03;
5330 stats->bICV = desc->ICV;
5331 stats->bCRC = desc->CRC32;
5332 stats->bHwError = stats->bCRC|stats->bICV;
5333 //RTL8190 set this bit to indicate that Hw does not decrypt packet
5334 stats->Decrypted = !desc->SWDec;
5337 if((priv->ieee80211->pHTInfo->bCurrentHTSupport == true) && (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP))
5339 stats->bHwError = false;
5343 stats->bHwError = stats->bCRC|stats->bICV;
5346 if(stats->Length < 24 || stats->Length > MAX_8192U_RX_SIZE)
5347 stats->bHwError |= 1;
5351 // TODO: Need to verify it on FGPA platform
5352 //Driver info are written to the RxBuffer following rx desc
5353 if (stats->RxDrvInfoSize != 0) {
5354 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) + \
5358 if(!stats->bHwError){
5360 ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
5361 if(ret_rate == 0xff)
5363 // Abnormal Case: Receive CRC OK packet with Rx descriptor indicating non supported rate.
5364 // Special Error Handling here, 2008.05.16, by Emily
5366 stats->bHwError = 1;
5367 stats->rate = MGN_1M; //Set 1M rate by default
5370 stats->rate = ret_rate;
5376 stats->bShortPreamble = driver_info->SPLCP;
5379 UpdateReceivedRateHistogramStatistics8190(dev, stats);
5381 stats->bIsAMPDU = (driver_info->PartAggr==1);
5382 stats->bFirstMPDU = (driver_info->PartAggr==1) && (driver_info->FirstAGGR==1);
5383 stats->TimeStampLow = driver_info->TSFL;
5384 // xiong mask it, 070514
5385 //pRfd->Status.TimeStampHigh = PlatformEFIORead4Byte(Adapter, TSFR+4);
5386 // stats->TimeStampHigh = read_nic_dword(dev, TSFR+4);
5388 UpdateRxPktTimeStamp8190(dev, stats);
5393 if(driver_info->FirstAGGR==1 || driver_info->PartAggr == 1)
5394 RT_TRACE(COMP_RXDESC, "driver_info->FirstAGGR = %d, driver_info->PartAggr = %d\n",
5395 driver_info->FirstAGGR, driver_info->PartAggr);
5399 skb_pull(skb,sizeof(rx_desc_819x_usb));
5401 // Get Total offset of MPDU Frame Body
5403 if((stats->RxBufShift + stats->RxDrvInfoSize) > 0) {
5405 skb_pull(skb,stats->RxBufShift + stats->RxDrvInfoSize);
5408 #ifdef USB_RX_AGGREGATION_SUPPORT
5409 /* for the rx aggregated sub frame, the redundant space truelly contained in the packet */
5410 if(bIsRxAggrSubframe) {
5414 /* for debug 2008.5.29 */
5416 //added by vivi, for MP, 20080108
5417 stats->RxIs40MHzPacket = driver_info->BW;
5418 if(stats->RxDrvInfoSize != 0)
5419 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
5423 u32 GetRxPacketShiftBytes819xUsb(struct ieee80211_rx_stats *Status, bool bIsRxAggrSubframe)
5425 #ifdef USB_RX_AGGREGATION_SUPPORT
5426 if (bIsRxAggrSubframe)
5427 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5428 + Status->RxBufShift + 8);
5431 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5432 + Status->RxBufShift);
5435 void rtl8192_rx_nomal(struct sk_buff* skb)
5437 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5438 struct net_device *dev=info->dev;
5439 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5440 struct ieee80211_rx_stats stats = {
5444 // .mac_time = jiffies,
5445 .freq = IEEE80211_24GHZ_BAND,
5448 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
5449 bool unicast_packet = false;
5450 #ifdef USB_RX_AGGREGATION_SUPPORT
5451 struct sk_buff *agg_skb = NULL;
5452 u32 TotalLength = 0;
5454 u32 PacketLength = 0;
5455 u32 PacketOccupiedLendth = 0;
5457 u32 PacketShiftBytes = 0;
5458 rx_desc_819x_usb_aggr_subframe *RxDescr = NULL;
5459 u8 PaddingBytes = 0;
5460 //add just for testing
5465 /* 20 is for ps-poll */
5466 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
5467 #ifdef USB_RX_AGGREGATION_SUPPORT
5468 TempByte = *(skb->data + sizeof(rx_desc_819x_usb));
5470 /* first packet should not contain Rx aggregation header */
5471 query_rxdesc_status(skb, &stats, false);
5473 /* hardware related info */
5474 #ifdef USB_RX_AGGREGATION_SUPPORT
5475 if (TempByte & BIT0) {
5477 //TotalLength = agg_skb->len - 4; /*sCrcLng*/
5478 TotalLength = stats.Length - 4; /*sCrcLng*/
5479 //RT_TRACE(COMP_RECV, "%s:first aggregated packet!Length=%d\n",__FUNCTION__,TotalLength);
5480 /* though the head pointer has passed this position */
5481 TempDWord = *(u32 *)(agg_skb->data - 4);
5482 PacketLength = (u16)(TempDWord & 0x3FFF); /*sCrcLng*/
5483 skb = dev_alloc_skb(PacketLength);
5484 memcpy(skb_put(skb,PacketLength),agg_skb->data,PacketLength);
5485 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, false);
5488 /* Process the MPDU recevied */
5489 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5491 rx_pkt_len = skb->len;
5492 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5493 unicast_packet = false;
5494 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5496 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5499 /* unicast packet */
5500 unicast_packet = true;
5503 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5504 dev_kfree_skb_any(skb);
5506 priv->stats.rxoktotal++;
5507 if(unicast_packet) {
5508 priv->stats.rxbytesunicast += rx_pkt_len;
5511 #ifdef USB_RX_AGGREGATION_SUPPORT
5513 // (PipeIndex == 0) && (TempByte & BIT0) => TotalLength > 0.
5514 if (TotalLength > 0) {
5515 PacketOccupiedLendth = PacketLength + (PacketShiftBytes + 8);
5516 if ((PacketOccupiedLendth & 0xFF) != 0)
5517 PacketOccupiedLendth = (PacketOccupiedLendth & 0xFFFFFF00) + 256;
5518 PacketOccupiedLendth -= 8;
5519 TempDWord = PacketOccupiedLendth - PacketShiftBytes; /*- PacketLength */
5520 if (agg_skb->len > TempDWord)
5521 skb_pull(agg_skb, TempDWord);
5525 while (agg_skb->len>=GetRxPacketShiftBytes819xUsb(&stats, true)) {
5526 u8 tmpCRC = 0, tmpICV = 0;
5527 //RT_TRACE(COMP_RECV,"%s:aggred pkt,total_len = %d\n",__FUNCTION__,agg_skb->len);
5528 RxDescr = (rx_desc_819x_usb_aggr_subframe *)(agg_skb->data);
5529 tmpCRC = RxDescr->CRC32;
5530 tmpICV = RxDescr->ICV;
5531 memcpy(agg_skb->data, &agg_skb->data[44], 2);
5532 RxDescr->CRC32 = tmpCRC;
5533 RxDescr->ICV = tmpICV;
5535 memset(&stats, 0, sizeof(struct ieee80211_rx_stats));
5539 stats.freq = IEEE80211_24GHZ_BAND;
5540 query_rxdesc_status(agg_skb, &stats, true);
5541 PacketLength = stats.Length;
5543 if(PacketLength > agg_skb->len) {
5546 /* Process the MPDU recevied */
5547 skb = dev_alloc_skb(PacketLength);
5548 memcpy(skb_put(skb,PacketLength),agg_skb->data, PacketLength);
5549 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5551 rx_pkt_len = skb->len;
5552 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5553 unicast_packet = false;
5554 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5556 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5559 /* unicast packet */
5560 unicast_packet = true;
5562 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5563 dev_kfree_skb_any(skb);
5565 priv->stats.rxoktotal++;
5566 if(unicast_packet) {
5567 priv->stats.rxbytesunicast += rx_pkt_len;
5570 /* should trim the packet which has been copied to target skb */
5571 skb_pull(agg_skb, PacketLength);
5572 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, true);
5573 PacketOccupiedLendth = PacketLength + PacketShiftBytes;
5574 if ((PacketOccupiedLendth & 0xFF) != 0) {
5575 PaddingBytes = 256 - (PacketOccupiedLendth & 0xFF);
5576 if (agg_skb->len > PaddingBytes)
5577 skb_pull(agg_skb, PaddingBytes);
5582 dev_kfree_skb(agg_skb);
5586 priv->stats.rxurberr++;
5587 printk("actual_length:%d\n", skb->len);
5588 dev_kfree_skb_any(skb);
5594 rtl819xusb_process_received_packet(
5595 struct net_device *dev,
5596 struct ieee80211_rx_stats *pstats
5599 // bool bfreerfd=false, bqueued=false;
5602 struct r8192_priv *priv = ieee80211_priv(dev);
5606 //PRX_TS_RECORD pts = NULL;
5608 // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
5609 //porting by amy 080508
5610 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
5611 frame = pstats->virtual_address;
5612 frame_len = pstats->packetlength;
5613 #ifdef TODO // by amy about HCT
5614 if(!Adapter->bInHctTest)
5615 CountRxErrStatistics(Adapter, pRfd);
5618 #ifdef ENABLE_PS //by amy for adding ps function in future
5619 RT_RF_POWER_STATE rtState;
5620 // When RF is off, we should not count the packet for hw/sw synchronize
5621 // reason, ie. there may be a duration while sw switch is changed and hw
5622 // switch is being changed. 2006.12.04, by shien chang.
5623 Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8* )(&rtState));
5624 if (rtState == eRfOff)
5629 priv->stats.rxframgment++;
5633 RmMonitorSignalStrength(Adapter, pRfd);
5635 /* 2007/01/16 MH Add RX command packet handle here. */
5636 /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
5637 if (rtl819xusb_rx_command_packet(dev, pstats))
5649 void query_rx_cmdpkt_desc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats)
5651 // rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5652 // struct net_device *dev=info->dev;
5653 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5654 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5655 // rx_drvinfo_819x_usb *driver_info;
5658 //Get Rx Descriptor Information
5660 stats->virtual_address = (u8*)skb->data;
5661 stats->Length = desc->Length;
5662 stats->RxDrvInfoSize = 0;
5663 stats->RxBufShift = 0;
5664 stats->packetlength = stats->Length-scrclng;
5665 stats->fraglength = stats->packetlength;
5666 stats->fragoffset = 0;
5667 stats->ntotalfrag = 1;
5671 void rtl8192_rx_cmd(struct sk_buff *skb)
5673 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5674 struct net_device *dev = info->dev;
5676 // struct urb *rx_urb = info->urb;
5678 struct ieee80211_rx_stats stats = {
5682 // .mac_time = jiffies,
5683 .freq = IEEE80211_24GHZ_BAND,
5686 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE))
5689 query_rx_cmdpkt_desc_status(skb,&stats);
5690 // this is to be done by amy 080508 prfd->queue_id = 1;
5694 // Process the command packet received.
5697 rtl819xusb_process_received_packet(dev,&stats);
5699 dev_kfree_skb_any(skb);
5707 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
5709 struct sk_buff *skb;
5710 struct rtl8192_rx_info *info;
5712 while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
5713 info = (struct rtl8192_rx_info *)skb->cb;
5714 switch (info->out_pipe) {
5715 /* Nomal packet pipe */
5717 //RT_TRACE(COMP_RECV, "normal in-pipe index(%d)\n",info->out_pipe);
5718 priv->IrpPendingCount--;
5719 rtl8192_rx_nomal(skb);
5722 /* Command packet pipe */
5724 RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",\
5727 rtl8192_rx_cmd(skb);
5730 default: /* should never get here! */
5731 RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",\
5740 static const struct net_device_ops rtl8192_netdev_ops = {
5741 .ndo_open = rtl8192_open,
5742 .ndo_stop = rtl8192_close,
5743 .ndo_get_stats = rtl8192_stats,
5744 .ndo_tx_timeout = tx_timeout,
5745 .ndo_do_ioctl = rtl8192_ioctl,
5746 .ndo_set_multicast_list = r8192_set_multicast,
5747 .ndo_set_mac_address = r8192_set_mac_adr,
5748 .ndo_validate_addr = eth_validate_addr,
5749 .ndo_change_mtu = eth_change_mtu,
5750 .ndo_start_xmit = ieee80211_xmit,
5754 /****************************************************************************
5755 ---------------------------- USB_STUFF---------------------------
5756 *****************************************************************************/
5758 static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
5759 const struct usb_device_id *id)
5761 // unsigned long ioaddr = 0;
5762 struct net_device *dev = NULL;
5763 struct r8192_priv *priv= NULL;
5764 struct usb_device *udev = interface_to_usbdev(intf);
5766 RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
5768 dev = alloc_ieee80211(sizeof(struct r8192_priv));
5772 usb_set_intfdata(intf, dev);
5773 SET_NETDEV_DEV(dev, &intf->dev);
5774 priv = ieee80211_priv(dev);
5775 priv->ieee80211 = netdev_priv(dev);
5778 dev->netdev_ops = &rtl8192_netdev_ops;
5780 //DMESG("Oops: i'm coming\n");
5781 #if WIRELESS_EXT >= 12
5782 #if WIRELESS_EXT < 17
5783 dev->get_wireless_stats = r8192_get_wireless_stats;
5785 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
5787 dev->type=ARPHRD_ETHER;
5789 dev->watchdog_timeo = HZ*3; //modified by john, 0805
5791 if (dev_alloc_name(dev, ifname) < 0){
5792 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
5794 dev_alloc_name(dev, ifname);
5797 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
5798 if(rtl8192_init(dev)!=0){
5799 RT_TRACE(COMP_ERR, "Initialization failed");
5803 netif_carrier_off(dev);
5804 netif_stop_queue(dev);
5806 ret = register_netdev(dev);
5810 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
5811 rtl8192_proc_init_one(dev);
5814 RT_TRACE(COMP_INIT, "Driver probe completed\n");
5819 kfree(priv->pFirmware);
5820 priv->pFirmware = NULL;
5821 rtl8192_usb_deleteendpoints(dev);
5822 destroy_workqueue(priv->priv_wq);
5825 free_ieee80211(dev);
5827 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
5831 //detach all the work and timer structure declared or inititialize in r8192U_init function.
5832 void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
5835 cancel_work_sync(&priv->reset_wq);
5836 cancel_delayed_work(&priv->watch_dog_wq);
5837 cancel_delayed_work(&priv->update_beacon_wq);
5838 cancel_work_sync(&priv->qos_activate);
5839 //cancel_work_sync(&priv->SetBWModeWorkItem);
5840 //cancel_work_sync(&priv->SwChnlWorkItem);
5845 static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf)
5847 struct net_device *dev = usb_get_intfdata(intf);
5849 struct r8192_priv *priv = ieee80211_priv(dev);
5852 unregister_netdev(dev);
5854 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
5855 rtl8192_proc_remove_one(dev);
5858 kfree(priv->pFirmware);
5859 priv->pFirmware = NULL;
5860 // priv->rf_close(dev);
5861 // rtl8192_SetRFPowerState(dev, eRfOff);
5862 rtl8192_usb_deleteendpoints(dev);
5863 destroy_workqueue(priv->priv_wq);
5864 //rtl8192_irq_disable(dev);
5865 //rtl8192_reset(dev);
5869 free_ieee80211(dev);
5870 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
5873 /* fun with the built-in ieee80211 stack... */
5874 extern int ieee80211_debug_init(void);
5875 extern void ieee80211_debug_exit(void);
5876 extern int ieee80211_crypto_init(void);
5877 extern void ieee80211_crypto_deinit(void);
5878 extern int ieee80211_crypto_tkip_init(void);
5879 extern void ieee80211_crypto_tkip_exit(void);
5880 extern int ieee80211_crypto_ccmp_init(void);
5881 extern void ieee80211_crypto_ccmp_exit(void);
5882 extern int ieee80211_crypto_wep_init(void);
5883 extern void ieee80211_crypto_wep_exit(void);
5885 static int __init rtl8192_usb_module_init(void)
5889 #ifdef CONFIG_IEEE80211_DEBUG
5890 ret = ieee80211_debug_init();
5892 printk(KERN_ERR "ieee80211_debug_init() failed %d\n", ret);
5896 ret = ieee80211_crypto_init();
5898 printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
5902 ret = ieee80211_crypto_tkip_init();
5904 printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n",
5909 ret = ieee80211_crypto_ccmp_init();
5911 printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n",
5916 ret = ieee80211_crypto_wep_init();
5918 printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
5922 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
5923 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
5924 RT_TRACE(COMP_INIT, "Initializing module");
5925 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
5926 rtl8192_proc_module_init();
5927 return usb_register(&rtl8192_usb_driver);
5931 static void __exit rtl8192_usb_module_exit(void)
5933 usb_deregister(&rtl8192_usb_driver);
5935 RT_TRACE(COMP_DOWN, "Exiting");
5936 // rtl8192_proc_module_remove();
5940 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
5942 unsigned long flags;
5944 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5946 spin_lock_irqsave(&priv->tx_lock,flags);
5947 enough_desc = check_nic_enough_desc(dev,pri);
5948 spin_unlock_irqrestore(&priv->tx_lock,flags);
5951 ieee80211_wake_queue(priv->ieee80211);
5954 void EnableHWSecurityConfig8192(struct net_device *dev)
5956 u8 SECR_value = 0x0;
5957 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5958 struct ieee80211_device* ieee = priv->ieee80211;
5959 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
5960 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
5962 SECR_value |= SCR_RxUseDK;
5963 SECR_value |= SCR_TxUseDK;
5965 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
5967 SECR_value |= SCR_RxUseDK;
5968 SECR_value |= SCR_TxUseDK;
5970 //add HWSec active enable here.
5971 //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
5973 ieee->hwsec_active = 1;
5975 if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep)//!ieee->hwsec_support) //add hwsec_support flag to totol control hw_sec on/off
5977 ieee->hwsec_active = 0;
5978 SECR_value &= ~SCR_RxDecEnable;
5980 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__, \
5981 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
5983 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
5988 void setKey( struct net_device *dev,
5996 u32 TargetCommand = 0;
5997 u32 TargetContent = 0;
6000 if (EntryNo >= TOTAL_CAM_ENTRY)
6001 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
6003 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
6006 usConfig |= BIT15 | (KeyType<<2);
6008 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
6009 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
6012 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
6013 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
6014 TargetCommand |= BIT31|BIT16;
6016 if(i==0){//MAC|Config
6017 TargetContent = (u32)(*(MacAddr+0)) << 16|
6018 (u32)(*(MacAddr+1)) << 24|
6021 write_nic_dword(dev, WCAMI, TargetContent);
6022 write_nic_dword(dev, RWCAM, TargetCommand);
6023 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6026 TargetContent = (u32)(*(MacAddr+2)) |
6027 (u32)(*(MacAddr+3)) << 8|
6028 (u32)(*(MacAddr+4)) << 16|
6029 (u32)(*(MacAddr+5)) << 24;
6030 write_nic_dword(dev, WCAMI, TargetContent);
6031 write_nic_dword(dev, RWCAM, TargetCommand);
6035 if(KeyContent !=NULL){
6036 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6037 write_nic_dword(dev, RWCAM, TargetCommand);
6044 /***************************************************************************
6045 ------------------- module init / exit stubs ----------------
6046 ****************************************************************************/
6047 module_init(rtl8192_usb_module_init);
6048 module_exit(rtl8192_usb_module_exit);