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, 0x8709)},
110 {USB_DEVICE(0x07aa, 0x0043)},
112 {USB_DEVICE(0x050d, 0x805E)},
114 {USB_DEVICE(0x0df6, 0x0031)},
116 {USB_DEVICE(0x1740, 0x9201)},
118 {USB_DEVICE(0x2001, 0x3301)},
120 {USB_DEVICE(0x5a57, 0x0290)},
122 {USB_DEVICE(0x043e, 0x7a01)},
126 MODULE_LICENSE("GPL");
127 MODULE_VERSION("V 1.1");
128 MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
129 MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
131 static char* ifname = "wlan%d";
132 static int hwwep = 1; //default use hw. set 0 to use software security
133 static int channels = 0x3fff;
137 module_param(ifname, charp, S_IRUGO|S_IWUSR );
138 //module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
139 module_param(hwwep,int, S_IRUGO|S_IWUSR);
140 module_param(channels,int, S_IRUGO|S_IWUSR);
142 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
143 //MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
144 MODULE_PARM_DESC(hwwep," Try to use hardware security support. ");
145 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
147 static int rtl8192_usb_probe(struct usb_interface *intf,
148 const struct usb_device_id *id);
149 static void rtl8192_usb_disconnect(struct usb_interface *intf);
152 static struct usb_driver rtl8192_usb_driver = {
153 .name = RTL819xU_MODULE_NAME, /* Driver name */
154 .id_table = rtl8192_usb_id_tbl, /* PCI_ID table */
155 .probe = rtl8192_usb_probe, /* probe fn */
156 .disconnect = rtl8192_usb_disconnect, /* remove fn */
157 #ifdef CONFIG_RTL8192_PM
158 .suspend = rtl8192_suspend, /* PM suspend fn */
159 .resume = rtl8192_resume, /* PM resume fn */
161 .suspend = NULL, /* PM suspend fn */
162 .resume = NULL, /* PM resume fn */
167 typedef struct _CHANNEL_LIST
171 }CHANNEL_LIST, *PCHANNEL_LIST;
173 static CHANNEL_LIST ChannelPlan[] = {
174 {{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
175 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
176 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
179 {{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
180 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
182 {{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
183 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
184 {{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
187 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
189 int i, max_chan=-1, min_chan=-1;
190 struct ieee80211_device* ieee = priv->ieee80211;
191 switch (channel_plan)
193 case COUNTRY_CODE_FCC:
194 case COUNTRY_CODE_IC:
195 case COUNTRY_CODE_ETSI:
196 case COUNTRY_CODE_SPAIN:
197 case COUNTRY_CODE_FRANCE:
198 case COUNTRY_CODE_MKK:
199 case COUNTRY_CODE_MKK1:
200 case COUNTRY_CODE_ISRAEL:
201 case COUNTRY_CODE_TELEC:
202 case COUNTRY_CODE_MIC:
205 ieee->bGlobalDomain = false;
206 //actually 8225 & 8256 rf chips only support B,G,24N mode
207 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256))
214 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
216 if (ChannelPlan[channel_plan].Len != 0){
217 // Clear old channel map
218 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
219 // Set new channel map
220 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
222 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
224 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
229 case COUNTRY_CODE_GLOBAL_DOMAIN:
231 GET_DOT11D_INFO(ieee)->bEnabled = 0;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
233 ieee->bGlobalDomain = true;
243 #define rx_hal_is_cck_rate(_pdrvinfo)\
244 (_pdrvinfo->RxRate == DESC90_RATE1M ||\
245 _pdrvinfo->RxRate == DESC90_RATE2M ||\
246 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
247 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
251 void CamResetAllEntry(struct net_device *dev)
254 //2004/02/11 In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
255 // However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
256 // In this condition, Cam can not be reset because upper layer will not set this static key again.
257 //if(Adapter->EncAlgorithm == WEP_Encryption)
260 //DbgPrint("========================================\n");
261 //DbgPrint(" Call ResetAllEntry \n");
262 //DbgPrint("========================================\n\n");
263 ulcommand |= BIT31|BIT30;
264 write_nic_dword(dev, RWCAM, ulcommand);
269 void write_cam(struct net_device *dev, u8 addr, u32 data)
271 write_nic_dword(dev, WCAMI, data);
272 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
275 u32 read_cam(struct net_device *dev, u8 addr)
277 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
278 return read_nic_dword(dev, 0xa8);
281 void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
284 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
285 struct usb_device *udev = priv->udev;
287 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
288 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
289 indx|0xfe00, 0, &data, 1, HZ / 2);
293 printk("write_nic_byte_E TimeOut! status:%d\n", status);
297 u8 read_nic_byte_E(struct net_device *dev, int indx)
301 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
302 struct usb_device *udev = priv->udev;
304 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
305 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
306 indx|0xfe00, 0, &data, 1, HZ / 2);
310 printk("read_nic_byte_E TimeOut! status:%d\n", status);
315 //as 92U has extend page from 4 to 16, so modify functions below.
316 void write_nic_byte(struct net_device *dev, int indx, u8 data)
320 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
321 struct usb_device *udev = priv->udev;
323 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
324 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
325 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
329 printk("write_nic_byte TimeOut! status:%d\n", status);
336 void write_nic_word(struct net_device *dev, int indx, u16 data)
341 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
342 struct usb_device *udev = priv->udev;
344 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
345 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
346 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 2, HZ / 2);
350 printk("write_nic_word TimeOut! status:%d\n", status);
356 void write_nic_dword(struct net_device *dev, int indx, u32 data)
361 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
362 struct usb_device *udev = priv->udev;
364 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
365 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
366 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 4, HZ / 2);
371 printk("write_nic_dword TimeOut! status:%d\n", status);
378 u8 read_nic_byte(struct net_device *dev, int indx)
382 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
383 struct usb_device *udev = priv->udev;
385 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
386 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
387 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
391 printk("read_nic_byte TimeOut! status:%d\n", status);
399 u16 read_nic_word(struct net_device *dev, int indx)
403 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
404 struct usb_device *udev = priv->udev;
406 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
407 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
408 (indx&0xff)|0xff00, (indx>>8)&0x0f,
412 printk("read_nic_word TimeOut! status:%d\n", status);
417 u16 read_nic_word_E(struct net_device *dev, int indx)
421 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
422 struct usb_device *udev = priv->udev;
424 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
425 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
426 indx|0xfe00, 0, &data, 2, HZ / 2);
429 printk("read_nic_word TimeOut! status:%d\n", status);
434 u32 read_nic_dword(struct net_device *dev, int indx)
440 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
441 struct usb_device *udev = priv->udev;
443 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
444 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
445 (indx&0xff)|0xff00, (indx>>8)&0x0f,
448 * printk(KERN_WARNING "read size of data = %d\, date = %d\n",
454 printk("read_nic_dword TimeOut! status:%d\n", status);
459 /* u8 read_phy_cck(struct net_device *dev, u8 adr); */
460 /* u8 read_phy_ofdm(struct net_device *dev, u8 adr); */
461 /* this might still called in what was the PHY rtl8185/rtl8192 common code
462 * plans are to possibility turn it again in one common code...
464 inline void force_pci_posting(struct net_device *dev)
468 static struct net_device_stats *rtl8192_stats(struct net_device *dev);
469 void rtl8192_commit(struct net_device *dev);
470 /* void rtl8192_restart(struct net_device *dev); */
471 void rtl8192_restart(struct work_struct *work);
472 /* void rtl8192_rq_tx_ack(struct work_struct *work); */
473 void watch_dog_timer_callback(unsigned long data);
475 /****************************************************************************
476 * -----------------------------PROCFS STUFF-------------------------
477 *****************************************************************************
480 static struct proc_dir_entry *rtl8192_proc;
482 static int proc_get_stats_ap(char *page, char **start, off_t offset, int count,
483 int *eof, void *data)
485 struct net_device *dev = data;
486 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
487 struct ieee80211_device *ieee = priv->ieee80211;
488 struct ieee80211_network *target;
492 list_for_each_entry(target, &ieee->network_list, list) {
494 len += snprintf(page + len, count - len, "%s ", target->ssid);
496 if (target->wpa_ie_len > 0 || target->rsn_ie_len > 0)
497 len += snprintf(page + len, count - len, "WPA\n");
499 len += snprintf(page + len, count - len, "non_WPA\n");
506 static int proc_get_registers(char *page, char **start,
507 off_t offset, int count,
508 int *eof, void *data)
510 struct net_device *dev = data;
511 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
518 /* This dump the current register page */
519 len += snprintf(page + len, count - len,
520 "\n####################page 0##################\n ");
524 //printk( "\nD: %2x> ", n);
525 len += snprintf(page + len, count - len,
528 for(i=0;i<16 && n<=max;i++,n++)
529 len += snprintf(page + len, count - len,
530 "%2x ",read_nic_byte(dev,0x000|n));
532 // printk("%2x ",read_nic_byte(dev,n));
534 len += snprintf(page + len, count - len,
535 "\n####################page 1##################\n ");
538 //printk( "\nD: %2x> ", n);
539 len += snprintf(page + len, count - len,
542 for(i=0;i<16 && n<=max;i++,n++)
543 len += snprintf(page + len, count - len,
544 "%2x ",read_nic_byte(dev,0x100|n));
546 // printk("%2x ",read_nic_byte(dev,n));
548 len += snprintf(page + len, count - len,
549 "\n####################page 3##################\n ");
552 //printk( "\nD: %2x> ", n);
553 len += snprintf(page + len, count - len,
556 for(i=0;i<16 && n<=max;i++,n++)
557 len += snprintf(page + len, count - len,
558 "%2x ",read_nic_byte(dev,0x300|n));
560 // printk("%2x ",read_nic_byte(dev,n));
564 len += snprintf(page + len, count - len,"\n");
574 static int proc_get_stats_tx(char *page, char **start,
575 off_t offset, int count,
576 int *eof, void *data)
578 struct net_device *dev = data;
579 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
583 len += snprintf(page + len, count - len,
584 "TX VI priority ok int: %lu\n"
585 "TX VI priority error int: %lu\n"
586 "TX VO priority ok int: %lu\n"
587 "TX VO priority error int: %lu\n"
588 "TX BE priority ok int: %lu\n"
589 "TX BE priority error int: %lu\n"
590 "TX BK priority ok int: %lu\n"
591 "TX BK priority error int: %lu\n"
592 "TX MANAGE priority ok int: %lu\n"
593 "TX MANAGE priority error int: %lu\n"
594 "TX BEACON priority ok int: %lu\n"
595 "TX BEACON priority error int: %lu\n"
596 // "TX high priority ok int: %lu\n"
597 // "TX high priority failed error int: %lu\n"
598 "TX queue resume: %lu\n"
599 "TX queue stopped?: %d\n"
600 "TX fifo overflow: %lu\n"
601 // "TX beacon: %lu\n"
606 // "TX HW queue: %d\n"
607 "TX VI dropped: %lu\n"
608 "TX VO dropped: %lu\n"
609 "TX BE dropped: %lu\n"
610 "TX BK dropped: %lu\n"
611 "TX total data packets %lu\n",
612 // "TX beacon aborted: %lu\n",
613 priv->stats.txviokint,
615 priv->stats.txvookint,
617 priv->stats.txbeokint,
619 priv->stats.txbkokint,
621 priv->stats.txmanageokint,
622 priv->stats.txmanageerr,
623 priv->stats.txbeaconokint,
624 priv->stats.txbeaconerr,
625 // priv->stats.txhpokint,
626 // priv->stats.txhperr,
627 priv->stats.txresumed,
628 netif_queue_stopped(dev),
629 priv->stats.txoverflow,
630 // priv->stats.txbeacon,
631 atomic_read(&(priv->tx_pending[VI_PRIORITY])),
632 atomic_read(&(priv->tx_pending[VO_PRIORITY])),
633 atomic_read(&(priv->tx_pending[BE_PRIORITY])),
634 atomic_read(&(priv->tx_pending[BK_PRIORITY])),
635 // read_nic_byte(dev, TXFIFOCOUNT),
636 priv->stats.txvidrop,
637 priv->stats.txvodrop,
638 priv->stats.txbedrop,
639 priv->stats.txbkdrop,
640 priv->stats.txdatapkt
641 // priv->stats.txbeaconerr
650 static int proc_get_stats_rx(char *page, char **start,
651 off_t offset, int count,
652 int *eof, void *data)
654 struct net_device *dev = data;
655 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
659 len += snprintf(page + len, count - len,
661 "RX urb status error: %lu\n"
662 "RX invalid urb error: %lu\n",
663 priv->stats.rxoktotal,
664 priv->stats.rxstaterr,
665 priv->stats.rxurberr);
670 void rtl8192_proc_module_init(void)
672 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
673 rtl8192_proc = proc_mkdir(RTL819xU_MODULE_NAME, init_net.proc_net);
677 void rtl8192_proc_module_remove(void)
679 remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
683 void rtl8192_proc_remove_one(struct net_device *dev)
685 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
689 // remove_proc_entry("stats-hw", priv->dir_dev);
690 remove_proc_entry("stats-tx", priv->dir_dev);
691 remove_proc_entry("stats-rx", priv->dir_dev);
692 // remove_proc_entry("stats-ieee", priv->dir_dev);
693 remove_proc_entry("stats-ap", priv->dir_dev);
694 remove_proc_entry("registers", priv->dir_dev);
695 // remove_proc_entry("cck-registers",priv->dir_dev);
696 // remove_proc_entry("ofdm-registers",priv->dir_dev);
697 //remove_proc_entry(dev->name, rtl8192_proc);
698 remove_proc_entry("wlan0", rtl8192_proc);
699 priv->dir_dev = NULL;
704 void rtl8192_proc_init_one(struct net_device *dev)
706 struct proc_dir_entry *e;
707 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
708 priv->dir_dev = proc_mkdir(dev->name, rtl8192_proc);
709 if (!priv->dir_dev) {
710 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
714 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
715 priv->dir_dev, proc_get_stats_rx, dev);
718 RT_TRACE(COMP_ERR,"Unable to initialize "
719 "/proc/net/rtl8192/%s/stats-rx\n",
724 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
725 priv->dir_dev, proc_get_stats_tx, dev);
728 RT_TRACE(COMP_ERR, "Unable to initialize "
729 "/proc/net/rtl8192/%s/stats-tx\n",
733 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
734 priv->dir_dev, proc_get_stats_ap, dev);
737 RT_TRACE(COMP_ERR, "Unable to initialize "
738 "/proc/net/rtl8192/%s/stats-ap\n",
742 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
743 priv->dir_dev, proc_get_registers, dev);
745 RT_TRACE(COMP_ERR, "Unable to initialize "
746 "/proc/net/rtl8192/%s/registers\n",
750 /****************************************************************************
751 -----------------------------MISC STUFF-------------------------
752 *****************************************************************************/
754 /* this is only for debugging */
755 void print_buffer(u32 *buffer, int len)
758 u8 *buf =(u8*)buffer;
760 printk("ASCII BUFFER DUMP (len: %x):\n",len);
765 printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
773 //short check_nic_enough_desc(struct net_device *dev, priority_t priority)
774 short check_nic_enough_desc(struct net_device *dev,int queue_index)
776 struct r8192_priv *priv = ieee80211_priv(dev);
777 int used = atomic_read(&priv->tx_pending[queue_index]);
779 return (used < MAX_TX_URB);
782 void tx_timeout(struct net_device *dev)
784 struct r8192_priv *priv = ieee80211_priv(dev);
785 //rtl8192_commit(dev);
787 schedule_work(&priv->reset_wq);
788 //DMESG("TXTIMEOUT");
792 /* this is only for debug */
793 void dump_eprom(struct net_device *dev)
797 RT_TRACE(COMP_EPROM, "EEPROM addr %x : %x", i, eprom_read(dev,i));
800 /* this is only for debug */
801 void rtl8192_dump_reg(struct net_device *dev)
807 RT_TRACE(COMP_PHY, "Dumping NIC register map");
811 printk( "\nD: %2x> ", n);
812 for(i=0;i<16 && n<=max;i++,n++)
813 printk("%2x ",read_nic_byte(dev,n));
818 /****************************************************************************
819 ------------------------------HW STUFF---------------------------
820 *****************************************************************************/
823 void rtl8192_set_mode(struct net_device *dev,int mode)
826 ecmd=read_nic_byte(dev, EPROM_CMD);
827 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
828 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
829 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
830 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
831 write_nic_byte(dev, EPROM_CMD, ecmd);
835 void rtl8192_update_msr(struct net_device *dev)
837 struct r8192_priv *priv = ieee80211_priv(dev);
840 msr = read_nic_byte(dev, MSR);
841 msr &= ~ MSR_LINK_MASK;
843 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
844 * msr must be updated if the state is ASSOCIATING.
845 * this is intentional and make sense for ad-hoc and
846 * master (see the create BSS/IBSS func)
848 if (priv->ieee80211->state == IEEE80211_LINKED){
850 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
851 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
852 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
853 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
854 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
855 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
858 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
860 write_nic_byte(dev, MSR, msr);
863 void rtl8192_set_chan(struct net_device *dev,short ch)
865 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
867 RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
870 /* this hack should avoid frame TX during channel setting*/
873 // tx = read_nic_dword(dev,TX_CONF);
874 // tx &= ~TX_LOOPBACK_MASK;
877 // write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
879 //need to implement rf set channel here WB
881 if (priv->rf_set_chan)
882 priv->rf_set_chan(dev,priv->chan);
884 // write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
888 static void rtl8192_rx_isr(struct urb *urb);
889 //static void rtl8192_rx_isr(struct urb *rx_urb);
891 u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
894 #ifdef USB_RX_AGGREGATION_SUPPORT
895 if (pstats->bisrxaggrsubframe)
896 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
897 + pstats->RxBufShift + 8);
900 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
901 + pstats->RxBufShift);
904 static int rtl8192_rx_initiate(struct net_device*dev)
906 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
909 struct rtl8192_rx_info *info;
911 /* nomal packet rx procedure */
912 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
913 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
916 entry = usb_alloc_urb(0, GFP_KERNEL);
921 // printk("nomal packet IN request!\n");
922 usb_fill_bulk_urb(entry, priv->udev,
923 usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
924 RX_URB_SIZE, rtl8192_rx_isr, skb);
925 info = (struct rtl8192_rx_info *) skb->cb;
928 info->out_pipe = 3; //denote rx normal packet queue
929 skb_queue_tail(&priv->rx_queue, skb);
930 usb_submit_urb(entry, GFP_KERNEL);
933 /* command packet rx procedure */
934 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
935 // printk("command packet IN request!\n");
936 skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL);
939 entry = usb_alloc_urb(0, GFP_KERNEL);
944 usb_fill_bulk_urb(entry, priv->udev,
945 usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
946 RX_URB_SIZE, rtl8192_rx_isr, skb);
947 info = (struct rtl8192_rx_info *) skb->cb;
950 info->out_pipe = 9; //denote rx cmd packet queue
951 skb_queue_tail(&priv->rx_queue, skb);
952 usb_submit_urb(entry, GFP_KERNEL);
958 void rtl8192_set_rxconf(struct net_device *dev)
960 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
963 rxconf=read_nic_dword(dev,RCR);
964 rxconf = rxconf &~ MAC_FILTER_MASK;
965 rxconf = rxconf | RCR_AMF;
966 rxconf = rxconf | RCR_ADF;
967 rxconf = rxconf | RCR_AB;
968 rxconf = rxconf | RCR_AM;
969 //rxconf = rxconf | RCR_ACF;
971 if (dev->flags & IFF_PROMISC) {DMESG ("NIC in promisc mode");}
973 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
974 dev->flags & IFF_PROMISC){
975 rxconf = rxconf | RCR_AAP;
976 } /*else if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
977 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
978 rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
980 rxconf = rxconf | RCR_APM;
981 rxconf = rxconf | RCR_CBSSID;
985 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
986 rxconf = rxconf | RCR_AICV;
987 rxconf = rxconf | RCR_APWRMGT;
990 if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
991 rxconf = rxconf | RCR_ACRC32;
994 rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
995 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
996 rxconf = rxconf &~ MAX_RX_DMA_MASK;
997 rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
999 // rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
1000 rxconf = rxconf | RCR_ONLYERLPKT;
1002 // rxconf = rxconf &~ RCR_CS_MASK;
1003 // rxconf = rxconf | (1<<RCR_CS_SHIFT);
1005 write_nic_dword(dev, RCR, rxconf);
1008 DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RCR));
1011 //wait to be removed
1012 void rtl8192_rx_enable(struct net_device *dev)
1016 //struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1018 rtl8192_rx_initiate(dev);
1020 // rtl8192_set_rxconf(dev);
1024 void rtl8192_tx_enable(struct net_device *dev)
1030 void rtl8192_rtx_disable(struct net_device *dev)
1033 struct r8192_priv *priv = ieee80211_priv(dev);
1034 struct sk_buff *skb;
1035 struct rtl8192_rx_info *info;
1037 cmd=read_nic_byte(dev,CMDR);
1038 write_nic_byte(dev, CMDR, cmd &~ \
1040 force_pci_posting(dev);
1043 while ((skb = __skb_dequeue(&priv->rx_queue))) {
1044 info = (struct rtl8192_rx_info *) skb->cb;
1048 usb_kill_urb(info->urb);
1052 if (skb_queue_len(&priv->skb_queue)) {
1053 printk(KERN_WARNING "skb_queue not empty\n");
1056 skb_queue_purge(&priv->skb_queue);
1061 int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
1066 inline u16 ieeerate2rtlrate(int rate)
1098 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
1099 inline u16 rtl8192_rate2rate(short rate)
1101 if (rate >11) return 0;
1102 return rtl_rate[rate];
1106 /* The prototype of rx_isr has changed since one version of Linux Kernel */
1107 static void rtl8192_rx_isr(struct urb *urb)
1109 struct sk_buff *skb = (struct sk_buff *) urb->context;
1110 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
1111 struct net_device *dev = info->dev;
1112 struct r8192_priv *priv = ieee80211_priv(dev);
1113 int out_pipe = info->out_pipe;
1117 if (unlikely(urb->status)) {
1119 priv->stats.rxstaterr++;
1120 priv->ieee80211->stats.rx_errors++;
1122 // printk("%s():rx status err\n",__FUNCTION__);
1125 skb_unlink(skb, &priv->rx_queue);
1126 skb_put(skb, urb->actual_length);
1128 skb_queue_tail(&priv->skb_queue, skb);
1129 tasklet_schedule(&priv->irq_rx_tasklet);
1131 skb = dev_alloc_skb(RX_URB_SIZE);
1132 if (unlikely(!skb)) {
1134 printk("%s():can,t alloc skb\n",__FUNCTION__);
1135 /* TODO check rx queue length and refill *somewhere* */
1139 usb_fill_bulk_urb(urb, priv->udev,
1140 usb_rcvbulkpipe(priv->udev, out_pipe), skb_tail_pointer(skb),
1141 RX_URB_SIZE, rtl8192_rx_isr, skb);
1143 info = (struct rtl8192_rx_info *) skb->cb;
1146 info->out_pipe = out_pipe;
1148 urb->transfer_buffer = skb_tail_pointer(skb);
1150 skb_queue_tail(&priv->rx_queue, skb);
1151 err = usb_submit_urb(urb, GFP_ATOMIC);
1152 if(err && err != EPERM)
1153 printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
1157 rtl819xusb_rx_command_packet(
1158 struct net_device *dev,
1159 struct ieee80211_rx_stats *pstats
1164 //RT_TRACE(COMP_RECV, DBG_TRACE, ("---> RxCommandPacketHandle819xUsb()\n"));
1166 status = cmpk_message_handle_rx(dev, pstats);
1169 DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
1173 //RT_TRACE(COMP_RECV, DBG_TRACE, ("RxCommandPacketHandle819xUsb: It is not a command packet\n"));
1176 //RT_TRACE(COMP_RECV, DBG_TRACE, ("<--- RxCommandPacketHandle819xUsb()\n"));
1181 void rtl8192_data_hard_stop(struct net_device *dev)
1187 void rtl8192_data_hard_resume(struct net_device *dev)
1192 /* this function TX data frames when the ieee80211 stack requires this.
1193 * It checks also if we need to stop the ieee tx queue, eventually do it
1195 void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
1197 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1199 unsigned long flags;
1200 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1201 u8 queue_index = tcb_desc->queue_index;
1203 /* shall not be referred by command packet */
1204 assert(queue_index != TXCMD_QUEUE);
1206 spin_lock_irqsave(&priv->tx_lock,flags);
1208 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1209 // tcb_desc->RATRIndex = 7;
1210 // tcb_desc->bTxDisableRateFallBack = 1;
1211 // tcb_desc->bTxUseDriverAssingedRate = 1;
1212 tcb_desc->bTxEnableFwCalcDur = 1;
1213 skb_push(skb, priv->ieee80211->tx_headroom);
1214 ret = rtl8192_tx(dev, skb);
1216 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1217 //priv->ieee80211->stats.tx_packets++;
1219 spin_unlock_irqrestore(&priv->tx_lock,flags);
1225 /* This is a rough attempt to TX a frame
1226 * This is called by the ieee 80211 stack to TX management frames.
1227 * If the ring is full packet are dropped (for data frame the queue
1228 * is stopped before this can happen).
1230 int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1232 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1234 unsigned long flags;
1235 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1236 u8 queue_index = tcb_desc->queue_index;
1239 spin_lock_irqsave(&priv->tx_lock,flags);
1241 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1242 if(queue_index == TXCMD_QUEUE) {
1243 skb_push(skb, USB_HWDESC_HEADER_LEN);
1244 rtl819xU_tx_cmd(dev, skb);
1246 spin_unlock_irqrestore(&priv->tx_lock,flags);
1249 skb_push(skb, priv->ieee80211->tx_headroom);
1250 ret = rtl8192_tx(dev, skb);
1253 spin_unlock_irqrestore(&priv->tx_lock,flags);
1259 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1261 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1262 u16 DrvAggr_PaddingAdd(struct net_device *dev, struct sk_buff *skb)
1264 u16 PaddingNum = 256 - ((skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES) % 256);
1265 return (PaddingNum&0xff);
1268 u8 MRateToHwRate8190Pci(u8 rate);
1269 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc);
1270 u8 MapHwQueueToFirmwareQueue(u8 QueueID);
1271 struct sk_buff *DrvAggr_Aggregation(struct net_device *dev, struct ieee80211_drv_agg_txb *pSendList)
1273 struct ieee80211_device *ieee = netdev_priv(dev);
1274 struct r8192_priv *priv = ieee80211_priv(dev);
1275 cb_desc *tcb_desc = NULL;
1278 struct sk_buff *skb;
1279 struct sk_buff *agg_skb;
1280 tx_desc_819x_usb_aggr_subframe *tx_agg_desc = NULL;
1281 tx_fwinfo_819x_usb *tx_fwinfo = NULL;
1284 // Local variable initialization.
1286 /* first skb initialization */
1287 skb = pSendList->tx_agg_frames[0];
1288 TotalLength = skb->len;
1290 /* Get the total aggregation length including the padding space and
1293 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1294 TotalLength += DrvAggr_PaddingAdd(dev, skb);
1295 skb = pSendList->tx_agg_frames[i];
1296 TotalLength += (skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1299 /* allocate skb to contain the aggregated packets */
1300 agg_skb = dev_alloc_skb(TotalLength + ieee->tx_headroom);
1301 memset(agg_skb->data, 0, agg_skb->len);
1302 skb_reserve(agg_skb, ieee->tx_headroom);
1304 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
1305 /* reserve info for first subframe Tx descriptor to be set in the tx function */
1306 skb = pSendList->tx_agg_frames[0];
1307 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1308 tcb_desc->drv_agg_enable = 1;
1309 tcb_desc->pkt_size = skb->len;
1310 tcb_desc->DrvAggrNum = pSendList->nr_drv_agg_frames;
1311 printk("DrvAggNum = %d\n", tcb_desc->DrvAggrNum);
1312 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
1313 // printk("========>skb->data ======> \n");
1314 // RT_DEBUG_DATA(COMP_SEND, skb->data, skb->len);
1315 memcpy(agg_skb->cb, skb->cb, sizeof(skb->cb));
1316 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1318 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1319 /* push the next sub frame to be 256 byte aline */
1320 skb_put(agg_skb,DrvAggr_PaddingAdd(dev,skb));
1322 /* Subframe drv Tx descriptor and firmware info setting */
1323 skb = pSendList->tx_agg_frames[i];
1324 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1325 tx_agg_desc = (tx_desc_819x_usb_aggr_subframe *)agg_skb->tail;
1326 tx_fwinfo = (tx_fwinfo_819x_usb *)(agg_skb->tail + sizeof(tx_desc_819x_usb_aggr_subframe));
1328 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
1330 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
1331 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
1332 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1333 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
1334 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
1335 tx_fwinfo->AllowAggregation = 1;
1337 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
1338 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
1340 tx_fwinfo->AllowAggregation = 0;
1342 tx_fwinfo->RxMF = 0;
1343 tx_fwinfo->RxAMD = 0;
1346 /* Protection mode related */
1347 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
1348 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
1349 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
1350 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
1351 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1352 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
1353 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
1354 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
1355 (tcb_desc->bRTSUseShortGI?1:0);
1357 /* Set Bandwidth and sub-channel settings. */
1358 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
1360 if(tcb_desc->bPacketBW) {
1361 tx_fwinfo->TxBandwidth = 1;
1362 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
1364 tx_fwinfo->TxBandwidth = 0;
1365 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1368 tx_fwinfo->TxBandwidth = 0;
1369 tx_fwinfo->TxSubCarrier = 0;
1372 /* Fill Tx descriptor */
1373 memset(tx_agg_desc, 0, sizeof(tx_desc_819x_usb_aggr_subframe));
1375 //tx_agg_desc->LINIP = 0;
1376 //tx_agg_desc->CmdInit = 1;
1377 tx_agg_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
1378 /* already raw data, need not to subtract header length */
1379 tx_agg_desc->PktSize = skb->len & 0xffff;
1382 tx_agg_desc->SecCAMID= 0;
1383 tx_agg_desc->RATid = tcb_desc->RATRIndex;
1386 tx_agg_desc->NoEnc = 1;
1388 tx_agg_desc->SecType = 0x0;
1390 if (tcb_desc->bHwSec) {
1391 switch (priv->ieee80211->pairwise_key_type)
1393 case KEY_TYPE_WEP40:
1394 case KEY_TYPE_WEP104:
1395 tx_agg_desc->SecType = 0x1;
1396 tx_agg_desc->NoEnc = 0;
1399 tx_agg_desc->SecType = 0x2;
1400 tx_agg_desc->NoEnc = 0;
1403 tx_agg_desc->SecType = 0x3;
1404 tx_agg_desc->NoEnc = 0;
1407 tx_agg_desc->SecType = 0x0;
1408 tx_agg_desc->NoEnc = 1;
1413 tx_agg_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1414 tx_agg_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
1416 tx_agg_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
1417 tx_agg_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1419 tx_agg_desc->OWN = 1;
1422 /* According windows driver, it seems that there no need to fill this field */
1423 //tx_agg_desc->TxBufferSize= (u32)(skb->len - USB_HWDESC_HEADER_LEN);
1425 /* to fill next packet */
1426 skb_put(agg_skb,TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1427 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1430 for(i = 0; i < pSendList->nr_drv_agg_frames; i++) {
1431 dev_kfree_skb_any(pSendList->tx_agg_frames[i]);
1438 This function return a list of PTCB which is proper to be aggregate with the input TCB.
1439 If no proper TCB is found to do aggregation, SendList will only contain the input TCB.
1441 u8 DrvAggr_GetAggregatibleList(struct net_device *dev, struct sk_buff *skb,
1442 struct ieee80211_drv_agg_txb *pSendList)
1444 struct ieee80211_device *ieee = netdev_priv(dev);
1445 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
1446 u16 nMaxAggrNum = pHTInfo->UsbTxAggrNum;
1447 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1448 u8 QueueID = tcb_desc->queue_index;
1451 pSendList->tx_agg_frames[pSendList->nr_drv_agg_frames++] = skb;
1452 if(pSendList->nr_drv_agg_frames >= nMaxAggrNum) {
1456 } while((skb = skb_dequeue(&ieee->skb_drv_aggQ[QueueID])));
1458 RT_TRACE(COMP_AMSDU, "DrvAggr_GetAggregatibleList, nAggrTcbNum = %d \n", pSendList->nr_drv_agg_frames);
1459 return pSendList->nr_drv_agg_frames;
1463 static void rtl8192_tx_isr(struct urb *tx_urb)
1465 struct sk_buff *skb = (struct sk_buff*)tx_urb->context;
1466 struct net_device *dev = NULL;
1467 struct r8192_priv *priv = NULL;
1468 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1469 u8 queue_index = tcb_desc->queue_index;
1470 // bool bToSend0Byte;
1471 // u16 BufLen = skb->len;
1473 memcpy(&dev,(struct net_device*)(skb->cb),sizeof(struct net_device*));
1474 priv = ieee80211_priv(dev);
1476 if(tcb_desc->queue_index != TXCMD_QUEUE) {
1477 if(tx_urb->status == 0) {
1478 dev->trans_start = jiffies;
1479 // Act as station mode, destination shall be unicast address.
1480 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1481 //priv->ieee80211->stats.tx_packets++;
1482 priv->stats.txoktotal++;
1483 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
1484 priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
1486 priv->ieee80211->stats.tx_errors++;
1487 //priv->stats.txmanageerr++;
1492 /* free skb and tx_urb */
1494 dev_kfree_skb_any(skb);
1495 usb_free_urb(tx_urb);
1496 atomic_dec(&priv->tx_pending[queue_index]);
1501 // Handle HW Beacon:
1502 // We had transfer our beacon frame to host controller at this moment.
1506 // Handling the wait queue of command packets.
1507 // For Tx command packets, we must not do TCB fragment because it is not handled right now.
1508 // We must cut the packets to match the size of TX_CMD_PKT before we send it.
1511 /* Handle MPDU in wait queue. */
1512 if(queue_index != BEACON_QUEUE) {
1513 /* Don't send data frame during scanning.*/
1514 if((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0)&&\
1515 (!(priv->ieee80211->queue_stop))) {
1516 if(NULL != (skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]))))
1517 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1519 return; //modified by david to avoid further processing AMSDU
1521 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1522 else if ((skb_queue_len(&priv->ieee80211->skb_drv_aggQ[queue_index])!= 0)&&\
1523 (!(priv->ieee80211->queue_stop))) {
1524 // Tx Driver Aggregation process
1525 /* The driver will aggregation the packets according to the following stats
1526 * 1. check whether there's tx irq available, for it's a completion return
1527 * function, it should contain enough tx irq;
1528 * 2. check packet type;
1529 * 3. initialize sendlist, check whether the to-be send packet no greater than 1
1530 * 4. aggregates the packets, and fill firmware info and tx desc into it, etc.
1531 * 5. check whether the packet could be sent, otherwise just insert into wait head
1533 skb = skb_dequeue(&priv->ieee80211->skb_drv_aggQ[queue_index]);
1534 if(!check_nic_enough_desc(dev, queue_index)) {
1535 skb_queue_head(&(priv->ieee80211->skb_drv_aggQ[queue_index]), skb);
1542 u8* pHeader = skb->data;
1544 if(IsMgntQosData(pHeader) ||
1545 IsMgntQData_Ack(pHeader) ||
1546 IsMgntQData_Poll(pHeader) ||
1547 IsMgntQData_Poll_Ack(pHeader)
1551 struct ieee80211_drv_agg_txb SendList;
1553 memset(&SendList, 0, sizeof(struct ieee80211_drv_agg_txb));
1554 if(DrvAggr_GetAggregatibleList(dev, skb, &SendList) > 1) {
1555 skb = DrvAggr_Aggregation(dev, &SendList);
1559 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1568 void rtl8192_beacon_stop(struct net_device *dev)
1571 struct r8192_priv *priv = ieee80211_priv(dev);
1573 msr = read_nic_byte(dev, MSR);
1574 msrm = msr & MSR_LINK_MASK;
1575 msr2 = msr & ~MSR_LINK_MASK;
1577 if(NIC_8192U == priv->card_8192) {
1578 usb_kill_urb(priv->rx_urb[MAX_RX_URB]);
1580 if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
1581 (msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
1582 write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
1583 write_nic_byte(dev, MSR, msr);
1587 void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1589 struct r8192_priv *priv = ieee80211_priv(dev);
1590 struct ieee80211_network *net;
1591 u8 i=0, basic_rate = 0;
1592 net = & priv->ieee80211->current_network;
1594 for (i=0; i<net->rates_len; i++)
1596 basic_rate = net->rates[i]&0x7f;
1599 case MGN_1M: *rate_config |= RRSR_1M; break;
1600 case MGN_2M: *rate_config |= RRSR_2M; break;
1601 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1602 case MGN_11M: *rate_config |= RRSR_11M; break;
1603 case MGN_6M: *rate_config |= RRSR_6M; break;
1604 case MGN_9M: *rate_config |= RRSR_9M; break;
1605 case MGN_12M: *rate_config |= RRSR_12M; break;
1606 case MGN_18M: *rate_config |= RRSR_18M; break;
1607 case MGN_24M: *rate_config |= RRSR_24M; break;
1608 case MGN_36M: *rate_config |= RRSR_36M; break;
1609 case MGN_48M: *rate_config |= RRSR_48M; break;
1610 case MGN_54M: *rate_config |= RRSR_54M; break;
1613 for (i=0; i<net->rates_ex_len; i++)
1615 basic_rate = net->rates_ex[i]&0x7f;
1618 case MGN_1M: *rate_config |= RRSR_1M; break;
1619 case MGN_2M: *rate_config |= RRSR_2M; break;
1620 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1621 case MGN_11M: *rate_config |= RRSR_11M; break;
1622 case MGN_6M: *rate_config |= RRSR_6M; break;
1623 case MGN_9M: *rate_config |= RRSR_9M; break;
1624 case MGN_12M: *rate_config |= RRSR_12M; break;
1625 case MGN_18M: *rate_config |= RRSR_18M; break;
1626 case MGN_24M: *rate_config |= RRSR_24M; break;
1627 case MGN_36M: *rate_config |= RRSR_36M; break;
1628 case MGN_48M: *rate_config |= RRSR_48M; break;
1629 case MGN_54M: *rate_config |= RRSR_54M; break;
1635 #define SHORT_SLOT_TIME 9
1636 #define NON_SHORT_SLOT_TIME 20
1638 void rtl8192_update_cap(struct net_device* dev, u16 cap)
1641 struct r8192_priv *priv = ieee80211_priv(dev);
1642 struct ieee80211_network *net = &priv->ieee80211->current_network;
1643 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1644 tmp = priv->basic_rate;
1645 if (priv->short_preamble)
1646 tmp |= BRSR_AckShortPmb;
1647 write_nic_dword(dev, RRSR, tmp);
1649 if (net->mode & (IEEE_G|IEEE_N_24G))
1652 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1654 slot_time = SHORT_SLOT_TIME;
1656 else //long slot time
1657 slot_time = NON_SHORT_SLOT_TIME;
1658 priv->slot_time = slot_time;
1659 write_nic_byte(dev, SLOT_TIME, slot_time);
1663 void rtl8192_net_update(struct net_device *dev)
1666 struct r8192_priv *priv = ieee80211_priv(dev);
1667 struct ieee80211_network *net;
1668 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1669 u16 rate_config = 0;
1670 net = & priv->ieee80211->current_network;
1672 rtl8192_config_rate(dev, &rate_config);
1673 priv->basic_rate = rate_config &= 0x15f;
1675 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1676 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1677 //for(i=0;i<ETH_ALEN;i++)
1678 // write_nic_byte(dev,BSSID+i,net->bssid[i]);
1680 rtl8192_update_msr(dev);
1681 // rtl8192_update_cap(dev, net->capability);
1682 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1684 write_nic_word(dev, ATIMWND, 2);
1685 write_nic_word(dev, BCN_DMATIME, 1023);
1686 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1687 // write_nic_word(dev, BcnIntTime, 100);
1688 write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
1689 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1690 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1691 // TODO: BcnIFS may required to be changed on ASIC
1692 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1694 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1701 //temporary hw beacon is not used any more.
1702 //open it when necessary
1703 void rtl819xusb_beacon_tx(struct net_device *dev,u16 tx_rate)
1707 inline u8 rtl8192_IsWirelessBMode(u16 rate)
1709 if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
1714 u16 N_DBPSOfRate(u16 DataRate);
1719 u8 bManagementFrame,
1727 if( rtl8192_IsWirelessBMode(DataRate) )
1729 if( bManagementFrame || !bShortPreamble || DataRate == 10 )
1731 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1735 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1737 if( ( FrameLength*8 % (DataRate/10) ) != 0 ) //Get the Ceilling
1739 } else { //802.11g DSSS-OFDM PLCP length field calculation.
1740 N_DBPS = N_DBPSOfRate(DataRate);
1741 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1742 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1743 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1748 u16 N_DBPSOfRate(u16 DataRate)
1793 void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
1795 usb_free_urb(tx_cmd_urb);
1798 unsigned int txqueue2outpipe(struct r8192_priv* priv,unsigned int tx_queue) {
1802 RT_TRACE(COMP_ERR,"%s():Unknown queue ID!!!\n",__FUNCTION__);
1805 return priv->txqueue_to_outpipemap[tx_queue];
1808 short rtl819xU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1810 struct r8192_priv *priv = ieee80211_priv(dev);
1815 unsigned int idx_pipe;
1816 tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
1817 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1818 u8 queue_index = tcb_desc->queue_index;
1820 //printk("\n %s::queue_index = %d\n",__FUNCTION__, queue_index);
1821 atomic_inc(&priv->tx_pending[queue_index]);
1822 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
1828 memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
1829 /* Tx descriptor ought to be set according to the skb->cb */
1830 pdesc->FirstSeg = 1;//bFirstSeg;
1831 pdesc->LastSeg = 1;//bLastSeg;
1832 pdesc->CmdInit = tcb_desc->bCmdOrInit;
1833 pdesc->TxBufferSize = tcb_desc->txbuf_size;
1835 pdesc->LINIP = tcb_desc->bLastIniPkt;
1837 //----------------------------------------------------------------------------
1838 // Fill up USB_OUT_CONTEXT.
1839 //----------------------------------------------------------------------------
1840 // Get index to out pipe from specified QueueID.
1841 #ifndef USE_ONE_PIPE
1842 idx_pipe = txqueue2outpipe(priv,queue_index);
1846 #ifdef JOHN_DUMP_TXDESC
1848 printk("<Tx descriptor>--rate %x---",rate);
1849 for (i = 0; i < 8; i++)
1850 printk("%8x ", tx[i]);
1853 usb_fill_bulk_urb(tx_urb,priv->udev, usb_sndbulkpipe(priv->udev,idx_pipe), \
1854 skb->data, skb->len, rtl8192_tx_isr, skb);
1856 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
1861 DMESGE("Error TX CMD URB, error %d",
1868 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1869 * in TxFwInfo data structure
1870 * 2006.10.30 by Emily
1872 * \param QUEUEID Software Queue
1874 u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1876 u8 QueueSelect = 0x0; //defualt set to
1880 QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
1884 QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
1888 QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
1892 QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
1895 QueueSelect = QSLT_MGNT;
1899 QueueSelect = QSLT_BEACON;
1902 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
1903 // TODO: Remove Assertions
1904 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
1906 QueueSelect = QSLT_CMD;
1910 QueueSelect = QSLT_HIGH;
1914 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
1920 u8 MRateToHwRate8190Pci(u8 rate)
1922 u8 ret = DESC90_RATE1M;
1925 case MGN_1M: ret = DESC90_RATE1M; break;
1926 case MGN_2M: ret = DESC90_RATE2M; break;
1927 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
1928 case MGN_11M: ret = DESC90_RATE11M; break;
1929 case MGN_6M: ret = DESC90_RATE6M; break;
1930 case MGN_9M: ret = DESC90_RATE9M; break;
1931 case MGN_12M: ret = DESC90_RATE12M; break;
1932 case MGN_18M: ret = DESC90_RATE18M; break;
1933 case MGN_24M: ret = DESC90_RATE24M; break;
1934 case MGN_36M: ret = DESC90_RATE36M; break;
1935 case MGN_48M: ret = DESC90_RATE48M; break;
1936 case MGN_54M: ret = DESC90_RATE54M; break;
1938 // HT rate since here
1939 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
1940 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
1941 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
1942 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
1943 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
1944 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
1945 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
1946 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
1947 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
1948 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
1949 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1950 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1951 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1952 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1953 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1954 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1955 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1963 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1967 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1969 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1975 static void tx_zero_isr(struct urb *tx_urb)
1981 * The tx procedure is just as following,
1982 * skb->cb will contain all the following information,
1983 * priority, morefrag, rate, &dev.
1985 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
1987 struct r8192_priv *priv = ieee80211_priv(dev);
1988 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1989 tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
1990 tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);
1991 struct usb_device *udev = priv->udev;
1994 struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
1996 unsigned int idx_pipe;
1997 // RT_DEBUG_DATA(COMP_SEND, tcb_desc, sizeof(cb_desc));
1998 // printk("=============> %s\n", __FUNCTION__);
1999 pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
2000 /* we are locked here so the two atomic_read and inc are executed
2001 * without interleaves
2002 * !!! For debug purpose
2004 if( pend > MAX_TX_URB){
2005 printk("To discard skb packet!\n");
2006 dev_kfree_skb_any(skb);
2010 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
2012 dev_kfree_skb_any(skb);
2016 /* Fill Tx firmware info */
2017 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
2019 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
2020 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
2021 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
2022 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
2023 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
2024 tx_fwinfo->AllowAggregation = 1;
2026 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
2027 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
2029 tx_fwinfo->AllowAggregation = 0;
2031 tx_fwinfo->RxMF = 0;
2032 tx_fwinfo->RxAMD = 0;
2035 /* Protection mode related */
2036 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
2037 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
2038 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
2039 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
2040 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
2041 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
2042 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
2043 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
2044 (tcb_desc->bRTSUseShortGI?1:0);
2046 /* Set Bandwidth and sub-channel settings. */
2047 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
2049 if(tcb_desc->bPacketBW) {
2050 tx_fwinfo->TxBandwidth = 1;
2051 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
2053 tx_fwinfo->TxBandwidth = 0;
2054 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
2057 tx_fwinfo->TxBandwidth = 0;
2058 tx_fwinfo->TxSubCarrier = 0;
2061 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2062 if (tcb_desc->drv_agg_enable)
2064 tx_fwinfo->Tx_INFO_RSVD = (tcb_desc->DrvAggrNum & 0x1f) << 1;
2067 /* Fill Tx descriptor */
2068 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
2071 tx_desc->CmdInit = 1;
2072 tx_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
2074 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2075 if (tcb_desc->drv_agg_enable) {
2076 tx_desc->PktSize = tcb_desc->pkt_size;
2080 tx_desc->PktSize = (skb->len - TX_PACKET_SHIFT_BYTES) & 0xffff;
2084 tx_desc->SecCAMID= 0;
2085 tx_desc->RATid = tcb_desc->RATRIndex;
2090 tx_desc->SecType = 0x0;
2091 if (tcb_desc->bHwSec)
2093 switch (priv->ieee80211->pairwise_key_type)
2095 case KEY_TYPE_WEP40:
2096 case KEY_TYPE_WEP104:
2097 tx_desc->SecType = 0x1;
2101 tx_desc->SecType = 0x2;
2105 tx_desc->SecType = 0x3;
2109 tx_desc->SecType = 0x0;
2115 tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
2116 tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
2118 tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
2119 tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
2121 /* Fill fields that are required to be initialized in all of the descriptors */
2123 tx_desc->FirstSeg = 1;
2124 tx_desc->LastSeg = 1;
2127 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2128 if (tcb_desc->drv_agg_enable) {
2129 tx_desc->TxBufferSize = tcb_desc->pkt_size + sizeof(tx_fwinfo_819x_usb);
2134 tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
2136 /* Get index to out pipe from specified QueueID */
2137 #ifndef USE_ONE_PIPE
2138 idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
2143 //RT_DEBUG_DATA(COMP_SEND,tx_fwinfo,sizeof(tx_fwinfo_819x_usb));
2144 //RT_DEBUG_DATA(COMP_SEND,tx_desc,sizeof(tx_desc_819x_usb));
2146 /* To submit bulk urb */
2147 usb_fill_bulk_urb(tx_urb,udev,
2148 usb_sndbulkpipe(udev,idx_pipe), skb->data,
2149 skb->len, rtl8192_tx_isr, skb);
2151 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
2153 //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
2154 bool bSend0Byte = false;
2156 if(udev->speed == USB_SPEED_HIGH)
2158 if (skb->len > 0 && skb->len % 512 == 0)
2163 if (skb->len > 0 && skb->len % 64 == 0)
2168 tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
2170 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
2173 usb_fill_bulk_urb(tx_urb_zero,udev,
2174 usb_sndbulkpipe(udev,idx_pipe), &zero,
2175 0, tx_zero_isr, dev);
2176 status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
2178 RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
2182 dev->trans_start = jiffies;
2183 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
2186 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
2192 short rtl8192_usb_initendpoints(struct net_device *dev)
2194 struct r8192_priv *priv = ieee80211_priv(dev);
2196 priv->rx_urb = kmalloc(sizeof(struct urb *) * (MAX_RX_URB+1),
2198 if (priv->rx_urb == NULL)
2201 #ifndef JACKSON_NEW_RX
2202 for(i=0;i<(MAX_RX_URB+1);i++){
2204 priv->rx_urb[i] = usb_alloc_urb(0,GFP_KERNEL);
2206 priv->rx_urb[i]->transfer_buffer = kmalloc(RX_URB_SIZE, GFP_KERNEL);
2208 priv->rx_urb[i]->transfer_buffer_length = RX_URB_SIZE;
2212 #ifdef THOMAS_BEACON
2215 void *oldaddr, *newaddr;
2217 priv->rx_urb[16] = usb_alloc_urb(0, GFP_KERNEL);
2218 priv->oldaddr = kmalloc(16, GFP_KERNEL);
2219 oldaddr = priv->oldaddr;
2220 align = ((long)oldaddr) & 3;
2222 newaddr = oldaddr + 4 - align;
2223 priv->rx_urb[16]->transfer_buffer_length = 16 - 4 + align;
2226 priv->rx_urb[16]->transfer_buffer_length = 16;
2228 priv->rx_urb[16]->transfer_buffer = newaddr;
2232 memset(priv->rx_urb, 0, sizeof(struct urb*) * MAX_RX_URB);
2233 priv->pp_rxskb = kcalloc(MAX_RX_URB, sizeof(struct sk_buff *),
2235 if (!priv->pp_rxskb) {
2236 kfree(priv->rx_urb);
2238 priv->pp_rxskb = NULL;
2239 priv->rx_urb = NULL;
2241 DMESGE("Endpoint Alloc Failure");
2245 printk("End of initendpoints\n");
2249 #ifdef THOMAS_BEACON
2250 void rtl8192_usb_deleteendpoints(struct net_device *dev)
2253 struct r8192_priv *priv = ieee80211_priv(dev);
2256 for(i=0;i<(MAX_RX_URB+1);i++){
2257 usb_kill_urb(priv->rx_urb[i]);
2258 usb_free_urb(priv->rx_urb[i]);
2260 kfree(priv->rx_urb);
2261 priv->rx_urb = NULL;
2263 kfree(priv->oldaddr);
2264 priv->oldaddr = NULL;
2265 if (priv->pp_rxskb) {
2266 kfree(priv->pp_rxskb);
2271 void rtl8192_usb_deleteendpoints(struct net_device *dev)
2274 struct r8192_priv *priv = ieee80211_priv(dev);
2276 #ifndef JACKSON_NEW_RX
2279 for(i=0;i<(MAX_RX_URB+1);i++){
2280 usb_kill_urb(priv->rx_urb[i]);
2281 kfree(priv->rx_urb[i]->transfer_buffer);
2282 usb_free_urb(priv->rx_urb[i]);
2284 kfree(priv->rx_urb);
2285 priv->rx_urb = NULL;
2289 kfree(priv->rx_urb);
2290 priv->rx_urb = NULL;
2291 kfree(priv->oldaddr);
2292 priv->oldaddr = NULL;
2293 if (priv->pp_rxskb) {
2294 kfree(priv->pp_rxskb);
2303 extern void rtl8192_update_ratr_table(struct net_device* dev);
2304 void rtl8192_link_change(struct net_device *dev)
2308 struct r8192_priv *priv = ieee80211_priv(dev);
2309 struct ieee80211_device* ieee = priv->ieee80211;
2310 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
2311 if (ieee->state == IEEE80211_LINKED)
2313 rtl8192_net_update(dev);
2314 rtl8192_update_ratr_table(dev);
2315 //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
2316 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
2317 EnableHWSecurityConfig8192(dev);
2319 /*update timing params*/
2320 // RT_TRACE(COMP_CH, "========>%s(), chan:%d\n", __FUNCTION__, priv->chan);
2321 // rtl8192_set_chan(dev, priv->chan);
2322 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
2325 reg = read_nic_dword(dev, RCR);
2326 if (priv->ieee80211->state == IEEE80211_LINKED)
2327 priv->ReceiveConfig = reg |= RCR_CBSSID;
2329 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
2330 write_nic_dword(dev, RCR, reg);
2333 // rtl8192_set_rxconf(dev);
2336 static struct ieee80211_qos_parameters def_qos_parameters = {
2337 {3,3,3,3},/* cw_min */
2338 {7,7,7,7},/* cw_max */
2339 {2,2,2,2},/* aifs */
2340 {0,0,0,0},/* flags */
2341 {0,0,0,0} /* tx_op_limit */
2345 void rtl8192_update_beacon(struct work_struct * work)
2347 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
2348 struct net_device *dev = priv->ieee80211->dev;
2349 struct ieee80211_device* ieee = priv->ieee80211;
2350 struct ieee80211_network* net = &ieee->current_network;
2352 if (ieee->pHTInfo->bCurrentHTSupport)
2353 HTUpdateSelfAndPeerSetting(ieee, net);
2354 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
2355 rtl8192_update_cap(dev, net->capability);
2358 * background support to run QoS activate functionality
2360 int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
2361 void rtl8192_qos_activate(struct work_struct * work)
2363 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
2364 struct net_device *dev = priv->ieee80211->dev;
2365 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
2366 u8 mode = priv->ieee80211->current_network.mode;
2367 //u32 size = sizeof(struct ieee80211_qos_parameters);
2375 mutex_lock(&priv->mutex);
2376 if(priv->ieee80211->state != IEEE80211_LINKED)
2378 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
2379 /* It better set slot time at first */
2380 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
2381 /* update the ac parameter to related registers */
2382 for(i = 0; i < QOS_QUEUE_NUM; i++) {
2383 //Mode G/A: slotTimeTimer = 9; Mode B: 20
2384 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
2385 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
2386 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
2387 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
2388 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
2390 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
2391 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
2395 mutex_unlock(&priv->mutex);
2398 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
2400 struct ieee80211_network *network)
2403 u32 size = sizeof(struct ieee80211_qos_parameters);
2405 if(priv->ieee80211->state !=IEEE80211_LINKED)
2408 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2411 if (network->flags & NETWORK_HAS_QOS_MASK) {
2412 if (active_network &&
2413 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
2414 network->qos_data.active = network->qos_data.supported;
2416 if ((network->qos_data.active == 1) && (active_network == 1) &&
2417 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
2418 (network->qos_data.old_param_count !=
2419 network->qos_data.param_count)) {
2420 network->qos_data.old_param_count =
2421 network->qos_data.param_count;
2422 queue_work(priv->priv_wq, &priv->qos_activate);
2423 RT_TRACE (COMP_QOS, "QoS parameters change call "
2427 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2428 &def_qos_parameters, size);
2430 if ((network->qos_data.active == 1) && (active_network == 1)) {
2431 queue_work(priv->priv_wq, &priv->qos_activate);
2432 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
2434 network->qos_data.active = 0;
2435 network->qos_data.supported = 0;
2441 /* handle and manage frame from beacon and probe response */
2442 static int rtl8192_handle_beacon(struct net_device * dev,
2443 struct ieee80211_beacon * beacon,
2444 struct ieee80211_network * network)
2446 struct r8192_priv *priv = ieee80211_priv(dev);
2448 rtl8192_qos_handle_probe_response(priv,1,network);
2449 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
2455 * handling the beaconing responses. if we get different QoS setting
2456 * off the network from the associated setting, adjust the QoS
2459 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
2460 struct ieee80211_network *network)
2463 unsigned long flags;
2464 u32 size = sizeof(struct ieee80211_qos_parameters);
2465 int set_qos_param = 0;
2467 if ((priv == NULL) || (network == NULL))
2470 if(priv->ieee80211->state !=IEEE80211_LINKED)
2473 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2476 spin_lock_irqsave(&priv->ieee80211->lock, flags);
2477 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
2478 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2479 &network->qos_data.parameters,\
2480 sizeof(struct ieee80211_qos_parameters));
2481 priv->ieee80211->current_network.qos_data.active = 1;
2484 /* update qos parameter for current network */
2485 priv->ieee80211->current_network.qos_data.old_param_count = \
2486 priv->ieee80211->current_network.qos_data.param_count;
2487 priv->ieee80211->current_network.qos_data.param_count = \
2488 network->qos_data.param_count;
2491 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2492 &def_qos_parameters, size);
2493 priv->ieee80211->current_network.qos_data.active = 0;
2494 priv->ieee80211->current_network.qos_data.supported = 0;
2498 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
2500 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
2501 if (set_qos_param == 1)
2502 queue_work(priv->priv_wq, &priv->qos_activate);
2509 static int rtl8192_handle_assoc_response(struct net_device *dev,
2510 struct ieee80211_assoc_response_frame *resp,
2511 struct ieee80211_network *network)
2513 struct r8192_priv *priv = ieee80211_priv(dev);
2514 rtl8192_qos_association_resp(priv, network);
2519 void rtl8192_update_ratr_table(struct net_device* dev)
2520 // POCTET_STRING posLegacyRate,
2522 // PRT_WLAN_STA pEntry)
2524 struct r8192_priv* priv = ieee80211_priv(dev);
2525 struct ieee80211_device* ieee = priv->ieee80211;
2526 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2527 //struct ieee80211_network *net = &ieee->current_network;
2530 rtl8192_config_rate(dev, (u16*)(&ratr_value));
2531 ratr_value |= (*(u16*)(pMcsRate)) << 12;
2532 // switch (net->mode)
2536 ratr_value &= 0x00000FF0;
2539 ratr_value &= 0x0000000F;
2542 ratr_value &= 0x00000FF7;
2546 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
2547 ratr_value &= 0x0007F007;
2549 if (priv->rf_type == RF_1T2R)
2550 ratr_value &= 0x000FF007;
2552 ratr_value &= 0x0F81F007;
2558 ratr_value &= 0x0FFFFFFF;
2559 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
2560 ratr_value |= 0x80000000;
2561 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
2562 ratr_value |= 0x80000000;
2564 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2565 write_nic_byte(dev, UFWP, 1);
2568 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
2569 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2570 bool GetNmodeSupportBySecCfg8192(struct net_device*dev)
2572 struct r8192_priv* priv = ieee80211_priv(dev);
2573 struct ieee80211_device* ieee = priv->ieee80211;
2574 struct ieee80211_network * network = &ieee->current_network;
2575 int wpa_ie_len= ieee->wpa_ie_len;
2576 struct ieee80211_crypt_data* crypt;
2579 crypt = ieee->crypt[ieee->tx_keyidx];
2580 //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
2581 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2584 if(encrypt && (wpa_ie_len == 0)) {
2585 /* wep encryption, no N mode setting */
2587 // } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
2588 } else if((wpa_ie_len != 0)) {
2589 /* parse pairwise key type */
2590 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
2591 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))))
2602 bool GetHalfNmodeSupportByAPs819xUsb(struct net_device* dev)
2605 struct r8192_priv* priv = ieee80211_priv(dev);
2606 struct ieee80211_device* ieee = priv->ieee80211;
2608 if(ieee->bHalfWirelessN24GMode == true)
2616 void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2618 struct ieee80211_device* ieee = priv->ieee80211;
2619 //we do not consider set support rate for ABG mode, only HT MCS rate is set here.
2620 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2622 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2623 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
2624 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
2627 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2631 u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2633 struct r8192_priv *priv = ieee80211_priv(dev);
2635 switch(priv->rf_chip)
2640 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2643 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2646 ret = WIRELESS_MODE_B;
2651 void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2653 struct r8192_priv *priv = ieee80211_priv(dev);
2654 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2656 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2658 if(bSupportMode & WIRELESS_MODE_N_24G)
2660 wireless_mode = WIRELESS_MODE_N_24G;
2662 else if(bSupportMode & WIRELESS_MODE_N_5G)
2664 wireless_mode = WIRELESS_MODE_N_5G;
2666 else if((bSupportMode & WIRELESS_MODE_A))
2668 wireless_mode = WIRELESS_MODE_A;
2670 else if((bSupportMode & WIRELESS_MODE_G))
2672 wireless_mode = WIRELESS_MODE_G;
2674 else if((bSupportMode & WIRELESS_MODE_B))
2676 wireless_mode = WIRELESS_MODE_B;
2679 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2680 wireless_mode = WIRELESS_MODE_B;
2683 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2684 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2686 priv->ieee80211->mode = wireless_mode;
2688 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2689 priv->ieee80211->pHTInfo->bEnableHT = 1;
2691 priv->ieee80211->pHTInfo->bEnableHT = 0;
2692 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2693 rtl8192_refresh_supportrate(priv);
2696 //init priv variables here. only non_zero value should be initialized here.
2697 static void rtl8192_init_priv_variable(struct net_device* dev)
2699 struct r8192_priv *priv = ieee80211_priv(dev);
2701 priv->card_8192 = NIC_8192U;
2702 priv->chan = 1; //set to channel 1
2703 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2704 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2705 priv->ieee80211->ieee_up=0;
2706 priv->retry_rts = DEFAULT_RETRY_RTS;
2707 priv->retry_data = DEFAULT_RETRY_DATA;
2708 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2709 priv->ieee80211->rate = 110; //11 mbps
2710 priv->ieee80211->short_slot = 1;
2711 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2714 priv->IrpPendingCount = 1;
2715 priv->ResetProgress = RESET_TYPE_NORESET;
2716 priv->bForcedSilentReset = 0;
2717 priv->bDisableNormalResetCheck = false;
2718 priv->force_reset = false;
2720 priv->ieee80211->FwRWRF = 0; //we don't use FW read/write RF until stable firmware is available.
2721 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2722 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2723 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2724 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2725 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
2726 IEEE_SOFTMAC_BEACONS;//added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2728 priv->ieee80211->active_scan = 1;
2729 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2730 priv->ieee80211->host_encrypt = 1;
2731 priv->ieee80211->host_decrypt = 1;
2732 priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2733 priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2734 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2735 priv->ieee80211->set_chan = rtl8192_set_chan;
2736 priv->ieee80211->link_change = rtl8192_link_change;
2737 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2738 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2739 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2740 priv->ieee80211->init_wmmparam_flag = 0;
2741 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2742 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2743 priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
2744 priv->ieee80211->qos_support = 1;
2747 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2748 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2749 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2750 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2752 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
2753 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
2754 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2756 priv->ieee80211->InitialGainHandler = InitialGain819xUsb;
2757 priv->card_type = USB;
2759 if(Adapter->bInHctTest)
2761 pHalData->ShortRetryLimit = 7;
2762 pHalData->LongRetryLimit = 7;
2766 priv->ShortRetryLimit = 0x30;
2767 priv->LongRetryLimit = 0x30;
2769 priv->EarlyRxThreshold = 7;
2770 priv->enable_gpio0 = 0;
2771 priv->TransmitConfig =
2772 // TCR_DurProcMode | //for RTL8185B, duration setting by HW
2773 //? TCR_DISReqQsize |
2774 (TCR_MXDMA_2048<<TCR_MXDMA_OFFSET)| // Max DMA Burst Size per Tx DMA Burst, 7: reserved.
2775 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)| // Short retry limit
2776 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
2777 (false ? TCR_SAT: 0); // FALSE: HW provides PLCP length and LENGEXT, TRUE: SW provides them
2779 if(Adapter->bInHctTest)
2780 pHalData->ReceiveConfig = pHalData->CSMethod |
2781 RCR_AMF | RCR_ADF | //RCR_AAP | //accept management/data
2783 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2784 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2785 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2786 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2787 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
2788 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt:0);
2792 priv->ReceiveConfig =
2793 RCR_AMF | RCR_ADF | //accept management/data
2794 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2795 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2796 //RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2797 ((u32)7<<RCR_MXDMA_OFFSET)| // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2798 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) | // Rx FIFO Threshold, 7: No Rx threshold.
2799 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT:0);
2801 priv->AcmControl = 0;
2802 priv->pFirmware = kzalloc(sizeof(rt_firmware), GFP_KERNEL);
2804 /* rx related queue */
2805 skb_queue_head_init(&priv->rx_queue);
2806 skb_queue_head_init(&priv->skb_queue);
2808 /* Tx related queue */
2809 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2810 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2812 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2813 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2815 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2816 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ [i]);
2818 priv->rf_set_chan = rtl8192_phy_SwChnl;
2822 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2824 spin_lock_init(&priv->tx_lock);
2825 spin_lock_init(&priv->irq_lock);//added by thomas
2826 //spin_lock_init(&priv->rf_lock);
2827 sema_init(&priv->wx_sem,1);
2828 sema_init(&priv->rf_sem,1);
2829 mutex_init(&priv->mutex);
2832 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
2834 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2835 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2836 #define DRV_NAME "wlan0"
2837 static void rtl8192_init_priv_task(struct net_device* dev)
2839 struct r8192_priv *priv = ieee80211_priv(dev);
2841 priv->priv_wq = create_workqueue(DRV_NAME);
2843 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2845 //INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2846 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2847 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2848 // INIT_DELAYED_WORK(&priv->gpio_change_rf_wq, dm_gpio_change_rf_callback);
2849 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2850 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2851 INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
2852 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2853 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2854 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2856 tasklet_init(&priv->irq_rx_tasklet,
2857 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2858 (unsigned long)priv);
2861 static void rtl8192_get_eeprom_size(struct net_device* dev)
2864 struct r8192_priv *priv = ieee80211_priv(dev);
2865 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2866 curCR = read_nic_word_E(dev,EPROM_CMD);
2867 RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
2868 //whether need I consider BIT5?
2869 priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2870 RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2873 //used to swap endian. as ntohl & htonl are not necessary to swap endian, so use this instead.
2874 static inline u16 endian_swap(u16* data)
2877 *data = (tmp >> 8) | (tmp << 8);
2880 static void rtl8192_read_eeprom_info(struct net_device* dev)
2883 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
2884 u8 bLoad_From_EEPOM = false;
2885 struct r8192_priv *priv = ieee80211_priv(dev);
2887 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2888 wEPROM_ID = eprom_read(dev, 0); //first read EEPROM ID out;
2889 RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
2891 if (wEPROM_ID != RTL8190_EEPROM_ID)
2893 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", wEPROM_ID, RTL8190_EEPROM_ID);
2896 bLoad_From_EEPOM = true;
2898 if (bLoad_From_EEPOM)
2900 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
2901 priv->eeprom_vid = endian_swap(&tmpValue);
2902 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
2903 tmpValue = eprom_read(dev, (EEPROM_ChannelPlan>>1));
2904 priv->eeprom_ChannelPlan =((tmpValue&0xff00)>>8);
2905 priv->btxpowerdata_readfromEEPORM = true;
2906 priv->eeprom_CustomerID = eprom_read(dev, (EEPROM_Customer_ID>>1)) >>8;
2910 priv->eeprom_vid = 0;
2911 priv->eeprom_pid = 0;
2912 priv->card_8192_version = VERSION_819xU_B;
2913 priv->eeprom_ChannelPlan = 0;
2914 priv->eeprom_CustomerID = 0;
2916 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);
2917 //set channelplan from eeprom
2918 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2919 if (bLoad_From_EEPOM)
2922 for (i=0; i<6; i+=2)
2925 tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
2926 *(u16*)(&dev->dev_addr[i]) = tmp;
2931 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2932 //should I set IDR0 here?
2934 RT_TRACE(COMP_EPROM, "MAC addr:%pM\n", dev->dev_addr);
2935 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
2936 priv->rf_chip = RF_8256;
2938 if (priv->card_8192_version == (u8)VERSION_819xU_A)
2940 //read Tx power gain offset of legacy OFDM to HT rate
2941 if (bLoad_From_EEPOM)
2942 priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff>>1))&0xff00) >> 8;
2944 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
2945 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
2946 //read ThermalMeter from EEPROM
2947 if (bLoad_From_EEPOM)
2948 priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter>>1))&0x00ff);
2950 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2951 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
2952 //vivi, for tx power track
2953 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2954 //read antenna tx power offset of B/C/D to A from EEPROM
2955 if (bLoad_From_EEPOM)
2956 priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff>>1))&0x0f00)>>8;
2958 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
2959 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
2960 // Read CrystalCap from EEPROM
2961 if (bLoad_From_EEPOM)
2962 priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap>>1))&0x0f);
2964 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
2965 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
2966 //get per-channel Tx power level
2967 if (bLoad_From_EEPOM)
2968 priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver>>1))&0xff00)>>8;
2970 priv->EEPROM_Def_Ver = 1;
2971 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
2972 if (priv->EEPROM_Def_Ver == 0) //old eeprom definition
2975 if (bLoad_From_EEPOM)
2976 priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK>>1))&0xff) >> 8;
2978 priv->EEPROMTxPowerLevelCCK = 0x10;
2979 RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
2982 if (bLoad_From_EEPOM)
2984 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G+i)>>1);
2985 if (((EEPROM_TxPwIndex_OFDM_24G+i) % 2) == 0)
2986 tmpValue = tmpValue & 0x00ff;
2988 tmpValue = (tmpValue & 0xff00) >> 8;
2992 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8) tmpValue;
2993 RT_TRACE(COMP_EPROM, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK);
2995 }//end if EEPROM_DEF_VER == 0
2996 else if (priv->EEPROM_Def_Ver == 1)
2998 if (bLoad_From_EEPOM)
3000 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1>>1));
3001 tmpValue = (tmpValue & 0xff00) >> 8;
3005 priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
3007 if (bLoad_From_EEPOM)
3008 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2)>>1);
3011 *((u16*)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
3012 if (bLoad_From_EEPOM)
3013 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1>>1));
3016 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[0])) = tmpValue;
3017 if (bLoad_From_EEPOM)
3018 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1+2)>>1);
3021 priv->EEPROMTxPowerLevelOFDM24G[2] = (u8)tmpValue;
3022 }//endif EEPROM_Def_Ver == 1
3024 //update HAL variables
3028 for (i=0; i<14; i++)
3031 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[0];
3032 else if (i>=4 && i<=9)
3033 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[1];
3035 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[2];
3038 for (i=0; i<14; i++)
3040 if (priv->EEPROM_Def_Ver == 0)
3043 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[0] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
3044 else if (i>=4 && i<=9)
3045 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK;
3047 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[2] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
3049 else if (priv->EEPROM_Def_Ver == 1)
3052 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[0];
3053 else if (i>=4 && i<=9)
3054 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[1];
3056 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[2];
3059 }//end update HAL variables
3060 priv->TxPowerDiff = priv->EEPROMPwDiff;
3061 // Antenna B gain offset to antenna A, bit0~3
3062 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
3063 // Antenna C gain offset to antenna A, bit4~7
3064 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
3065 // CrystalCap, bit12~15
3066 priv->CrystalCap = priv->EEPROMCrystalCap;
3067 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
3068 // 92U does not enable TX power tracking.
3069 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
3070 }//end if VersionID == VERSION_819xU_A
3072 //added by vivi, for dlink led, 20080416
3073 switch(priv->eeprom_CustomerID)
3075 case EEPROM_CID_RUNTOP:
3076 priv->CustomerID = RT_CID_819x_RUNTOP;
3079 case EEPROM_CID_DLINK:
3080 priv->CustomerID = RT_CID_DLINK;
3084 priv->CustomerID = RT_CID_DEFAULT;
3089 switch(priv->CustomerID)
3091 case RT_CID_819x_RUNTOP:
3092 priv->LedStrategy = SW_LED_MODE2;
3096 priv->LedStrategy = SW_LED_MODE4;
3100 priv->LedStrategy = SW_LED_MODE0;
3106 if(priv->rf_type == RF_1T2R)
3108 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
3112 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
3115 // 2008/01/16 MH We can only know RF type in the function. So we have to init
3116 // DIG RATR table again.
3117 init_rate_adaptive(dev);
3118 //we need init DIG RATR table here again.
3120 RT_TRACE(COMP_EPROM, "<===========%s()\n", __FUNCTION__);
3124 short rtl8192_get_channel_map(struct net_device * dev)
3126 struct r8192_priv *priv = ieee80211_priv(dev);
3127 if(priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN){
3128 printk("rtl8180_init:Error channel plan! Set to default.\n");
3129 priv->ChannelPlan= 0;
3131 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
3133 rtl819x_set_channel_map(priv->ChannelPlan, priv);
3137 short rtl8192_init(struct net_device *dev)
3140 struct r8192_priv *priv = ieee80211_priv(dev);
3142 memset(&(priv->stats),0,sizeof(struct Stats));
3143 memset(priv->txqueue_to_outpipemap,0,9);
3147 u8 queuetopipe[]={3,2,1,0,4,8,7,6,5};
3148 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3150 printk("%d ",priv->txqueue_to_outpipemap[i]);
3155 u8 queuetopipe[]={3,2,1,0,4,4,0,4,4};
3156 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3158 printk("%d ",priv->txqueue_to_outpipemap[i]);
3162 rtl8192_init_priv_variable(dev);
3163 rtl8192_init_priv_lock(priv);
3164 rtl8192_init_priv_task(dev);
3165 rtl8192_get_eeprom_size(dev);
3166 rtl8192_read_eeprom_info(dev);
3167 rtl8192_get_channel_map(dev);
3169 init_timer(&priv->watch_dog_timer);
3170 priv->watch_dog_timer.data = (unsigned long)dev;
3171 priv->watch_dog_timer.function = watch_dog_timer_callback;
3172 if(rtl8192_usb_initendpoints(dev)!=0){
3173 DMESG("Endopoints initialization failed");
3177 //rtl8192_adapter_start(dev);
3184 /******************************************************************************
3185 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
3186 * not to do all the hw config as its name says
3187 * input: net_device dev
3190 * notice: This part need to modified according to the rate set we filtered
3191 * ****************************************************************************/
3192 void rtl8192_hwconfig(struct net_device* dev)
3194 u32 regRATR = 0, regRRSR = 0;
3195 u8 regBwOpMode = 0, regTmp = 0;
3196 struct r8192_priv *priv = ieee80211_priv(dev);
3198 // Set RRSR, RATR, and BW_OPMODE registers
3200 switch(priv->ieee80211->mode)
3202 case WIRELESS_MODE_B:
3203 regBwOpMode = BW_OPMODE_20MHZ;
3204 regRATR = RATE_ALL_CCK;
3205 regRRSR = RATE_ALL_CCK;
3207 case WIRELESS_MODE_A:
3208 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
3209 regRATR = RATE_ALL_OFDM_AG;
3210 regRRSR = RATE_ALL_OFDM_AG;
3212 case WIRELESS_MODE_G:
3213 regBwOpMode = BW_OPMODE_20MHZ;
3214 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3215 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3217 case WIRELESS_MODE_AUTO:
3219 if (Adapter->bInHctTest)
3221 regBwOpMode = BW_OPMODE_20MHZ;
3222 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3223 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3228 regBwOpMode = BW_OPMODE_20MHZ;
3229 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3230 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3233 case WIRELESS_MODE_N_24G:
3234 // It support CCK rate by default.
3235 // CCK rate will be filtered out only when associated AP does not support it.
3236 regBwOpMode = BW_OPMODE_20MHZ;
3237 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3238 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3240 case WIRELESS_MODE_N_5G:
3241 regBwOpMode = BW_OPMODE_5G;
3242 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3243 regRRSR = RATE_ALL_OFDM_AG;
3247 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
3250 ratr_value = regRATR;
3251 if (priv->rf_type == RF_1T2R)
3253 ratr_value &= ~(RATE_ALL_OFDM_2SS);
3255 write_nic_dword(dev, RATR0, ratr_value);
3256 write_nic_byte(dev, UFWP, 1);
3258 regTmp = read_nic_byte(dev, 0x313);
3259 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
3260 write_nic_dword(dev, RRSR, regRRSR);
3263 // Set Retry Limit here
3265 write_nic_word(dev, RETRY_LIMIT,
3266 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | \
3267 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3268 // Set Contention Window here
3272 // Set Tx Antenna including Feedback control
3274 // Set Auto Rate fallback control
3280 //InitializeAdapter and PhyCfg
3281 bool rtl8192_adapter_start(struct net_device *dev)
3283 struct r8192_priv *priv = ieee80211_priv(dev);
3285 bool init_status = true;
3286 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3287 priv->Rf_Mode = RF_OP_By_SW_3wire;
3288 //for ASIC power on sequence
3289 write_nic_byte_E(dev, 0x5f, 0x80);
3291 write_nic_byte_E(dev, 0x5f, 0xf0);
3292 write_nic_byte_E(dev, 0x5d, 0x00);
3293 write_nic_byte_E(dev, 0x5e, 0x80);
3294 write_nic_byte(dev, 0x17, 0x37);
3297 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3298 //config CPUReset Register
3299 //Firmware Reset or not?
3300 dwRegRead = read_nic_dword(dev, CPU_GEN);
3301 if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3302 dwRegRead |= CPU_GEN_SYSTEM_RESET; //do nothing here?
3303 else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3304 dwRegRead |= CPU_GEN_FIRMWARE_RESET;
3306 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3308 write_nic_dword(dev, CPU_GEN, dwRegRead);
3311 rtl8192_BBConfig(dev);
3313 //Loopback mode or not
3314 priv->LoopbackMode = RTL819xU_NO_LOOPBACK;
3315 // priv->LoopbackMode = RTL819xU_MAC_LOOPBACK;
3317 dwRegRead = read_nic_dword(dev, CPU_GEN);
3318 if (priv->LoopbackMode == RTL819xU_NO_LOOPBACK)
3319 dwRegRead = ((dwRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3320 else if (priv->LoopbackMode == RTL819xU_MAC_LOOPBACK)
3321 dwRegRead |= CPU_CCK_LOOPBACK;
3323 RT_TRACE(COMP_ERR, "Serious error in %s(): wrong loopback mode setting(%d)\n", __FUNCTION__, priv->LoopbackMode);
3325 write_nic_dword(dev, CPU_GEN, dwRegRead);
3327 //after reset cpu, we need wait for a seconds to write in register.
3330 //xiong add for new bitfile:usb suspend reset pin set to 1. //do we need?
3331 write_nic_byte_E(dev, 0x5f, (read_nic_byte_E(dev, 0x5f)|0x20));
3334 rtl8192_hwconfig(dev);
3337 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3340 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3341 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3344 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3346 //Initialize Number of Reserved Pages in Firmware Queue
3347 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |\
3348 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT | \
3349 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT | \
3350 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3351 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT |\
3352 NUM_OF_PAGE_IN_FW_QUEUE_CMD << RSVD_FW_QUEUE_PAGE_CMD_SHIFT);
3353 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW| \
3354 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
3355 // | NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
3357 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3360 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3361 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3363 // RT_TRACE(COMP_INIT, "%s():priv->ResetProgress is %d\n", __FUNCTION__,priv->ResetProgress);
3364 if(priv->ResetProgress == RESET_TYPE_NORESET)
3365 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3366 if(priv->ResetProgress == RESET_TYPE_NORESET){
3367 CamResetAllEntry(dev);
3369 u8 SECR_value = 0x0;
3370 SECR_value |= SCR_TxEncEnable;
3371 SECR_value |= SCR_RxDecEnable;
3372 SECR_value |= SCR_NoSKMC;
3373 write_nic_byte(dev, SECR, SECR_value);
3378 write_nic_word(dev, ATIMWND, 2);
3379 write_nic_word(dev, BCN_INTERVAL, 100);
3382 #define DEFAULT_EDCA 0x005e4332
3384 for (i=0; i<QOS_QUEUE_NUM; i++)
3385 write_nic_dword(dev, WDCAPARA_ADD[i], DEFAULT_EDCA);
3387 #ifdef USB_RX_AGGREGATION_SUPPORT
3388 //3 For usb rx firmware aggregation control
3389 if(priv->ResetProgress == RESET_TYPE_NORESET)
3392 PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
3393 ulValue = (pHTInfo->UsbRxFwAggrEn<<24) | (pHTInfo->UsbRxFwAggrPageNum<<16) |
3394 (pHTInfo->UsbRxFwAggrPacketNum<<8) | (pHTInfo->UsbRxFwAggrTimeout);
3396 * If usb rx firmware aggregation is enabled,
3397 * when anyone of three threshold conditions above is reached,
3398 * firmware will send aggregated packet to driver.
3400 write_nic_dword(dev, 0x1a8, ulValue);
3401 priv->bCurrentRxAggrEnable = true;
3405 rtl8192_phy_configmac(dev);
3407 if (priv->card_8192_version == (u8) VERSION_819xU_A)
3409 rtl8192_phy_getTxPower(dev);
3410 rtl8192_phy_setTxPower(dev, priv->chan);
3414 init_status = init_firmware(dev);
3417 RT_TRACE(COMP_ERR,"ERR!!! %s(): Firmware download is failed\n", __FUNCTION__);
3420 RT_TRACE(COMP_INIT, "%s():after firmware download\n", __FUNCTION__);
3423 if(Adapter->ResetProgress == RESET_TYPE_NORESET)
3425 if(pMgntInfo->RegRfOff == TRUE)
3426 { // User disable RF via registry.
3427 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
3428 MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
3429 // Those actions will be discard in MgntActSet_RF_State because of the same state
3430 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3431 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3433 else if(pMgntInfo->RfOffReason > RF_CHANGE_BY_PS)
3434 { // H/W or S/W RF OFF before sleep.
3435 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RfOffReason(%d) ----------\n", pMgntInfo->RfOffReason));
3436 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3440 pHalData->eRFPowerState = eRfOn;
3441 pMgntInfo->RfOffReason = 0;
3442 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): RF is on ----------\n"));
3447 if(pHalData->eRFPowerState == eRfOff)
3449 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3450 // Those actions will be discard in MgntActSet_RF_State because of the same state
3451 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3452 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3457 if(priv->ResetProgress == RESET_TYPE_NORESET){
3458 rtl8192_phy_RFConfig(dev);
3459 RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __FUNCTION__);
3463 if(priv->ieee80211->FwRWRF)
3464 // We can force firmware to do RF-R/W
3465 priv->Rf_Mode = RF_OP_By_FW;
3467 priv->Rf_Mode = RF_OP_By_SW_3wire;
3470 rtl8192_phy_updateInitGain(dev);
3471 /*--set CCK and OFDM Block "ON"--*/
3472 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3473 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3475 if(priv->ResetProgress == RESET_TYPE_NORESET)
3478 u8 tmpvalue = read_nic_byte(dev, 0x301);
3482 RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
3486 priv->bDcut = FALSE;
3487 RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
3489 dm_initialize_txpower_tracking(dev);
3491 if(priv->bDcut == TRUE)
3494 u32 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3495 // u32 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3496 for(i = 0; i<TxBBGainTableLength; i++)
3498 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3500 priv->rfa_txpowertrackingindex= (u8)i;
3501 priv->rfa_txpowertrackingindex_real= (u8)i;
3502 priv->rfa_txpowertracking_default= priv->rfa_txpowertrackingindex;
3507 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3509 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3512 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3514 priv->cck_present_attentuation_20Mdefault=(u8) i;
3518 priv->cck_present_attentuation_40Mdefault= 0;
3519 priv->cck_present_attentuation_difference= 0;
3520 priv->cck_present_attentuation = priv->cck_present_attentuation_20Mdefault;
3522 // pMgntInfo->bTXPowerTracking = FALSE;//TEMPLY DISABLE
3525 write_nic_byte(dev, 0x87, 0x0);
3531 /* this configures registers for beacon tx and enables it via
3532 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3533 * be used to stop beacon transmission
3535 /***************************************************************************
3536 -------------------------------NET STUFF---------------------------
3537 ***************************************************************************/
3539 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
3541 struct r8192_priv *priv = ieee80211_priv(dev);
3543 return &priv->ieee80211->stats;
3547 HalTxCheckStuck819xUsb(
3548 struct net_device *dev
3551 struct r8192_priv *priv = ieee80211_priv(dev);
3552 u16 RegTxCounter = read_nic_word(dev, 0x128);
3553 bool bStuck = FALSE;
3554 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3555 if(priv->TxCounter==RegTxCounter)
3558 priv->TxCounter = RegTxCounter;
3564 * <Assumption: RT_TX_SPINLOCK is acquired.>
3565 * First added: 2006.11.19 by emily
3568 TxCheckStuck(struct net_device *dev)
3570 struct r8192_priv *priv = ieee80211_priv(dev);
3573 // u8 ResetThreshold;
3574 bool bCheckFwTxCnt = false;
3575 //unsigned long flags;
3578 // Decide such threshold according to current power save mode
3581 // RT_TRACE(COMP_RESET, " ==> TxCheckStuck()\n");
3582 // PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK);
3583 // spin_lock_irqsave(&priv->ieee80211->lock,flags);
3584 for (QueueID = 0; QueueID<=BEACON_QUEUE;QueueID ++)
3586 if(QueueID == TXCMD_QUEUE)
3588 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3589 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))
3591 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
3595 bCheckFwTxCnt = true;
3597 // PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
3598 // spin_unlock_irqrestore(&priv->ieee80211->lock,flags);
3599 // RT_TRACE(COMP_RESET,"bCheckFwTxCnt is %d\n",bCheckFwTxCnt);
3602 if(HalTxCheckStuck819xUsb(dev))
3604 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3605 return RESET_TYPE_SILENT;
3608 return RESET_TYPE_NORESET;
3612 HalRxCheckStuck819xUsb(struct net_device *dev)
3614 u16 RegRxCounter = read_nic_word(dev, 0x130);
3615 struct r8192_priv *priv = ieee80211_priv(dev);
3616 bool bStuck = FALSE;
3617 static u8 rx_chk_cnt = 0;
3618 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3619 // If rssi is small, we should check rx for long time because of bad rx.
3620 // or maybe it will continuous silent reset every 2 seconds.
3622 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3624 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
3626 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3627 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3628 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
3639 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
3640 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
3641 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
3645 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3651 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3658 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
3664 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
3668 if(priv->RxCounter==RegRxCounter)
3671 priv->RxCounter = RegRxCounter;
3677 RxCheckStuck(struct net_device *dev)
3679 struct r8192_priv *priv = ieee80211_priv(dev);
3681 bool bRxCheck = FALSE;
3683 // RT_TRACE(COMP_RESET," ==> RxCheckStuck()\n");
3684 //PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
3686 if(priv->IrpPendingCount > 1)
3688 //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
3690 // RT_TRACE(COMP_RESET,"bRxCheck is %d \n",bRxCheck);
3693 if(HalRxCheckStuck819xUsb(dev))
3695 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
3696 return RESET_TYPE_SILENT;
3699 return RESET_TYPE_NORESET;
3704 * This function is called by Checkforhang to check whether we should ask OS to reset driver
3706 * \param pAdapter The adapter context for this miniport
3708 * Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
3709 * to judge whether there is tx stuck.
3710 * Note: This function may be required to be rewrite for Vista OS.
3711 * <<<Assumption: Tx spinlock has been acquired >>>
3713 * 8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
3716 rtl819x_ifcheck_resetornot(struct net_device *dev)
3718 struct r8192_priv *priv = ieee80211_priv(dev);
3719 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
3720 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
3721 RT_RF_POWER_STATE rfState;
3723 rfState = priv->ieee80211->eRFPowerState;
3725 TxResetType = TxCheckStuck(dev);
3726 if( rfState != eRfOff ||
3727 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3728 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
3730 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3731 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3732 // if driver is in firmware download failure status, driver should initialize RF in the following
3733 // silent reset procedure Emily, 2008.01.21
3735 // Driver should not check RX stuck in IBSS mode because it is required to
3736 // set Check BSSID in order to send beacon, however, if check BSSID is
3737 // set, STA cannot hear any packet at all. Emily, 2008.04.12
3738 RxResetType = RxCheckStuck(dev);
3740 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
3741 return RESET_TYPE_NORMAL;
3742 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT){
3743 RT_TRACE(COMP_RESET,"%s():silent reset\n",__FUNCTION__);
3744 return RESET_TYPE_SILENT;
3747 return RESET_TYPE_NORESET;
3751 void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
3752 int _rtl8192_up(struct net_device *dev);
3753 int rtl8192_close(struct net_device *dev);
3758 CamRestoreAllEntry( struct net_device *dev)
3761 struct r8192_priv *priv = ieee80211_priv(dev);
3762 u8* MacAddr = priv->ieee80211->current_network.bssid;
3764 static u8 CAM_CONST_ADDR[4][6] = {
3765 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3766 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3767 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3768 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3769 static u8 CAM_CONST_BROAD[] =
3770 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3772 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3775 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
3776 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
3779 for(EntryId=0; EntryId<4; EntryId++)
3782 MacAddr = CAM_CONST_ADDR[EntryId];
3786 priv->ieee80211->pairwise_key_type,
3794 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
3798 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3802 priv->ieee80211->pairwise_key_type,
3810 priv->ieee80211->pairwise_key_type,
3816 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
3820 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3824 priv->ieee80211->pairwise_key_type,
3832 priv->ieee80211->pairwise_key_type,
3841 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
3843 MacAddr = CAM_CONST_BROAD;
3844 for(EntryId=1 ; EntryId<4 ; EntryId++)
3850 priv->ieee80211->group_key_type,
3856 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3860 priv->ieee80211->group_key_type,
3865 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
3867 MacAddr = CAM_CONST_BROAD;
3868 for(EntryId=1; EntryId<4 ; EntryId++)
3874 priv->ieee80211->group_key_type,
3881 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3885 priv->ieee80211->group_key_type,
3891 //////////////////////////////////////////////////////////////
3892 // This function is used to fix Tx/Rx stop bug temporarily.
3893 // This function will do "system reset" to NIC when Tx or Rx is stuck.
3894 // The method checking Tx/Rx stuck of this function is supported by FW,
3895 // which reports Tx and Rx counter to register 0x128 and 0x130.
3896 //////////////////////////////////////////////////////////////
3898 rtl819x_ifsilentreset(struct net_device *dev)
3900 //OCTET_STRING asocpdu;
3901 struct r8192_priv *priv = ieee80211_priv(dev);
3903 int reset_status = 0;
3904 struct ieee80211_device *ieee = priv->ieee80211;
3907 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3908 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3910 if(priv->ResetProgress==RESET_TYPE_NORESET)
3914 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
3916 // Set the variable for reset.
3917 priv->ResetProgress = RESET_TYPE_SILENT;
3918 // rtl8192_close(dev);
3919 down(&priv->wx_sem);
3922 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
3927 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
3928 // if(!netif_queue_stopped(dev))
3929 // netif_stop_queue(dev);
3931 rtl8192_rtx_disable(dev);
3932 rtl8192_cancel_deferred_work(priv);
3934 del_timer_sync(&priv->watch_dog_timer);
3936 ieee->sync_scan_hurryup = 1;
3937 if(ieee->state == IEEE80211_LINKED)
3939 down(&ieee->wx_sem);
3940 printk("ieee->state is IEEE80211_LINKED\n");
3941 ieee80211_stop_send_beacons(priv->ieee80211);
3942 del_timer_sync(&ieee->associate_timer);
3943 cancel_delayed_work(&ieee->associate_retry_wq);
3944 ieee80211_stop_scan(ieee);
3945 netif_carrier_off(dev);
3949 printk("ieee->state is NOT LINKED\n");
3950 ieee80211_softmac_stop_protocol(priv->ieee80211); }
3952 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
3953 //rtl8192_irq_disable(dev);
3954 RT_TRACE(COMP_RESET,"%s():===========>start up the driver\n",__FUNCTION__);
3955 reset_status = _rtl8192_up(dev);
3957 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
3958 if(reset_status == -EAGAIN)
3967 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n", __FUNCTION__);
3970 ieee->is_silent_reset = 1;
3971 EnableHWSecurityConfig8192(dev);
3972 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
3974 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3976 queue_work(ieee->wq, &ieee->associate_complete_wq);
3979 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
3981 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3982 ieee->link_change(ieee->dev);
3984 // notify_wx_assoc_event(ieee);
3986 ieee80211_start_send_beacons(ieee);
3988 if (ieee->data_hard_resume)
3989 ieee->data_hard_resume(ieee->dev);
3990 netif_carrier_on(ieee->dev);
3993 CamRestoreAllEntry(dev);
3995 priv->ResetProgress = RESET_TYPE_NORESET;
3996 priv->reset_count++;
3998 priv->bForcedSilentReset =false;
3999 priv->bResetInProgress = false;
4001 // For test --> force write UFWP.
4002 write_nic_byte(dev, UFWP, 1);
4003 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4007 void CAM_read_entry(
4008 struct net_device *dev,
4012 u32 target_command=0;
4013 u32 target_content=0;
4017 // printk("=======>start read CAM\n");
4018 for(entry_i=0;entry_i<CAM_CONTENT_COUNT;entry_i++)
4020 // polling bit, and No Write enable, and address
4021 target_command= entry_i+CAM_CONTENT_COUNT*iIndex;
4022 target_command= target_command | BIT31;
4024 //Check polling bit is clear
4028 ulStatus = read_nic_dword(dev, RWCAM);
4029 if(ulStatus & BIT31){
4036 write_nic_dword(dev, RWCAM, target_command);
4037 RT_TRACE(COMP_SEC,"CAM_read_entry(): WRITE A0: %x \n",target_command);
4038 // printk("CAM_read_entry(): WRITE A0: %lx \n",target_command);
4039 target_content = read_nic_dword(dev, RCAMO);
4040 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A8: %x \n",target_content);
4041 // printk("CAM_read_entry(): WRITE A8: %lx \n",target_content);
4046 void rtl819x_update_rxcounts(
4047 struct r8192_priv *priv,
4056 *TotalRxDataNum = 0;
4058 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4059 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4060 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4061 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4062 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4063 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4068 extern void rtl819x_watchdog_wqcallback(struct work_struct *work)
4070 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4071 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4072 struct net_device *dev = priv->ieee80211->dev;
4073 struct ieee80211_device* ieee = priv->ieee80211;
4074 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4075 static u8 check_reset_cnt=0;
4076 bool bBusyTraffic = false;
4080 hal_dm_watchdog(dev);
4082 {//to get busy traffic condition
4083 if(ieee->state == IEEE80211_LINKED)
4085 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 666 ||
4086 ieee->LinkDetectInfo.NumTxOkInPeriod> 666 ) {
4087 bBusyTraffic = true;
4089 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4090 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4091 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4094 //added by amy for AP roaming
4096 if(priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA)
4098 u32 TotalRxBcnNum = 0;
4099 u32 TotalRxDataNum = 0;
4101 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4102 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4105 if(rfState == eRfOff)
4106 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4108 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4109 // Dot11d_Reset(dev);
4110 priv->ieee80211->state = IEEE80211_ASSOCIATING;
4111 notify_wx_assoc_event(priv->ieee80211);
4112 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4113 priv->ieee80211->link_change(dev);
4114 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
4118 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod=0;
4119 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod=0;
4121 // CAM_read_entry(dev,4);
4122 //check if reset the driver
4123 if(check_reset_cnt++ >= 3)
4125 ResetType = rtl819x_ifcheck_resetornot(dev);
4126 check_reset_cnt = 3;
4127 //DbgPrint("Start to check silent reset\n");
4129 // 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);
4130 if( (priv->force_reset) || (priv->ResetProgress==RESET_TYPE_NORESET &&
4131 (priv->bForcedSilentReset ||
4132 (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT)))) // This is control by OID set in Pomelo
4134 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);
4135 rtl819x_ifsilentreset(dev);
4137 priv->force_reset = false;
4138 priv->bForcedSilentReset = false;
4139 priv->bResetInProgress = false;
4140 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4144 void watch_dog_timer_callback(unsigned long data)
4146 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4147 //printk("===============>watch_dog timer\n");
4148 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq, 0);
4149 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4151 int _rtl8192_up(struct net_device *dev)
4153 struct r8192_priv *priv = ieee80211_priv(dev);
4155 int init_status = 0;
4157 priv->ieee80211->ieee_up=1;
4158 RT_TRACE(COMP_INIT, "Bringing up iface");
4159 init_status = rtl8192_adapter_start(dev);
4162 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization failed!\n", __FUNCTION__);
4163 priv->up=priv->ieee80211->ieee_up = 0;
4166 RT_TRACE(COMP_INIT, "start adapter finished\n");
4167 rtl8192_rx_enable(dev);
4168 // rtl8192_tx_enable(dev);
4169 if(priv->ieee80211->state != IEEE80211_LINKED)
4170 ieee80211_softmac_start_protocol(priv->ieee80211);
4171 ieee80211_reset_queue(priv->ieee80211);
4172 watch_dog_timer_callback((unsigned long) dev);
4173 if(!netif_queue_stopped(dev))
4174 netif_start_queue(dev);
4176 netif_wake_queue(dev);
4182 int rtl8192_open(struct net_device *dev)
4184 struct r8192_priv *priv = ieee80211_priv(dev);
4186 down(&priv->wx_sem);
4187 ret = rtl8192_up(dev);
4194 int rtl8192_up(struct net_device *dev)
4196 struct r8192_priv *priv = ieee80211_priv(dev);
4198 if (priv->up == 1) return -1;
4200 return _rtl8192_up(dev);
4204 int rtl8192_close(struct net_device *dev)
4206 struct r8192_priv *priv = ieee80211_priv(dev);
4209 down(&priv->wx_sem);
4211 ret = rtl8192_down(dev);
4219 int rtl8192_down(struct net_device *dev)
4221 struct r8192_priv *priv = ieee80211_priv(dev);
4224 if (priv->up == 0) return -1;
4227 priv->ieee80211->ieee_up = 0;
4228 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4230 if (!netif_queue_stopped(dev))
4231 netif_stop_queue(dev);
4233 rtl8192_rtx_disable(dev);
4234 //rtl8192_irq_disable(dev);
4236 /* Tx related queue release */
4237 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4238 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
4240 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4241 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
4244 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4245 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ [i]);
4248 //as cancel_delayed_work will del work->timer, so if work is not defined as struct delayed_work, it will corrupt
4249 // flush_scheduled_work();
4250 rtl8192_cancel_deferred_work(priv);
4252 del_timer_sync(&priv->watch_dog_timer);
4255 ieee80211_softmac_stop_protocol(priv->ieee80211);
4256 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4257 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4263 void rtl8192_commit(struct net_device *dev)
4265 struct r8192_priv *priv = ieee80211_priv(dev);
4266 int reset_status = 0;
4267 //u8 reset_times = 0;
4268 if (priv->up == 0) return ;
4271 rtl8192_cancel_deferred_work(priv);
4272 del_timer_sync(&priv->watch_dog_timer);
4273 //cancel_delayed_work(&priv->SwChnlWorkItem);
4275 ieee80211_softmac_stop_protocol(priv->ieee80211);
4277 //rtl8192_irq_disable(dev);
4278 rtl8192_rtx_disable(dev);
4279 reset_status = _rtl8192_up(dev);
4284 void rtl8192_restart(struct net_device *dev)
4286 struct r8192_priv *priv = ieee80211_priv(dev);
4288 void rtl8192_restart(struct work_struct *work)
4290 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4291 struct net_device *dev = priv->ieee80211->dev;
4293 down(&priv->wx_sem);
4295 rtl8192_commit(dev);
4300 static void r8192_set_multicast(struct net_device *dev)
4302 struct r8192_priv *priv = ieee80211_priv(dev);
4305 //down(&priv->wx_sem);
4309 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4311 if (promisc != priv->promisc)
4312 // rtl8192_commit(dev);
4314 priv->promisc = promisc;
4316 //schedule_work(&priv->reset_wq);
4317 //up(&priv->wx_sem);
4321 int r8192_set_mac_adr(struct net_device *dev, void *mac)
4323 struct r8192_priv *priv = ieee80211_priv(dev);
4324 struct sockaddr *addr = mac;
4326 down(&priv->wx_sem);
4328 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4330 schedule_work(&priv->reset_wq);
4336 /* based on ipw2200 driver */
4337 int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4339 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4340 struct iwreq *wrq = (struct iwreq *)rq;
4342 struct ieee80211_device *ieee = priv->ieee80211;
4344 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4345 struct iw_point *p = &wrq->u.data;
4346 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
4348 down(&priv->wx_sem);
4351 if (p->length < sizeof(struct ieee_param) || !p->pointer){
4356 ipw = kmalloc(p->length, GFP_KERNEL);
4361 if (copy_from_user(ipw, p->pointer, p->length)) {
4368 case RTL_IOCTL_WPA_SUPPLICANT:
4369 //parse here for HW security
4370 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
4372 if (ipw->u.crypt.set_tx)
4374 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4375 ieee->pairwise_key_type = KEY_TYPE_CCMP;
4376 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4377 ieee->pairwise_key_type = KEY_TYPE_TKIP;
4378 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4380 if (ipw->u.crypt.key_len == 13)
4381 ieee->pairwise_key_type = KEY_TYPE_WEP104;
4382 else if (ipw->u.crypt.key_len == 5)
4383 ieee->pairwise_key_type = KEY_TYPE_WEP40;
4386 ieee->pairwise_key_type = KEY_TYPE_NA;
4388 if (ieee->pairwise_key_type)
4390 memcpy((u8*)key, ipw->u.crypt.key, 16);
4391 EnableHWSecurityConfig8192(dev);
4392 //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!
4394 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4395 if (ieee->auth_mode != 2)
4396 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4399 else //if (ipw->u.crypt.idx) //group key use idx > 0
4401 memcpy((u8*)key, ipw->u.crypt.key, 16);
4402 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4403 ieee->group_key_type= KEY_TYPE_CCMP;
4404 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4405 ieee->group_key_type = KEY_TYPE_TKIP;
4406 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4408 if (ipw->u.crypt.key_len == 13)
4409 ieee->group_key_type = KEY_TYPE_WEP104;
4410 else if (ipw->u.crypt.key_len == 5)
4411 ieee->group_key_type = KEY_TYPE_WEP40;
4414 ieee->group_key_type = KEY_TYPE_NA;
4416 if (ieee->group_key_type)
4420 ipw->u.crypt.idx, //KeyIndex
4421 ieee->group_key_type, //KeyType
4422 broadcast_addr, //MacAddr
4428 #ifdef JOHN_HWSEC_DEBUG
4430 printk("@@ wrq->u pointer = ");
4431 for(i=0;i<wrq->u.data.length;i++){
4432 if(i%10==0) printk("\n");
4433 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
4436 #endif /*JOHN_HWSEC_DEBUG*/
4437 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
4451 u8 HwRateToMRate90(bool bIsHT, u8 rate)
4457 case DESC90_RATE1M: ret_rate = MGN_1M; break;
4458 case DESC90_RATE2M: ret_rate = MGN_2M; break;
4459 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
4460 case DESC90_RATE11M: ret_rate = MGN_11M; break;
4461 case DESC90_RATE6M: ret_rate = MGN_6M; break;
4462 case DESC90_RATE9M: ret_rate = MGN_9M; break;
4463 case DESC90_RATE12M: ret_rate = MGN_12M; break;
4464 case DESC90_RATE18M: ret_rate = MGN_18M; break;
4465 case DESC90_RATE24M: ret_rate = MGN_24M; break;
4466 case DESC90_RATE36M: ret_rate = MGN_36M; break;
4467 case DESC90_RATE48M: ret_rate = MGN_48M; break;
4468 case DESC90_RATE54M: ret_rate = MGN_54M; break;
4472 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
4478 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
4479 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
4480 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
4481 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
4482 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
4483 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
4484 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
4485 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
4486 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
4487 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
4488 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
4489 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
4490 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
4491 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
4492 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
4493 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
4494 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
4498 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
4507 * Function: UpdateRxPktTimeStamp
4508 * Overview: Record the TSF time stamp when receiving a packet
4516 * (pRfd->Status.TimeStampHigh is updated)
4517 * (pRfd->Status.TimeStampLow is updated)
4521 void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
4523 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4525 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
4526 stats->mac_time[0] = priv->LastRxDescTSFLow;
4527 stats->mac_time[1] = priv->LastRxDescTSFHigh;
4529 priv->LastRxDescTSFLow = stats->mac_time[0];
4530 priv->LastRxDescTSFHigh = stats->mac_time[1];
4536 long rtl819x_translate_todbm(u8 signal_strength_index )// 0-100 index.
4538 long signal_power; // in dBm.
4540 // Translate to dBm (x=0.5y-95).
4541 signal_power = (long)((signal_strength_index + 1) >> 1);
4544 return signal_power;
4548 /* 2008/01/22 MH We can not declare RSSI/EVM total value of sliding window to
4549 be a local static. Otherwise, it may increase when we return from S3/S4. The
4550 value will be kept in memory or disk. Declare the value in the adaptor
4551 and it will be reinitialized when returned from S3/S4. */
4552 void rtl8192_process_phyinfo(struct r8192_priv * priv,u8* buffer, struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
4554 bool bcheck = false;
4556 u32 nspatial_stream, tmp_val;
4558 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
4559 static u32 slide_evm_index=0, slide_evm_statistics=0;
4560 static u32 last_rssi=0, last_evm=0;
4562 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
4563 static u32 last_beacon_adc_pwdb=0;
4565 struct ieee80211_hdr_3addr *hdr;
4567 unsigned int frag,seq;
4568 hdr = (struct ieee80211_hdr_3addr *)buffer;
4569 sc = le16_to_cpu(hdr->seq_ctl);
4570 frag = WLAN_GET_SEQ_FRAG(sc);
4571 seq = WLAN_GET_SEQ_SEQ(sc);
4572 //cosa add 04292008 to record the sequence number
4573 pcurrent_stats->Seq_Num = seq;
4575 // Check whether we should take the previous packet into accounting
4577 if(!pprevious_stats->bIsAMPDU)
4579 // if previous packet is not aggregated packet
4586 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
4588 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
4589 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
4590 priv->stats.slide_rssi_total -= last_rssi;
4592 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
4594 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
4595 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
4596 slide_rssi_index = 0;
4598 // <1> Showed on UI for user, in dbm
4599 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
4600 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
4601 pcurrent_stats->rssi = priv->stats.signal_strength;
4603 // If the previous packet does not match the criteria, neglect it
4605 if(!pprevious_stats->bPacketMatchBSSID)
4607 if(!pprevious_stats->bToSelfBA)
4615 //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
4620 priv->stats.num_process_phyinfo++;
4622 /* record the general signal strength to the sliding window. */
4625 // <2> Showed on UI for engineering
4626 // hardware does not provide rssi information for each rf path in CCK
4627 if(!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA))
4629 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++)
4631 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
4634 //Fixed by Jacken 2008-03-20
4635 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
4637 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
4638 //DbgPrint("MIMO RSSI initialize \n");
4640 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
4642 priv->stats.rx_rssi_percentage[rfpath] =
4643 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4644 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4645 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
4649 priv->stats.rx_rssi_percentage[rfpath] =
4650 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4651 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4653 RT_TRACE(COMP_DBG,"priv->stats.rx_rssi_percentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
4661 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4662 pprevious_stats->bIsCCK? "CCK": "OFDM",
4663 pprevious_stats->RxPWDBAll);
4665 if(pprevious_stats->bPacketBeacon)
4667 /* record the beacon pwdb to the sliding window. */
4668 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4670 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
4671 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
4672 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
4673 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
4674 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
4676 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
4677 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
4678 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
4679 slide_beacon_adc_pwdb_index++;
4680 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4681 slide_beacon_adc_pwdb_index = 0;
4682 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
4683 if(pprevious_stats->RxPWDBAll >= 3)
4684 pprevious_stats->RxPWDBAll -= 3;
4687 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4688 pprevious_stats->bIsCCK? "CCK": "OFDM",
4689 pprevious_stats->RxPWDBAll);
4692 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4694 if(priv->undecorated_smoothed_pwdb < 0) // initialize
4696 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
4697 //DbgPrint("First pwdb initialize \n");
4699 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
4701 priv->undecorated_smoothed_pwdb =
4702 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4703 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4704 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
4708 priv->undecorated_smoothed_pwdb =
4709 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4710 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4718 /* record the general EVM to the sliding window. */
4719 if(pprevious_stats->SignalQuality == 0)
4724 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
4725 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
4726 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
4727 last_evm = priv->stats.slide_evm[slide_evm_index];
4728 priv->stats.slide_evm_total -= last_evm;
4731 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
4733 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
4734 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
4735 slide_evm_index = 0;
4737 // <1> Showed on UI for user, in percentage.
4738 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
4739 priv->stats.signal_quality = tmp_val;
4740 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
4741 priv->stats.last_signal_strength_inpercent = tmp_val;
4744 // <2> Showed on UI for engineering
4745 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4747 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
4749 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
4751 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
4753 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
4755 priv->stats.rx_evm_percentage[nspatial_stream] =
4756 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
4757 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
4766 /*-----------------------------------------------------------------------------
4767 * Function: rtl819x_query_rxpwrpercentage()
4771 * Input: char antpower
4775 * Return: 0-100 percentage
4779 * 05/26/2008 amy Create Version 0 porting from windows code.
4781 *---------------------------------------------------------------------------*/
4782 static u8 rtl819x_query_rxpwrpercentage(
4786 if ((antpower <= -100) || (antpower >= 20))
4790 else if (antpower >= 0)
4796 return (100+antpower);
4799 } /* QueryRxPwrPercentage */
4802 rtl819x_evm_dbtopercentage(
4814 ret_val = 0 - ret_val;
4822 // We want good-looking for signal strength/quality
4823 // 2007/7/19 01:09, by cosa.
4826 rtl819x_signal_scale_mapping(
4832 // Step 1. Scale mapping.
4833 if(currsig >= 61 && currsig <= 100)
4835 retsig = 90 + ((currsig - 60) / 4);
4837 else if(currsig >= 41 && currsig <= 60)
4839 retsig = 78 + ((currsig - 40) / 2);
4841 else if(currsig >= 31 && currsig <= 40)
4843 retsig = 66 + (currsig - 30);
4845 else if(currsig >= 21 && currsig <= 30)
4847 retsig = 54 + (currsig - 20);
4849 else if(currsig >= 5 && currsig <= 20)
4851 retsig = 42 + (((currsig - 5) * 2) / 3);
4853 else if(currsig == 4)
4857 else if(currsig == 3)
4861 else if(currsig == 2)
4865 else if(currsig == 1)
4877 static void rtl8192_query_rxphystatus(
4878 struct r8192_priv * priv,
4879 struct ieee80211_rx_stats * pstats,
4880 rx_drvinfo_819x_usb * pdrvinfo,
4881 struct ieee80211_rx_stats * precord_stats,
4882 bool bpacket_match_bssid,
4883 bool bpacket_toself,
4888 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
4889 phy_sts_ofdm_819xusb_t* pofdm_buf;
4890 phy_sts_cck_819xusb_t * pcck_buf;
4891 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
4893 u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
4894 char rx_pwr[4], rx_pwr_all=0;
4895 //long rx_avg_pwr = 0;
4896 char rx_snrX, rx_evmX;
4898 u32 RSSI, total_rssi=0;//, total_evm=0;
4899 // long signal_strength_index = 0;
4904 priv->stats.numqry_phystatus++;
4906 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
4908 // Record it for next packet processing
4909 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
4910 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
4911 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
4912 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
4913 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
4914 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
4916 prxpkt = (u8*)pdrvinfo;
4918 /* Move pointer to the 16th bytes. Phy status start address. */
4919 prxpkt += sizeof(rx_drvinfo_819x_usb);
4921 /* Initial the cck and ofdm buffer pointer */
4922 pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
4923 pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
4925 pstats->RxMIMOSignalQuality[0] = -1;
4926 pstats->RxMIMOSignalQuality[1] = -1;
4927 precord_stats->RxMIMOSignalQuality[0] = -1;
4928 precord_stats->RxMIMOSignalQuality[1] = -1;
4933 // (1)Hardware does not provide RSSI for CCK
4937 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4939 u8 report;//, cck_agc_rpt;
4941 priv->stats.numqry_phystatusCCK++;
4943 if(!priv->bCckHighPower)
4945 report = pcck_buf->cck_agc_rpt & 0xc0;
4949 //Fixed by Jacken from Bryant 2008-03-20
4950 //Original value is -38 , -26 , -14 , -2
4951 //Fixed value is -35 , -23 , -11 , 6
4953 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
4956 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
4959 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
4962 rx_pwr_all = 6 - (pcck_buf->cck_agc_rpt & 0x3e);
4968 report = pcck_buf->cck_agc_rpt & 0x60;
4973 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
4976 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4979 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
4982 rx_pwr_all = 6 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
4987 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
4988 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
4989 pstats->RecvSignalPower = pwdb_all;
4992 // (3) Get Signal Quality (EVM)
4994 //if(bpacket_match_bssid)
4998 if(pstats->RxPWDBAll > 40)
5003 sq = pcck_buf->sq_rpt;
5005 if(pcck_buf->sq_rpt > 64)
5007 else if (pcck_buf->sq_rpt < 20)
5010 sq = ((64-sq) * 100) / 44;
5012 pstats->SignalQuality = precord_stats->SignalQuality = sq;
5013 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5014 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5019 priv->stats.numqry_phystatusHT++;
5021 // (1)Get RSSI for HT rate
5023 for(i=RF90_PATH_A; i<priv->NumTotalRFPath; i++)
5025 // 2008/01/30 MH we will judge RF RX path now.
5026 if (priv->brfpath_rxenable[i])
5031 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
5034 //Fixed by Jacken from Bryant 2008-03-20
5035 //Original value is 106
5036 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5038 //Get Rx snr value in DB
5039 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5040 rx_snrX = (char)(tmp_rxsnr);
5043 priv->stats.rxSNRdB[i] = (long)rx_snrX;
5045 /* Translate DBM to percentage. */
5046 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5049 /* Record Signal Strength for next packet */
5050 //if(bpacket_match_bssid)
5052 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5053 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5059 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5061 //Fixed by Jacken from Bryant 2008-03-20
5062 //Original value is 106
5063 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5064 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5066 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5067 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5070 // (3)EVM of HT rate
5072 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5073 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5074 max_spatial_stream = 2; //both spatial stream make sense
5076 max_spatial_stream = 1; //only spatial stream 1 makes sense
5078 for(i=0; i<max_spatial_stream; i++)
5080 tmp_rxevm = pofdm_buf->rxevm_X[i];
5081 rx_evmX = (char)(tmp_rxevm);
5083 // Do not use shift operation like "rx_evmX >>= 1" because the compiler of free build environment
5084 // will set the most significant bit to "zero" when doing shifting operation which may change a negative
5085 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5088 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5089 //if(bpacket_match_bssid)
5091 if(i==0) // Fill value in RFD, Get the first spatial stream only
5092 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5093 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5098 /* record rx statistics for debug */
5099 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5100 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5101 if(pdrvinfo->BW) //40M channel
5102 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5104 priv->stats.received_bwtype[0]++;
5107 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5108 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5111 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5116 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u8)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u8)(total_rssi/=RF90_PATH_MAX);
5117 // We can judge RX path number now.
5119 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5121 } /* QueryRxPhyStatus8190Pci */
5124 rtl8192_record_rxdesc_forlateruse(
5125 struct ieee80211_rx_stats * psrc_stats,
5126 struct ieee80211_rx_stats * ptarget_stats
5129 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5130 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5131 ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5135 void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
5136 struct ieee80211_rx_stats * pstats,
5137 rx_drvinfo_819x_usb *pdrvinfo)
5139 // TODO: We must only check packet for current MAC address. Not finish
5140 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5141 struct net_device *dev=info->dev;
5142 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5143 bool bpacket_match_bssid, bpacket_toself;
5144 bool bPacketBeacon=FALSE, bToSelfBA=FALSE;
5145 static struct ieee80211_rx_stats previous_stats;
5146 struct ieee80211_hdr_3addr *hdr;//by amy
5149 // Get Signal Quality for only RX data queue (but not command queue)
5152 //u16 tmp_buf_len = 0;
5155 /* Get MAC frame start address. */
5156 tmp_buf = (u8*)skb->data;// + get_rxpacket_shiftbytes_819xusb(pstats);
5158 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5159 fc = le16_to_cpu(hdr->frame_ctl);
5160 type = WLAN_FC_GET_TYPE(fc);
5161 praddr = hdr->addr1;
5163 /* Check if the received packet is acceptable. */
5164 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5165 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5166 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5167 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5169 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5171 bPacketBeacon = true;
5172 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5174 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5176 if((eqMacAddr(praddr,dev->dev_addr)))
5178 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5183 if(bpacket_match_bssid)
5185 priv->stats.numpacket_matchbssid++;
5188 priv->stats.numpacket_toself++;
5191 // Process PHY information for previous packet (RSSI/PWDB/EVM)
5193 // Because phy information is contained in the last packet of AMPDU only, so driver
5194 // should process phy information of previous packet
5195 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
5196 rtl8192_query_rxphystatus(priv, pstats, pdrvinfo, &previous_stats, bpacket_match_bssid,bpacket_toself,bPacketBeacon,bToSelfBA);
5197 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
5202 * Function: UpdateReceivedRateHistogramStatistics
5203 * Overview: Record the received data rate
5206 * struct net_device *dev
5207 * struct ieee80211_rx_stats *stats
5211 * (priv->stats.ReceivedRateHistogram[] is updated)
5216 UpdateReceivedRateHistogramStatistics8190(
5217 struct net_device *dev,
5218 struct ieee80211_rx_stats *stats
5221 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5222 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
5224 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
5229 else if(stats->bICV)
5232 if(stats->bShortPreamble)
5233 preamble_guardinterval = 1;// short
5235 preamble_guardinterval = 0;// long
5242 case MGN_1M: rateIndex = 0; break;
5243 case MGN_2M: rateIndex = 1; break;
5244 case MGN_5_5M: rateIndex = 2; break;
5245 case MGN_11M: rateIndex = 3; break;
5249 case MGN_6M: rateIndex = 4; break;
5250 case MGN_9M: rateIndex = 5; break;
5251 case MGN_12M: rateIndex = 6; break;
5252 case MGN_18M: rateIndex = 7; break;
5253 case MGN_24M: rateIndex = 8; break;
5254 case MGN_36M: rateIndex = 9; break;
5255 case MGN_48M: rateIndex = 10; break;
5256 case MGN_54M: rateIndex = 11; break;
5258 // 11n High throughput rate
5260 case MGN_MCS0: rateIndex = 12; break;
5261 case MGN_MCS1: rateIndex = 13; break;
5262 case MGN_MCS2: rateIndex = 14; break;
5263 case MGN_MCS3: rateIndex = 15; break;
5264 case MGN_MCS4: rateIndex = 16; break;
5265 case MGN_MCS5: rateIndex = 17; break;
5266 case MGN_MCS6: rateIndex = 18; break;
5267 case MGN_MCS7: rateIndex = 19; break;
5268 case MGN_MCS8: rateIndex = 20; break;
5269 case MGN_MCS9: rateIndex = 21; break;
5270 case MGN_MCS10: rateIndex = 22; break;
5271 case MGN_MCS11: rateIndex = 23; break;
5272 case MGN_MCS12: rateIndex = 24; break;
5273 case MGN_MCS13: rateIndex = 25; break;
5274 case MGN_MCS14: rateIndex = 26; break;
5275 case MGN_MCS15: rateIndex = 27; break;
5276 default: rateIndex = 28; break;
5278 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
5279 priv->stats.received_rate_histogram[0][rateIndex]++; //total
5280 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
5284 void query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe)
5286 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5287 struct net_device *dev=info->dev;
5288 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5289 //rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5290 rx_drvinfo_819x_usb *driver_info = NULL;
5293 //Get Rx Descriptor Information
5295 #ifdef USB_RX_AGGREGATION_SUPPORT
5296 if (bIsRxAggrSubframe)
5298 rx_desc_819x_usb_aggr_subframe *desc = (rx_desc_819x_usb_aggr_subframe *)skb->data;
5299 stats->Length = desc->Length ;
5300 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5301 stats->RxBufShift = 0; //RxBufShift = 2 in RxDesc, but usb didn't shift bytes in fact.
5302 stats->bICV = desc->ICV;
5303 stats->bCRC = desc->CRC32;
5304 stats->bHwError = stats->bCRC|stats->bICV;
5305 stats->Decrypted = !desc->SWDec;//RTL8190 set this bit to indicate that Hw does not decrypt packet
5309 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5311 stats->Length = desc->Length;
5312 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5313 stats->RxBufShift = 0;//desc->Shift&0x03;
5314 stats->bICV = desc->ICV;
5315 stats->bCRC = desc->CRC32;
5316 stats->bHwError = stats->bCRC|stats->bICV;
5317 //RTL8190 set this bit to indicate that Hw does not decrypt packet
5318 stats->Decrypted = !desc->SWDec;
5321 if((priv->ieee80211->pHTInfo->bCurrentHTSupport == true) && (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP))
5323 stats->bHwError = false;
5327 stats->bHwError = stats->bCRC|stats->bICV;
5330 if(stats->Length < 24 || stats->Length > MAX_8192U_RX_SIZE)
5331 stats->bHwError |= 1;
5335 // TODO: Need to verify it on FGPA platform
5336 //Driver info are written to the RxBuffer following rx desc
5337 if (stats->RxDrvInfoSize != 0) {
5338 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) + \
5342 if(!stats->bHwError){
5344 ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
5345 if(ret_rate == 0xff)
5347 // Abnormal Case: Receive CRC OK packet with Rx descriptor indicating non supported rate.
5348 // Special Error Handling here, 2008.05.16, by Emily
5350 stats->bHwError = 1;
5351 stats->rate = MGN_1M; //Set 1M rate by default
5354 stats->rate = ret_rate;
5360 stats->bShortPreamble = driver_info->SPLCP;
5363 UpdateReceivedRateHistogramStatistics8190(dev, stats);
5365 stats->bIsAMPDU = (driver_info->PartAggr==1);
5366 stats->bFirstMPDU = (driver_info->PartAggr==1) && (driver_info->FirstAGGR==1);
5367 stats->TimeStampLow = driver_info->TSFL;
5368 // xiong mask it, 070514
5369 //pRfd->Status.TimeStampHigh = PlatformEFIORead4Byte(Adapter, TSFR+4);
5370 // stats->TimeStampHigh = read_nic_dword(dev, TSFR+4);
5372 UpdateRxPktTimeStamp8190(dev, stats);
5377 if(driver_info->FirstAGGR==1 || driver_info->PartAggr == 1)
5378 RT_TRACE(COMP_RXDESC, "driver_info->FirstAGGR = %d, driver_info->PartAggr = %d\n",
5379 driver_info->FirstAGGR, driver_info->PartAggr);
5383 skb_pull(skb,sizeof(rx_desc_819x_usb));
5385 // Get Total offset of MPDU Frame Body
5387 if((stats->RxBufShift + stats->RxDrvInfoSize) > 0) {
5389 skb_pull(skb,stats->RxBufShift + stats->RxDrvInfoSize);
5392 #ifdef USB_RX_AGGREGATION_SUPPORT
5393 /* for the rx aggregated sub frame, the redundant space truly contained in the packet */
5394 if(bIsRxAggrSubframe) {
5398 /* for debug 2008.5.29 */
5400 //added by vivi, for MP, 20080108
5401 stats->RxIs40MHzPacket = driver_info->BW;
5402 if(stats->RxDrvInfoSize != 0)
5403 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
5407 u32 GetRxPacketShiftBytes819xUsb(struct ieee80211_rx_stats *Status, bool bIsRxAggrSubframe)
5409 #ifdef USB_RX_AGGREGATION_SUPPORT
5410 if (bIsRxAggrSubframe)
5411 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5412 + Status->RxBufShift + 8);
5415 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5416 + Status->RxBufShift);
5419 void rtl8192_rx_nomal(struct sk_buff* skb)
5421 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5422 struct net_device *dev=info->dev;
5423 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5424 struct ieee80211_rx_stats stats = {
5428 // .mac_time = jiffies,
5429 .freq = IEEE80211_24GHZ_BAND,
5432 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
5433 bool unicast_packet = false;
5434 #ifdef USB_RX_AGGREGATION_SUPPORT
5435 struct sk_buff *agg_skb = NULL;
5436 u32 TotalLength = 0;
5438 u32 PacketLength = 0;
5439 u32 PacketOccupiedLendth = 0;
5441 u32 PacketShiftBytes = 0;
5442 rx_desc_819x_usb_aggr_subframe *RxDescr = NULL;
5443 u8 PaddingBytes = 0;
5444 //add just for testing
5449 /* 20 is for ps-poll */
5450 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
5451 #ifdef USB_RX_AGGREGATION_SUPPORT
5452 TempByte = *(skb->data + sizeof(rx_desc_819x_usb));
5454 /* first packet should not contain Rx aggregation header */
5455 query_rxdesc_status(skb, &stats, false);
5457 /* hardware related info */
5458 #ifdef USB_RX_AGGREGATION_SUPPORT
5459 if (TempByte & BIT0) {
5461 //TotalLength = agg_skb->len - 4; /*sCrcLng*/
5462 TotalLength = stats.Length - 4; /*sCrcLng*/
5463 //RT_TRACE(COMP_RECV, "%s:first aggregated packet!Length=%d\n",__FUNCTION__,TotalLength);
5464 /* though the head pointer has passed this position */
5465 TempDWord = *(u32 *)(agg_skb->data - 4);
5466 PacketLength = (u16)(TempDWord & 0x3FFF); /*sCrcLng*/
5467 skb = dev_alloc_skb(PacketLength);
5468 memcpy(skb_put(skb,PacketLength),agg_skb->data,PacketLength);
5469 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, false);
5472 /* Process the MPDU received */
5473 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5475 rx_pkt_len = skb->len;
5476 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5477 unicast_packet = false;
5478 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5480 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5483 /* unicast packet */
5484 unicast_packet = true;
5487 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5488 dev_kfree_skb_any(skb);
5490 priv->stats.rxoktotal++;
5491 if(unicast_packet) {
5492 priv->stats.rxbytesunicast += rx_pkt_len;
5495 #ifdef USB_RX_AGGREGATION_SUPPORT
5497 // (PipeIndex == 0) && (TempByte & BIT0) => TotalLength > 0.
5498 if (TotalLength > 0) {
5499 PacketOccupiedLendth = PacketLength + (PacketShiftBytes + 8);
5500 if ((PacketOccupiedLendth & 0xFF) != 0)
5501 PacketOccupiedLendth = (PacketOccupiedLendth & 0xFFFFFF00) + 256;
5502 PacketOccupiedLendth -= 8;
5503 TempDWord = PacketOccupiedLendth - PacketShiftBytes; /*- PacketLength */
5504 if (agg_skb->len > TempDWord)
5505 skb_pull(agg_skb, TempDWord);
5509 while (agg_skb->len>=GetRxPacketShiftBytes819xUsb(&stats, true)) {
5510 u8 tmpCRC = 0, tmpICV = 0;
5511 //RT_TRACE(COMP_RECV,"%s:aggred pkt,total_len = %d\n",__FUNCTION__,agg_skb->len);
5512 RxDescr = (rx_desc_819x_usb_aggr_subframe *)(agg_skb->data);
5513 tmpCRC = RxDescr->CRC32;
5514 tmpICV = RxDescr->ICV;
5515 memcpy(agg_skb->data, &agg_skb->data[44], 2);
5516 RxDescr->CRC32 = tmpCRC;
5517 RxDescr->ICV = tmpICV;
5519 memset(&stats, 0, sizeof(struct ieee80211_rx_stats));
5523 stats.freq = IEEE80211_24GHZ_BAND;
5524 query_rxdesc_status(agg_skb, &stats, true);
5525 PacketLength = stats.Length;
5527 if(PacketLength > agg_skb->len) {
5530 /* Process the MPDU received */
5531 skb = dev_alloc_skb(PacketLength);
5532 memcpy(skb_put(skb,PacketLength),agg_skb->data, PacketLength);
5533 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5535 rx_pkt_len = skb->len;
5536 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5537 unicast_packet = false;
5538 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5540 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5543 /* unicast packet */
5544 unicast_packet = true;
5546 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5547 dev_kfree_skb_any(skb);
5549 priv->stats.rxoktotal++;
5550 if(unicast_packet) {
5551 priv->stats.rxbytesunicast += rx_pkt_len;
5554 /* should trim the packet which has been copied to target skb */
5555 skb_pull(agg_skb, PacketLength);
5556 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, true);
5557 PacketOccupiedLendth = PacketLength + PacketShiftBytes;
5558 if ((PacketOccupiedLendth & 0xFF) != 0) {
5559 PaddingBytes = 256 - (PacketOccupiedLendth & 0xFF);
5560 if (agg_skb->len > PaddingBytes)
5561 skb_pull(agg_skb, PaddingBytes);
5566 dev_kfree_skb(agg_skb);
5570 priv->stats.rxurberr++;
5571 printk("actual_length:%d\n", skb->len);
5572 dev_kfree_skb_any(skb);
5578 rtl819xusb_process_received_packet(
5579 struct net_device *dev,
5580 struct ieee80211_rx_stats *pstats
5583 // bool bfreerfd=false, bqueued=false;
5586 struct r8192_priv *priv = ieee80211_priv(dev);
5590 //PRX_TS_RECORD pts = NULL;
5592 // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
5593 //porting by amy 080508
5594 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
5595 frame = pstats->virtual_address;
5596 frame_len = pstats->packetlength;
5597 #ifdef TODO // by amy about HCT
5598 if(!Adapter->bInHctTest)
5599 CountRxErrStatistics(Adapter, pRfd);
5602 #ifdef ENABLE_PS //by amy for adding ps function in future
5603 RT_RF_POWER_STATE rtState;
5604 // When RF is off, we should not count the packet for hw/sw synchronize
5605 // reason, ie. there may be a duration while sw switch is changed and hw
5606 // switch is being changed. 2006.12.04, by shien chang.
5607 Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8* )(&rtState));
5608 if (rtState == eRfOff)
5613 priv->stats.rxframgment++;
5617 RmMonitorSignalStrength(Adapter, pRfd);
5619 /* 2007/01/16 MH Add RX command packet handle here. */
5620 /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
5621 if (rtl819xusb_rx_command_packet(dev, pstats))
5633 void query_rx_cmdpkt_desc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats)
5635 // rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5636 // struct net_device *dev=info->dev;
5637 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5638 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5639 // rx_drvinfo_819x_usb *driver_info;
5642 //Get Rx Descriptor Information
5644 stats->virtual_address = (u8*)skb->data;
5645 stats->Length = desc->Length;
5646 stats->RxDrvInfoSize = 0;
5647 stats->RxBufShift = 0;
5648 stats->packetlength = stats->Length-scrclng;
5649 stats->fraglength = stats->packetlength;
5650 stats->fragoffset = 0;
5651 stats->ntotalfrag = 1;
5655 void rtl8192_rx_cmd(struct sk_buff *skb)
5657 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5658 struct net_device *dev = info->dev;
5660 // struct urb *rx_urb = info->urb;
5662 struct ieee80211_rx_stats stats = {
5666 // .mac_time = jiffies,
5667 .freq = IEEE80211_24GHZ_BAND,
5670 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE))
5673 query_rx_cmdpkt_desc_status(skb,&stats);
5674 // this is to be done by amy 080508 prfd->queue_id = 1;
5678 // Process the command packet received.
5681 rtl819xusb_process_received_packet(dev,&stats);
5683 dev_kfree_skb_any(skb);
5691 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
5693 struct sk_buff *skb;
5694 struct rtl8192_rx_info *info;
5696 while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
5697 info = (struct rtl8192_rx_info *)skb->cb;
5698 switch (info->out_pipe) {
5699 /* Nomal packet pipe */
5701 //RT_TRACE(COMP_RECV, "normal in-pipe index(%d)\n",info->out_pipe);
5702 priv->IrpPendingCount--;
5703 rtl8192_rx_nomal(skb);
5706 /* Command packet pipe */
5708 RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",\
5711 rtl8192_rx_cmd(skb);
5714 default: /* should never get here! */
5715 RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",\
5724 static const struct net_device_ops rtl8192_netdev_ops = {
5725 .ndo_open = rtl8192_open,
5726 .ndo_stop = rtl8192_close,
5727 .ndo_get_stats = rtl8192_stats,
5728 .ndo_tx_timeout = tx_timeout,
5729 .ndo_do_ioctl = rtl8192_ioctl,
5730 .ndo_set_rx_mode = r8192_set_multicast,
5731 .ndo_set_mac_address = r8192_set_mac_adr,
5732 .ndo_validate_addr = eth_validate_addr,
5733 .ndo_change_mtu = eth_change_mtu,
5734 .ndo_start_xmit = ieee80211_xmit,
5738 /****************************************************************************
5739 ---------------------------- USB_STUFF---------------------------
5740 *****************************************************************************/
5742 static int rtl8192_usb_probe(struct usb_interface *intf,
5743 const struct usb_device_id *id)
5745 // unsigned long ioaddr = 0;
5746 struct net_device *dev = NULL;
5747 struct r8192_priv *priv= NULL;
5748 struct usb_device *udev = interface_to_usbdev(intf);
5750 RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
5752 dev = alloc_ieee80211(sizeof(struct r8192_priv));
5756 usb_set_intfdata(intf, dev);
5757 SET_NETDEV_DEV(dev, &intf->dev);
5758 priv = ieee80211_priv(dev);
5759 priv->ieee80211 = netdev_priv(dev);
5762 dev->netdev_ops = &rtl8192_netdev_ops;
5764 //DMESG("Oops: i'm coming\n");
5765 #if WIRELESS_EXT >= 12
5766 #if WIRELESS_EXT < 17
5767 dev->get_wireless_stats = r8192_get_wireless_stats;
5769 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
5771 dev->type=ARPHRD_ETHER;
5773 dev->watchdog_timeo = HZ*3; //modified by john, 0805
5775 if (dev_alloc_name(dev, ifname) < 0){
5776 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
5778 dev_alloc_name(dev, ifname);
5781 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
5782 if(rtl8192_init(dev)!=0){
5783 RT_TRACE(COMP_ERR, "Initialization failed");
5787 netif_carrier_off(dev);
5788 netif_stop_queue(dev);
5790 ret = register_netdev(dev);
5794 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
5795 rtl8192_proc_init_one(dev);
5798 RT_TRACE(COMP_INIT, "Driver probe completed\n");
5803 kfree(priv->pFirmware);
5804 priv->pFirmware = NULL;
5805 rtl8192_usb_deleteendpoints(dev);
5806 destroy_workqueue(priv->priv_wq);
5809 free_ieee80211(dev);
5811 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
5815 //detach all the work and timer structure declared or inititialize in r8192U_init function.
5816 void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
5819 cancel_work_sync(&priv->reset_wq);
5820 cancel_delayed_work(&priv->watch_dog_wq);
5821 cancel_delayed_work(&priv->update_beacon_wq);
5822 cancel_work_sync(&priv->qos_activate);
5823 //cancel_work_sync(&priv->SetBWModeWorkItem);
5824 //cancel_work_sync(&priv->SwChnlWorkItem);
5829 static void rtl8192_usb_disconnect(struct usb_interface *intf)
5831 struct net_device *dev = usb_get_intfdata(intf);
5833 struct r8192_priv *priv = ieee80211_priv(dev);
5836 unregister_netdev(dev);
5838 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
5839 rtl8192_proc_remove_one(dev);
5842 kfree(priv->pFirmware);
5843 priv->pFirmware = NULL;
5844 // priv->rf_close(dev);
5845 // rtl8192_SetRFPowerState(dev, eRfOff);
5846 rtl8192_usb_deleteendpoints(dev);
5847 destroy_workqueue(priv->priv_wq);
5848 //rtl8192_irq_disable(dev);
5849 //rtl8192_reset(dev);
5853 free_ieee80211(dev);
5854 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
5857 /* fun with the built-in ieee80211 stack... */
5858 extern int ieee80211_debug_init(void);
5859 extern void ieee80211_debug_exit(void);
5860 extern int ieee80211_crypto_init(void);
5861 extern void ieee80211_crypto_deinit(void);
5862 extern int ieee80211_crypto_tkip_init(void);
5863 extern void ieee80211_crypto_tkip_exit(void);
5864 extern int ieee80211_crypto_ccmp_init(void);
5865 extern void ieee80211_crypto_ccmp_exit(void);
5866 extern int ieee80211_crypto_wep_init(void);
5867 extern void ieee80211_crypto_wep_exit(void);
5869 static int __init rtl8192_usb_module_init(void)
5873 #ifdef CONFIG_IEEE80211_DEBUG
5874 ret = ieee80211_debug_init();
5876 printk(KERN_ERR "ieee80211_debug_init() failed %d\n", ret);
5880 ret = ieee80211_crypto_init();
5882 printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
5886 ret = ieee80211_crypto_tkip_init();
5888 printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n",
5893 ret = ieee80211_crypto_ccmp_init();
5895 printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n",
5900 ret = ieee80211_crypto_wep_init();
5902 printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
5906 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
5907 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
5908 RT_TRACE(COMP_INIT, "Initializing module");
5909 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
5910 rtl8192_proc_module_init();
5911 return usb_register(&rtl8192_usb_driver);
5915 static void __exit rtl8192_usb_module_exit(void)
5917 usb_deregister(&rtl8192_usb_driver);
5919 RT_TRACE(COMP_DOWN, "Exiting");
5920 // rtl8192_proc_module_remove();
5924 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
5926 unsigned long flags;
5928 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5930 spin_lock_irqsave(&priv->tx_lock,flags);
5931 enough_desc = check_nic_enough_desc(dev,pri);
5932 spin_unlock_irqrestore(&priv->tx_lock,flags);
5935 ieee80211_wake_queue(priv->ieee80211);
5938 void EnableHWSecurityConfig8192(struct net_device *dev)
5940 u8 SECR_value = 0x0;
5941 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5942 struct ieee80211_device* ieee = priv->ieee80211;
5943 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
5944 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
5946 SECR_value |= SCR_RxUseDK;
5947 SECR_value |= SCR_TxUseDK;
5949 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
5951 SECR_value |= SCR_RxUseDK;
5952 SECR_value |= SCR_TxUseDK;
5954 //add HWSec active enable here.
5955 //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
5957 ieee->hwsec_active = 1;
5959 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
5961 ieee->hwsec_active = 0;
5962 SECR_value &= ~SCR_RxDecEnable;
5964 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__, \
5965 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
5967 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
5972 void setKey( struct net_device *dev,
5980 u32 TargetCommand = 0;
5981 u32 TargetContent = 0;
5984 if (EntryNo >= TOTAL_CAM_ENTRY)
5985 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
5987 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
5990 usConfig |= BIT15 | (KeyType<<2);
5992 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
5993 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
5996 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
5997 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
5998 TargetCommand |= BIT31|BIT16;
6000 if(i==0){//MAC|Config
6001 TargetContent = (u32)(*(MacAddr+0)) << 16|
6002 (u32)(*(MacAddr+1)) << 24|
6005 write_nic_dword(dev, WCAMI, TargetContent);
6006 write_nic_dword(dev, RWCAM, TargetCommand);
6007 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6010 TargetContent = (u32)(*(MacAddr+2)) |
6011 (u32)(*(MacAddr+3)) << 8|
6012 (u32)(*(MacAddr+4)) << 16|
6013 (u32)(*(MacAddr+5)) << 24;
6014 write_nic_dword(dev, WCAMI, TargetContent);
6015 write_nic_dword(dev, RWCAM, TargetCommand);
6019 if(KeyContent !=NULL){
6020 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6021 write_nic_dword(dev, RWCAM, TargetCommand);
6028 /***************************************************************************
6029 ------------------- module init / exit stubs ----------------
6030 ****************************************************************************/
6031 module_init(rtl8192_usb_module_init);
6032 module_exit(rtl8192_usb_module_exit);