Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/linville/wirel...
[linux-2.6.git] / drivers / staging / rtl8192su / r8192U_core.c
1 /******************************************************************************
2  * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3  * Linux device driver for RTL8192U
4  *
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.
10  *
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
14  * more details.
15  *
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
19  *
20  * The full GNU General Public License is included in this distribution in the
21  * file called LICENSE.
22  *
23  * Contact Information:
24  * Jerry chuang <wlanfae@realtek.com>
25  */
26
27 #include <linux/vmalloc.h>
28
29 #undef LOOP_TEST
30 #undef DUMP_RX
31 #undef DUMP_TX
32 #undef DEBUG_TX_DESC2
33 #undef RX_DONT_PASS_UL
34 #undef DEBUG_EPROM
35 #undef DEBUG_RX_VERBOSE
36 #undef DUMMY_RX
37 #undef DEBUG_ZERO_RX
38 #undef DEBUG_RX_SKB
39 #undef DEBUG_TX_FRAG
40 #undef DEBUG_RX_FRAG
41 #undef DEBUG_TX_FILLDESC
42 #undef DEBUG_TX
43 #undef DEBUG_IRQ
44 #undef DEBUG_RX
45 #undef DEBUG_RXALLOC
46 #undef DEBUG_REGISTERS
47 #undef DEBUG_RING
48 #undef DEBUG_IRQ_TASKLET
49 #undef DEBUG_TX_ALLOC
50 #undef DEBUG_TX_DESC
51
52 #define CONFIG_RTL8192_IO_MAP
53
54 #include <asm/uaccess.h>
55 #include "r8192U.h"
56 #include "r8180_93cx6.h"   /* Card EEPROM */
57 #include "r8192U_wx.h"
58
59 #include "r8192S_rtl8225.h"
60 #include "r8192S_hw.h"
61 #include "r8192S_phy.h"
62 #include "r8192S_phyreg.h"
63 #include "r8192S_Efuse.h"
64
65 #include "r819xU_cmdpkt.h"
66 #include "r8192U_dm.h"
67 //#include "r8192xU_phyreg.h"
68 #include <linux/usb.h>
69
70 #include "r8192U_pm.h"
71
72 #include "ieee80211/dot11d.h"
73
74
75
76 u32 rt_global_debug_component = \
77 //                              COMP_TRACE      |
78 //                              COMP_DBG        |
79 //                              COMP_INIT       |
80 //                              COMP_RECV       |
81 //                              COMP_SEND       |
82 //                              COMP_IO         |
83                                 COMP_POWER      |
84 //                              COMP_EPROM      |
85                                 COMP_SWBW       |
86                                 COMP_POWER_TRACKING |
87                                 COMP_TURBO      |
88                                 COMP_QOS        |
89 //                              COMP_RATE       |
90 //                              COMP_RM         |
91                                 COMP_DIG        |
92 //                              COMP_EFUSE      |
93 //                              COMP_CH         |
94 //                              COMP_TXAGC      |
95                                 COMP_HIPWR      |
96 //                              COMP_HALDM      |
97                                 COMP_SEC        |
98                                 COMP_LED        |
99 //                              COMP_RF         |
100 //                              COMP_RXDESC     |
101                                 COMP_FIRMWARE   |
102                                 COMP_HT         |
103                                 COMP_AMSDU      |
104                                 COMP_SCAN       |
105 //                              COMP_CMD        |
106                                 COMP_DOWN       |
107                                 COMP_RESET      |
108                                 COMP_ERR; //always open err flags on
109
110 #define TOTAL_CAM_ENTRY 32
111 #define CAM_CONTENT_COUNT 8
112
113 static struct usb_device_id rtl8192_usb_id_tbl[] = {
114         /* Realtek */
115         {USB_DEVICE(0x0bda, 0x8192)},
116         {USB_DEVICE(0x0bda, 0x8709)},
117         /* Corega */
118         {USB_DEVICE(0x07aa, 0x0043)},
119         /* Belkin */
120         {USB_DEVICE(0x050d, 0x805E)},
121         /* Sitecom */
122         {USB_DEVICE(0x0df6, 0x0031)},
123         /* EnGenius */
124         {USB_DEVICE(0x1740, 0x9201)},
125         /* Dlink */
126         {USB_DEVICE(0x2001, 0x3301)},
127         /* Zinwell */
128         {USB_DEVICE(0x5a57, 0x0290)},
129         //92SU
130         {USB_DEVICE(0x0bda, 0x8172)},
131         {}
132 };
133
134 MODULE_LICENSE("GPL");
135 MODULE_VERSION("V 1.1");
136 MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
137 MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
138
139 static char* ifname = "wlan%d";
140 static int hwwep = 1;  //default use hw. set 0 to use software security
141 static int channels = 0x3fff;
142
143
144
145 module_param(ifname, charp, S_IRUGO|S_IWUSR );
146 //module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
147 module_param(hwwep,int, S_IRUGO|S_IWUSR);
148 module_param(channels,int, S_IRUGO|S_IWUSR);
149
150 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
151 //MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
152 MODULE_PARM_DESC(hwwep," Try to use hardware security support. ");
153 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
154
155 static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
156                          const struct usb_device_id *id);
157 static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf);
158
159 static struct usb_driver rtl8192_usb_driver = {
160         .name           = RTL819xU_MODULE_NAME,           /* Driver name   */
161         .id_table       = rtl8192_usb_id_tbl,             /* PCI_ID table  */
162         .probe          = rtl8192_usb_probe,              /* probe fn      */
163         .disconnect     = rtl8192_usb_disconnect,         /* remove fn     */
164         .suspend        = rtl8192U_suspend,               /* PM suspend fn */
165         .resume         = rtl8192U_resume,                 /* PM resume fn  */
166         .reset_resume   = rtl8192U_resume,                 /* PM reset resume fn  */
167 };
168
169
170 static void     rtl8192SU_read_eeprom_info(struct net_device *dev);
171 short   rtl8192SU_tx(struct net_device *dev, struct sk_buff* skb);
172 void    rtl8192SU_rx_nomal(struct sk_buff* skb);
173 void    rtl8192SU_rx_cmd(struct sk_buff *skb);
174 bool    rtl8192SU_adapter_start(struct net_device *dev);
175 short   rtl8192SU_tx_cmd(struct net_device *dev, struct sk_buff *skb);
176 void    rtl8192SU_link_change(struct net_device *dev);
177 void    InitialGain8192S(struct net_device *dev,u8 Operation);
178 void    rtl8192SU_query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe);
179
180 struct rtl819x_ops rtl8192su_ops = {
181         .nic_type = NIC_8192SU,
182         .rtl819x_read_eeprom_info = rtl8192SU_read_eeprom_info,
183         .rtl819x_tx = rtl8192SU_tx,
184         .rtl819x_tx_cmd = rtl8192SU_tx_cmd,
185         .rtl819x_rx_nomal = rtl8192SU_rx_nomal,
186         .rtl819x_rx_cmd = rtl8192SU_rx_cmd,
187         .rtl819x_adapter_start = rtl8192SU_adapter_start,
188         .rtl819x_link_change = rtl8192SU_link_change,
189         .rtl819x_initial_gain = InitialGain8192S,
190         .rtl819x_query_rxdesc_status = rtl8192SU_query_rxdesc_status,
191 };
192
193
194 typedef struct _CHANNEL_LIST
195 {
196         u8      Channel[32];
197         u8      Len;
198 }CHANNEL_LIST, *PCHANNEL_LIST;
199
200 static CHANNEL_LIST ChannelPlan[] = {
201         {{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
202         {{1,2,3,4,5,6,7,8,9,10,11},11},                                                 //IC
203         {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21},   //ETSI
204         {{1,2,3,4,5,6,7,8,9,10,11,12,13},13},    //Spain. Change to ETSI.
205         {{1,2,3,4,5,6,7,8,9,10,11,12,13},13},   //France. Change to ETSI.
206         {{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
207         {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
208         {{1,2,3,4,5,6,7,8,9,10,11,12,13},13},   //Israel.
209         {{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
210         {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22},    //MIC
211         {{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
212 };
213
214 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
215 {
216         int i, max_chan=-1, min_chan=-1;
217         struct ieee80211_device* ieee = priv->ieee80211;
218         switch (channel_plan)
219         {
220                 case COUNTRY_CODE_FCC:
221                 case COUNTRY_CODE_IC:
222                 case COUNTRY_CODE_ETSI:
223                 case COUNTRY_CODE_SPAIN:
224                 case COUNTRY_CODE_FRANCE:
225                 case COUNTRY_CODE_MKK:
226                 case COUNTRY_CODE_MKK1:
227                 case COUNTRY_CODE_ISRAEL:
228                 case COUNTRY_CODE_TELEC:
229                 case COUNTRY_CODE_MIC:
230                 {
231                         Dot11d_Init(ieee);
232                         ieee->bGlobalDomain = false;
233                         //acturally 8225 & 8256 rf chip only support B,G,24N mode
234                         if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256) || (priv->rf_chip == RF_6052))
235                         {
236                                 min_chan = 1;
237                                 max_chan = 14;
238                         }
239                         else
240                         {
241                                 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
242                         }
243                         if (ChannelPlan[channel_plan].Len != 0){
244                                 // Clear old channel map
245                                 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
246                                 // Set new channel map
247                                 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
248                                 {
249                                         if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
250                                         break;
251                                         GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
252                                 }
253                         }
254                         break;
255                 }
256                 case COUNTRY_CODE_GLOBAL_DOMAIN:
257                 {
258                         GET_DOT11D_INFO(ieee)->bEnabled = 0;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
259                         Dot11d_Reset(ieee);
260                         ieee->bGlobalDomain = true;
261                         break;
262                 }
263                 default:
264                         break;
265         }
266         return;
267 }
268
269 #define eqMacAddr(a,b) ( ((a)[0]==(b)[0] && (a)[1]==(b)[1] && (a)[2]==(b)[2] && (a)[3]==(b)[3] && (a)[4]==(b)[4] && (a)[5]==(b)[5]) ? 1:0 )
270
271 #define         rx_hal_is_cck_rate(_pDesc)\
272                         ((_pDesc->RxMCS  == DESC92S_RATE1M ||\
273                         _pDesc->RxMCS == DESC92S_RATE2M ||\
274                         _pDesc->RxMCS == DESC92S_RATE5_5M ||\
275                         _pDesc->RxMCS == DESC92S_RATE11M) &&\
276                         !_pDesc->RxHT)
277
278 #define         tx_hal_is_cck_rate(_DataRate)\
279                         ( _DataRate == MGN_1M ||\
280                          _DataRate == MGN_2M ||\
281                          _DataRate == MGN_5_5M ||\
282                          _DataRate == MGN_11M )
283
284
285
286
287 void CamResetAllEntry(struct net_device *dev)
288 {
289 #if 1
290         u32 ulcommand = 0;
291         //2004/02/11  In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
292         // However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
293         // In this condition, Cam can not be reset because upper layer will not set this static key again.
294         //if(Adapter->EncAlgorithm == WEP_Encryption)
295         //      return;
296 //debug
297         //DbgPrint("========================================\n");
298         //DbgPrint("                            Call ResetAllEntry                                              \n");
299         //DbgPrint("========================================\n\n");
300         ulcommand |= BIT31|BIT30;
301         write_nic_dword(dev, RWCAM, ulcommand);
302 #else
303         for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
304                 CAM_mark_invalid(dev, ucIndex);
305         for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
306                 CAM_empty_entry(dev, ucIndex);
307 #endif
308
309 }
310
311
312 void write_cam(struct net_device *dev, u8 addr, u32 data)
313 {
314         write_nic_dword(dev, WCAMI, data);
315         write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
316 }
317
318 u32 read_cam(struct net_device *dev, u8 addr)
319 {
320         write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
321         return read_nic_dword(dev, 0xa8);
322 }
323
324 void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
325 {
326         int status;
327         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
328         struct usb_device *udev = priv->udev;
329
330         status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
331                                RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
332                                indx|0xfe00, 0, &data, 1, HZ / 2);
333
334         if (status < 0)
335         {
336                 printk("write_nic_byte_E TimeOut! status:%d\n", status);
337         }
338 }
339
340 u8 read_nic_byte_E(struct net_device *dev, int indx)
341 {
342         int status;
343         u8 data;
344         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
345         struct usb_device *udev = priv->udev;
346
347         status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
348                                RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
349                                indx|0xfe00, 0, &data, 1, HZ / 2);
350
351         if (status < 0)
352         {
353                 printk("read_nic_byte_E TimeOut! status:%d\n", status);
354         }
355
356         return data;
357 }
358 //as 92U has extend page from 4 to 16, so modify functions below.
359 void write_nic_byte(struct net_device *dev, int indx, u8 data)
360 {
361         int status;
362
363         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
364         struct usb_device *udev = priv->udev;
365
366         status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
367                                RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
368                                indx, 0, &data, 1, HZ / 2);
369
370         if (status < 0)
371         {
372                 printk("write_nic_byte TimeOut! status:%d\n", status);
373         }
374
375
376 }
377
378
379 void write_nic_word(struct net_device *dev, int indx, u16 data)
380 {
381
382         int status;
383
384         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
385         struct usb_device *udev = priv->udev;
386
387         status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
388                                RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
389                                indx, 0, &data, 2, HZ / 2);
390
391         if (status < 0)
392         {
393                 printk("write_nic_word TimeOut! status:%d\n", status);
394         }
395
396 }
397
398
399 void write_nic_dword(struct net_device *dev, int indx, u32 data)
400 {
401
402         int status;
403
404         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
405         struct usb_device *udev = priv->udev;
406
407         status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
408                                RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
409                                indx, 0, &data, 4, HZ / 2);
410
411
412         if (status < 0)
413         {
414                 printk("write_nic_dword TimeOut! status:%d\n", status);
415         }
416
417 }
418
419
420
421 u8 read_nic_byte(struct net_device *dev, int indx)
422 {
423         u8 data;
424         int status;
425         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
426         struct usb_device *udev = priv->udev;
427
428         status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
429                                RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
430                                indx, 0, &data, 1, HZ / 2);
431
432         if (status < 0)
433         {
434                 printk("read_nic_byte TimeOut! status:%d\n", status);
435         }
436
437         return data;
438 }
439
440
441
442 u16 read_nic_word(struct net_device *dev, int indx)
443 {
444         u16 data;
445         int status;
446         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
447         struct usb_device *udev = priv->udev;
448
449         status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
450                                RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
451                                indx, 0, &data, 2, HZ / 2);
452
453         if (status < 0)
454         {
455                 printk("read_nic_word TimeOut! status:%d\n", status);
456         }
457
458
459         return data;
460 }
461
462 u16 read_nic_word_E(struct net_device *dev, int indx)
463 {
464         u16 data;
465         int status;
466         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
467         struct usb_device *udev = priv->udev;
468
469         status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
470                                RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
471                                indx|0xfe00, 0, &data, 2, HZ / 2);
472
473         if (status < 0)
474         {
475                 printk("read_nic_word TimeOut! status:%d\n", status);
476         }
477
478
479         return data;
480 }
481
482 u32 read_nic_dword(struct net_device *dev, int indx)
483 {
484         u32 data;
485         int status;
486 //      int result;
487
488         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
489         struct usb_device *udev = priv->udev;
490
491         status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
492                                RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
493                                indx, 0, &data, 4, HZ / 2);
494 //      if(0 != result) {
495 //        printk(KERN_WARNING "read size of data = %d\, date = %d\n", result, data);
496 //      }
497
498         if (status < 0)
499         {
500                 printk("read_nic_dword TimeOut! status:%d\n", status);
501                 if(status == -ENODEV) {
502                         priv->usb_error = true;
503                 }
504         }
505
506
507
508         return data;
509 }
510
511
512 //u8 read_phy_cck(struct net_device *dev, u8 adr);
513 //u8 read_phy_ofdm(struct net_device *dev, u8 adr);
514 /* this might still called in what was the PHY rtl8185/rtl8192 common code
515  * plans are to possibilty turn it again in one common code...
516  */
517 inline void force_pci_posting(struct net_device *dev)
518 {
519 }
520
521
522 static struct net_device_stats *rtl8192_stats(struct net_device *dev);
523 void rtl8192_commit(struct net_device *dev);
524 //void rtl8192_restart(struct net_device *dev);
525 void rtl8192_restart(struct work_struct *work);
526 //void rtl8192_rq_tx_ack(struct work_struct *work);
527
528 void watch_dog_timer_callback(unsigned long data);
529
530 /****************************************************************************
531    -----------------------------PROCFS STUFF-------------------------
532 *****************************************************************************/
533
534 static struct proc_dir_entry *rtl8192_proc = NULL;
535
536
537
538 static int proc_get_stats_ap(char *page, char **start,
539                           off_t offset, int count,
540                           int *eof, void *data)
541 {
542         struct net_device *dev = data;
543         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
544         struct ieee80211_device *ieee = priv->ieee80211;
545         struct ieee80211_network *target;
546
547         int len = 0;
548
549         list_for_each_entry(target, &ieee->network_list, list) {
550
551                 len += snprintf(page + len, count - len,
552                 "%s ", target->ssid);
553
554                 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
555                         len += snprintf(page + len, count - len,
556                         "WPA\n");
557                 }
558                 else{
559                         len += snprintf(page + len, count - len,
560                         "non_WPA\n");
561                 }
562
563         }
564
565         *eof = 1;
566         return len;
567 }
568
569 static int proc_get_registers(char *page, char **start,
570                           off_t offset, int count,
571                           int *eof, void *data)
572 {
573         struct net_device *dev = data;
574 //      struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
575
576         int len = 0;
577         int i,n,page0,page1,page2;
578
579         int max=0xff;
580         page0 = 0x000;
581         page1 = 0x100;
582         page2 = 0x800;
583
584         /* This dump the current register page */
585         if(!IS_BB_REG_OFFSET_92S(page0)){
586                 len += snprintf(page + len, count - len,
587                                 "\n####################page %x##################\n ", (page0>>8));
588                 for(n=0;n<=max;)
589                 {
590                         len += snprintf(page + len, count - len,
591                                         "\nD:  %2x > ",n);
592                         for(i=0;i<16 && n<=max;i++,n++)
593                                 len += snprintf(page + len, count - len,
594                                                 "%2.2x ",read_nic_byte(dev,(page0|n)));
595                 }
596         }else{
597                 len += snprintf(page + len, count - len,
598                                 "\n####################page %x##################\n ", (page0>>8));
599                 for(n=0;n<=max;)
600                 {
601                         len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
602                         for(i=0;i<4 && n<=max;n+=4,i++)
603                                 len += snprintf(page + len, count - len,
604                                                 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
605                 }
606         }
607         len += snprintf(page + len, count - len,"\n");
608         *eof = 1;
609         return len;
610
611 }
612 static int proc_get_registers_1(char *page, char **start,
613                           off_t offset, int count,
614                           int *eof, void *data)
615 {
616         struct net_device *dev = data;
617 //      struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
618
619         int len = 0;
620         int i,n,page0;
621
622         int max=0xff;
623         page0 = 0x100;
624
625         /* This dump the current register page */
626                 len += snprintf(page + len, count - len,
627                                 "\n####################page %x##################\n ", (page0>>8));
628                 for(n=0;n<=max;)
629                 {
630                         len += snprintf(page + len, count - len,
631                                         "\nD:  %2x > ",n);
632                         for(i=0;i<16 && n<=max;i++,n++)
633                                 len += snprintf(page + len, count - len,
634                                                 "%2.2x ",read_nic_byte(dev,(page0|n)));
635                 }
636         len += snprintf(page + len, count - len,"\n");
637         *eof = 1;
638         return len;
639
640 }
641 static int proc_get_registers_2(char *page, char **start,
642                           off_t offset, int count,
643                           int *eof, void *data)
644 {
645         struct net_device *dev = data;
646 //      struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
647
648         int len = 0;
649         int i,n,page0;
650
651         int max=0xff;
652         page0 = 0x200;
653
654         /* This dump the current register page */
655                 len += snprintf(page + len, count - len,
656                                 "\n####################page %x##################\n ", (page0>>8));
657                 for(n=0;n<=max;)
658                 {
659                         len += snprintf(page + len, count - len,
660                                         "\nD:  %2x > ",n);
661                         for(i=0;i<16 && n<=max;i++,n++)
662                                 len += snprintf(page + len, count - len,
663                                                 "%2.2x ",read_nic_byte(dev,(page0|n)));
664                 }
665         len += snprintf(page + len, count - len,"\n");
666         *eof = 1;
667         return len;
668
669 }
670 static int proc_get_registers_8(char *page, char **start,
671                           off_t offset, int count,
672                           int *eof, void *data)
673 {
674         struct net_device *dev = data;
675
676         int len = 0;
677         int i,n,page0;
678
679         int max=0xff;
680         page0 = 0x800;
681
682         /* This dump the current register page */
683                 len += snprintf(page + len, count - len,
684                                 "\n####################page %x##################\n ", (page0>>8));
685                 for(n=0;n<=max;)
686                 {
687                         len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
688                         for(i=0;i<4 && n<=max;n+=4,i++)
689                                 len += snprintf(page + len, count - len,
690                                                 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
691                 }
692         len += snprintf(page + len, count - len,"\n");
693         *eof = 1;
694         return len;
695
696         }
697 static int proc_get_registers_9(char *page, char **start,
698                           off_t offset, int count,
699                           int *eof, void *data)
700 {
701         struct net_device *dev = data;
702 //      struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
703
704         int len = 0;
705         int i,n,page0;
706
707         int max=0xff;
708         page0 = 0x900;
709
710         /* This dump the current register page */
711                 len += snprintf(page + len, count - len,
712                                 "\n####################page %x##################\n ", (page0>>8));
713                 for(n=0;n<=max;)
714                 {
715                         len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
716                         for(i=0;i<4 && n<=max;n+=4,i++)
717                         len += snprintf(page + len, count - len,
718                                                 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
719                 }
720         len += snprintf(page + len, count - len,"\n");
721         *eof = 1;
722         return len;
723 }
724 static int proc_get_registers_a(char *page, char **start,
725                           off_t offset, int count,
726                           int *eof, void *data)
727 {
728         struct net_device *dev = data;
729 //      struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
730
731         int len = 0;
732         int i,n,page0;
733
734         int max=0xff;
735         page0 = 0xa00;
736
737         /* This dump the current register page */
738                                 len += snprintf(page + len, count - len,
739                                 "\n####################page %x##################\n ", (page0>>8));
740                 for(n=0;n<=max;)
741                 {
742                         len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
743                         for(i=0;i<4 && n<=max;n+=4,i++)
744                                 len += snprintf(page + len, count - len,
745                                                 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
746                 }
747         len += snprintf(page + len, count - len,"\n");
748         *eof = 1;
749         return len;
750 }
751 static int proc_get_registers_b(char *page, char **start,
752                           off_t offset, int count,
753                           int *eof, void *data)
754 {
755         struct net_device *dev = data;
756 //      struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
757
758         int len = 0;
759         int i,n,page0;
760
761         int max=0xff;
762         page0 = 0xb00;
763
764         /* This dump the current register page */
765                 len += snprintf(page + len, count - len,
766                                 "\n####################page %x##################\n ", (page0>>8));
767                 for(n=0;n<=max;)
768                 {
769                         len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
770                         for(i=0;i<4 && n<=max;n+=4,i++)
771                                 len += snprintf(page + len, count - len,
772                                                 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
773                 }
774         len += snprintf(page + len, count - len,"\n");
775         *eof = 1;
776         return len;
777         }
778 static int proc_get_registers_c(char *page, char **start,
779                           off_t offset, int count,
780                           int *eof, void *data)
781 {
782         struct net_device *dev = data;
783 //      struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
784
785         int len = 0;
786         int i,n,page0;
787
788         int max=0xff;
789         page0 = 0xc00;
790
791         /* This dump the current register page */
792                 len += snprintf(page + len, count - len,
793                                 "\n####################page %x##################\n ", (page0>>8));
794                 for(n=0;n<=max;)
795                 {
796                         len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
797                         for(i=0;i<4 && n<=max;n+=4,i++)
798                                 len += snprintf(page + len, count - len,
799                                                 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
800                 }
801         len += snprintf(page + len, count - len,"\n");
802         *eof = 1;
803         return len;
804 }
805 static int proc_get_registers_d(char *page, char **start,
806                           off_t offset, int count,
807                           int *eof, void *data)
808 {
809         struct net_device *dev = data;
810 //      struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
811
812         int len = 0;
813         int i,n,page0;
814
815         int max=0xff;
816         page0 = 0xd00;
817
818         /* This dump the current register page */
819                 len += snprintf(page + len, count - len,
820                                 "\n####################page %x##################\n ", (page0>>8));
821                 for(n=0;n<=max;)
822                 {
823                         len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
824                         for(i=0;i<4 && n<=max;n+=4,i++)
825                                 len += snprintf(page + len, count - len,
826                                                 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
827                 }
828         len += snprintf(page + len, count - len,"\n");
829         *eof = 1;
830         return len;
831 }
832 static int proc_get_registers_e(char *page, char **start,
833                           off_t offset, int count,
834                           int *eof, void *data)
835 {
836         struct net_device *dev = data;
837 //      struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
838
839         int len = 0;
840         int i,n,page0;
841
842         int max=0xff;
843         page0 = 0xe00;
844
845         /* This dump the current register page */
846                 len += snprintf(page + len, count - len,
847                                 "\n####################page %x##################\n ", (page0>>8));
848                 for(n=0;n<=max;)
849                 {
850                         len += snprintf(page + len, count - len, "\nD:  %2x > ",n);
851                         for(i=0;i<4 && n<=max;n+=4,i++)
852                                 len += snprintf(page + len, count - len,
853                                                 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
854                 }
855         len += snprintf(page + len, count - len,"\n");
856         *eof = 1;
857         return len;
858 }
859
860 static int proc_get_stats_tx(char *page, char **start,
861                           off_t offset, int count,
862                           int *eof, void *data)
863 {
864         struct net_device *dev = data;
865         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
866
867         int len = 0;
868
869         len += snprintf(page + len, count - len,
870                 "TX VI priority ok int: %lu\n"
871                 "TX VI priority error int: %lu\n"
872                 "TX VO priority ok int: %lu\n"
873                 "TX VO priority error int: %lu\n"
874                 "TX BE priority ok int: %lu\n"
875                 "TX BE priority error int: %lu\n"
876                 "TX BK priority ok int: %lu\n"
877                 "TX BK priority error int: %lu\n"
878                 "TX MANAGE priority ok int: %lu\n"
879                 "TX MANAGE priority error int: %lu\n"
880                 "TX BEACON priority ok int: %lu\n"
881                 "TX BEACON priority error int: %lu\n"
882 //              "TX high priority ok int: %lu\n"
883 //              "TX high priority failed error int: %lu\n"
884                 "TX queue resume: %lu\n"
885                 "TX queue stopped?: %d\n"
886                 "TX fifo overflow: %lu\n"
887 //              "TX beacon: %lu\n"
888                 "TX VI queue: %d\n"
889                 "TX VO queue: %d\n"
890                 "TX BE queue: %d\n"
891                 "TX BK queue: %d\n"
892 //              "TX HW queue: %d\n"
893                 "TX VI dropped: %lu\n"
894                 "TX VO dropped: %lu\n"
895                 "TX BE dropped: %lu\n"
896                 "TX BK dropped: %lu\n"
897                 "TX total data packets %lu\n",
898 //              "TX beacon aborted: %lu\n",
899                 priv->stats.txviokint,
900                 priv->stats.txvierr,
901                 priv->stats.txvookint,
902                 priv->stats.txvoerr,
903                 priv->stats.txbeokint,
904                 priv->stats.txbeerr,
905                 priv->stats.txbkokint,
906                 priv->stats.txbkerr,
907                 priv->stats.txmanageokint,
908                 priv->stats.txmanageerr,
909                 priv->stats.txbeaconokint,
910                 priv->stats.txbeaconerr,
911 //              priv->stats.txhpokint,
912 //              priv->stats.txhperr,
913                 priv->stats.txresumed,
914                 netif_queue_stopped(dev),
915                 priv->stats.txoverflow,
916 //              priv->stats.txbeacon,
917                 atomic_read(&(priv->tx_pending[VI_PRIORITY])),
918                 atomic_read(&(priv->tx_pending[VO_PRIORITY])),
919                 atomic_read(&(priv->tx_pending[BE_PRIORITY])),
920                 atomic_read(&(priv->tx_pending[BK_PRIORITY])),
921 //              read_nic_byte(dev, TXFIFOCOUNT),
922                 priv->stats.txvidrop,
923                 priv->stats.txvodrop,
924                 priv->stats.txbedrop,
925                 priv->stats.txbkdrop,
926                 priv->stats.txdatapkt
927 //              priv->stats.txbeaconerr
928                 );
929
930         *eof = 1;
931         return len;
932 }
933
934
935
936 static int proc_get_stats_rx(char *page, char **start,
937                           off_t offset, int count,
938                           int *eof, void *data)
939 {
940         struct net_device *dev = data;
941         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
942
943         int len = 0;
944
945         len += snprintf(page + len, count - len,
946                 "RX packets: %lu\n"
947                 "RX urb status error: %lu\n"
948                 "RX invalid urb error: %lu\n",
949                 priv->stats.rxoktotal,
950                 priv->stats.rxstaterr,
951                 priv->stats.rxurberr);
952
953         *eof = 1;
954         return len;
955 }
956
957 void rtl8192_proc_module_init(void)
958 {
959         RT_TRACE(COMP_INIT, "Initializing proc filesystem");
960         rtl8192_proc=create_proc_entry(RTL819xU_MODULE_NAME, S_IFDIR, init_net.proc_net);
961 }
962
963
964 void rtl8192_proc_module_remove(void)
965 {
966         remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
967 }
968
969
970 void rtl8192_proc_remove_one(struct net_device *dev)
971 {
972         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
973
974
975         if (priv->dir_dev) {
976         //      remove_proc_entry("stats-hw", priv->dir_dev);
977                 remove_proc_entry("stats-tx", priv->dir_dev);
978                 remove_proc_entry("stats-rx", priv->dir_dev);
979         //      remove_proc_entry("stats-ieee", priv->dir_dev);
980                 remove_proc_entry("stats-ap", priv->dir_dev);
981                 remove_proc_entry("registers", priv->dir_dev);
982                 remove_proc_entry("registers-1", priv->dir_dev);
983                 remove_proc_entry("registers-2", priv->dir_dev);
984                 remove_proc_entry("registers-8", priv->dir_dev);
985                 remove_proc_entry("registers-9", priv->dir_dev);
986                 remove_proc_entry("registers-a", priv->dir_dev);
987                 remove_proc_entry("registers-b", priv->dir_dev);
988                 remove_proc_entry("registers-c", priv->dir_dev);
989                 remove_proc_entry("registers-d", priv->dir_dev);
990                 remove_proc_entry("registers-e", priv->dir_dev);
991         //      remove_proc_entry("cck-registers",priv->dir_dev);
992         //      remove_proc_entry("ofdm-registers",priv->dir_dev);
993                 //remove_proc_entry(dev->name, rtl8192_proc);
994                 remove_proc_entry("wlan0", rtl8192_proc);
995                 priv->dir_dev = NULL;
996         }
997 }
998
999
1000 void rtl8192_proc_init_one(struct net_device *dev)
1001 {
1002         struct proc_dir_entry *e;
1003         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1004         priv->dir_dev = create_proc_entry(dev->name,
1005                                           S_IFDIR | S_IRUGO | S_IXUGO,
1006                                           rtl8192_proc);
1007         if (!priv->dir_dev) {
1008                 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
1009                       dev->name);
1010                 return;
1011         }
1012         e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
1013                                    priv->dir_dev, proc_get_stats_rx, dev);
1014
1015         if (!e) {
1016                 RT_TRACE(COMP_ERR,"Unable to initialize "
1017                       "/proc/net/rtl8192/%s/stats-rx\n",
1018                       dev->name);
1019         }
1020
1021
1022         e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
1023                                    priv->dir_dev, proc_get_stats_tx, dev);
1024
1025         if (!e) {
1026                 RT_TRACE(COMP_ERR, "Unable to initialize "
1027                       "/proc/net/rtl8192/%s/stats-tx\n",
1028                       dev->name);
1029         }
1030
1031         e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
1032                                    priv->dir_dev, proc_get_stats_ap, dev);
1033
1034         if (!e) {
1035                 RT_TRACE(COMP_ERR, "Unable to initialize "
1036                       "/proc/net/rtl8192/%s/stats-ap\n",
1037                       dev->name);
1038         }
1039
1040         e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
1041                                    priv->dir_dev, proc_get_registers, dev);
1042         if (!e) {
1043                 RT_TRACE(COMP_ERR, "Unable to initialize "
1044                       "/proc/net/rtl8192/%s/registers\n",
1045                       dev->name);
1046         }
1047         e = create_proc_read_entry("registers-1", S_IFREG | S_IRUGO,
1048                                    priv->dir_dev, proc_get_registers_1, dev);
1049         if (!e) {
1050                 RT_TRACE(COMP_ERR, "Unable to initialize "
1051                       "/proc/net/rtl8192/%s/registers-1\n",
1052                       dev->name);
1053         }
1054         e = create_proc_read_entry("registers-2", S_IFREG | S_IRUGO,
1055                                    priv->dir_dev, proc_get_registers_2, dev);
1056         if (!e) {
1057                 RT_TRACE(COMP_ERR, "Unable to initialize "
1058                       "/proc/net/rtl8192/%s/registers-2\n",
1059                       dev->name);
1060         }
1061         e = create_proc_read_entry("registers-8", S_IFREG | S_IRUGO,
1062                                    priv->dir_dev, proc_get_registers_8, dev);
1063         if (!e) {
1064                 RT_TRACE(COMP_ERR, "Unable to initialize "
1065                       "/proc/net/rtl8192/%s/registers-8\n",
1066                       dev->name);
1067         }
1068         e = create_proc_read_entry("registers-9", S_IFREG | S_IRUGO,
1069                                    priv->dir_dev, proc_get_registers_9, dev);
1070         if (!e) {
1071                 RT_TRACE(COMP_ERR, "Unable to initialize "
1072                       "/proc/net/rtl8192/%s/registers-9\n",
1073                       dev->name);
1074         }
1075         e = create_proc_read_entry("registers-a", S_IFREG | S_IRUGO,
1076                                    priv->dir_dev, proc_get_registers_a, dev);
1077         if (!e) {
1078                 RT_TRACE(COMP_ERR, "Unable to initialize "
1079                       "/proc/net/rtl8192/%s/registers-a\n",
1080                       dev->name);
1081         }
1082         e = create_proc_read_entry("registers-b", S_IFREG | S_IRUGO,
1083                                    priv->dir_dev, proc_get_registers_b, dev);
1084         if (!e) {
1085                 RT_TRACE(COMP_ERR, "Unable to initialize "
1086                       "/proc/net/rtl8192/%s/registers-b\n",
1087                       dev->name);
1088         }
1089         e = create_proc_read_entry("registers-c", S_IFREG | S_IRUGO,
1090                                    priv->dir_dev, proc_get_registers_c, dev);
1091         if (!e) {
1092                 RT_TRACE(COMP_ERR, "Unable to initialize "
1093                       "/proc/net/rtl8192/%s/registers-c\n",
1094                       dev->name);
1095         }
1096         e = create_proc_read_entry("registers-d", S_IFREG | S_IRUGO,
1097                                    priv->dir_dev, proc_get_registers_d, dev);
1098         if (!e) {
1099                 RT_TRACE(COMP_ERR, "Unable to initialize "
1100                       "/proc/net/rtl8192/%s/registers-d\n",
1101                       dev->name);
1102         }
1103         e = create_proc_read_entry("registers-e", S_IFREG | S_IRUGO,
1104                                    priv->dir_dev, proc_get_registers_e, dev);
1105         if (!e) {
1106                 RT_TRACE(COMP_ERR, "Unable to initialize "
1107                       "/proc/net/rtl8192/%s/registers-e\n",
1108                       dev->name);
1109         }
1110 }
1111 /****************************************************************************
1112    -----------------------------MISC STUFF-------------------------
1113 *****************************************************************************/
1114
1115 /* this is only for debugging */
1116 void print_buffer(u32 *buffer, int len)
1117 {
1118         int i;
1119         u8 *buf =(u8*)buffer;
1120
1121         printk("ASCII BUFFER DUMP (len: %x):\n",len);
1122
1123         for(i=0;i<len;i++)
1124                 printk("%c",buf[i]);
1125
1126         printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
1127
1128         for(i=0;i<len;i++)
1129                 printk("%x",buf[i]);
1130
1131         printk("\n");
1132 }
1133
1134 //short check_nic_enough_desc(struct net_device *dev, priority_t priority)
1135 short check_nic_enough_desc(struct net_device *dev,int queue_index)
1136 {
1137         struct r8192_priv *priv = ieee80211_priv(dev);
1138         int used = atomic_read(&priv->tx_pending[queue_index]);
1139
1140         return (used < MAX_TX_URB);
1141 }
1142
1143 void tx_timeout(struct net_device *dev)
1144 {
1145         struct r8192_priv *priv = ieee80211_priv(dev);
1146         //rtl8192_commit(dev);
1147
1148         schedule_work(&priv->reset_wq);
1149         //DMESG("TXTIMEOUT");
1150 }
1151
1152
1153 /* this is only for debug */
1154 void dump_eprom(struct net_device *dev)
1155 {
1156         int i;
1157         for(i=0; i<63; i++)
1158                 RT_TRACE(COMP_EPROM, "EEPROM addr %x : %x", i, eprom_read(dev,i));
1159 }
1160
1161 /* this is only for debug */
1162 void rtl8192_dump_reg(struct net_device *dev)
1163 {
1164         int i;
1165         int n;
1166         int max=0x1ff;
1167
1168         RT_TRACE(COMP_PHY, "Dumping NIC register map");
1169
1170         for(n=0;n<=max;)
1171         {
1172                 printk( "\nD: %2x> ", n);
1173                 for(i=0;i<16 && n<=max;i++,n++)
1174                         printk("%2x ",read_nic_byte(dev,n));
1175         }
1176         printk("\n");
1177 }
1178
1179 /****************************************************************************
1180       ------------------------------HW STUFF---------------------------
1181 *****************************************************************************/
1182
1183 void rtl8192_set_mode(struct net_device *dev,int mode)
1184 {
1185         u8 ecmd;
1186         ecmd=read_nic_byte(dev, EPROM_CMD);
1187         ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
1188         ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
1189         ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
1190         ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
1191         write_nic_byte(dev, EPROM_CMD, ecmd);
1192 }
1193
1194
1195 void rtl8192_update_msr(struct net_device *dev)
1196 {
1197         struct r8192_priv *priv = ieee80211_priv(dev);
1198         u8 msr;
1199
1200         msr  = read_nic_byte(dev, MSR);
1201         msr &= ~ MSR_LINK_MASK;
1202
1203         /* do not change in link_state != WLAN_LINK_ASSOCIATED.
1204          * msr must be updated if the state is ASSOCIATING.
1205          * this is intentional and make sense for ad-hoc and
1206          * master (see the create BSS/IBSS func)
1207          */
1208         if (priv->ieee80211->state == IEEE80211_LINKED){
1209
1210                 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
1211                         msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
1212                 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1213                         msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
1214                 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
1215                         msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
1216
1217         }else
1218                 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
1219
1220         write_nic_byte(dev, MSR, msr);
1221 }
1222
1223 void rtl8192_set_chan(struct net_device *dev,short ch)
1224 {
1225         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1226 //      u32 tx;
1227         RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
1228         //printk("=====>%s()====ch:%d\n", __FUNCTION__, ch);
1229         priv->chan=ch;
1230
1231         /* this hack should avoid frame TX during channel setting*/
1232
1233
1234 //      tx = read_nic_dword(dev,TX_CONF);
1235 //      tx &= ~TX_LOOPBACK_MASK;
1236
1237 #ifndef LOOP_TEST
1238 //      write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
1239
1240         //need to implement rf set channel here WB
1241
1242         if (priv->rf_set_chan)
1243         priv->rf_set_chan(dev,priv->chan);
1244         mdelay(10);
1245 //      write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
1246 #endif
1247 }
1248
1249 static void rtl8192_rx_isr(struct urb *urb);
1250
1251 u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
1252 {
1253
1254                 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
1255                                 + pstats->RxBufShift);
1256
1257 }
1258 static int rtl8192_rx_initiate(struct net_device*dev)
1259 {
1260         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1261         struct urb *entry;
1262         struct sk_buff *skb;
1263         struct rtl8192_rx_info *info;
1264
1265         /* nomal packet rx procedure */
1266         while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
1267                 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
1268                 if (!skb)
1269                         break;
1270                 entry = usb_alloc_urb(0, GFP_KERNEL);
1271                 if (!entry) {
1272                         kfree_skb(skb);
1273                         break;
1274                 }
1275 //              printk("nomal packet IN request!\n");
1276                 usb_fill_bulk_urb(entry, priv->udev,
1277                                   usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
1278                                   RX_URB_SIZE, rtl8192_rx_isr, skb);
1279                 info = (struct rtl8192_rx_info *) skb->cb;
1280                 info->urb = entry;
1281                 info->dev = dev;
1282                 info->out_pipe = 3; //denote rx normal packet queue
1283                 skb_queue_tail(&priv->rx_queue, skb);
1284                 usb_submit_urb(entry, GFP_KERNEL);
1285         }
1286
1287         /* command packet rx procedure */
1288         while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
1289 //              printk("command packet IN request!\n");
1290                 skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL);
1291                 if (!skb)
1292                         break;
1293                 entry = usb_alloc_urb(0, GFP_KERNEL);
1294                 if (!entry) {
1295                         kfree_skb(skb);
1296                         break;
1297                 }
1298                 usb_fill_bulk_urb(entry, priv->udev,
1299                                   usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
1300                                   RX_URB_SIZE, rtl8192_rx_isr, skb);
1301                 info = (struct rtl8192_rx_info *) skb->cb;
1302                 info->urb = entry;
1303                 info->dev = dev;
1304                    info->out_pipe = 9; //denote rx cmd packet queue
1305                 skb_queue_tail(&priv->rx_queue, skb);
1306                 usb_submit_urb(entry, GFP_KERNEL);
1307         }
1308
1309         return 0;
1310 }
1311
1312 void rtl8192_set_rxconf(struct net_device *dev)
1313 {
1314         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1315         u32 rxconf;
1316
1317         rxconf=read_nic_dword(dev,RCR);
1318         rxconf = rxconf &~ MAC_FILTER_MASK;
1319         rxconf = rxconf | RCR_AMF;
1320         rxconf = rxconf | RCR_ADF;
1321         rxconf = rxconf | RCR_AB;
1322         rxconf = rxconf | RCR_AM;
1323         //rxconf = rxconf | RCR_ACF;
1324
1325         if (dev->flags & IFF_PROMISC) {DMESG ("NIC in promisc mode");}
1326
1327         if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
1328            dev->flags & IFF_PROMISC){
1329                 rxconf = rxconf | RCR_AAP;
1330         } /*else if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
1331                 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
1332                 rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
1333         }*/else{
1334                 rxconf = rxconf | RCR_APM;
1335                 rxconf = rxconf | RCR_CBSSID;
1336         }
1337
1338
1339         if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
1340                 rxconf = rxconf | RCR_AICV;
1341                 rxconf = rxconf | RCR_APWRMGT;
1342         }
1343
1344         if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
1345                 rxconf = rxconf | RCR_ACRC32;
1346
1347
1348         rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
1349         rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
1350         rxconf = rxconf &~ MAX_RX_DMA_MASK;
1351         rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
1352
1353 //      rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
1354         rxconf = rxconf | RCR_ONLYERLPKT;
1355
1356 //      rxconf = rxconf &~ RCR_CS_MASK;
1357 //      rxconf = rxconf | (1<<RCR_CS_SHIFT);
1358
1359         write_nic_dword(dev, RCR, rxconf);
1360
1361         #ifdef DEBUG_RX
1362         DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RCR));
1363         #endif
1364 }
1365 //wait to be removed
1366 void rtl8192_rx_enable(struct net_device *dev)
1367 {
1368         //u8 cmd;
1369
1370         //struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1371
1372         rtl8192_rx_initiate(dev);
1373
1374 //      rtl8192_set_rxconf(dev);
1375 }
1376
1377
1378 void rtl8192_tx_enable(struct net_device *dev)
1379 {
1380 }
1381
1382 void rtl8192_rtx_disable(struct net_device *dev)
1383 {
1384         u8 cmd;
1385         struct r8192_priv *priv = ieee80211_priv(dev);
1386         struct sk_buff *skb;
1387         struct rtl8192_rx_info *info;
1388
1389         cmd=read_nic_byte(dev,CMDR);
1390         write_nic_byte(dev, CMDR, cmd &~ \
1391                 (CR_TE|CR_RE));
1392         force_pci_posting(dev);
1393         mdelay(10);
1394
1395         while ((skb = __skb_dequeue(&priv->rx_queue))) {
1396                 info = (struct rtl8192_rx_info *) skb->cb;
1397                 if (!info->urb)
1398                         continue;
1399
1400                 usb_kill_urb(info->urb);
1401                 kfree_skb(skb);
1402         }
1403
1404         if (skb_queue_len(&priv->skb_queue)) {
1405                 printk(KERN_WARNING "skb_queue not empty\n");
1406         }
1407
1408         skb_queue_purge(&priv->skb_queue);
1409         return;
1410 }
1411
1412
1413 int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
1414 {
1415         return 0;
1416 }
1417
1418 inline u16 ieeerate2rtlrate(int rate)
1419 {
1420         switch(rate){
1421         case 10:
1422         return 0;
1423         case 20:
1424         return 1;
1425         case 55:
1426         return 2;
1427         case 110:
1428         return 3;
1429         case 60:
1430         return 4;
1431         case 90:
1432         return 5;
1433         case 120:
1434         return 6;
1435         case 180:
1436         return 7;
1437         case 240:
1438         return 8;
1439         case 360:
1440         return 9;
1441         case 480:
1442         return 10;
1443         case 540:
1444         return 11;
1445         default:
1446         return 3;
1447
1448         }
1449 }
1450 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
1451 inline u16 rtl8192_rate2rate(short rate)
1452 {
1453         if (rate >11) return 0;
1454         return rtl_rate[rate];
1455 }
1456
1457 static void rtl8192_rx_isr(struct urb *urb)
1458 {
1459         struct sk_buff *skb = (struct sk_buff *) urb->context;
1460         struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
1461         struct net_device *dev = info->dev;
1462         struct r8192_priv *priv = ieee80211_priv(dev);
1463         int out_pipe = info->out_pipe;
1464         int err;
1465         if(!priv->up)
1466                 return;
1467         if (unlikely(urb->status)) {
1468                 info->urb = NULL;
1469                 priv->stats.rxstaterr++;
1470                 priv->ieee80211->stats.rx_errors++;
1471                 usb_free_urb(urb);
1472         //      printk("%s():rx status err\n",__FUNCTION__);
1473                 return;
1474         }
1475
1476         skb_unlink(skb, &priv->rx_queue);
1477         skb_put(skb, urb->actual_length);
1478
1479         skb_queue_tail(&priv->skb_queue, skb);
1480         tasklet_schedule(&priv->irq_rx_tasklet);
1481
1482         skb = dev_alloc_skb(RX_URB_SIZE);
1483         if (unlikely(!skb)) {
1484                 usb_free_urb(urb);
1485                 printk("%s():can,t alloc skb\n",__FUNCTION__);
1486                 /* TODO check rx queue length and refill *somewhere* */
1487                 return;
1488         }
1489
1490         usb_fill_bulk_urb(urb, priv->udev,
1491                         usb_rcvbulkpipe(priv->udev, out_pipe),
1492                         skb_tail_pointer(skb),
1493                         RX_URB_SIZE, rtl8192_rx_isr, skb);
1494
1495         info = (struct rtl8192_rx_info *) skb->cb;
1496         info->urb = urb;
1497         info->dev = dev;
1498         info->out_pipe = out_pipe;
1499
1500         urb->transfer_buffer = skb_tail_pointer(skb);
1501         urb->context = skb;
1502         skb_queue_tail(&priv->rx_queue, skb);
1503         err = usb_submit_urb(urb, GFP_ATOMIC);
1504         if(err && err != EPERM)
1505                 printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
1506 }
1507
1508 u32
1509 rtl819xusb_rx_command_packet(
1510         struct net_device *dev,
1511         struct ieee80211_rx_stats *pstats
1512         )
1513 {
1514         u32     status;
1515
1516         //RT_TRACE(COMP_RECV, DBG_TRACE, ("---> RxCommandPacketHandle819xUsb()\n"));
1517
1518         status = cmpk_message_handle_rx(dev, pstats);
1519         if (status)
1520         {
1521                 DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
1522         }
1523         else
1524         {
1525                 //RT_TRACE(COMP_RECV, DBG_TRACE, ("RxCommandPacketHandle819xUsb: It is not a command packet\n"));
1526         }
1527
1528         //RT_TRACE(COMP_RECV, DBG_TRACE, ("<--- RxCommandPacketHandle819xUsb()\n"));
1529         return status;
1530 }
1531
1532 void rtl8192_data_hard_stop(struct net_device *dev)
1533 {
1534         //FIXME !!
1535 }
1536
1537
1538 void rtl8192_data_hard_resume(struct net_device *dev)
1539 {
1540         // FIXME !!
1541 }
1542
1543 /* this function TX data frames when the ieee80211 stack requires this.
1544  * It checks also if we need to stop the ieee tx queue, eventually do it
1545  */
1546 void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
1547 {
1548         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1549         int ret;
1550         unsigned long flags;
1551         cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1552         u8 queue_index = tcb_desc->queue_index;
1553
1554         /* shall not be referred by command packet */
1555         assert(queue_index != TXCMD_QUEUE);
1556
1557         spin_lock_irqsave(&priv->tx_lock,flags);
1558
1559         memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1560 //      tcb_desc->RATRIndex = 7;
1561 //      tcb_desc->bTxDisableRateFallBack = 1;
1562 //      tcb_desc->bTxUseDriverAssingedRate = 1;
1563         tcb_desc->bTxEnableFwCalcDur = 1;
1564         skb_push(skb, priv->ieee80211->tx_headroom);
1565         ret = priv->ops->rtl819x_tx(dev, skb);
1566
1567         //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1568         //priv->ieee80211->stats.tx_packets++;
1569
1570         spin_unlock_irqrestore(&priv->tx_lock,flags);
1571
1572 //      return ret;
1573         return;
1574 }
1575
1576 /* This is a rough attempt to TX a frame
1577  * This is called by the ieee 80211 stack to TX management frames.
1578  * If the ring is full packet are dropped (for data frame the queue
1579  * is stopped before this can happen).
1580  */
1581 int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1582 {
1583         struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1584         int ret;
1585         unsigned long flags;
1586         cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1587         u8 queue_index = tcb_desc->queue_index;
1588
1589
1590         spin_lock_irqsave(&priv->tx_lock,flags);
1591
1592         memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1593         if(queue_index == TXCMD_QUEUE) {
1594                 skb_push(skb, USB_HWDESC_HEADER_LEN);
1595                 priv->ops->rtl819x_tx_cmd(dev, skb);
1596                 ret = 1;
1597                 spin_unlock_irqrestore(&priv->tx_lock,flags);
1598                 return ret;
1599         } else {
1600                 skb_push(skb, priv->ieee80211->tx_headroom);
1601                 ret = priv->ops->rtl819x_tx(dev, skb);
1602         }
1603
1604         spin_unlock_irqrestore(&priv->tx_lock,flags);
1605
1606         return ret;
1607 }
1608
1609
1610 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1611
1612
1613 static void rtl8192_tx_isr(struct urb *tx_urb)
1614 {
1615         struct sk_buff *skb = (struct sk_buff*)tx_urb->context;
1616         struct net_device *dev = NULL;
1617         struct r8192_priv *priv = NULL;
1618         cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1619         u8  queue_index = tcb_desc->queue_index;
1620 //      bool bToSend0Byte;
1621 //      u16 BufLen = skb->len;
1622
1623         memcpy(&dev,(struct net_device*)(skb->cb),sizeof(struct net_device*));
1624         priv = ieee80211_priv(dev);
1625
1626         if(tcb_desc->queue_index != TXCMD_QUEUE) {
1627                 if(tx_urb->status == 0) {
1628                 //      dev->trans_start = jiffies;
1629                         // As act as station mode, destion shall be  unicast address.
1630                         //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1631                         //priv->ieee80211->stats.tx_packets++;
1632                         priv->stats.txoktotal++;
1633                         priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
1634                         priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
1635                 } else {
1636                         priv->ieee80211->stats.tx_errors++;
1637                         //priv->stats.txmanageerr++;
1638                         /* TODO */
1639                 }
1640         }
1641
1642         /* free skb and tx_urb */
1643         if(skb != NULL) {
1644                 dev_kfree_skb_any(skb);
1645                 usb_free_urb(tx_urb);
1646                 atomic_dec(&priv->tx_pending[queue_index]);
1647         }
1648
1649         {
1650                 //
1651                 // Handle HW Beacon:
1652                 // We had transfer our beacon frame to host controler at this moment.
1653                 //
1654                 //
1655                 // Caution:
1656                 // Handling the wait queue of command packets.
1657                 // For Tx command packets, we must not do TCB fragment because it is not handled right now.
1658                 // We must cut the packets to match the size of TX_CMD_PKT before we send it.
1659                 //
1660         if (queue_index == MGNT_QUEUE){
1661         if (priv->ieee80211->ack_tx_to_ieee){
1662             if (rtl8192_is_tx_queue_empty(dev)){
1663                 priv->ieee80211->ack_tx_to_ieee = 0;
1664                 ieee80211_ps_tx_ack(priv->ieee80211, 1);
1665             }
1666         }
1667     }
1668                 /* Handle MPDU in wait queue. */
1669                 if(queue_index != BEACON_QUEUE) {
1670                         /* Don't send data frame during scanning.*/
1671                         if((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0)&&\
1672                                         (!(priv->ieee80211->queue_stop))) {
1673                                 if(NULL != (skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]))))
1674                                         priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1675
1676                                 return; //modified by david to avoid further processing AMSDU
1677                         }
1678                 }
1679         }
1680 }
1681
1682 void rtl8192_beacon_stop(struct net_device *dev)
1683 {
1684         u8 msr, msrm, msr2;
1685         struct r8192_priv *priv = ieee80211_priv(dev);
1686
1687         msr  = read_nic_byte(dev, MSR);
1688         msrm = msr & MSR_LINK_MASK;
1689         msr2 = msr & ~MSR_LINK_MASK;
1690
1691         if(NIC_8192U == priv->card_8192) {
1692                 usb_kill_urb(priv->rx_urb[MAX_RX_URB]);
1693         }
1694         if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
1695                 (msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
1696                 write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
1697                 write_nic_byte(dev, MSR, msr);
1698         }
1699 }
1700
1701 void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1702 {
1703          struct r8192_priv *priv = ieee80211_priv(dev);
1704          struct ieee80211_network *net;
1705          u8 i=0, basic_rate = 0;
1706          net = & priv->ieee80211->current_network;
1707
1708          for (i=0; i<net->rates_len; i++)
1709          {
1710                  basic_rate = net->rates[i]&0x7f;
1711                  switch(basic_rate)
1712                  {
1713                          case MGN_1M:   *rate_config |= RRSR_1M;        break;
1714                          case MGN_2M:   *rate_config |= RRSR_2M;        break;
1715                          case MGN_5_5M: *rate_config |= RRSR_5_5M;      break;
1716                          case MGN_11M:  *rate_config |= RRSR_11M;       break;
1717                          case MGN_6M:   *rate_config |= RRSR_6M;        break;
1718                          case MGN_9M:   *rate_config |= RRSR_9M;        break;
1719                          case MGN_12M:  *rate_config |= RRSR_12M;       break;
1720                          case MGN_18M:  *rate_config |= RRSR_18M;       break;
1721                          case MGN_24M:  *rate_config |= RRSR_24M;       break;
1722                          case MGN_36M:  *rate_config |= RRSR_36M;       break;
1723                          case MGN_48M:  *rate_config |= RRSR_48M;       break;
1724                          case MGN_54M:  *rate_config |= RRSR_54M;       break;
1725                  }
1726          }
1727          for (i=0; i<net->rates_ex_len; i++)
1728          {
1729                  basic_rate = net->rates_ex[i]&0x7f;
1730                  switch(basic_rate)
1731                  {
1732                          case MGN_1M:   *rate_config |= RRSR_1M;        break;
1733                          case MGN_2M:   *rate_config |= RRSR_2M;        break;
1734                          case MGN_5_5M: *rate_config |= RRSR_5_5M;      break;
1735                          case MGN_11M:  *rate_config |= RRSR_11M;       break;
1736                          case MGN_6M:   *rate_config |= RRSR_6M;        break;
1737                          case MGN_9M:   *rate_config |= RRSR_9M;        break;
1738                          case MGN_12M:  *rate_config |= RRSR_12M;       break;
1739                          case MGN_18M:  *rate_config |= RRSR_18M;       break;
1740                          case MGN_24M:  *rate_config |= RRSR_24M;       break;
1741                          case MGN_36M:  *rate_config |= RRSR_36M;       break;
1742                          case MGN_48M:  *rate_config |= RRSR_48M;       break;
1743                          case MGN_54M:  *rate_config |= RRSR_54M;       break;
1744                  }
1745          }
1746 }
1747
1748
1749 #define SHORT_SLOT_TIME 9
1750 #define NON_SHORT_SLOT_TIME 20
1751
1752 void rtl8192_update_cap(struct net_device* dev, u16 cap)
1753 {
1754         //u32 tmp = 0;
1755         struct r8192_priv *priv = ieee80211_priv(dev);
1756         struct ieee80211_network *net = &priv->ieee80211->current_network;
1757         priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1758
1759         //LZM MOD 090303 HW_VAR_ACK_PREAMBLE
1760         if(0)
1761         {
1762                 u8 tmp = 0;
1763                 tmp = ((priv->nCur40MhzPrimeSC) << 5);
1764                 if (priv->short_preamble)
1765                         tmp |= 0x80;
1766                 write_nic_byte(dev, RRSR+2, tmp);
1767         }
1768
1769         if (net->mode & (IEEE_G|IEEE_N_24G))
1770         {
1771                 u8 slot_time = 0;
1772                 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1773                 {//short slot time
1774                         slot_time = SHORT_SLOT_TIME;
1775                 }
1776                 else //long slot time
1777                         slot_time = NON_SHORT_SLOT_TIME;
1778                 priv->slot_time = slot_time;
1779                 write_nic_byte(dev, SLOT_TIME, slot_time);
1780         }
1781
1782 }
1783 void rtl8192_net_update(struct net_device *dev)
1784 {
1785
1786         struct r8192_priv *priv = ieee80211_priv(dev);
1787         struct ieee80211_network *net;
1788         u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1789         u16 rate_config = 0;
1790         net = & priv->ieee80211->current_network;
1791
1792         rtl8192_config_rate(dev, &rate_config);
1793         priv->basic_rate = rate_config &= 0x15f;
1794
1795         write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1796         write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1797         //for(i=0;i<ETH_ALEN;i++)
1798         //      write_nic_byte(dev,BSSID+i,net->bssid[i]);
1799
1800         rtl8192_update_msr(dev);
1801 //      rtl8192_update_cap(dev, net->capability);
1802         if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1803         {
1804         write_nic_word(dev, ATIMWND, 2);
1805         write_nic_word(dev, BCN_DMATIME, 1023);
1806         write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1807 //      write_nic_word(dev, BcnIntTime, 100);
1808         write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
1809         write_nic_byte(dev, BCN_ERR_THRESH, 100);
1810                 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1811         // TODO: BcnIFS may required to be changed on ASIC
1812                 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1813
1814         write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1815         }
1816
1817
1818
1819 }
1820
1821 //temporary hw beacon is not used any more.
1822 //open it when necessary
1823 #if 1
1824 void rtl819xusb_beacon_tx(struct net_device *dev,u16  tx_rate)
1825 {
1826 }
1827 #endif
1828 inline u8 rtl8192_IsWirelessBMode(u16 rate)
1829 {
1830         if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
1831                 return 1;
1832         else return 0;
1833 }
1834
1835 u16 N_DBPSOfRate(u16 DataRate);
1836
1837 u16 ComputeTxTime(
1838         u16             FrameLength,
1839         u16             DataRate,
1840         u8              bManagementFrame,
1841         u8              bShortPreamble
1842 )
1843 {
1844         u16     FrameTime;
1845         u16     N_DBPS;
1846         u16     Ceiling;
1847
1848         if( rtl8192_IsWirelessBMode(DataRate) )
1849         {
1850                 if( bManagementFrame || !bShortPreamble || DataRate == 10 )
1851                 {       // long preamble
1852                         FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1853                 }
1854                 else
1855                 {       // Short preamble
1856                         FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1857                 }
1858                 if( ( FrameLength*8 % (DataRate/10) ) != 0 ) //Get the Ceilling
1859                                 FrameTime ++;
1860         } else {        //802.11g DSSS-OFDM PLCP length field calculation.
1861                 N_DBPS = N_DBPSOfRate(DataRate);
1862                 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1863                                 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1864                 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1865         }
1866         return FrameTime;
1867 }
1868
1869 u16 N_DBPSOfRate(u16 DataRate)
1870 {
1871          u16 N_DBPS = 24;
1872
1873          switch(DataRate)
1874          {
1875          case 60:
1876           N_DBPS = 24;
1877           break;
1878
1879          case 90:
1880           N_DBPS = 36;
1881           break;
1882
1883          case 120:
1884           N_DBPS = 48;
1885           break;
1886
1887          case 180:
1888           N_DBPS = 72;
1889           break;
1890
1891          case 240:
1892           N_DBPS = 96;
1893           break;
1894
1895          case 360:
1896           N_DBPS = 144;
1897           break;
1898
1899          case 480:
1900           N_DBPS = 192;
1901           break;
1902
1903          case 540:
1904           N_DBPS = 216;
1905           break;
1906
1907          default:
1908           break;
1909          }
1910
1911          return N_DBPS;
1912 }
1913
1914 void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
1915 {
1916         usb_free_urb(tx_cmd_urb);
1917 }
1918
1919 unsigned int txqueue2outpipe(struct r8192_priv* priv,unsigned int tx_queue) {
1920
1921         if(tx_queue >= 9)
1922         {
1923                 RT_TRACE(COMP_ERR,"%s():Unknown queue ID!!!\n",__FUNCTION__);
1924                 return 0x04;
1925         }
1926         return priv->txqueue_to_outpipemap[tx_queue];
1927 }
1928
1929 short rtl8192SU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1930 {
1931         struct r8192_priv *priv = ieee80211_priv(dev);
1932         int                     status;
1933         struct urb              *tx_urb;
1934         unsigned int            idx_pipe;
1935         tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
1936         cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1937         u8 queue_index = tcb_desc->queue_index;
1938         u32                     PktSize = 0;
1939
1940         //printk("\n %s::::::::::::::::::::::queue_index = %d\n",__FUNCTION__, queue_index);
1941         atomic_inc(&priv->tx_pending[queue_index]);
1942
1943         tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
1944         if(!tx_urb){
1945                 dev_kfree_skb(skb);
1946                 return -ENOMEM;
1947         }
1948
1949         memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
1950
1951         /* Tx descriptor ought to be set according to the skb->cb */
1952         pdesc->LINIP = tcb_desc->bLastIniPkt;
1953         PktSize = (u16)(skb->len - USB_HWDESC_HEADER_LEN);
1954         pdesc->PktSize = PktSize;
1955         //printk("PKTSize = %d %x\n",pdesc->PktSize,pdesc->PktSize);
1956         //----------------------------------------------------------------------------
1957         // Fill up USB_OUT_CONTEXT.
1958         //----------------------------------------------------------------------------
1959         // Get index to out pipe from specified QueueID.
1960         idx_pipe = txqueue2outpipe(priv,queue_index);
1961         //printk("=============>%s queue_index:%d, outpipe:%d\n", __func__,queue_index,priv->RtOutPipes[idx_pipe]);
1962
1963         usb_fill_bulk_urb(tx_urb,
1964                                     priv->udev,
1965                                     usb_sndbulkpipe(priv->udev,priv->RtOutPipes[idx_pipe]),
1966                                     skb->data,
1967                                     skb->len,
1968                                     rtl8192_tx_isr,
1969                                     skb);
1970
1971         status = usb_submit_urb(tx_urb, GFP_ATOMIC);
1972         if (!status){
1973                 return 0;
1974         }else{
1975                 printk("Error TX CMD URB, error %d",
1976                                 status);
1977                 return -1;
1978         }
1979 }
1980
1981 /*
1982  * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1983  * in TxFwInfo data structure
1984  * 2006.10.30 by Emily
1985  *
1986  * \param QUEUEID       Software Queue
1987 */
1988 u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1989 {
1990         u8 QueueSelect = 0x0;       //defualt set to
1991
1992         switch(QueueID) {
1993                 case BE_QUEUE:
1994                         QueueSelect = QSLT_BE;  //or QSelect = pTcb->priority;
1995                         break;
1996
1997                 case BK_QUEUE:
1998                         QueueSelect = QSLT_BK;  //or QSelect = pTcb->priority;
1999                         break;
2000
2001                 case VO_QUEUE:
2002                         QueueSelect = QSLT_VO;  //or QSelect = pTcb->priority;
2003                         break;
2004
2005                 case VI_QUEUE:
2006                         QueueSelect = QSLT_VI;  //or QSelect = pTcb->priority;
2007                         break;
2008                 case MGNT_QUEUE:
2009                         QueueSelect = QSLT_MGNT;
2010                         break;
2011
2012                 case BEACON_QUEUE:
2013                         QueueSelect = QSLT_BEACON;
2014                         break;
2015
2016                         // TODO: 2006.10.30 mark other queue selection until we verify it is OK
2017                         // TODO: Remove Assertions
2018 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
2019                 case TXCMD_QUEUE:
2020                         QueueSelect = QSLT_CMD;
2021                         break;
2022 //#endif
2023                 case HIGH_QUEUE:
2024                         QueueSelect = QSLT_HIGH;
2025                         break;
2026
2027                 default:
2028                         RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
2029                         break;
2030         }
2031         return QueueSelect;
2032 }
2033
2034 u8 MRateToHwRate8190Pci(u8 rate)
2035 {
2036         u8      ret = DESC92S_RATE1M;
2037
2038         switch(rate)
2039         {
2040                 // CCK and OFDM non-HT rates
2041         case MGN_1M:            ret = DESC92S_RATE1M;   break;
2042         case MGN_2M:            ret = DESC92S_RATE2M;   break;
2043         case MGN_5_5M:          ret = DESC92S_RATE5_5M; break;
2044         case MGN_11M:           ret = DESC92S_RATE11M;  break;
2045         case MGN_6M:            ret = DESC92S_RATE6M;   break;
2046         case MGN_9M:            ret = DESC92S_RATE9M;   break;
2047         case MGN_12M:           ret = DESC92S_RATE12M;  break;
2048         case MGN_18M:           ret = DESC92S_RATE18M;  break;
2049         case MGN_24M:           ret = DESC92S_RATE24M;  break;
2050         case MGN_36M:           ret = DESC92S_RATE36M;  break;
2051         case MGN_48M:           ret = DESC92S_RATE48M;  break;
2052         case MGN_54M:           ret = DESC92S_RATE54M;  break;
2053
2054                 // HT rates since here
2055         case MGN_MCS0:          ret = DESC92S_RATEMCS0; break;
2056         case MGN_MCS1:          ret = DESC92S_RATEMCS1; break;
2057         case MGN_MCS2:          ret = DESC92S_RATEMCS2; break;
2058         case MGN_MCS3:          ret = DESC92S_RATEMCS3; break;
2059         case MGN_MCS4:          ret = DESC92S_RATEMCS4; break;
2060         case MGN_MCS5:          ret = DESC92S_RATEMCS5; break;
2061         case MGN_MCS6:          ret = DESC92S_RATEMCS6; break;
2062         case MGN_MCS7:          ret = DESC92S_RATEMCS7; break;
2063         case MGN_MCS8:          ret = DESC92S_RATEMCS8; break;
2064         case MGN_MCS9:          ret = DESC92S_RATEMCS9; break;
2065         case MGN_MCS10: ret = DESC92S_RATEMCS10;        break;
2066         case MGN_MCS11: ret = DESC92S_RATEMCS11;        break;
2067         case MGN_MCS12: ret = DESC92S_RATEMCS12;        break;
2068         case MGN_MCS13: ret = DESC92S_RATEMCS13;        break;
2069         case MGN_MCS14: ret = DESC92S_RATEMCS14;        break;
2070         case MGN_MCS15: ret = DESC92S_RATEMCS15;        break;
2071
2072         // Set the highest SG rate
2073         case MGN_MCS0_SG:
2074         case MGN_MCS1_SG:
2075         case MGN_MCS2_SG:
2076         case MGN_MCS3_SG:
2077         case MGN_MCS4_SG:
2078         case MGN_MCS5_SG:
2079         case MGN_MCS6_SG:
2080         case MGN_MCS7_SG:
2081         case MGN_MCS8_SG:
2082         case MGN_MCS9_SG:
2083         case MGN_MCS10_SG:
2084         case MGN_MCS11_SG:
2085         case MGN_MCS12_SG:
2086         case MGN_MCS13_SG:
2087         case MGN_MCS14_SG:
2088         case MGN_MCS15_SG:
2089         {
2090                 ret = DESC92S_RATEMCS15_SG;
2091                 break;
2092         }
2093
2094         default:                break;
2095         }
2096         return ret;
2097 }
2098
2099 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
2100 {
2101         u8   tmp_Short;
2102
2103         tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
2104
2105         if(TxHT==1 && TxRate != DESC90_RATEMCS15)
2106                 tmp_Short = 0;
2107
2108         return tmp_Short;
2109 }
2110
2111 static void tx_zero_isr(struct urb *tx_urb)
2112 {
2113         return;
2114 }
2115
2116
2117 /*
2118  * The tx procedure is just as following,  skb->cb will contain all the following
2119  *information: * priority, morefrag, rate, &dev.
2120  * */
2121  //     <Note> Buffer format for 8192S Usb bulk out:
2122 //
2123 //  --------------------------------------------------
2124 //  | 8192S Usb Tx Desc | 802_11_MAC_header |    data          |
2125 //  --------------------------------------------------
2126 //  |  32 bytes                   |       24 bytes             |0-2318 bytes|
2127 //  --------------------------------------------------
2128 //  |<------------ BufferLen ------------------------->|
2129
2130 short rtl8192SU_tx(struct net_device *dev, struct sk_buff* skb)
2131 {
2132         struct r8192_priv *priv = ieee80211_priv(dev);
2133         cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2134         tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
2135         //tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);//92su del
2136         struct usb_device *udev = priv->udev;
2137         int pend;
2138         int status;
2139         struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
2140         //int urb_len;
2141         unsigned int idx_pipe;
2142         u16             MPDUOverhead = 0;
2143         //RT_DEBUG_DATA(COMP_SEND, tcb_desc, sizeof(cb_desc));
2144
2145         pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
2146         /* we are locked here so the two atomic_read and inc are executed
2147          * without interleaves  * !!! For debug purpose           */
2148         if( pend > MAX_TX_URB){
2149                 switch (tcb_desc->queue_index) {
2150                         case VO_PRIORITY:
2151                                 priv->stats.txvodrop++;
2152                                 break;
2153                         case VI_PRIORITY:
2154                                 priv->stats.txvidrop++;
2155                                 break;
2156                         case BE_PRIORITY:
2157                                 priv->stats.txbedrop++;
2158                                 break;
2159                         default://BK_PRIORITY
2160                                 priv->stats.txbkdrop++;
2161                                 break;
2162                 }
2163                 printk("To discard skb packet!\n");
2164                 dev_kfree_skb_any(skb);
2165                 return -1;
2166         }
2167
2168         tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
2169         if(!tx_urb){
2170                 dev_kfree_skb_any(skb);
2171                 return -ENOMEM;
2172         }
2173
2174         memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
2175
2176
2177                 tx_desc->NonQos = (IsQoSDataFrame(skb->data)==TRUE)? 0:1;
2178
2179         /* Fill Tx descriptor */
2180         //memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
2181
2182         // This part can just fill to the first descriptor of the frame.
2183         /* DWORD 0 */
2184         tx_desc->TxHT = (tcb_desc->data_rate&0x80)?1:0;
2185
2186
2187         tx_desc->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
2188         //tx_desc->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
2189         tx_desc->TxShort = QueryIsShort(tx_desc->TxHT, tx_desc->TxRate, tcb_desc);
2190
2191
2192         // Aggregation related
2193         if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
2194                 tx_desc->AllowAggregation = 1;
2195                 /* DWORD 1 */
2196                 //tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
2197                 //tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
2198         } else {
2199                 tx_desc->AllowAggregation = 0;
2200                 /* DWORD 1 */
2201                 //tx_fwinfo->RxMF = 0;
2202                 //tx_fwinfo->RxAMD = 0;
2203         }
2204
2205         //
2206         // <Roger_Notes> For AMPDU case, we must insert SSN into TX_DESC,
2207         // FW according as this SSN to do necessary packet retry.
2208         // 2008.06.06.
2209         //
2210         {
2211                 u8      *pSeq;
2212                 u16     Temp;
2213                 //pSeq = (u8 *)(VirtualAddress+USB_HWDESC_HEADER_LEN + FRAME_OFFSET_SEQUENCE);
2214                 pSeq = (u8 *)(skb->data+USB_HWDESC_HEADER_LEN + 22);
2215                 Temp = pSeq[0];
2216                 Temp <<= 12;
2217                 Temp |= (*(u16 *)pSeq)>>4;
2218                 tx_desc->Seq = Temp;
2219         }
2220
2221         /* Protection mode related */
2222         tx_desc->RTSEn = (tcb_desc->bRTSEnable)?1:0;
2223         tx_desc->CTS2Self = (tcb_desc->bCTSEnable)?1:0;
2224         tx_desc->RTSSTBC = (tcb_desc->bRTSSTBC)?1:0;
2225         tx_desc->RTSHT = (tcb_desc->rts_rate&0x80)?1:0;
2226         tx_desc->RTSRate =  MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
2227         tx_desc->RTSSubcarrier = (tx_desc->RTSHT==0)?(tcb_desc->RTSSC):0;
2228         tx_desc->RTSBW = (tx_desc->RTSHT==1)?((tcb_desc->bRTSBW)?1:0):0;
2229         tx_desc->RTSShort = (tx_desc->RTSHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
2230                                 (tcb_desc->bRTSUseShortGI?1:0);
2231         //LZM 090219
2232         tx_desc->DisRTSFB = 0;
2233         tx_desc->RTSRateFBLmt = 0xf;
2234
2235         // <Roger_EXP> 2008.09.22. We disable RTS rate fallback temporarily.
2236         //tx_desc->DisRTSFB = 0x01;
2237
2238         /* Set Bandwidth and sub-channel settings. */
2239         if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
2240         {
2241                 if(tcb_desc->bPacketBW) {
2242                         tx_desc->TxBandwidth = 1;
2243                         tx_desc->TxSubCarrier = 0;    //By SD3's Jerry suggestion, use duplicated mode
2244                 } else {
2245                         tx_desc->TxBandwidth = 0;
2246                         tx_desc->TxSubCarrier = priv->nCur40MhzPrimeSC;
2247                 }
2248         } else {
2249                 tx_desc->TxBandwidth = 0;
2250                 tx_desc->TxSubCarrier = 0;
2251         }
2252
2253
2254         //memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
2255         /* DWORD 0 */
2256         tx_desc->LINIP = 0;
2257         //tx_desc->CmdInit = 1; //92su del
2258         tx_desc->Offset =  USB_HWDESC_HEADER_LEN;
2259
2260         {
2261                 tx_desc->PktSize = (skb->len - USB_HWDESC_HEADER_LEN) & 0xffff;
2262         }
2263
2264         /*DWORD 1*/
2265         //tx_desc->SecCAMID= 0;//92su del
2266         tx_desc->RaBRSRID= tcb_desc->RATRIndex;
2267 //#ifdef RTL8192S_PREPARE_FOR_NORMAL_RELEASE
2268
2269         {
2270                 MPDUOverhead = 0;
2271                 //tx_desc->NoEnc = 1;//92su del
2272         }
2273
2274         tx_desc->SecType = 0x0;
2275
2276                 if (tcb_desc->bHwSec)
2277                         {
2278                                 switch (priv->ieee80211->pairwise_key_type)
2279                                 {
2280                                         case KEY_TYPE_WEP40:
2281                                         case KEY_TYPE_WEP104:
2282                                                  tx_desc->SecType = 0x1;
2283                                                  //tx_desc->NoEnc = 0;//92su del
2284                                                  break;
2285                                         case KEY_TYPE_TKIP:
2286                                                  tx_desc->SecType = 0x2;
2287                                                  //tx_desc->NoEnc = 0;//92su del
2288                                                  break;
2289                                         case KEY_TYPE_CCMP:
2290                                                  tx_desc->SecType = 0x3;
2291                                                  //tx_desc->NoEnc = 0;//92su del
2292                                                  break;
2293                                         case KEY_TYPE_NA:
2294                                                  tx_desc->SecType = 0x0;
2295                                                  //tx_desc->NoEnc = 1;//92su del
2296                                                  break;
2297                                         default:
2298                                                  tx_desc->SecType = 0x0;
2299                                                  //tx_desc->NoEnc = 1;//92su del
2300                                                  break;
2301                                 }
2302                         }
2303
2304         //tx_desc->TxFWInfoSize =  sizeof(tx_fwinfo_819x_usb);//92su del
2305
2306
2307         tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
2308         tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
2309         tx_desc->DataRateFBLmt = 0x1F;// Alwasy enable all rate fallback range
2310
2311         tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
2312
2313
2314         /* Fill fields that are required to be initialized in all of the descriptors */
2315         //DWORD 0
2316         tx_desc->FirstSeg = 1;
2317         tx_desc->LastSeg = 1;
2318         tx_desc->OWN = 1;
2319
2320         {
2321                 //DWORD 2
2322                 //tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
2323                 tx_desc->TxBufferSize = (u32)(skb->len);//92su mod FIXLZM
2324         }
2325
2326         /* Get index to out pipe from specified QueueID */
2327         idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
2328         //printk("=============>%s queue_index:%d, outpipe:%d\n", __func__,tcb_desc->queue_index,priv->RtOutPipes[idx_pipe]);
2329
2330         //RT_DEBUG_DATA(COMP_SEND,tx_fwinfo,sizeof(tx_fwinfo_819x_usb));
2331         //RT_DEBUG_DATA(COMP_SEND,tx_desc,sizeof(tx_desc_819x_usb));
2332
2333         /* To submit bulk urb */
2334         usb_fill_bulk_urb(tx_urb,
2335                                     udev,
2336                                     usb_sndbulkpipe(udev,priv->RtOutPipes[idx_pipe]),
2337                                     skb->data,
2338                                     skb->len, rtl8192_tx_isr, skb);
2339
2340         status = usb_submit_urb(tx_urb, GFP_ATOMIC);
2341         if (!status){
2342 //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
2343                 bool bSend0Byte = false;
2344                 u8 zero = 0;
2345                 if(udev->speed == USB_SPEED_HIGH)
2346                 {
2347                         if (skb->len > 0 && skb->len % 512 == 0)
2348                                 bSend0Byte = true;
2349                 }
2350                 else
2351                 {
2352                         if (skb->len > 0 && skb->len % 64 == 0)
2353                                 bSend0Byte = true;
2354                 }
2355                 if (bSend0Byte)
2356                 {
2357 #if 1
2358                         tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
2359                         if(!tx_urb_zero){
2360                                 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
2361                                 return -ENOMEM;
2362                         }
2363                         usb_fill_bulk_urb(tx_urb_zero,udev,
2364                                         usb_sndbulkpipe(udev,idx_pipe), &zero,
2365                                         0, tx_zero_isr, dev);
2366                         status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
2367                         if (status){
2368                         RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
2369                         return -1;
2370                         }
2371 #endif
2372                 }
2373                 dev->trans_start = jiffies;
2374                 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
2375                 return 0;
2376         }else{
2377                 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
2378                                 status);
2379                 return -1;
2380         }
2381 }
2382
2383 void rtl8192SU_net_update(struct net_device *dev)
2384 {
2385
2386         struct r8192_priv *priv = ieee80211_priv(dev);
2387         struct ieee80211_device* ieee = priv->ieee80211;
2388         struct ieee80211_network *net = &priv->ieee80211->current_network;
2389         //u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
2390         u16 rate_config = 0;
2391         u32 regTmp = 0;
2392         u8 rateIndex = 0;
2393         u8      retrylimit = 0x30;
2394         u16 cap = net->capability;
2395
2396         priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
2397
2398 //HW_VAR_BASIC_RATE
2399         //update Basic rate: RR, BRSR
2400         rtl8192_config_rate(dev, &rate_config); //HalSetBrateCfg
2401
2402         priv->basic_rate = rate_config  = rate_config & 0x15f;
2403
2404         // Set RRSR rate table.
2405         write_nic_byte(dev, RRSR, rate_config&0xff);
2406         write_nic_byte(dev, RRSR+1, (rate_config>>8)&0xff);
2407
2408         // Set RTS initial rate
2409         while(rate_config > 0x1)
2410         {
2411                 rate_config = (rate_config>> 1);
2412                 rateIndex++;
2413         }
2414         write_nic_byte(dev, INIRTSMCS_SEL, rateIndex);
2415 //HW_VAR_BASIC_RATE
2416
2417         //set ack preample
2418         regTmp = (priv->nCur40MhzPrimeSC) << 5;
2419         if (priv->short_preamble)
2420                 regTmp |= 0x80;
2421         write_nic_byte(dev, RRSR+2, regTmp);
2422
2423         write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
2424         write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
2425
2426         write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
2427         //2008.10.24 added by tynli for beacon changed.
2428         PHY_SetBeaconHwReg( dev, net->beacon_interval);
2429
2430         rtl8192_update_cap(dev, cap);
2431
2432         if (ieee->iw_mode == IW_MODE_ADHOC){
2433                 retrylimit = 7;
2434                 //we should enable ibss interrupt here, but disable it temporarily
2435                 if (0){
2436                         priv->irq_mask |= (IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
2437                         //rtl8192_irq_disable(dev);
2438                         //rtl8192_irq_enable(dev);
2439                 }
2440         }
2441         else{
2442                 if (0){
2443                         priv->irq_mask &= ~(IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
2444                         //rtl8192_irq_disable(dev);
2445                         //rtl8192_irq_enable(dev);
2446                 }
2447         }
2448
2449         priv->ShortRetryLimit = priv->LongRetryLimit = retrylimit;
2450
2451         write_nic_word(dev,     RETRY_LIMIT,
2452                                 retrylimit << RETRY_LIMIT_SHORT_SHIFT | \
2453                                 retrylimit << RETRY_LIMIT_LONG_SHIFT);
2454 }
2455
2456 void rtl8192SU_update_ratr_table(struct net_device* dev)
2457 {
2458                 struct r8192_priv* priv = ieee80211_priv(dev);
2459         struct ieee80211_device* ieee = priv->ieee80211;
2460         u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2461         //struct ieee80211_network *net = &ieee->current_network;
2462         u32 ratr_value = 0;
2463
2464         u8 rate_index = 0;
2465         int WirelessMode = ieee->mode;
2466         u8 MimoPs = ieee->pHTInfo->PeerMimoPs;
2467
2468         u8 bNMode = 0;
2469
2470         rtl8192_config_rate(dev, (u16*)(&ratr_value));
2471         ratr_value |= (*(u16*)(pMcsRate)) << 12;
2472
2473         //switch (ieee->mode)
2474         switch (WirelessMode)
2475         {
2476                 case IEEE_A:
2477                         ratr_value &= 0x00000FF0;
2478                         break;
2479                 case IEEE_B:
2480                         ratr_value &= 0x0000000D;
2481                         break;
2482                 case IEEE_G:
2483                         ratr_value &= 0x00000FF5;
2484                         break;
2485                 case IEEE_N_24G:
2486                 case IEEE_N_5G:
2487                 {
2488                         bNMode = 1;
2489
2490                         if (MimoPs == 0) //MIMO_PS_STATIC
2491                                         {
2492                                 ratr_value &= 0x0007F005;
2493                         }
2494                         else
2495                         {       // MCS rate only => for 11N mode.
2496                                 u32     ratr_mask;
2497
2498                                 // 1T2R or 1T1R, Spatial Stream 2 should be disabled
2499                                 if (    priv->rf_type == RF_1T2R ||
2500                                         priv->rf_type == RF_1T1R ||
2501                                         (ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_TX_2SS) )
2502                                                 ratr_mask = 0x000ff005;
2503                                         else
2504                                                 ratr_mask = 0x0f0ff005;
2505
2506                                 if((ieee->pHTInfo->bCurTxBW40MHz) &&
2507                                     !(ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_TX_40_MHZ))
2508                                         ratr_mask |= 0x00000010; // Set 6MBps
2509
2510                                 // Select rates for rate adaptive mechanism.
2511                                         ratr_value &= ratr_mask;
2512                                         }
2513                         }
2514                         break;
2515                 default:
2516                         if(0)
2517                         {
2518                                 if(priv->rf_type == RF_1T2R)    // 1T2R, Spatial Stream 2 should be disabled
2519                                 {
2520                                 ratr_value &= 0x000ff0f5;
2521                                 }
2522                                 else
2523                                 {
2524                                 ratr_value &= 0x0f0ff0f5;
2525                                 }
2526                         }
2527                         //printk("====>%s(), mode is not correct:%x\n", __FUNCTION__, ieee->mode);
2528                         break;
2529         }
2530
2531         ratr_value &= 0x0FFFFFFF;
2532
2533         // Get MAX MCS available.
2534         if (   (bNMode && ((ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_SHORT_GI)==0)) &&
2535                 ((ieee->pHTInfo->bCurBW40MHz && ieee->pHTInfo->bCurShortGI40MHz) ||
2536                 (!ieee->pHTInfo->bCurBW40MHz && ieee->pHTInfo->bCurShortGI20MHz)))
2537         {
2538                 u8 shortGI_rate = 0;
2539                 u32 tmp_ratr_value = 0;
2540                 ratr_value |= 0x10000000;//???
2541                 tmp_ratr_value = (ratr_value>>12);
2542                 for(shortGI_rate=15; shortGI_rate>0; shortGI_rate--)
2543                 {
2544                         if((1<<shortGI_rate) & tmp_ratr_value)
2545                                 break;
2546                 }
2547                 shortGI_rate = (shortGI_rate<<12)|(shortGI_rate<<8)|(shortGI_rate<<4)|(shortGI_rate);
2548                 write_nic_byte(dev, SG_RATE, shortGI_rate);
2549                 //printk("==>SG_RATE:%x\n", read_nic_byte(dev, SG_RATE));
2550         }
2551         write_nic_dword(dev, ARFR0+rate_index*4, ratr_value);
2552         printk("=============>ARFR0+rate_index*4:%#x\n", ratr_value);
2553
2554         //2 UFWP
2555         if (ratr_value & 0xfffff000){
2556                 //printk("===>set to N mode\n");
2557                 HalSetFwCmd8192S(dev, FW_CMD_RA_REFRESH_N);
2558         }
2559         else    {
2560                 //printk("===>set to B/G mode\n");
2561                 HalSetFwCmd8192S(dev, FW_CMD_RA_REFRESH_BG);
2562         }
2563 }
2564
2565 void rtl8192SU_link_change(struct net_device *dev)
2566 {
2567         struct r8192_priv *priv = ieee80211_priv(dev);
2568         struct ieee80211_device* ieee = priv->ieee80211;
2569         //unsigned long flags;
2570         u32 reg = 0;
2571
2572         printk("=====>%s 1\n", __func__);
2573         reg = read_nic_dword(dev, RCR);
2574
2575         if (ieee->state == IEEE80211_LINKED)
2576         {
2577
2578                 rtl8192SU_net_update(dev);
2579                 rtl8192SU_update_ratr_table(dev);
2580                 ieee->SetFwCmdHandler(dev, FW_CMD_HIGH_PWR_ENABLE);
2581                 priv->ReceiveConfig = reg |= RCR_CBSSID;
2582
2583         }else{
2584                 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
2585
2586         }
2587
2588         write_nic_dword(dev, RCR, reg);
2589         rtl8192_update_msr(dev);
2590
2591         printk("<=====%s 2\n", __func__);
2592 }
2593
2594 static struct ieee80211_qos_parameters def_qos_parameters = {
2595         {3,3,3,3},/* cw_min */
2596         {7,7,7,7},/* cw_max */
2597         {2,2,2,2},/* aifs */
2598         {0,0,0,0},/* flags */
2599         {0,0,0,0} /* tx_op_limit */
2600 };
2601
2602
2603 void rtl8192_update_beacon(struct work_struct * work)
2604 {
2605         struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
2606         struct net_device *dev = priv->ieee80211->dev;
2607         struct ieee80211_device* ieee = priv->ieee80211;
2608         struct ieee80211_network* net = &ieee->current_network;
2609
2610         if (ieee->pHTInfo->bCurrentHTSupport)
2611                 HTUpdateSelfAndPeerSetting(ieee, net);
2612         ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
2613         // Joseph test for turbo mode with AP
2614         ieee->pHTInfo->RT2RT_HT_Mode = net->bssht.RT2RT_HT_Mode;
2615         rtl8192_update_cap(dev, net->capability);
2616 }
2617 /*
2618 * background support to run QoS activate functionality
2619 */
2620 int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
2621
2622 void rtl8192_qos_activate(struct work_struct * work)
2623 {
2624         struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
2625         struct net_device *dev = priv->ieee80211->dev;
2626         struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
2627         u8 mode = priv->ieee80211->current_network.mode;
2628         //u32 size = sizeof(struct ieee80211_qos_parameters);
2629         u8  u1bAIFS;
2630         u32 u4bAcParam;
2631         int i;
2632
2633         if (priv == NULL)
2634                 return;
2635
2636        mutex_lock(&priv->mutex);
2637
2638         if(priv->ieee80211->state != IEEE80211_LINKED)
2639                 goto success;
2640         RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
2641         /* It better set slot time at first */
2642         /* For we just support b/g mode at present, let the slot time at 9/20 selection */
2643         /* update the ac parameter to related registers */
2644         for(i = 0; i <  QOS_QUEUE_NUM; i++) {
2645                 //Mode G/A: slotTimeTimer = 9; Mode B: 20
2646                 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
2647                 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
2648                                 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
2649                                 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
2650                                 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
2651
2652                 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
2653                 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4322);
2654         }
2655
2656 success:
2657        mutex_unlock(&priv->mutex);
2658 }
2659
2660 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
2661                 int active_network,
2662                 struct ieee80211_network *network)
2663 {
2664         int ret = 0;
2665         u32 size = sizeof(struct ieee80211_qos_parameters);
2666
2667         if(priv->ieee80211->state !=IEEE80211_LINKED)
2668                 return ret;
2669
2670         if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2671                 return ret;
2672
2673         if (network->flags & NETWORK_HAS_QOS_MASK) {
2674                 if (active_network &&
2675                                 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
2676                         network->qos_data.active = network->qos_data.supported;
2677
2678                 if ((network->qos_data.active == 1) && (active_network == 1) &&
2679                                 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
2680                                 (network->qos_data.old_param_count !=
2681                                  network->qos_data.param_count)) {
2682                         network->qos_data.old_param_count =
2683                                 network->qos_data.param_count;
2684                         queue_work(priv->priv_wq, &priv->qos_activate);
2685                         RT_TRACE (COMP_QOS, "QoS parameters change call "
2686                                         "qos_activate\n");
2687                 }
2688         } else {
2689                 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2690                        &def_qos_parameters, size);
2691
2692                 if ((network->qos_data.active == 1) && (active_network == 1)) {
2693                         queue_work(priv->priv_wq, &priv->qos_activate);
2694                         RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
2695                 }
2696                 network->qos_data.active = 0;
2697                 network->qos_data.supported = 0;
2698         }
2699
2700         return 0;
2701 }
2702
2703 /* handle manage frame frame beacon and probe response */
2704 static int rtl8192_handle_beacon(struct net_device * dev,
2705                                  struct ieee80211_probe_response *beacon,
2706                                  struct ieee80211_network *network)
2707 {
2708         struct r8192_priv *priv = ieee80211_priv(dev);
2709
2710         rtl8192_qos_handle_probe_response(priv,1,network);
2711         queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
2712
2713         return 0;
2714
2715 }
2716
2717 /*
2718 * handling the beaconing responses. if we get different QoS setting
2719 * off the network from the associated setting, adjust the QoS
2720 * setting
2721 */
2722 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
2723                                     struct ieee80211_network *network)
2724 {
2725         int ret = 0;
2726         unsigned long flags;
2727         u32 size = sizeof(struct ieee80211_qos_parameters);
2728         int set_qos_param = 0;
2729
2730         if ((priv == NULL) || (network == NULL))
2731                 return ret;
2732
2733         if(priv->ieee80211->state !=IEEE80211_LINKED)
2734                 return ret;
2735
2736         if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2737                 return ret;
2738
2739         spin_lock_irqsave(&priv->ieee80211->lock, flags);
2740         if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
2741                 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2742                          &network->qos_data.parameters,\
2743                         sizeof(struct ieee80211_qos_parameters));
2744                 priv->ieee80211->current_network.qos_data.active = 1;
2745                  {
2746                         set_qos_param = 1;
2747                         /* update qos parameter for current network */
2748                         priv->ieee80211->current_network.qos_data.old_param_count = \
2749                                  priv->ieee80211->current_network.qos_data.param_count;
2750                         priv->ieee80211->current_network.qos_data.param_count = \
2751                                  network->qos_data.param_count;
2752                 }
2753         } else {
2754                 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2755                        &def_qos_parameters, size);
2756                 priv->ieee80211->current_network.qos_data.active = 0;
2757                 priv->ieee80211->current_network.qos_data.supported = 0;
2758                 set_qos_param = 1;
2759         }
2760
2761         spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
2762
2763         RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
2764         if (set_qos_param == 1)
2765                 queue_work(priv->priv_wq, &priv->qos_activate);
2766
2767         return ret;
2768 }
2769
2770
2771 static int rtl8192_handle_assoc_response(struct net_device *dev,
2772                                      struct ieee80211_assoc_response_frame *resp,
2773                                      struct ieee80211_network *network)
2774 {
2775         struct r8192_priv *priv = ieee80211_priv(dev);
2776         rtl8192_qos_association_resp(priv, network);
2777         return 0;
2778 }
2779
2780
2781 void rtl8192_update_ratr_table(struct net_device* dev)
2782         //      POCTET_STRING   posLegacyRate,
2783         //      u8*                     pMcsRate)
2784         //      PRT_WLAN_STA    pEntry)
2785 {
2786         struct r8192_priv* priv = ieee80211_priv(dev);
2787         struct ieee80211_device* ieee = priv->ieee80211;
2788         u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2789         //struct ieee80211_network *net = &ieee->current_network;
2790         u32 ratr_value = 0;
2791         u8 rate_index = 0;
2792         rtl8192_config_rate(dev, (u16*)(&ratr_value));
2793         ratr_value |= (*(u16*)(pMcsRate)) << 12;
2794 //      switch (net->mode)
2795         switch (ieee->mode)
2796         {
2797                 case IEEE_A:
2798                         ratr_value &= 0x00000FF0;
2799                         break;
2800                 case IEEE_B:
2801                         ratr_value &= 0x0000000F;
2802                         break;
2803                 case IEEE_G:
2804                         ratr_value &= 0x00000FF7;
2805                         break;
2806                 case IEEE_N_24G:
2807                 case IEEE_N_5G:
2808                         if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
2809                                 ratr_value &= 0x0007F007;
2810                         else{
2811                                 if (priv->rf_type == RF_1T2R)
2812                                         ratr_value &= 0x000FF007;
2813                                 else
2814                                         ratr_value &= 0x0F81F007;
2815                         }
2816                         break;
2817                 default:
2818                         break;
2819         }
2820         ratr_value &= 0x0FFFFFFF;
2821         if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
2822                 ratr_value |= 0x80000000;
2823         }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
2824                 ratr_value |= 0x80000000;
2825         }
2826         write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2827         write_nic_byte(dev, UFWP, 1);
2828 }
2829
2830 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
2831 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2832 bool GetNmodeSupportBySecCfg8192(struct net_device*dev)
2833 {
2834 #if 1
2835         struct r8192_priv* priv = ieee80211_priv(dev);
2836         struct ieee80211_device* ieee = priv->ieee80211;
2837         struct ieee80211_network * network = &ieee->current_network;
2838         int wpa_ie_len= ieee->wpa_ie_len;
2839         struct ieee80211_crypt_data* crypt;
2840         int encrypt;
2841         return TRUE;
2842
2843         crypt = ieee->crypt[ieee->tx_keyidx];
2844         //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
2845         encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2846
2847         /* simply judge  */
2848         if(encrypt && (wpa_ie_len == 0)) {
2849                 /* wep encryption, no N mode setting */
2850                 return false;
2851 //      } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
2852         } else if((wpa_ie_len != 0)) {
2853                 /* parse pairwise key type */
2854                 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
2855                 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))))
2856                         return true;
2857                 else
2858                         return false;
2859         } else {
2860                 return true;
2861         }
2862
2863         return true;
2864 #endif
2865 }
2866
2867 bool GetHalfNmodeSupportByAPs819xUsb(struct net_device* dev)
2868 {
2869         bool                    Reval;
2870         struct r8192_priv* priv = ieee80211_priv(dev);
2871         struct ieee80211_device* ieee = priv->ieee80211;
2872
2873 //      Added by Roger, 2008.08.29.
2874         return false;
2875
2876         if(ieee->bHalfWirelessN24GMode == true)
2877                 Reval = true;
2878         else
2879                 Reval =  false;
2880
2881         return Reval;
2882 }
2883
2884 void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2885 {
2886         struct ieee80211_device* ieee = priv->ieee80211;
2887         //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
2888         if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2889         {
2890                 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2891                 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
2892                 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
2893         }
2894         else
2895                 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2896         return;
2897 }
2898
2899 u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2900 {
2901         struct r8192_priv *priv = ieee80211_priv(dev);
2902         u8 ret = 0;
2903         switch(priv->rf_chip)
2904         {
2905                 case RF_8225:
2906                 case RF_8256:
2907                 case RF_PSEUDO_11N:
2908                 case RF_6052:
2909                         ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2910                         break;
2911                 case RF_8258:
2912                         ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2913                         break;
2914                 default:
2915                         ret = WIRELESS_MODE_B;
2916                         break;
2917         }
2918         return ret;
2919 }
2920 void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2921 {
2922         struct r8192_priv *priv = ieee80211_priv(dev);
2923         u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2924
2925 #if 1
2926         if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2927         {
2928                 if(bSupportMode & WIRELESS_MODE_N_24G)
2929                 {
2930                         wireless_mode = WIRELESS_MODE_N_24G;
2931                 }
2932                 else if(bSupportMode & WIRELESS_MODE_N_5G)
2933                 {
2934                         wireless_mode = WIRELESS_MODE_N_5G;
2935                 }
2936                 else if((bSupportMode & WIRELESS_MODE_A))
2937                 {
2938                         wireless_mode = WIRELESS_MODE_A;
2939                 }
2940                 else if((bSupportMode & WIRELESS_MODE_G))
2941                 {
2942                         wireless_mode = WIRELESS_MODE_G;
2943                 }
2944                 else if((bSupportMode & WIRELESS_MODE_B))
2945                 {
2946                         wireless_mode = WIRELESS_MODE_B;
2947                 }
2948                 else{
2949                         RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2950                         wireless_mode = WIRELESS_MODE_B;
2951                 }
2952         }
2953 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we shoud wait for FPGA
2954         ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2955 #endif
2956         //LZM 090306 usb crash here, mark it temp
2957         //write_nic_word(dev, SIFS_OFDM, 0x0e0e);
2958         priv->ieee80211->mode = wireless_mode;
2959
2960         if ((wireless_mode == WIRELESS_MODE_N_24G) ||  (wireless_mode == WIRELESS_MODE_N_5G))
2961                 priv->ieee80211->pHTInfo->bEnableHT = 1;
2962         else
2963                 priv->ieee80211->pHTInfo->bEnableHT = 0;
2964         RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2965         rtl8192_refresh_supportrate(priv);
2966 #endif
2967
2968 }
2969
2970
2971 short rtl8192_is_tx_queue_empty(struct net_device *dev)
2972 {
2973         int i=0;
2974         struct r8192_priv *priv = ieee80211_priv(dev);
2975         //struct ieee80211_device* ieee = priv->ieee80211;
2976         for (i=0; i<=MGNT_QUEUE; i++)
2977         {
2978                 if ((i== TXCMD_QUEUE) || (i == HCCA_QUEUE) )
2979                         continue;
2980                 if (atomic_read(&priv->tx_pending[i]))
2981                 {
2982                         printk("===>tx queue is not empty:%d, %d\n", i, atomic_read(&priv->tx_pending[i]));
2983                         return 0;
2984                 }
2985         }
2986         return 1;
2987 }
2988
2989 void rtl8192_hw_sleep_down(struct net_device *dev)
2990 {
2991         RT_TRACE(COMP_POWER, "%s()============>come to sleep down\n", __FUNCTION__);
2992 #ifdef TODO
2993 //      MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
2994 #endif
2995 }
2996
2997 void rtl8192_hw_sleep_wq (struct work_struct *work)
2998 {
2999 //      struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
3000 //      struct ieee80211_device * ieee = (struct ieee80211_device*)
3001 //                                             container_of(work, struct ieee80211_device, watch_dog_wq);
3002         struct delayed_work *dwork = container_of(work,struct delayed_work,work);
3003         struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
3004         struct net_device *dev = ieee->dev;
3005
3006         //printk("=========>%s()\n", __FUNCTION__);
3007         rtl8192_hw_sleep_down(dev);
3008 }
3009 //      printk("dev is %d\n",dev);
3010 //      printk("&*&(^*(&(&=========>%s()\n", __FUNCTION__);
3011 void rtl8192_hw_wakeup(struct net_device* dev)
3012 {
3013 //      u32 flags = 0;
3014
3015 //      spin_lock_irqsave(&priv->ps_lock,flags);
3016         RT_TRACE(COMP_POWER, "%s()============>come to wake up\n", __FUNCTION__);
3017 #ifdef TODO
3018 //      MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
3019 #endif
3020         //FIXME: will we send package stored while nic is sleep?
3021 //      spin_unlock_irqrestore(&priv->ps_lock,flags);
3022 }
3023
3024 void rtl8192_hw_wakeup_wq (struct work_struct *work)
3025 {
3026 //      struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
3027 //      struct ieee80211_device * ieee = (struct ieee80211_device*)
3028 //                                             container_of(work, struct ieee80211_device, watch_dog_wq);
3029         struct delayed_work *dwork = container_of(work,struct delayed_work,work);
3030         struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
3031         struct net_device *dev = ieee->dev;
3032
3033         rtl8192_hw_wakeup(dev);
3034 }
3035
3036 #define MIN_SLEEP_TIME 50
3037 #define MAX_SLEEP_TIME 10000
3038 void rtl8192_hw_to_sleep(struct net_device *dev, u32 th, u32 tl)
3039 {
3040
3041         struct r8192_priv *priv = ieee80211_priv(dev);
3042
3043         u32 rb = jiffies;
3044         unsigned long flags;
3045
3046         spin_lock_irqsave(&priv->ps_lock,flags);
3047
3048         /* Writing HW register with 0 equals to disable
3049          * the timer, that is not really what we want
3050          */
3051         tl -= MSECS(4+16+7);
3052
3053         //if(tl == 0) tl = 1;
3054
3055         /* FIXME HACK FIXME HACK */
3056 //      force_pci_posting(dev);
3057         //mdelay(1);
3058
3059 //      rb = read_nic_dword(dev, TSFTR);
3060
3061         /* If the interval in witch we are requested to sleep is too
3062          * short then give up and remain awake
3063          */
3064         if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
3065                 ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
3066                 spin_unlock_irqrestore(&priv->ps_lock,flags);
3067                 printk("too short to sleep\n");
3068                 return;
3069         }
3070
3071 //      write_nic_dword(dev, TimerInt, tl);
3072 //      rb = read_nic_dword(dev, TSFTR);
3073         {
3074                 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
3075         //      if (tl<rb)
3076
3077                 queue_delayed_work(priv->ieee80211->wq, &priv->ieee80211->hw_wakeup_wq, tmp); //as tl may be less than rb
3078         }
3079         /* if we suspect the TimerInt is gone beyond tl
3080          * while setting it, then give up
3081          */
3082 #if 1
3083         if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
3084                 ((tl < rb) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))) {
3085                 printk("========>too long to sleep:%x, %x, %lx\n", tl, rb,  MSECS(MAX_SLEEP_TIME));
3086                 spin_unlock_irqrestore(&priv->ps_lock,flags);
3087                 return;
3088         }
3089 #endif
3090 //      if(priv->rf_sleep)
3091 //              priv->rf_sleep(dev);
3092
3093         //printk("<=========%s()\n", __FUNCTION__);
3094         queue_delayed_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_sleep_wq,0);
3095
3096         spin_unlock_irqrestore(&priv->ps_lock,flags);
3097 }
3098 //init priv variables here. only non_zero value should be initialized here.
3099 static void rtl8192_init_priv_variable(struct net_device* dev)
3100 {
3101         struct r8192_priv *priv = ieee80211_priv(dev);
3102         u8 i;
3103         priv->card_8192 = NIC_8192U;
3104         priv->chan = 1; //set to channel 1
3105         priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
3106         priv->ieee80211->iw_mode = IW_MODE_INFRA;
3107         priv->ieee80211->ieee_up=0;
3108         priv->retry_rts = DEFAULT_RETRY_RTS;
3109         priv->retry_data = DEFAULT_RETRY_DATA;
3110         priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
3111         priv->ieee80211->rate = 110; //11 mbps
3112         priv->ieee80211->short_slot = 1;
3113         priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
3114         priv->CckPwEnl = 6;
3115         //for silent reset
3116         priv->IrpPendingCount = 1;
3117         priv->ResetProgress = RESET_TYPE_NORESET;
3118         priv->bForcedSilentReset = 0;
3119         priv->bDisableNormalResetCheck = false;
3120         priv->force_reset = false;
3121
3122         priv->ieee80211->FwRWRF = 0;    //we don't use FW read/write RF until stable firmware is available.
3123         priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
3124         priv->ieee80211->iw_mode = IW_MODE_INFRA;
3125         priv->ieee80211->softmac_features  = IEEE_SOFTMAC_SCAN |
3126                 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
3127                 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
3128                 IEEE_SOFTMAC_BEACONS;//added by amy 080604 //|  //IEEE_SOFTMAC_SINGLE_QUEUE;
3129
3130         priv->ieee80211->active_scan = 1;
3131         priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
3132         priv->ieee80211->host_encrypt = 1;
3133         priv->ieee80211->host_decrypt = 1;
3134         priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
3135         priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
3136         priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
3137         priv->ieee80211->set_chan = rtl8192_set_chan;
3138         priv->ieee80211->link_change = priv->ops->rtl819x_link_change;
3139         priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
3140         priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
3141         priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
3142         priv->ieee80211->init_wmmparam_flag = 0;
3143         priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
3144         priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
3145         priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
3146         priv->ieee80211->qos_support = 1;
3147
3148         //added by WB
3149 //      priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
3150         priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
3151         priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
3152         priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
3153         //for LPS
3154         priv->ieee80211->sta_wake_up = rtl8192_hw_wakeup;
3155 //      priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
3156         priv->ieee80211->enter_sleep_state = rtl8192_hw_to_sleep;
3157         priv->ieee80211->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
3158         //added by david
3159         priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
3160         priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
3161         priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
3162         //added by amy
3163         priv->ieee80211->InitialGainHandler = priv->ops->rtl819x_initial_gain;
3164         priv->card_type = USB;
3165
3166 //1 RTL8192SU/
3167         priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
3168         priv->ieee80211->SetFwCmdHandler = HalSetFwCmd8192S;
3169         priv->bRFSiOrPi = 0;//o=si,1=pi;
3170         //lzm add
3171         priv->bInHctTest = false;
3172
3173         priv->MidHighPwrTHR_L1 = 0x3B;
3174         priv->MidHighPwrTHR_L2 = 0x40;
3175
3176         if(priv->bInHctTest)
3177         {
3178                 priv->ShortRetryLimit = HAL_RETRY_LIMIT_AP_ADHOC;
3179                 priv->LongRetryLimit = HAL_RETRY_LIMIT_AP_ADHOC;
3180         }
3181         else
3182         {
3183                 priv->ShortRetryLimit = HAL_RETRY_LIMIT_INFRA;
3184                 priv->LongRetryLimit = HAL_RETRY_LIMIT_INFRA;
3185         }
3186
3187         priv->SetFwCmdInProgress = false; //is set FW CMD in Progress? 92S only
3188         priv->CurrentFwCmdIO = 0;
3189
3190         priv->MinSpaceCfg = 0;
3191
3192         priv->EarlyRxThreshold = 7;
3193         priv->enable_gpio0 = 0;
3194         priv->TransmitConfig    =
3195                                 ((u32)TCR_MXDMA_2048<<TCR_MXDMA_OFFSET) |       // Max DMA Burst Size per Tx DMA Burst, 7: reservied.
3196                                 (priv->ShortRetryLimit<<TCR_SRL_OFFSET) |       // Short retry limit
3197                                 (priv->LongRetryLimit<<TCR_LRL_OFFSET) |        // Long retry limit
3198                                 (false ? TCR_SAT : 0);  // FALSE: HW provies PLCP length and LENGEXT, TURE: SW proiveds them
3199         if(priv->bInHctTest)
3200                 priv->ReceiveConfig     =       //priv->CSMethod |
3201                                                                 RCR_AMF | RCR_ADF |     //RCR_AAP |     //accept management/data
3202                                                                         RCR_ACF |RCR_APPFCS|                                            //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
3203                                                                 RCR_AB | RCR_AM | RCR_APM |             //accept BC/MC/UC
3204                                                                 RCR_AICV | RCR_ACRC32 |                 //accept ICV/CRC error packet
3205                                                                 RCR_APP_PHYST_STAFF | RCR_APP_PHYST_RXFF |      // Accept PHY status
3206                                                                 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
3207                                                                 (priv->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
3208                                                                 (priv->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt:0);
3209         else
3210                 priv->ReceiveConfig     =       //priv->CSMethod |
3211                                                                         RCR_AMF | RCR_ADF | RCR_AB |
3212                                                                         RCR_AM | RCR_APM |RCR_AAP |RCR_ADD3|RCR_APP_ICV|
3213                                                                 RCR_APP_PHYST_STAFF | RCR_APP_PHYST_RXFF |      // Accept PHY status
3214                                                                         RCR_APP_MIC | RCR_APPFCS;
3215
3216         // <Roger_EXP> 2008.06.16.
3217         priv->IntrMask          =       (u16)(IMR_ROK | IMR_VODOK | IMR_VIDOK | IMR_BEDOK | IMR_BKDOK |         \
3218                                                                 IMR_HCCADOK | IMR_MGNTDOK | IMR_COMDOK | IMR_HIGHDOK |                                  \
3219                                                                 IMR_BDOK | IMR_RXCMDOK | /*IMR_TIMEOUT0 |*/ IMR_RDU | IMR_RXFOVW        |                       \
3220                                                                 IMR_TXFOVW | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
3221
3222 //1 End
3223
3224
3225         priv->AcmControl = 0;
3226         priv->pFirmware = (rt_firmware*)vmalloc(sizeof(rt_firmware));
3227         if (priv->pFirmware)
3228         memset(priv->pFirmware, 0, sizeof(rt_firmware));
3229
3230         /* rx related queue */
3231         skb_queue_head_init(&priv->rx_queue);
3232         skb_queue_head_init(&priv->skb_queue);
3233
3234         /* Tx related queue */
3235         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
3236                 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
3237         }
3238         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
3239                 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
3240         }
3241         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
3242                 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ [i]);
3243         }
3244         priv->rf_set_chan = rtl8192_phy_SwChnl;
3245 }
3246
3247 //init lock here
3248 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
3249 {
3250         spin_lock_init(&priv->tx_lock);
3251         spin_lock_init(&priv->irq_lock);//added by thomas
3252         //spin_lock_init(&priv->rf_lock);//use rf_sem, or will crash in some OS.
3253         sema_init(&priv->wx_sem,1);
3254         sema_init(&priv->rf_sem,1);
3255         spin_lock_init(&priv->ps_lock);
3256         mutex_init(&priv->mutex);
3257 }
3258
3259 extern  void    rtl819x_watchdog_wqcallback(struct work_struct *work);
3260
3261 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
3262 //init tasklet and wait_queue here. only 2.6 above kernel is considered
3263 #define DRV_NAME "wlan0"
3264 static void rtl8192_init_priv_task(struct net_device* dev)
3265 {
3266         struct r8192_priv *priv = ieee80211_priv(dev);
3267
3268 #ifdef PF_SYNCTHREAD
3269         priv->priv_wq = create_workqueue(DRV_NAME,0);
3270 #else
3271         priv->priv_wq = create_workqueue(DRV_NAME);
3272 #endif
3273
3274         INIT_WORK(&priv->reset_wq, rtl8192_restart);
3275
3276         //INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
3277         INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
3278         INIT_DELAYED_WORK(&priv->txpower_tracking_wq,  dm_txpower_trackingcallback);
3279 //      INIT_DELAYED_WORK(&priv->gpio_change_rf_wq,  dm_gpio_change_rf_callback);
3280         INIT_DELAYED_WORK(&priv->rfpath_check_wq,  dm_rf_pathcheck_workitemcallback);
3281         INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
3282         INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
3283         //INIT_WORK(&priv->SwChnlWorkItem,  rtl8192_SwChnl_WorkItem);
3284         //INIT_WORK(&priv->SetBWModeWorkItem,  rtl8192_SetBWModeWorkItem);
3285         INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
3286         INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq);
3287         INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq);
3288
3289         tasklet_init(&priv->irq_rx_tasklet,
3290              (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
3291              (unsigned long)priv);
3292 }
3293
3294 static void rtl8192_get_eeprom_size(struct net_device* dev)
3295 {
3296         u16 curCR = 0;
3297         struct r8192_priv *priv = ieee80211_priv(dev);
3298         RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
3299         curCR = read_nic_word_E(dev,EPROM_CMD);
3300         RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
3301         //whether need I consider BIT5?
3302         priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
3303         RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
3304 }
3305
3306 //used to swap endian. as ntohl & htonl are not neccessary to swap endian, so use this instead.
3307 static inline u16 endian_swap(u16* data)
3308 {
3309         u16 tmp = *data;
3310         *data = (tmp >> 8) | (tmp << 8);
3311         return *data;
3312 }
3313
3314 u8 rtl8192SU_UsbOptionToEndPointNumber(u8 UsbOption)
3315 {
3316         u8      nEndPoint = 0;
3317         switch(UsbOption)
3318         {
3319                 case 0:
3320                         nEndPoint = 6;
3321                         break;
3322                 case 1:
3323                         nEndPoint = 11;
3324                         break;
3325                 case 2:
3326                         nEndPoint = 4;
3327                         break;
3328                 default:
3329                         RT_TRACE(COMP_INIT, "UsbOptionToEndPointNumber(): Invalid UsbOption(%#x)\n", UsbOption);
3330                         break;
3331         }
3332         return nEndPoint;
3333 }
3334
3335 u8 rtl8192SU_BoardTypeToRFtype(struct net_device* dev,  u8 Boardtype)
3336 {
3337         u8      RFtype = RF_1T2R;
3338
3339         switch(Boardtype)
3340         {
3341                 case 0:
3342                         RFtype = RF_1T1R;
3343                         break;
3344                 case 1:
3345                         RFtype = RF_1T2R;
3346                         break;
3347                 case 2:
3348                         RFtype = RF_2T2R;
3349                         break;
3350                 case 3:
3351                         RFtype = RF_2T2R_GREEN;
3352                         break;
3353                 default:
3354                         break;
3355         }
3356
3357         return RFtype;
3358 }
3359
3360 //
3361 //      Description:
3362 //              Config HW adapter information into initial value.
3363 //
3364 //      Assumption:
3365 //              1. After Auto load fail(i.e, check CR9346 fail)
3366 //
3367 //      Created by Roger, 2008.10.21.
3368 //
3369 void
3370 rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device* dev)
3371 {
3372         struct r8192_priv       *priv = ieee80211_priv(dev);
3373         //u16                   i,usValue;
3374         //u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x92, 0x00};
3375         u8              rf_path, index; // For EEPROM/EFUSE After V0.6_1117
3376         int     i;
3377
3378         RT_TRACE(COMP_INIT, "====> ConfigAdapterInfo8192SForAutoLoadFail\n");
3379
3380         write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader
3381         //PlatformStallExecution(10000);
3382         mdelay(10);
3383         write_nic_byte(dev, PMC_FSM, 0x02); // Enable Loader Data Keep
3384
3385         //RT_ASSERT(priv->AutoloadFailFlag==TRUE, ("ReadAdapterInfo8192SEEPROM(): AutoloadFailFlag !=TRUE\n"));
3386
3387         // Initialize IC Version && Channel Plan
3388         priv->eeprom_vid = 0;
3389         priv->eeprom_pid = 0;
3390         priv->card_8192_version = 0;
3391         priv->eeprom_ChannelPlan = 0;
3392         priv->eeprom_CustomerID = 0;
3393         priv->eeprom_SubCustomerID = 0;
3394         priv->bIgnoreDiffRateTxPowerOffset = false;
3395
3396         RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
3397         RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid);
3398         RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
3399         RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n", priv->eeprom_SubCustomerID);
3400         RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", priv->eeprom_ChannelPlan);
3401         RT_TRACE(COMP_INIT, "IgnoreDiffRateTxPowerOffset = %d\n", priv->bIgnoreDiffRateTxPowerOffset);
3402
3403
3404
3405         priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC;
3406         RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption);
3407
3408         for(i=0; i<5; i++)
3409                 priv->EEPROMUsbPhyParam[i] = EEPROM_USB_Default_PHY_PARAM;
3410
3411         //RT_PRINT_DATA(COMP_INIT|COMP_EFUSE, DBG_LOUD, ("EFUSE USB PHY Param: \n"), priv->EEPROMUsbPhyParam, 5);
3412
3413         {
3414         //<Roger_Notes> In this case, we random assigh MAC address here. 2008.10.15.
3415                 static u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x92, 0x00};
3416                 u8      i;
3417
3418                 //sMacAddr[5] = (u8)GetRandomNumber(1, 254);
3419
3420                 for(i = 0; i < 6; i++)
3421                         dev->dev_addr[i] = sMacAddr[i];
3422         }
3423         //NicIFSetMacAddress(Adapter, Adapter->PermanentAddress);
3424         write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
3425         write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
3426
3427         RT_TRACE(COMP_INIT, "ReadAdapterInfo8192SEFuse(), Permanent Address = %02x-%02x-%02x-%02x-%02x-%02x\n",
3428                         dev->dev_addr[0], dev->dev_addr[1],
3429                         dev->dev_addr[2], dev->dev_addr[3],
3430                         dev->dev_addr[4], dev->dev_addr[5]);
3431
3432         priv->EEPROMBoardType = EEPROM_Default_BoardType;
3433         priv->rf_type = RF_1T2R; //RF_2T2R
3434         priv->EEPROMTxPowerDiff = EEPROM_Default_PwDiff;
3435         priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
3436         priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
3437         priv->EEPROMTxPwrBase = EEPROM_Default_TxPowerBase;
3438         priv->EEPROMTSSI_A = EEPROM_Default_TSSI;
3439         priv->EEPROMTSSI_B = EEPROM_Default_TSSI;
3440         priv->EEPROMTxPwrTkMode = EEPROM_Default_TxPwrTkMode;
3441
3442
3443
3444         for (rf_path = 0; rf_path < 2; rf_path++)
3445         {
3446                 for (i = 0; i < 3; i++)
3447                 {
3448                         // Read CCK RF A & B Tx power
3449                         priv->RfCckChnlAreaTxPwr[rf_path][i] =
3450                         priv->RfOfdmChnlAreaTxPwr1T[rf_path][i] =
3451                         priv->RfOfdmChnlAreaTxPwr2T[rf_path][i] =
3452                         (u8)(EEPROM_Default_TxPower & 0xff);
3453                 }
3454         }
3455
3456         for (i = 0; i < 3; i++)
3457         {
3458                 //RT_TRACE((COMP_EFUSE), "CCK RF-%d CHan_Area-%d = 0x%x\n",  rf_path, i,
3459                 //priv->RfCckChnlAreaTxPwr[rf_path][i]);
3460                 //RT_TRACE((COMP_EFUSE), "OFDM-1T RF-%d CHan_Area-%d = 0x%x\n",  rf_path, i,
3461                 //priv->RfOfdmChnlAreaTxPwr1T[rf_path][i]);
3462                 //RT_TRACE((COMP_EFUSE), "OFDM-2T RF-%d CHan_Area-%d = 0x%x\n",  rf_path, i,
3463                 //priv->RfOfdmChnlAreaTxPwr2T[rf_path][i]);
3464         }
3465
3466         // Assign dedicated channel tx power
3467         for(i=0; i<14; i++)     // channel 1~3 use the same Tx Power Level.
3468                 {
3469                 if (i < 3)                      // Cjanel 1-3
3470                         index = 0;
3471                 else if (i < 9)         // Channel 4-9
3472                         index = 1;
3473                 else                            // Channel 10-14
3474                         index = 2;
3475
3476                 // Record A & B CCK /OFDM - 1T/2T Channel area tx power
3477                 priv->RfTxPwrLevelCck[rf_path][i]  =
3478                 priv->RfCckChnlAreaTxPwr[rf_path][index];
3479                 priv->RfTxPwrLevelOfdm1T[rf_path][i]  =
3480                 priv->RfOfdmChnlAreaTxPwr1T[rf_path][index];
3481                 priv->RfTxPwrLevelOfdm2T[rf_path][i]  =
3482                 priv->RfOfdmChnlAreaTxPwr2T[rf_path][index];
3483                 }
3484
3485                 for(i=0; i<14; i++)
3486                 {
3487                 //RT_TRACE((COMP_EFUSE), "Rf-%d TxPwr CH-%d CCK OFDM_1T OFDM_2T= 0x%x/0x%x/0x%x\n",
3488                 //rf_path, i, priv->RfTxPwrLevelCck[0][i],
3489                 //priv->RfTxPwrLevelOfdm1T[0][i] ,
3490                 //priv->RfTxPwrLevelOfdm2T[0][i] );
3491                 }
3492
3493         //
3494         // Update remained HAL variables.
3495         //
3496         priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
3497         priv->LegacyHTTxPowerDiff = priv->EEPROMTxPowerDiff;//new
3498         priv->TxPowerDiff = priv->EEPROMTxPowerDiff;
3499         //priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);// Antenna B gain offset to antenna A, bit0~3
3500         //priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);// Antenna C gain offset to antenna A, bit4~7
3501         priv->CrystalCap = priv->EEPROMCrystalCap;      // CrystalCap, bit12~15
3502         priv->ThermalMeter[0] = priv->EEPROMThermalMeter;// ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
3503         priv->LedStrategy = SW_LED_MODE0;
3504
3505         init_rate_adaptive(dev);
3506
3507         RT_TRACE(COMP_INIT, "<==== ConfigAdapterInfo8192SForAutoLoadFail\n");
3508
3509 }
3510
3511 //
3512 //      Description:
3513 //              Read HW adapter information by E-Fuse or EEPROM according CR9346 reported.
3514 //
3515 //      Assumption:
3516 //              1. CR9346 regiser has verified.
3517 //              2. PASSIVE_LEVEL (USB interface)
3518 //
3519 //      Created by Roger, 2008.10.21.
3520 //
3521 void
3522 rtl8192SU_ReadAdapterInfo8192SUsb(struct net_device* dev)
3523 {
3524         struct r8192_priv       *priv = ieee80211_priv(dev);
3525         u16                     i,usValue;
3526         u8                      tmpU1b, tempval;
3527         u16                     EEPROMId;
3528         u8                      hwinfo[HWSET_MAX_SIZE_92S];
3529         u8                      rf_path, index; // For EEPROM/EFUSE After V0.6_1117
3530
3531
3532         RT_TRACE(COMP_INIT, "====> ReadAdapterInfo8192SUsb\n");
3533
3534         //
3535         // <Roger_Note> The following operation are prevent Efuse leakage by turn on 2.5V.
3536         // 2008.11.25.
3537         //
3538         tmpU1b = read_nic_byte(dev, EFUSE_TEST+3);
3539         write_nic_byte(dev, EFUSE_TEST+3, tmpU1b|0x80);
3540         //PlatformStallExecution(1000);
3541         mdelay(10);
3542         write_nic_byte(dev, EFUSE_TEST+3, (tmpU1b&(~BIT7)));
3543
3544         // Retrieve Chip version.
3545         priv->card_8192_version = (VERSION_8192S)((read_nic_dword(dev, PMC_FSM)>>16)&0xF);
3546         RT_TRACE(COMP_INIT, "Chip Version ID: 0x%2x\n", priv->card_8192_version);
3547
3548         switch(priv->card_8192_version)
3549         {
3550                 case 0:
3551                         RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_ACUT.\n");
3552                         break;
3553                 case 1:
3554                         RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_BCUT.\n");
3555                         break;
3556                 case 2:
3557                         RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_CCUT.\n");
3558                         break;
3559                 default:
3560                         RT_TRACE(COMP_INIT, "Unknown Chip Version!!\n");
3561                         priv->card_8192_version = VERSION_8192S_BCUT;
3562                         break;
3563         }
3564
3565         //if (IS_BOOT_FROM_EEPROM(Adapter))
3566         if(priv->EepromOrEfuse)
3567         {       // Read frin EEPROM
3568                 write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader
3569                 //PlatformStallExecution(10000);
3570                 mdelay(10);
3571                 write_nic_byte(dev, PMC_FSM, 0x02); // Enable Loader Data Keep
3572                 // Read all Content from EEPROM or EFUSE.
3573                 for(i = 0; i < HWSET_MAX_SIZE_92S; i += 2)
3574                 {
3575                         usValue = eprom_read(dev, (u16) (i>>1));
3576                         *((u16*)(&hwinfo[i])) = usValue;
3577                 }
3578         }
3579         else if (!(priv->EepromOrEfuse))
3580         {       // Read from EFUSE
3581
3582                 //
3583                 // <Roger_Notes> We set Isolation signals from Loader and reset EEPROM after system resuming
3584                 // from suspend mode.
3585                 // 2008.10.21.
3586                 //
3587                 //PlatformEFIOWrite1Byte(Adapter, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader
3588                 //PlatformStallExecution(10000);
3589                 //PlatformEFIOWrite1Byte(Adapter, SYS_FUNC_EN+1, 0x40);
3590                 //PlatformEFIOWrite1Byte(Adapter, SYS_FUNC_EN+1, 0x50);
3591
3592                 //tmpU1b = PlatformEFIORead1Byte(Adapter, EFUSE_TEST+3);
3593                 //PlatformEFIOWrite1Byte(Adapter, EFUSE_TEST+3, (tmpU1b | 0x80));
3594                 //PlatformEFIOWrite1Byte(Adapter, EFUSE_TEST+3, 0x72);
3595                 //PlatformEFIOWrite1Byte(Adapter, EFUSE_CLK, 0x03);
3596
3597                 // Read EFUSE real map to shadow.
3598                 EFUSE_ShadowMapUpdate(dev);
3599                 memcpy(hwinfo, &priv->EfuseMap[EFUSE_INIT_MAP][0], HWSET_MAX_SIZE_92S);
3600         }
3601         else
3602         {
3603                 RT_TRACE(COMP_INIT, "ReadAdapterInfo8192SUsb(): Invalid boot type!!\n");
3604         }
3605
3606         //YJ,test,090106
3607         //dump_buf(hwinfo,HWSET_MAX_SIZE_92S);
3608         //
3609         // <Roger_Notes> The following are EFUSE/EEPROM independent operations!!
3610         //
3611         //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("MAP: \n"), hwinfo, HWSET_MAX_SIZE_92S);
3612
3613         //
3614         // <Roger_Notes> Event though CR9346 regiser can verify whether Autoload is success or not, but we still
3615         // double check ID codes for 92S here(e.g., due to HW GPIO polling fail issue).
3616         // 2008.10.21.
3617         //
3618         EEPROMId = *((u16 *)&hwinfo[0]);
3619
3620         if( EEPROMId != RTL8190_EEPROM_ID )
3621         {
3622                 RT_TRACE(COMP_INIT, "ID(%#x) is invalid!!\n", EEPROMId);
3623                 priv->bTXPowerDataReadFromEEPORM = FALSE;
3624                 priv->AutoloadFailFlag=TRUE;
3625         }
3626         else
3627         {
3628                 priv->AutoloadFailFlag=FALSE;
3629                 priv->bTXPowerDataReadFromEEPORM = TRUE;
3630         }
3631        // Read IC Version && Channel Plan
3632         if(!priv->AutoloadFailFlag)
3633         {
3634                 // VID, PID
3635                 priv->eeprom_vid = *(u16 *)&hwinfo[EEPROM_VID];
3636                 priv->eeprom_pid = *(u16 *)&hwinfo[EEPROM_PID];
3637                 priv->bIgnoreDiffRateTxPowerOffset = false;     //cosa for test
3638
3639
3640                 // EEPROM Version ID, Channel plan
3641                 priv->EEPROMVersion = *(u8 *)&hwinfo[EEPROM_Version];
3642                 priv->eeprom_ChannelPlan = *(u8 *)&hwinfo[EEPROM_ChannelPlan];
3643
3644                 // Customer ID, 0x00 and 0xff are reserved for Realtek.
3645                 priv->eeprom_CustomerID = *(u8 *)&hwinfo[EEPROM_CustomID];
3646                 priv->eeprom_SubCustomerID = *(u8 *)&hwinfo[EEPROM_SubCustomID];
3647         }
3648         else
3649         {
3650                 //priv->eeprom_vid = 0;
3651                 //priv->eeprom_pid = 0;
3652                 //priv->EEPROMVersion = 0;
3653                 //priv->eeprom_ChannelPlan = 0;
3654                 //priv->eeprom_CustomerID = 0;
3655                 //priv->eeprom_SubCustomerID = 0;
3656
3657                 rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(dev);
3658                 return;
3659         }
3660
3661
3662         RT_TRACE(COMP_INIT, "EEPROM Id = 0x%4x\n", EEPROMId);
3663         RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
3664         RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid);
3665         RT_TRACE(COMP_INIT, "EEPROM Version ID: 0x%2x\n", priv->EEPROMVersion);
3666         RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
3667         RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n", priv->eeprom_SubCustomerID);
3668         RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", priv->eeprom_ChannelPlan);
3669         RT_TRACE(COMP_INIT, "bIgnoreDiffRateTxPowerOffset = %d\n", priv->bIgnoreDiffRateTxPowerOffset);
3670
3671
3672         // Read USB optional function.
3673         if(!priv->AutoloadFailFlag)
3674         {
3675                 priv->EEPROMUsbOption = *(u8 *)&hwinfo[EEPROM_USB_OPTIONAL];
3676         }
3677         else
3678         {
3679                 priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC;
3680         }
3681
3682
3683         priv->EEPROMUsbEndPointNumber = rtl8192SU_UsbOptionToEndPointNumber((priv->EEPROMUsbOption&EEPROM_EP_NUMBER)>>3);
3684
3685         RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption);
3686         RT_TRACE(COMP_INIT, "EndPoint Number = %#x\n", priv->EEPROMUsbEndPointNumber);
3687
3688 #ifdef TO_DO_LIST
3689         //
3690         //  Decide CustomerID according to VID/DID or EEPROM
3691         //
3692         switch(pHalData->EEPROMCustomerID)
3693         {
3694                 case EEPROM_CID_ALPHA:
3695                         pMgntInfo->CustomerID = RT_CID_819x_ALPHA;
3696                         break;
3697
3698                 case EEPROM_CID_CAMEO:
3699                         pMgntInfo->CustomerID = RT_CID_819x_CAMEO;
3700                         break;
3701
3702                 case EEPROM_CID_SITECOM:
3703                         pMgntInfo->CustomerID = RT_CID_819x_Sitecom;
3704                         RT_TRACE(COMP_INIT, DBG_LOUD, ("CustomerID = 0x%4x\n", pMgntInfo->CustomerID));
3705
3706                         break;
3707
3708                 case EEPROM_CID_WHQL:
3709                         Adapter->bInHctTest = TRUE;
3710
3711                         pMgntInfo->bSupportTurboMode = FALSE;
3712                         pMgntInfo->bAutoTurboBy8186 = FALSE;
3713
3714                         pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
3715                         pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
3716                         pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
3717                         pMgntInfo->keepAliveLevel = 0;
3718                         break;
3719
3720                 default:
3721                         pMgntInfo->CustomerID = RT_CID_DEFAULT;
3722                         break;
3723
3724         }
3725
3726         //
3727         // Led mode
3728         //
3729         switch(pMgntInfo->CustomerID)
3730         {
3731                 case RT_CID_DEFAULT:
3732                 case RT_CID_819x_ALPHA:
3733                         pHalData->LedStrategy = SW_LED_MODE1;
3734                         pHalData->bRegUseLed = TRUE;
3735                         pHalData->SwLed1.bLedOn = TRUE;
3736                         break;
3737                 case RT_CID_819x_CAMEO:
3738                         pHalData->LedStrategy = SW_LED_MODE1;
3739                         pHalData->bRegUseLed = TRUE;
3740                         break;
3741
3742                 case RT_CID_819x_Sitecom:
3743                         pHalData->LedStrategy = SW_LED_MODE2;
3744                         pHalData->bRegUseLed = TRUE;
3745                         break;
3746
3747                 default:
3748                         pHalData->LedStrategy = SW_LED_MODE0;
3749                         break;
3750         }
3751 #endif
3752
3753         // Read USB PHY parameters.
3754         for(i=0; i<5; i++)
3755                 priv->EEPROMUsbPhyParam[i] = *(u8 *)&hwinfo[EEPROM_USB_PHY_PARA1+i];
3756
3757         //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("USB PHY Param: \n"), pHalData->EEPROMUsbPhyParam, 5);
3758
3759
3760        //Read Permanent MAC address
3761         for(i=0; i<6; i++)
3762                 dev->dev_addr[i] =  *(u8 *)&hwinfo[EEPROM_NODE_ADDRESS_BYTE_0+i];
3763
3764         //NicIFSetMacAddress(Adapter, Adapter->PermanentAddress);
3765         write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
3766         write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
3767
3768         RT_TRACE(COMP_INIT, "ReadAdapterInfo8192SEFuse(), Permanent Address = %02x-%02x-%02x-%02x-%02x-%02x\n",
3769                         dev->dev_addr[0], dev->dev_addr[1],
3770                         dev->dev_addr[2], dev->dev_addr[3],
3771                         dev->dev_addr[4], dev->dev_addr[5]);
3772
3773         //
3774         // Get CustomerID(Boad Type)
3775         // i.e., 0x0: RTL8188SU, 0x1: RTL8191SU, 0x2: RTL8192SU, 0x3: RTL8191GU.
3776         // Others: Reserved. Default is 0x2: RTL8192SU.
3777         //
3778         //if(!priv->AutoloadFailFlag)
3779         //{
3780                 priv->EEPROMBoardType = *(u8 *)&hwinfo[EEPROM_BoardType];
3781                 priv->rf_type = rtl8192SU_BoardTypeToRFtype(dev, priv->EEPROMBoardType);
3782         //}
3783         //else
3784         //{
3785         //      priv->EEPROMBoardType = EEPROM_Default_BoardType;
3786         //      priv->rf_type = RF_1T2R;
3787         //}
3788
3789         priv->rf_chip = RF_6052;
3790
3791         priv->rf_chip = RF_6052;//lzm test
3792         RT_TRACE(COMP_INIT, "BoardType = 0x%2x\n", priv->EEPROMBoardType);
3793         RT_TRACE(COMP_INIT, "RF_Type = 0x%2x\n", priv->rf_type);
3794
3795         //
3796         // Read antenna tx power offset of B/C/D to A  from EEPROM
3797         // and read ThermalMeter from EEPROM
3798         //
3799         //if(!priv->AutoloadFailFlag)
3800         {
3801                 priv->EEPROMTxPowerDiff = *(u8 *)&hwinfo[EEPROM_PwDiff];
3802                 priv->EEPROMThermalMeter = *(u8 *)&hwinfo[EEPROM_ThermalMeter];
3803         }
3804         //else
3805         //{
3806         //      priv->EEPROMTxPowerDiff = EEPROM_Default_PwDiff;
3807         //      priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
3808         //}
3809
3810         RT_TRACE(COMP_INIT, "PwDiff = %#x\n", priv->EEPROMTxPowerDiff);
3811         RT_TRACE(COMP_INIT, "ThermalMeter = %#x\n", priv->EEPROMThermalMeter);
3812
3813         //
3814         // Read Tx Power gain offset of legacy OFDM to HT rate.
3815         // Read CrystalCap from EEPROM
3816         //
3817         //if(!priv->AutoloadFailFlag)
3818         {
3819                 priv->EEPROMCrystalCap = *(u8 *)&hwinfo[EEPROM_CrystalCap];
3820         }
3821         //else
3822         //{
3823         //      priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
3824         //}
3825
3826         RT_TRACE(COMP_INIT, "CrystalCap = %#x\n", priv->EEPROMCrystalCap);
3827
3828         //
3829         // Get Tx Power Base.
3830         //
3831         //if(!priv->AutoloadFailFlag)
3832         {
3833                 priv->EEPROMTxPwrBase = *(u8 *)&hwinfo[EEPROM_TxPowerBase];
3834         }
3835         //else
3836         //{
3837         //      priv->EEPROMTxPwrBase = EEPROM_Default_TxPowerBase;
3838         //}
3839
3840         RT_TRACE(COMP_INIT, "TxPwrBase = %#x\n", priv->EEPROMTxPwrBase);
3841
3842
3843         //
3844         // Get TSSI value for each path.
3845         //
3846         //if(!priv->AutoloadFailFlag)
3847         {
3848                 priv->EEPROMTSSI_A = *(u8 *)&hwinfo[EEPROM_TSSI_A];
3849                 priv->EEPROMTSSI_B = *(u8 *)&hwinfo[EEPROM_TSSI_B];
3850         }
3851         //else
3852         //{ // Default setting for Empty EEPROM
3853         //      priv->EEPROMTSSI_A = EEPROM_Default_TSSI;
3854         //      priv->EEPROMTSSI_B = EEPROM_Default_TSSI;
3855         //}
3856
3857         RT_TRACE(COMP_INIT, "TSSI_A = %#x, TSSI_B = %#x\n", priv->EEPROMTSSI_A, priv->EEPROMTSSI_B);
3858
3859         //
3860         // Get Tx Power tracking mode.
3861         //
3862         //if(!priv->AutoloadFailFlag)
3863         {
3864                 priv->EEPROMTxPwrTkMode = *(u8 *)&hwinfo[EEPROM_TxPwTkMode];
3865         }
3866
3867         RT_TRACE(COMP_INIT, "TxPwrTkMod = %#x\n", priv->EEPROMTxPwrTkMode);
3868
3869
3870         {
3871                 //
3872                 // Buffer TxPwIdx(i.e., from offset 0x55~0x66, total 18Bytes)
3873                 // Update CCK, OFDM (1T/2T)Tx Power Index from above buffer.
3874                 //
3875
3876                 //
3877                 // Get Tx Power Level by Channel
3878                 //
3879                 //if(!priv->AutoloadFailFlag)
3880                 {
3881                         // Read Tx power of Channel 1 ~ 14 from EFUSE.
3882                         // 92S suupport RF A & B
3883                         for (rf_path = 0; rf_path < 2; rf_path++)
3884                         {
3885                                 for (i = 0; i < 3; i++)
3886                                 {
3887                                         // Read CCK RF A & B Tx power
3888                                         priv->RfCckChnlAreaTxPwr[rf_path][i] =
3889                                         hwinfo[EEPROM_TxPwIndex+rf_path*3+i];
3890
3891                                         // Read OFDM RF A & B Tx power for 1T
3892                                         priv->RfOfdmChnlAreaTxPwr1T[rf_path][i] =
3893                                         hwinfo[EEPROM_TxPwIndex+6+rf_path*3+i];
3894
3895                                         // Read OFDM RF A & B Tx power for 2T
3896                                         priv->RfOfdmChnlAreaTxPwr2T[rf_path][i] =
3897                                         hwinfo[EEPROM_TxPwIndex+12+rf_path*3+i];
3898                                 }
3899                         }
3900
3901                 }
3902 //
3903                 // Update Tx Power HAL variables.
3904 //
3905                 for (rf_path = 0; rf_path < 2; rf_path++)
3906                 {
3907                         for (i = 0; i < 3; i++)
3908                         {
3909                                 RT_TRACE((COMP_INIT),  "CCK RF-%d CHan_Area-%d = 0x%x\n",  rf_path, i,
3910                                 priv->RfCckChnlAreaTxPwr[rf_path][i]);
3911                                 RT_TRACE((COMP_INIT), "OFDM-1T RF-%d CHan_Area-%d = 0x%x\n",  rf_path, i,
3912                                 priv->RfOfdmChnlAreaTxPwr1T[rf_path][i]);
3913                                 RT_TRACE((COMP_INIT), "OFDM-2T RF-%d CHan_Area-%d = 0x%x\n",  rf_path, i, priv->RfOfdmChnlAreaTxPwr2T[rf_path][i]);
3914                         }
3915
3916                         // Assign dedicated channel tx power
3917                         for(i=0; i<14; i++)     // channel 1~3 use the same Tx Power Level.
3918                         {
3919                                 if (i < 3)                      // Cjanel 1-3
3920                                         index = 0;
3921                                 else if (i < 9)         // Channel 4-9
3922                                         index = 1;
3923                                 else                            // Channel 10-14
3924                                         index = 2;
3925
3926                                 // Record A & B CCK /OFDM - 1T/2T Channel area tx power
3927                                 priv->RfTxPwrLevelCck[rf_path][i]  =
3928                                 priv->RfCckChnlAreaTxPwr[rf_path][index];
3929                                 priv->RfTxPwrLevelOfdm1T[rf_path][i]  =
3930                                 priv->RfOfdmChnlAreaTxPwr1T[rf_path][index];
3931                                 priv->RfTxPwrLevelOfdm2T[rf_path][i]  =
3932                                 priv->RfOfdmChnlAreaTxPwr2T[rf_path][index];
3933                                 if (rf_path == 0)
3934                                 {
3935                                         priv->TxPowerLevelOFDM24G[i] = priv->RfTxPwrLevelOfdm1T[rf_path][i] ;
3936                                         priv->TxPowerLevelCCK[i] = priv->RfTxPwrLevelCck[rf_path][i];
3937                                 }
3938                         }
3939
3940                         for(i=0; i<14; i++)
3941                         {
3942                                 RT_TRACE((COMP_INIT),
3943                                 "Rf-%d TxPwr CH-%d CCK OFDM_1T OFDM_2T= 0x%x/0x%x/0x%x\n",
3944                                 rf_path, i, priv->RfTxPwrLevelCck[rf_path][i],
3945                                 priv->RfTxPwrLevelOfdm1T[rf_path][i] ,
3946                                 priv->RfTxPwrLevelOfdm2T[rf_path][i] );
3947                         }
3948                 }
3949         }
3950
3951         //
3952         // 2009/02/09 Cosa add for new EEPROM format
3953         //
3954         for(i=0; i<14; i++)     // channel 1~3 use the same Tx Power Level.
3955         {
3956                 // Read tx power difference between HT OFDM 20/40 MHZ
3957                 if (i < 3)                      // Cjanel 1-3
3958                         index = 0;
3959                 else if (i < 9)         // Channel 4-9
3960                         index = 1;
3961                 else                            // Channel 10-14
3962                         index = 2;
3963
3964                 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_HT20_DIFF+index])&0xff;
3965                 priv->TxPwrHt20Diff[RF90_PATH_A][i] = (tempval&0xF);
3966                 priv->TxPwrHt20Diff[RF90_PATH_B][i] = ((tempval>>4)&0xF);
3967
3968                 // Read OFDM<->HT tx power diff
3969                 if (i < 3)                      // Cjanel 1-3
3970                         tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_OFDM_DIFF])&0xff;
3971                 else if (i < 9)         // Channel 4-9
3972                         tempval = (*(u8 *)&hwinfo[EEPROM_PwDiff])&0xff;
3973                 else                            // Channel 10-14
3974                         tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_OFDM_DIFF+1])&0xff;
3975
3976                 //cosa tempval = (*(u1Byte *)&hwinfo[EEPROM_TX_PWR_OFDM_DIFF+index])&0xff;
3977                 priv->TxPwrLegacyHtDiff[RF90_PATH_A][i] = (tempval&0xF);
3978                 priv->TxPwrLegacyHtDiff[RF90_PATH_B][i] = ((tempval>>4)&0xF);
3979
3980                 //
3981                 // Read Band Edge tx power offset and check if user enable the ability
3982                 //
3983                 // HT 40 band edge channel
3984                 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE])&0xff;
3985                 priv->TxPwrbandEdgeHt40[RF90_PATH_A][0] = (tempval&0xF);                // Band edge low channel
3986                 priv->TxPwrbandEdgeHt40[RF90_PATH_A][1] =  ((tempval>>4)&0xF);  // Band edge high channel
3987                 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+1])&0xff;
3988                 priv->TxPwrbandEdgeHt40[RF90_PATH_B][0] = (tempval&0xF);                // Band edge low channel
3989                 priv->TxPwrbandEdgeHt40[RF90_PATH_B][1] =  ((tempval>>4)&0xF);  // Band edge high channel
3990                 // HT 20 band edge channel
3991                 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+2])&0xff;
3992                 priv->TxPwrbandEdgeHt20[RF90_PATH_A][0] = (tempval&0xF);                // Band edge low channel
3993                 priv->TxPwrbandEdgeHt20[RF90_PATH_A][1] =  ((tempval>>4)&0xF);  // Band edge high channel
3994                 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+3])&0xff;
3995                 priv->TxPwrbandEdgeHt20[RF90_PATH_B][0] = (tempval&0xF);                // Band edge low channel
3996                 priv->TxPwrbandEdgeHt20[RF90_PATH_B][1] =  ((tempval>>4)&0xF);  // Band edge high channel
3997                 // OFDM band edge channel
3998                 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+4])&0xff;
3999                 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][0] = (tempval&0xF);          // Band edge low channel
4000                 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][1] =  ((tempval>>4)&0xF);    // Band edge high channel
4001                 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+5])&0xff;
4002                 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][0] = (tempval&0xF);          // Band edge low channel
4003                 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][1] =  ((tempval>>4)&0xF);    // Band edge high channel
4004
4005                 priv->TxPwrbandEdgeFlag = (*(u8 *)&hwinfo[TX_PWR_BAND_EDGE_CHK]);
4006         }
4007
4008         for(i=0; i<14; i++)
4009                 RT_TRACE(COMP_INIT, "RF-A Ht20 to HT40 Diff[%d] = 0x%x\n", i, priv->TxPwrHt20Diff[RF90_PATH_A][i]);
4010         for(i=0; i<14; i++)
4011                 RT_TRACE(COMP_INIT,  "RF-A Legacy to Ht40 Diff[%d] = 0x%x\n", i, priv->TxPwrLegacyHtDiff[RF90_PATH_A][i]);
4012         for(i=0; i<14; i++)
4013                 RT_TRACE(COMP_INIT,  "RF-B Ht20 to HT40 Diff[%d] = 0x%x\n", i, priv->TxPwrHt20Diff[RF90_PATH_B][i]);
4014         for(i=0; i<14; i++)
4015                 RT_TRACE(COMP_INIT,  "RF-B Legacy to HT40 Diff[%d] = 0x%x\n", i, priv->TxPwrLegacyHtDiff[RF90_PATH_B][i]);
4016         RT_TRACE(COMP_INIT, "RF-A HT40 band-edge low/high power diff = 0x%x/0x%x\n",
4017                 priv->TxPwrbandEdgeHt40[RF90_PATH_A][0],
4018                 priv->TxPwrbandEdgeHt40[RF90_PATH_A][1]);
4019         RT_TRACE((COMP_INIT&COMP_DBG), "RF-B HT40 band-edge low/high power diff = 0x%x/0x%x\n",
4020                 priv->TxPwrbandEdgeHt40[RF90_PATH_B][0],
4021                 priv->TxPwrbandEdgeHt40[RF90_PATH_B][1]);
4022
4023         RT_TRACE((COMP_INIT&COMP_DBG), "RF-A HT20 band-edge low/high power diff = 0x%x/0x%x\n",
4024                 priv->TxPwrbandEdgeHt20[RF90_PATH_A][0],
4025                 priv->TxPwrbandEdgeHt20[RF90_PATH_A][1]);
4026         RT_TRACE((COMP_INIT&COMP_DBG), "RF-B HT20 band-edge low/high power diff = 0x%x/0x%x\n",
4027                 priv->TxPwrbandEdgeHt20[RF90_PATH_B][0],
4028                 priv->TxPwrbandEdgeHt20[RF90_PATH_B][1]);
4029
4030         RT_TRACE((COMP_INIT&COMP_DBG), "RF-A OFDM band-edge low/high power diff = 0x%x/0x%x\n",
4031                 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][0],
4032                 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][1]);
4033         RT_TRACE((COMP_INIT&COMP_DBG), "RF-B OFDM band-edge low/high power diff = 0x%x/0x%x\n",
4034                 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][0],
4035                 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][1]);
4036         RT_TRACE((COMP_INIT&COMP_DBG), "Band-edge enable flag = %d\n", priv->TxPwrbandEdgeFlag);
4037
4038         //
4039         // Update remained HAL variables.
4040         //
4041         priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
4042         priv->LegacyHTTxPowerDiff = priv->EEPROMTxPowerDiff;
4043         priv->TxPowerDiff = priv->EEPROMTxPowerDiff;
4044         //priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);// Antenna B gain offset to antenna A, bit[3:0]
4045         //priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);// Antenna C gain offset to antenna A, bit[7:4]
4046         priv->CrystalCap = priv->EEPROMCrystalCap;      // CrystalCap, bit[15:12]
4047         priv->ThermalMeter[0] = (priv->EEPROMThermalMeter&0x1f);// ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
4048         priv->LedStrategy = SW_LED_MODE0;
4049
4050         init_rate_adaptive(dev);
4051
4052         RT_TRACE(COMP_INIT, "<==== ReadAdapterInfo8192SUsb\n");
4053
4054         //return RT_STATUS_SUCCESS;
4055 }
4056
4057
4058 //
4059 //      Description:
4060 //              Read HW adapter information by E-Fuse or EEPROM according CR9346 reported.
4061 //
4062 //      Assumption:
4063 //              1. CR9346 regiser has verified.
4064 //              2. PASSIVE_LEVEL (USB interface)
4065 //
4066 //      Created by Roger, 2008.10.21.
4067 //
4068 static void rtl8192SU_read_eeprom_info(struct net_device *dev)
4069 {
4070         struct r8192_priv       *priv = ieee80211_priv(dev);
4071         u8                      tmpU1b;
4072
4073         RT_TRACE(COMP_INIT, "====> ReadAdapterInfo8192SUsb\n");
4074
4075         // Retrieve Chip version.
4076         priv->card_8192_version = (VERSION_8192S)((read_nic_dword(dev, PMC_FSM)>>16)&0xF);
4077         RT_TRACE(COMP_INIT, "Chip Version ID: 0x%2x\n", priv->card_8192_version);
4078
4079         tmpU1b = read_nic_byte(dev, EPROM_CMD);//CR9346
4080
4081         // To check system boot selection.
4082         if (tmpU1b & CmdEERPOMSEL)
4083         {
4084                 RT_TRACE(COMP_INIT, "Boot from EEPROM\n");
4085                 priv->EepromOrEfuse = TRUE;
4086         }
4087         else
4088         {
4089                 RT_TRACE(COMP_INIT, "Boot from EFUSE\n");
4090                 priv->EepromOrEfuse = FALSE;
4091         }
4092
4093         // To check autoload success or not.
4094         if (tmpU1b & CmdEEPROM_En)
4095         {
4096                 RT_TRACE(COMP_INIT, "Autoload OK!!\n");
4097                 priv->AutoloadFailFlag=FALSE;
4098                 rtl8192SU_ReadAdapterInfo8192SUsb(dev);//eeprom or e-fuse
4099         }
4100         else
4101         { // Auto load fail.
4102                 RT_TRACE(COMP_INIT, "AutoLoad Fail reported from CR9346!!\n");
4103                 priv->AutoloadFailFlag=TRUE;
4104                 rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(dev);
4105
4106                 //if (IS_BOOT_FROM_EFUSE(Adapter))
4107                 if(!priv->EepromOrEfuse)
4108                 {
4109                         RT_TRACE(COMP_INIT, "Update shadow map for EFuse future use!!\n");
4110                         EFUSE_ShadowMapUpdate(dev);
4111                 }
4112         }
4113 #ifdef TO_DO_LIST
4114         if((priv->RegChannelPlan >= RT_CHANNEL_DOMAIN_MAX) || (pHalData->EEPROMChannelPlan & EEPROM_CHANNEL_PLAN_BY_HW_MASK))
4115         {
4116                 pMgntInfo->ChannelPlan = HalMapChannelPlan8192S(Adapter, (pHalData->EEPROMChannelPlan & (~(EEPROM_CHANNEL_PLAN_BY_HW_MASK))));
4117                 pMgntInfo->bChnlPlanFromHW = (pHalData->EEPROMChannelPlan & EEPROM_CHANNEL_PLAN_BY_HW_MASK) ? TRUE : FALSE; // User cannot change  channel plan.
4118         }
4119         else
4120         {
4121                 pMgntInfo->ChannelPlan = (RT_CHANNEL_DOMAIN)pMgntInfo->RegChannelPlan;
4122         }
4123
4124         switch(pMgntInfo->ChannelPlan)
4125         {
4126                 case RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN:
4127                 {
4128                         PRT_DOT11D_INFO pDot11dInfo = GET_DOT11D_INFO(pMgntInfo);
4129
4130                         pDot11dInfo->bEnabled = TRUE;
4131                 }
4132                 RT_TRACE(COMP_INIT, DBG_LOUD, ("ReadAdapterInfo8187(): Enable dot11d when RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN!\n"));
4133                 break;
4134         }
4135
4136         RT_TRACE(COMP_INIT, DBG_LOUD, ("RegChannelPlan(%d) EEPROMChannelPlan(%d)", pMgntInfo->RegChannelPlan, pHalData->EEPROMChannelPlan));
4137         RT_TRACE(COMP_INIT, DBG_LOUD, ("ChannelPlan = %d\n" , pMgntInfo->ChannelPlan));
4138
4139         RT_TRACE(COMP_INIT, DBG_LOUD, ("<==== ReadAdapterInfo8192S\n"));
4140 #endif
4141
4142         RT_TRACE(COMP_INIT, "<==== ReadAdapterInfo8192SUsb\n");
4143
4144         //return RT_STATUS_SUCCESS;
4145 }
4146
4147 short rtl8192_get_channel_map(struct net_device * dev)
4148 {
4149         struct r8192_priv *priv = ieee80211_priv(dev);
4150         if(priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN){
4151                 printk("rtl8180_init:Error channel plan! Set to default.\n");
4152                 priv->ChannelPlan= 0;
4153         }
4154         RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
4155
4156         rtl819x_set_channel_map(priv->ChannelPlan, priv);
4157         return 0;
4158 }
4159
4160 short rtl8192_init(struct net_device *dev)
4161 {
4162
4163         struct r8192_priv *priv = ieee80211_priv(dev);
4164
4165         rtl8192_init_priv_variable(dev);
4166         rtl8192_init_priv_lock(priv);
4167         rtl8192_init_priv_task(dev);
4168         rtl8192_get_eeprom_size(dev);
4169         priv->ops->rtl819x_read_eeprom_info(dev);
4170         rtl8192_get_channel_map(dev);
4171         init_hal_dm(dev);
4172         init_timer(&priv->watch_dog_timer);
4173         priv->watch_dog_timer.data = (unsigned long)dev;
4174         priv->watch_dog_timer.function = watch_dog_timer_callback;
4175
4176         //rtl8192_adapter_start(dev);
4177 #ifdef DEBUG_EPROM
4178         dump_eprom(dev);
4179 #endif
4180         return 0;
4181 }
4182
4183 /******************************************************************************
4184  *function:  This function actually only set RRSR, RATR and BW_OPMODE registers
4185  *           not to do all the hw config as its name says
4186  *   input:  net_device dev
4187  *  output:  none
4188  *  return:  none
4189  *  notice:  This part need to modified according to the rate set we filtered
4190  * ****************************************************************************/
4191 void rtl8192_hwconfig(struct net_device* dev)
4192 {
4193         u32 regRATR = 0, regRRSR = 0;
4194         u8 regBwOpMode = 0, regTmp = 0;
4195         struct r8192_priv *priv = ieee80211_priv(dev);
4196
4197 // Set RRSR, RATR, and BW_OPMODE registers
4198         //
4199         switch(priv->ieee80211->mode)
4200         {
4201         case WIRELESS_MODE_B:
4202                 regBwOpMode = BW_OPMODE_20MHZ;
4203                 regRATR = RATE_ALL_CCK;
4204                 regRRSR = RATE_ALL_CCK;
4205                 break;
4206         case WIRELESS_MODE_A:
4207                 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
4208                 regRATR = RATE_ALL_OFDM_AG;
4209                 regRRSR = RATE_ALL_OFDM_AG;
4210                 break;
4211         case WIRELESS_MODE_G:
4212                 regBwOpMode = BW_OPMODE_20MHZ;
4213                 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4214                 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4215                 break;
4216         case WIRELESS_MODE_AUTO:
4217 #ifdef TO_DO_LIST
4218                 if (Adapter->bInHctTest)
4219                 {
4220                     regBwOpMode = BW_OPMODE_20MHZ;
4221                     regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4222                     regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4223                 }
4224                 else
4225 #endif
4226                 {
4227                     regBwOpMode = BW_OPMODE_20MHZ;
4228                     regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4229                     regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4230                 }
4231                 break;
4232         case WIRELESS_MODE_N_24G:
4233                 // It support CCK rate by default.
4234                 // CCK rate will be filtered out only when associated AP does not support it.
4235                 regBwOpMode = BW_OPMODE_20MHZ;
4236                         regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4237                         regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4238                 break;
4239         case WIRELESS_MODE_N_5G:
4240                 regBwOpMode = BW_OPMODE_5G;
4241                 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4242                 regRRSR = RATE_ALL_OFDM_AG;
4243                 break;
4244         }
4245
4246         write_nic_byte(dev, BW_OPMODE, regBwOpMode);
4247         {
4248                 u32 ratr_value = 0;
4249                 ratr_value = regRATR;
4250                 if (priv->rf_type == RF_1T2R)
4251                 {
4252                         ratr_value &= ~(RATE_ALL_OFDM_2SS);
4253                 }
4254                 write_nic_dword(dev, RATR0, ratr_value);
4255                 write_nic_byte(dev, UFWP, 1);
4256         }
4257         regTmp = read_nic_byte(dev, 0x313);
4258         regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
4259         write_nic_dword(dev, RRSR, regRRSR);
4260
4261         //
4262         // Set Retry Limit here
4263         //
4264         write_nic_word(dev, RETRY_LIMIT,
4265                         priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | \
4266                         priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
4267         // Set Contention Window here
4268
4269         // Set Tx AGC
4270
4271         // Set Tx Antenna including Feedback control
4272
4273         // Set Auto Rate fallback control
4274
4275
4276 }
4277
4278
4279 //
4280 //      Description:
4281 //              Initial HW relted registers.
4282 //
4283 //      Assumption:
4284 //              Config RTL8192S USB MAC, we should config MAC before download FW.
4285 //
4286 //      2008.09.03, Added by Roger.
4287 //
4288 static void rtl8192SU_MacConfigBeforeFwDownloadASIC(struct net_device *dev)
4289 {
4290         u8                              tmpU1b;// i;
4291 //      u16                             tmpU2b;
4292 //      u32                             tmpU4b;
4293         u8                              PollingCnt = 20;
4294
4295         RT_TRACE(COMP_INIT, "--->MacConfigBeforeFwDownloadASIC()\n");
4296
4297         //2MAC Initialization for power on sequence, Revised by Roger. 2008.09.03.
4298
4299         //
4300         //<Roger_Notes> Set control path switch to HW control and reset Digital Core,  CPU Core and
4301         // MAC I/O to solve FW download fail when system from resume sate.
4302         // 2008.11.04.
4303         //
4304        tmpU1b = read_nic_byte(dev, SYS_CLKR+1);
4305        if(tmpU1b & 0x80)
4306         {
4307         tmpU1b &= 0x3f;
4308               write_nic_byte(dev, SYS_CLKR+1, tmpU1b);
4309        }
4310         // Clear FW RPWM for FW control LPS. by tynli. 2009.02.23
4311         write_nic_byte(dev, RPWM, 0x0);
4312
4313        tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
4314        tmpU1b &= 0x73;
4315        write_nic_byte(dev, SYS_FUNC_EN+1, tmpU1b);
4316        udelay(1000);
4317
4318         //Revised POS, suggested by SD1 Alex, 2008.09.27.
4319         write_nic_byte(dev, SPS0_CTRL+1, 0x53);
4320         write_nic_byte(dev, SPS0_CTRL, 0x57);
4321
4322         //Enable AFE Macro Block's Bandgap adn Enable AFE Macro Block's Mbias
4323         tmpU1b = read_nic_byte(dev, AFE_MISC);
4324         write_nic_byte(dev, AFE_MISC, (tmpU1b|AFE_BGEN|AFE_MBEN));
4325
4326         //Enable PLL Power (LDOA15V)
4327         tmpU1b = read_nic_byte(dev, LDOA15_CTRL);
4328         write_nic_byte(dev, LDOA15_CTRL, (tmpU1b|LDA15_EN));
4329
4330         //Enable LDOV12D block
4331         tmpU1b = read_nic_byte(dev, LDOV12D_CTRL);
4332         write_nic_byte(dev, LDOV12D_CTRL, (tmpU1b|LDV12_EN));
4333
4334         //mpU1b = read_nic_byte(Adapter, SPS1_CTRL);
4335         //write_nic_byte(dev, SPS1_CTRL, (tmpU1b|SPS1_LDEN));
4336
4337         //PlatformSleepUs(2000);
4338
4339         //Enable Switch Regulator Block
4340         //tmpU1b = read_nic_byte(Adapter, SPS1_CTRL);
4341         //write_nic_byte(dev, SPS1_CTRL, (tmpU1b|SPS1_SWEN));
4342
4343         //write_nic_dword(Adapter, SPS1_CTRL, 0x00a7b267);
4344
4345         tmpU1b = read_nic_byte(dev, SYS_ISO_CTRL+1);
4346         write_nic_byte(dev, SYS_ISO_CTRL+1, (tmpU1b|0x08));
4347
4348         //Engineer Packet CP test Enable
4349         tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
4350         write_nic_byte(dev, SYS_FUNC_EN+1, (tmpU1b|0x20));
4351
4352         //Support 64k IMEM, suggested by SD1 Alex.
4353         tmpU1b = read_nic_byte(dev, SYS_ISO_CTRL+1);
4354         write_nic_byte(dev, SYS_ISO_CTRL+1, (tmpU1b& 0x68));
4355
4356         //Enable AFE clock
4357         tmpU1b = read_nic_byte(dev, AFE_XTAL_CTRL+1);
4358         write_nic_byte(dev, AFE_XTAL_CTRL+1, (tmpU1b& 0xfb));
4359
4360         //Enable AFE PLL Macro Block
4361         tmpU1b = read_nic_byte(dev, AFE_PLL_CTRL);
4362         write_nic_byte(dev, AFE_PLL_CTRL, (tmpU1b|0x11));
4363
4364         //Attatch AFE PLL to MACTOP/BB/PCIe Digital
4365         tmpU1b = read_nic_byte(dev, SYS_ISO_CTRL);
4366         write_nic_byte(dev, SYS_ISO_CTRL, (tmpU1b&0xEE));
4367
4368         // Switch to 40M clock
4369         write_nic_byte(dev, SYS_CLKR, 0x00);
4370
4371         //SSC Disable
4372         tmpU1b = read_nic_byte(dev, SYS_CLKR);
4373         //write_nic_byte(dev, SYS_CLKR, (tmpU1b&0x5f));
4374         write_nic_byte(dev, SYS_CLKR, (tmpU1b|0xa0));
4375
4376         //Enable MAC clock
4377         tmpU1b = read_nic_byte(dev, SYS_CLKR+1);
4378         write_nic_byte(dev, SYS_CLKR+1, (tmpU1b|0x18));
4379
4380         //Revised POS, suggested by SD1 Alex, 2008.09.27.
4381         write_nic_byte(dev, PMC_FSM, 0x02);
4382
4383         //Enable Core digital and enable IOREG R/W
4384         tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
4385         write_nic_byte(dev, SYS_FUNC_EN+1, (tmpU1b|0x08));
4386
4387         //Enable REG_EN
4388         tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
4389         write_nic_byte(dev, SYS_FUNC_EN+1, (tmpU1b|0x80));
4390
4391         //Switch the control path to FW
4392         tmpU1b = read_nic_byte(dev, SYS_CLKR+1);
4393         write_nic_byte(dev, SYS_CLKR+1, (tmpU1b|0x80)& 0xBF);
4394
4395         write_nic_byte(dev, CMDR, 0xFC);
4396         write_nic_byte(dev, CMDR+1, 0x37);
4397
4398         //Fix the RX FIFO issue(usb error), 970410
4399         tmpU1b = read_nic_byte_E(dev, 0x5c);
4400         write_nic_byte_E(dev, 0x5c, (tmpU1b|BIT7));
4401
4402          //For power save, used this in the bit file after 970621
4403         tmpU1b = read_nic_byte(dev, SYS_CLKR);
4404         write_nic_byte(dev, SYS_CLKR, tmpU1b&(~SYS_CPU_CLKSEL));
4405
4406         // Revised for 8051 ROM code wrong operation. Added by Roger. 2008.10.16.
4407         write_nic_byte_E(dev, 0x1c, 0x80);
4408
4409         //
4410         // <Roger_EXP> To make sure that TxDMA can ready to download FW.
4411         // We should reset TxDMA if IMEM RPT was not ready.
4412         // Suggested by SD1 Alex. 2008.10.23.
4413         //
4414         do
4415         {
4416                 tmpU1b = read_nic_byte(dev, TCR);
4417                 if((tmpU1b & TXDMA_INIT_VALUE) == TXDMA_INIT_VALUE)
4418                         break;
4419                 //PlatformStallExecution(5);
4420                 udelay(5);
4421         }while(PollingCnt--);   // Delay 1ms
4422
4423         if(PollingCnt <= 0 )
4424         {
4425                 RT_TRACE(COMP_INIT, "MacConfigBeforeFwDownloadASIC(): Polling TXDMA_INIT_VALUE timeout!! Current TCR(%#x)\n", tmpU1b);
4426                 tmpU1b = read_nic_byte(dev, CMDR);
4427                 write_nic_byte(dev, CMDR, tmpU1b&(~TXDMA_EN));
4428                 udelay(2);
4429                 write_nic_byte(dev, CMDR, tmpU1b|TXDMA_EN);// Reset TxDMA
4430         }
4431
4432
4433         RT_TRACE(COMP_INIT, "<---MacConfigBeforeFwDownloadASIC()\n");
4434 }
4435
4436 //
4437 //      Description:
4438 //              Initial HW relted registers.
4439 //
4440 //      Assumption:
4441 //              1. This function is only invoked at driver intialization once.
4442 //              2. PASSIVE LEVEL.
4443 //
4444 //      2008.06.10, Added by Roger.
4445 //
4446 static void rtl8192SU_MacConfigAfterFwDownload(struct net_device *dev)
4447 {
4448         struct r8192_priv *priv = ieee80211_priv((struct net_device *)dev);
4449         //PRT_HIGH_THROUGHPUT   pHTInfo = priv->ieee80211->pHTInfo;
4450         //u8    tmpU1b, RxPageCfg, i;
4451         u16     tmpU2b;
4452         u8      tmpU1b;//, i;
4453
4454
4455         RT_TRACE(COMP_INIT, "--->MacConfigAfterFwDownload()\n");
4456
4457         // Enable Tx/Rx
4458         tmpU2b = (BBRSTn|BB_GLB_RSTn|SCHEDULE_EN|MACRXEN|MACTXEN|DDMA_EN|
4459                          FW2HW_EN|RXDMA_EN|TXDMA_EN|HCI_RXDMA_EN|HCI_TXDMA_EN);         //3
4460         //Adapter->HalFunc.SetHwRegHandler( Adapter, HW_VAR_COMMAND, &tmpU1b );
4461         write_nic_word(dev, CMDR, tmpU2b); //LZM REGISTER COM 090305
4462
4463         // Loopback mode or not
4464         priv->LoopbackMode = RTL8192SU_NO_LOOPBACK; // Set no loopback as default.
4465         if(priv->LoopbackMode == RTL8192SU_NO_LOOPBACK)
4466                 tmpU1b = LBK_NORMAL;
4467         else if (priv->LoopbackMode == RTL8192SU_MAC_LOOPBACK )
4468                 tmpU1b = LBK_MAC_DLB;
4469         else
4470                 RT_TRACE(COMP_INIT, "Serious error: wrong loopback mode setting\n");
4471
4472         //Adapter->HalFunc.SetHwRegHandler( Adapter, HW_VAR_LBK_MODE, &tmpU1b);
4473         write_nic_byte(dev, LBKMD_SEL, tmpU1b);
4474
4475         // Set RCR
4476         write_nic_dword(dev, RCR, priv->ReceiveConfig);
4477         RT_TRACE(COMP_INIT, "MacConfigAfterFwDownload(): Current RCR settings(%#x)\n", priv->ReceiveConfig);
4478
4479
4480         // Set RQPN
4481         //
4482         // <Roger_Notes> 2008.08.18.
4483         // 6 endpoints:
4484         // (1) Page number on CMDQ is 0x03.
4485         // (2) Page number on BCNQ, HQ and MGTQ is 0.
4486         // (3) Page number on BKQ, BEQ, VIQ and VOQ are 0x07.
4487         // (4) Page number on PUBQ is 0xdd
4488         //
4489         // 11 endpoints:
4490         // (1) Page number on CMDQ is 0x00.
4491         // (2) Page number on BCNQ is 0x02, HQ and MGTQ are 0x03.
4492         // (3) Page number on BKQ, BEQ, VIQ and VOQ are 0x07.
4493         // (4) Page number on PUBQ is 0xd8
4494         //
4495         //write_nic_dword(Adapter, 0xa0, 0x07070707); //BKQ, BEQ, VIQ and VOQ
4496         //write_nic_byte(dev, 0xa4, 0x00); // HCCAQ
4497
4498         // Fix the RX FIFO issue(USB error), Rivesed by Roger, 2008-06-14
4499         tmpU1b = read_nic_byte_E(dev, 0x5C);
4500         write_nic_byte_E(dev, 0x5C, tmpU1b|BIT7);
4501
4502         // For EFUSE init configuration.
4503         //if (IS_BOOT_FROM_EFUSE(Adapter))      // We may R/W EFUSE in EFUSE mode
4504         if (priv->bBootFromEfuse)
4505         {
4506                 u8      tempval;
4507
4508                 tempval = read_nic_byte(dev, SYS_ISO_CTRL+1);
4509                 tempval &= 0xFE;
4510                 write_nic_byte(dev, SYS_ISO_CTRL+1, tempval);
4511
4512                 // Enable LDO 2.5V for write action
4513                 //tempval = read_nic_byte(Adapter, EFUSE_TEST+3);
4514                 //write_nic_byte(Adapter, EFUSE_TEST+3, (tempval | 0x80));
4515
4516                 // Change Efuse Clock for write action
4517                 //write_nic_byte(Adapter, EFUSE_CLK, 0x03);
4518
4519                 // Change Program timing
4520                 write_nic_byte(dev, EFUSE_CTRL+3, 0x72);
4521                 //printk("!!!!!!!!!!!!!!!!!!!!!%s: write 0x33 with 0x72\n",__FUNCTION__);
4522                 RT_TRACE(COMP_INIT, "EFUSE CONFIG OK\n");
4523         }
4524
4525
4526         RT_TRACE(COMP_INIT, "<---MacConfigAfterFwDownload()\n");
4527 }
4528
4529 void rtl8192SU_HwConfigureRTL8192SUsb(struct net_device *dev)
4530 {
4531
4532         struct r8192_priv *priv = ieee80211_priv(dev);
4533         u8                      regBwOpMode = 0;
4534         u32                     regRATR = 0, regRRSR = 0;
4535         u8                      regTmp = 0;
4536         u32                     i = 0;
4537
4538         //1 This part need to modified according to the rate set we filtered!!
4539         //
4540         // Set RRSR, RATR, and BW_OPMODE registers
4541         //
4542         switch(priv->ieee80211->mode)
4543         {
4544         case WIRELESS_MODE_B:
4545                 regBwOpMode = BW_OPMODE_20MHZ;
4546                 regRATR = RATE_ALL_CCK;
4547                 regRRSR = RATE_ALL_CCK;
4548                 break;
4549         case WIRELESS_MODE_A:
4550                 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
4551                 regRATR = RATE_ALL_OFDM_AG;
4552                 regRRSR = RATE_ALL_OFDM_AG;
4553                 break;
4554         case WIRELESS_MODE_G:
4555                 regBwOpMode = BW_OPMODE_20MHZ;
4556                 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4557                 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4558                 break;
4559         case WIRELESS_MODE_AUTO:
4560                 if (priv->bInHctTest)
4561                 {
4562                     regBwOpMode = BW_OPMODE_20MHZ;
4563                     regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4564                     regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4565                 }
4566                 else
4567                 {
4568                     regBwOpMode = BW_OPMODE_20MHZ;
4569                     regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4570                     regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4571                 }
4572                 break;
4573         case WIRELESS_MODE_N_24G:
4574                 // It support CCK rate by default.
4575                 // CCK rate will be filtered out only when associated AP does not support it.
4576                 regBwOpMode = BW_OPMODE_20MHZ;
4577                         regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4578                         regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4579                 break;
4580         case WIRELESS_MODE_N_5G:
4581                 regBwOpMode = BW_OPMODE_5G;
4582                 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4583                 regRRSR = RATE_ALL_OFDM_AG;
4584                 break;
4585         }
4586
4587         //
4588         // <Roger_Notes> We disable CCK response rate until FIB CCK rate IC's back.
4589         // 2008.09.23.
4590         //
4591         regTmp = read_nic_byte(dev, INIRTSMCS_SEL);
4592         regRRSR = ((regRRSR & 0x000fffff)<<8) | regTmp;
4593
4594         //
4595         // Update SIFS timing.
4596         //
4597         //priv->SifsTime = 0x0e0e0a0a;
4598         //Adapter->HalFunc.SetHwRegHandler( Adapter, HW_VAR_SIFS,  (pu1Byte)&pHalData->SifsTime);
4599         {       u8 val[4] = {0x0e, 0x0e, 0x0a, 0x0a};
4600                 // SIFS for CCK Data ACK
4601                 write_nic_byte(dev, SIFS_CCK, val[0]);
4602                 // SIFS for CCK consecutive tx like CTS data!
4603                 write_nic_byte(dev, SIFS_CCK+1, val[1]);
4604
4605                 // SIFS for OFDM Data ACK
4606                 write_nic_byte(dev, SIFS_OFDM, val[2]);
4607                 // SIFS for OFDM consecutive tx like CTS data!
4608                 write_nic_byte(dev, SIFS_OFDM+1, val[3]);
4609         }
4610
4611         write_nic_dword(dev, INIRTSMCS_SEL, regRRSR);
4612         write_nic_byte(dev, BW_OPMODE, regBwOpMode);
4613
4614         //
4615         // Suggested by SD1 Alex, 2008-06-14.
4616         //
4617         //PlatformEFIOWrite1Byte(Adapter, TXOP_STALL_CTRL, 0x80);//NAV to protect all TXOP.
4618
4619         //
4620         // Set Data Auto Rate Fallback Retry Count register.
4621         //
4622         write_nic_dword(dev, DARFRC, 0x02010000);
4623         write_nic_dword(dev, DARFRC+4, 0x06050403);
4624         write_nic_dword(dev, RARFRC, 0x02010000);
4625         write_nic_dword(dev, RARFRC+4, 0x06050403);
4626
4627         // Set Data Auto Rate Fallback Reg. Added by Roger, 2008.09.22.
4628         for (i = 0; i < 8; i++)
4629                 write_nic_dword(dev, ARFR0+i*4, 0x1f0ffff0);
4630
4631         //
4632         // Aggregation length limit. Revised by Roger. 2008.09.22.
4633         //
4634         write_nic_byte(dev, AGGLEN_LMT_H, 0x0f);        // Set AMPDU length to 12Kbytes for ShortGI case.
4635         write_nic_dword(dev, AGGLEN_LMT_L, 0xddd77442); // Long GI
4636         write_nic_dword(dev, AGGLEN_LMT_L+4, 0xfffdd772);
4637
4638         // Set NAV protection length
4639         write_nic_word(dev, NAV_PROT_LEN, 0x0080);
4640
4641         // Set TXOP stall control for several queue/HI/BCN/MGT/
4642         write_nic_byte(dev, TXOP_STALL_CTRL, 0x00); // NAV Protect next packet.
4643
4644         // Set MSDU lifetime.
4645         write_nic_byte(dev, MLT, 0x8f);
4646
4647         // Set CCK/OFDM SIFS
4648         write_nic_word(dev, SIFS_CCK, 0x0a0a); // CCK SIFS shall always be 10us.
4649         write_nic_word(dev, SIFS_OFDM, 0x0e0e);
4650
4651         write_nic_byte(dev, ACK_TIMEOUT, 0x40);
4652
4653         // CF-END Threshold
4654         write_nic_byte(dev, CFEND_TH, 0xFF);
4655
4656         //
4657         // For Min Spacing configuration.
4658         //
4659         switch(priv->rf_type)
4660         {
4661                 case RF_1T2R:
4662                 case RF_1T1R:
4663                         RT_TRACE(COMP_INIT, "Initializeadapter: RF_Type%s\n", (priv->rf_type==RF_1T1R? "(1T1R)":"(1T2R)"));
4664                         priv->MinSpaceCfg = (MAX_MSS_DENSITY_1T<<3);
4665                         break;
4666                 case RF_2T2R:
4667                 case RF_2T2R_GREEN:
4668                         RT_TRACE(COMP_INIT, "Initializeadapter:RF_Type(2T2R)\n");
4669                         priv->MinSpaceCfg = (MAX_MSS_DENSITY_2T<<3);
4670                         break;
4671         }
4672         write_nic_byte(dev, AMPDU_MIN_SPACE, priv->MinSpaceCfg);
4673
4674         //LZM 090219
4675         //
4676         // For Min Spacing configuration.
4677         //
4678         //priv->MinSpaceCfg = 0x00;
4679         //rtl8192SU_SetHwRegAmpduMinSpace(dev, priv->MinSpaceCfg);
4680 }
4681
4682
4683 //      Description:    Initial HW relted registers.
4684 //
4685 //      Assumption:     This function is only invoked at driver intialization once.
4686 //
4687 //      2008.06.10, Added by Roger.
4688 bool rtl8192SU_adapter_start(struct net_device *dev)
4689 {
4690         struct r8192_priv *priv = ieee80211_priv(dev);
4691         //u32                                   dwRegRead = 0;
4692         //bool                                  init_status = true;
4693         //u32                                   ulRegRead;
4694         bool                                            rtStatus = true;
4695         //u8                                    PipeIndex;
4696         //u8                                    eRFPath, tmpU1b;
4697         u8 fw_download_times = 1;
4698
4699
4700         RT_TRACE(COMP_INIT, "--->InitializeAdapter8192SUsb()\n");
4701
4702         //pHalData->bGPIOChangeRF = FALSE;
4703
4704
4705         //
4706         // <Roger_Notes> 2008.06.15.
4707         //
4708         // Initialization Steps on RTL8192SU:
4709         // a. MAC initialization prior to sending down firmware code.
4710         // b. Download firmware code step by step(i.e., IMEM, EMEM, DMEM).
4711         // c. MAC configuration after firmware has been download successfully.
4712         // d. Initialize BB related configurations.
4713         // e. Initialize RF related configurations.
4714         // f.  Start to BulkIn transfer.
4715         //
4716
4717         //
4718         //a. MAC initialization prior to send down firmware code.
4719         //
4720 start:
4721         rtl8192SU_MacConfigBeforeFwDownloadASIC(dev);
4722
4723         //
4724         //b. Download firmware code step by step(i.e., IMEM, EMEM, DMEM).
4725         //
4726         rtStatus = FirmwareDownload92S(dev);
4727         if(rtStatus != true)
4728         {
4729                 if(fw_download_times == 1){
4730                         RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Download Firmware failed once, Download again!!\n");
4731                         fw_download_times = fw_download_times + 1;
4732                         goto start;
4733                 }else{
4734                         RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Download Firmware failed twice, end!!\n");
4735                 goto end;
4736         }
4737         }
4738         //
4739         //c. MAC configuration after firmware has been download successfully.
4740         //
4741         rtl8192SU_MacConfigAfterFwDownload(dev);
4742
4743         //priv->bLbusEnable = TRUE;
4744         //if(priv->RegRfOff == TRUE)
4745         //      priv->eRFPowerState = eRfOff;
4746
4747         // Save target channel
4748         // <Roger_Notes> Current Channel will be updated again later.
4749         //priv->CurrentChannel = Channel;
4750         rtStatus = PHY_MACConfig8192S(dev);//===>ok
4751         if(rtStatus != true)
4752         {
4753                 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Fail to configure MAC!!\n");
4754                 goto end;
4755         }
4756         if (1){
4757                 int i;
4758                 for (i=0; i<4; i++)
4759                         write_nic_dword(dev,WDCAPARA_ADD[i], 0x5e4322);
4760                 write_nic_byte(dev,AcmHwCtrl, 0x01);
4761         }
4762
4763
4764         //
4765         //d. Initialize BB related configurations.
4766         //
4767
4768         rtStatus = PHY_BBConfig8192S(dev);//===>ok
4769         if(rtStatus != true)
4770         {
4771                 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Fail to configure BB!!\n");
4772                 goto end;
4773         }
4774
4775         rtl8192_setBBreg(dev, rFPGA0_AnalogParameter2, 0xff, 0x58);//===>ok
4776
4777         //
4778         // e. Initialize RF related configurations.
4779         //
4780         // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
4781         priv->Rf_Mode = RF_OP_By_SW_3wire;
4782
4783         // For RF test only from Scott's suggestion
4784         //write_nic_byte(dev, 0x27, 0xDB);
4785         //write_nic_byte(dev, 0x1B, 0x07);
4786
4787
4788         write_nic_byte(dev, AFE_XTAL_CTRL+1, 0xDB);
4789
4790         // <Roger_Notes> The following IOs are configured for each RF modules.
4791         // Enable RF module and reset RF and SDM module. 2008.11.17.
4792         if(priv->card_8192_version == VERSION_8192S_ACUT)
4793                 write_nic_byte(dev, SPS1_CTRL+3, (u8)(RF_EN|RF_RSTB|RF_SDMRSTB)); // Fix A-Cut bug.
4794         else
4795                 write_nic_byte(dev, RF_CTRL, (u8)(RF_EN|RF_RSTB|RF_SDMRSTB));
4796
4797         rtStatus = PHY_RFConfig8192S(dev);//===>ok
4798         if(rtStatus != true)
4799         {
4800                 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Fail to configure RF!!\n");
4801                 goto end;
4802         }
4803
4804
4805         // Set CCK and OFDM Block "ON"
4806         rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
4807         rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
4808
4809         //
4810         // Turn off Radio B while RF type is 1T1R by SD3 Wilsion's request.
4811         // Revised by Roger, 2008.12.18.
4812         //
4813         if(priv->rf_type == RF_1T1R)
4814         {
4815                 // This is needed for PHY_REG after 20081219
4816                 rtl8192_setBBreg(dev, rFPGA0_RFMOD, 0xff000000, 0x03);
4817                 // This is needed for PHY_REG before 20081219
4818                 //PHY_SetBBReg(Adapter, rOFDM0_TRxPathEnable, bMaskByte0, 0x11);
4819         }
4820
4821
4822         //LZM 090219
4823         // Set CCK and OFDM Block "ON"
4824         //rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
4825         //rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
4826
4827
4828         //3//Get hardware version, do it in read eeprom?
4829         //GetHardwareVersion819xUsb(Adapter);
4830
4831         //3//
4832         //3 //Set Hardware
4833         //3//
4834         rtl8192SU_HwConfigureRTL8192SUsb(dev);//==>ok
4835
4836         //
4837         // <Roger_Notes> We set MAC address here if autoload was failed before,
4838         // otherwise IDR0 will NOT contain any value.
4839         //
4840         write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
4841         write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
4842         if(!priv->bInHctTest)
4843         {
4844                 if(priv->ResetProgress == RESET_TYPE_NORESET)
4845                 {
4846                         //RT_TRACE(COMP_MLME, DBG_LOUD, ("Initializeadapter8192SUsb():RegWirelessMode(%#x) \n", Adapter->RegWirelessMode));
4847                         //Adapter->HalFunc.SetWirelessModeHandler(Adapter, Adapter->RegWirelessMode);
4848                         rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);//===>ok
4849                 }
4850         }
4851         else
4852         {
4853                 priv->ieee80211->mode = WIRELESS_MODE_G;
4854                 rtl8192_SetWirelessMode(dev, WIRELESS_MODE_G);
4855         }
4856
4857         //Security related.
4858         //-----------------------------------------------------------------------------
4859         // Set up security related. 070106, by rcnjko:
4860         // 1. Clear all H/W keys.
4861         // 2. Enable H/W encryption/decryption.
4862         //-----------------------------------------------------------------------------
4863         //CamResetAllEntry(Adapter);
4864         //Adapter->HalFunc.EnableHWSecCfgHandler(Adapter);
4865
4866         //SecClearAllKeys(Adapter);
4867         CamResetAllEntry(dev);
4868         //SecInit(Adapter);
4869         {
4870                 u8 SECR_value = 0x0;
4871                 SECR_value |= SCR_TxEncEnable;
4872                 SECR_value |= SCR_RxDecEnable;
4873                 SECR_value |= SCR_NoSKMC;
4874                 write_nic_byte(dev, SECR, SECR_value);
4875         }
4876
4877 #ifdef TO_DO_LIST
4878
4879         //PHY_UpdateInitialGain(dev);
4880
4881         if(priv->RegRfOff == true)
4882         { // User disable RF via registry.
4883                 u8 eRFPath = 0;
4884
4885                 RT_TRACE((COMP_INIT|COMP_RF), "InitializeAdapter8192SUsb(): Turn off RF for RegRfOff ----------\n");
4886                 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW);
4887                 // Those action will be discard in MgntActSet_RF_State because off the same state
4888                 for(eRFPath = 0; eRFPath <priv->NumTotalRFPath; eRFPath++)
4889                         rtl8192_setBBreg(dev, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
4890         }
4891         else if(priv->RfOffReason > RF_CHANGE_BY_PS)
4892         { // H/W or S/W RF OFF before sleep.
4893                 RT_TRACE((COMP_INIT|COMP_RF), "InitializeAdapter8192SUsb(): Turn off RF for RfOffReason(%d) ----------\n", priv->RfOffReason);
4894                 MgntActSet_RF_State(dev, eRfOff, priv->RfOffReason);
4895         }
4896         else
4897         {
4898                 priv->eRFPowerState = eRfOn;
4899                 priv->RfOffReason = 0;
4900                 RT_TRACE((COMP_INIT|COMP_RF), "InitializeAdapter8192SUsb(): RF is on ----------\n");
4901         }
4902
4903 #endif
4904
4905
4906 //
4907 // f. Start to BulkIn transfer.
4908 //
4909 #ifdef TO_DO_LIST
4910
4911 #ifndef UNDER_VISTA
4912         {
4913                 u8      i;
4914                 PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
4915
4916                 for(PipeIndex=0; PipeIndex < MAX_RX_QUEUE; PipeIndex++)
4917                 {
4918                         if (PipeIndex == 0)
4919                         {
4920                                 for(i=0; i<32; i++)
4921                                 HalUsbInMpdu(Adapter, PipeIndex);
4922                         }
4923                         else
4924                         {
4925                                 //HalUsbInMpdu(Adapter, PipeIndex);
4926                                 //HalUsbInMpdu(Adapter, PipeIndex);
4927                                 //HalUsbInMpdu(Adapter, PipeIndex);
4928                         }
4929                 }
4930                 PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
4931         }
4932 #else
4933                 // Joseph add to 819X code base for Vista USB platform.
4934                 // This part may need to be add to Hal819xU code base. too.
4935                 PlatformUsbEnableInPipes(Adapter);
4936 #endif
4937
4938         RT_TRACE(COMP_INIT, "HighestOperaRate = %x\n", Adapter->MgntInfo.HighestOperaRate);
4939
4940         PlatformStartWorkItem( &(pHalData->RtUsbCheckForHangWorkItem) );
4941
4942         //
4943         // <Roger_EXP> The following  configurations are for ASIC verification temporally.
4944         // 2008.07.10.
4945         //
4946
4947 #endif
4948
4949         //
4950         // Read EEPROM TX power index and PHY_REG_PG.txt to capture correct
4951         // TX power index for different rate set.
4952         //
4953         //if(priv->card_8192_version >= VERSION_8192S_ACUT)
4954         {
4955                 // Get original hw reg values
4956                 PHY_GetHWRegOriginalValue(dev);
4957
4958                 // Write correct tx power index//FIXLZM
4959                 PHY_SetTxPowerLevel8192S(dev, priv->chan);
4960         }
4961
4962         {
4963         u8  tmpU1b = 0;
4964         // EEPROM R/W workaround
4965         tmpU1b = read_nic_byte(dev, MAC_PINMUX_CFG);
4966         write_nic_byte(dev, MAC_PINMUX_CFG, tmpU1b&(~GPIOMUX_EN));
4967         }
4968
4969 //
4970 //<Roger_Notes> 2008.08.19.
4971 // We return status here for temporal FPGA verification, 2008.08.19.
4972
4973 #ifdef RTL8192SU_FW_IQK
4974         write_nic_dword(dev, WFM5, FW_IQK_ENABLE);
4975         ChkFwCmdIoDone(dev);
4976 #endif
4977
4978         //
4979         // <Roger_Notes> We enable high power mechanism after NIC initialized.
4980         // 2008.11.27.
4981         //
4982         write_nic_dword(dev, WFM5, FW_RA_RESET);
4983         ChkFwCmdIoDone(dev);
4984         write_nic_dword(dev, WFM5, FW_RA_ACTIVE);
4985         ChkFwCmdIoDone(dev);
4986         write_nic_dword(dev, WFM5, FW_RA_REFRESH);
4987         ChkFwCmdIoDone(dev);
4988         write_nic_dword(dev, WFM5, FW_BB_RESET_ENABLE);
4989
4990 // <Roger_Notes> We return status here for temporal FPGA verification. 2008.05.12.
4991 //
4992
4993 end:
4994 return rtStatus;
4995 }
4996
4997 /***************************************************************************
4998     -------------------------------NET STUFF---------------------------
4999 ***************************************************************************/
5000
5001 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
5002 {
5003         struct r8192_priv *priv = ieee80211_priv(dev);
5004
5005         return &priv->ieee80211->stats;
5006 }
5007
5008 bool
5009 HalTxCheckStuck819xUsb(
5010         struct net_device *dev
5011         )
5012 {
5013         struct r8192_priv *priv = ieee80211_priv(dev);
5014         u16             RegTxCounter = read_nic_word(dev, 0x128);
5015         bool            bStuck = FALSE;
5016         RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
5017         if(priv->TxCounter==RegTxCounter)
5018                 bStuck = TRUE;
5019
5020         priv->TxCounter = RegTxCounter;
5021
5022         return bStuck;
5023 }
5024
5025 /*
5026 *       <Assumption: RT_TX_SPINLOCK is acquired.>
5027 *       First added: 2006.11.19 by emily
5028 */
5029 RESET_TYPE
5030 TxCheckStuck(struct net_device *dev)
5031 {
5032         struct r8192_priv *priv = ieee80211_priv(dev);
5033         u8                      QueueID;
5034 //      PRT_TCB                 pTcb;
5035 //      u8                      ResetThreshold;
5036         bool                    bCheckFwTxCnt = false;
5037         //unsigned long flags;
5038
5039         //
5040         // Decide Stuch threshold according to current power save mode
5041         //
5042
5043 //     RT_TRACE(COMP_RESET, " ==> TxCheckStuck()\n");
5044 //           PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK);
5045 //           spin_lock_irqsave(&priv->ieee80211->lock,flags);
5046              for (QueueID = 0; QueueID<=BEACON_QUEUE;QueueID ++)
5047              {
5048                         if(QueueID == TXCMD_QUEUE)
5049                          continue;
5050 #if 1
5051                         if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0)  && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
5052                                 continue;
5053 #endif
5054
5055                      bCheckFwTxCnt = true;
5056              }
5057 //           PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
5058 //      spin_unlock_irqrestore(&priv->ieee80211->lock,flags);
5059 //      RT_TRACE(COMP_RESET,"bCheckFwTxCnt is %d\n",bCheckFwTxCnt);
5060 #if 1
5061         if(bCheckFwTxCnt)
5062         {
5063                 if(HalTxCheckStuck819xUsb(dev))
5064                 {
5065                         RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
5066                         return RESET_TYPE_SILENT;
5067                 }
5068         }
5069 #endif
5070         return RESET_TYPE_NORESET;
5071 }
5072
5073 bool
5074 HalRxCheckStuck819xUsb(struct net_device *dev)
5075 {
5076         u16     RegRxCounter = read_nic_word(dev, 0x130);
5077         struct r8192_priv *priv = ieee80211_priv(dev);
5078         bool bStuck = FALSE;
5079 //#ifdef RTL8192SU
5080
5081 //#else
5082         static u8       rx_chk_cnt = 0;
5083         RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
5084         // If rssi is small, we should check rx for long time because of bad rx.
5085         // or maybe it will continuous silent reset every 2 seconds.
5086         rx_chk_cnt++;
5087         if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
5088         {
5089                 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
5090         }
5091         else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
5092                 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
5093                 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
5094         {
5095                 if(rx_chk_cnt < 2)
5096                 {
5097                         return bStuck;
5098                 }
5099                 else
5100                 {
5101                         rx_chk_cnt = 0;
5102                 }
5103         }
5104         else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
5105                 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
5106                 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
5107         {
5108                 if(rx_chk_cnt < 4)
5109                 {
5110                         //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
5111                         return bStuck;
5112                 }
5113                 else
5114                 {
5115                         rx_chk_cnt = 0;
5116                         //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
5117                 }
5118         }
5119         else
5120         {
5121                 if(rx_chk_cnt < 8)
5122                 {
5123                         //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
5124                         return bStuck;
5125                 }
5126                 else
5127                 {
5128                         rx_chk_cnt = 0;
5129                         //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
5130                 }
5131         }
5132 //#endif
5133
5134         if(priv->RxCounter==RegRxCounter)
5135                 bStuck = TRUE;
5136
5137         priv->RxCounter = RegRxCounter;
5138
5139         return bStuck;
5140 }
5141
5142 RESET_TYPE
5143 RxCheckStuck(struct net_device *dev)
5144 {
5145         struct r8192_priv *priv = ieee80211_priv(dev);
5146         //int                     i;
5147         bool        bRxCheck = FALSE;
5148
5149 //       RT_TRACE(COMP_RESET," ==> RxCheckStuck()\n");
5150         //PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
5151
5152          if(priv->IrpPendingCount > 1)
5153                 bRxCheck = TRUE;
5154        //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
5155
5156 //       RT_TRACE(COMP_RESET,"bRxCheck is %d \n",bRxCheck);
5157         if(bRxCheck)
5158         {
5159                 if(HalRxCheckStuck819xUsb(dev))
5160                 {
5161                         RT_TRACE(COMP_RESET, "RxStuck Condition\n");
5162                         return RESET_TYPE_SILENT;
5163                 }
5164         }
5165         return RESET_TYPE_NORESET;
5166 }
5167
5168
5169 /**
5170 *       This function is called by Checkforhang to check whether we should ask OS to reset driver
5171 *
5172 *       \param pAdapter The adapter context for this miniport
5173 *
5174 *       Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
5175 *       to judge whether there is tx stuck.
5176 *       Note: This function may be required to be rewrite for Vista OS.
5177 *       <<<Assumption: Tx spinlock has been acquired >>>
5178 *
5179 *       8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
5180 */
5181 RESET_TYPE
5182 rtl819x_ifcheck_resetornot(struct net_device *dev)
5183 {
5184         struct r8192_priv *priv = ieee80211_priv(dev);
5185         RESET_TYPE      TxResetType = RESET_TYPE_NORESET;
5186         RESET_TYPE      RxResetType = RESET_TYPE_NORESET;
5187         RT_RF_POWER_STATE       rfState;
5188
5189         return RESET_TYPE_NORESET;
5190
5191         rfState = priv->ieee80211->eRFPowerState;
5192
5193         TxResetType = TxCheckStuck(dev);
5194 #if 1
5195         if( rfState != eRfOff ||
5196                 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
5197                 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
5198         {
5199                 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
5200                 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
5201                 // if driver is in firmware download failure status, driver should initialize RF in the following
5202                 // silent reset procedure Emily, 2008.01.21
5203
5204                 // Driver should not check RX stuck in IBSS mode because it is required to
5205                 // set Check BSSID in order to send beacon, however, if check BSSID is
5206                 // set, STA cannot hear any packet a all. Emily, 2008.04.12
5207                 RxResetType = RxCheckStuck(dev);
5208         }
5209 #endif
5210         if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
5211                 return RESET_TYPE_NORMAL;
5212         else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT){
5213                 RT_TRACE(COMP_RESET,"%s():silent reset\n",__FUNCTION__);
5214                 return RESET_TYPE_SILENT;
5215         }
5216         else
5217                 return RESET_TYPE_NORESET;
5218
5219 }
5220
5221 void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
5222 int _rtl8192_up(struct net_device *dev);
5223 int rtl8192_close(struct net_device *dev);
5224
5225
5226
5227 void
5228 CamRestoreAllEntry(     struct net_device *dev)
5229 {
5230         u8 EntryId = 0;
5231         struct r8192_priv *priv = ieee80211_priv(dev);
5232         u8*     MacAddr = priv->ieee80211->current_network.bssid;
5233
5234         static u8       CAM_CONST_ADDR[4][6] = {
5235                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
5236                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
5237                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
5238                 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
5239         static u8       CAM_CONST_BROAD[] =
5240                 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
5241
5242         RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
5243
5244
5245         if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
5246             (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
5247         {
5248
5249                 for(EntryId=0; EntryId<4; EntryId++)
5250                 {
5251                         {
5252                                 MacAddr = CAM_CONST_ADDR[EntryId];
5253                                 setKey(dev,
5254                                                 EntryId ,
5255                                                 EntryId,
5256                                                 priv->ieee80211->pairwise_key_type,
5257                                                 MacAddr,
5258                                                 0,
5259                                                 NULL);
5260                         }
5261                 }
5262
5263         }
5264         else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
5265         {
5266
5267                 {
5268                         if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
5269                                 setKey(dev,
5270                                                 4,
5271                                                 0,
5272                                                 priv->ieee80211->pairwise_key_type,
5273                                                 (u8*)dev->dev_addr,
5274                                                 0,
5275                                                 NULL);
5276                         else
5277                                 setKey(dev,
5278                                                 4,
5279                                                 0,
5280                                                 priv->ieee80211->pairwise_key_type,
5281                                                 MacAddr,
5282                                                 0,
5283                                                 NULL);
5284                 }
5285         }
5286         else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
5287         {
5288
5289                 {
5290                         if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
5291                                 setKey(dev,
5292                                                 4,
5293                                                 0,
5294                                                 priv->ieee80211->pairwise_key_type,
5295                                                 (u8*)dev->dev_addr,
5296                                                 0,
5297                                                 NULL);
5298                         else
5299                                 setKey(dev,
5300                                                 4,
5301                                                 0,
5302                                                 priv->ieee80211->pairwise_key_type,
5303                                                 MacAddr,
5304                                                 0,
5305                                                 NULL);
5306                 }
5307         }
5308
5309
5310
5311         if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
5312         {
5313                 MacAddr = CAM_CONST_BROAD;
5314                 for(EntryId=1 ; EntryId<4 ; EntryId++)
5315                 {
5316                         {
5317                                 setKey(dev,
5318                                                 EntryId,
5319                                                 EntryId,
5320                                                 priv->ieee80211->group_key_type,
5321                                                 MacAddr,
5322                                                 0,
5323                                                 NULL);
5324                         }
5325                 }
5326                 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
5327                                 setKey(dev,
5328                                                 0,
5329                                                 0,
5330                                                 priv->ieee80211->group_key_type,
5331                                                 CAM_CONST_ADDR[0],
5332                                                 0,
5333                                                 NULL);
5334         }
5335         else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
5336         {
5337                 MacAddr = CAM_CONST_BROAD;
5338                 for(EntryId=1; EntryId<4 ; EntryId++)
5339                 {
5340                         {
5341                                 setKey(dev,
5342                                                 EntryId ,
5343                                                 EntryId,
5344                                                 priv->ieee80211->group_key_type,
5345                                                 MacAddr,
5346                                                 0,
5347                                                 NULL);
5348                         }
5349                 }
5350
5351                 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
5352                                 setKey(dev,
5353                                                 0 ,
5354                                                 0,
5355                                                 priv->ieee80211->group_key_type,
5356                                                 CAM_CONST_ADDR[0],
5357                                                 0,
5358                                                 NULL);
5359         }
5360 }
5361 //////////////////////////////////////////////////////////////
5362 // This function is used to fix Tx/Rx stop bug temporarily.
5363 // This function will do "system reset" to NIC when Tx or Rx is stuck.
5364 // The method checking Tx/Rx stuck of this function is supported by FW,
5365 // which reports Tx and Rx counter to register 0x128 and 0x130.
5366 //////////////////////////////////////////////////////////////
5367 void
5368 rtl819x_ifsilentreset(struct net_device *dev)
5369 {
5370         //OCTET_STRING asocpdu;
5371         struct r8192_priv *priv = ieee80211_priv(dev);
5372         u8      reset_times = 0;
5373         int reset_status = 0;
5374         struct ieee80211_device *ieee = priv->ieee80211;
5375
5376
5377         // 2007.07.20. If we need to check CCK stop, please uncomment this line.
5378         //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
5379
5380         if(priv->ResetProgress==RESET_TYPE_NORESET)
5381         {
5382 RESET_START:
5383
5384                 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
5385
5386                 // Set the variable for reset.
5387                 priv->ResetProgress = RESET_TYPE_SILENT;
5388 //              rtl8192_close(dev);
5389 #if 1
5390                 down(&priv->wx_sem);
5391                 if(priv->up == 0)
5392                 {
5393                         RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
5394                         up(&priv->wx_sem);
5395                         return ;
5396                 }
5397                 priv->up = 0;
5398                 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
5399 //              if(!netif_queue_stopped(dev))
5400 //                      netif_stop_queue(dev);
5401
5402                 rtl8192_rtx_disable(dev);
5403                 rtl8192_cancel_deferred_work(priv);
5404                 deinit_hal_dm(dev);
5405                 del_timer_sync(&priv->watch_dog_timer);
5406
5407                 ieee->sync_scan_hurryup = 1;
5408                 if(ieee->state == IEEE80211_LINKED)
5409                 {
5410                         down(&ieee->wx_sem);
5411                         printk("ieee->state is IEEE80211_LINKED\n");
5412                         ieee80211_stop_send_beacons(priv->ieee80211);
5413                         del_timer_sync(&ieee->associate_timer);
5414                         cancel_delayed_work(&ieee->associate_retry_wq);
5415                         ieee80211_stop_scan(ieee);
5416                         netif_carrier_off(dev);
5417                         up(&ieee->wx_sem);
5418                 }
5419                 else{
5420                         printk("ieee->state is NOT LINKED\n");
5421                         ieee80211_softmac_stop_protocol(priv->ieee80211);                       }
5422                 up(&priv->wx_sem);
5423                 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
5424         //rtl8192_irq_disable(dev);
5425                 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
5426                 reset_status = _rtl8192_up(dev);
5427
5428                 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
5429                 if(reset_status == -EAGAIN)
5430                 {
5431                         if(reset_times < 3)
5432                         {
5433                                 reset_times++;
5434                                 goto RESET_START;
5435                         }
5436                         else
5437                         {
5438                                 RT_TRACE(COMP_ERR," ERR!!! %s():  Reset Failed!!\n", __FUNCTION__);
5439                         }
5440                 }
5441 #endif
5442                 ieee->is_silent_reset = 1;
5443 #if 1
5444                 EnableHWSecurityConfig8192(dev);
5445 #if 1
5446                 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
5447                 {
5448                         ieee->set_chan(ieee->dev, ieee->current_network.channel);
5449
5450 #if 1
5451                         queue_work(ieee->wq, &ieee->associate_complete_wq);
5452 #endif
5453
5454                 }
5455                 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
5456                 {
5457                         ieee->set_chan(ieee->dev, ieee->current_network.channel);
5458                         ieee->link_change(ieee->dev);
5459
5460                 //      notify_wx_assoc_event(ieee);
5461
5462                         ieee80211_start_send_beacons(ieee);
5463
5464                         if (ieee->data_hard_resume)
5465                                 ieee->data_hard_resume(ieee->dev);
5466                         netif_carrier_on(ieee->dev);
5467                 }
5468 #endif
5469
5470                 CamRestoreAllEntry(dev);
5471
5472                 priv->ResetProgress = RESET_TYPE_NORESET;
5473                 priv->reset_count++;
5474
5475                 priv->bForcedSilentReset =false;
5476                 priv->bResetInProgress = false;
5477
5478                 // For test --> force write UFWP.
5479                 write_nic_byte(dev, UFWP, 1);
5480                 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
5481 #endif
5482         }
5483 }
5484
5485 void CAM_read_entry(
5486         struct net_device *dev,
5487         u32                     iIndex
5488 )
5489 {
5490         u32 target_command=0;
5491          u32 target_content=0;
5492          u8 entry_i=0;
5493          u32 ulStatus;
5494         s32 i=100;
5495 //      printk("=======>start read CAM\n");
5496         for(entry_i=0;entry_i<CAM_CONTENT_COUNT;entry_i++)
5497         {
5498         // polling bit, and No Write enable, and address
5499                 target_command= entry_i+CAM_CONTENT_COUNT*iIndex;
5500                 target_command= target_command | BIT31;
5501
5502         //Check polling bit is clear
5503 //      mdelay(1);
5504 #if 1
5505                 while((i--)>=0)
5506                 {
5507                         ulStatus = read_nic_dword(dev, RWCAM);
5508                         if(ulStatus & BIT31){
5509                                 continue;
5510                         }
5511                         else{
5512                                 break;
5513                         }
5514                 }
5515 #endif
5516                 write_nic_dword(dev, RWCAM, target_command);
5517                 RT_TRACE(COMP_SEC,"CAM_read_entry(): WRITE A0: %x \n",target_command);
5518          //     printk("CAM_read_entry(): WRITE A0: %lx \n",target_command);
5519                 target_content = read_nic_dword(dev, RCAMO);
5520                 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A8: %x \n",target_content);
5521          //     printk("CAM_read_entry(): WRITE A8: %lx \n",target_content);
5522         }
5523         printk("\n");
5524 }
5525
5526 void rtl819x_update_rxcounts(
5527         struct r8192_priv *priv,
5528         u32* TotalRxBcnNum,
5529         u32* TotalRxDataNum
5530 )
5531 {
5532         u16                     SlotIndex;
5533         u8                      i;
5534
5535         *TotalRxBcnNum = 0;
5536         *TotalRxDataNum = 0;
5537
5538         SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
5539         priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
5540         priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
5541         for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
5542                 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
5543                 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
5544         }
5545 }
5546
5547 extern  void    rtl819x_watchdog_wqcallback(struct work_struct *work)
5548 {
5549         struct delayed_work *dwork = container_of(work,struct delayed_work,work);
5550        struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
5551        struct net_device *dev = priv->ieee80211->dev;
5552         struct ieee80211_device* ieee = priv->ieee80211;
5553         RESET_TYPE      ResetType = RESET_TYPE_NORESET;
5554         static u8       check_reset_cnt=0;
5555         bool bBusyTraffic = false;
5556
5557         if(!priv->up)
5558                 return;
5559         hal_dm_watchdog(dev);
5560
5561         {//to get busy traffic condition
5562                 if(ieee->state == IEEE80211_LINKED)
5563                 {
5564                         //windows mod 666 to 100.
5565                         //if(   ieee->LinkDetectInfo.NumRxOkInPeriod> 666 ||
5566                         //      ieee->LinkDetectInfo.NumTxOkInPeriod> 666 ) {
5567                         if(     ieee->LinkDetectInfo.NumRxOkInPeriod> 100 ||
5568                                 ieee->LinkDetectInfo.NumTxOkInPeriod> 100 ) {
5569                                 bBusyTraffic = true;
5570                         }
5571                         ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
5572                         ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
5573                         ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
5574                 }
5575         }
5576         //added by amy for AP roaming
5577         {
5578                 if(priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA)
5579                 {
5580                         u32     TotalRxBcnNum = 0;
5581                         u32     TotalRxDataNum = 0;
5582
5583                         rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
5584                         if((TotalRxBcnNum+TotalRxDataNum) == 0)
5585                         {
5586                                 #ifdef TODO
5587                                 if(rfState == eRfOff)
5588                                         RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
5589                                 #endif
5590                                 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
5591                         //      Dot11d_Reset(dev);
5592                                 priv->ieee80211->state = IEEE80211_ASSOCIATING;
5593                                 notify_wx_assoc_event(priv->ieee80211);
5594                                 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
5595                                 ieee->is_roaming = true;
5596                                 priv->ieee80211->link_change(dev);
5597                                 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
5598                         }
5599                 }
5600                 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod=0;
5601                 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod=0;
5602         }
5603 //      CAM_read_entry(dev,4);
5604         //check if reset the driver
5605         if(check_reset_cnt++ >= 3 && !ieee->is_roaming)
5606         {
5607                 ResetType = rtl819x_ifcheck_resetornot(dev);
5608                 check_reset_cnt = 3;
5609                 //DbgPrint("Start to check silent reset\n");
5610         }
5611         //      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);
5612 #if 1
5613         if( (priv->force_reset) || (priv->ResetProgress==RESET_TYPE_NORESET &&
5614                 (priv->bForcedSilentReset ||
5615                 (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT)))) // This is control by OID set in Pomelo
5616         {
5617                 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);
5618                 rtl819x_ifsilentreset(dev);
5619         }
5620 #endif
5621         priv->force_reset = false;
5622         priv->bForcedSilentReset = false;
5623         priv->bResetInProgress = false;
5624         RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
5625
5626 }
5627
5628 void watch_dog_timer_callback(unsigned long data)
5629 {
5630         struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
5631         //printk("===============>watch_dog  timer\n");
5632         queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq, 0);
5633         mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
5634 }
5635 int _rtl8192_up(struct net_device *dev)
5636 {
5637         struct r8192_priv *priv = ieee80211_priv(dev);
5638         //int i;
5639         int init_status = 0;
5640         priv->up=1;
5641         priv->ieee80211->ieee_up=1;
5642         RT_TRACE(COMP_INIT, "Bringing up iface");
5643         init_status = priv->ops->rtl819x_adapter_start(dev);
5644         if(!init_status)
5645         {
5646                 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n", __FUNCTION__);
5647                 priv->up=priv->ieee80211->ieee_up = 0;
5648                 return -EAGAIN;
5649         }
5650         RT_TRACE(COMP_INIT, "start adapter finished\n");
5651         rtl8192_rx_enable(dev);
5652 //      rtl8192_tx_enable(dev);
5653         if(priv->ieee80211->state != IEEE80211_LINKED)
5654         ieee80211_softmac_start_protocol(priv->ieee80211);
5655         ieee80211_reset_queue(priv->ieee80211);
5656         watch_dog_timer_callback((unsigned long) dev);
5657         if(!netif_queue_stopped(dev))
5658                 netif_start_queue(dev);
5659         else
5660                 netif_wake_queue(dev);
5661
5662         /*
5663          * Make sure that drop_unencrypted is initialized as "0"
5664          * No packets will be sent in non-security mode if we had set drop_unencrypted.
5665          * ex, After kill wpa_supplicant process, make the driver up again.
5666          * drop_unencrypted remains as "1", which is set by wpa_supplicant. 2008/12/04.john
5667          */
5668         priv->ieee80211->drop_unencrypted = 0;
5669
5670         return 0;
5671 }
5672
5673
5674 int rtl8192_open(struct net_device *dev)
5675 {
5676         struct r8192_priv *priv = ieee80211_priv(dev);
5677         int ret;
5678         down(&priv->wx_sem);
5679         ret = rtl8192_up(dev);
5680         up(&priv->wx_sem);
5681         return ret;
5682
5683 }
5684
5685
5686 int rtl8192_up(struct net_device *dev)
5687 {
5688         struct r8192_priv *priv = ieee80211_priv(dev);
5689
5690         if (priv->up == 1) return -1;
5691
5692         return _rtl8192_up(dev);
5693 }
5694
5695
5696 int rtl8192_close(struct net_device *dev)
5697 {
5698         struct r8192_priv *priv = ieee80211_priv(dev);
5699         int ret;
5700
5701         down(&priv->wx_sem);
5702
5703         ret = rtl8192_down(dev);
5704
5705         up(&priv->wx_sem);
5706
5707         return ret;
5708
5709 }
5710
5711 int rtl8192_down(struct net_device *dev)
5712 {
5713         struct r8192_priv *priv = ieee80211_priv(dev);
5714         int i;
5715
5716         if (priv->up == 0) return -1;
5717
5718         priv->up=0;
5719         priv->ieee80211->ieee_up = 0;
5720         RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
5721 /* FIXME */
5722         if (!netif_queue_stopped(dev))
5723                 netif_stop_queue(dev);
5724
5725         rtl8192_rtx_disable(dev);
5726         //rtl8192_irq_disable(dev);
5727
5728  /* Tx related queue release */
5729         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
5730                 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
5731         }
5732         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
5733                 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
5734         }
5735
5736         for(i = 0; i < MAX_QUEUE_SIZE; i++) {
5737                 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ [i]);
5738         }
5739
5740         //as cancel_delayed_work will del work->timer, so if work is not definedas struct delayed_work, it will corrupt
5741 //      flush_scheduled_work();
5742         rtl8192_cancel_deferred_work(priv);
5743         deinit_hal_dm(dev);
5744         del_timer_sync(&priv->watch_dog_timer);
5745
5746
5747         ieee80211_softmac_stop_protocol(priv->ieee80211);
5748         memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
5749         RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
5750
5751                 return 0;
5752 }
5753
5754
5755 void rtl8192_commit(struct net_device *dev)
5756 {
5757         struct r8192_priv *priv = ieee80211_priv(dev);
5758         int reset_status = 0;
5759         //u8 reset_times = 0;
5760         if (priv->up == 0) return ;
5761         priv->up = 0;
5762
5763         rtl8192_cancel_deferred_work(priv);
5764         del_timer_sync(&priv->watch_dog_timer);
5765         //cancel_delayed_work(&priv->SwChnlWorkItem);
5766
5767         ieee80211_softmac_stop_protocol(priv->ieee80211);
5768
5769         //rtl8192_irq_disable(dev);
5770         rtl8192_rtx_disable(dev);
5771         reset_status = _rtl8192_up(dev);
5772
5773 }
5774
5775 /*
5776 void rtl8192_restart(struct net_device *dev)
5777 {
5778         struct r8192_priv *priv = ieee80211_priv(dev);
5779 */
5780 void rtl8192_restart(struct work_struct *work)
5781 {
5782         struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
5783         struct net_device *dev = priv->ieee80211->dev;
5784
5785         down(&priv->wx_sem);
5786
5787         rtl8192_commit(dev);
5788
5789         up(&priv->wx_sem);
5790 }
5791
5792 static void r8192_set_multicast(struct net_device *dev)
5793 {
5794         struct r8192_priv *priv = ieee80211_priv(dev);
5795         short promisc;
5796
5797         //down(&priv->wx_sem);
5798
5799         /* FIXME FIXME */
5800
5801         promisc = (dev->flags & IFF_PROMISC) ? 1:0;
5802
5803         if (promisc != priv->promisc)
5804         //      rtl8192_commit(dev);
5805
5806         priv->promisc = promisc;
5807
5808         //schedule_work(&priv->reset_wq);
5809         //up(&priv->wx_sem);
5810 }
5811
5812
5813 int r8192_set_mac_adr(struct net_device *dev, void *mac)
5814 {
5815         struct r8192_priv *priv = ieee80211_priv(dev);
5816         struct sockaddr *addr = mac;
5817