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 #include <linux/proc_fs.h>
75 #include <linux/seq_file.h>
76 // FIXME: check if 2.6.7 is ok
78 #ifdef CONFIG_RTL8192_PM
83 //set here to open your trace code. //WB
84 u32 rt_global_debug_component = \
92 // COMP_POWER_TRACKING |
103 COMP_ERR ; //always open err flags on
105 #define TOTAL_CAM_ENTRY 32
106 #define CAM_CONTENT_COUNT 8
108 static const struct usb_device_id rtl8192_usb_id_tbl[] = {
110 {USB_DEVICE(0x0bda, 0x8709)},
112 {USB_DEVICE(0x07aa, 0x0043)},
114 {USB_DEVICE(0x050d, 0x805E)},
116 {USB_DEVICE(0x0df6, 0x0031)},
118 {USB_DEVICE(0x1740, 0x9201)},
120 {USB_DEVICE(0x2001, 0x3301)},
122 {USB_DEVICE(0x5a57, 0x0290)},
124 {USB_DEVICE(0x043e, 0x7a01)},
128 MODULE_LICENSE("GPL");
129 MODULE_VERSION("V 1.1");
130 MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
131 MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
133 static char* ifname = "wlan%d";
134 static int hwwep = 1; //default use hw. set 0 to use software security
135 static int channels = 0x3fff;
139 module_param(ifname, charp, S_IRUGO|S_IWUSR );
140 //module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
141 module_param(hwwep,int, S_IRUGO|S_IWUSR);
142 module_param(channels,int, S_IRUGO|S_IWUSR);
144 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
145 //MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
146 MODULE_PARM_DESC(hwwep," Try to use hardware security support. ");
147 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
149 static int rtl8192_usb_probe(struct usb_interface *intf,
150 const struct usb_device_id *id);
151 static void rtl8192_usb_disconnect(struct usb_interface *intf);
154 static struct usb_driver rtl8192_usb_driver = {
155 .name = RTL819xU_MODULE_NAME, /* Driver name */
156 .id_table = rtl8192_usb_id_tbl, /* PCI_ID table */
157 .probe = rtl8192_usb_probe, /* probe fn */
158 .disconnect = rtl8192_usb_disconnect, /* remove fn */
159 #ifdef CONFIG_RTL8192_PM
160 .suspend = rtl8192_suspend, /* PM suspend fn */
161 .resume = rtl8192_resume, /* PM resume fn */
163 .suspend = NULL, /* PM suspend fn */
164 .resume = NULL, /* PM resume fn */
169 typedef struct _CHANNEL_LIST {
172 }CHANNEL_LIST, *PCHANNEL_LIST;
174 static CHANNEL_LIST ChannelPlan[] = {
175 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64,149,153,157,161,165},24}, //FCC
176 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
179 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
180 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, //MKK //MKK
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
182 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
183 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, // For 11a , TELEC
184 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
185 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14},14} //For Global Domain. 1-11:active scan, 12-14 passive scan. //+YJ, 080626
188 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
190 int i, max_chan=-1, min_chan=-1;
191 struct ieee80211_device* ieee = priv->ieee80211;
192 switch (channel_plan)
194 case COUNTRY_CODE_FCC:
195 case COUNTRY_CODE_IC:
196 case COUNTRY_CODE_ETSI:
197 case COUNTRY_CODE_SPAIN:
198 case COUNTRY_CODE_FRANCE:
199 case COUNTRY_CODE_MKK:
200 case COUNTRY_CODE_MKK1:
201 case COUNTRY_CODE_ISRAEL:
202 case COUNTRY_CODE_TELEC:
203 case COUNTRY_CODE_MIC:
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)) {
212 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
214 if (ChannelPlan[channel_plan].Len != 0) {
215 // Clear old channel map
216 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
217 // Set new channel map
218 for (i=0;i<ChannelPlan[channel_plan].Len;i++) {
219 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
221 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
226 case COUNTRY_CODE_GLOBAL_DOMAIN:
227 GET_DOT11D_INFO(ieee)->bEnabled = 0;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
229 ieee->bGlobalDomain = true;
238 #define rx_hal_is_cck_rate(_pdrvinfo)\
239 (_pdrvinfo->RxRate == DESC90_RATE1M ||\
240 _pdrvinfo->RxRate == DESC90_RATE2M ||\
241 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
242 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
246 void CamResetAllEntry(struct net_device *dev)
249 //2004/02/11 In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
250 // However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
251 // In this condition, Cam can not be reset because upper layer will not set this static key again.
252 //if(Adapter->EncAlgorithm == WEP_Encryption)
255 //DbgPrint("========================================\n");
256 //DbgPrint(" Call ResetAllEntry \n");
257 //DbgPrint("========================================\n\n");
258 ulcommand |= BIT31|BIT30;
259 write_nic_dword(dev, RWCAM, ulcommand);
264 void write_cam(struct net_device *dev, u8 addr, u32 data)
266 write_nic_dword(dev, WCAMI, data);
267 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
270 u32 read_cam(struct net_device *dev, u8 addr)
272 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
273 return read_nic_dword(dev, 0xa8);
276 void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
279 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
280 struct usb_device *udev = priv->udev;
282 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
283 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
284 indx|0xfe00, 0, &data, 1, HZ / 2);
288 printk("write_nic_byte_E TimeOut! status:%d\n", status);
292 u8 read_nic_byte_E(struct net_device *dev, int indx)
296 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
297 struct usb_device *udev = priv->udev;
299 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
300 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
301 indx|0xfe00, 0, &data, 1, HZ / 2);
305 printk("read_nic_byte_E TimeOut! status:%d\n", status);
310 //as 92U has extend page from 4 to 16, so modify functions below.
311 void write_nic_byte(struct net_device *dev, int indx, u8 data)
315 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
316 struct usb_device *udev = priv->udev;
318 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
319 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
320 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
324 printk("write_nic_byte TimeOut! status:%d\n", status);
331 void write_nic_word(struct net_device *dev, int indx, u16 data)
336 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
337 struct usb_device *udev = priv->udev;
339 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
340 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
341 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 2, HZ / 2);
345 printk("write_nic_word TimeOut! status:%d\n", status);
351 void write_nic_dword(struct net_device *dev, int indx, u32 data)
356 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
357 struct usb_device *udev = priv->udev;
359 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
360 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
361 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 4, HZ / 2);
366 printk("write_nic_dword TimeOut! status:%d\n", status);
373 u8 read_nic_byte(struct net_device *dev, int indx)
377 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
378 struct usb_device *udev = priv->udev;
380 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
381 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
382 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
386 printk("read_nic_byte TimeOut! status:%d\n", status);
394 u16 read_nic_word(struct net_device *dev, int indx)
398 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
399 struct usb_device *udev = priv->udev;
401 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
402 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
403 (indx&0xff)|0xff00, (indx>>8)&0x0f,
407 printk("read_nic_word TimeOut! status:%d\n", status);
412 u16 read_nic_word_E(struct net_device *dev, int indx)
416 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
417 struct usb_device *udev = priv->udev;
419 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
420 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
421 indx|0xfe00, 0, &data, 2, HZ / 2);
424 printk("read_nic_word TimeOut! status:%d\n", status);
429 u32 read_nic_dword(struct net_device *dev, int indx)
435 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
436 struct usb_device *udev = priv->udev;
438 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
439 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
440 (indx&0xff)|0xff00, (indx>>8)&0x0f,
443 * printk(KERN_WARNING "read size of data = %d\, date = %d\n",
449 printk("read_nic_dword TimeOut! status:%d\n", status);
454 /* u8 read_phy_cck(struct net_device *dev, u8 adr); */
455 /* u8 read_phy_ofdm(struct net_device *dev, u8 adr); */
456 /* this might still called in what was the PHY rtl8185/rtl8192 common code
457 * plans are to possibility turn it again in one common code...
459 inline void force_pci_posting(struct net_device *dev)
463 static struct net_device_stats *rtl8192_stats(struct net_device *dev);
464 void rtl8192_commit(struct net_device *dev);
465 /* void rtl8192_restart(struct net_device *dev); */
466 void rtl8192_restart(struct work_struct *work);
467 /* void rtl8192_rq_tx_ack(struct work_struct *work); */
468 void watch_dog_timer_callback(unsigned long data);
470 /****************************************************************************
471 * -----------------------------PROCFS STUFF-------------------------
472 *****************************************************************************
475 static struct proc_dir_entry *rtl8192_proc;
477 static int proc_get_stats_ap(struct seq_file *m, void *v)
479 struct net_device *dev = m->private;
480 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
481 struct ieee80211_device *ieee = priv->ieee80211;
482 struct ieee80211_network *target;
484 list_for_each_entry(target, &ieee->network_list, list) {
485 const char *wpa = "non_WPA";
486 if (target->wpa_ie_len > 0 || target->rsn_ie_len > 0)
489 seq_printf(m, "%s %s\n", target->ssid, wpa);
495 static int proc_get_registers(struct seq_file *m, void *v)
497 struct net_device *dev = m->private;
500 seq_puts(m, "\n####################page 0##################\n ");
503 //printk( "\nD: %2x> ", n);
504 seq_printf(m, "\nD: %2x > ",n);
506 for (i=0;i<16 && n<=max;i++,n++)
507 seq_printf(m, "%2x ",read_nic_byte(dev,0x000|n));
509 // printk("%2x ",read_nic_byte(dev,n));
512 seq_puts(m, "\n####################page 1##################\n ");
514 //printk( "\nD: %2x> ", n);
515 seq_printf(m, "\nD: %2x > ",n);
517 for (i=0;i<16 && n<=max;i++,n++)
518 seq_printf(m, "%2x ",read_nic_byte(dev,0x100|n));
520 // printk("%2x ",read_nic_byte(dev,n));
523 seq_puts(m, "\n####################page 3##################\n ");
525 //printk( "\nD: %2x> ", n);
526 seq_printf(m, "\nD: %2x > ",n);
528 for(i=0;i<16 && n<=max;i++,n++)
529 seq_printf(m, "%2x ",read_nic_byte(dev,0x300|n));
531 // printk("%2x ",read_nic_byte(dev,n));
538 static int proc_get_stats_tx(struct seq_file *m, void *v)
540 struct net_device *dev = m->private;
541 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
544 "TX VI priority ok int: %lu\n"
545 "TX VI priority error int: %lu\n"
546 "TX VO priority ok int: %lu\n"
547 "TX VO priority error int: %lu\n"
548 "TX BE priority ok int: %lu\n"
549 "TX BE priority error int: %lu\n"
550 "TX BK priority ok int: %lu\n"
551 "TX BK priority error int: %lu\n"
552 "TX MANAGE priority ok int: %lu\n"
553 "TX MANAGE priority error int: %lu\n"
554 "TX BEACON priority ok int: %lu\n"
555 "TX BEACON priority error int: %lu\n"
556 // "TX high priority ok int: %lu\n"
557 // "TX high priority failed error int: %lu\n"
558 "TX queue resume: %lu\n"
559 "TX queue stopped?: %d\n"
560 "TX fifo overflow: %lu\n"
561 // "TX beacon: %lu\n"
566 // "TX HW queue: %d\n"
567 "TX VI dropped: %lu\n"
568 "TX VO dropped: %lu\n"
569 "TX BE dropped: %lu\n"
570 "TX BK dropped: %lu\n"
571 "TX total data packets %lu\n",
572 // "TX beacon aborted: %lu\n",
573 priv->stats.txviokint,
575 priv->stats.txvookint,
577 priv->stats.txbeokint,
579 priv->stats.txbkokint,
581 priv->stats.txmanageokint,
582 priv->stats.txmanageerr,
583 priv->stats.txbeaconokint,
584 priv->stats.txbeaconerr,
585 // priv->stats.txhpokint,
586 // priv->stats.txhperr,
587 priv->stats.txresumed,
588 netif_queue_stopped(dev),
589 priv->stats.txoverflow,
590 // priv->stats.txbeacon,
591 atomic_read(&(priv->tx_pending[VI_PRIORITY])),
592 atomic_read(&(priv->tx_pending[VO_PRIORITY])),
593 atomic_read(&(priv->tx_pending[BE_PRIORITY])),
594 atomic_read(&(priv->tx_pending[BK_PRIORITY])),
595 // read_nic_byte(dev, TXFIFOCOUNT),
596 priv->stats.txvidrop,
597 priv->stats.txvodrop,
598 priv->stats.txbedrop,
599 priv->stats.txbkdrop,
600 priv->stats.txdatapkt
601 // priv->stats.txbeaconerr
607 static int proc_get_stats_rx(struct seq_file *m, void *v)
609 struct net_device *dev = m->private;
610 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
614 "RX urb status error: %lu\n"
615 "RX invalid urb error: %lu\n",
616 priv->stats.rxoktotal,
617 priv->stats.rxstaterr,
618 priv->stats.rxurberr);
623 void rtl8192_proc_module_init(void)
625 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
626 rtl8192_proc = proc_mkdir(RTL819xU_MODULE_NAME, init_net.proc_net);
630 void rtl8192_proc_module_remove(void)
632 remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
636 * seq_file wrappers for procfile show routines.
638 static int rtl8192_proc_open(struct inode *inode, struct file *file)
640 struct net_device *dev = proc_get_parent_data(inode);
641 int (*show)(struct seq_file *, void *) = PDE_DATA(inode);
643 return single_open(file, show, dev);
646 static const struct file_operations rtl8192_proc_fops = {
647 .open = rtl8192_proc_open,
650 .release = single_release,
654 * Table of proc files we need to create.
656 struct rtl8192_proc_file {
658 int (*show)(struct seq_file *, void *);
661 static const struct rtl8192_proc_file rtl8192_proc_files[] = {
662 { "stats-rx", &proc_get_stats_rx },
663 { "stats-tx", &proc_get_stats_tx },
664 { "stats-ap", &proc_get_stats_ap },
665 { "registers", &proc_get_registers },
669 void rtl8192_proc_init_one(struct net_device *dev)
671 const struct rtl8192_proc_file *f;
672 struct proc_dir_entry *dir;
675 dir = proc_mkdir_data(dev->name, 0, rtl8192_proc, dev);
677 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
682 for (f = rtl8192_proc_files; f->name[0]; f++) {
683 if (!proc_create_data(f->name, S_IFREG | S_IRUGO, dir,
684 &rtl8192_proc_fops, f->show)) {
685 RT_TRACE(COMP_ERR, "Unable to initialize "
686 "/proc/net/rtl8192/%s/%s\n",
694 void rtl8192_proc_remove_one(struct net_device *dev)
696 remove_proc_subtree(dev->name, rtl8192_proc);
699 /****************************************************************************
700 -----------------------------MISC STUFF-------------------------
701 *****************************************************************************/
703 /* this is only for debugging */
704 void print_buffer(u32 *buffer, int len)
707 u8 *buf =(u8*)buffer;
709 printk("ASCII BUFFER DUMP (len: %x):\n",len);
714 printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
722 //short check_nic_enough_desc(struct net_device *dev, priority_t priority)
723 short check_nic_enough_desc(struct net_device *dev,int queue_index)
725 struct r8192_priv *priv = ieee80211_priv(dev);
726 int used = atomic_read(&priv->tx_pending[queue_index]);
728 return (used < MAX_TX_URB);
731 void tx_timeout(struct net_device *dev)
733 struct r8192_priv *priv = ieee80211_priv(dev);
734 //rtl8192_commit(dev);
736 schedule_work(&priv->reset_wq);
737 //DMESG("TXTIMEOUT");
741 /* this is only for debug */
742 void dump_eprom(struct net_device *dev)
746 RT_TRACE(COMP_EPROM, "EEPROM addr %x : %x", i, eprom_read(dev,i));
749 /* this is only for debug */
750 void rtl8192_dump_reg(struct net_device *dev)
756 RT_TRACE(COMP_PHY, "Dumping NIC register map");
760 printk( "\nD: %2x> ", n);
761 for(i=0;i<16 && n<=max;i++,n++)
762 printk("%2x ",read_nic_byte(dev,n));
767 /****************************************************************************
768 ------------------------------HW STUFF---------------------------
769 *****************************************************************************/
772 void rtl8192_set_mode(struct net_device *dev,int mode)
775 ecmd=read_nic_byte(dev, EPROM_CMD);
776 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
777 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
778 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
779 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
780 write_nic_byte(dev, EPROM_CMD, ecmd);
784 void rtl8192_update_msr(struct net_device *dev)
786 struct r8192_priv *priv = ieee80211_priv(dev);
789 msr = read_nic_byte(dev, MSR);
790 msr &= ~ MSR_LINK_MASK;
792 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
793 * msr must be updated if the state is ASSOCIATING.
794 * this is intentional and make sense for ad-hoc and
795 * master (see the create BSS/IBSS func)
797 if (priv->ieee80211->state == IEEE80211_LINKED){
799 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
800 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
801 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
802 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
803 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
804 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
807 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
809 write_nic_byte(dev, MSR, msr);
812 void rtl8192_set_chan(struct net_device *dev,short ch)
814 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
816 RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
819 /* this hack should avoid frame TX during channel setting*/
822 // tx = read_nic_dword(dev,TX_CONF);
823 // tx &= ~TX_LOOPBACK_MASK;
826 // write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
828 //need to implement rf set channel here WB
830 if (priv->rf_set_chan)
831 priv->rf_set_chan(dev,priv->chan);
833 // write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
837 static void rtl8192_rx_isr(struct urb *urb);
838 //static void rtl8192_rx_isr(struct urb *rx_urb);
840 u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
843 #ifdef USB_RX_AGGREGATION_SUPPORT
844 if (pstats->bisrxaggrsubframe)
845 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
846 + pstats->RxBufShift + 8);
849 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
850 + pstats->RxBufShift);
853 static int rtl8192_rx_initiate(struct net_device*dev)
855 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
858 struct rtl8192_rx_info *info;
860 /* nomal packet rx procedure */
861 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
862 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
865 entry = usb_alloc_urb(0, GFP_KERNEL);
870 // printk("nomal packet IN request!\n");
871 usb_fill_bulk_urb(entry, priv->udev,
872 usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
873 RX_URB_SIZE, rtl8192_rx_isr, skb);
874 info = (struct rtl8192_rx_info *) skb->cb;
877 info->out_pipe = 3; //denote rx normal packet queue
878 skb_queue_tail(&priv->rx_queue, skb);
879 usb_submit_urb(entry, GFP_KERNEL);
882 /* command packet rx procedure */
883 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
884 // printk("command packet IN request!\n");
885 skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL);
888 entry = usb_alloc_urb(0, GFP_KERNEL);
893 usb_fill_bulk_urb(entry, priv->udev,
894 usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
895 RX_URB_SIZE, rtl8192_rx_isr, skb);
896 info = (struct rtl8192_rx_info *) skb->cb;
899 info->out_pipe = 9; //denote rx cmd packet queue
900 skb_queue_tail(&priv->rx_queue, skb);
901 usb_submit_urb(entry, GFP_KERNEL);
907 void rtl8192_set_rxconf(struct net_device *dev)
909 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
912 rxconf=read_nic_dword(dev,RCR);
913 rxconf = rxconf &~ MAC_FILTER_MASK;
914 rxconf = rxconf | RCR_AMF;
915 rxconf = rxconf | RCR_ADF;
916 rxconf = rxconf | RCR_AB;
917 rxconf = rxconf | RCR_AM;
918 //rxconf = rxconf | RCR_ACF;
920 if (dev->flags & IFF_PROMISC) {DMESG ("NIC in promisc mode");}
922 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
923 dev->flags & IFF_PROMISC){
924 rxconf = rxconf | RCR_AAP;
925 } /*else if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
926 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
927 rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
929 rxconf = rxconf | RCR_APM;
930 rxconf = rxconf | RCR_CBSSID;
934 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
935 rxconf = rxconf | RCR_AICV;
936 rxconf = rxconf | RCR_APWRMGT;
939 if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
940 rxconf = rxconf | RCR_ACRC32;
943 rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
944 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
945 rxconf = rxconf &~ MAX_RX_DMA_MASK;
946 rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
948 // rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
949 rxconf = rxconf | RCR_ONLYERLPKT;
951 // rxconf = rxconf &~ RCR_CS_MASK;
952 // rxconf = rxconf | (1<<RCR_CS_SHIFT);
954 write_nic_dword(dev, RCR, rxconf);
957 DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RCR));
961 void rtl8192_rx_enable(struct net_device *dev)
965 //struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
967 rtl8192_rx_initiate(dev);
969 // rtl8192_set_rxconf(dev);
973 void rtl8192_tx_enable(struct net_device *dev)
979 void rtl8192_rtx_disable(struct net_device *dev)
982 struct r8192_priv *priv = ieee80211_priv(dev);
984 struct rtl8192_rx_info *info;
986 cmd=read_nic_byte(dev,CMDR);
987 write_nic_byte(dev, CMDR, cmd &~ \
989 force_pci_posting(dev);
992 while ((skb = __skb_dequeue(&priv->rx_queue))) {
993 info = (struct rtl8192_rx_info *) skb->cb;
997 usb_kill_urb(info->urb);
1001 if (skb_queue_len(&priv->skb_queue)) {
1002 printk(KERN_WARNING "skb_queue not empty\n");
1005 skb_queue_purge(&priv->skb_queue);
1010 int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
1015 inline u16 ieeerate2rtlrate(int rate)
1047 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
1048 inline u16 rtl8192_rate2rate(short rate)
1050 if (rate >11) return 0;
1051 return rtl_rate[rate];
1055 /* The prototype of rx_isr has changed since one version of Linux Kernel */
1056 static void rtl8192_rx_isr(struct urb *urb)
1058 struct sk_buff *skb = (struct sk_buff *) urb->context;
1059 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
1060 struct net_device *dev = info->dev;
1061 struct r8192_priv *priv = ieee80211_priv(dev);
1062 int out_pipe = info->out_pipe;
1066 if (unlikely(urb->status)) {
1068 priv->stats.rxstaterr++;
1069 priv->ieee80211->stats.rx_errors++;
1071 // printk("%s():rx status err\n",__FUNCTION__);
1074 skb_unlink(skb, &priv->rx_queue);
1075 skb_put(skb, urb->actual_length);
1077 skb_queue_tail(&priv->skb_queue, skb);
1078 tasklet_schedule(&priv->irq_rx_tasklet);
1080 skb = dev_alloc_skb(RX_URB_SIZE);
1081 if (unlikely(!skb)) {
1083 printk("%s():can,t alloc skb\n",__FUNCTION__);
1084 /* TODO check rx queue length and refill *somewhere* */
1088 usb_fill_bulk_urb(urb, priv->udev,
1089 usb_rcvbulkpipe(priv->udev, out_pipe), skb_tail_pointer(skb),
1090 RX_URB_SIZE, rtl8192_rx_isr, skb);
1092 info = (struct rtl8192_rx_info *) skb->cb;
1095 info->out_pipe = out_pipe;
1097 urb->transfer_buffer = skb_tail_pointer(skb);
1099 skb_queue_tail(&priv->rx_queue, skb);
1100 err = usb_submit_urb(urb, GFP_ATOMIC);
1101 if(err && err != EPERM)
1102 printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
1106 rtl819xusb_rx_command_packet(
1107 struct net_device *dev,
1108 struct ieee80211_rx_stats *pstats
1113 //RT_TRACE(COMP_RECV, DBG_TRACE, ("---> RxCommandPacketHandle819xUsb()\n"));
1115 status = cmpk_message_handle_rx(dev, pstats);
1118 DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
1122 //RT_TRACE(COMP_RECV, DBG_TRACE, ("RxCommandPacketHandle819xUsb: It is not a command packet\n"));
1125 //RT_TRACE(COMP_RECV, DBG_TRACE, ("<--- RxCommandPacketHandle819xUsb()\n"));
1130 void rtl8192_data_hard_stop(struct net_device *dev)
1136 void rtl8192_data_hard_resume(struct net_device *dev)
1141 /* this function TX data frames when the ieee80211 stack requires this.
1142 * It checks also if we need to stop the ieee tx queue, eventually do it
1144 void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
1146 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1148 unsigned long flags;
1149 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1150 u8 queue_index = tcb_desc->queue_index;
1152 /* shall not be referred by command packet */
1153 assert(queue_index != TXCMD_QUEUE);
1155 spin_lock_irqsave(&priv->tx_lock,flags);
1157 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1158 // tcb_desc->RATRIndex = 7;
1159 // tcb_desc->bTxDisableRateFallBack = 1;
1160 // tcb_desc->bTxUseDriverAssingedRate = 1;
1161 tcb_desc->bTxEnableFwCalcDur = 1;
1162 skb_push(skb, priv->ieee80211->tx_headroom);
1163 ret = rtl8192_tx(dev, skb);
1165 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1166 //priv->ieee80211->stats.tx_packets++;
1168 spin_unlock_irqrestore(&priv->tx_lock,flags);
1174 /* This is a rough attempt to TX a frame
1175 * This is called by the ieee 80211 stack to TX management frames.
1176 * If the ring is full packet are dropped (for data frame the queue
1177 * is stopped before this can happen).
1179 int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1181 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1183 unsigned long flags;
1184 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1185 u8 queue_index = tcb_desc->queue_index;
1188 spin_lock_irqsave(&priv->tx_lock,flags);
1190 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1191 if(queue_index == TXCMD_QUEUE) {
1192 skb_push(skb, USB_HWDESC_HEADER_LEN);
1193 rtl819xU_tx_cmd(dev, skb);
1195 spin_unlock_irqrestore(&priv->tx_lock,flags);
1198 skb_push(skb, priv->ieee80211->tx_headroom);
1199 ret = rtl8192_tx(dev, skb);
1202 spin_unlock_irqrestore(&priv->tx_lock,flags);
1208 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1210 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1211 u16 DrvAggr_PaddingAdd(struct net_device *dev, struct sk_buff *skb)
1213 u16 PaddingNum = 256 - ((skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES) % 256);
1214 return (PaddingNum&0xff);
1217 u8 MRateToHwRate8190Pci(u8 rate);
1218 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc);
1219 u8 MapHwQueueToFirmwareQueue(u8 QueueID);
1220 struct sk_buff *DrvAggr_Aggregation(struct net_device *dev, struct ieee80211_drv_agg_txb *pSendList)
1222 struct ieee80211_device *ieee = netdev_priv(dev);
1223 struct r8192_priv *priv = ieee80211_priv(dev);
1224 cb_desc *tcb_desc = NULL;
1227 struct sk_buff *skb;
1228 struct sk_buff *agg_skb;
1229 tx_desc_819x_usb_aggr_subframe *tx_agg_desc = NULL;
1230 tx_fwinfo_819x_usb *tx_fwinfo = NULL;
1233 // Local variable initialization.
1235 /* first skb initialization */
1236 skb = pSendList->tx_agg_frames[0];
1237 TotalLength = skb->len;
1239 /* Get the total aggregation length including the padding space and
1242 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1243 TotalLength += DrvAggr_PaddingAdd(dev, skb);
1244 skb = pSendList->tx_agg_frames[i];
1245 TotalLength += (skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1248 /* allocate skb to contain the aggregated packets */
1249 agg_skb = dev_alloc_skb(TotalLength + ieee->tx_headroom);
1250 memset(agg_skb->data, 0, agg_skb->len);
1251 skb_reserve(agg_skb, ieee->tx_headroom);
1253 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
1254 /* reserve info for first subframe Tx descriptor to be set in the tx function */
1255 skb = pSendList->tx_agg_frames[0];
1256 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1257 tcb_desc->drv_agg_enable = 1;
1258 tcb_desc->pkt_size = skb->len;
1259 tcb_desc->DrvAggrNum = pSendList->nr_drv_agg_frames;
1260 printk("DrvAggNum = %d\n", tcb_desc->DrvAggrNum);
1261 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
1262 // printk("========>skb->data ======> \n");
1263 // RT_DEBUG_DATA(COMP_SEND, skb->data, skb->len);
1264 memcpy(agg_skb->cb, skb->cb, sizeof(skb->cb));
1265 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1267 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1268 /* push the next sub frame to be 256 byte aline */
1269 skb_put(agg_skb,DrvAggr_PaddingAdd(dev,skb));
1271 /* Subframe drv Tx descriptor and firmware info setting */
1272 skb = pSendList->tx_agg_frames[i];
1273 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1274 tx_agg_desc = (tx_desc_819x_usb_aggr_subframe *)skb_tail_pointer(agg_skb);
1275 tx_fwinfo = (tx_fwinfo_819x_usb *)(skb_tail_pointer(agg_skb) + sizeof(tx_desc_819x_usb_aggr_subframe));
1277 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
1279 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
1280 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
1281 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1282 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
1283 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
1284 tx_fwinfo->AllowAggregation = 1;
1286 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
1287 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
1289 tx_fwinfo->AllowAggregation = 0;
1291 tx_fwinfo->RxMF = 0;
1292 tx_fwinfo->RxAMD = 0;
1295 /* Protection mode related */
1296 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
1297 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
1298 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
1299 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
1300 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1301 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
1302 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
1303 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
1304 (tcb_desc->bRTSUseShortGI?1:0);
1306 /* Set Bandwidth and sub-channel settings. */
1307 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
1309 if(tcb_desc->bPacketBW) {
1310 tx_fwinfo->TxBandwidth = 1;
1311 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
1313 tx_fwinfo->TxBandwidth = 0;
1314 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1317 tx_fwinfo->TxBandwidth = 0;
1318 tx_fwinfo->TxSubCarrier = 0;
1321 /* Fill Tx descriptor */
1322 memset(tx_agg_desc, 0, sizeof(tx_desc_819x_usb_aggr_subframe));
1324 //tx_agg_desc->LINIP = 0;
1325 //tx_agg_desc->CmdInit = 1;
1326 tx_agg_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
1327 /* already raw data, need not to subtract header length */
1328 tx_agg_desc->PktSize = skb->len & 0xffff;
1331 tx_agg_desc->SecCAMID= 0;
1332 tx_agg_desc->RATid = tcb_desc->RATRIndex;
1335 tx_agg_desc->NoEnc = 1;
1337 tx_agg_desc->SecType = 0x0;
1339 if (tcb_desc->bHwSec) {
1340 switch (priv->ieee80211->pairwise_key_type)
1342 case KEY_TYPE_WEP40:
1343 case KEY_TYPE_WEP104:
1344 tx_agg_desc->SecType = 0x1;
1345 tx_agg_desc->NoEnc = 0;
1348 tx_agg_desc->SecType = 0x2;
1349 tx_agg_desc->NoEnc = 0;
1352 tx_agg_desc->SecType = 0x3;
1353 tx_agg_desc->NoEnc = 0;
1356 tx_agg_desc->SecType = 0x0;
1357 tx_agg_desc->NoEnc = 1;
1362 tx_agg_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1363 tx_agg_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
1365 tx_agg_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
1366 tx_agg_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1368 tx_agg_desc->OWN = 1;
1371 /* According windows driver, it seems that there no need to fill this field */
1372 //tx_agg_desc->TxBufferSize= (u32)(skb->len - USB_HWDESC_HEADER_LEN);
1374 /* to fill next packet */
1375 skb_put(agg_skb,TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1376 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1379 for(i = 0; i < pSendList->nr_drv_agg_frames; i++) {
1380 dev_kfree_skb_any(pSendList->tx_agg_frames[i]);
1387 This function return a list of PTCB which is proper to be aggregate with the input TCB.
1388 If no proper TCB is found to do aggregation, SendList will only contain the input TCB.
1390 u8 DrvAggr_GetAggregatibleList(struct net_device *dev, struct sk_buff *skb,
1391 struct ieee80211_drv_agg_txb *pSendList)
1393 struct ieee80211_device *ieee = netdev_priv(dev);
1394 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
1395 u16 nMaxAggrNum = pHTInfo->UsbTxAggrNum;
1396 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1397 u8 QueueID = tcb_desc->queue_index;
1400 pSendList->tx_agg_frames[pSendList->nr_drv_agg_frames++] = skb;
1401 if(pSendList->nr_drv_agg_frames >= nMaxAggrNum) {
1405 } while((skb = skb_dequeue(&ieee->skb_drv_aggQ[QueueID])));
1407 RT_TRACE(COMP_AMSDU, "DrvAggr_GetAggregatibleList, nAggrTcbNum = %d \n", pSendList->nr_drv_agg_frames);
1408 return pSendList->nr_drv_agg_frames;
1412 static void rtl8192_tx_isr(struct urb *tx_urb)
1414 struct sk_buff *skb = (struct sk_buff*)tx_urb->context;
1415 struct net_device *dev = NULL;
1416 struct r8192_priv *priv = NULL;
1417 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1418 u8 queue_index = tcb_desc->queue_index;
1419 // bool bToSend0Byte;
1420 // u16 BufLen = skb->len;
1422 memcpy(&dev,(struct net_device*)(skb->cb),sizeof(struct net_device*));
1423 priv = ieee80211_priv(dev);
1425 if(tcb_desc->queue_index != TXCMD_QUEUE) {
1426 if(tx_urb->status == 0) {
1427 dev->trans_start = jiffies;
1428 // Act as station mode, destination shall be unicast address.
1429 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1430 //priv->ieee80211->stats.tx_packets++;
1431 priv->stats.txoktotal++;
1432 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
1433 priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
1435 priv->ieee80211->stats.tx_errors++;
1436 //priv->stats.txmanageerr++;
1441 /* free skb and tx_urb */
1443 dev_kfree_skb_any(skb);
1444 usb_free_urb(tx_urb);
1445 atomic_dec(&priv->tx_pending[queue_index]);
1450 // Handle HW Beacon:
1451 // We had transfer our beacon frame to host controller at this moment.
1455 // Handling the wait queue of command packets.
1456 // For Tx command packets, we must not do TCB fragment because it is not handled right now.
1457 // We must cut the packets to match the size of TX_CMD_PKT before we send it.
1460 /* Handle MPDU in wait queue. */
1461 if(queue_index != BEACON_QUEUE) {
1462 /* Don't send data frame during scanning.*/
1463 if((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0)&&\
1464 (!(priv->ieee80211->queue_stop))) {
1465 if(NULL != (skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]))))
1466 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1468 return; //modified by david to avoid further processing AMSDU
1470 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1471 else if ((skb_queue_len(&priv->ieee80211->skb_drv_aggQ[queue_index])!= 0)&&\
1472 (!(priv->ieee80211->queue_stop))) {
1473 // Tx Driver Aggregation process
1474 /* The driver will aggregation the packets according to the following stats
1475 * 1. check whether there's tx irq available, for it's a completion return
1476 * function, it should contain enough tx irq;
1477 * 2. check packet type;
1478 * 3. initialize sendlist, check whether the to-be send packet no greater than 1
1479 * 4. aggregates the packets, and fill firmware info and tx desc into it, etc.
1480 * 5. check whether the packet could be sent, otherwise just insert into wait head
1482 skb = skb_dequeue(&priv->ieee80211->skb_drv_aggQ[queue_index]);
1483 if(!check_nic_enough_desc(dev, queue_index)) {
1484 skb_queue_head(&(priv->ieee80211->skb_drv_aggQ[queue_index]), skb);
1491 u8* pHeader = skb->data;
1493 if(IsMgntQosData(pHeader) ||
1494 IsMgntQData_Ack(pHeader) ||
1495 IsMgntQData_Poll(pHeader) ||
1496 IsMgntQData_Poll_Ack(pHeader)
1500 struct ieee80211_drv_agg_txb SendList;
1502 memset(&SendList, 0, sizeof(struct ieee80211_drv_agg_txb));
1503 if(DrvAggr_GetAggregatibleList(dev, skb, &SendList) > 1) {
1504 skb = DrvAggr_Aggregation(dev, &SendList);
1508 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1517 void rtl8192_beacon_stop(struct net_device *dev)
1520 struct r8192_priv *priv = ieee80211_priv(dev);
1522 msr = read_nic_byte(dev, MSR);
1523 msrm = msr & MSR_LINK_MASK;
1524 msr2 = msr & ~MSR_LINK_MASK;
1526 if(NIC_8192U == priv->card_8192) {
1527 usb_kill_urb(priv->rx_urb[MAX_RX_URB]);
1529 if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
1530 (msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
1531 write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
1532 write_nic_byte(dev, MSR, msr);
1536 void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1538 struct r8192_priv *priv = ieee80211_priv(dev);
1539 struct ieee80211_network *net;
1540 u8 i=0, basic_rate = 0;
1541 net = & priv->ieee80211->current_network;
1543 for (i=0; i<net->rates_len; i++)
1545 basic_rate = net->rates[i]&0x7f;
1548 case MGN_1M: *rate_config |= RRSR_1M; break;
1549 case MGN_2M: *rate_config |= RRSR_2M; break;
1550 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1551 case MGN_11M: *rate_config |= RRSR_11M; break;
1552 case MGN_6M: *rate_config |= RRSR_6M; break;
1553 case MGN_9M: *rate_config |= RRSR_9M; break;
1554 case MGN_12M: *rate_config |= RRSR_12M; break;
1555 case MGN_18M: *rate_config |= RRSR_18M; break;
1556 case MGN_24M: *rate_config |= RRSR_24M; break;
1557 case MGN_36M: *rate_config |= RRSR_36M; break;
1558 case MGN_48M: *rate_config |= RRSR_48M; break;
1559 case MGN_54M: *rate_config |= RRSR_54M; break;
1562 for (i=0; i<net->rates_ex_len; i++)
1564 basic_rate = net->rates_ex[i]&0x7f;
1567 case MGN_1M: *rate_config |= RRSR_1M; break;
1568 case MGN_2M: *rate_config |= RRSR_2M; break;
1569 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1570 case MGN_11M: *rate_config |= RRSR_11M; break;
1571 case MGN_6M: *rate_config |= RRSR_6M; break;
1572 case MGN_9M: *rate_config |= RRSR_9M; break;
1573 case MGN_12M: *rate_config |= RRSR_12M; break;
1574 case MGN_18M: *rate_config |= RRSR_18M; break;
1575 case MGN_24M: *rate_config |= RRSR_24M; break;
1576 case MGN_36M: *rate_config |= RRSR_36M; break;
1577 case MGN_48M: *rate_config |= RRSR_48M; break;
1578 case MGN_54M: *rate_config |= RRSR_54M; break;
1584 #define SHORT_SLOT_TIME 9
1585 #define NON_SHORT_SLOT_TIME 20
1587 void rtl8192_update_cap(struct net_device* dev, u16 cap)
1590 struct r8192_priv *priv = ieee80211_priv(dev);
1591 struct ieee80211_network *net = &priv->ieee80211->current_network;
1592 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1593 tmp = priv->basic_rate;
1594 if (priv->short_preamble)
1595 tmp |= BRSR_AckShortPmb;
1596 write_nic_dword(dev, RRSR, tmp);
1598 if (net->mode & (IEEE_G|IEEE_N_24G))
1601 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1603 slot_time = SHORT_SLOT_TIME;
1605 else //long slot time
1606 slot_time = NON_SHORT_SLOT_TIME;
1607 priv->slot_time = slot_time;
1608 write_nic_byte(dev, SLOT_TIME, slot_time);
1612 void rtl8192_net_update(struct net_device *dev)
1615 struct r8192_priv *priv = ieee80211_priv(dev);
1616 struct ieee80211_network *net;
1617 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1618 u16 rate_config = 0;
1619 net = & priv->ieee80211->current_network;
1621 rtl8192_config_rate(dev, &rate_config);
1622 priv->basic_rate = rate_config &= 0x15f;
1624 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1625 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1626 //for(i=0;i<ETH_ALEN;i++)
1627 // write_nic_byte(dev,BSSID+i,net->bssid[i]);
1629 rtl8192_update_msr(dev);
1630 // rtl8192_update_cap(dev, net->capability);
1631 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1633 write_nic_word(dev, ATIMWND, 2);
1634 write_nic_word(dev, BCN_DMATIME, 1023);
1635 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1636 // write_nic_word(dev, BcnIntTime, 100);
1637 write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
1638 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1639 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1640 // TODO: BcnIFS may required to be changed on ASIC
1641 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1643 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1650 //temporary hw beacon is not used any more.
1651 //open it when necessary
1652 void rtl819xusb_beacon_tx(struct net_device *dev,u16 tx_rate)
1656 inline u8 rtl8192_IsWirelessBMode(u16 rate)
1658 if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
1663 u16 N_DBPSOfRate(u16 DataRate);
1668 u8 bManagementFrame,
1676 if( rtl8192_IsWirelessBMode(DataRate) )
1678 if( bManagementFrame || !bShortPreamble || DataRate == 10 )
1680 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1684 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1686 if( ( FrameLength*8 % (DataRate/10) ) != 0 ) //Get the Ceilling
1688 } else { //802.11g DSSS-OFDM PLCP length field calculation.
1689 N_DBPS = N_DBPSOfRate(DataRate);
1690 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1691 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1692 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1697 u16 N_DBPSOfRate(u16 DataRate)
1742 void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
1744 usb_free_urb(tx_cmd_urb);
1747 unsigned int txqueue2outpipe(struct r8192_priv* priv,unsigned int tx_queue) {
1751 RT_TRACE(COMP_ERR,"%s():Unknown queue ID!!!\n",__FUNCTION__);
1754 return priv->txqueue_to_outpipemap[tx_queue];
1757 short rtl819xU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1759 struct r8192_priv *priv = ieee80211_priv(dev);
1764 unsigned int idx_pipe;
1765 tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
1766 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1767 u8 queue_index = tcb_desc->queue_index;
1769 //printk("\n %s::queue_index = %d\n",__FUNCTION__, queue_index);
1770 atomic_inc(&priv->tx_pending[queue_index]);
1771 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
1777 memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
1778 /* Tx descriptor ought to be set according to the skb->cb */
1779 pdesc->FirstSeg = 1;//bFirstSeg;
1780 pdesc->LastSeg = 1;//bLastSeg;
1781 pdesc->CmdInit = tcb_desc->bCmdOrInit;
1782 pdesc->TxBufferSize = tcb_desc->txbuf_size;
1784 pdesc->LINIP = tcb_desc->bLastIniPkt;
1786 //----------------------------------------------------------------------------
1787 // Fill up USB_OUT_CONTEXT.
1788 //----------------------------------------------------------------------------
1789 // Get index to out pipe from specified QueueID.
1790 #ifndef USE_ONE_PIPE
1791 idx_pipe = txqueue2outpipe(priv,queue_index);
1795 #ifdef JOHN_DUMP_TXDESC
1797 printk("<Tx descriptor>--rate %x---",rate);
1798 for (i = 0; i < 8; i++)
1799 printk("%8x ", tx[i]);
1802 usb_fill_bulk_urb(tx_urb,priv->udev, usb_sndbulkpipe(priv->udev,idx_pipe), \
1803 skb->data, skb->len, rtl8192_tx_isr, skb);
1805 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
1810 DMESGE("Error TX CMD URB, error %d",
1817 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1818 * in TxFwInfo data structure
1819 * 2006.10.30 by Emily
1821 * \param QUEUEID Software Queue
1823 u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1825 u8 QueueSelect = 0x0; //defualt set to
1829 QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
1833 QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
1837 QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
1841 QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
1844 QueueSelect = QSLT_MGNT;
1848 QueueSelect = QSLT_BEACON;
1851 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
1852 // TODO: Remove Assertions
1853 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
1855 QueueSelect = QSLT_CMD;
1859 QueueSelect = QSLT_HIGH;
1863 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
1869 u8 MRateToHwRate8190Pci(u8 rate)
1871 u8 ret = DESC90_RATE1M;
1874 case MGN_1M: ret = DESC90_RATE1M; break;
1875 case MGN_2M: ret = DESC90_RATE2M; break;
1876 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
1877 case MGN_11M: ret = DESC90_RATE11M; break;
1878 case MGN_6M: ret = DESC90_RATE6M; break;
1879 case MGN_9M: ret = DESC90_RATE9M; break;
1880 case MGN_12M: ret = DESC90_RATE12M; break;
1881 case MGN_18M: ret = DESC90_RATE18M; break;
1882 case MGN_24M: ret = DESC90_RATE24M; break;
1883 case MGN_36M: ret = DESC90_RATE36M; break;
1884 case MGN_48M: ret = DESC90_RATE48M; break;
1885 case MGN_54M: ret = DESC90_RATE54M; break;
1887 // HT rate since here
1888 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
1889 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
1890 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
1891 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
1892 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
1893 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
1894 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
1895 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
1896 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
1897 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
1898 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1899 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1900 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1901 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1902 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1903 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1904 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1912 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1916 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1918 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1924 static void tx_zero_isr(struct urb *tx_urb)
1930 * The tx procedure is just as following,
1931 * skb->cb will contain all the following information,
1932 * priority, morefrag, rate, &dev.
1934 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
1936 struct r8192_priv *priv = ieee80211_priv(dev);
1937 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1938 tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
1939 tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);
1940 struct usb_device *udev = priv->udev;
1943 struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
1945 unsigned int idx_pipe;
1946 // RT_DEBUG_DATA(COMP_SEND, tcb_desc, sizeof(cb_desc));
1947 // printk("=============> %s\n", __FUNCTION__);
1948 pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
1949 /* we are locked here so the two atomic_read and inc are executed
1950 * without interleaves
1951 * !!! For debug purpose
1953 if( pend > MAX_TX_URB){
1954 printk("To discard skb packet!\n");
1955 dev_kfree_skb_any(skb);
1959 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
1961 dev_kfree_skb_any(skb);
1965 /* Fill Tx firmware info */
1966 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
1968 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
1969 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
1970 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1971 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
1972 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
1973 tx_fwinfo->AllowAggregation = 1;
1975 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
1976 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
1978 tx_fwinfo->AllowAggregation = 0;
1980 tx_fwinfo->RxMF = 0;
1981 tx_fwinfo->RxAMD = 0;
1984 /* Protection mode related */
1985 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
1986 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
1987 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
1988 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
1989 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1990 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
1991 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
1992 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
1993 (tcb_desc->bRTSUseShortGI?1:0);
1995 /* Set Bandwidth and sub-channel settings. */
1996 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
1998 if(tcb_desc->bPacketBW) {
1999 tx_fwinfo->TxBandwidth = 1;
2000 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
2002 tx_fwinfo->TxBandwidth = 0;
2003 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
2006 tx_fwinfo->TxBandwidth = 0;
2007 tx_fwinfo->TxSubCarrier = 0;
2010 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2011 if (tcb_desc->drv_agg_enable)
2013 tx_fwinfo->Tx_INFO_RSVD = (tcb_desc->DrvAggrNum & 0x1f) << 1;
2016 /* Fill Tx descriptor */
2017 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
2020 tx_desc->CmdInit = 1;
2021 tx_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
2023 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2024 if (tcb_desc->drv_agg_enable) {
2025 tx_desc->PktSize = tcb_desc->pkt_size;
2029 tx_desc->PktSize = (skb->len - TX_PACKET_SHIFT_BYTES) & 0xffff;
2033 tx_desc->SecCAMID= 0;
2034 tx_desc->RATid = tcb_desc->RATRIndex;
2039 tx_desc->SecType = 0x0;
2040 if (tcb_desc->bHwSec)
2042 switch (priv->ieee80211->pairwise_key_type)
2044 case KEY_TYPE_WEP40:
2045 case KEY_TYPE_WEP104:
2046 tx_desc->SecType = 0x1;
2050 tx_desc->SecType = 0x2;
2054 tx_desc->SecType = 0x3;
2058 tx_desc->SecType = 0x0;
2064 tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
2065 tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
2067 tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
2068 tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
2070 /* Fill fields that are required to be initialized in all of the descriptors */
2072 tx_desc->FirstSeg = 1;
2073 tx_desc->LastSeg = 1;
2076 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2077 if (tcb_desc->drv_agg_enable) {
2078 tx_desc->TxBufferSize = tcb_desc->pkt_size + sizeof(tx_fwinfo_819x_usb);
2083 tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
2085 /* Get index to out pipe from specified QueueID */
2086 #ifndef USE_ONE_PIPE
2087 idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
2092 //RT_DEBUG_DATA(COMP_SEND,tx_fwinfo,sizeof(tx_fwinfo_819x_usb));
2093 //RT_DEBUG_DATA(COMP_SEND,tx_desc,sizeof(tx_desc_819x_usb));
2095 /* To submit bulk urb */
2096 usb_fill_bulk_urb(tx_urb,udev,
2097 usb_sndbulkpipe(udev,idx_pipe), skb->data,
2098 skb->len, rtl8192_tx_isr, skb);
2100 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
2102 //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
2103 bool bSend0Byte = false;
2105 if(udev->speed == USB_SPEED_HIGH)
2107 if (skb->len > 0 && skb->len % 512 == 0)
2112 if (skb->len > 0 && skb->len % 64 == 0)
2117 tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
2119 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
2122 usb_fill_bulk_urb(tx_urb_zero,udev,
2123 usb_sndbulkpipe(udev,idx_pipe), &zero,
2124 0, tx_zero_isr, dev);
2125 status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
2127 RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
2131 dev->trans_start = jiffies;
2132 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
2135 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
2141 short rtl8192_usb_initendpoints(struct net_device *dev)
2143 struct r8192_priv *priv = ieee80211_priv(dev);
2145 priv->rx_urb = kmalloc(sizeof(struct urb *) * (MAX_RX_URB+1),
2147 if (priv->rx_urb == NULL)
2150 #ifndef JACKSON_NEW_RX
2151 for(i=0;i<(MAX_RX_URB+1);i++){
2153 priv->rx_urb[i] = usb_alloc_urb(0,GFP_KERNEL);
2155 priv->rx_urb[i]->transfer_buffer = kmalloc(RX_URB_SIZE, GFP_KERNEL);
2157 priv->rx_urb[i]->transfer_buffer_length = RX_URB_SIZE;
2161 #ifdef THOMAS_BEACON
2164 void *oldaddr, *newaddr;
2166 priv->rx_urb[16] = usb_alloc_urb(0, GFP_KERNEL);
2167 priv->oldaddr = kmalloc(16, GFP_KERNEL);
2168 oldaddr = priv->oldaddr;
2169 align = ((long)oldaddr) & 3;
2171 newaddr = oldaddr + 4 - align;
2172 priv->rx_urb[16]->transfer_buffer_length = 16 - 4 + align;
2175 priv->rx_urb[16]->transfer_buffer_length = 16;
2177 priv->rx_urb[16]->transfer_buffer = newaddr;
2181 memset(priv->rx_urb, 0, sizeof(struct urb*) * MAX_RX_URB);
2182 priv->pp_rxskb = kcalloc(MAX_RX_URB, sizeof(struct sk_buff *),
2184 if (!priv->pp_rxskb) {
2185 kfree(priv->rx_urb);
2187 priv->pp_rxskb = NULL;
2188 priv->rx_urb = NULL;
2190 DMESGE("Endpoint Alloc Failure");
2194 printk("End of initendpoints\n");
2198 #ifdef THOMAS_BEACON
2199 void rtl8192_usb_deleteendpoints(struct net_device *dev)
2202 struct r8192_priv *priv = ieee80211_priv(dev);
2205 for(i=0;i<(MAX_RX_URB+1);i++){
2206 usb_kill_urb(priv->rx_urb[i]);
2207 usb_free_urb(priv->rx_urb[i]);
2209 kfree(priv->rx_urb);
2210 priv->rx_urb = NULL;
2212 kfree(priv->oldaddr);
2213 priv->oldaddr = NULL;
2214 if (priv->pp_rxskb) {
2215 kfree(priv->pp_rxskb);
2220 void rtl8192_usb_deleteendpoints(struct net_device *dev)
2223 struct r8192_priv *priv = ieee80211_priv(dev);
2225 #ifndef JACKSON_NEW_RX
2228 for(i=0;i<(MAX_RX_URB+1);i++){
2229 usb_kill_urb(priv->rx_urb[i]);
2230 kfree(priv->rx_urb[i]->transfer_buffer);
2231 usb_free_urb(priv->rx_urb[i]);
2233 kfree(priv->rx_urb);
2234 priv->rx_urb = NULL;
2238 kfree(priv->rx_urb);
2239 priv->rx_urb = NULL;
2240 kfree(priv->oldaddr);
2241 priv->oldaddr = NULL;
2242 if (priv->pp_rxskb) {
2243 kfree(priv->pp_rxskb);
2252 extern void rtl8192_update_ratr_table(struct net_device* dev);
2253 void rtl8192_link_change(struct net_device *dev)
2257 struct r8192_priv *priv = ieee80211_priv(dev);
2258 struct ieee80211_device* ieee = priv->ieee80211;
2259 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
2260 if (ieee->state == IEEE80211_LINKED)
2262 rtl8192_net_update(dev);
2263 rtl8192_update_ratr_table(dev);
2264 //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
2265 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
2266 EnableHWSecurityConfig8192(dev);
2268 /*update timing params*/
2269 // RT_TRACE(COMP_CH, "========>%s(), chan:%d\n", __FUNCTION__, priv->chan);
2270 // rtl8192_set_chan(dev, priv->chan);
2271 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
2274 reg = read_nic_dword(dev, RCR);
2275 if (priv->ieee80211->state == IEEE80211_LINKED)
2276 priv->ReceiveConfig = reg |= RCR_CBSSID;
2278 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
2279 write_nic_dword(dev, RCR, reg);
2282 // rtl8192_set_rxconf(dev);
2285 static struct ieee80211_qos_parameters def_qos_parameters = {
2286 {3,3,3,3},/* cw_min */
2287 {7,7,7,7},/* cw_max */
2288 {2,2,2,2},/* aifs */
2289 {0,0,0,0},/* flags */
2290 {0,0,0,0} /* tx_op_limit */
2294 void rtl8192_update_beacon(struct work_struct * work)
2296 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
2297 struct net_device *dev = priv->ieee80211->dev;
2298 struct ieee80211_device* ieee = priv->ieee80211;
2299 struct ieee80211_network* net = &ieee->current_network;
2301 if (ieee->pHTInfo->bCurrentHTSupport)
2302 HTUpdateSelfAndPeerSetting(ieee, net);
2303 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
2304 rtl8192_update_cap(dev, net->capability);
2307 * background support to run QoS activate functionality
2309 int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
2310 void rtl8192_qos_activate(struct work_struct * work)
2312 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
2313 struct net_device *dev = priv->ieee80211->dev;
2314 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
2315 u8 mode = priv->ieee80211->current_network.mode;
2316 //u32 size = sizeof(struct ieee80211_qos_parameters);
2324 mutex_lock(&priv->mutex);
2325 if(priv->ieee80211->state != IEEE80211_LINKED)
2327 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
2328 /* It better set slot time at first */
2329 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
2330 /* update the ac parameter to related registers */
2331 for(i = 0; i < QOS_QUEUE_NUM; i++) {
2332 //Mode G/A: slotTimeTimer = 9; Mode B: 20
2333 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
2334 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
2335 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
2336 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
2337 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
2339 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
2340 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
2344 mutex_unlock(&priv->mutex);
2347 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
2349 struct ieee80211_network *network)
2352 u32 size = sizeof(struct ieee80211_qos_parameters);
2354 if(priv->ieee80211->state !=IEEE80211_LINKED)
2357 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2360 if (network->flags & NETWORK_HAS_QOS_MASK) {
2361 if (active_network &&
2362 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
2363 network->qos_data.active = network->qos_data.supported;
2365 if ((network->qos_data.active == 1) && (active_network == 1) &&
2366 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
2367 (network->qos_data.old_param_count !=
2368 network->qos_data.param_count)) {
2369 network->qos_data.old_param_count =
2370 network->qos_data.param_count;
2371 queue_work(priv->priv_wq, &priv->qos_activate);
2372 RT_TRACE (COMP_QOS, "QoS parameters change call "
2376 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2377 &def_qos_parameters, size);
2379 if ((network->qos_data.active == 1) && (active_network == 1)) {
2380 queue_work(priv->priv_wq, &priv->qos_activate);
2381 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
2383 network->qos_data.active = 0;
2384 network->qos_data.supported = 0;
2390 /* handle and manage frame from beacon and probe response */
2391 static int rtl8192_handle_beacon(struct net_device * dev,
2392 struct ieee80211_beacon * beacon,
2393 struct ieee80211_network * network)
2395 struct r8192_priv *priv = ieee80211_priv(dev);
2397 rtl8192_qos_handle_probe_response(priv,1,network);
2398 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
2404 * handling the beaconing responses. if we get different QoS setting
2405 * off the network from the associated setting, adjust the QoS
2408 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
2409 struct ieee80211_network *network)
2412 unsigned long flags;
2413 u32 size = sizeof(struct ieee80211_qos_parameters);
2414 int set_qos_param = 0;
2416 if ((priv == NULL) || (network == NULL))
2419 if(priv->ieee80211->state !=IEEE80211_LINKED)
2422 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2425 spin_lock_irqsave(&priv->ieee80211->lock, flags);
2426 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
2427 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2428 &network->qos_data.parameters,\
2429 sizeof(struct ieee80211_qos_parameters));
2430 priv->ieee80211->current_network.qos_data.active = 1;
2433 /* update qos parameter for current network */
2434 priv->ieee80211->current_network.qos_data.old_param_count = \
2435 priv->ieee80211->current_network.qos_data.param_count;
2436 priv->ieee80211->current_network.qos_data.param_count = \
2437 network->qos_data.param_count;
2440 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2441 &def_qos_parameters, size);
2442 priv->ieee80211->current_network.qos_data.active = 0;
2443 priv->ieee80211->current_network.qos_data.supported = 0;
2447 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
2449 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
2450 if (set_qos_param == 1)
2451 queue_work(priv->priv_wq, &priv->qos_activate);
2458 static int rtl8192_handle_assoc_response(struct net_device *dev,
2459 struct ieee80211_assoc_response_frame *resp,
2460 struct ieee80211_network *network)
2462 struct r8192_priv *priv = ieee80211_priv(dev);
2463 rtl8192_qos_association_resp(priv, network);
2468 void rtl8192_update_ratr_table(struct net_device* dev)
2469 // POCTET_STRING posLegacyRate,
2471 // PRT_WLAN_STA pEntry)
2473 struct r8192_priv* priv = ieee80211_priv(dev);
2474 struct ieee80211_device* ieee = priv->ieee80211;
2475 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2476 //struct ieee80211_network *net = &ieee->current_network;
2479 rtl8192_config_rate(dev, (u16*)(&ratr_value));
2480 ratr_value |= (*(u16*)(pMcsRate)) << 12;
2481 // switch (net->mode)
2485 ratr_value &= 0x00000FF0;
2488 ratr_value &= 0x0000000F;
2491 ratr_value &= 0x00000FF7;
2495 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
2496 ratr_value &= 0x0007F007;
2498 if (priv->rf_type == RF_1T2R)
2499 ratr_value &= 0x000FF007;
2501 ratr_value &= 0x0F81F007;
2507 ratr_value &= 0x0FFFFFFF;
2508 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
2509 ratr_value |= 0x80000000;
2510 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
2511 ratr_value |= 0x80000000;
2513 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2514 write_nic_byte(dev, UFWP, 1);
2517 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
2518 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2519 bool GetNmodeSupportBySecCfg8192(struct net_device*dev)
2521 struct r8192_priv* priv = ieee80211_priv(dev);
2522 struct ieee80211_device* ieee = priv->ieee80211;
2523 struct ieee80211_network * network = &ieee->current_network;
2524 int wpa_ie_len= ieee->wpa_ie_len;
2525 struct ieee80211_crypt_data* crypt;
2528 crypt = ieee->crypt[ieee->tx_keyidx];
2529 //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
2530 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2533 if(encrypt && (wpa_ie_len == 0)) {
2534 /* wep encryption, no N mode setting */
2536 // } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
2537 } else if((wpa_ie_len != 0)) {
2538 /* parse pairwise key type */
2539 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
2540 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))))
2551 bool GetHalfNmodeSupportByAPs819xUsb(struct net_device* dev)
2554 struct r8192_priv* priv = ieee80211_priv(dev);
2555 struct ieee80211_device* ieee = priv->ieee80211;
2557 if(ieee->bHalfWirelessN24GMode == true)
2565 void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2567 struct ieee80211_device* ieee = priv->ieee80211;
2568 //we do not consider set support rate for ABG mode, only HT MCS rate is set here.
2569 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2571 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2572 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
2573 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
2576 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2580 u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2582 struct r8192_priv *priv = ieee80211_priv(dev);
2584 switch(priv->rf_chip)
2589 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2592 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2595 ret = WIRELESS_MODE_B;
2600 void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2602 struct r8192_priv *priv = ieee80211_priv(dev);
2603 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2605 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2607 if(bSupportMode & WIRELESS_MODE_N_24G)
2609 wireless_mode = WIRELESS_MODE_N_24G;
2611 else if(bSupportMode & WIRELESS_MODE_N_5G)
2613 wireless_mode = WIRELESS_MODE_N_5G;
2615 else if((bSupportMode & WIRELESS_MODE_A))
2617 wireless_mode = WIRELESS_MODE_A;
2619 else if((bSupportMode & WIRELESS_MODE_G))
2621 wireless_mode = WIRELESS_MODE_G;
2623 else if((bSupportMode & WIRELESS_MODE_B))
2625 wireless_mode = WIRELESS_MODE_B;
2628 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2629 wireless_mode = WIRELESS_MODE_B;
2632 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2633 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2635 priv->ieee80211->mode = wireless_mode;
2637 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2638 priv->ieee80211->pHTInfo->bEnableHT = 1;
2640 priv->ieee80211->pHTInfo->bEnableHT = 0;
2641 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2642 rtl8192_refresh_supportrate(priv);
2645 //init priv variables here. only non_zero value should be initialized here.
2646 static void rtl8192_init_priv_variable(struct net_device* dev)
2648 struct r8192_priv *priv = ieee80211_priv(dev);
2650 priv->card_8192 = NIC_8192U;
2651 priv->chan = 1; //set to channel 1
2652 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2653 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2654 priv->ieee80211->ieee_up=0;
2655 priv->retry_rts = DEFAULT_RETRY_RTS;
2656 priv->retry_data = DEFAULT_RETRY_DATA;
2657 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2658 priv->ieee80211->rate = 110; //11 mbps
2659 priv->ieee80211->short_slot = 1;
2660 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2663 priv->IrpPendingCount = 1;
2664 priv->ResetProgress = RESET_TYPE_NORESET;
2665 priv->bForcedSilentReset = 0;
2666 priv->bDisableNormalResetCheck = false;
2667 priv->force_reset = false;
2669 priv->ieee80211->FwRWRF = 0; //we don't use FW read/write RF until stable firmware is available.
2670 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2671 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2672 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2673 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2674 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
2675 IEEE_SOFTMAC_BEACONS;//added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2677 priv->ieee80211->active_scan = 1;
2678 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2679 priv->ieee80211->host_encrypt = 1;
2680 priv->ieee80211->host_decrypt = 1;
2681 priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2682 priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2683 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2684 priv->ieee80211->set_chan = rtl8192_set_chan;
2685 priv->ieee80211->link_change = rtl8192_link_change;
2686 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2687 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2688 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2689 priv->ieee80211->init_wmmparam_flag = 0;
2690 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2691 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2692 priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
2693 priv->ieee80211->qos_support = 1;
2696 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2697 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2698 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2699 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2701 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
2702 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
2703 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2705 priv->ieee80211->InitialGainHandler = InitialGain819xUsb;
2706 priv->card_type = USB;
2708 if(Adapter->bInHctTest)
2710 pHalData->ShortRetryLimit = 7;
2711 pHalData->LongRetryLimit = 7;
2715 priv->ShortRetryLimit = 0x30;
2716 priv->LongRetryLimit = 0x30;
2718 priv->EarlyRxThreshold = 7;
2719 priv->enable_gpio0 = 0;
2720 priv->TransmitConfig =
2721 // TCR_DurProcMode | //for RTL8185B, duration setting by HW
2722 //? TCR_DISReqQsize |
2723 (TCR_MXDMA_2048<<TCR_MXDMA_OFFSET)| // Max DMA Burst Size per Tx DMA Burst, 7: reserved.
2724 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)| // Short retry limit
2725 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
2726 (false ? TCR_SAT: 0); // FALSE: HW provides PLCP length and LENGEXT, TRUE: SW provides them
2728 if(Adapter->bInHctTest)
2729 pHalData->ReceiveConfig = pHalData->CSMethod |
2730 RCR_AMF | RCR_ADF | //RCR_AAP | //accept management/data
2732 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2733 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2734 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2735 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2736 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
2737 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt:0);
2741 priv->ReceiveConfig =
2742 RCR_AMF | RCR_ADF | //accept management/data
2743 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2744 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2745 //RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2746 ((u32)7<<RCR_MXDMA_OFFSET)| // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2747 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) | // Rx FIFO Threshold, 7: No Rx threshold.
2748 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT:0);
2750 priv->AcmControl = 0;
2751 priv->pFirmware = kzalloc(sizeof(rt_firmware), GFP_KERNEL);
2753 /* rx related queue */
2754 skb_queue_head_init(&priv->rx_queue);
2755 skb_queue_head_init(&priv->skb_queue);
2757 /* Tx related queue */
2758 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2759 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2761 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2762 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2764 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2765 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ [i]);
2767 priv->rf_set_chan = rtl8192_phy_SwChnl;
2771 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2773 spin_lock_init(&priv->tx_lock);
2774 spin_lock_init(&priv->irq_lock);//added by thomas
2775 //spin_lock_init(&priv->rf_lock);
2776 sema_init(&priv->wx_sem,1);
2777 sema_init(&priv->rf_sem,1);
2778 mutex_init(&priv->mutex);
2781 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
2783 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2784 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2785 #define DRV_NAME "wlan0"
2786 static void rtl8192_init_priv_task(struct net_device* dev)
2788 struct r8192_priv *priv = ieee80211_priv(dev);
2790 priv->priv_wq = create_workqueue(DRV_NAME);
2792 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2794 //INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2795 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2796 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2797 // INIT_DELAYED_WORK(&priv->gpio_change_rf_wq, dm_gpio_change_rf_callback);
2798 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2799 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2800 INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
2801 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2802 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2803 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2805 tasklet_init(&priv->irq_rx_tasklet,
2806 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2807 (unsigned long)priv);
2810 static void rtl8192_get_eeprom_size(struct net_device* dev)
2813 struct r8192_priv *priv = ieee80211_priv(dev);
2814 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2815 curCR = read_nic_word_E(dev,EPROM_CMD);
2816 RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
2817 //whether need I consider BIT5?
2818 priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2819 RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2822 //used to swap endian. as ntohl & htonl are not necessary to swap endian, so use this instead.
2823 static inline u16 endian_swap(u16* data)
2826 *data = (tmp >> 8) | (tmp << 8);
2829 static void rtl8192_read_eeprom_info(struct net_device* dev)
2832 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
2833 u8 bLoad_From_EEPOM = false;
2834 struct r8192_priv *priv = ieee80211_priv(dev);
2836 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2837 wEPROM_ID = eprom_read(dev, 0); //first read EEPROM ID out;
2838 RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
2840 if (wEPROM_ID != RTL8190_EEPROM_ID)
2842 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", wEPROM_ID, RTL8190_EEPROM_ID);
2845 bLoad_From_EEPOM = true;
2847 if (bLoad_From_EEPOM)
2849 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
2850 priv->eeprom_vid = endian_swap(&tmpValue);
2851 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
2852 tmpValue = eprom_read(dev, (EEPROM_ChannelPlan>>1));
2853 priv->eeprom_ChannelPlan =((tmpValue&0xff00)>>8);
2854 priv->btxpowerdata_readfromEEPORM = true;
2855 priv->eeprom_CustomerID = eprom_read(dev, (EEPROM_Customer_ID>>1)) >>8;
2859 priv->eeprom_vid = 0;
2860 priv->eeprom_pid = 0;
2861 priv->card_8192_version = VERSION_819xU_B;
2862 priv->eeprom_ChannelPlan = 0;
2863 priv->eeprom_CustomerID = 0;
2865 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);
2866 //set channelplan from eeprom
2867 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2868 if (bLoad_From_EEPOM)
2871 for (i=0; i<6; i+=2)
2874 tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
2875 *(u16*)(&dev->dev_addr[i]) = tmp;
2880 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2881 //should I set IDR0 here?
2883 RT_TRACE(COMP_EPROM, "MAC addr:%pM\n", dev->dev_addr);
2884 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
2885 priv->rf_chip = RF_8256;
2887 if (priv->card_8192_version == (u8)VERSION_819xU_A)
2889 //read Tx power gain offset of legacy OFDM to HT rate
2890 if (bLoad_From_EEPOM)
2891 priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff>>1))&0xff00) >> 8;
2893 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
2894 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
2895 //read ThermalMeter from EEPROM
2896 if (bLoad_From_EEPOM)
2897 priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter>>1))&0x00ff);
2899 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2900 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
2901 //vivi, for tx power track
2902 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2903 //read antenna tx power offset of B/C/D to A from EEPROM
2904 if (bLoad_From_EEPOM)
2905 priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff>>1))&0x0f00)>>8;
2907 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
2908 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
2909 // Read CrystalCap from EEPROM
2910 if (bLoad_From_EEPOM)
2911 priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap>>1))&0x0f);
2913 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
2914 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
2915 //get per-channel Tx power level
2916 if (bLoad_From_EEPOM)
2917 priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver>>1))&0xff00)>>8;
2919 priv->EEPROM_Def_Ver = 1;
2920 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
2921 if (priv->EEPROM_Def_Ver == 0) //old eeprom definition
2924 if (bLoad_From_EEPOM)
2925 priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK>>1))&0xff) >> 8;
2927 priv->EEPROMTxPowerLevelCCK = 0x10;
2928 RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
2931 if (bLoad_From_EEPOM)
2933 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G+i)>>1);
2934 if (((EEPROM_TxPwIndex_OFDM_24G+i) % 2) == 0)
2935 tmpValue = tmpValue & 0x00ff;
2937 tmpValue = (tmpValue & 0xff00) >> 8;
2941 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8) tmpValue;
2942 RT_TRACE(COMP_EPROM, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK);
2944 }//end if EEPROM_DEF_VER == 0
2945 else if (priv->EEPROM_Def_Ver == 1)
2947 if (bLoad_From_EEPOM)
2949 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1>>1));
2950 tmpValue = (tmpValue & 0xff00) >> 8;
2954 priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
2956 if (bLoad_From_EEPOM)
2957 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2)>>1);
2960 *((u16*)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
2961 if (bLoad_From_EEPOM)
2962 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1>>1));
2965 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[0])) = tmpValue;
2966 if (bLoad_From_EEPOM)
2967 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1+2)>>1);
2970 priv->EEPROMTxPowerLevelOFDM24G[2] = (u8)tmpValue;
2971 }//endif EEPROM_Def_Ver == 1
2973 //update HAL variables
2977 for (i=0; i<14; i++)
2980 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[0];
2981 else if (i>=4 && i<=9)
2982 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[1];
2984 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[2];
2987 for (i=0; i<14; i++)
2989 if (priv->EEPROM_Def_Ver == 0)
2992 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[0] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
2993 else if (i>=4 && i<=9)
2994 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK;
2996 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[2] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
2998 else if (priv->EEPROM_Def_Ver == 1)
3001 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[0];
3002 else if (i>=4 && i<=9)
3003 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[1];
3005 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[2];
3008 }//end update HAL variables
3009 priv->TxPowerDiff = priv->EEPROMPwDiff;
3010 // Antenna B gain offset to antenna A, bit0~3
3011 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
3012 // Antenna C gain offset to antenna A, bit4~7
3013 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
3014 // CrystalCap, bit12~15
3015 priv->CrystalCap = priv->EEPROMCrystalCap;
3016 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
3017 // 92U does not enable TX power tracking.
3018 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
3019 }//end if VersionID == VERSION_819xU_A
3021 //added by vivi, for dlink led, 20080416
3022 switch(priv->eeprom_CustomerID)
3024 case EEPROM_CID_RUNTOP:
3025 priv->CustomerID = RT_CID_819x_RUNTOP;
3028 case EEPROM_CID_DLINK:
3029 priv->CustomerID = RT_CID_DLINK;
3033 priv->CustomerID = RT_CID_DEFAULT;
3038 switch(priv->CustomerID)
3040 case RT_CID_819x_RUNTOP:
3041 priv->LedStrategy = SW_LED_MODE2;
3045 priv->LedStrategy = SW_LED_MODE4;
3049 priv->LedStrategy = SW_LED_MODE0;
3055 if(priv->rf_type == RF_1T2R)
3057 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
3061 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
3064 // 2008/01/16 MH We can only know RF type in the function. So we have to init
3065 // DIG RATR table again.
3066 init_rate_adaptive(dev);
3067 //we need init DIG RATR table here again.
3069 RT_TRACE(COMP_EPROM, "<===========%s()\n", __FUNCTION__);
3073 short rtl8192_get_channel_map(struct net_device * dev)
3075 struct r8192_priv *priv = ieee80211_priv(dev);
3076 if(priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN){
3077 printk("rtl8180_init:Error channel plan! Set to default.\n");
3078 priv->ChannelPlan= 0;
3080 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
3082 rtl819x_set_channel_map(priv->ChannelPlan, priv);
3086 short rtl8192_init(struct net_device *dev)
3089 struct r8192_priv *priv = ieee80211_priv(dev);
3091 memset(&(priv->stats),0,sizeof(struct Stats));
3092 memset(priv->txqueue_to_outpipemap,0,9);
3096 u8 queuetopipe[]={3,2,1,0,4,8,7,6,5};
3097 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3099 printk("%d ",priv->txqueue_to_outpipemap[i]);
3104 u8 queuetopipe[]={3,2,1,0,4,4,0,4,4};
3105 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3107 printk("%d ",priv->txqueue_to_outpipemap[i]);
3111 rtl8192_init_priv_variable(dev);
3112 rtl8192_init_priv_lock(priv);
3113 rtl8192_init_priv_task(dev);
3114 rtl8192_get_eeprom_size(dev);
3115 rtl8192_read_eeprom_info(dev);
3116 rtl8192_get_channel_map(dev);
3118 init_timer(&priv->watch_dog_timer);
3119 priv->watch_dog_timer.data = (unsigned long)dev;
3120 priv->watch_dog_timer.function = watch_dog_timer_callback;
3121 if(rtl8192_usb_initendpoints(dev)!=0){
3122 DMESG("Endopoints initialization failed");
3126 //rtl8192_adapter_start(dev);
3133 /******************************************************************************
3134 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
3135 * not to do all the hw config as its name says
3136 * input: net_device dev
3139 * notice: This part need to modified according to the rate set we filtered
3140 * ****************************************************************************/
3141 void rtl8192_hwconfig(struct net_device* dev)
3143 u32 regRATR = 0, regRRSR = 0;
3144 u8 regBwOpMode = 0, regTmp = 0;
3145 struct r8192_priv *priv = ieee80211_priv(dev);
3147 // Set RRSR, RATR, and BW_OPMODE registers
3149 switch(priv->ieee80211->mode)
3151 case WIRELESS_MODE_B:
3152 regBwOpMode = BW_OPMODE_20MHZ;
3153 regRATR = RATE_ALL_CCK;
3154 regRRSR = RATE_ALL_CCK;
3156 case WIRELESS_MODE_A:
3157 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
3158 regRATR = RATE_ALL_OFDM_AG;
3159 regRRSR = RATE_ALL_OFDM_AG;
3161 case WIRELESS_MODE_G:
3162 regBwOpMode = BW_OPMODE_20MHZ;
3163 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3164 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3166 case WIRELESS_MODE_AUTO:
3168 if (Adapter->bInHctTest)
3170 regBwOpMode = BW_OPMODE_20MHZ;
3171 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3172 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3177 regBwOpMode = BW_OPMODE_20MHZ;
3178 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3179 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3182 case WIRELESS_MODE_N_24G:
3183 // It support CCK rate by default.
3184 // CCK rate will be filtered out only when associated AP does not support it.
3185 regBwOpMode = BW_OPMODE_20MHZ;
3186 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3187 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3189 case WIRELESS_MODE_N_5G:
3190 regBwOpMode = BW_OPMODE_5G;
3191 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3192 regRRSR = RATE_ALL_OFDM_AG;
3196 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
3199 ratr_value = regRATR;
3200 if (priv->rf_type == RF_1T2R)
3202 ratr_value &= ~(RATE_ALL_OFDM_2SS);
3204 write_nic_dword(dev, RATR0, ratr_value);
3205 write_nic_byte(dev, UFWP, 1);
3207 regTmp = read_nic_byte(dev, 0x313);
3208 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
3209 write_nic_dword(dev, RRSR, regRRSR);
3212 // Set Retry Limit here
3214 write_nic_word(dev, RETRY_LIMIT,
3215 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | \
3216 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3217 // Set Contention Window here
3221 // Set Tx Antenna including Feedback control
3223 // Set Auto Rate fallback control
3229 //InitializeAdapter and PhyCfg
3230 bool rtl8192_adapter_start(struct net_device *dev)
3232 struct r8192_priv *priv = ieee80211_priv(dev);
3234 bool init_status = true;
3235 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3236 priv->Rf_Mode = RF_OP_By_SW_3wire;
3237 //for ASIC power on sequence
3238 write_nic_byte_E(dev, 0x5f, 0x80);
3240 write_nic_byte_E(dev, 0x5f, 0xf0);
3241 write_nic_byte_E(dev, 0x5d, 0x00);
3242 write_nic_byte_E(dev, 0x5e, 0x80);
3243 write_nic_byte(dev, 0x17, 0x37);
3246 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3247 //config CPUReset Register
3248 //Firmware Reset or not?
3249 dwRegRead = read_nic_dword(dev, CPU_GEN);
3250 if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3251 dwRegRead |= CPU_GEN_SYSTEM_RESET; //do nothing here?
3252 else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3253 dwRegRead |= CPU_GEN_FIRMWARE_RESET;
3255 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3257 write_nic_dword(dev, CPU_GEN, dwRegRead);
3260 rtl8192_BBConfig(dev);
3262 //Loopback mode or not
3263 priv->LoopbackMode = RTL819xU_NO_LOOPBACK;
3264 // priv->LoopbackMode = RTL819xU_MAC_LOOPBACK;
3266 dwRegRead = read_nic_dword(dev, CPU_GEN);
3267 if (priv->LoopbackMode == RTL819xU_NO_LOOPBACK)
3268 dwRegRead = ((dwRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3269 else if (priv->LoopbackMode == RTL819xU_MAC_LOOPBACK)
3270 dwRegRead |= CPU_CCK_LOOPBACK;
3272 RT_TRACE(COMP_ERR, "Serious error in %s(): wrong loopback mode setting(%d)\n", __FUNCTION__, priv->LoopbackMode);
3274 write_nic_dword(dev, CPU_GEN, dwRegRead);
3276 //after reset cpu, we need wait for a seconds to write in register.
3279 //xiong add for new bitfile:usb suspend reset pin set to 1. //do we need?
3280 write_nic_byte_E(dev, 0x5f, (read_nic_byte_E(dev, 0x5f)|0x20));
3283 rtl8192_hwconfig(dev);
3286 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3289 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3290 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3293 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3295 //Initialize Number of Reserved Pages in Firmware Queue
3296 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |\
3297 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT | \
3298 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT | \
3299 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3300 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT |\
3301 NUM_OF_PAGE_IN_FW_QUEUE_CMD << RSVD_FW_QUEUE_PAGE_CMD_SHIFT);
3302 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW| \
3303 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
3304 // | NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
3306 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3309 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3310 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3312 // RT_TRACE(COMP_INIT, "%s():priv->ResetProgress is %d\n", __FUNCTION__,priv->ResetProgress);
3313 if(priv->ResetProgress == RESET_TYPE_NORESET)
3314 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3315 if(priv->ResetProgress == RESET_TYPE_NORESET){
3316 CamResetAllEntry(dev);
3318 u8 SECR_value = 0x0;
3319 SECR_value |= SCR_TxEncEnable;
3320 SECR_value |= SCR_RxDecEnable;
3321 SECR_value |= SCR_NoSKMC;
3322 write_nic_byte(dev, SECR, SECR_value);
3327 write_nic_word(dev, ATIMWND, 2);
3328 write_nic_word(dev, BCN_INTERVAL, 100);
3331 #define DEFAULT_EDCA 0x005e4332
3333 for (i=0; i<QOS_QUEUE_NUM; i++)
3334 write_nic_dword(dev, WDCAPARA_ADD[i], DEFAULT_EDCA);
3336 #ifdef USB_RX_AGGREGATION_SUPPORT
3337 //3 For usb rx firmware aggregation control
3338 if(priv->ResetProgress == RESET_TYPE_NORESET)
3341 PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
3342 ulValue = (pHTInfo->UsbRxFwAggrEn<<24) | (pHTInfo->UsbRxFwAggrPageNum<<16) |
3343 (pHTInfo->UsbRxFwAggrPacketNum<<8) | (pHTInfo->UsbRxFwAggrTimeout);
3345 * If usb rx firmware aggregation is enabled,
3346 * when anyone of three threshold conditions above is reached,
3347 * firmware will send aggregated packet to driver.
3349 write_nic_dword(dev, 0x1a8, ulValue);
3350 priv->bCurrentRxAggrEnable = true;
3354 rtl8192_phy_configmac(dev);
3356 if (priv->card_8192_version == (u8) VERSION_819xU_A)
3358 rtl8192_phy_getTxPower(dev);
3359 rtl8192_phy_setTxPower(dev, priv->chan);
3363 init_status = init_firmware(dev);
3366 RT_TRACE(COMP_ERR,"ERR!!! %s(): Firmware download is failed\n", __FUNCTION__);
3369 RT_TRACE(COMP_INIT, "%s():after firmware download\n", __FUNCTION__);
3372 if(Adapter->ResetProgress == RESET_TYPE_NORESET)
3374 if(pMgntInfo->RegRfOff == TRUE)
3375 { // User disable RF via registry.
3376 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
3377 MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
3378 // Those actions will be discard in MgntActSet_RF_State because of the same state
3379 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3380 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3382 else if(pMgntInfo->RfOffReason > RF_CHANGE_BY_PS)
3383 { // H/W or S/W RF OFF before sleep.
3384 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RfOffReason(%d) ----------\n", pMgntInfo->RfOffReason));
3385 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3389 pHalData->eRFPowerState = eRfOn;
3390 pMgntInfo->RfOffReason = 0;
3391 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): RF is on ----------\n"));
3396 if(pHalData->eRFPowerState == eRfOff)
3398 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3399 // Those actions will be discard in MgntActSet_RF_State because of the same state
3400 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3401 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3406 if(priv->ResetProgress == RESET_TYPE_NORESET){
3407 rtl8192_phy_RFConfig(dev);
3408 RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __FUNCTION__);
3412 if(priv->ieee80211->FwRWRF)
3413 // We can force firmware to do RF-R/W
3414 priv->Rf_Mode = RF_OP_By_FW;
3416 priv->Rf_Mode = RF_OP_By_SW_3wire;
3419 rtl8192_phy_updateInitGain(dev);
3420 /*--set CCK and OFDM Block "ON"--*/
3421 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3422 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3424 if(priv->ResetProgress == RESET_TYPE_NORESET)
3427 u8 tmpvalue = read_nic_byte(dev, 0x301);
3431 RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
3435 priv->bDcut = FALSE;
3436 RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
3438 dm_initialize_txpower_tracking(dev);
3440 if(priv->bDcut == TRUE)
3443 u32 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3444 // u32 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3445 for(i = 0; i<TxBBGainTableLength; i++)
3447 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3449 priv->rfa_txpowertrackingindex= (u8)i;
3450 priv->rfa_txpowertrackingindex_real= (u8)i;
3451 priv->rfa_txpowertracking_default= priv->rfa_txpowertrackingindex;
3456 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3458 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3461 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3463 priv->cck_present_attentuation_20Mdefault=(u8) i;
3467 priv->cck_present_attentuation_40Mdefault= 0;
3468 priv->cck_present_attentuation_difference= 0;
3469 priv->cck_present_attentuation = priv->cck_present_attentuation_20Mdefault;
3471 // pMgntInfo->bTXPowerTracking = FALSE;//TEMPLY DISABLE
3474 write_nic_byte(dev, 0x87, 0x0);
3480 /* this configures registers for beacon tx and enables it via
3481 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3482 * be used to stop beacon transmission
3484 /***************************************************************************
3485 -------------------------------NET STUFF---------------------------
3486 ***************************************************************************/
3488 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
3490 struct r8192_priv *priv = ieee80211_priv(dev);
3492 return &priv->ieee80211->stats;
3496 HalTxCheckStuck819xUsb(
3497 struct net_device *dev
3500 struct r8192_priv *priv = ieee80211_priv(dev);
3501 u16 RegTxCounter = read_nic_word(dev, 0x128);
3502 bool bStuck = FALSE;
3503 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3504 if(priv->TxCounter==RegTxCounter)
3507 priv->TxCounter = RegTxCounter;
3513 * <Assumption: RT_TX_SPINLOCK is acquired.>
3514 * First added: 2006.11.19 by emily
3517 TxCheckStuck(struct net_device *dev)
3519 struct r8192_priv *priv = ieee80211_priv(dev);
3522 // u8 ResetThreshold;
3523 bool bCheckFwTxCnt = false;
3524 //unsigned long flags;
3527 // Decide such threshold according to current power save mode
3530 // RT_TRACE(COMP_RESET, " ==> TxCheckStuck()\n");
3531 // PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK);
3532 // spin_lock_irqsave(&priv->ieee80211->lock,flags);
3533 for (QueueID = 0; QueueID<=BEACON_QUEUE;QueueID ++)
3535 if(QueueID == TXCMD_QUEUE)
3537 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3538 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))
3540 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
3544 bCheckFwTxCnt = true;
3546 // PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
3547 // spin_unlock_irqrestore(&priv->ieee80211->lock,flags);
3548 // RT_TRACE(COMP_RESET,"bCheckFwTxCnt is %d\n",bCheckFwTxCnt);
3551 if(HalTxCheckStuck819xUsb(dev))
3553 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3554 return RESET_TYPE_SILENT;
3557 return RESET_TYPE_NORESET;
3561 HalRxCheckStuck819xUsb(struct net_device *dev)
3563 u16 RegRxCounter = read_nic_word(dev, 0x130);
3564 struct r8192_priv *priv = ieee80211_priv(dev);
3565 bool bStuck = FALSE;
3566 static u8 rx_chk_cnt;
3567 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3568 // If rssi is small, we should check rx for long time because of bad rx.
3569 // or maybe it will continuous silent reset every 2 seconds.
3571 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3573 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
3575 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3576 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3577 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
3588 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
3589 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
3590 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
3594 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3600 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3607 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
3613 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
3617 if(priv->RxCounter==RegRxCounter)
3620 priv->RxCounter = RegRxCounter;
3626 RxCheckStuck(struct net_device *dev)
3628 struct r8192_priv *priv = ieee80211_priv(dev);
3630 bool bRxCheck = FALSE;
3632 // RT_TRACE(COMP_RESET," ==> RxCheckStuck()\n");
3633 //PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
3635 if(priv->IrpPendingCount > 1)
3637 //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
3639 // RT_TRACE(COMP_RESET,"bRxCheck is %d \n",bRxCheck);
3642 if(HalRxCheckStuck819xUsb(dev))
3644 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
3645 return RESET_TYPE_SILENT;
3648 return RESET_TYPE_NORESET;
3653 * This function is called by Checkforhang to check whether we should ask OS to reset driver
3655 * \param pAdapter The adapter context for this miniport
3657 * Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
3658 * to judge whether there is tx stuck.
3659 * Note: This function may be required to be rewrite for Vista OS.
3660 * <<<Assumption: Tx spinlock has been acquired >>>
3662 * 8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
3665 rtl819x_ifcheck_resetornot(struct net_device *dev)
3667 struct r8192_priv *priv = ieee80211_priv(dev);
3668 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
3669 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
3670 RT_RF_POWER_STATE rfState;
3672 rfState = priv->ieee80211->eRFPowerState;
3674 TxResetType = TxCheckStuck(dev);
3675 if( rfState != eRfOff ||
3676 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3677 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
3679 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3680 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3681 // if driver is in firmware download failure status, driver should initialize RF in the following
3682 // silent reset procedure Emily, 2008.01.21
3684 // Driver should not check RX stuck in IBSS mode because it is required to
3685 // set Check BSSID in order to send beacon, however, if check BSSID is
3686 // set, STA cannot hear any packet at all. Emily, 2008.04.12
3687 RxResetType = RxCheckStuck(dev);
3689 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
3690 return RESET_TYPE_NORMAL;
3691 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT){
3692 RT_TRACE(COMP_RESET,"%s():silent reset\n",__FUNCTION__);
3693 return RESET_TYPE_SILENT;
3696 return RESET_TYPE_NORESET;
3700 void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
3701 int _rtl8192_up(struct net_device *dev);
3702 int rtl8192_close(struct net_device *dev);
3707 CamRestoreAllEntry( struct net_device *dev)
3710 struct r8192_priv *priv = ieee80211_priv(dev);
3711 u8* MacAddr = priv->ieee80211->current_network.bssid;
3713 static u8 CAM_CONST_ADDR[4][6] = {
3714 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3715 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3716 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3717 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3718 static u8 CAM_CONST_BROAD[] =
3719 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3721 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3724 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
3725 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
3728 for(EntryId=0; EntryId<4; EntryId++)
3731 MacAddr = CAM_CONST_ADDR[EntryId];
3735 priv->ieee80211->pairwise_key_type,
3743 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
3747 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3751 priv->ieee80211->pairwise_key_type,
3759 priv->ieee80211->pairwise_key_type,
3765 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
3769 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3773 priv->ieee80211->pairwise_key_type,
3781 priv->ieee80211->pairwise_key_type,
3790 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
3792 MacAddr = CAM_CONST_BROAD;
3793 for(EntryId=1 ; EntryId<4 ; EntryId++)
3799 priv->ieee80211->group_key_type,
3805 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3809 priv->ieee80211->group_key_type,
3814 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
3816 MacAddr = CAM_CONST_BROAD;
3817 for(EntryId=1; EntryId<4 ; EntryId++)
3823 priv->ieee80211->group_key_type,
3830 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3834 priv->ieee80211->group_key_type,
3840 //////////////////////////////////////////////////////////////
3841 // This function is used to fix Tx/Rx stop bug temporarily.
3842 // This function will do "system reset" to NIC when Tx or Rx is stuck.
3843 // The method checking Tx/Rx stuck of this function is supported by FW,
3844 // which reports Tx and Rx counter to register 0x128 and 0x130.
3845 //////////////////////////////////////////////////////////////
3847 rtl819x_ifsilentreset(struct net_device *dev)
3849 //OCTET_STRING asocpdu;
3850 struct r8192_priv *priv = ieee80211_priv(dev);
3852 int reset_status = 0;
3853 struct ieee80211_device *ieee = priv->ieee80211;
3856 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3857 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3859 if(priv->ResetProgress==RESET_TYPE_NORESET)
3863 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
3865 // Set the variable for reset.
3866 priv->ResetProgress = RESET_TYPE_SILENT;
3867 // rtl8192_close(dev);
3868 down(&priv->wx_sem);
3871 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
3876 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
3877 // if(!netif_queue_stopped(dev))
3878 // netif_stop_queue(dev);
3880 rtl8192_rtx_disable(dev);
3881 rtl8192_cancel_deferred_work(priv);
3883 del_timer_sync(&priv->watch_dog_timer);
3885 ieee->sync_scan_hurryup = 1;
3886 if(ieee->state == IEEE80211_LINKED)
3888 down(&ieee->wx_sem);
3889 printk("ieee->state is IEEE80211_LINKED\n");
3890 ieee80211_stop_send_beacons(priv->ieee80211);
3891 del_timer_sync(&ieee->associate_timer);
3892 cancel_delayed_work(&ieee->associate_retry_wq);
3893 ieee80211_stop_scan(ieee);
3894 netif_carrier_off(dev);
3898 printk("ieee->state is NOT LINKED\n");
3899 ieee80211_softmac_stop_protocol(priv->ieee80211); }
3901 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
3902 //rtl8192_irq_disable(dev);
3903 RT_TRACE(COMP_RESET,"%s():===========>start up the driver\n",__FUNCTION__);
3904 reset_status = _rtl8192_up(dev);
3906 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
3907 if(reset_status == -EAGAIN)
3916 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n", __FUNCTION__);
3919 ieee->is_silent_reset = 1;
3920 EnableHWSecurityConfig8192(dev);
3921 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
3923 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3925 queue_work(ieee->wq, &ieee->associate_complete_wq);
3928 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
3930 ieee->set_chan(ieee->dev, ieee->current_network.channel);
3931 ieee->link_change(ieee->dev);
3933 // notify_wx_assoc_event(ieee);
3935 ieee80211_start_send_beacons(ieee);
3937 if (ieee->data_hard_resume)
3938 ieee->data_hard_resume(ieee->dev);
3939 netif_carrier_on(ieee->dev);
3942 CamRestoreAllEntry(dev);
3944 priv->ResetProgress = RESET_TYPE_NORESET;
3945 priv->reset_count++;
3947 priv->bForcedSilentReset =false;
3948 priv->bResetInProgress = false;
3950 // For test --> force write UFWP.
3951 write_nic_byte(dev, UFWP, 1);
3952 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
3956 void CAM_read_entry(
3957 struct net_device *dev,
3961 u32 target_command=0;
3962 u32 target_content=0;
3966 // printk("=======>start read CAM\n");
3967 for(entry_i=0;entry_i<CAM_CONTENT_COUNT;entry_i++)
3969 // polling bit, and No Write enable, and address
3970 target_command= entry_i+CAM_CONTENT_COUNT*iIndex;
3971 target_command= target_command | BIT31;
3973 //Check polling bit is clear
3977 ulStatus = read_nic_dword(dev, RWCAM);
3978 if(ulStatus & BIT31){
3985 write_nic_dword(dev, RWCAM, target_command);
3986 RT_TRACE(COMP_SEC,"CAM_read_entry(): WRITE A0: %x \n",target_command);
3987 // printk("CAM_read_entry(): WRITE A0: %lx \n",target_command);
3988 target_content = read_nic_dword(dev, RCAMO);
3989 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A8: %x \n",target_content);
3990 // printk("CAM_read_entry(): WRITE A8: %lx \n",target_content);
3995 void rtl819x_update_rxcounts(
3996 struct r8192_priv *priv,
4005 *TotalRxDataNum = 0;
4007 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4008 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4009 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4010 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4011 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4012 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4017 extern void rtl819x_watchdog_wqcallback(struct work_struct *work)
4019 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4020 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4021 struct net_device *dev = priv->ieee80211->dev;
4022 struct ieee80211_device* ieee = priv->ieee80211;
4023 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4024 static u8 check_reset_cnt;
4025 bool bBusyTraffic = false;
4029 hal_dm_watchdog(dev);
4031 {//to get busy traffic condition
4032 if(ieee->state == IEEE80211_LINKED)
4034 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 666 ||
4035 ieee->LinkDetectInfo.NumTxOkInPeriod> 666 ) {
4036 bBusyTraffic = true;
4038 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4039 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4040 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4043 //added by amy for AP roaming
4045 if(priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA)
4047 u32 TotalRxBcnNum = 0;
4048 u32 TotalRxDataNum = 0;
4050 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4051 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4054 if(rfState == eRfOff)
4055 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4057 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4058 // Dot11d_Reset(dev);
4059 priv->ieee80211->state = IEEE80211_ASSOCIATING;
4060 notify_wx_assoc_event(priv->ieee80211);
4061 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4062 priv->ieee80211->link_change(dev);
4063 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
4067 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod=0;
4068 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod=0;
4070 // CAM_read_entry(dev,4);
4071 //check if reset the driver
4072 if(check_reset_cnt++ >= 3)
4074 ResetType = rtl819x_ifcheck_resetornot(dev);
4075 check_reset_cnt = 3;
4076 //DbgPrint("Start to check silent reset\n");
4078 // 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);
4079 if( (priv->force_reset) || (priv->ResetProgress==RESET_TYPE_NORESET &&
4080 (priv->bForcedSilentReset ||
4081 (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT)))) // This is control by OID set in Pomelo
4083 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);
4084 rtl819x_ifsilentreset(dev);
4086 priv->force_reset = false;
4087 priv->bForcedSilentReset = false;
4088 priv->bResetInProgress = false;
4089 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4093 void watch_dog_timer_callback(unsigned long data)
4095 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4096 //printk("===============>watch_dog timer\n");
4097 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq, 0);
4098 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4100 int _rtl8192_up(struct net_device *dev)
4102 struct r8192_priv *priv = ieee80211_priv(dev);
4104 int init_status = 0;
4106 priv->ieee80211->ieee_up=1;
4107 RT_TRACE(COMP_INIT, "Bringing up iface");
4108 init_status = rtl8192_adapter_start(dev);
4111 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization failed!\n", __FUNCTION__);
4112 priv->up=priv->ieee80211->ieee_up = 0;
4115 RT_TRACE(COMP_INIT, "start adapter finished\n");
4116 rtl8192_rx_enable(dev);
4117 // rtl8192_tx_enable(dev);
4118 if(priv->ieee80211->state != IEEE80211_LINKED)
4119 ieee80211_softmac_start_protocol(priv->ieee80211);
4120 ieee80211_reset_queue(priv->ieee80211);
4121 watch_dog_timer_callback((unsigned long) dev);
4122 if(!netif_queue_stopped(dev))
4123 netif_start_queue(dev);
4125 netif_wake_queue(dev);
4131 int rtl8192_open(struct net_device *dev)
4133 struct r8192_priv *priv = ieee80211_priv(dev);
4135 down(&priv->wx_sem);
4136 ret = rtl8192_up(dev);
4143 int rtl8192_up(struct net_device *dev)
4145 struct r8192_priv *priv = ieee80211_priv(dev);
4147 if (priv->up == 1) return -1;
4149 return _rtl8192_up(dev);
4153 int rtl8192_close(struct net_device *dev)
4155 struct r8192_priv *priv = ieee80211_priv(dev);
4158 down(&priv->wx_sem);
4160 ret = rtl8192_down(dev);
4168 int rtl8192_down(struct net_device *dev)
4170 struct r8192_priv *priv = ieee80211_priv(dev);
4173 if (priv->up == 0) return -1;
4176 priv->ieee80211->ieee_up = 0;
4177 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4179 if (!netif_queue_stopped(dev))
4180 netif_stop_queue(dev);
4182 rtl8192_rtx_disable(dev);
4183 //rtl8192_irq_disable(dev);
4185 /* Tx related queue release */
4186 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4187 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
4189 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4190 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
4193 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4194 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ [i]);
4197 //as cancel_delayed_work will del work->timer, so if work is not defined as struct delayed_work, it will corrupt
4198 // flush_scheduled_work();
4199 rtl8192_cancel_deferred_work(priv);
4201 del_timer_sync(&priv->watch_dog_timer);
4204 ieee80211_softmac_stop_protocol(priv->ieee80211);
4205 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4206 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4212 void rtl8192_commit(struct net_device *dev)
4214 struct r8192_priv *priv = ieee80211_priv(dev);
4215 int reset_status = 0;
4216 //u8 reset_times = 0;
4217 if (priv->up == 0) return ;
4220 rtl8192_cancel_deferred_work(priv);
4221 del_timer_sync(&priv->watch_dog_timer);
4222 //cancel_delayed_work(&priv->SwChnlWorkItem);
4224 ieee80211_softmac_stop_protocol(priv->ieee80211);
4226 //rtl8192_irq_disable(dev);
4227 rtl8192_rtx_disable(dev);
4228 reset_status = _rtl8192_up(dev);
4233 void rtl8192_restart(struct net_device *dev)
4235 struct r8192_priv *priv = ieee80211_priv(dev);
4237 void rtl8192_restart(struct work_struct *work)
4239 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4240 struct net_device *dev = priv->ieee80211->dev;
4242 down(&priv->wx_sem);
4244 rtl8192_commit(dev);
4249 static void r8192_set_multicast(struct net_device *dev)
4251 struct r8192_priv *priv = ieee80211_priv(dev);
4254 //down(&priv->wx_sem);
4258 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4260 if (promisc != priv->promisc)
4261 // rtl8192_commit(dev);
4263 priv->promisc = promisc;
4265 //schedule_work(&priv->reset_wq);
4266 //up(&priv->wx_sem);
4270 int r8192_set_mac_adr(struct net_device *dev, void *mac)
4272 struct r8192_priv *priv = ieee80211_priv(dev);
4273 struct sockaddr *addr = mac;
4275 down(&priv->wx_sem);
4277 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4279 schedule_work(&priv->reset_wq);
4285 /* based on ipw2200 driver */
4286 int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4288 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4289 struct iwreq *wrq = (struct iwreq *)rq;
4291 struct ieee80211_device *ieee = priv->ieee80211;
4293 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4294 struct iw_point *p = &wrq->u.data;
4295 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
4297 down(&priv->wx_sem);
4300 if (p->length < sizeof(struct ieee_param) || !p->pointer){
4305 ipw = kmalloc(p->length, GFP_KERNEL);
4310 if (copy_from_user(ipw, p->pointer, p->length)) {
4317 case RTL_IOCTL_WPA_SUPPLICANT:
4318 //parse here for HW security
4319 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
4321 if (ipw->u.crypt.set_tx)
4323 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4324 ieee->pairwise_key_type = KEY_TYPE_CCMP;
4325 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4326 ieee->pairwise_key_type = KEY_TYPE_TKIP;
4327 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4329 if (ipw->u.crypt.key_len == 13)
4330 ieee->pairwise_key_type = KEY_TYPE_WEP104;
4331 else if (ipw->u.crypt.key_len == 5)
4332 ieee->pairwise_key_type = KEY_TYPE_WEP40;
4335 ieee->pairwise_key_type = KEY_TYPE_NA;
4337 if (ieee->pairwise_key_type)
4339 memcpy((u8*)key, ipw->u.crypt.key, 16);
4340 EnableHWSecurityConfig8192(dev);
4341 //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!
4343 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4344 if (ieee->auth_mode != 2)
4345 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4348 else //if (ipw->u.crypt.idx) //group key use idx > 0
4350 memcpy((u8*)key, ipw->u.crypt.key, 16);
4351 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4352 ieee->group_key_type= KEY_TYPE_CCMP;
4353 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4354 ieee->group_key_type = KEY_TYPE_TKIP;
4355 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4357 if (ipw->u.crypt.key_len == 13)
4358 ieee->group_key_type = KEY_TYPE_WEP104;
4359 else if (ipw->u.crypt.key_len == 5)
4360 ieee->group_key_type = KEY_TYPE_WEP40;
4363 ieee->group_key_type = KEY_TYPE_NA;
4365 if (ieee->group_key_type)
4369 ipw->u.crypt.idx, //KeyIndex
4370 ieee->group_key_type, //KeyType
4371 broadcast_addr, //MacAddr
4377 #ifdef JOHN_HWSEC_DEBUG
4379 printk("@@ wrq->u pointer = ");
4380 for(i=0;i<wrq->u.data.length;i++){
4381 if(i%10==0) printk("\n");
4382 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
4385 #endif /*JOHN_HWSEC_DEBUG*/
4386 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
4400 u8 HwRateToMRate90(bool bIsHT, u8 rate)
4406 case DESC90_RATE1M: ret_rate = MGN_1M; break;
4407 case DESC90_RATE2M: ret_rate = MGN_2M; break;
4408 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
4409 case DESC90_RATE11M: ret_rate = MGN_11M; break;
4410 case DESC90_RATE6M: ret_rate = MGN_6M; break;
4411 case DESC90_RATE9M: ret_rate = MGN_9M; break;
4412 case DESC90_RATE12M: ret_rate = MGN_12M; break;
4413 case DESC90_RATE18M: ret_rate = MGN_18M; break;
4414 case DESC90_RATE24M: ret_rate = MGN_24M; break;
4415 case DESC90_RATE36M: ret_rate = MGN_36M; break;
4416 case DESC90_RATE48M: ret_rate = MGN_48M; break;
4417 case DESC90_RATE54M: ret_rate = MGN_54M; break;
4421 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
4427 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
4428 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
4429 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
4430 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
4431 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
4432 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
4433 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
4434 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
4435 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
4436 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
4437 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
4438 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
4439 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
4440 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
4441 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
4442 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
4443 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
4447 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
4456 * Function: UpdateRxPktTimeStamp
4457 * Overview: Record the TSF time stamp when receiving a packet
4465 * (pRfd->Status.TimeStampHigh is updated)
4466 * (pRfd->Status.TimeStampLow is updated)
4470 void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
4472 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4474 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
4475 stats->mac_time[0] = priv->LastRxDescTSFLow;
4476 stats->mac_time[1] = priv->LastRxDescTSFHigh;
4478 priv->LastRxDescTSFLow = stats->mac_time[0];
4479 priv->LastRxDescTSFHigh = stats->mac_time[1];
4485 long rtl819x_translate_todbm(u8 signal_strength_index )// 0-100 index.
4487 long signal_power; // in dBm.
4489 // Translate to dBm (x=0.5y-95).
4490 signal_power = (long)((signal_strength_index + 1) >> 1);
4493 return signal_power;
4497 /* 2008/01/22 MH We can not declare RSSI/EVM total value of sliding window to
4498 be a local static. Otherwise, it may increase when we return from S3/S4. The
4499 value will be kept in memory or disk. Declare the value in the adaptor
4500 and it will be reinitialized when returned from S3/S4. */
4501 void rtl8192_process_phyinfo(struct r8192_priv * priv,u8* buffer, struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
4503 bool bcheck = false;
4505 u32 nspatial_stream, tmp_val;
4507 static u32 slide_rssi_index, slide_rssi_statistics;
4508 static u32 slide_evm_index, slide_evm_statistics;
4509 static u32 last_rssi, last_evm;
4511 static u32 slide_beacon_adc_pwdb_index, slide_beacon_adc_pwdb_statistics;
4512 static u32 last_beacon_adc_pwdb;
4514 struct ieee80211_hdr_3addr *hdr;
4516 unsigned int frag,seq;
4517 hdr = (struct ieee80211_hdr_3addr *)buffer;
4518 sc = le16_to_cpu(hdr->seq_ctl);
4519 frag = WLAN_GET_SEQ_FRAG(sc);
4520 seq = WLAN_GET_SEQ_SEQ(sc);
4521 //cosa add 04292008 to record the sequence number
4522 pcurrent_stats->Seq_Num = seq;
4524 // Check whether we should take the previous packet into accounting
4526 if(!pprevious_stats->bIsAMPDU)
4528 // if previous packet is not aggregated packet
4532 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
4534 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
4535 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
4536 priv->stats.slide_rssi_total -= last_rssi;
4538 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
4540 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
4541 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
4542 slide_rssi_index = 0;
4544 // <1> Showed on UI for user, in dbm
4545 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
4546 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
4547 pcurrent_stats->rssi = priv->stats.signal_strength;
4549 // If the previous packet does not match the criteria, neglect it
4551 if(!pprevious_stats->bPacketMatchBSSID)
4553 if(!pprevious_stats->bToSelfBA)
4561 //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
4566 priv->stats.num_process_phyinfo++;
4568 /* record the general signal strength to the sliding window. */
4571 // <2> Showed on UI for engineering
4572 // hardware does not provide rssi information for each rf path in CCK
4573 if(!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA))
4575 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++)
4577 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
4580 //Fixed by Jacken 2008-03-20
4581 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
4583 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
4584 //DbgPrint("MIMO RSSI initialize \n");
4586 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
4588 priv->stats.rx_rssi_percentage[rfpath] =
4589 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4590 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4591 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
4595 priv->stats.rx_rssi_percentage[rfpath] =
4596 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4597 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4599 RT_TRACE(COMP_DBG,"priv->stats.rx_rssi_percentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
4607 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4608 pprevious_stats->bIsCCK? "CCK": "OFDM",
4609 pprevious_stats->RxPWDBAll);
4611 if(pprevious_stats->bPacketBeacon)
4613 /* record the beacon pwdb to the sliding window. */
4614 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4616 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
4617 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
4618 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
4619 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
4620 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
4622 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
4623 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
4624 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
4625 slide_beacon_adc_pwdb_index++;
4626 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4627 slide_beacon_adc_pwdb_index = 0;
4628 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
4629 if(pprevious_stats->RxPWDBAll >= 3)
4630 pprevious_stats->RxPWDBAll -= 3;
4633 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4634 pprevious_stats->bIsCCK? "CCK": "OFDM",
4635 pprevious_stats->RxPWDBAll);
4638 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4640 if(priv->undecorated_smoothed_pwdb < 0) // initialize
4642 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
4643 //DbgPrint("First pwdb initialize \n");
4645 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
4647 priv->undecorated_smoothed_pwdb =
4648 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4649 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4650 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
4654 priv->undecorated_smoothed_pwdb =
4655 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4656 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4664 /* record the general EVM to the sliding window. */
4665 if(pprevious_stats->SignalQuality == 0)
4670 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
4671 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
4672 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
4673 last_evm = priv->stats.slide_evm[slide_evm_index];
4674 priv->stats.slide_evm_total -= last_evm;
4677 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
4679 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
4680 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
4681 slide_evm_index = 0;
4683 // <1> Showed on UI for user, in percentage.
4684 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
4685 priv->stats.signal_quality = tmp_val;
4686 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
4687 priv->stats.last_signal_strength_inpercent = tmp_val;
4690 // <2> Showed on UI for engineering
4691 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4693 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
4695 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
4697 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
4699 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
4701 priv->stats.rx_evm_percentage[nspatial_stream] =
4702 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
4703 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
4712 /*-----------------------------------------------------------------------------
4713 * Function: rtl819x_query_rxpwrpercentage()
4717 * Input: char antpower
4721 * Return: 0-100 percentage
4725 * 05/26/2008 amy Create Version 0 porting from windows code.
4727 *---------------------------------------------------------------------------*/
4728 static u8 rtl819x_query_rxpwrpercentage(
4732 if ((antpower <= -100) || (antpower >= 20))
4736 else if (antpower >= 0)
4742 return (100+antpower);
4745 } /* QueryRxPwrPercentage */
4748 rtl819x_evm_dbtopercentage(
4760 ret_val = 0 - ret_val;
4768 // We want good-looking for signal strength/quality
4769 // 2007/7/19 01:09, by cosa.
4772 rtl819x_signal_scale_mapping(
4778 // Step 1. Scale mapping.
4779 if(currsig >= 61 && currsig <= 100)
4781 retsig = 90 + ((currsig - 60) / 4);
4783 else if(currsig >= 41 && currsig <= 60)
4785 retsig = 78 + ((currsig - 40) / 2);
4787 else if(currsig >= 31 && currsig <= 40)
4789 retsig = 66 + (currsig - 30);
4791 else if(currsig >= 21 && currsig <= 30)
4793 retsig = 54 + (currsig - 20);
4795 else if(currsig >= 5 && currsig <= 20)
4797 retsig = 42 + (((currsig - 5) * 2) / 3);
4799 else if(currsig == 4)
4803 else if(currsig == 3)
4807 else if(currsig == 2)
4811 else if(currsig == 1)
4823 static void rtl8192_query_rxphystatus(
4824 struct r8192_priv * priv,
4825 struct ieee80211_rx_stats * pstats,
4826 rx_drvinfo_819x_usb * pdrvinfo,
4827 struct ieee80211_rx_stats * precord_stats,
4828 bool bpacket_match_bssid,
4829 bool bpacket_toself,
4834 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
4835 phy_sts_ofdm_819xusb_t* pofdm_buf;
4836 phy_sts_cck_819xusb_t * pcck_buf;
4837 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
4839 u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
4840 char rx_pwr[4], rx_pwr_all=0;
4841 //long rx_avg_pwr = 0;
4842 char rx_snrX, rx_evmX;
4844 u32 RSSI, total_rssi=0;//, total_evm=0;
4845 // long signal_strength_index = 0;
4850 priv->stats.numqry_phystatus++;
4852 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
4854 // Record it for next packet processing
4855 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
4856 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
4857 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
4858 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
4859 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
4860 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
4862 prxpkt = (u8*)pdrvinfo;
4864 /* Move pointer to the 16th bytes. Phy status start address. */
4865 prxpkt += sizeof(rx_drvinfo_819x_usb);
4867 /* Initial the cck and ofdm buffer pointer */
4868 pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
4869 pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
4871 pstats->RxMIMOSignalQuality[0] = -1;
4872 pstats->RxMIMOSignalQuality[1] = -1;
4873 precord_stats->RxMIMOSignalQuality[0] = -1;
4874 precord_stats->RxMIMOSignalQuality[1] = -1;
4879 // (1)Hardware does not provide RSSI for CCK
4883 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4885 u8 report;//, cck_agc_rpt;
4887 priv->stats.numqry_phystatusCCK++;
4889 if(!priv->bCckHighPower)
4891 report = pcck_buf->cck_agc_rpt & 0xc0;
4895 //Fixed by Jacken from Bryant 2008-03-20
4896 //Original value is -38 , -26 , -14 , -2
4897 //Fixed value is -35 , -23 , -11 , 6
4899 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
4902 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
4905 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
4908 rx_pwr_all = 6 - (pcck_buf->cck_agc_rpt & 0x3e);
4914 report = pcck_buf->cck_agc_rpt & 0x60;
4919 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
4922 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
4925 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
4928 rx_pwr_all = 6 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
4933 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
4934 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
4935 pstats->RecvSignalPower = pwdb_all;
4938 // (3) Get Signal Quality (EVM)
4940 //if(bpacket_match_bssid)
4944 if(pstats->RxPWDBAll > 40)
4949 sq = pcck_buf->sq_rpt;
4951 if(pcck_buf->sq_rpt > 64)
4953 else if (pcck_buf->sq_rpt < 20)
4956 sq = ((64-sq) * 100) / 44;
4958 pstats->SignalQuality = precord_stats->SignalQuality = sq;
4959 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
4960 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
4965 priv->stats.numqry_phystatusHT++;
4967 // (1)Get RSSI for HT rate
4969 for(i=RF90_PATH_A; i<priv->NumTotalRFPath; i++)
4971 // 2008/01/30 MH we will judge RF RX path now.
4972 if (priv->brfpath_rxenable[i])
4977 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
4980 //Fixed by Jacken from Bryant 2008-03-20
4981 //Original value is 106
4982 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
4984 //Get Rx snr value in DB
4985 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
4986 rx_snrX = (char)(tmp_rxsnr);
4989 priv->stats.rxSNRdB[i] = (long)rx_snrX;
4991 /* Translate DBM to percentage. */
4992 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
4995 /* Record Signal Strength for next packet */
4996 //if(bpacket_match_bssid)
4998 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
4999 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5005 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5007 //Fixed by Jacken from Bryant 2008-03-20
5008 //Original value is 106
5009 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5010 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5012 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5013 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5016 // (3)EVM of HT rate
5018 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5019 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5020 max_spatial_stream = 2; //both spatial stream make sense
5022 max_spatial_stream = 1; //only spatial stream 1 makes sense
5024 for(i=0; i<max_spatial_stream; i++)
5026 tmp_rxevm = pofdm_buf->rxevm_X[i];
5027 rx_evmX = (char)(tmp_rxevm);
5029 // Do not use shift operation like "rx_evmX >>= 1" because the compiler of free build environment
5030 // will set the most significant bit to "zero" when doing shifting operation which may change a negative
5031 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5034 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5035 //if(bpacket_match_bssid)
5037 if(i==0) // Fill value in RFD, Get the first spatial stream only
5038 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5039 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5044 /* record rx statistics for debug */
5045 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5046 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5047 if(pdrvinfo->BW) //40M channel
5048 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5050 priv->stats.received_bwtype[0]++;
5053 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5054 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5057 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5062 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u8)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u8)(total_rssi/=RF90_PATH_MAX);
5063 // We can judge RX path number now.
5065 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5067 } /* QueryRxPhyStatus8190Pci */
5070 rtl8192_record_rxdesc_forlateruse(
5071 struct ieee80211_rx_stats * psrc_stats,
5072 struct ieee80211_rx_stats * ptarget_stats
5075 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5076 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5077 ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5081 void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
5082 struct ieee80211_rx_stats * pstats,
5083 rx_drvinfo_819x_usb *pdrvinfo)
5085 // TODO: We must only check packet for current MAC address. Not finish
5086 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5087 struct net_device *dev=info->dev;
5088 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5089 bool bpacket_match_bssid, bpacket_toself;
5090 bool bPacketBeacon=FALSE, bToSelfBA=FALSE;
5091 static struct ieee80211_rx_stats previous_stats;
5092 struct ieee80211_hdr_3addr *hdr;//by amy
5095 // Get Signal Quality for only RX data queue (but not command queue)
5098 //u16 tmp_buf_len = 0;
5101 /* Get MAC frame start address. */
5102 tmp_buf = (u8*)skb->data;// + get_rxpacket_shiftbytes_819xusb(pstats);
5104 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5105 fc = le16_to_cpu(hdr->frame_ctl);
5106 type = WLAN_FC_GET_TYPE(fc);
5107 praddr = hdr->addr1;
5109 /* Check if the received packet is acceptable. */
5110 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5111 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5112 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5113 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5115 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5117 bPacketBeacon = true;
5118 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5120 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5122 if((eqMacAddr(praddr,dev->dev_addr)))
5124 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5129 if(bpacket_match_bssid)
5131 priv->stats.numpacket_matchbssid++;
5134 priv->stats.numpacket_toself++;
5137 // Process PHY information for previous packet (RSSI/PWDB/EVM)
5139 // Because phy information is contained in the last packet of AMPDU only, so driver
5140 // should process phy information of previous packet
5141 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
5142 rtl8192_query_rxphystatus(priv, pstats, pdrvinfo, &previous_stats, bpacket_match_bssid,bpacket_toself,bPacketBeacon,bToSelfBA);
5143 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
5148 * Function: UpdateReceivedRateHistogramStatistics
5149 * Overview: Record the received data rate
5152 * struct net_device *dev
5153 * struct ieee80211_rx_stats *stats
5157 * (priv->stats.ReceivedRateHistogram[] is updated)
5162 UpdateReceivedRateHistogramStatistics8190(
5163 struct net_device *dev,
5164 struct ieee80211_rx_stats *stats
5167 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5168 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
5170 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
5175 else if(stats->bICV)
5178 if(stats->bShortPreamble)
5179 preamble_guardinterval = 1;// short
5181 preamble_guardinterval = 0;// long
5188 case MGN_1M: rateIndex = 0; break;
5189 case MGN_2M: rateIndex = 1; break;
5190 case MGN_5_5M: rateIndex = 2; break;
5191 case MGN_11M: rateIndex = 3; break;
5195 case MGN_6M: rateIndex = 4; break;
5196 case MGN_9M: rateIndex = 5; break;
5197 case MGN_12M: rateIndex = 6; break;
5198 case MGN_18M: rateIndex = 7; break;
5199 case MGN_24M: rateIndex = 8; break;
5200 case MGN_36M: rateIndex = 9; break;
5201 case MGN_48M: rateIndex = 10; break;
5202 case MGN_54M: rateIndex = 11; break;
5204 // 11n High throughput rate
5206 case MGN_MCS0: rateIndex = 12; break;
5207 case MGN_MCS1: rateIndex = 13; break;
5208 case MGN_MCS2: rateIndex = 14; break;
5209 case MGN_MCS3: rateIndex = 15; break;
5210 case MGN_MCS4: rateIndex = 16; break;
5211 case MGN_MCS5: rateIndex = 17; break;
5212 case MGN_MCS6: rateIndex = 18; break;
5213 case MGN_MCS7: rateIndex = 19; break;
5214 case MGN_MCS8: rateIndex = 20; break;
5215 case MGN_MCS9: rateIndex = 21; break;
5216 case MGN_MCS10: rateIndex = 22; break;
5217 case MGN_MCS11: rateIndex = 23; break;
5218 case MGN_MCS12: rateIndex = 24; break;
5219 case MGN_MCS13: rateIndex = 25; break;
5220 case MGN_MCS14: rateIndex = 26; break;
5221 case MGN_MCS15: rateIndex = 27; break;
5222 default: rateIndex = 28; break;
5224 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
5225 priv->stats.received_rate_histogram[0][rateIndex]++; //total
5226 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
5230 void query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe)
5232 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5233 struct net_device *dev=info->dev;
5234 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5235 //rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5236 rx_drvinfo_819x_usb *driver_info = NULL;
5239 //Get Rx Descriptor Information
5241 #ifdef USB_RX_AGGREGATION_SUPPORT
5242 if (bIsRxAggrSubframe)
5244 rx_desc_819x_usb_aggr_subframe *desc = (rx_desc_819x_usb_aggr_subframe *)skb->data;
5245 stats->Length = desc->Length ;
5246 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5247 stats->RxBufShift = 0; //RxBufShift = 2 in RxDesc, but usb didn't shift bytes in fact.
5248 stats->bICV = desc->ICV;
5249 stats->bCRC = desc->CRC32;
5250 stats->bHwError = stats->bCRC|stats->bICV;
5251 stats->Decrypted = !desc->SWDec;//RTL8190 set this bit to indicate that Hw does not decrypt packet
5255 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5257 stats->Length = desc->Length;
5258 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5259 stats->RxBufShift = 0;//desc->Shift&0x03;
5260 stats->bICV = desc->ICV;
5261 stats->bCRC = desc->CRC32;
5262 stats->bHwError = stats->bCRC|stats->bICV;
5263 //RTL8190 set this bit to indicate that Hw does not decrypt packet
5264 stats->Decrypted = !desc->SWDec;
5267 if((priv->ieee80211->pHTInfo->bCurrentHTSupport == true) && (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP))
5269 stats->bHwError = false;
5273 stats->bHwError = stats->bCRC|stats->bICV;
5276 if(stats->Length < 24 || stats->Length > MAX_8192U_RX_SIZE)
5277 stats->bHwError |= 1;
5281 // TODO: Need to verify it on FGPA platform
5282 //Driver info are written to the RxBuffer following rx desc
5283 if (stats->RxDrvInfoSize != 0) {
5284 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) + \
5288 if(!stats->bHwError){
5290 ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
5291 if(ret_rate == 0xff)
5293 // Abnormal Case: Receive CRC OK packet with Rx descriptor indicating non supported rate.
5294 // Special Error Handling here, 2008.05.16, by Emily
5296 stats->bHwError = 1;
5297 stats->rate = MGN_1M; //Set 1M rate by default
5300 stats->rate = ret_rate;
5306 stats->bShortPreamble = driver_info->SPLCP;
5309 UpdateReceivedRateHistogramStatistics8190(dev, stats);
5311 stats->bIsAMPDU = (driver_info->PartAggr==1);
5312 stats->bFirstMPDU = (driver_info->PartAggr==1) && (driver_info->FirstAGGR==1);
5313 stats->TimeStampLow = driver_info->TSFL;
5314 // xiong mask it, 070514
5315 //pRfd->Status.TimeStampHigh = PlatformEFIORead4Byte(Adapter, TSFR+4);
5316 // stats->TimeStampHigh = read_nic_dword(dev, TSFR+4);
5318 UpdateRxPktTimeStamp8190(dev, stats);
5323 if(driver_info->FirstAGGR==1 || driver_info->PartAggr == 1)
5324 RT_TRACE(COMP_RXDESC, "driver_info->FirstAGGR = %d, driver_info->PartAggr = %d\n",
5325 driver_info->FirstAGGR, driver_info->PartAggr);
5329 skb_pull(skb,sizeof(rx_desc_819x_usb));
5331 // Get Total offset of MPDU Frame Body
5333 if((stats->RxBufShift + stats->RxDrvInfoSize) > 0) {
5335 skb_pull(skb,stats->RxBufShift + stats->RxDrvInfoSize);
5338 #ifdef USB_RX_AGGREGATION_SUPPORT
5339 /* for the rx aggregated sub frame, the redundant space truly contained in the packet */
5340 if(bIsRxAggrSubframe) {
5344 /* for debug 2008.5.29 */
5346 //added by vivi, for MP, 20080108
5347 stats->RxIs40MHzPacket = driver_info->BW;
5348 if(stats->RxDrvInfoSize != 0)
5349 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
5353 u32 GetRxPacketShiftBytes819xUsb(struct ieee80211_rx_stats *Status, bool bIsRxAggrSubframe)
5355 #ifdef USB_RX_AGGREGATION_SUPPORT
5356 if (bIsRxAggrSubframe)
5357 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5358 + Status->RxBufShift + 8);
5361 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5362 + Status->RxBufShift);
5365 void rtl8192_rx_nomal(struct sk_buff* skb)
5367 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5368 struct net_device *dev=info->dev;
5369 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5370 struct ieee80211_rx_stats stats = {
5374 // .mac_time = jiffies,
5375 .freq = IEEE80211_24GHZ_BAND,
5378 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
5379 bool unicast_packet = false;
5380 #ifdef USB_RX_AGGREGATION_SUPPORT
5381 struct sk_buff *agg_skb = NULL;
5382 u32 TotalLength = 0;
5384 u32 PacketLength = 0;
5385 u32 PacketOccupiedLendth = 0;
5387 u32 PacketShiftBytes = 0;
5388 rx_desc_819x_usb_aggr_subframe *RxDescr = NULL;
5389 u8 PaddingBytes = 0;
5390 //add just for testing
5395 /* 20 is for ps-poll */
5396 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
5397 #ifdef USB_RX_AGGREGATION_SUPPORT
5398 TempByte = *(skb->data + sizeof(rx_desc_819x_usb));
5400 /* first packet should not contain Rx aggregation header */
5401 query_rxdesc_status(skb, &stats, false);
5403 /* hardware related info */
5404 #ifdef USB_RX_AGGREGATION_SUPPORT
5405 if (TempByte & BIT0) {
5407 //TotalLength = agg_skb->len - 4; /*sCrcLng*/
5408 TotalLength = stats.Length - 4; /*sCrcLng*/
5409 //RT_TRACE(COMP_RECV, "%s:first aggregated packet!Length=%d\n",__FUNCTION__,TotalLength);
5410 /* though the head pointer has passed this position */
5411 TempDWord = *(u32 *)(agg_skb->data - 4);
5412 PacketLength = (u16)(TempDWord & 0x3FFF); /*sCrcLng*/
5413 skb = dev_alloc_skb(PacketLength);
5414 memcpy(skb_put(skb,PacketLength),agg_skb->data,PacketLength);
5415 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, false);
5418 /* Process the MPDU received */
5419 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5421 rx_pkt_len = skb->len;
5422 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5423 unicast_packet = false;
5424 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5426 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5429 /* unicast packet */
5430 unicast_packet = true;
5433 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5434 dev_kfree_skb_any(skb);
5436 priv->stats.rxoktotal++;
5437 if(unicast_packet) {
5438 priv->stats.rxbytesunicast += rx_pkt_len;
5441 #ifdef USB_RX_AGGREGATION_SUPPORT
5443 // (PipeIndex == 0) && (TempByte & BIT0) => TotalLength > 0.
5444 if (TotalLength > 0) {
5445 PacketOccupiedLendth = PacketLength + (PacketShiftBytes + 8);
5446 if ((PacketOccupiedLendth & 0xFF) != 0)
5447 PacketOccupiedLendth = (PacketOccupiedLendth & 0xFFFFFF00) + 256;
5448 PacketOccupiedLendth -= 8;
5449 TempDWord = PacketOccupiedLendth - PacketShiftBytes; /*- PacketLength */
5450 if (agg_skb->len > TempDWord)
5451 skb_pull(agg_skb, TempDWord);
5455 while (agg_skb->len>=GetRxPacketShiftBytes819xUsb(&stats, true)) {
5456 u8 tmpCRC = 0, tmpICV = 0;
5457 //RT_TRACE(COMP_RECV,"%s:aggred pkt,total_len = %d\n",__FUNCTION__,agg_skb->len);
5458 RxDescr = (rx_desc_819x_usb_aggr_subframe *)(agg_skb->data);
5459 tmpCRC = RxDescr->CRC32;
5460 tmpICV = RxDescr->ICV;
5461 memcpy(agg_skb->data, &agg_skb->data[44], 2);
5462 RxDescr->CRC32 = tmpCRC;
5463 RxDescr->ICV = tmpICV;
5465 memset(&stats, 0, sizeof(struct ieee80211_rx_stats));
5469 stats.freq = IEEE80211_24GHZ_BAND;
5470 query_rxdesc_status(agg_skb, &stats, true);
5471 PacketLength = stats.Length;
5473 if(PacketLength > agg_skb->len) {
5476 /* Process the MPDU received */
5477 skb = dev_alloc_skb(PacketLength);
5478 memcpy(skb_put(skb,PacketLength),agg_skb->data, PacketLength);
5479 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5481 rx_pkt_len = skb->len;
5482 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5483 unicast_packet = false;
5484 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5486 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5489 /* unicast packet */
5490 unicast_packet = true;
5492 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5493 dev_kfree_skb_any(skb);
5495 priv->stats.rxoktotal++;
5496 if(unicast_packet) {
5497 priv->stats.rxbytesunicast += rx_pkt_len;
5500 /* should trim the packet which has been copied to target skb */
5501 skb_pull(agg_skb, PacketLength);
5502 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, true);
5503 PacketOccupiedLendth = PacketLength + PacketShiftBytes;
5504 if ((PacketOccupiedLendth & 0xFF) != 0) {
5505 PaddingBytes = 256 - (PacketOccupiedLendth & 0xFF);
5506 if (agg_skb->len > PaddingBytes)
5507 skb_pull(agg_skb, PaddingBytes);
5512 dev_kfree_skb(agg_skb);
5516 priv->stats.rxurberr++;
5517 printk("actual_length:%d\n", skb->len);
5518 dev_kfree_skb_any(skb);
5524 rtl819xusb_process_received_packet(
5525 struct net_device *dev,
5526 struct ieee80211_rx_stats *pstats
5529 // bool bfreerfd=false, bqueued=false;
5532 struct r8192_priv *priv = ieee80211_priv(dev);
5536 //PRX_TS_RECORD pts = NULL;
5538 // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
5539 //porting by amy 080508
5540 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
5541 frame = pstats->virtual_address;
5542 frame_len = pstats->packetlength;
5543 #ifdef TODO // by amy about HCT
5544 if(!Adapter->bInHctTest)
5545 CountRxErrStatistics(Adapter, pRfd);
5548 #ifdef ENABLE_PS //by amy for adding ps function in future
5549 RT_RF_POWER_STATE rtState;
5550 // When RF is off, we should not count the packet for hw/sw synchronize
5551 // reason, ie. there may be a duration while sw switch is changed and hw
5552 // switch is being changed. 2006.12.04, by shien chang.
5553 Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8* )(&rtState));
5554 if (rtState == eRfOff)
5559 priv->stats.rxframgment++;
5563 RmMonitorSignalStrength(Adapter, pRfd);
5565 /* 2007/01/16 MH Add RX command packet handle here. */
5566 /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
5567 if (rtl819xusb_rx_command_packet(dev, pstats))
5579 void query_rx_cmdpkt_desc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats)
5581 // rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5582 // struct net_device *dev=info->dev;
5583 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5584 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5585 // rx_drvinfo_819x_usb *driver_info;
5588 //Get Rx Descriptor Information
5590 stats->virtual_address = (u8*)skb->data;
5591 stats->Length = desc->Length;
5592 stats->RxDrvInfoSize = 0;
5593 stats->RxBufShift = 0;
5594 stats->packetlength = stats->Length-scrclng;
5595 stats->fraglength = stats->packetlength;
5596 stats->fragoffset = 0;
5597 stats->ntotalfrag = 1;
5601 void rtl8192_rx_cmd(struct sk_buff *skb)
5603 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5604 struct net_device *dev = info->dev;
5606 // struct urb *rx_urb = info->urb;
5608 struct ieee80211_rx_stats stats = {
5612 // .mac_time = jiffies,
5613 .freq = IEEE80211_24GHZ_BAND,
5616 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE))
5619 query_rx_cmdpkt_desc_status(skb,&stats);
5620 // this is to be done by amy 080508 prfd->queue_id = 1;
5624 // Process the command packet received.
5627 rtl819xusb_process_received_packet(dev,&stats);
5629 dev_kfree_skb_any(skb);
5633 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
5635 struct sk_buff *skb;
5636 struct rtl8192_rx_info *info;
5638 while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
5639 info = (struct rtl8192_rx_info *)skb->cb;
5640 switch (info->out_pipe) {
5641 /* Nomal packet pipe */
5643 //RT_TRACE(COMP_RECV, "normal in-pipe index(%d)\n",info->out_pipe);
5644 priv->IrpPendingCount--;
5645 rtl8192_rx_nomal(skb);
5648 /* Command packet pipe */
5650 RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",\
5653 rtl8192_rx_cmd(skb);
5656 default: /* should never get here! */
5657 RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",\
5666 static const struct net_device_ops rtl8192_netdev_ops = {
5667 .ndo_open = rtl8192_open,
5668 .ndo_stop = rtl8192_close,
5669 .ndo_get_stats = rtl8192_stats,
5670 .ndo_tx_timeout = tx_timeout,
5671 .ndo_do_ioctl = rtl8192_ioctl,
5672 .ndo_set_rx_mode = r8192_set_multicast,
5673 .ndo_set_mac_address = r8192_set_mac_adr,
5674 .ndo_validate_addr = eth_validate_addr,
5675 .ndo_change_mtu = eth_change_mtu,
5676 .ndo_start_xmit = ieee80211_xmit,
5680 /****************************************************************************
5681 ---------------------------- USB_STUFF---------------------------
5682 *****************************************************************************/
5684 static int rtl8192_usb_probe(struct usb_interface *intf,
5685 const struct usb_device_id *id)
5687 // unsigned long ioaddr = 0;
5688 struct net_device *dev = NULL;
5689 struct r8192_priv *priv= NULL;
5690 struct usb_device *udev = interface_to_usbdev(intf);
5692 RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
5694 dev = alloc_ieee80211(sizeof(struct r8192_priv));
5698 usb_set_intfdata(intf, dev);
5699 SET_NETDEV_DEV(dev, &intf->dev);
5700 priv = ieee80211_priv(dev);
5701 priv->ieee80211 = netdev_priv(dev);
5704 dev->netdev_ops = &rtl8192_netdev_ops;
5706 //DMESG("Oops: i'm coming\n");
5707 #if WIRELESS_EXT >= 12
5708 #if WIRELESS_EXT < 17
5709 dev->get_wireless_stats = r8192_get_wireless_stats;
5711 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
5713 dev->type=ARPHRD_ETHER;
5715 dev->watchdog_timeo = HZ*3; //modified by john, 0805
5717 if (dev_alloc_name(dev, ifname) < 0){
5718 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
5720 dev_alloc_name(dev, ifname);
5723 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
5724 if(rtl8192_init(dev)!=0){
5725 RT_TRACE(COMP_ERR, "Initialization failed");
5729 netif_carrier_off(dev);
5730 netif_stop_queue(dev);
5732 ret = register_netdev(dev);
5736 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
5737 rtl8192_proc_init_one(dev);
5740 RT_TRACE(COMP_INIT, "Driver probe completed\n");
5745 kfree(priv->pFirmware);
5746 priv->pFirmware = NULL;
5747 rtl8192_usb_deleteendpoints(dev);
5748 destroy_workqueue(priv->priv_wq);
5751 free_ieee80211(dev);
5753 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
5757 //detach all the work and timer structure declared or inititialize in r8192U_init function.
5758 void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
5761 cancel_work_sync(&priv->reset_wq);
5762 cancel_delayed_work(&priv->watch_dog_wq);
5763 cancel_delayed_work(&priv->update_beacon_wq);
5764 cancel_work_sync(&priv->qos_activate);
5765 //cancel_work_sync(&priv->SetBWModeWorkItem);
5766 //cancel_work_sync(&priv->SwChnlWorkItem);
5771 static void rtl8192_usb_disconnect(struct usb_interface *intf)
5773 struct net_device *dev = usb_get_intfdata(intf);
5775 struct r8192_priv *priv = ieee80211_priv(dev);
5778 unregister_netdev(dev);
5780 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
5781 rtl8192_proc_remove_one(dev);
5784 kfree(priv->pFirmware);
5785 priv->pFirmware = NULL;
5786 // priv->rf_close(dev);
5787 // rtl8192_SetRFPowerState(dev, eRfOff);
5788 rtl8192_usb_deleteendpoints(dev);
5789 destroy_workqueue(priv->priv_wq);
5790 //rtl8192_irq_disable(dev);
5791 //rtl8192_reset(dev);
5795 free_ieee80211(dev);
5796 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
5799 /* fun with the built-in ieee80211 stack... */
5800 extern int ieee80211_debug_init(void);
5801 extern void ieee80211_debug_exit(void);
5802 extern int ieee80211_crypto_init(void);
5803 extern void ieee80211_crypto_deinit(void);
5804 extern int ieee80211_crypto_tkip_init(void);
5805 extern void ieee80211_crypto_tkip_exit(void);
5806 extern int ieee80211_crypto_ccmp_init(void);
5807 extern void ieee80211_crypto_ccmp_exit(void);
5808 extern int ieee80211_crypto_wep_init(void);
5809 extern void ieee80211_crypto_wep_exit(void);
5811 static int __init rtl8192_usb_module_init(void)
5815 #ifdef CONFIG_IEEE80211_DEBUG
5816 ret = ieee80211_debug_init();
5818 printk(KERN_ERR "ieee80211_debug_init() failed %d\n", ret);
5822 ret = ieee80211_crypto_init();
5824 printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
5828 ret = ieee80211_crypto_tkip_init();
5830 printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n",
5835 ret = ieee80211_crypto_ccmp_init();
5837 printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n",
5842 ret = ieee80211_crypto_wep_init();
5844 printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
5848 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
5849 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
5850 RT_TRACE(COMP_INIT, "Initializing module");
5851 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
5852 rtl8192_proc_module_init();
5853 return usb_register(&rtl8192_usb_driver);
5857 static void __exit rtl8192_usb_module_exit(void)
5859 usb_deregister(&rtl8192_usb_driver);
5861 RT_TRACE(COMP_DOWN, "Exiting");
5862 // rtl8192_proc_module_remove();
5866 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
5868 unsigned long flags;
5870 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5872 spin_lock_irqsave(&priv->tx_lock,flags);
5873 enough_desc = check_nic_enough_desc(dev,pri);
5874 spin_unlock_irqrestore(&priv->tx_lock,flags);
5877 ieee80211_wake_queue(priv->ieee80211);
5880 void EnableHWSecurityConfig8192(struct net_device *dev)
5882 u8 SECR_value = 0x0;
5883 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5884 struct ieee80211_device* ieee = priv->ieee80211;
5885 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
5886 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
5888 SECR_value |= SCR_RxUseDK;
5889 SECR_value |= SCR_TxUseDK;
5891 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
5893 SECR_value |= SCR_RxUseDK;
5894 SECR_value |= SCR_TxUseDK;
5896 //add HWSec active enable here.
5897 //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
5899 ieee->hwsec_active = 1;
5901 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
5903 ieee->hwsec_active = 0;
5904 SECR_value &= ~SCR_RxDecEnable;
5906 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__, \
5907 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
5909 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
5914 void setKey( struct net_device *dev,
5922 u32 TargetCommand = 0;
5923 u32 TargetContent = 0;
5926 if (EntryNo >= TOTAL_CAM_ENTRY)
5927 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
5929 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr%pM\n", dev,EntryNo, KeyIndex, KeyType, MacAddr);
5932 usConfig |= BIT15 | (KeyType<<2);
5934 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
5935 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
5938 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
5939 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
5940 TargetCommand |= BIT31|BIT16;
5942 if(i==0){//MAC|Config
5943 TargetContent = (u32)(*(MacAddr+0)) << 16|
5944 (u32)(*(MacAddr+1)) << 24|
5947 write_nic_dword(dev, WCAMI, TargetContent);
5948 write_nic_dword(dev, RWCAM, TargetCommand);
5949 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
5952 TargetContent = (u32)(*(MacAddr+2)) |
5953 (u32)(*(MacAddr+3)) << 8|
5954 (u32)(*(MacAddr+4)) << 16|
5955 (u32)(*(MacAddr+5)) << 24;
5956 write_nic_dword(dev, WCAMI, TargetContent);
5957 write_nic_dword(dev, RWCAM, TargetCommand);
5961 if(KeyContent !=NULL){
5962 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
5963 write_nic_dword(dev, RWCAM, TargetCommand);
5970 /***************************************************************************
5971 ------------------- module init / exit stubs ----------------
5972 ****************************************************************************/
5973 module_init(rtl8192_usb_module_init);
5974 module_exit(rtl8192_usb_module_exit);