?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hrtimer: Add tracepoint for hrtimers
[linux-2.6/cjktty.git] / drivers / staging / rtl8192su / r8192U_core.c
blob70f81a8f12913b7e2ccda789331f2343fc28eda5
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 #ifndef CONFIG_FORCE_HARD_FLOAT
28 double __floatsidf (int i) { return i; }
29 unsigned int __fixunsdfsi (double d) { return d; }
30 double __adddf3(double a, double b) { return a+b; }
31 double __addsf3(float a, float b) { return a+b; }
32 double __subdf3(double a, double b) { return a-b; }
33 double __extendsfdf2(float a) {return a;}
34 #endif
35
36 #undef LOOP_TEST
37 #undef DUMP_RX
38 #undef DUMP_TX
39 #undef DEBUG_TX_DESC2
40 #undef RX_DONT_PASS_UL
41 #undef DEBUG_EPROM
42 #undef DEBUG_RX_VERBOSE
43 #undef DUMMY_RX
44 #undef DEBUG_ZERO_RX
45 #undef DEBUG_RX_SKB
46 #undef DEBUG_TX_FRAG
47 #undef DEBUG_RX_FRAG
48 #undef DEBUG_TX_FILLDESC
49 #undef DEBUG_TX
50 #undef DEBUG_IRQ
51 #undef DEBUG_RX
52 #undef DEBUG_RXALLOC
53 #undef DEBUG_REGISTERS
54 #undef DEBUG_RING
55 #undef DEBUG_IRQ_TASKLET
56 #undef DEBUG_TX_ALLOC
57 #undef DEBUG_TX_DESC
58
59 #define CONFIG_RTL8192_IO_MAP
60
61 #ifdef RTL8192SU
62 #include <asm/uaccess.h>
63 #include "r8192U.h"
64 //#include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
65 #include "r8180_93cx6.h" /* Card EEPROM */
66 #include "r8192U_wx.h"
67
68 #include "r8192S_rtl8225.h"
69 #include "r8192S_hw.h"
70 #include "r8192S_phy.h"
71 #include "r8192S_phyreg.h"
72 #include "r8192S_Efuse.h"
73
74 #include "r819xU_cmdpkt.h"
75 #include "r8192U_dm.h"
76 //#include "r8192xU_phyreg.h"
77 #include <linux/usb.h>
78 // FIXME: check if 2.6.7 is ok
79 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7))
80 #define usb_kill_urb usb_unlink_urb
81 #endif
82
83 #ifdef CONFIG_RTL8192_PM
84 #include "r8192U_pm.h"
85 #endif
86
87 #ifdef ENABLE_DOT11D
88 #include "dot11d.h"
89 #endif
90
91 #else
92
93 #include <asm/uaccess.h>
94 #include "r8192U_hw.h"
95 #include "r8192U.h"
96 #include "r8190_rtl8256.h" /* RTL8225 Radio frontend */
97 #include "r8180_93cx6.h" /* Card EEPROM */
98 #include "r8192U_wx.h"
99 #include "r819xU_phy.h" //added by WB 4.30.2008
100 #include "r819xU_phyreg.h"
101 #include "r819xU_cmdpkt.h"
102 #include "r8192U_dm.h"
103 //#include "r8192xU_phyreg.h"
104 #include <linux/usb.h>
105 // FIXME: check if 2.6.7 is ok
106 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,7))
107 #define usb_kill_urb usb_unlink_urb
108 #endif
109
110 #ifdef CONFIG_RTL8192_PM
111 #include "r8192U_pm.h"
112 #endif
113
114 #ifdef ENABLE_DOT11D
115 #include "dot11d.h"
116 #endif
117
118 #endif
119
120
121 #ifdef RTL8192SU
122 u32 rt_global_debug_component = \
123 // COMP_TRACE |
124 // COMP_DBG |
125 // COMP_INIT |
126 // COMP_RECV |
127 // COMP_SEND |
128 // COMP_IO |
129 COMP_POWER |
130 // COMP_EPROM |
131 COMP_SWBW |
132 COMP_POWER_TRACKING |
133 COMP_TURBO |
134 COMP_QOS |
135 // COMP_RATE |
136 // COMP_RM |
137 COMP_DIG |
138 // COMP_EFUSE |
139 // COMP_CH |
140 // COMP_TXAGC |
141 COMP_HIPWR |
142 // COMP_HALDM |
143 COMP_SEC |
144 COMP_LED |
145 // COMP_RF |
146 // COMP_RXDESC |
147 COMP_FIRMWARE |
148 COMP_HT |
149 COMP_AMSDU |
150 COMP_SCAN |
151 // COMP_CMD |
152 COMP_DOWN |
153 COMP_RESET |
154 COMP_ERR; //always open err flags on
155 #else
156 //set here to open your trace code. //WB
157 u32 rt_global_debug_component = \
158 // COMP_INIT |
159 // COMP_DBG |
160 // COMP_EPROM |
161 // COMP_PHY |
162 // COMP_RF |
163 // COMP_FIRMWARE |
164 // COMP_CH |
165 // COMP_POWER_TRACKING |
166 // COMP_RATE |
167 // COMP_TXAGC |
168 // COMP_TRACE |
169 COMP_DOWN |
170 // COMP_RECV |
171 // COMP_SWBW |
172 COMP_SEC |
173 // COMP_RESET |
174 // COMP_SEND |
175 // COMP_EVENTS |
176 COMP_ERR ; //always open err flags on
177 #endif
178
179 #define TOTAL_CAM_ENTRY 32
180 #define CAM_CONTENT_COUNT 8
181
182 static struct usb_device_id rtl8192_usb_id_tbl[] = {
183 /* Realtek */
184 {USB_DEVICE(0x0bda, 0x8192)},
185 {USB_DEVICE(0x0bda, 0x8709)},
186 /* Corega */
187 {USB_DEVICE(0x07aa, 0x0043)},
188 /* Belkin */
189 {USB_DEVICE(0x050d, 0x805E)},
190 /* Sitecom */
191 {USB_DEVICE(0x0df6, 0x0031)},
192 /* EnGenius */
193 {USB_DEVICE(0x1740, 0x9201)},
194 /* Dlink */
195 {USB_DEVICE(0x2001, 0x3301)},
196 /* Zinwell */
197 {USB_DEVICE(0x5a57, 0x0290)},
198 //92SU
199 {USB_DEVICE(0x0bda, 0x8172)},
200 {}
201 };
202
203 MODULE_LICENSE("GPL");
204 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
205 MODULE_VERSION("V 1.1");
206 #endif
207 MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
208 MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
209
210 static char* ifname = "wlan%d";
211 #if 0
212 static int hwseqnum = 0;
213 static int hwwep = 0;
214 #endif
215 static int hwwep = 1; //default use hw. set 0 to use software security
216 static int channels = 0x3fff;
217
218
219
220 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 9)
221 module_param(ifname, charp, S_IRUGO|S_IWUSR );
222 //module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
223 module_param(hwwep,int, S_IRUGO|S_IWUSR);
224 module_param(channels,int, S_IRUGO|S_IWUSR);
225 #else
226 MODULE_PARM(ifname, "s");
227 //MODULE_PARM(hwseqnum,"i");
228 MODULE_PARM(hwwep,"i");
229 MODULE_PARM(channels,"i");
230 #endif
231
232 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
233 //MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
234 MODULE_PARM_DESC(hwwep," Try to use hardware security support. ");
235 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
236
237 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
238 static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
239 const struct usb_device_id *id);
240 static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf);
241 #else
242 static void *__devinit rtl8192_usb_probe(struct usb_device *udev,unsigned int ifnum,
243 const struct usb_device_id *id);
244 static void __devexit rtl8192_usb_disconnect(struct usb_device *udev, void *ptr);
245 #endif
246
247
248 static struct usb_driver rtl8192_usb_driver = {
249 #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 15)
250 .owner = THIS_MODULE,
251 #endif
252 .name = RTL819xU_MODULE_NAME, /* Driver name */
253 .id_table = rtl8192_usb_id_tbl, /* PCI_ID table */
254 .probe = rtl8192_usb_probe, /* probe fn */
255 .disconnect = rtl8192_usb_disconnect, /* remove fn */
256 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 5, 0)
257 #ifdef CONFIG_RTL8192_PM
258 .suspend = rtl8192U_suspend, /* PM suspend fn */
259 .resume = rtl8192U_resume, /* PM resume fn */
260 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
261 .reset_resume = rtl8192U_resume, /* PM reset resume fn */
262 #endif
263 #else
264 .suspend = NULL, /* PM suspend fn */
265 .resume = NULL, /* PM resume fn */
266 #if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 22)
267 .reset_resume = NULL, /* PM reset resume fn */
268 #endif
269 #endif
270 #endif
271 };
272
273
274 #ifdef RTL8192SU
275 static void rtl8192SU_read_eeprom_info(struct net_device *dev);
276 short rtl8192SU_tx(struct net_device *dev, struct sk_buff* skb);
277 void rtl8192SU_rx_nomal(struct sk_buff* skb);
278 void rtl8192SU_rx_cmd(struct sk_buff *skb);
279 bool rtl8192SU_adapter_start(struct net_device *dev);
280 short rtl8192SU_tx_cmd(struct net_device *dev, struct sk_buff *skb);
281 void rtl8192SU_link_change(struct net_device *dev);
282 void InitialGain8192S(struct net_device *dev,u8 Operation);
283 void rtl8192SU_query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe);
284
285 struct rtl819x_ops rtl8192su_ops = {
286 .nic_type = NIC_8192SU,
287 .rtl819x_read_eeprom_info = rtl8192SU_read_eeprom_info,
288 .rtl819x_tx = rtl8192SU_tx,
289 .rtl819x_tx_cmd = rtl8192SU_tx_cmd,
290 .rtl819x_rx_nomal = rtl8192SU_rx_nomal,
291 .rtl819x_rx_cmd = rtl8192SU_rx_cmd,
292 .rtl819x_adapter_start = rtl8192SU_adapter_start,
293 .rtl819x_link_change = rtl8192SU_link_change,
294 .rtl819x_initial_gain = InitialGain8192S,
295 .rtl819x_query_rxdesc_status = rtl8192SU_query_rxdesc_status,
296 };
297 #else
298 static void rtl8192_read_eeprom_info(struct net_device *dev);
299 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb);
300 void rtl8192_rx_nomal(struct sk_buff* skb);
301 void rtl8192_rx_cmd(struct sk_buff *skb);
302 bool rtl8192_adapter_start(struct net_device *dev);
303 short rtl819xU_tx_cmd(struct net_device *dev, struct sk_buff *skb);
304 void rtl8192_link_change(struct net_device *dev);
305 void InitialGain819xUsb(struct net_device *dev,u8 Operation);
306 void query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe);
307
308 struct rtl819x_ops rtl8192u_ops = {
309 .nic_type = NIC_8192U,
310 .rtl819x_read_eeprom_info = rtl8192_read_eeprom_info,
311 .rtl819x_tx = rtl8192_tx,
312 .rtl819x_tx_cmd = rtl819xU_tx_cmd,
313 .rtl819x_rx_nomal = rtl8192_rx_nomal,
314 .rtl819x_rx_cmd = rtl8192_rx_cmd,
315 .rtl819x_adapter_start = rtl8192_adapter_start,
316 .rtl819x_link_change = rtl8192_link_change,
317 .rtl819x_initial_gain = InitialGain819xUsb,
318 .rtl819x_query_rxdesc_status = query_rxdesc_status,
319 };
320 #endif
321
322 #ifdef ENABLE_DOT11D
323
324 typedef struct _CHANNEL_LIST
325 {
326 u8 Channel[32];
327 u8 Len;
328 }CHANNEL_LIST, *PCHANNEL_LIST;
329
330 static CHANNEL_LIST ChannelPlan[] = {
331 {{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
332 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
333 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
334 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
335 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
336 {{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
337 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
338 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
339 {{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
340 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
341 {{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
342 };
343
344 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
345 {
346 int i, max_chan=-1, min_chan=-1;
347 struct ieee80211_device* ieee = priv->ieee80211;
348 switch (channel_plan)
349 {
350 case COUNTRY_CODE_FCC:
351 case COUNTRY_CODE_IC:
352 case COUNTRY_CODE_ETSI:
353 case COUNTRY_CODE_SPAIN:
354 case COUNTRY_CODE_FRANCE:
355 case COUNTRY_CODE_MKK:
356 case COUNTRY_CODE_MKK1:
357 case COUNTRY_CODE_ISRAEL:
358 case COUNTRY_CODE_TELEC:
359 case COUNTRY_CODE_MIC:
360 {
361 Dot11d_Init(ieee);
362 ieee->bGlobalDomain = false;
363 //acturally 8225 & 8256 rf chip only support B,G,24N mode
364 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256) || (priv->rf_chip == RF_6052))
365 {
366 min_chan = 1;
367 max_chan = 14;
368 }
369 else
370 {
371 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
372 }
373 if (ChannelPlan[channel_plan].Len != 0){
374 // Clear old channel map
375 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
376 // Set new channel map
377 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
378 {
379 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
380 break;
381 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
382 }
383 }
384 break;
385 }
386 case COUNTRY_CODE_GLOBAL_DOMAIN:
387 {
388 GET_DOT11D_INFO(ieee)->bEnabled = 0;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
389 Dot11d_Reset(ieee);
390 ieee->bGlobalDomain = true;
391 break;
392 }
393 default:
394 break;
395 }
396 return;
397 }
398 #endif
399
400 #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 )
401
402 #ifdef RTL8192SU
403 #define rx_hal_is_cck_rate(_pDesc)\
404 ((_pDesc->RxMCS == DESC92S_RATE1M ||\
405 _pDesc->RxMCS == DESC92S_RATE2M ||\
406 _pDesc->RxMCS == DESC92S_RATE5_5M ||\
407 _pDesc->RxMCS == DESC92S_RATE11M) &&\
408 !_pDesc->RxHT)
409
410 #define tx_hal_is_cck_rate(_DataRate)\
411 ( _DataRate == MGN_1M ||\
412 _DataRate == MGN_2M ||\
413 _DataRate == MGN_5_5M ||\
414 _DataRate == MGN_11M )
415
416 #else
417 #define rx_hal_is_cck_rate(_pdrvinfo)\
418 ((_pdrvinfo->RxRate == DESC90_RATE1M ||\
419 _pdrvinfo->RxRate == DESC90_RATE2M ||\
420 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
421 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
422 !_pdrvinfo->RxHT)
423 #endif
424
425
426
427 void CamResetAllEntry(struct net_device *dev)
428 {
429 #if 1
430 u32 ulcommand = 0;
431 //2004/02/11 In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
432 // However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
433 // In this condition, Cam can not be reset because upper layer will not set this static key again.
434 //if(Adapter->EncAlgorithm == WEP_Encryption)
435 // return;
436 //debug
437 //DbgPrint("========================================\n");
438 //DbgPrint(" Call ResetAllEntry \n");
439 //DbgPrint("========================================\n\n");
440 ulcommand |= BIT31|BIT30;
441 write_nic_dword(dev, RWCAM, ulcommand);
442 #else
443 for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
444 CAM_mark_invalid(dev, ucIndex);
445 for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
446 CAM_empty_entry(dev, ucIndex);
447 #endif
448
449 }
450
451
452 void write_cam(struct net_device *dev, u8 addr, u32 data)
453 {
454 write_nic_dword(dev, WCAMI, data);
455 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
456 }
457
458 u32 read_cam(struct net_device *dev, u8 addr)
459 {
460 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
461 return read_nic_dword(dev, 0xa8);
462 }
463
464 void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
465 {
466 int status;
467 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
468 struct usb_device *udev = priv->udev;
469
470 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
471 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
472 indx|0xfe00, 0, &data, 1, HZ / 2);
473
474 if (status < 0)
475 {
476 printk("write_nic_byte_E TimeOut! status:%d\n", status);
477 }
478 }
479
480 u8 read_nic_byte_E(struct net_device *dev, int indx)
481 {
482 int status;
483 u8 data;
484 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
485 struct usb_device *udev = priv->udev;
486
487 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
488 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
489 indx|0xfe00, 0, &data, 1, HZ / 2);
490
491 if (status < 0)
492 {
493 printk("read_nic_byte_E TimeOut! status:%d\n", status);
494 }
495
496 return data;
497 }
498 //as 92U has extend page from 4 to 16, so modify functions below.
499 void write_nic_byte(struct net_device *dev, int indx, u8 data)
500 {
501 int status;
502
503 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
504 struct usb_device *udev = priv->udev;
505
506 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
507 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
508 #ifdef RTL8192SU
509 indx, 0, &data, 1, HZ / 2);
510 #else
511 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
512 #endif
513
514 if (status < 0)
515 {
516 printk("write_nic_byte TimeOut! status:%d\n", status);
517 }
518
519
520 }
521
522
523 void write_nic_word(struct net_device *dev, int indx, u16 data)
524 {
525
526 int status;
527
528 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
529 struct usb_device *udev = priv->udev;
530
531 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
532 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
533 #ifdef RTL8192SU
534 indx, 0, &data, 2, HZ / 2);
535 #else
536 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 2, HZ / 2);
537 #endif
538
539 if (status < 0)
540 {
541 printk("write_nic_word TimeOut! status:%d\n", status);
542 }
543
544 }
545
546
547 void write_nic_dword(struct net_device *dev, int indx, u32 data)
548 {
549
550 int status;
551
552 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
553 struct usb_device *udev = priv->udev;
554
555 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
556 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
557 #ifdef RTL8192SU
558 indx, 0, &data, 4, HZ / 2);
559 #else
560 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 4, HZ / 2);
561 #endif
562
563
564 if (status < 0)
565 {
566 printk("write_nic_dword TimeOut! status:%d\n", status);
567 }
568
569 }
570
571
572
573 u8 read_nic_byte(struct net_device *dev, int indx)
574 {
575 u8 data;
576 int status;
577 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
578 struct usb_device *udev = priv->udev;
579
580 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
581 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
582 #ifdef RTL8192SU
583 indx, 0, &data, 1, HZ / 2);
584 #else
585 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
586 #endif
587
588 if (status < 0)
589 {
590 printk("read_nic_byte TimeOut! status:%d\n", status);
591 }
592
593 return data;
594 }
595
596
597
598 u16 read_nic_word(struct net_device *dev, int indx)
599 {
600 u16 data;
601 int status;
602 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
603 struct usb_device *udev = priv->udev;
604
605 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
606 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
607 #ifdef RTL8192SU
608 indx, 0, &data, 2, HZ / 2);
609 #else
610 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 2, HZ / 2);
611 #endif
612
613 if (status < 0)
614 {
615 printk("read_nic_word TimeOut! status:%d\n", status);
616 }
617
618
619 return data;
620 }
621
622 u16 read_nic_word_E(struct net_device *dev, int indx)
623 {
624 u16 data;
625 int status;
626 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
627 struct usb_device *udev = priv->udev;
628
629 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
630 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
631 indx|0xfe00, 0, &data, 2, HZ / 2);
632
633 if (status < 0)
634 {
635 printk("read_nic_word TimeOut! status:%d\n", status);
636 }
637
638
639 return data;
640 }
641
642 u32 read_nic_dword(struct net_device *dev, int indx)
643 {
644 u32 data;
645 int status;
646 // int result;
647
648 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
649 struct usb_device *udev = priv->udev;
650
651 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
652 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
653 #ifdef RTL8192SU
654 indx, 0, &data, 4, HZ / 2);
655 #else
656 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 4, HZ / 2);
657 #endif
658 // if(0 != result) {
659 // printk(KERN_WARNING "read size of data = %d\, date = %d\n", result, data);
660 // }
661
662 if (status < 0)
663 {
664 printk("read_nic_dword TimeOut! status:%d\n", status);
665 if(status == -ENODEV) {
666 priv->usb_error = true;
667 }
668 }
669
670
671
672 return data;
673 }
674
675
676 //u8 read_phy_cck(struct net_device *dev, u8 adr);
677 //u8 read_phy_ofdm(struct net_device *dev, u8 adr);
678 /* this might still called in what was the PHY rtl8185/rtl8192 common code
679 * plans are to possibilty turn it again in one common code...
680 */
681 inline void force_pci_posting(struct net_device *dev)
682 {
683 }
684
685
686 static struct net_device_stats *rtl8192_stats(struct net_device *dev);
687 void rtl8192_commit(struct net_device *dev);
688 //void rtl8192_restart(struct net_device *dev);
689 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
690 void rtl8192_restart(struct work_struct *work);
691 //void rtl8192_rq_tx_ack(struct work_struct *work);
692 #else
693 void rtl8192_restart(struct net_device *dev);
694 // //void rtl8192_rq_tx_ack(struct net_device *dev);
695 #endif
696
697 void watch_dog_timer_callback(unsigned long data);
698
699 /****************************************************************************
700 -----------------------------PROCFS STUFF-------------------------
701 *****************************************************************************/
702
703 static struct proc_dir_entry *rtl8192_proc = NULL;
704
705
706
707 static int proc_get_stats_ap(char *page, char **start,
708 off_t offset, int count,
709 int *eof, void *data)
710 {
711 struct net_device *dev = data;
712 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
713 struct ieee80211_device *ieee = priv->ieee80211;
714 struct ieee80211_network *target;
715
716 int len = 0;
717
718 list_for_each_entry(target, &ieee->network_list, list) {
719
720 len += snprintf(page + len, count - len,
721 "%s ", target->ssid);
722
723 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
724 len += snprintf(page + len, count - len,
725 "WPA\n");
726 }
727 else{
728 len += snprintf(page + len, count - len,
729 "non_WPA\n");
730 }
731
732 }
733
734 *eof = 1;
735 return len;
736 }
737
738 #ifdef RTL8192SU
739 static int proc_get_registers(char *page, char **start,
740 off_t offset, int count,
741 int *eof, void *data)
742 {
743 struct net_device *dev = data;
744 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
745
746 int len = 0;
747 int i,n,page0,page1,page2;
748
749 int max=0xff;
750 page0 = 0x000;
751 page1 = 0x100;
752 page2 = 0x800;
753
754 /* This dump the current register page */
755 if(!IS_BB_REG_OFFSET_92S(page0)){
756 len += snprintf(page + len, count - len,
757 "\n####################page %x##################\n ", (page0>>8));
758 for(n=0;n<=max;)
759 {
760 len += snprintf(page + len, count - len,
761 "\nD: %2x > ",n);
762 for(i=0;i<16 && n<=max;i++,n++)
763 len += snprintf(page + len, count - len,
764 "%2.2x ",read_nic_byte(dev,(page0|n)));
765 }
766 }else{
767 len += snprintf(page + len, count - len,
768 "\n####################page %x##################\n ", (page0>>8));
769 for(n=0;n<=max;)
770 {
771 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
772 for(i=0;i<4 && n<=max;n+=4,i++)
773 len += snprintf(page + len, count - len,
774 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
775 }
776 }
777 len += snprintf(page + len, count - len,"\n");
778 *eof = 1;
779 return len;
780
781 }
782 static int proc_get_registers_1(char *page, char **start,
783 off_t offset, int count,
784 int *eof, void *data)
785 {
786 struct net_device *dev = data;
787 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
788
789 int len = 0;
790 int i,n,page0;
791
792 int max=0xff;
793 page0 = 0x100;
794
795 /* This dump the current register page */
796 len += snprintf(page + len, count - len,
797 "\n####################page %x##################\n ", (page0>>8));
798 for(n=0;n<=max;)
799 {
800 len += snprintf(page + len, count - len,
801 "\nD: %2x > ",n);
802 for(i=0;i<16 && n<=max;i++,n++)
803 len += snprintf(page + len, count - len,
804 "%2.2x ",read_nic_byte(dev,(page0|n)));
805 }
806 len += snprintf(page + len, count - len,"\n");
807 *eof = 1;
808 return len;
809
810 }
811 static int proc_get_registers_2(char *page, char **start,
812 off_t offset, int count,
813 int *eof, void *data)
814 {
815 struct net_device *dev = data;
816 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
817
818 int len = 0;
819 int i,n,page0;
820
821 int max=0xff;
822 page0 = 0x200;
823
824 /* This dump the current register page */
825 len += snprintf(page + len, count - len,
826 "\n####################page %x##################\n ", (page0>>8));
827 for(n=0;n<=max;)
828 {
829 len += snprintf(page + len, count - len,
830 "\nD: %2x > ",n);
831 for(i=0;i<16 && n<=max;i++,n++)
832 len += snprintf(page + len, count - len,
833 "%2.2x ",read_nic_byte(dev,(page0|n)));
834 }
835 len += snprintf(page + len, count - len,"\n");
836 *eof = 1;
837 return len;
838
839 }
840 static int proc_get_registers_8(char *page, char **start,
841 off_t offset, int count,
842 int *eof, void *data)
843 {
844 struct net_device *dev = data;
845
846 int len = 0;
847 int i,n,page0;
848
849 int max=0xff;
850 page0 = 0x800;
851
852 /* This dump the current register page */
853 len += snprintf(page + len, count - len,
854 "\n####################page %x##################\n ", (page0>>8));
855 for(n=0;n<=max;)
856 {
857 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
858 for(i=0;i<4 && n<=max;n+=4,i++)
859 len += snprintf(page + len, count - len,
860 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
861 }
862 len += snprintf(page + len, count - len,"\n");
863 *eof = 1;
864 return len;
865
866 }
867 static int proc_get_registers_9(char *page, char **start,
868 off_t offset, int count,
869 int *eof, void *data)
870 {
871 struct net_device *dev = data;
872 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
873
874 int len = 0;
875 int i,n,page0;
876
877 int max=0xff;
878 page0 = 0x900;
879
880 /* This dump the current register page */
881 len += snprintf(page + len, count - len,
882 "\n####################page %x##################\n ", (page0>>8));
883 for(n=0;n<=max;)
884 {
885 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
886 for(i=0;i<4 && n<=max;n+=4,i++)
887 len += snprintf(page + len, count - len,
888 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
889 }
890 len += snprintf(page + len, count - len,"\n");
891 *eof = 1;
892 return len;
893 }
894 static int proc_get_registers_a(char *page, char **start,
895 off_t offset, int count,
896 int *eof, void *data)
897 {
898 struct net_device *dev = data;
899 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
900
901 int len = 0;
902 int i,n,page0;
903
904 int max=0xff;
905 page0 = 0xa00;
906
907 /* This dump the current register page */
908 len += snprintf(page + len, count - len,
909 "\n####################page %x##################\n ", (page0>>8));
910 for(n=0;n<=max;)
911 {
912 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
913 for(i=0;i<4 && n<=max;n+=4,i++)
914 len += snprintf(page + len, count - len,
915 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
916 }
917 len += snprintf(page + len, count - len,"\n");
918 *eof = 1;
919 return len;
920 }
921 static int proc_get_registers_b(char *page, char **start,
922 off_t offset, int count,
923 int *eof, void *data)
924 {
925 struct net_device *dev = data;
926 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
927
928 int len = 0;
929 int i,n,page0;
930
931 int max=0xff;
932 page0 = 0xb00;
933
934 /* This dump the current register page */
935 len += snprintf(page + len, count - len,
936 "\n####################page %x##################\n ", (page0>>8));
937 for(n=0;n<=max;)
938 {
939 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
940 for(i=0;i<4 && n<=max;n+=4,i++)
941 len += snprintf(page + len, count - len,
942 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
943 }
944 len += snprintf(page + len, count - len,"\n");
945 *eof = 1;
946 return len;
947 }
948 static int proc_get_registers_c(char *page, char **start,
949 off_t offset, int count,
950 int *eof, void *data)
951 {
952 struct net_device *dev = data;
953 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
954
955 int len = 0;
956 int i,n,page0;
957
958 int max=0xff;
959 page0 = 0xc00;
960
961 /* This dump the current register page */
962 len += snprintf(page + len, count - len,
963 "\n####################page %x##################\n ", (page0>>8));
964 for(n=0;n<=max;)
965 {
966 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
967 for(i=0;i<4 && n<=max;n+=4,i++)
968 len += snprintf(page + len, count - len,
969 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
970 }
971 len += snprintf(page + len, count - len,"\n");
972 *eof = 1;
973 return len;
974 }
975 static int proc_get_registers_d(char *page, char **start,
976 off_t offset, int count,
977 int *eof, void *data)
978 {
979 struct net_device *dev = data;
980 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
981
982 int len = 0;
983 int i,n,page0;
984
985 int max=0xff;
986 page0 = 0xd00;
987
988 /* This dump the current register page */
989 len += snprintf(page + len, count - len,
990 "\n####################page %x##################\n ", (page0>>8));
991 for(n=0;n<=max;)
992 {
993 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
994 for(i=0;i<4 && n<=max;n+=4,i++)
995 len += snprintf(page + len, count - len,
996 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
997 }
998 len += snprintf(page + len, count - len,"\n");
999 *eof = 1;
1000 return len;
1001 }
1002 static int proc_get_registers_e(char *page, char **start,
1003 off_t offset, int count,
1004 int *eof, void *data)
1005 {
1006 struct net_device *dev = data;
1007 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1008
1009 int len = 0;
1010 int i,n,page0;
1011
1012 int max=0xff;
1013 page0 = 0xe00;
1014
1015 /* This dump the current register page */
1016 len += snprintf(page + len, count - len,
1017 "\n####################page %x##################\n ", (page0>>8));
1018 for(n=0;n<=max;)
1019 {
1020 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
1021 for(i=0;i<4 && n<=max;n+=4,i++)
1022 len += snprintf(page + len, count - len,
1023 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
1024 }
1025 len += snprintf(page + len, count - len,"\n");
1026 *eof = 1;
1027 return len;
1028 }
1029 #else
1030 static int proc_get_registers(char *page, char **start,
1031 off_t offset, int count,
1032 int *eof, void *data)
1033 {
1034 struct net_device *dev = data;
1035 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1036
1037 int len = 0;
1038 int i,n;
1039
1040 int max=0xff;
1041
1042 /* This dump the current register page */
1043 len += snprintf(page + len, count - len,
1044 "\n####################page 0##################\n ");
1045
1046 for(n=0;n<=max;)
1047 {
1048 //printk( "\nD: %2x> ", n);
1049 len += snprintf(page + len, count - len,
1050 "\nD: %2x > ",n);
1051
1052 for(i=0;i<16 && n<=max;i++,n++)
1053 len += snprintf(page + len, count - len,
1054 "%2x ",read_nic_byte(dev,0x000|n));
1055
1056 // printk("%2x ",read_nic_byte(dev,n));
1057 }
1058 #if 1
1059 len += snprintf(page + len, count - len,
1060 "\n####################page 1##################\n ");
1061 for(n=0;n<=max;)
1062 {
1063 //printk( "\nD: %2x> ", n);
1064 len += snprintf(page + len, count - len,
1065 "\nD: %2x > ",n);
1066
1067 for(i=0;i<16 && n<=max;i++,n++)
1068 len += snprintf(page + len, count - len,
1069 "%2x ",read_nic_byte(dev,0x100|n));
1070
1071 // printk("%2x ",read_nic_byte(dev,n));
1072 }
1073 len += snprintf(page + len, count - len,
1074 "\n####################page 3##################\n ");
1075 for(n=0;n<=max;)
1076 {
1077 //printk( "\nD: %2x> ", n);
1078 len += snprintf(page + len, count - len,
1079 "\nD: %2x > ",n);
1080
1081 for(i=0;i<16 && n<=max;i++,n++)
1082 len += snprintf(page + len, count - len,
1083 "%2x ",read_nic_byte(dev,0x300|n));
1084
1085 // printk("%2x ",read_nic_byte(dev,n));
1086 }
1087
1088 #endif
1089
1090 len += snprintf(page + len, count - len,"\n");
1091 *eof = 1;
1092 return len;
1093
1094 }
1095 #endif
1096
1097 #if 0
1098 static int proc_get_cck_reg(char *page, char **start,
1099 off_t offset, int count,
1100 int *eof, void *data)
1101 {
1102 struct net_device *dev = data;
1103 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1104
1105 int len = 0;
1106 int i,n;
1107
1108 int max = 0x5F;
1109
1110 /* This dump the current register page */
1111 for(n=0;n<=max;)
1112 {
1113 //printk( "\nD: %2x> ", n);
1114 len += snprintf(page + len, count - len,
1115 "\nD: %2x > ",n);
1116
1117 for(i=0;i<16 && n<=max;i++,n++)
1118 len += snprintf(page + len, count - len,
1119 "%2x ",read_phy_cck(dev,n));
1120
1121 // printk("%2x ",read_nic_byte(dev,n));
1122 }
1123 len += snprintf(page + len, count - len,"\n");
1124
1125
1126 *eof = 1;
1127 return len;
1128 }
1129
1130 #endif
1131
1132 #if 0
1133 static int proc_get_ofdm_reg(char *page, char **start,
1134 off_t offset, int count,
1135 int *eof, void *data)
1136 {
1137 struct net_device *dev = data;
1138 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1139
1140 int len = 0;
1141 int i,n;
1142
1143 //int max=0xff;
1144 int max = 0x40;
1145
1146 /* This dump the current register page */
1147 for(n=0;n<=max;)
1148 {
1149 //printk( "\nD: %2x> ", n);
1150 len += snprintf(page + len, count - len,
1151 "\nD: %2x > ",n);
1152
1153 for(i=0;i<16 && n<=max;i++,n++)
1154 len += snprintf(page + len, count - len,
1155 "%2x ",read_phy_ofdm(dev,n));
1156
1157 // printk("%2x ",read_nic_byte(dev,n));
1158 }
1159 len += snprintf(page + len, count - len,"\n");
1160
1161
1162
1163 *eof = 1;
1164 return len;
1165 }
1166
1167 #endif
1168
1169 #if 0
1170 static int proc_get_stats_hw(char *page, char **start,
1171 off_t offset, int count,
1172 int *eof, void *data)
1173 {
1174 struct net_device *dev = data;
1175 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1176
1177 int len = 0;
1178
1179 len += snprintf(page + len, count - len,
1180 "NIC int: %lu\n"
1181 "Total int: %lu\n",
1182 priv->stats.ints,
1183 priv->stats.shints);
1184
1185 *eof = 1;
1186 return len;
1187 }
1188 #endif
1189
1190 static int proc_get_stats_tx(char *page, char **start,
1191 off_t offset, int count,
1192 int *eof, void *data)
1193 {
1194 struct net_device *dev = data;
1195 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1196
1197 int len = 0;
1198
1199 len += snprintf(page + len, count - len,
1200 "TX VI priority ok int: %lu\n"
1201 "TX VI priority error int: %lu\n"
1202 "TX VO priority ok int: %lu\n"
1203 "TX VO priority error int: %lu\n"
1204 "TX BE priority ok int: %lu\n"
1205 "TX BE priority error int: %lu\n"
1206 "TX BK priority ok int: %lu\n"
1207 "TX BK priority error int: %lu\n"
1208 "TX MANAGE priority ok int: %lu\n"
1209 "TX MANAGE priority error int: %lu\n"
1210 "TX BEACON priority ok int: %lu\n"
1211 "TX BEACON priority error int: %lu\n"
1212 // "TX high priority ok int: %lu\n"
1213 // "TX high priority failed error int: %lu\n"
1214 "TX queue resume: %lu\n"
1215 "TX queue stopped?: %d\n"
1216 "TX fifo overflow: %lu\n"
1217 // "TX beacon: %lu\n"
1218 "TX VI queue: %d\n"
1219 "TX VO queue: %d\n"
1220 "TX BE queue: %d\n"
1221 "TX BK queue: %d\n"
1222 // "TX HW queue: %d\n"
1223 "TX VI dropped: %lu\n"
1224 "TX VO dropped: %lu\n"
1225 "TX BE dropped: %lu\n"
1226 "TX BK dropped: %lu\n"
1227 "TX total data packets %lu\n",
1228 // "TX beacon aborted: %lu\n",
1229 priv->stats.txviokint,
1230 priv->stats.txvierr,
1231 priv->stats.txvookint,
1232 priv->stats.txvoerr,
1233 priv->stats.txbeokint,
1234 priv->stats.txbeerr,
1235 priv->stats.txbkokint,
1236 priv->stats.txbkerr,
1237 priv->stats.txmanageokint,
1238 priv->stats.txmanageerr,
1239 priv->stats.txbeaconokint,
1240 priv->stats.txbeaconerr,
1241 // priv->stats.txhpokint,
1242 // priv->stats.txhperr,
1243 priv->stats.txresumed,
1244 netif_queue_stopped(dev),
1245 priv->stats.txoverflow,
1246 // priv->stats.txbeacon,
1247 atomic_read(&(priv->tx_pending[VI_PRIORITY])),
1248 atomic_read(&(priv->tx_pending[VO_PRIORITY])),
1249 atomic_read(&(priv->tx_pending[BE_PRIORITY])),
1250 atomic_read(&(priv->tx_pending[BK_PRIORITY])),
1251 // read_nic_byte(dev, TXFIFOCOUNT),
1252 priv->stats.txvidrop,
1253 priv->stats.txvodrop,
1254 priv->stats.txbedrop,
1255 priv->stats.txbkdrop,
1256 priv->stats.txdatapkt
1257 // priv->stats.txbeaconerr
1258 );
1259
1260 *eof = 1;
1261 return len;
1262 }
1263
1264
1265
1266 static int proc_get_stats_rx(char *page, char **start,
1267 off_t offset, int count,
1268 int *eof, void *data)
1269 {
1270 struct net_device *dev = data;
1271 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1272
1273 int len = 0;
1274
1275 len += snprintf(page + len, count - len,
1276 "RX packets: %lu\n"
1277 "RX urb status error: %lu\n"
1278 "RX invalid urb error: %lu\n",
1279 priv->stats.rxoktotal,
1280 priv->stats.rxstaterr,
1281 priv->stats.rxurberr);
1282
1283 *eof = 1;
1284 return len;
1285 }
1286 #if 0
1287 #if WIRELESS_EXT >= 12 && WIRELESS_EXT < 17
1288
1289 static struct iw_statistics *r8192_get_wireless_stats(struct net_device *dev)
1290 {
1291 struct r8192_priv *priv = ieee80211_priv(dev);
1292
1293 return &priv->wstats;
1294 }
1295 #endif
1296 #endif
1297 void rtl8192_proc_module_init(void)
1298 {
1299 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
1300 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
1301 rtl8192_proc=create_proc_entry(RTL819xU_MODULE_NAME, S_IFDIR, proc_net);
1302 #else
1303 rtl8192_proc=create_proc_entry(RTL819xU_MODULE_NAME, S_IFDIR, init_net.proc_net);
1304 #endif
1305 }
1306
1307
1308 void rtl8192_proc_module_remove(void)
1309 {
1310 #if(LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24))
1311 remove_proc_entry(RTL819xU_MODULE_NAME, proc_net);
1312 #else
1313 remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
1314 #endif
1315 }
1316
1317
1318 void rtl8192_proc_remove_one(struct net_device *dev)
1319 {
1320 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1321
1322
1323 if (priv->dir_dev) {
1324 // remove_proc_entry("stats-hw", priv->dir_dev);
1325 remove_proc_entry("stats-tx", priv->dir_dev);
1326 remove_proc_entry("stats-rx", priv->dir_dev);
1327 // remove_proc_entry("stats-ieee", priv->dir_dev);
1328 remove_proc_entry("stats-ap", priv->dir_dev);
1329 remove_proc_entry("registers", priv->dir_dev);
1330 remove_proc_entry("registers-1", priv->dir_dev);
1331 remove_proc_entry("registers-2", priv->dir_dev);
1332 remove_proc_entry("registers-8", priv->dir_dev);
1333 remove_proc_entry("registers-9", priv->dir_dev);
1334 remove_proc_entry("registers-a", priv->dir_dev);
1335 remove_proc_entry("registers-b", priv->dir_dev);
1336 remove_proc_entry("registers-c", priv->dir_dev);
1337 remove_proc_entry("registers-d", priv->dir_dev);
1338 remove_proc_entry("registers-e", priv->dir_dev);
1339 // remove_proc_entry("cck-registers",priv->dir_dev);
1340 // remove_proc_entry("ofdm-registers",priv->dir_dev);
1341 //remove_proc_entry(dev->name, rtl8192_proc);
1342 remove_proc_entry("wlan0", rtl8192_proc);
1343 priv->dir_dev = NULL;
1344 }
1345 }
1346
1347
1348 void rtl8192_proc_init_one(struct net_device *dev)
1349 {
1350 struct proc_dir_entry *e;
1351 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1352 priv->dir_dev = create_proc_entry(dev->name,
1353 S_IFDIR | S_IRUGO | S_IXUGO,
1354 rtl8192_proc);
1355 if (!priv->dir_dev) {
1356 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
1357 dev->name);
1358 return;
1359 }
1360 #if 0
1361 e = create_proc_read_entry("stats-hw", S_IFREG | S_IRUGO,
1362 priv->dir_dev, proc_get_stats_hw, dev);
1363
1364 if (!e) {
1365 DMESGE("Unable to initialize "
1366 "/proc/net/rtl8192/%s/stats-hw\n",
1367 dev->name);
1368 }
1369 #endif
1370 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
1371 priv->dir_dev, proc_get_stats_rx, dev);
1372
1373 if (!e) {
1374 RT_TRACE(COMP_ERR,"Unable to initialize "
1375 "/proc/net/rtl8192/%s/stats-rx\n",
1376 dev->name);
1377 }
1378
1379
1380 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
1381 priv->dir_dev, proc_get_stats_tx, dev);
1382
1383 if (!e) {
1384 RT_TRACE(COMP_ERR, "Unable to initialize "
1385 "/proc/net/rtl8192/%s/stats-tx\n",
1386 dev->name);
1387 }
1388 #if 0
1389 e = create_proc_read_entry("stats-ieee", S_IFREG | S_IRUGO,
1390 priv->dir_dev, proc_get_stats_ieee, dev);
1391
1392 if (!e) {
1393 DMESGE("Unable to initialize "
1394 "/proc/net/rtl8192/%s/stats-ieee\n",
1395 dev->name);
1396 }
1397
1398 #endif
1399
1400 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
1401 priv->dir_dev, proc_get_stats_ap, dev);
1402
1403 if (!e) {
1404 RT_TRACE(COMP_ERR, "Unable to initialize "
1405 "/proc/net/rtl8192/%s/stats-ap\n",
1406 dev->name);
1407 }
1408
1409 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
1410 priv->dir_dev, proc_get_registers, dev);
1411 if (!e) {
1412 RT_TRACE(COMP_ERR, "Unable to initialize "
1413 "/proc/net/rtl8192/%s/registers\n",
1414 dev->name);
1415 }
1416 #ifdef RTL8192SU
1417 e = create_proc_read_entry("registers-1", S_IFREG | S_IRUGO,
1418 priv->dir_dev, proc_get_registers_1, dev);
1419 if (!e) {
1420 RT_TRACE(COMP_ERR, "Unable to initialize "
1421 "/proc/net/rtl8192/%s/registers-1\n",
1422 dev->name);
1423 }
1424 e = create_proc_read_entry("registers-2", S_IFREG | S_IRUGO,
1425 priv->dir_dev, proc_get_registers_2, dev);
1426 if (!e) {
1427 RT_TRACE(COMP_ERR, "Unable to initialize "
1428 "/proc/net/rtl8192/%s/registers-2\n",
1429 dev->name);
1430 }
1431 e = create_proc_read_entry("registers-8", S_IFREG | S_IRUGO,
1432 priv->dir_dev, proc_get_registers_8, dev);
1433 if (!e) {
1434 RT_TRACE(COMP_ERR, "Unable to initialize "
1435 "/proc/net/rtl8192/%s/registers-8\n",
1436 dev->name);
1437 }
1438 e = create_proc_read_entry("registers-9", S_IFREG | S_IRUGO,
1439 priv->dir_dev, proc_get_registers_9, dev);
1440 if (!e) {
1441 RT_TRACE(COMP_ERR, "Unable to initialize "
1442 "/proc/net/rtl8192/%s/registers-9\n",
1443 dev->name);
1444 }
1445 e = create_proc_read_entry("registers-a", S_IFREG | S_IRUGO,
1446 priv->dir_dev, proc_get_registers_a, dev);
1447 if (!e) {
1448 RT_TRACE(COMP_ERR, "Unable to initialize "
1449 "/proc/net/rtl8192/%s/registers-a\n",
1450 dev->name);
1451 }
1452 e = create_proc_read_entry("registers-b", S_IFREG | S_IRUGO,
1453 priv->dir_dev, proc_get_registers_b, dev);
1454 if (!e) {
1455 RT_TRACE(COMP_ERR, "Unable to initialize "
1456 "/proc/net/rtl8192/%s/registers-b\n",
1457 dev->name);
1458 }
1459 e = create_proc_read_entry("registers-c", S_IFREG | S_IRUGO,
1460 priv->dir_dev, proc_get_registers_c, dev);
1461 if (!e) {
1462 RT_TRACE(COMP_ERR, "Unable to initialize "
1463 "/proc/net/rtl8192/%s/registers-c\n",
1464 dev->name);
1465 }
1466 e = create_proc_read_entry("registers-d", S_IFREG | S_IRUGO,
1467 priv->dir_dev, proc_get_registers_d, dev);
1468 if (!e) {
1469 RT_TRACE(COMP_ERR, "Unable to initialize "
1470 "/proc/net/rtl8192/%s/registers-d\n",
1471 dev->name);
1472 }
1473 e = create_proc_read_entry("registers-e", S_IFREG | S_IRUGO,
1474 priv->dir_dev, proc_get_registers_e, dev);
1475 if (!e) {
1476 RT_TRACE(COMP_ERR, "Unable to initialize "
1477 "/proc/net/rtl8192/%s/registers-e\n",
1478 dev->name);
1479 }
1480 #endif
1481 #if 0
1482 e = create_proc_read_entry("cck-registers", S_IFREG | S_IRUGO,
1483 priv->dir_dev, proc_get_cck_reg, dev);
1484 if (!e) {
1485 RT_TRACE(COMP_ERR, "Unable to initialize "
1486 "/proc/net/rtl8192/%s/cck-registers\n",
1487 dev->name);
1488 }
1489
1490 e = create_proc_read_entry("ofdm-registers", S_IFREG | S_IRUGO,
1491 priv->dir_dev, proc_get_ofdm_reg, dev);
1492 if (!e) {
1493 RT_TRACE(COMP_ERR, "Unable to initialize "
1494 "/proc/net/rtl8192/%s/ofdm-registers\n",
1495 dev->name);
1496 }
1497 #endif
1498 }
1499 /****************************************************************************
1500 -----------------------------MISC STUFF-------------------------
1501 *****************************************************************************/
1502
1503 /* this is only for debugging */
1504 void print_buffer(u32 *buffer, int len)
1505 {
1506 int i;
1507 u8 *buf =(u8*)buffer;
1508
1509 printk("ASCII BUFFER DUMP (len: %x):\n",len);
1510
1511 for(i=0;i<len;i++)
1512 printk("%c",buf[i]);
1513
1514 printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
1515
1516 for(i=0;i<len;i++)
1517 printk("%x",buf[i]);
1518
1519 printk("\n");
1520 }
1521
1522 //short check_nic_enough_desc(struct net_device *dev, priority_t priority)
1523 short check_nic_enough_desc(struct net_device *dev,int queue_index)
1524 {
1525 struct r8192_priv *priv = ieee80211_priv(dev);
1526 int used = atomic_read(&priv->tx_pending[queue_index]);
1527
1528 return (used < MAX_TX_URB);
1529 }
1530
1531 void tx_timeout(struct net_device *dev)
1532 {
1533 struct r8192_priv *priv = ieee80211_priv(dev);
1534 //rtl8192_commit(dev);
1535
1536 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
1537 schedule_work(&priv->reset_wq);
1538 #else
1539 schedule_task(&priv->reset_wq);
1540 #endif
1541 //DMESG("TXTIMEOUT");
1542 }
1543
1544
1545 /* this is only for debug */
1546 void dump_eprom(struct net_device *dev)
1547 {
1548 int i;
1549 for(i=0; i<63; i++)
1550 RT_TRACE(COMP_EPROM, "EEPROM addr %x : %x", i, eprom_read(dev,i));
1551 }
1552
1553 /* this is only for debug */
1554 void rtl8192_dump_reg(struct net_device *dev)
1555 {
1556 int i;
1557 int n;
1558 int max=0x1ff;
1559
1560 RT_TRACE(COMP_PHY, "Dumping NIC register map");
1561
1562 for(n=0;n<=max;)
1563 {
1564 printk( "\nD: %2x> ", n);
1565 for(i=0;i<16 && n<=max;i++,n++)
1566 printk("%2x ",read_nic_byte(dev,n));
1567 }
1568 printk("\n");
1569 }
1570
1571 /****************************************************************************
1572 ------------------------------HW STUFF---------------------------
1573 *****************************************************************************/
1574
1575 #if 0
1576 void rtl8192_irq_enable(struct net_device *dev)
1577 {
1578 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1579 //priv->irq_enabled = 1;
1580 /*
1581 write_nic_word(dev,INTA_MASK,INTA_RXOK | INTA_RXDESCERR | INTA_RXOVERFLOW |\
1582 INTA_TXOVERFLOW | INTA_HIPRIORITYDESCERR | INTA_HIPRIORITYDESCOK |\
1583 INTA_NORMPRIORITYDESCERR | INTA_NORMPRIORITYDESCOK |\
1584 INTA_LOWPRIORITYDESCERR | INTA_LOWPRIORITYDESCOK | INTA_TIMEOUT);
1585 */
1586 write_nic_word(dev,INTA_MASK, priv->irq_mask);
1587 }
1588
1589
1590 void rtl8192_irq_disable(struct net_device *dev)
1591 {
1592 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1593
1594 write_nic_word(dev,INTA_MASK,0);
1595 force_pci_posting(dev);
1596 // priv->irq_enabled = 0;
1597 }
1598 #endif
1599
1600 void rtl8192_set_mode(struct net_device *dev,int mode)
1601 {
1602 u8 ecmd;
1603 ecmd=read_nic_byte(dev, EPROM_CMD);
1604 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
1605 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
1606 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
1607 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
1608 write_nic_byte(dev, EPROM_CMD, ecmd);
1609 }
1610
1611
1612 void rtl8192_update_msr(struct net_device *dev)
1613 {
1614 struct r8192_priv *priv = ieee80211_priv(dev);
1615 u8 msr;
1616
1617 msr = read_nic_byte(dev, MSR);
1618 msr &= ~ MSR_LINK_MASK;
1619
1620 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
1621 * msr must be updated if the state is ASSOCIATING.
1622 * this is intentional and make sense for ad-hoc and
1623 * master (see the create BSS/IBSS func)
1624 */
1625 if (priv->ieee80211->state == IEEE80211_LINKED){
1626
1627 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
1628 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
1629 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1630 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
1631 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
1632 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
1633
1634 }else
1635 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
1636
1637 write_nic_byte(dev, MSR, msr);
1638 }
1639
1640 void rtl8192_set_chan(struct net_device *dev,short ch)
1641 {
1642 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1643 // u32 tx;
1644 RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
1645 //printk("=====>%s()====ch:%d\n", __FUNCTION__, ch);
1646 priv->chan=ch;
1647 #if 0
1648 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC ||
1649 priv->ieee80211->iw_mode == IW_MODE_MASTER){
1650
1651 priv->ieee80211->link_state = WLAN_LINK_ASSOCIATED;
1652 priv->ieee80211->master_chan = ch;
1653 rtl8192_update_beacon_ch(dev);
1654 }
1655 #endif
1656
1657 /* this hack should avoid frame TX during channel setting*/
1658
1659
1660 // tx = read_nic_dword(dev,TX_CONF);
1661 // tx &= ~TX_LOOPBACK_MASK;
1662
1663 #ifndef LOOP_TEST
1664 // write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
1665
1666 //need to implement rf set channel here WB
1667
1668 if (priv->rf_set_chan)
1669 priv->rf_set_chan(dev,priv->chan);
1670 mdelay(10);
1671 // write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
1672 #endif
1673 }
1674
1675 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
1676 static void rtl8192_rx_isr(struct urb *urb, struct pt_regs *regs);
1677 #else
1678 static void rtl8192_rx_isr(struct urb *urb);
1679 #endif
1680 //static void rtl8192_rx_isr(struct urb *rx_urb);
1681
1682 u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
1683 {
1684
1685 #ifdef USB_RX_AGGREGATION_SUPPORT
1686 if (pstats->bisrxaggrsubframe)
1687 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
1688 + pstats->RxBufShift + 8);
1689 else
1690 #endif
1691 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
1692 + pstats->RxBufShift);
1693
1694 }
1695 static int rtl8192_rx_initiate(struct net_device*dev)
1696 {
1697 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1698 struct urb *entry;
1699 struct sk_buff *skb;
1700 struct rtl8192_rx_info *info;
1701
1702 /* nomal packet rx procedure */
1703 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
1704 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
1705 if (!skb)
1706 break;
1707 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
1708 entry = usb_alloc_urb(0, GFP_KERNEL);
1709 #else
1710 entry = usb_alloc_urb(0);
1711 #endif
1712 if (!entry) {
1713 kfree_skb(skb);
1714 break;
1715 }
1716 // printk("nomal packet IN request!\n");
1717 usb_fill_bulk_urb(entry, priv->udev,
1718 usb_rcvbulkpipe(priv->udev, 3), skb->tail,
1719 RX_URB_SIZE, rtl8192_rx_isr, skb);
1720 info = (struct rtl8192_rx_info *) skb->cb;
1721 info->urb = entry;
1722 info->dev = dev;
1723 info->out_pipe = 3; //denote rx normal packet queue
1724 skb_queue_tail(&priv->rx_queue, skb);
1725 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
1726 usb_submit_urb(entry, GFP_KERNEL);
1727 #else
1728 usb_submit_urb(entry);
1729 #endif
1730 }
1731
1732 /* command packet rx procedure */
1733 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
1734 // printk("command packet IN request!\n");
1735 skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL);
1736 if (!skb)
1737 break;
1738 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
1739 entry = usb_alloc_urb(0, GFP_KERNEL);
1740 #else
1741 entry = usb_alloc_urb(0);
1742 #endif
1743 if (!entry) {
1744 kfree_skb(skb);
1745 break;
1746 }
1747 usb_fill_bulk_urb(entry, priv->udev,
1748 usb_rcvbulkpipe(priv->udev, 9), skb->tail,
1749 RX_URB_SIZE, rtl8192_rx_isr, skb);
1750 info = (struct rtl8192_rx_info *) skb->cb;
1751 info->urb = entry;
1752 info->dev = dev;
1753 info->out_pipe = 9; //denote rx cmd packet queue
1754 skb_queue_tail(&priv->rx_queue, skb);
1755 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
1756 usb_submit_urb(entry, GFP_KERNEL);
1757 #else
1758 usb_submit_urb(entry);
1759 #endif
1760 }
1761
1762 return 0;
1763 }
1764
1765 void rtl8192_set_rxconf(struct net_device *dev)
1766 {
1767 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1768 u32 rxconf;
1769
1770 rxconf=read_nic_dword(dev,RCR);
1771 rxconf = rxconf &~ MAC_FILTER_MASK;
1772 rxconf = rxconf | RCR_AMF;
1773 rxconf = rxconf | RCR_ADF;
1774 rxconf = rxconf | RCR_AB;
1775 rxconf = rxconf | RCR_AM;
1776 //rxconf = rxconf | RCR_ACF;
1777
1778 if (dev->flags & IFF_PROMISC) {DMESG ("NIC in promisc mode");}
1779
1780 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
1781 dev->flags & IFF_PROMISC){
1782 rxconf = rxconf | RCR_AAP;
1783 } /*else if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
1784 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
1785 rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
1786 }*/else{
1787 rxconf = rxconf | RCR_APM;
1788 rxconf = rxconf | RCR_CBSSID;
1789 }
1790
1791
1792 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
1793 rxconf = rxconf | RCR_AICV;
1794 rxconf = rxconf | RCR_APWRMGT;
1795 }
1796
1797 if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
1798 rxconf = rxconf | RCR_ACRC32;
1799
1800
1801 rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
1802 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
1803 rxconf = rxconf &~ MAX_RX_DMA_MASK;
1804 rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
1805
1806 // rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
1807 rxconf = rxconf | RCR_ONLYERLPKT;
1808
1809 // rxconf = rxconf &~ RCR_CS_MASK;
1810 // rxconf = rxconf | (1<<RCR_CS_SHIFT);
1811
1812 write_nic_dword(dev, RCR, rxconf);
1813
1814 #ifdef DEBUG_RX
1815 DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RCR));
1816 #endif
1817 }
1818 //wait to be removed
1819 void rtl8192_rx_enable(struct net_device *dev)
1820 {
1821 //u8 cmd;
1822
1823 //struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1824
1825 rtl8192_rx_initiate(dev);
1826
1827 // rtl8192_set_rxconf(dev);
1828 #if 0
1829 if(NIC_8187 == priv->card_8187) {
1830 cmd=read_nic_byte(dev,CMD);
1831 write_nic_byte(dev,CMD,cmd | (1<<CMD_RX_ENABLE_SHIFT));
1832 }
1833 else {
1834 //write_nic_dword(dev, RX_CONF, priv->ReceiveConfig);
1835 }
1836 #endif
1837 }
1838
1839
1840 void rtl8192_tx_enable(struct net_device *dev)
1841 {
1842 #if 0
1843 u8 cmd;
1844 u8 byte;
1845 u32 txconf;
1846 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1847 //test loopback
1848 // priv->TransmitConfig |= (TX_LOOPBACK_BASEBAND<<TX_LOOPBACK_SHIFT);
1849 if(NIC_8187B == priv->card_8187){
1850 write_nic_dword(dev, TX_CONF, priv->TransmitConfig);
1851 byte = read_nic_byte(dev, MSR);
1852 byte |= MSR_LINK_ENEDCA;
1853 write_nic_byte(dev, MSR, byte);
1854 } else {
1855 byte = read_nic_byte(dev,CW_CONF);
1856 byte &= ~(1<<CW_CONF_PERPACKET_CW_SHIFT);
1857 byte &= ~(1<<CW_CONF_PERPACKET_RETRY_SHIFT);
1858 write_nic_byte(dev, CW_CONF, byte);
1859
1860 byte = read_nic_byte(dev, TX_AGC_CTL);
1861 byte &= ~(1<<TX_AGC_CTL_PERPACKET_GAIN_SHIFT);
1862 byte &= ~(1<<TX_AGC_CTL_PERPACKET_ANTSEL_SHIFT);
1863 byte &= ~(1<<TX_AGC_CTL_FEEDBACK_ANT);
1864 write_nic_byte(dev, TX_AGC_CTL, byte);
1865
1866 txconf= read_nic_dword(dev,TX_CONF);
1867
1868
1869 txconf = txconf &~ TX_LOOPBACK_MASK;
1870
1871 #ifndef LOOP_TEST
1872 txconf = txconf | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT);
1873 #else
1874 txconf = txconf | (TX_LOOPBACK_BASEBAND<<TX_LOOPBACK_SHIFT);
1875 #endif
1876 txconf = txconf &~ TCR_SRL_MASK;
1877 txconf = txconf &~ TCR_LRL_MASK;
1878
1879 txconf = txconf | (priv->retry_data<<TX_LRLRETRY_SHIFT); // long
1880 txconf = txconf | (priv->retry_rts<<TX_SRLRETRY_SHIFT); // short
1881
1882 txconf = txconf &~ (1<<TX_NOCRC_SHIFT);
1883
1884 txconf = txconf &~ TCR_MXDMA_MASK;
1885 txconf = txconf | (TCR_MXDMA_2048<<TCR_MXDMA_SHIFT);
1886
1887 txconf = txconf | TCR_DISReqQsize;
1888 txconf = txconf | TCR_DISCW;
1889 txconf = txconf &~ TCR_SWPLCPLEN;
1890
1891 txconf=txconf | (1<<TX_NOICV_SHIFT);
1892
1893 write_nic_dword(dev,TX_CONF,txconf);
1894
1895 #ifdef DEBUG_TX
1896 DMESG("txconf: %x %x",txconf,read_nic_dword(dev,TX_CONF));
1897 #endif
1898
1899 cmd=read_nic_byte(dev,CMD);
1900 write_nic_byte(dev,CMD,cmd | (1<<CMD_TX_ENABLE_SHIFT));
1901 }
1902 #endif
1903 }
1904
1905 #if 0
1906 void rtl8192_beacon_tx_enable(struct net_device *dev)
1907 {
1908 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1909 priv->dma_poll_mask &=~(1<<TX_DMA_STOP_BEACON_SHIFT);
1910 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
1911 write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
1912 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
1913 }
1914
1915
1916 void rtl8192_
1917 _disable(struct net_device *dev)
1918 {
1919 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1920 priv->dma_poll_mask |= (1<<TX_DMA_STOP_BEACON_SHIFT);
1921 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
1922 write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
1923 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
1924 }
1925
1926 #endif
1927
1928
1929 void rtl8192_rtx_disable(struct net_device *dev)
1930 {
1931 u8 cmd;
1932 struct r8192_priv *priv = ieee80211_priv(dev);
1933 struct sk_buff *skb;
1934 struct rtl8192_rx_info *info;
1935
1936 cmd=read_nic_byte(dev,CMDR);
1937 write_nic_byte(dev, CMDR, cmd &~ \
1938 (CR_TE|CR_RE));
1939 force_pci_posting(dev);
1940 mdelay(10);
1941
1942 while ((skb = __skb_dequeue(&priv->rx_queue))) {
1943 info = (struct rtl8192_rx_info *) skb->cb;
1944 if (!info->urb)
1945 continue;
1946
1947 usb_kill_urb(info->urb);
1948 kfree_skb(skb);
1949 }
1950
1951 if (skb_queue_len(&priv->skb_queue)) {
1952 printk(KERN_WARNING "skb_queue not empty\n");
1953 }
1954
1955 skb_queue_purge(&priv->skb_queue);
1956 return;
1957 }
1958
1959
1960 int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
1961 {
1962 #if 0
1963 int i;
1964 u32 *tmp;
1965 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1966
1967 priv->txbeaconring = (u32*)pci_alloc_consistent(priv->pdev,
1968 sizeof(u32)*8*count,
1969 &priv->txbeaconringdma);
1970 if (!priv->txbeaconring) return -1;
1971 for (tmp=priv->txbeaconring,i=0;i<count;i++){
1972 *tmp = *tmp &~ (1<<31); // descriptor empty, owned by the drv
1973 /*
1974 *(tmp+2) = (u32)dma_tmp;
1975 *(tmp+3) = bufsize;
1976 */
1977 if(i+1<count)
1978 *(tmp+4) = (u32)priv->txbeaconringdma+((i+1)*8*4);
1979 else
1980 *(tmp+4) = (u32)priv->txbeaconringdma;
1981
1982 tmp=tmp+8;
1983 }
1984 #endif
1985 return 0;
1986 }
1987
1988 #if 0
1989 void rtl8192_reset(struct net_device *dev)
1990 {
1991
1992 //struct r8192_priv *priv = ieee80211_priv(dev);
1993 //u8 cr;
1994
1995
1996 /* make sure the analog power is on before
1997 * reset, otherwise reset may fail
1998 */
1999 #if 0
2000 if(NIC_8187 == priv->card_8187) {
2001 rtl8192_set_anaparam(dev, RTL8225_ANAPARAM_ON);
2002 rtl8185_set_anaparam2(dev, RTL8225_ANAPARAM2_ON);
2003 rtl8192_irq_disable(dev);
2004 mdelay(200);
2005 write_nic_byte_E(dev,0x18,0x10);
2006 write_nic_byte_E(dev,0x18,0x11);
2007 write_nic_byte_E(dev,0x18,0x00);
2008 mdelay(200);
2009 }
2010 #endif
2011 printk("=====>reset?\n");
2012 #if 0
2013 cr=read_nic_byte(dev,CMD);
2014 cr = cr & 2;
2015 cr = cr | (1<<CMD_RST_SHIFT);
2016 write_nic_byte(dev,CMD,cr);
2017
2018 force_pci_posting(dev);
2019
2020 mdelay(200);
2021
2022 if(read_nic_byte(dev,CMD) & (1<<CMD_RST_SHIFT))
2023 RT_TRACE(COMP_ERR, "Card reset timeout!\n");
2024 else
2025 RT_TRACE(COMP_DOWN, "Card successfully reset\n");
2026 #endif
2027 #if 0
2028 if(NIC_8187 == priv->card_8187) {
2029
2030 printk("This is RTL8187 Reset procedure\n");
2031 rtl8192_set_mode(dev,EPROM_CMD_LOAD);
2032 force_pci_posting(dev);
2033 mdelay(200);
2034
2035 /* after the eeprom load cycle, make sure we have
2036 * correct anaparams
2037 */
2038 rtl8192_set_anaparam(dev, RTL8225_ANAPARAM_ON);
2039 rtl8185_set_anaparam2(dev, RTL8225_ANAPARAM2_ON);
2040 }
2041 else
2042 #endif
2043 printk("This is RTL8187B Reset procedure\n");
2044
2045 }
2046 #endif
2047 inline u16 ieeerate2rtlrate(int rate)
2048 {
2049 switch(rate){
2050 case 10:
2051 return 0;
2052 case 20:
2053 return 1;
2054 case 55:
2055 return 2;
2056 case 110:
2057 return 3;
2058 case 60:
2059 return 4;
2060 case 90:
2061 return 5;
2062 case 120:
2063 return 6;
2064 case 180:
2065 return 7;
2066 case 240:
2067 return 8;
2068 case 360:
2069 return 9;
2070 case 480:
2071 return 10;
2072 case 540:
2073 return 11;
2074 default:
2075 return 3;
2076
2077 }
2078 }
2079 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
2080 inline u16 rtl8192_rate2rate(short rate)
2081 {
2082 if (rate >11) return 0;
2083 return rtl_rate[rate];
2084 }
2085
2086
2087 /* The protype of rx_isr has changed since one verion of Linux Kernel */
2088 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
2089 static void rtl8192_rx_isr(struct urb *urb, struct pt_regs *regs)
2090 #else
2091 static void rtl8192_rx_isr(struct urb *urb)
2092 #endif
2093 {
2094 struct sk_buff *skb = (struct sk_buff *) urb->context;
2095 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
2096 struct net_device *dev = info->dev;
2097 struct r8192_priv *priv = ieee80211_priv(dev);
2098 int out_pipe = info->out_pipe;
2099 int err;
2100 if(!priv->up)
2101 return;
2102 if (unlikely(urb->status)) {
2103 info->urb = NULL;
2104 priv->stats.rxstaterr++;
2105 priv->ieee80211->stats.rx_errors++;
2106 usb_free_urb(urb);
2107 // printk("%s():rx status err\n",__FUNCTION__);
2108 return;
2109 }
2110 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,14)
2111 skb_unlink(skb, &priv->rx_queue);
2112 #else
2113 /*
2114 * __skb_unlink before linux2.6.14 does not use spinlock to protect list head.
2115 * add spinlock function manually. john,2008/12/03
2116 */
2117 {
2118 unsigned long flags;
2119 spin_lock_irqsave(&(priv->rx_queue.lock), flags);
2120 __skb_unlink(skb,&priv->rx_queue);
2121 spin_unlock_irqrestore(&(priv->rx_queue.lock), flags);
2122 }
2123 #endif
2124 skb_put(skb, urb->actual_length);
2125
2126 skb_queue_tail(&priv->skb_queue, skb);
2127 tasklet_schedule(&priv->irq_rx_tasklet);
2128
2129 skb = dev_alloc_skb(RX_URB_SIZE);
2130 if (unlikely(!skb)) {
2131 usb_free_urb(urb);
2132 printk("%s():can,t alloc skb\n",__FUNCTION__);
2133 /* TODO check rx queue length and refill *somewhere* */
2134 return;
2135 }
2136
2137 usb_fill_bulk_urb(urb, priv->udev,
2138 usb_rcvbulkpipe(priv->udev, out_pipe), skb->tail,
2139 RX_URB_SIZE, rtl8192_rx_isr, skb);
2140
2141 info = (struct rtl8192_rx_info *) skb->cb;
2142 info->urb = urb;
2143 info->dev = dev;
2144 info->out_pipe = out_pipe;
2145
2146 urb->transfer_buffer = skb->tail;
2147 urb->context = skb;
2148 skb_queue_tail(&priv->rx_queue, skb);
2149 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
2150 err = usb_submit_urb(urb, GFP_ATOMIC);
2151 #else
2152 err = usb_submit_urb(urb);
2153 #endif
2154 if(err && err != EPERM)
2155 printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
2156 }
2157
2158 u32
2159 rtl819xusb_rx_command_packet(
2160 struct net_device *dev,
2161 struct ieee80211_rx_stats *pstats
2162 )
2163 {
2164 u32 status;
2165
2166 //RT_TRACE(COMP_RECV, DBG_TRACE, ("---> RxCommandPacketHandle819xUsb()\n"));
2167
2168 status = cmpk_message_handle_rx(dev, pstats);
2169 if (status)
2170 {
2171 DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
2172 }
2173 else
2174 {
2175 //RT_TRACE(COMP_RECV, DBG_TRACE, ("RxCommandPacketHandle819xUsb: It is not a command packet\n"));
2176 }
2177
2178 //RT_TRACE(COMP_RECV, DBG_TRACE, ("<--- RxCommandPacketHandle819xUsb()\n"));
2179 return status;
2180 }
2181
2182 #if 0
2183 void rtl8192_tx_queues_stop(struct net_device *dev)
2184 {
2185 //struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
2186 u8 dma_poll_mask = (1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
2187 dma_poll_mask |= (1<<TX_DMA_STOP_HIPRIORITY_SHIFT);
2188 dma_poll_mask |= (1<<TX_DMA_STOP_NORMPRIORITY_SHIFT);
2189 dma_poll_mask |= (1<<TX_DMA_STOP_BEACON_SHIFT);
2190
2191 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
2192 write_nic_byte(dev,TX_DMA_POLLING,dma_poll_mask);
2193 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
2194 }
2195 #endif
2196
2197 void rtl8192_data_hard_stop(struct net_device *dev)
2198 {
2199 //FIXME !!
2200 #if 0
2201 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
2202 priv->dma_poll_mask |= (1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
2203 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
2204 write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
2205 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
2206 #endif
2207 }
2208
2209
2210 void rtl8192_data_hard_resume(struct net_device *dev)
2211 {
2212 // FIXME !!
2213 #if 0
2214 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
2215 priv->dma_poll_mask &= ~(1<<TX_DMA_STOP_LOWPRIORITY_SHIFT);
2216 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
2217 write_nic_byte(dev,TX_DMA_POLLING,priv->dma_poll_mask);
2218 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
2219 #endif
2220 }
2221
2222 /* this function TX data frames when the ieee80211 stack requires this.
2223 * It checks also if we need to stop the ieee tx queue, eventually do it
2224 */
2225 void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
2226 {
2227 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
2228 int ret;
2229 unsigned long flags;
2230 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2231 u8 queue_index = tcb_desc->queue_index;
2232
2233 /* shall not be referred by command packet */
2234 assert(queue_index != TXCMD_QUEUE);
2235
2236 spin_lock_irqsave(&priv->tx_lock,flags);
2237
2238 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
2239 // tcb_desc->RATRIndex = 7;
2240 // tcb_desc->bTxDisableRateFallBack = 1;
2241 // tcb_desc->bTxUseDriverAssingedRate = 1;
2242 tcb_desc->bTxEnableFwCalcDur = 1;
2243 skb_push(skb, priv->ieee80211->tx_headroom);
2244 ret = priv->ops->rtl819x_tx(dev, skb);
2245
2246 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
2247 //priv->ieee80211->stats.tx_packets++;
2248
2249 spin_unlock_irqrestore(&priv->tx_lock,flags);
2250
2251 // return ret;
2252 return;
2253 }
2254
2255 /* This is a rough attempt to TX a frame
2256 * This is called by the ieee 80211 stack to TX management frames.
2257 * If the ring is full packet are dropped (for data frame the queue
2258 * is stopped before this can happen).
2259 */
2260 int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
2261 {
2262 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
2263 int ret;
2264 unsigned long flags;
2265 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2266 u8 queue_index = tcb_desc->queue_index;
2267
2268
2269 spin_lock_irqsave(&priv->tx_lock,flags);
2270
2271 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
2272 if(queue_index == TXCMD_QUEUE) {
2273 skb_push(skb, USB_HWDESC_HEADER_LEN);
2274 priv->ops->rtl819x_tx_cmd(dev, skb);
2275 ret = 1;
2276 spin_unlock_irqrestore(&priv->tx_lock,flags);
2277 return ret;
2278 } else {
2279 skb_push(skb, priv->ieee80211->tx_headroom);
2280 ret = priv->ops->rtl819x_tx(dev, skb);
2281 }
2282
2283 spin_unlock_irqrestore(&priv->tx_lock,flags);
2284
2285 return ret;
2286 }
2287
2288
2289 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
2290
2291 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2292 u16 DrvAggr_PaddingAdd(struct net_device *dev, struct sk_buff *skb)
2293 {
2294 u16 PaddingNum = 256 - ((skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES) % 256);
2295 return (PaddingNum&0xff);
2296 }
2297
2298 u8 MRateToHwRate8190Pci(u8 rate);
2299 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc);
2300 u8 MapHwQueueToFirmwareQueue(u8 QueueID);
2301 struct sk_buff *DrvAggr_Aggregation(struct net_device *dev, struct ieee80211_drv_agg_txb *pSendList)
2302 {
2303 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
2304 struct ieee80211_device *ieee = netdev_priv(dev);
2305 #else
2306 struct ieee80211_device *ieee = (struct ieee80211_device *)dev->priv;
2307 #endif
2308 struct r8192_priv *priv = ieee80211_priv(dev);
2309 cb_desc *tcb_desc = NULL;
2310 u8 i;
2311 u32 TotalLength;
2312 struct sk_buff *skb;
2313 struct sk_buff *agg_skb;
2314 tx_desc_819x_usb_aggr_subframe *tx_agg_desc = NULL;
2315 tx_fwinfo_819x_usb *tx_fwinfo = NULL;
2316
2317 //
2318 // Local variable initialization.
2319 //
2320 /* first skb initialization */
2321 skb = pSendList->tx_agg_frames[0];
2322 TotalLength = skb->len;
2323
2324 /* Get the total aggregation length including the padding space and
2325 * sub frame header.
2326 */
2327 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
2328 TotalLength += DrvAggr_PaddingAdd(dev, skb);
2329 skb = pSendList->tx_agg_frames[i];
2330 TotalLength += (skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
2331 }
2332
2333 /* allocate skb to contain the aggregated packets */
2334 agg_skb = dev_alloc_skb(TotalLength + ieee->tx_headroom);
2335 memset(agg_skb->data, 0, agg_skb->len);
2336 skb_reserve(agg_skb, ieee->tx_headroom);
2337
2338 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
2339 /* reserve info for first subframe Tx descriptor to be set in the tx function */
2340 skb = pSendList->tx_agg_frames[0];
2341 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2342 tcb_desc->drv_agg_enable = 1;
2343 tcb_desc->pkt_size = skb->len;
2344 tcb_desc->DrvAggrNum = pSendList->nr_drv_agg_frames;
2345 printk("DrvAggNum = %d\n", tcb_desc->DrvAggrNum);
2346 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
2347 // printk("========>skb->data ======> \n");
2348 // RT_DEBUG_DATA(COMP_SEND, skb->data, skb->len);
2349 memcpy(agg_skb->cb, skb->cb, sizeof(skb->cb));
2350 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
2351
2352 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
2353 /* push the next sub frame to be 256 byte aline */
2354 skb_put(agg_skb,DrvAggr_PaddingAdd(dev,skb));
2355
2356 /* Subframe drv Tx descriptor and firmware info setting */
2357 skb = pSendList->tx_agg_frames[i];
2358 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2359 tx_agg_desc = (tx_desc_819x_usb_aggr_subframe *)agg_skb->tail;
2360 tx_fwinfo = (tx_fwinfo_819x_usb *)(agg_skb->tail + sizeof(tx_desc_819x_usb_aggr_subframe));
2361
2362 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
2363 /* DWORD 0 */
2364 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
2365 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
2366 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
2367 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
2368 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
2369 tx_fwinfo->AllowAggregation = 1;
2370 /* DWORD 1 */
2371 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
2372 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
2373 } else {
2374 tx_fwinfo->AllowAggregation = 0;
2375 /* DWORD 1 */
2376 tx_fwinfo->RxMF = 0;
2377 tx_fwinfo->RxAMD = 0;
2378 }
2379
2380 /* Protection mode related */
2381 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
2382 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
2383 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
2384 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
2385 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
2386 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
2387 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
2388 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
2389 (tcb_desc->bRTSUseShortGI?1:0);
2390
2391 /* Set Bandwidth and sub-channel settings. */
2392 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
2393 {
2394 if(tcb_desc->bPacketBW) {
2395 tx_fwinfo->TxBandwidth = 1;
2396 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
2397 } else {
2398 tx_fwinfo->TxBandwidth = 0;
2399 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
2400 }
2401 } else {
2402 tx_fwinfo->TxBandwidth = 0;
2403 tx_fwinfo->TxSubCarrier = 0;
2404 }
2405
2406 /* Fill Tx descriptor */
2407 memset(tx_agg_desc, 0, sizeof(tx_desc_819x_usb_aggr_subframe));
2408 /* DWORD 0 */
2409 //tx_agg_desc->LINIP = 0;
2410 //tx_agg_desc->CmdInit = 1;
2411 tx_agg_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
2412 /* already raw data, need not to substract header length */
2413 tx_agg_desc->PktSize = skb->len & 0xffff;
2414
2415 /*DWORD 1*/
2416 tx_agg_desc->SecCAMID= 0;
2417 tx_agg_desc->RATid = tcb_desc->RATRIndex;
2418 #if 0
2419 /* Fill security related */
2420 if( pTcb->bEncrypt && !Adapter->MgntInfo.SecurityInfo.SWTxEncryptFlag)
2421 {
2422 EncAlg = SecGetEncryptionOverhead(
2423 Adapter,
2424 &EncryptionMPDUHeadOverhead,
2425 &EncryptionMPDUTailOverhead,
2426 NULL,
2427 NULL,
2428 FALSE,
2429 FALSE);
2430 //2004/07/22, kcwu, EncryptionMPDUHeadOverhead has been added in previous code
2431 //MPDUOverhead = EncryptionMPDUHeadOverhead + EncryptionMPDUTailOverhead;
2432 MPDUOverhead = EncryptionMPDUTailOverhead;
2433 tx_agg_desc->NoEnc = 0;
2434 RT_TRACE(COMP_SEC, DBG_LOUD, ("******We in the loop SecCAMID is %d SecDescAssign is %d The Sec is %d********\n",tx_agg_desc->SecCAMID,tx_agg_desc->SecDescAssign,EncAlg));
2435 //CamDumpAll(Adapter);
2436 }
2437 else
2438 #endif
2439 {
2440 //MPDUOverhead = 0;
2441 tx_agg_desc->NoEnc = 1;
2442 }
2443 #if 0
2444 switch(EncAlg){
2445 case NO_Encryption:
2446 tx_agg_desc->SecType = 0x0;
2447 break;
2448 case WEP40_Encryption:
2449 case WEP104_Encryption:
2450 tx_agg_desc->SecType = 0x1;
2451 break;
2452 case TKIP_Encryption:
2453 tx_agg_desc->SecType = 0x2;
2454 break;
2455 case AESCCMP_Encryption:
2456 tx_agg_desc->SecType = 0x3;
2457 break;
2458 default:
2459 tx_agg_desc->SecType = 0x0;
2460 break;
2461 }
2462 #else
2463 tx_agg_desc->SecType = 0x0;
2464 #endif
2465
2466 if (tcb_desc->bHwSec) {
2467 switch (priv->ieee80211->pairwise_key_type)
2468 {
2469 case KEY_TYPE_WEP40:
2470 case KEY_TYPE_WEP104:
2471 tx_agg_desc->SecType = 0x1;
2472 tx_agg_desc->NoEnc = 0;
2473 break;
2474 case KEY_TYPE_TKIP:
2475 tx_agg_desc->SecType = 0x2;
2476 tx_agg_desc->NoEnc = 0;
2477 break;
2478 case KEY_TYPE_CCMP:
2479 tx_agg_desc->SecType = 0x3;
2480 tx_agg_desc->NoEnc = 0;
2481 break;
2482 case KEY_TYPE_NA:
2483 tx_agg_desc->SecType = 0x0;
2484 tx_agg_desc->NoEnc = 1;
2485 break;
2486 }
2487 }
2488
2489 tx_agg_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
2490 tx_agg_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
2491
2492 tx_agg_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
2493 tx_agg_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
2494
2495 tx_agg_desc->OWN = 1;
2496
2497 //DWORD 2
2498 /* According windows driver, it seems that there no need to fill this field */
2499 //tx_agg_desc->TxBufferSize= (u32)(skb->len - USB_HWDESC_HEADER_LEN);
2500
2501 /* to fill next packet */
2502 skb_put(agg_skb,TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
2503 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
2504 }
2505
2506 for(i = 0; i < pSendList->nr_drv_agg_frames; i++) {
2507 dev_kfree_skb_any(pSendList->tx_agg_frames[i]);
2508 }
2509
2510 return agg_skb;
2511 }
2512
2513 /* NOTE:
2514 This function return a list of PTCB which is proper to be aggregate with the input TCB.
2515 If no proper TCB is found to do aggregation, SendList will only contain the input TCB.
2516 */
2517 u8 DrvAggr_GetAggregatibleList(struct net_device *dev, struct sk_buff *skb,
2518 struct ieee80211_drv_agg_txb *pSendList)
2519 {
2520 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
2521 struct ieee80211_device *ieee = netdev_priv(dev);
2522 #else
2523 struct ieee80211_device *ieee = (struct ieee80211_device *)dev->priv;
2524 #endif
2525 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
2526 u16 nMaxAggrNum = pHTInfo->UsbTxAggrNum;
2527 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2528 u8 QueueID = tcb_desc->queue_index;
2529
2530 do {
2531 pSendList->tx_agg_frames[pSendList->nr_drv_agg_frames++] = skb;
2532 if(pSendList->nr_drv_agg_frames >= nMaxAggrNum) {
2533 break;
2534 }
2535
2536 } while((skb = skb_dequeue(&ieee->skb_drv_aggQ[QueueID])));
2537
2538 RT_TRACE(COMP_AMSDU, "DrvAggr_GetAggregatibleList, nAggrTcbNum = %d \n", pSendList->nr_drv_agg_frames);
2539 return pSendList->nr_drv_agg_frames;
2540 }
2541 #endif
2542
2543 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
2544 static void rtl8192_tx_isr(struct urb *tx_urb, struct pt_regs *reg)
2545 #else
2546 static void rtl8192_tx_isr(struct urb *tx_urb)
2547 #endif
2548 {
2549 struct sk_buff *skb = (struct sk_buff*)tx_urb->context;
2550 struct net_device *dev = NULL;
2551 struct r8192_priv *priv = NULL;
2552 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2553 u8 queue_index = tcb_desc->queue_index;
2554 // bool bToSend0Byte;
2555 // u16 BufLen = skb->len;
2556
2557 memcpy(&dev,(struct net_device*)(skb->cb),sizeof(struct net_device*));
2558 priv = ieee80211_priv(dev);
2559
2560 if(tcb_desc->queue_index != TXCMD_QUEUE) {
2561 if(tx_urb->status == 0) {
2562 // dev->trans_start = jiffies;
2563 // As act as station mode, destion shall be unicast address.
2564 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
2565 //priv->ieee80211->stats.tx_packets++;
2566 priv->stats.txoktotal++;
2567 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
2568 priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
2569 } else {
2570 priv->ieee80211->stats.tx_errors++;
2571 //priv->stats.txmanageerr++;
2572 /* TODO */
2573 }
2574 }
2575
2576 /* free skb and tx_urb */
2577 if(skb != NULL) {
2578 dev_kfree_skb_any(skb);
2579 usb_free_urb(tx_urb);
2580 atomic_dec(&priv->tx_pending[queue_index]);
2581 }
2582
2583 #if 0 //we need to send zero byte packet just after 512 byte(64 byte)packet is transmitted, or we will halt. It will greatly reduced available page in FW, and ruin our throughput. WB 2008.08.27
2584 if(BufLen > 0 && ((BufLen % 512 == 0)||(BufLen % 64 == 0))) {
2585 bToSend0Byte = true;
2586 }
2587
2588 bToSend0Byte = false;
2589 //
2590 // Note that, we at most handle 1 MPDU to send here, either
2591 // fragment or MPDU in wait queue.
2592 //
2593 if(!bToSend0Byte)
2594 #endif
2595 {
2596 //
2597 // Handle HW Beacon:
2598 // We had transfer our beacon frame to host controler at this moment.
2599 //
2600 #if 0
2601 if(tcb_desc->tx_queue == BEACON_QUEUE)
2602 {
2603 priv->bSendingBeacon = FALSE;
2604 }
2605 #endif
2606 //
2607 // Caution:
2608 // Handling the wait queue of command packets.
2609 // For Tx command packets, we must not do TCB fragment because it is not handled right now.
2610 // We must cut the packets to match the size of TX_CMD_PKT before we send it.
2611 //
2612 if (queue_index == MGNT_QUEUE){
2613 if (priv->ieee80211->ack_tx_to_ieee){
2614 if (rtl8192_is_tx_queue_empty(dev)){
2615 priv->ieee80211->ack_tx_to_ieee = 0;
2616 ieee80211_ps_tx_ack(priv->ieee80211, 1);
2617 }
2618 }
2619 }
2620 /* Handle MPDU in wait queue. */
2621 if(queue_index != BEACON_QUEUE) {
2622 /* Don't send data frame during scanning.*/
2623 if((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0)&&\
2624 (!(priv->ieee80211->queue_stop))) {
2625 if(NULL != (skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]))))
2626 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
2627
2628 return; //modified by david to avoid further processing AMSDU
2629 }
2630 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2631 else if ((skb_queue_len(&priv->ieee80211->skb_drv_aggQ[queue_index])!= 0)&&\
2632 (!(priv->ieee80211->queue_stop))) {
2633 // Tx Driver Aggregation process
2634 /* The driver will aggregation the packets according to the following stets
2635 * 1. check whether there's tx irq available, for it's a completion return
2636 * function, it should contain enough tx irq;
2637 * 2. check pakcet type;
2638 * 3. intialize sendlist, check whether the to-be send packet no greater than 1
2639 * 4. aggregation the packets, and fill firmware info and tx desc to it, etc.
2640 * 5. check whehter the packet could be sent, otherwise just insert to wait head
2641 * */
2642 skb = skb_dequeue(&priv->ieee80211->skb_drv_aggQ[queue_index]);
2643 if(!check_nic_enough_desc(dev, queue_index)) {
2644 skb_queue_head(&(priv->ieee80211->skb_drv_aggQ[queue_index]), skb);
2645 return;
2646 }
2647
2648 {
2649 /*TODO*/
2650 /*
2651 u8* pHeader = skb->data;
2652
2653 if(IsMgntQosData(pHeader) ||
2654 IsMgntQData_Ack(pHeader) ||
2655 IsMgntQData_Poll(pHeader) ||
2656 IsMgntQData_Poll_Ack(pHeader)
2657 )
2658 */
2659 {
2660 struct ieee80211_drv_agg_txb SendList;
2661
2662 memset(&SendList, 0, sizeof(struct ieee80211_drv_agg_txb));
2663 if(DrvAggr_GetAggregatibleList(dev, skb, &SendList) > 1) {
2664 skb = DrvAggr_Aggregation(dev, &SendList);
2665
2666 #if 0
2667 printk("=============>to send aggregated packet!\n");
2668 RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
2669 printk("\n=================skb->len = %d\n", skb->len);
2670 RT_DEBUG_DATA(COMP_SEND, skb->data, skb->len);
2671 #endif
2672 }
2673 }
2674 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
2675 }
2676 }
2677 #endif
2678 }
2679 }
2680
2681 #if 0
2682 else
2683 {
2684 RT_TRACE( COMP_SEND,"HalUsbOutComplete(%d): bToSend0Byte.\n", PipeIndex);
2685
2686 //
2687 // In this case, we don't return skb now.
2688 // It will be returned when the 0-byte request completed.
2689 //
2690
2691 //
2692 // Bulk out an 0-byte padding transfer.
2693 //
2694 HalUsbOut0Byte(pAdapter, PipeIndex, skb);
2695 }
2696
2697 #endif
2698 }
2699
2700 void rtl8192_beacon_stop(struct net_device *dev)
2701 {
2702 u8 msr, msrm, msr2;
2703 struct r8192_priv *priv = ieee80211_priv(dev);
2704
2705 msr = read_nic_byte(dev, MSR);
2706 msrm = msr & MSR_LINK_MASK;
2707 msr2 = msr & ~MSR_LINK_MASK;
2708
2709 if(NIC_8192U == priv->card_8192) {
2710 usb_kill_urb(priv->rx_urb[MAX_RX_URB]);
2711 }
2712 if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
2713 (msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
2714 write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
2715 write_nic_byte(dev, MSR, msr);
2716 }
2717 }
2718
2719 void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
2720 {
2721 struct r8192_priv *priv = ieee80211_priv(dev);
2722 struct ieee80211_network *net;
2723 u8 i=0, basic_rate = 0;
2724 net = & priv->ieee80211->current_network;
2725
2726 for (i=0; i<net->rates_len; i++)
2727 {
2728 basic_rate = net->rates[i]&0x7f;
2729 switch(basic_rate)
2730 {
2731 case MGN_1M: *rate_config |= RRSR_1M; break;
2732 case MGN_2M: *rate_config |= RRSR_2M; break;
2733 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
2734 case MGN_11M: *rate_config |= RRSR_11M; break;
2735 case MGN_6M: *rate_config |= RRSR_6M; break;
2736 case MGN_9M: *rate_config |= RRSR_9M; break;
2737 case MGN_12M: *rate_config |= RRSR_12M; break;
2738 case MGN_18M: *rate_config |= RRSR_18M; break;
2739 case MGN_24M: *rate_config |= RRSR_24M; break;
2740 case MGN_36M: *rate_config |= RRSR_36M; break;
2741 case MGN_48M: *rate_config |= RRSR_48M; break;
2742 case MGN_54M: *rate_config |= RRSR_54M; break;
2743 }
2744 }
2745 for (i=0; i<net->rates_ex_len; i++)
2746 {
2747 basic_rate = net->rates_ex[i]&0x7f;
2748 switch(basic_rate)
2749 {
2750 case MGN_1M: *rate_config |= RRSR_1M; break;
2751 case MGN_2M: *rate_config |= RRSR_2M; break;
2752 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
2753 case MGN_11M: *rate_config |= RRSR_11M; break;
2754 case MGN_6M: *rate_config |= RRSR_6M; break;
2755 case MGN_9M: *rate_config |= RRSR_9M; break;
2756 case MGN_12M: *rate_config |= RRSR_12M; break;
2757 case MGN_18M: *rate_config |= RRSR_18M; break;
2758 case MGN_24M: *rate_config |= RRSR_24M; break;
2759 case MGN_36M: *rate_config |= RRSR_36M; break;
2760 case MGN_48M: *rate_config |= RRSR_48M; break;
2761 case MGN_54M: *rate_config |= RRSR_54M; break;
2762 }
2763 }
2764 }
2765
2766
2767 #define SHORT_SLOT_TIME 9
2768 #define NON_SHORT_SLOT_TIME 20
2769
2770 void rtl8192_update_cap(struct net_device* dev, u16 cap)
2771 {
2772 //u32 tmp = 0;
2773 struct r8192_priv *priv = ieee80211_priv(dev);
2774 struct ieee80211_network *net = &priv->ieee80211->current_network;
2775 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
2776
2777 //LZM MOD 090303 HW_VAR_ACK_PREAMBLE
2778 #ifdef RTL8192SU
2779 if(0)
2780 {
2781 u8 tmp = 0;
2782 tmp = ((priv->nCur40MhzPrimeSC) << 5);
2783 if (priv->short_preamble)
2784 tmp |= 0x80;
2785 write_nic_byte(dev, RRSR+2, tmp);
2786 }
2787 #else
2788 {
2789 u32 tmp = 0;
2790 tmp = priv->basic_rate;
2791 if (priv->short_preamble)
2792 tmp |= BRSR_AckShortPmb;
2793 write_nic_dword(dev, RRSR, tmp);
2794 }
2795 #endif
2796
2797 if (net->mode & (IEEE_G|IEEE_N_24G))
2798 {
2799 u8 slot_time = 0;
2800 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
2801 {//short slot time
2802 slot_time = SHORT_SLOT_TIME;
2803 }
2804 else //long slot time
2805 slot_time = NON_SHORT_SLOT_TIME;
2806 priv->slot_time = slot_time;
2807 write_nic_byte(dev, SLOT_TIME, slot_time);
2808 }
2809
2810 }
2811 void rtl8192_net_update(struct net_device *dev)
2812 {
2813
2814 struct r8192_priv *priv = ieee80211_priv(dev);
2815 struct ieee80211_network *net;
2816 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
2817 u16 rate_config = 0;
2818 net = & priv->ieee80211->current_network;
2819
2820 rtl8192_config_rate(dev, &rate_config);
2821 priv->basic_rate = rate_config &= 0x15f;
2822
2823 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
2824 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
2825 //for(i=0;i<ETH_ALEN;i++)
2826 // write_nic_byte(dev,BSSID+i,net->bssid[i]);
2827
2828 rtl8192_update_msr(dev);
2829 // rtl8192_update_cap(dev, net->capability);
2830 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
2831 {
2832 write_nic_word(dev, ATIMWND, 2);
2833 write_nic_word(dev, BCN_DMATIME, 1023);
2834 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
2835 // write_nic_word(dev, BcnIntTime, 100);
2836 write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
2837 write_nic_byte(dev, BCN_ERR_THRESH, 100);
2838 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
2839 // TODO: BcnIFS may required to be changed on ASIC
2840 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
2841
2842 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
2843 }
2844
2845
2846
2847 }
2848
2849 //temporary hw beacon is not used any more.
2850 //open it when necessary
2851 #if 1
2852 void rtl819xusb_beacon_tx(struct net_device *dev,u16 tx_rate)
2853 {
2854
2855 #if 0
2856 struct r8192_priv *priv = ieee80211_priv(dev);
2857 struct sk_buff *skb;
2858 int i = 0;
2859 //u8 cr;
2860
2861 rtl8192_net_update(dev);
2862
2863 skb = ieee80211_get_beacon(priv->ieee80211);
2864 if(!skb){
2865 DMESG("not enought memory for allocating beacon");
2866 return;
2867 }
2868
2869
2870 write_nic_byte(dev, BQREQ, read_nic_byte(dev, BQREQ) | (1<<7));
2871
2872 i=0;
2873 //while(!read_nic_byte(dev,BQREQ & (1<<7)))
2874 while( (read_nic_byte(dev, BQREQ) & (1<<7)) == 0 )
2875 {
2876 msleep_interruptible_rtl(HZ/2);
2877 if(i++ > 10){
2878 DMESGW("get stuck to wait HW beacon to be ready");
2879 return ;
2880 }
2881 }
2882 skb->cb[0] = NORM_PRIORITY;
2883 skb->cb[1] = 0; //morefragment = 0
2884 skb->cb[2] = ieeerate2rtlrate(tx_rate);
2885
2886 rtl8192_tx(dev,skb);
2887
2888 #endif
2889 }
2890 #endif
2891 inline u8 rtl8192_IsWirelessBMode(u16 rate)
2892 {
2893 if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
2894 return 1;
2895 else return 0;
2896 }
2897
2898 u16 N_DBPSOfRate(u16 DataRate);
2899
2900 u16 ComputeTxTime(
2901 u16 FrameLength,
2902 u16 DataRate,
2903 u8 bManagementFrame,
2904 u8 bShortPreamble
2905 )
2906 {
2907 u16 FrameTime;
2908 u16 N_DBPS;
2909 u16 Ceiling;
2910
2911 if( rtl8192_IsWirelessBMode(DataRate) )
2912 {
2913 if( bManagementFrame || !bShortPreamble || DataRate == 10 )
2914 { // long preamble
2915 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
2916 }
2917 else
2918 { // Short preamble
2919 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
2920 }
2921 if( ( FrameLength*8 % (DataRate/10) ) != 0 ) //Get the Ceilling
2922 FrameTime ++;
2923 } else { //802.11g DSSS-OFDM PLCP length field calculation.
2924 N_DBPS = N_DBPSOfRate(DataRate);
2925 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
2926 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
2927 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
2928 }
2929 return FrameTime;
2930 }
2931
2932 u16 N_DBPSOfRate(u16 DataRate)
2933 {
2934 u16 N_DBPS = 24;
2935
2936 switch(DataRate)
2937 {
2938 case 60:
2939 N_DBPS = 24;
2940 break;
2941
2942 case 90:
2943 N_DBPS = 36;
2944 break;
2945
2946 case 120:
2947 N_DBPS = 48;
2948 break;
2949
2950 case 180:
2951 N_DBPS = 72;
2952 break;
2953
2954 case 240:
2955 N_DBPS = 96;
2956 break;
2957
2958 case 360:
2959 N_DBPS = 144;
2960 break;
2961
2962 case 480:
2963 N_DBPS = 192;
2964 break;
2965
2966 case 540:
2967 N_DBPS = 216;
2968 break;
2969
2970 default:
2971 break;
2972 }
2973
2974 return N_DBPS;
2975 }
2976
2977 void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
2978 {
2979 #if 0
2980 struct net_device *dev = (struct net_device*)tx_cmd_urb->context;
2981 struct r8192_priv *priv = ieee80211_priv(dev);
2982 int last_init_packet = 0;
2983 u8 *ptr_cmd_buf;
2984 u16 cmd_buf_len;
2985
2986 if(tx_cmd_urb->status != 0) {
2987 priv->pFirmware.firmware_seg_index = 0; //only begin transter, should it can be set to 1
2988 }
2989
2990 /* Free the urb and the corresponding buf for common Tx cmd packet, or
2991 * last segment of each firmware img.
2992 */
2993 if((priv->pFirmware.firmware_seg_index == 0) ||(priv->pFirmware.firmware_seg_index == priv->pFirmware.firmware_seg_maxnum)) {
2994 priv->pFirmware.firmware_seg_index = 0;//only begin transter, should it can be set to 1
2995 } else {
2996 /* prepare for last transfer */
2997 /* update some infomation for */
2998 /* last segment of the firmware img need indicate to device */
2999 priv->pFirmware.firmware_seg_index++;
3000 if(priv->pFirmware.firmware_seg_index == priv->pFirmware.firmware_seg_maxnum) {
3001 last_init_packet = 1;
3002 }
3003
3004 cmd_buf_len = priv->pFirmware.firmware_seg_container[priv->pFirmware.firmware_seg_index-1].seg_size;
3005 ptr_cmd_buf = priv->pFfirmware.firmware_seg_container[priv->pFfirmware.firmware_seg_index-1].seg_ptr;
3006 rtl819xU_tx_cmd(dev, ptr_cmd_buf, cmd_buf_len, last_init_packet, DESC_PACKET_TYPE_INIT);
3007 }
3008
3009 kfree(tx_cmd_urb->transfer_buffer);
3010 #endif
3011 usb_free_urb(tx_cmd_urb);
3012 }
3013
3014 unsigned int txqueue2outpipe(struct r8192_priv* priv,unsigned int tx_queue) {
3015
3016 if(tx_queue >= 9)
3017 {
3018 RT_TRACE(COMP_ERR,"%s():Unknown queue ID!!!\n",__FUNCTION__);
3019 return 0x04;
3020 }
3021 return priv->txqueue_to_outpipemap[tx_queue];
3022 }
3023
3024 #ifdef RTL8192SU
3025 short rtl8192SU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
3026 {
3027 struct r8192_priv *priv = ieee80211_priv(dev);
3028 int status;
3029 struct urb *tx_urb;
3030 unsigned int idx_pipe;
3031 tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
3032 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
3033 u8 queue_index = tcb_desc->queue_index;
3034 u32 PktSize = 0;
3035
3036 //printk("\n %s::::::::::::::::::::::queue_index = %d\n",__FUNCTION__, queue_index);
3037 atomic_inc(&priv->tx_pending[queue_index]);
3038
3039 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3040 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
3041 #else
3042 tx_urb = usb_alloc_urb(0);
3043 #endif
3044 if(!tx_urb){
3045 dev_kfree_skb(skb);
3046 return -ENOMEM;
3047 }
3048
3049 memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
3050
3051 /* Tx descriptor ought to be set according to the skb->cb */
3052 pdesc->LINIP = tcb_desc->bLastIniPkt;
3053 PktSize = (u16)(skb->len - USB_HWDESC_HEADER_LEN);
3054 pdesc->PktSize = PktSize;
3055 //printk("PKTSize = %d %x\n",pdesc->PktSize,pdesc->PktSize);
3056 //----------------------------------------------------------------------------
3057 // Fill up USB_OUT_CONTEXT.
3058 //----------------------------------------------------------------------------
3059 // Get index to out pipe from specified QueueID.
3060 idx_pipe = txqueue2outpipe(priv,queue_index);
3061 //printk("=============>%s queue_index:%d, outpipe:%d\n", __func__,queue_index,priv->RtOutPipes[idx_pipe]);
3062
3063 #ifdef JOHN_DUMP_TXDESC
3064 int i;
3065 printk("Len = %d\n", skb->len);
3066 for (i = 0; i < 8; i++)
3067 printk("%2.2x ", *((u8*)skb->data+i));
3068 printk("\n");
3069 #endif
3070
3071 usb_fill_bulk_urb(tx_urb,
3072 priv->udev,
3073 usb_sndbulkpipe(priv->udev,priv->RtOutPipes[idx_pipe]),
3074 skb->data,
3075 skb->len,
3076 rtl8192_tx_isr,
3077 skb);
3078
3079 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3080 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
3081 #else
3082 status = usb_submit_urb(tx_urb);
3083 #endif
3084
3085 if (!status){
3086 return 0;
3087 }else{
3088 printk("Error TX CMD URB, error %d",
3089 status);
3090 return -1;
3091 }
3092 }
3093 #else
3094 short rtl819xU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
3095 {
3096 struct r8192_priv *priv = ieee80211_priv(dev);
3097 //u8 *tx;
3098 int status;
3099 struct urb *tx_urb;
3100 //int urb_buf_len;
3101 unsigned int idx_pipe;
3102 tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
3103 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
3104 u8 queue_index = tcb_desc->queue_index;
3105
3106 //printk("\n %s::queue_index = %d\n",__FUNCTION__, queue_index);
3107 atomic_inc(&priv->tx_pending[queue_index]);
3108 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3109 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
3110 #else
3111 tx_urb = usb_alloc_urb(0);
3112 #endif
3113 if(!tx_urb){
3114 dev_kfree_skb(skb);
3115 return -ENOMEM;
3116 }
3117
3118 memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
3119 /* Tx descriptor ought to be set according to the skb->cb */
3120 pdesc->FirstSeg = 1;//bFirstSeg;
3121 pdesc->LastSeg = 1;//bLastSeg;
3122 pdesc->CmdInit = tcb_desc->bCmdOrInit;
3123 pdesc->TxBufferSize = tcb_desc->txbuf_size;
3124 pdesc->OWN = 1;
3125 pdesc->LINIP = tcb_desc->bLastIniPkt;
3126
3127 //----------------------------------------------------------------------------
3128 // Fill up USB_OUT_CONTEXT.
3129 //----------------------------------------------------------------------------
3130 // Get index to out pipe from specified QueueID.
3131 #ifndef USE_ONE_PIPE
3132 idx_pipe = txqueue2outpipe(priv,queue_index);
3133 #else
3134 idx_pipe = 0x04;
3135 #endif
3136 #ifdef JOHN_DUMP_TXDESC
3137 int i;
3138 printk("<Tx descriptor>--rate %x---",rate);
3139 for (i = 0; i < 8; i++)
3140 printk("%8x ", tx[i]);
3141 printk("\n");
3142 #endif
3143 usb_fill_bulk_urb(tx_urb,priv->udev, usb_sndbulkpipe(priv->udev,idx_pipe), \
3144 skb->data, skb->len, rtl8192_tx_isr, skb);
3145
3146 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3147 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
3148 #else
3149 status = usb_submit_urb(tx_urb);
3150 #endif
3151
3152 if (!status){
3153 return 0;
3154 }else{
3155 DMESGE("Error TX CMD URB, error %d",
3156 status);
3157 return -1;
3158 }
3159 }
3160 #endif
3161
3162 /*
3163 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
3164 * in TxFwInfo data structure
3165 * 2006.10.30 by Emily
3166 *
3167 * \param QUEUEID Software Queue
3168 */
3169 u8 MapHwQueueToFirmwareQueue(u8 QueueID)
3170 {
3171 u8 QueueSelect = 0x0; //defualt set to
3172
3173 switch(QueueID) {
3174 case BE_QUEUE:
3175 QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
3176 break;
3177
3178 case BK_QUEUE:
3179 QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
3180 break;
3181
3182 case VO_QUEUE:
3183 QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
3184 break;
3185
3186 case VI_QUEUE:
3187 QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
3188 break;
3189 case MGNT_QUEUE:
3190 QueueSelect = QSLT_MGNT;
3191 break;
3192
3193 case BEACON_QUEUE:
3194 QueueSelect = QSLT_BEACON;
3195 break;
3196
3197 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
3198 // TODO: Remove Assertions
3199 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
3200 case TXCMD_QUEUE:
3201 QueueSelect = QSLT_CMD;
3202 break;
3203 //#endif
3204 case HIGH_QUEUE:
3205 QueueSelect = QSLT_HIGH;
3206 break;
3207
3208 default:
3209 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
3210 break;
3211 }
3212 return QueueSelect;
3213 }
3214
3215 #ifdef RTL8192SU
3216 u8 MRateToHwRate8190Pci(u8 rate)
3217 {
3218 u8 ret = DESC92S_RATE1M;
3219
3220 switch(rate)
3221 {
3222 // CCK and OFDM non-HT rates
3223 case MGN_1M: ret = DESC92S_RATE1M; break;
3224 case MGN_2M: ret = DESC92S_RATE2M; break;
3225 case MGN_5_5M: ret = DESC92S_RATE5_5M; break;
3226 case MGN_11M: ret = DESC92S_RATE11M; break;
3227 case MGN_6M: ret = DESC92S_RATE6M; break;
3228 case MGN_9M: ret = DESC92S_RATE9M; break;
3229 case MGN_12M: ret = DESC92S_RATE12M; break;
3230 case MGN_18M: ret = DESC92S_RATE18M; break;
3231 case MGN_24M: ret = DESC92S_RATE24M; break;
3232 case MGN_36M: ret = DESC92S_RATE36M; break;
3233 case MGN_48M: ret = DESC92S_RATE48M; break;
3234 case MGN_54M: ret = DESC92S_RATE54M; break;
3235
3236 // HT rates since here
3237 case MGN_MCS0: ret = DESC92S_RATEMCS0; break;
3238 case MGN_MCS1: ret = DESC92S_RATEMCS1; break;
3239 case MGN_MCS2: ret = DESC92S_RATEMCS2; break;
3240 case MGN_MCS3: ret = DESC92S_RATEMCS3; break;
3241 case MGN_MCS4: ret = DESC92S_RATEMCS4; break;
3242 case MGN_MCS5: ret = DESC92S_RATEMCS5; break;
3243 case MGN_MCS6: ret = DESC92S_RATEMCS6; break;
3244 case MGN_MCS7: ret = DESC92S_RATEMCS7; break;
3245 case MGN_MCS8: ret = DESC92S_RATEMCS8; break;
3246 case MGN_MCS9: ret = DESC92S_RATEMCS9; break;
3247 case MGN_MCS10: ret = DESC92S_RATEMCS10; break;
3248 case MGN_MCS11: ret = DESC92S_RATEMCS11; break;
3249 case MGN_MCS12: ret = DESC92S_RATEMCS12; break;
3250 case MGN_MCS13: ret = DESC92S_RATEMCS13; break;
3251 case MGN_MCS14: ret = DESC92S_RATEMCS14; break;
3252 case MGN_MCS15: ret = DESC92S_RATEMCS15; break;
3253
3254 // Set the highest SG rate
3255 case MGN_MCS0_SG:
3256 case MGN_MCS1_SG:
3257 case MGN_MCS2_SG:
3258 case MGN_MCS3_SG:
3259 case MGN_MCS4_SG:
3260 case MGN_MCS5_SG:
3261 case MGN_MCS6_SG:
3262 case MGN_MCS7_SG:
3263 case MGN_MCS8_SG:
3264 case MGN_MCS9_SG:
3265 case MGN_MCS10_SG:
3266 case MGN_MCS11_SG:
3267 case MGN_MCS12_SG:
3268 case MGN_MCS13_SG:
3269 case MGN_MCS14_SG:
3270 case MGN_MCS15_SG:
3271 {
3272 ret = DESC92S_RATEMCS15_SG;
3273 break;
3274 }
3275
3276 default: break;
3277 }
3278 return ret;
3279 }
3280 #else
3281 u8 MRateToHwRate8190Pci(u8 rate)
3282 {
3283 u8 ret = DESC90_RATE1M;
3284
3285 switch(rate) {
3286 case MGN_1M: ret = DESC90_RATE1M; break;
3287 case MGN_2M: ret = DESC90_RATE2M; break;
3288 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
3289 case MGN_11M: ret = DESC90_RATE11M; break;
3290 case MGN_6M: ret = DESC90_RATE6M; break;
3291 case MGN_9M: ret = DESC90_RATE9M; break;
3292 case MGN_12M: ret = DESC90_RATE12M; break;
3293 case MGN_18M: ret = DESC90_RATE18M; break;
3294 case MGN_24M: ret = DESC90_RATE24M; break;
3295 case MGN_36M: ret = DESC90_RATE36M; break;
3296 case MGN_48M: ret = DESC90_RATE48M; break;
3297 case MGN_54M: ret = DESC90_RATE54M; break;
3298
3299 // HT rate since here
3300 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
3301 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
3302 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
3303 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
3304 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
3305 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
3306 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
3307 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
3308 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
3309 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
3310 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
3311 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
3312 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
3313 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
3314 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
3315 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
3316 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
3317
3318 default: break;
3319 }
3320 return ret;
3321 }
3322 #endif
3323
3324 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
3325 {
3326 u8 tmp_Short;
3327
3328 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
3329
3330 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
3331 tmp_Short = 0;
3332
3333 return tmp_Short;
3334 }
3335
3336 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20)
3337 static void tx_zero_isr(struct urb *tx_urb, struct pt_regs *reg)
3338 #else
3339 static void tx_zero_isr(struct urb *tx_urb)
3340 #endif
3341 {
3342 return;
3343 }
3344
3345
3346 #ifdef RTL8192SU
3347 /*
3348 * The tx procedure is just as following, skb->cb will contain all the following
3349 *information: * priority, morefrag, rate, &dev.
3350 * */
3351 // <Note> Buffer format for 8192S Usb bulk out:
3352 //
3353 // --------------------------------------------------
3354 // | 8192S Usb Tx Desc | 802_11_MAC_header | data |
3355 // --------------------------------------------------
3356 // | 32 bytes | 24 bytes |0-2318 bytes|
3357 // --------------------------------------------------
3358 // |<------------ BufferLen ------------------------->|
3359
3360 short rtl8192SU_tx(struct net_device *dev, struct sk_buff* skb)
3361 {
3362 struct r8192_priv *priv = ieee80211_priv(dev);
3363 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
3364 tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
3365 //tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);//92su del
3366 struct usb_device *udev = priv->udev;
3367 int pend;
3368 int status;
3369 struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
3370 //int urb_len;
3371 unsigned int idx_pipe;
3372 u16 MPDUOverhead = 0;
3373 //RT_DEBUG_DATA(COMP_SEND, tcb_desc, sizeof(cb_desc));
3374
3375 #if 0
3376 /* Added by Annie for filling Len_Adjust field. 2005-12-14. */
3377 RT_ENC_ALG EncAlg = NO_Encryption;
3378 #endif
3379
3380
3381 pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
3382 /* we are locked here so the two atomic_read and inc are executed
3383 * without interleaves * !!! For debug purpose */
3384 if( pend > MAX_TX_URB){
3385 switch (tcb_desc->queue_index) {
3386 case VO_PRIORITY:
3387 priv->stats.txvodrop++;
3388 break;
3389 case VI_PRIORITY:
3390 priv->stats.txvidrop++;
3391 break;
3392 case BE_PRIORITY:
3393 priv->stats.txbedrop++;
3394 break;
3395 default://BK_PRIORITY
3396 priv->stats.txbkdrop++;
3397 break;
3398 }
3399 printk("To discard skb packet!\n");
3400 dev_kfree_skb_any(skb);
3401 return -1;
3402 }
3403
3404 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3405 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
3406 #else
3407 tx_urb = usb_alloc_urb(0);
3408 #endif
3409 if(!tx_urb){
3410 dev_kfree_skb_any(skb);
3411 return -ENOMEM;
3412 }
3413
3414 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
3415
3416
3417 #if RTL8192SU_FPGA_UNSPECIFIED_NETWORK
3418 if(IsQoSDataFrame(skb->data))
3419 {
3420 tcb_desc->bAMPDUEnable = TRUE;
3421 tx_desc->NonQos = 0;
3422 }
3423 else
3424 tcb_desc->bAMPDUEnable = FALSE;
3425
3426 tcb_desc->bPacketBW = TRUE;
3427 priv->CurrentChannelBW = HT_CHANNEL_WIDTH_20_40;
3428 #endif
3429
3430 #if (defined (RTL8192SU_FPGA_2MAC_VERIFICATION)||defined (RTL8192SU_ASIC_VERIFICATION))
3431 tx_desc->NonQos = (IsQoSDataFrame(skb->data)==TRUE)? 0:1;
3432 #endif
3433
3434 /* Fill Tx descriptor */
3435 //memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
3436
3437 // This part can just fill to the first descriptor of the frame.
3438 /* DWORD 0 */
3439 tx_desc->TxHT = (tcb_desc->data_rate&0x80)?1:0;
3440
3441 #ifdef RTL8192SU_DISABLE_CCK_RATE
3442 if(tx_hal_is_cck_rate(tcb_desc->data_rate))
3443 tcb_desc->data_rate = MGN_6M;
3444 #endif
3445
3446 tx_desc->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
3447 //tx_desc->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
3448 tx_desc->TxShort = QueryIsShort(tx_desc->TxHT, tx_desc->TxRate, tcb_desc);
3449
3450
3451 // Aggregation related
3452 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
3453 tx_desc->AllowAggregation = 1;
3454 /* DWORD 1 */
3455 //tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
3456 //tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
3457 } else {
3458 tx_desc->AllowAggregation = 0;
3459 /* DWORD 1 */
3460 //tx_fwinfo->RxMF = 0;
3461 //tx_fwinfo->RxAMD = 0;
3462 }
3463
3464 //
3465 // <Roger_Notes> For AMPDU case, we must insert SSN into TX_DESC,
3466 // FW according as this SSN to do necessary packet retry.
3467 // 2008.06.06.
3468 //
3469 {
3470 u8 *pSeq;
3471 u16 Temp;
3472 //pSeq = (u8 *)(VirtualAddress+USB_HWDESC_HEADER_LEN + FRAME_OFFSET_SEQUENCE);
3473 pSeq = (u8 *)(skb->data+USB_HWDESC_HEADER_LEN + 22);
3474 Temp = pSeq[0];
3475 Temp <<= 12;
3476 Temp |= (*(u16 *)pSeq)>>4;
3477 tx_desc->Seq = Temp;
3478 }
3479
3480 /* Protection mode related */
3481 tx_desc->RTSEn = (tcb_desc->bRTSEnable)?1:0;
3482 tx_desc->CTS2Self = (tcb_desc->bCTSEnable)?1:0;
3483 tx_desc->RTSSTBC = (tcb_desc->bRTSSTBC)?1:0;
3484 tx_desc->RTSHT = (tcb_desc->rts_rate&0x80)?1:0;
3485 tx_desc->RTSRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
3486 tx_desc->RTSSubcarrier = (tx_desc->RTSHT==0)?(tcb_desc->RTSSC):0;
3487 tx_desc->RTSBW = (tx_desc->RTSHT==1)?((tcb_desc->bRTSBW)?1:0):0;
3488 tx_desc->RTSShort = (tx_desc->RTSHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
3489 (tcb_desc->bRTSUseShortGI?1:0);
3490 //LZM 090219
3491 tx_desc->DisRTSFB = 0;
3492 tx_desc->RTSRateFBLmt = 0xf;
3493
3494 // <Roger_EXP> 2008.09.22. We disable RTS rate fallback temporarily.
3495 //tx_desc->DisRTSFB = 0x01;
3496
3497 /* Set Bandwidth and sub-channel settings. */
3498 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
3499 {
3500 if(tcb_desc->bPacketBW) {
3501 tx_desc->TxBandwidth = 1;
3502 tx_desc->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
3503 } else {
3504 tx_desc->TxBandwidth = 0;
3505 tx_desc->TxSubCarrier = priv->nCur40MhzPrimeSC;
3506 }
3507 } else {
3508 tx_desc->TxBandwidth = 0;
3509 tx_desc->TxSubCarrier = 0;
3510 }
3511
3512 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3513 if (tcb_desc->drv_agg_enable)
3514 {
3515 //tx_desc->Tx_INFO_RSVD = (tcb_desc->DrvAggrNum & 0x1f) << 1; //92su del
3516 }
3517 #endif
3518
3519 //memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
3520 /* DWORD 0 */
3521 tx_desc->LINIP = 0;
3522 //tx_desc->CmdInit = 1; //92su del
3523 tx_desc->Offset = USB_HWDESC_HEADER_LEN;
3524
3525 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3526 if (tcb_desc->drv_agg_enable) {
3527 tx_desc->PktSize = tcb_desc->pkt_size;//FIXLZM
3528 } else
3529 #endif
3530 {
3531 tx_desc->PktSize = (skb->len - USB_HWDESC_HEADER_LEN) & 0xffff;
3532 }
3533
3534 /*DWORD 1*/
3535 //tx_desc->SecCAMID= 0;//92su del
3536 tx_desc->RaBRSRID= tcb_desc->RATRIndex;
3537 //#ifdef RTL8192S_PREPARE_FOR_NORMAL_RELEASE
3538 #if 0//LZM 090219
3539 tx_desc->RaBRSRID= 1;
3540 #endif
3541
3542 #if 0
3543 /* Fill security related */
3544 if( pTcb->bEncrypt && !Adapter->MgntInfo.SecurityInfo.SWTxEncryptFlag)
3545 {
3546 EncAlg = SecGetEncryptionOverhead(
3547 Adapter,
3548 &EncryptionMPDUHeadOverhead,
3549 &EncryptionMPDUTailOverhead,
3550 NULL,
3551 NULL,
3552 FALSE,
3553 FALSE);
3554 //2004/07/22, kcwu, EncryptionMPDUHeadOverhead has been added in previous code
3555 //MPDUOverhead = EncryptionMPDUHeadOverhead + EncryptionMPDUTailOverhead;
3556 MPDUOverhead = EncryptionMPDUTailOverhead;
3557 tx_desc->NoEnc = 0;
3558 RT_TRACE(COMP_SEC, DBG_LOUD, ("******We in the loop SecCAMID is %d SecDescAssign is %d The Sec is %d********\n",tx_desc->SecCAMID,tx_desc->SecDescAssign,EncAlg));
3559 //CamDumpAll(Adapter);
3560 }
3561 else
3562 #endif
3563 {
3564 MPDUOverhead = 0;
3565 //tx_desc->NoEnc = 1;//92su del
3566 }
3567 #if 0
3568 switch(EncAlg){
3569 case NO_Encryption:
3570 tx_desc->SecType = 0x0;
3571 break;
3572 case WEP40_Encryption:
3573 case WEP104_Encryption:
3574 tx_desc->SecType = 0x1;
3575 break;
3576 case TKIP_Encryption:
3577 tx_desc->SecType = 0x2;
3578 break;
3579 case AESCCMP_Encryption:
3580 tx_desc->SecType = 0x3;
3581 break;
3582 default:
3583 tx_desc->SecType = 0x0;
3584 break;
3585 }
3586 #else
3587 tx_desc->SecType = 0x0;
3588 #endif
3589 if (tcb_desc->bHwSec)
3590 {
3591 switch (priv->ieee80211->pairwise_key_type)
3592 {
3593 case KEY_TYPE_WEP40:
3594 case KEY_TYPE_WEP104:
3595 tx_desc->SecType = 0x1;
3596 //tx_desc->NoEnc = 0;//92su del
3597 break;
3598 case KEY_TYPE_TKIP:
3599 tx_desc->SecType = 0x2;
3600 //tx_desc->NoEnc = 0;//92su del
3601 break;
3602 case KEY_TYPE_CCMP:
3603 tx_desc->SecType = 0x3;
3604 //tx_desc->NoEnc = 0;//92su del
3605 break;
3606 case KEY_TYPE_NA:
3607 tx_desc->SecType = 0x0;
3608 //tx_desc->NoEnc = 1;//92su del
3609 break;
3610 default:
3611 tx_desc->SecType = 0x0;
3612 //tx_desc->NoEnc = 1;//92su del
3613 break;
3614 }
3615 }
3616
3617 //tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);//92su del
3618
3619
3620 tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
3621 tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
3622 tx_desc->DataRateFBLmt = 0x1F;// Alwasy enable all rate fallback range
3623
3624 tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
3625
3626
3627 /* Fill fields that are required to be initialized in all of the descriptors */
3628 //DWORD 0
3629 #if 0
3630 tx_desc->FirstSeg = (tcb_desc->bFirstSeg)? 1:0;
3631 tx_desc->LastSeg = (tcb_desc->bLastSeg)?1:0;
3632 #else
3633 tx_desc->FirstSeg = 1;
3634 tx_desc->LastSeg = 1;
3635 #endif
3636 tx_desc->OWN = 1;
3637
3638 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3639 if (tcb_desc->drv_agg_enable) {
3640 tx_desc->TxBufferSize = tcb_desc->pkt_size + sizeof(tx_fwinfo_819x_usb);
3641 } else
3642 #endif
3643 {
3644 //DWORD 2
3645 //tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
3646 tx_desc->TxBufferSize = (u32)(skb->len);//92su mod FIXLZM
3647 }
3648
3649 #if 0
3650 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(1)TxFillDescriptor8192SUsb(): DataRate(%#x)\n", pTcb->DataRate));
3651 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(2)TxFillDescriptor8192SUsb(): bTxUseDriverAssingedRate(%#x)\n", pTcb->bTxUseDriverAssingedRate));
3652 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(3)TxFillDescriptor8192SUsb(): bAMPDUEnable(%d)\n", pTcb->bAMPDUEnable));
3653 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(4)TxFillDescriptor8192SUsb(): bRTSEnable(%d)\n", pTcb->bRTSEnable));
3654 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(5)TxFillDescriptor8192SUsb(): RTSRate(%#x)\n", pTcb->RTSRate));
3655 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(6)TxFillDescriptor8192SUsb(): bCTSEnable(%d)\n", pTcb->bCTSEnable));
3656 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(7)TxFillDescriptor8192SUsb(): bUseShortGI(%d)\n", pTcb->bUseShortGI));
3657 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(8)TxFillDescriptor8192SUsb(): bPacketBW(%d)\n", pTcb->bPacketBW));
3658 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(9)TxFillDescriptor8192SUsb(): CurrentChannelBW(%d)\n", pHalData->CurrentChannelBW));
3659 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(10)TxFillDescriptor8192SUsb(): bTxDisableRateFallBack(%d)\n", pTcb->bTxDisableRateFallBack));
3660 RT_TRACE(COMP_FPGA, DBG_LOUD, ("(11)TxFillDescriptor8192SUsb(): RATRIndex(%d)\n", pTcb->RATRIndex));
3661 #endif
3662
3663 /* Get index to out pipe from specified QueueID */
3664 idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
3665 //printk("=============>%s queue_index:%d, outpipe:%d\n", __func__,tcb_desc->queue_index,priv->RtOutPipes[idx_pipe]);
3666
3667 //RT_DEBUG_DATA(COMP_SEND,tx_fwinfo,sizeof(tx_fwinfo_819x_usb));
3668 //RT_DEBUG_DATA(COMP_SEND,tx_desc,sizeof(tx_desc_819x_usb));
3669
3670 /* To submit bulk urb */
3671 usb_fill_bulk_urb(tx_urb,
3672 udev,
3673 usb_sndbulkpipe(udev,priv->RtOutPipes[idx_pipe]),
3674 skb->data,
3675 skb->len, rtl8192_tx_isr, skb);
3676
3677 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3678 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
3679 #else
3680 status = usb_submit_urb(tx_urb);
3681 #endif
3682 if (!status){
3683 //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
3684 bool bSend0Byte = false;
3685 u8 zero = 0;
3686 if(udev->speed == USB_SPEED_HIGH)
3687 {
3688 if (skb->len > 0 && skb->len % 512 == 0)
3689 bSend0Byte = true;
3690 }
3691 else
3692 {
3693 if (skb->len > 0 && skb->len % 64 == 0)
3694 bSend0Byte = true;
3695 }
3696 if (bSend0Byte)
3697 {
3698 #if 1
3699 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3700 tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
3701 #else
3702 tx_urb_zero = usb_alloc_urb(0);
3703 #endif
3704 if(!tx_urb_zero){
3705 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
3706 return -ENOMEM;
3707 }
3708 usb_fill_bulk_urb(tx_urb_zero,udev,
3709 usb_sndbulkpipe(udev,idx_pipe), &zero,
3710 0, tx_zero_isr, dev);
3711 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3712 status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
3713 #else
3714 status = usb_submit_urb(tx_urb_zero);
3715 #endif
3716 if (status){
3717 RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
3718 return -1;
3719 }
3720 #endif
3721 }
3722 dev->trans_start = jiffies;
3723 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
3724 return 0;
3725 }else{
3726 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
3727 status);
3728 return -1;
3729 }
3730 }
3731 #else
3732
3733 /*
3734 * The tx procedure is just as following,
3735 * skb->cb will contain all the following information,
3736 * priority, morefrag, rate, &dev.
3737 * */
3738 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
3739 {
3740 struct r8192_priv *priv = ieee80211_priv(dev);
3741 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
3742 tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
3743 tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);
3744 struct usb_device *udev = priv->udev;
3745 int pend;
3746 int status;
3747 struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
3748 //int urb_len;
3749 unsigned int idx_pipe;
3750 // RT_DEBUG_DATA(COMP_SEND, tcb_desc, sizeof(cb_desc));
3751 #if 0
3752 /* Added by Annie for filling Len_Adjust field. 2005-12-14. */
3753 RT_ENC_ALG EncAlg = NO_Encryption;
3754 #endif
3755 // printk("=============> %s\n", __FUNCTION__);
3756 pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
3757 /* we are locked here so the two atomic_read and inc are executed
3758 * without interleaves
3759 * !!! For debug purpose
3760 */
3761 if( pend > MAX_TX_URB){
3762 #if 0
3763 switch (tcb_desc->queue_index) {
3764 case VO_PRIORITY:
3765 priv->stats.txvodrop++;
3766 break;
3767 case VI_PRIORITY:
3768 priv->stats.txvidrop++;
3769 break;
3770 case BE_PRIORITY:
3771 priv->stats.txbedrop++;
3772 break;
3773 default://BK_PRIORITY
3774 priv->stats.txbkdrop++;
3775 break;
3776 }
3777 #endif
3778 printk("To discard skb packet!\n");
3779 dev_kfree_skb_any(skb);
3780 return -1;
3781 }
3782
3783 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3784 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
3785 #else
3786 tx_urb = usb_alloc_urb(0);
3787 #endif
3788 if(!tx_urb){
3789 dev_kfree_skb_any(skb);
3790 return -ENOMEM;
3791 }
3792
3793 /* Fill Tx firmware info */
3794 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
3795 /* DWORD 0 */
3796 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
3797 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
3798 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
3799 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
3800 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
3801 tx_fwinfo->AllowAggregation = 1;
3802 /* DWORD 1 */
3803 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
3804 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
3805 } else {
3806 tx_fwinfo->AllowAggregation = 0;
3807 /* DWORD 1 */
3808 tx_fwinfo->RxMF = 0;
3809 tx_fwinfo->RxAMD = 0;
3810 }
3811
3812 /* Protection mode related */
3813 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
3814 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
3815 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
3816 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
3817 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
3818 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
3819 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
3820 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
3821 (tcb_desc->bRTSUseShortGI?1:0);
3822
3823 /* Set Bandwidth and sub-channel settings. */
3824 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
3825 {
3826 if(tcb_desc->bPacketBW) {
3827 tx_fwinfo->TxBandwidth = 1;
3828 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
3829 } else {
3830 tx_fwinfo->TxBandwidth = 0;
3831 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
3832 }
3833 } else {
3834 tx_fwinfo->TxBandwidth = 0;
3835 tx_fwinfo->TxSubCarrier = 0;
3836 }
3837
3838 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3839 if (tcb_desc->drv_agg_enable)
3840 {
3841 tx_fwinfo->Tx_INFO_RSVD = (tcb_desc->DrvAggrNum & 0x1f) << 1;
3842 }
3843 #endif
3844 /* Fill Tx descriptor */
3845 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
3846 /* DWORD 0 */
3847 tx_desc->LINIP = 0;
3848 tx_desc->CmdInit = 1;
3849 tx_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
3850
3851 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3852 if (tcb_desc->drv_agg_enable) {
3853 tx_desc->PktSize = tcb_desc->pkt_size;
3854 } else
3855 #endif
3856 {
3857 tx_desc->PktSize = (skb->len - TX_PACKET_SHIFT_BYTES) & 0xffff;
3858 }
3859
3860 /*DWORD 1*/
3861 tx_desc->SecCAMID= 0;
3862 tx_desc->RATid = tcb_desc->RATRIndex;
3863 #if 0
3864 /* Fill security related */
3865 if( pTcb->bEncrypt && !Adapter->MgntInfo.SecurityInfo.SWTxEncryptFlag)
3866 {
3867 EncAlg = SecGetEncryptionOverhead(
3868 Adapter,
3869 &EncryptionMPDUHeadOverhead,
3870 &EncryptionMPDUTailOverhead,
3871 NULL,
3872 NULL,
3873 FALSE,
3874 FALSE);
3875 //2004/07/22, kcwu, EncryptionMPDUHeadOverhead has been added in previous code
3876 //MPDUOverhead = EncryptionMPDUHeadOverhead + EncryptionMPDUTailOverhead;
3877 MPDUOverhead = EncryptionMPDUTailOverhead;
3878 tx_desc->NoEnc = 0;
3879 RT_TRACE(COMP_SEC, DBG_LOUD, ("******We in the loop SecCAMID is %d SecDescAssign is %d The Sec is %d********\n",tx_desc->SecCAMID,tx_desc->SecDescAssign,EncAlg));
3880 //CamDumpAll(Adapter);
3881 }
3882 else
3883 #endif
3884 {
3885 //MPDUOverhead = 0;
3886 tx_desc->NoEnc = 1;
3887 }
3888 #if 0
3889 switch(EncAlg){
3890 case NO_Encryption:
3891 tx_desc->SecType = 0x0;
3892 break;
3893 case WEP40_Encryption:
3894 case WEP104_Encryption:
3895 tx_desc->SecType = 0x1;
3896 break;
3897 case TKIP_Encryption:
3898 tx_desc->SecType = 0x2;
3899 break;
3900 case AESCCMP_Encryption:
3901 tx_desc->SecType = 0x3;
3902 break;
3903 default:
3904 tx_desc->SecType = 0x0;
3905 break;
3906 }
3907 #else
3908 tx_desc->SecType = 0x0;
3909 #endif
3910 if (tcb_desc->bHwSec)
3911 {
3912 switch (priv->ieee80211->pairwise_key_type)
3913 {
3914 case KEY_TYPE_WEP40:
3915 case KEY_TYPE_WEP104:
3916 tx_desc->SecType = 0x1;
3917 tx_desc->NoEnc = 0;
3918 break;
3919 case KEY_TYPE_TKIP:
3920 tx_desc->SecType = 0x2;
3921 tx_desc->NoEnc = 0;
3922 break;
3923 case KEY_TYPE_CCMP:
3924 tx_desc->SecType = 0x3;
3925 tx_desc->NoEnc = 0;
3926 break;
3927 case KEY_TYPE_NA:
3928 tx_desc->SecType = 0x0;
3929 tx_desc->NoEnc = 1;
3930 break;
3931 }
3932 }
3933
3934 tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
3935 tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
3936
3937 tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
3938 tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
3939
3940 /* Fill fields that are required to be initialized in all of the descriptors */
3941 //DWORD 0
3942 #if 0
3943 tx_desc->FirstSeg = (tcb_desc->bFirstSeg)? 1:0;
3944 tx_desc->LastSeg = (tcb_desc->bLastSeg)?1:0;
3945 #else
3946 tx_desc->FirstSeg = 1;
3947 tx_desc->LastSeg = 1;
3948 #endif
3949 tx_desc->OWN = 1;
3950
3951 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3952 if (tcb_desc->drv_agg_enable) {
3953 tx_desc->TxBufferSize = tcb_desc->pkt_size + sizeof(tx_fwinfo_819x_usb);
3954 } else
3955 #endif
3956 {
3957 //DWORD 2
3958 tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
3959 }
3960 /* Get index to out pipe from specified QueueID */
3961 #ifndef USE_ONE_PIPE
3962 idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
3963 #else
3964 idx_pipe = 0x5;
3965 #endif
3966
3967 //RT_DEBUG_DATA(COMP_SEND,tx_fwinfo,sizeof(tx_fwinfo_819x_usb));
3968 //RT_DEBUG_DATA(COMP_SEND,tx_desc,sizeof(tx_desc_819x_usb));
3969
3970 /* To submit bulk urb */
3971 usb_fill_bulk_urb(tx_urb,udev,
3972 usb_sndbulkpipe(udev,idx_pipe), skb->data,
3973 skb->len, rtl8192_tx_isr, skb);
3974
3975 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3976 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
3977 #else
3978 status = usb_submit_urb(tx_urb);
3979 #endif
3980 if (!status){
3981 //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
3982 bool bSend0Byte = false;
3983 u8 zero = 0;
3984 if(udev->speed == USB_SPEED_HIGH)
3985 {
3986 if (skb->len > 0 && skb->len % 512 == 0)
3987 bSend0Byte = true;
3988 }
3989 else
3990 {
3991 if (skb->len > 0 && skb->len % 64 == 0)
3992 bSend0Byte = true;
3993 }
3994 if (bSend0Byte)
3995 {
3996 #if 1
3997 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
3998 tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
3999 #else
4000 tx_urb_zero = usb_alloc_urb(0);
4001 #endif
4002 if(!tx_urb_zero){
4003 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
4004 return -ENOMEM;
4005 }
4006 usb_fill_bulk_urb(tx_urb_zero,udev,
4007 usb_sndbulkpipe(udev,idx_pipe), &zero,
4008 0, tx_zero_isr, dev);
4009 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
4010 status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
4011 #else
4012 status = usb_submit_urb(tx_urb_zero);
4013 #endif
4014 if (status){
4015 RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
4016 return -1;
4017 }
4018 #endif
4019 }
4020 dev->trans_start = jiffies;
4021 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
4022 return 0;
4023 }else{
4024 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
4025 status);
4026 return -1;
4027 }
4028 }
4029 #endif
4030
4031 #if 0
4032 void rtl8192_set_rate(struct net_device *dev)
4033 {
4034 int i;
4035 u16 word;
4036 int basic_rate,min_rr_rate,max_rr_rate;
4037
4038 // struct r8192_priv *priv = ieee80211_priv(dev);
4039
4040 //if (ieee80211_is_54g(priv->ieee80211->current_network) &&
4041 // priv->ieee80211->state == IEEE80211_LINKED){
4042 basic_rate = ieeerate2rtlrate(240);
4043 min_rr_rate = ieeerate2rtlrate(60);
4044 max_rr_rate = ieeerate2rtlrate(240);
4045
4046 //
4047 // }else{
4048 // basic_rate = ieeerate2rtlrate(20);
4049 // min_rr_rate = ieeerate2rtlrate(10);
4050 // max_rr_rate = ieeerate2rtlrate(110);
4051 // }
4052
4053 write_nic_byte(dev, RESP_RATE,
4054 max_rr_rate<<MAX_RESP_RATE_SHIFT| min_rr_rate<<MIN_RESP_RATE_SHIFT);
4055
4056 //word = read_nic_word(dev, BRSR);
4057 word = read_nic_word(dev, BRSR_8187);
4058 word &= ~BRSR_MBR_8185;
4059
4060
4061 for(i=0;i<=basic_rate;i++)
4062 word |= (1<<i);
4063
4064 //write_nic_word(dev, BRSR, word);
4065 write_nic_word(dev, BRSR_8187, word);
4066 //DMESG("RR:%x BRSR: %x", read_nic_byte(dev,RESP_RATE), read_nic_word(dev,BRSR));
4067 }
4068 #endif
4069
4070
4071 #ifdef RTL8192SU
4072 void rtl8192SU_net_update(struct net_device *dev)
4073 {
4074
4075 struct r8192_priv *priv = ieee80211_priv(dev);
4076 struct ieee80211_device* ieee = priv->ieee80211;
4077 struct ieee80211_network *net = &priv->ieee80211->current_network;
4078 //u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
4079 u16 rate_config = 0;
4080 u32 regTmp = 0;
4081 u8 rateIndex = 0;
4082 u8 retrylimit = 0x30;
4083 u16 cap = net->capability;
4084
4085 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
4086
4087 //HW_VAR_BASIC_RATE
4088 //update Basic rate: RR, BRSR
4089 rtl8192_config_rate(dev, &rate_config); //HalSetBrateCfg
4090
4091 #ifdef RTL8192SU_DISABLE_CCK_RATE
4092 priv->basic_rate = rate_config = rate_config & 0x150; // Disable CCK 11M, 5.5M, 2M, and 1M rates.
4093 #else
4094 priv->basic_rate = rate_config = rate_config & 0x15f;
4095 #endif
4096
4097 // Set RRSR rate table.
4098 write_nic_byte(dev, RRSR, rate_config&0xff);
4099 write_nic_byte(dev, RRSR+1, (rate_config>>8)&0xff);
4100
4101 // Set RTS initial rate
4102 while(rate_config > 0x1)
4103 {
4104 rate_config = (rate_config>> 1);
4105 rateIndex++;
4106 }
4107 write_nic_byte(dev, INIRTSMCS_SEL, rateIndex);
4108 //HW_VAR_BASIC_RATE
4109
4110 //set ack preample
4111 regTmp = (priv->nCur40MhzPrimeSC) << 5;
4112 if (priv->short_preamble)
4113 regTmp |= 0x80;
4114 write_nic_byte(dev, RRSR+2, regTmp);
4115
4116 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
4117 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
4118
4119 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
4120 //2008.10.24 added by tynli for beacon changed.
4121 PHY_SetBeaconHwReg( dev, net->beacon_interval);
4122
4123 rtl8192_update_cap(dev, cap);
4124
4125 if (ieee->iw_mode == IW_MODE_ADHOC){
4126 retrylimit = 7;
4127 //we should enable ibss interrupt here, but disable it temporarily
4128 if (0){
4129 priv->irq_mask |= (IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
4130 //rtl8192_irq_disable(dev);
4131 //rtl8192_irq_enable(dev);
4132 }
4133 }
4134 else{
4135 if (0){
4136 priv->irq_mask &= ~(IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
4137 //rtl8192_irq_disable(dev);
4138 //rtl8192_irq_enable(dev);
4139 }
4140 }
4141
4142 priv->ShortRetryLimit = priv->LongRetryLimit = retrylimit;
4143
4144 write_nic_word(dev, RETRY_LIMIT,
4145 retrylimit << RETRY_LIMIT_SHORT_SHIFT | \
4146 retrylimit << RETRY_LIMIT_LONG_SHIFT);
4147 }
4148
4149 void rtl8192SU_update_ratr_table(struct net_device* dev)
4150 {
4151 struct r8192_priv* priv = ieee80211_priv(dev);
4152 struct ieee80211_device* ieee = priv->ieee80211;
4153 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
4154 //struct ieee80211_network *net = &ieee->current_network;
4155 u32 ratr_value = 0;
4156
4157 u8 rate_index = 0;
4158 int WirelessMode = ieee->mode;
4159 u8 MimoPs = ieee->pHTInfo->PeerMimoPs;
4160
4161 u8 bNMode = 0;
4162
4163 rtl8192_config_rate(dev, (u16*)(&ratr_value));
4164 ratr_value |= (*(u16*)(pMcsRate)) << 12;
4165
4166 //switch (ieee->mode)
4167 switch (WirelessMode)
4168 {
4169 case IEEE_A:
4170 ratr_value &= 0x00000FF0;
4171 break;
4172 case IEEE_B:
4173 ratr_value &= 0x0000000D;
4174 break;
4175 case IEEE_G:
4176 ratr_value &= 0x00000FF5;
4177 break;
4178 case IEEE_N_24G:
4179 case IEEE_N_5G:
4180 {
4181 bNMode = 1;
4182
4183 if (MimoPs == 0) //MIMO_PS_STATIC
4184 {
4185 ratr_value &= 0x0007F005;
4186 }
4187 else
4188 { // MCS rate only => for 11N mode.
4189 u32 ratr_mask;
4190
4191 // 1T2R or 1T1R, Spatial Stream 2 should be disabled
4192 if ( priv->rf_type == RF_1T2R ||
4193 priv->rf_type == RF_1T1R ||
4194 (ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_TX_2SS) )
4195 ratr_mask = 0x000ff005;
4196 else
4197 ratr_mask = 0x0f0ff005;
4198
4199 if((ieee->pHTInfo->bCurTxBW40MHz) &&
4200 !(ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_TX_40_MHZ))
4201 ratr_mask |= 0x00000010; // Set 6MBps
4202
4203 // Select rates for rate adaptive mechanism.
4204 ratr_value &= ratr_mask;
4205 }
4206 }
4207 break;
4208 default:
4209 if(0)
4210 {
4211 if(priv->rf_type == RF_1T2R) // 1T2R, Spatial Stream 2 should be disabled
4212 {
4213 ratr_value &= 0x000ff0f5;
4214 }
4215 else
4216 {
4217 ratr_value &= 0x0f0ff0f5;
4218 }
4219 }
4220 //printk("====>%s(), mode is not correct:%x\n", __FUNCTION__, ieee->mode);
4221 break;
4222 }
4223
4224 #ifdef RTL8192SU_DISABLE_CCK_RATE
4225 ratr_value &= 0x0FFFFFF0;
4226 #else
4227 ratr_value &= 0x0FFFFFFF;
4228 #endif
4229
4230 // Get MAX MCS available.
4231 if ( (bNMode && ((ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_SHORT_GI)==0)) &&
4232 ((ieee->pHTInfo->bCurBW40MHz && ieee->pHTInfo->bCurShortGI40MHz) ||
4233 (!ieee->pHTInfo->bCurBW40MHz && ieee->pHTInfo->bCurShortGI20MHz)))
4234 {
4235 u8 shortGI_rate = 0;
4236 u32 tmp_ratr_value = 0;
4237 ratr_value |= 0x10000000;//???
4238 tmp_ratr_value = (ratr_value>>12);
4239 for(shortGI_rate=15; shortGI_rate>0; shortGI_rate--)
4240 {
4241 if((1<<shortGI_rate) & tmp_ratr_value)
4242 break;
4243 }
4244 shortGI_rate = (shortGI_rate<<12)|(shortGI_rate<<8)|(shortGI_rate<<4)|(shortGI_rate);
4245 write_nic_byte(dev, SG_RATE, shortGI_rate);
4246 //printk("==>SG_RATE:%x\n", read_nic_byte(dev, SG_RATE));
4247 }
4248 write_nic_dword(dev, ARFR0+rate_index*4, ratr_value);
4249 printk("=============>ARFR0+rate_index*4:%#x\n", ratr_value);
4250
4251 //2 UFWP
4252 if (ratr_value & 0xfffff000){
4253 //printk("===>set to N mode\n");
4254 HalSetFwCmd8192S(dev, FW_CMD_RA_REFRESH_N);
4255 }
4256 else {
4257 //printk("===>set to B/G mode\n");
4258 HalSetFwCmd8192S(dev, FW_CMD_RA_REFRESH_BG);
4259 }
4260 }
4261
4262 void rtl8192SU_link_change(struct net_device *dev)
4263 {
4264 struct r8192_priv *priv = ieee80211_priv(dev);
4265 struct ieee80211_device* ieee = priv->ieee80211;
4266 //unsigned long flags;
4267 u32 reg = 0;
4268
4269 printk("=====>%s 1\n", __func__);
4270 reg = read_nic_dword(dev, RCR);
4271
4272 if (ieee->state == IEEE80211_LINKED)
4273 {
4274
4275 rtl8192SU_net_update(dev);
4276 rtl8192SU_update_ratr_table(dev);
4277 ieee->SetFwCmdHandler(dev, FW_CMD_HIGH_PWR_ENABLE);
4278 priv->ReceiveConfig = reg |= RCR_CBSSID;
4279
4280 }else{
4281 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
4282
4283 }
4284
4285 write_nic_dword(dev, RCR, reg);
4286 rtl8192_update_msr(dev);
4287
4288 printk("<=====%s 2\n", __func__);
4289 }
4290 #else
4291 extern void rtl8192_update_ratr_table(struct net_device* dev);
4292 void rtl8192_link_change(struct net_device *dev)
4293 {
4294 // int i;
4295
4296 struct r8192_priv *priv = ieee80211_priv(dev);
4297 struct ieee80211_device* ieee = priv->ieee80211;
4298 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
4299 if (ieee->state == IEEE80211_LINKED)
4300 {
4301 rtl8192_net_update(dev);
4302 rtl8192_update_ratr_table(dev);
4303 #if 1
4304 //add this as in pure N mode, wep encryption will use software way, but there is no chance to set this as wep will not set group key in wext. WB.2008.07.08
4305 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
4306 EnableHWSecurityConfig8192(dev);
4307 #endif
4308 }
4309 /*update timing params*/
4310 // RT_TRACE(COMP_CH, "========>%s(), chan:%d\n", __FUNCTION__, priv->chan);
4311 // rtl8192_set_chan(dev, priv->chan);
4312 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
4313 {
4314 u32 reg = 0;
4315 reg = read_nic_dword(dev, RCR);
4316 if (priv->ieee80211->state == IEEE80211_LINKED)
4317 priv->ReceiveConfig = reg |= RCR_CBSSID;
4318 else
4319 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
4320 write_nic_dword(dev, RCR, reg);
4321 }
4322
4323 // rtl8192_set_rxconf(dev);
4324 }
4325 #endif
4326
4327 static struct ieee80211_qos_parameters def_qos_parameters = {
4328 {3,3,3,3},/* cw_min */
4329 {7,7,7,7},/* cw_max */
4330 {2,2,2,2},/* aifs */
4331 {0,0,0,0},/* flags */
4332 {0,0,0,0} /* tx_op_limit */
4333 };
4334
4335
4336 #if LINUX_VERSION_CODE >=KERNEL_VERSION(2,6,20)
4337 void rtl8192_update_beacon(struct work_struct * work)
4338 {
4339 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
4340 struct net_device *dev = priv->ieee80211->dev;
4341 #else
4342 void rtl8192_update_beacon(struct net_device *dev)
4343 {
4344 struct r8192_priv *priv = ieee80211_priv(dev);
4345 #endif
4346 struct ieee80211_device* ieee = priv->ieee80211;
4347 struct ieee80211_network* net = &ieee->current_network;
4348
4349 if (ieee->pHTInfo->bCurrentHTSupport)
4350 HTUpdateSelfAndPeerSetting(ieee, net);
4351 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
4352 // Joseph test for turbo mode with AP
4353 ieee->pHTInfo->RT2RT_HT_Mode = net->bssht.RT2RT_HT_Mode;
4354 rtl8192_update_cap(dev, net->capability);
4355 }
4356 /*
4357 * background support to run QoS activate functionality
4358 */
4359 int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
4360 #if LINUX_VERSION_CODE >=KERNEL_VERSION(2,6,20)
4361 void rtl8192_qos_activate(struct work_struct * work)
4362 {
4363 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
4364 struct net_device *dev = priv->ieee80211->dev;
4365 #else
4366 void rtl8192_qos_activate(struct net_device *dev)
4367 {
4368 struct r8192_priv *priv = ieee80211_priv(dev);
4369 #endif
4370 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
4371 u8 mode = priv->ieee80211->current_network.mode;
4372 //u32 size = sizeof(struct ieee80211_qos_parameters);
4373 u8 u1bAIFS;
4374 u32 u4bAcParam;
4375 int i;
4376
4377 if (priv == NULL)
4378 return;
4379
4380 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16))
4381 down(&priv->mutex);
4382 #else
4383 mutex_lock(&priv->mutex);
4384 #endif
4385 if(priv->ieee80211->state != IEEE80211_LINKED)
4386 goto success;
4387 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
4388 /* It better set slot time at first */
4389 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
4390 /* update the ac parameter to related registers */
4391 for(i = 0; i < QOS_QUEUE_NUM; i++) {
4392 //Mode G/A: slotTimeTimer = 9; Mode B: 20
4393 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
4394 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
4395 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
4396 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
4397 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
4398
4399 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
4400 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4322);
4401 }
4402
4403 success:
4404 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16))
4405 up(&priv->mutex);
4406 #else
4407 mutex_unlock(&priv->mutex);
4408 #endif
4409 }
4410
4411 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
4412 int active_network,
4413 struct ieee80211_network *network)
4414 {
4415 int ret = 0;
4416 u32 size = sizeof(struct ieee80211_qos_parameters);
4417
4418 if(priv->ieee80211->state !=IEEE80211_LINKED)
4419 return ret;
4420
4421 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
4422 return ret;
4423
4424 if (network->flags & NETWORK_HAS_QOS_MASK) {
4425 if (active_network &&
4426 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
4427 network->qos_data.active = network->qos_data.supported;
4428
4429 if ((network->qos_data.active == 1) && (active_network == 1) &&
4430 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
4431 (network->qos_data.old_param_count !=
4432 network->qos_data.param_count)) {
4433 network->qos_data.old_param_count =
4434 network->qos_data.param_count;
4435 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
4436 queue_work(priv->priv_wq, &priv->qos_activate);
4437 #else
4438 schedule_task(&priv->qos_activate);
4439 #endif
4440 RT_TRACE (COMP_QOS, "QoS parameters change call "
4441 "qos_activate\n");
4442 }
4443 } else {
4444 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
4445 &def_qos_parameters, size);
4446
4447 if ((network->qos_data.active == 1) && (active_network == 1)) {
4448 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
4449 queue_work(priv->priv_wq, &priv->qos_activate);
4450 #else
4451 schedule_task(&priv->qos_activate);
4452 #endif
4453 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
4454 }
4455 network->qos_data.active = 0;
4456 network->qos_data.supported = 0;
4457 }
4458
4459 return 0;
4460 }
4461
4462 /* handle manage frame frame beacon and probe response */
4463 static int rtl8192_handle_beacon(struct net_device * dev,
4464 struct ieee80211_beacon * beacon,
4465 struct ieee80211_network * network)
4466 {
4467 struct r8192_priv *priv = ieee80211_priv(dev);
4468
4469 rtl8192_qos_handle_probe_response(priv,1,network);
4470 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
4471 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
4472 #else
4473 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
4474 schedule_task(&priv->update_beacon_wq);
4475 #else
4476 queue_work(priv->priv_wq, &priv->update_beacon_wq);
4477 #endif
4478
4479 #endif
4480 return 0;
4481
4482 }
4483
4484 /*
4485 * handling the beaconing responses. if we get different QoS setting
4486 * off the network from the associated setting, adjust the QoS
4487 * setting
4488 */
4489 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
4490 struct ieee80211_network *network)
4491 {
4492 int ret = 0;
4493 unsigned long flags;
4494 u32 size = sizeof(struct ieee80211_qos_parameters);
4495 int set_qos_param = 0;
4496
4497 if ((priv == NULL) || (network == NULL))
4498 return ret;
4499
4500 if(priv->ieee80211->state !=IEEE80211_LINKED)
4501 return ret;
4502
4503 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
4504 return ret;
4505
4506 spin_lock_irqsave(&priv->ieee80211->lock, flags);
4507 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
4508 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
4509 &network->qos_data.parameters,\
4510 sizeof(struct ieee80211_qos_parameters));
4511 priv->ieee80211->current_network.qos_data.active = 1;
4512 #if 0
4513 if((priv->ieee80211->current_network.qos_data.param_count != \
4514 network->qos_data.param_count))
4515 #endif
4516 {
4517 set_qos_param = 1;
4518 /* update qos parameter for current network */
4519 priv->ieee80211->current_network.qos_data.old_param_count = \
4520 priv->ieee80211->current_network.qos_data.param_count;
4521 priv->ieee80211->current_network.qos_data.param_count = \
4522 network->qos_data.param_count;
4523 }
4524 } else {
4525 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
4526 &def_qos_parameters, size);
4527 priv->ieee80211->current_network.qos_data.active = 0;
4528 priv->ieee80211->current_network.qos_data.supported = 0;
4529 set_qos_param = 1;
4530 }
4531
4532 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
4533
4534 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
4535 if (set_qos_param == 1)
4536 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
4537 queue_work(priv->priv_wq, &priv->qos_activate);
4538 #else
4539 schedule_task(&priv->qos_activate);
4540 #endif
4541
4542
4543 return ret;
4544 }
4545
4546
4547 static int rtl8192_handle_assoc_response(struct net_device *dev,
4548 struct ieee80211_assoc_response_frame *resp,
4549 struct ieee80211_network *network)
4550 {
4551 struct r8192_priv *priv = ieee80211_priv(dev);
4552 rtl8192_qos_association_resp(priv, network);
4553 return 0;
4554 }
4555
4556
4557 void rtl8192_update_ratr_table(struct net_device* dev)
4558 // POCTET_STRING posLegacyRate,
4559 // u8* pMcsRate)
4560 // PRT_WLAN_STA pEntry)
4561 {
4562 struct r8192_priv* priv = ieee80211_priv(dev);
4563 struct ieee80211_device* ieee = priv->ieee80211;
4564 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
4565 //struct ieee80211_network *net = &ieee->current_network;
4566 u32 ratr_value = 0;
4567 u8 rate_index = 0;
4568 rtl8192_config_rate(dev, (u16*)(&ratr_value));
4569 ratr_value |= (*(u16*)(pMcsRate)) << 12;
4570 // switch (net->mode)
4571 switch (ieee->mode)
4572 {
4573 case IEEE_A:
4574 ratr_value &= 0x00000FF0;
4575 break;
4576 case IEEE_B:
4577 ratr_value &= 0x0000000F;
4578 break;
4579 case IEEE_G:
4580 ratr_value &= 0x00000FF7;
4581 break;
4582 case IEEE_N_24G:
4583 case IEEE_N_5G:
4584 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
4585 ratr_value &= 0x0007F007;
4586 else{
4587 if (priv->rf_type == RF_1T2R)
4588 ratr_value &= 0x000FF007;
4589 else
4590 ratr_value &= 0x0F81F007;
4591 }
4592 break;
4593 default:
4594 break;
4595 }
4596 ratr_value &= 0x0FFFFFFF;
4597 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
4598 ratr_value |= 0x80000000;
4599 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
4600 ratr_value |= 0x80000000;
4601 }
4602 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
4603 write_nic_byte(dev, UFWP, 1);
4604 }
4605
4606 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
4607 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
4608 bool GetNmodeSupportBySecCfg8192(struct net_device*dev)
4609 {
4610 #if 1
4611 struct r8192_priv* priv = ieee80211_priv(dev);
4612 struct ieee80211_device* ieee = priv->ieee80211;
4613 struct ieee80211_network * network = &ieee->current_network;
4614 int wpa_ie_len= ieee->wpa_ie_len;
4615 struct ieee80211_crypt_data* crypt;
4616 int encrypt;
4617 #if (defined (RTL8192SU_FPGA_2MAC_VERIFICATION)||defined (RTL8192SU_ASIC_VERIFICATION))
4618 return TRUE;
4619 #endif
4620
4621 crypt = ieee->crypt[ieee->tx_keyidx];
4622 //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
4623 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
4624
4625 /* simply judge */
4626 if(encrypt && (wpa_ie_len == 0)) {
4627 /* wep encryption, no N mode setting */
4628 return false;
4629 // } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
4630 } else if((wpa_ie_len != 0)) {
4631 /* parse pairwise key type */
4632 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
4633 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))))
4634 return true;
4635 else
4636 return false;
4637 } else {
4638 return true;
4639 }
4640
4641 #if 0
4642 //In here we discuss with SD4 David. He think we still can send TKIP in broadcast group key in MCS rate.
4643 //We can't force in G mode if Pairwie key is AES and group key is TKIP
4644 if((pSecInfo->GroupEncAlgorithm == WEP104_Encryption) || (pSecInfo->GroupEncAlgorithm == WEP40_Encryption) ||
4645 (pSecInfo->PairwiseEncAlgorithm == WEP104_Encryption) ||
4646 (pSecInfo->PairwiseEncAlgorithm == WEP40_Encryption) || (pSecInfo->PairwiseEncAlgorithm == TKIP_Encryption))
4647 {
4648 return false;
4649 }
4650 else
4651 return true;
4652 #endif
4653 return true;
4654 #endif
4655 }
4656
4657 bool GetHalfNmodeSupportByAPs819xUsb(struct net_device* dev)
4658 {
4659 bool Reval;
4660 struct r8192_priv* priv = ieee80211_priv(dev);
4661 struct ieee80211_device* ieee = priv->ieee80211;
4662
4663 // Added by Roger, 2008.08.29.
4664 #ifdef RTL8192SU
4665 return false;
4666 #endif
4667
4668 if(ieee->bHalfWirelessN24GMode == true)
4669 Reval = true;
4670 else
4671 Reval = false;
4672
4673 return Reval;
4674 }
4675
4676 void rtl8192_refresh_supportrate(struct r8192_priv* priv)
4677 {
4678 struct ieee80211_device* ieee = priv->ieee80211;
4679 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
4680 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
4681 {
4682 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
4683 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
4684 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
4685 }
4686 else
4687 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
4688 return;
4689 }
4690
4691 u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
4692 {
4693 struct r8192_priv *priv = ieee80211_priv(dev);
4694 u8 ret = 0;
4695 switch(priv->rf_chip)
4696 {
4697 case RF_8225:
4698 case RF_8256:
4699 case RF_PSEUDO_11N:
4700 case RF_6052:
4701 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
4702 break;
4703 case RF_8258:
4704 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
4705 break;
4706 default:
4707 ret = WIRELESS_MODE_B;
4708 break;
4709 }
4710 return ret;
4711 }
4712 void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
4713 {
4714 struct r8192_priv *priv = ieee80211_priv(dev);
4715 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
4716
4717 #if 1
4718 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
4719 {
4720 if(bSupportMode & WIRELESS_MODE_N_24G)
4721 {
4722 wireless_mode = WIRELESS_MODE_N_24G;
4723 }
4724 else if(bSupportMode & WIRELESS_MODE_N_5G)
4725 {
4726 wireless_mode = WIRELESS_MODE_N_5G;
4727 }
4728 else if((bSupportMode & WIRELESS_MODE_A))
4729 {
4730 wireless_mode = WIRELESS_MODE_A;
4731 }
4732 else if((bSupportMode & WIRELESS_MODE_G))
4733 {
4734 wireless_mode = WIRELESS_MODE_G;
4735 }
4736 else if((bSupportMode & WIRELESS_MODE_B))
4737 {
4738 wireless_mode = WIRELESS_MODE_B;
4739 }
4740 else{
4741 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
4742 wireless_mode = WIRELESS_MODE_B;
4743 }
4744 }
4745 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we shoud wait for FPGA
4746 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
4747 #endif
4748 #ifdef RTL8192SU
4749 //LZM 090306 usb crash here, mark it temp
4750 //write_nic_word(dev, SIFS_OFDM, 0x0e0e);
4751 #endif
4752 priv->ieee80211->mode = wireless_mode;
4753
4754 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
4755 priv->ieee80211->pHTInfo->bEnableHT = 1;
4756 else
4757 priv->ieee80211->pHTInfo->bEnableHT = 0;
4758 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
4759 rtl8192_refresh_supportrate(priv);
4760 #endif
4761
4762 }
4763
4764
4765 short rtl8192_is_tx_queue_empty(struct net_device *dev)
4766 {
4767 int i=0;
4768 struct r8192_priv *priv = ieee80211_priv(dev);
4769 //struct ieee80211_device* ieee = priv->ieee80211;
4770 for (i=0; i<=MGNT_QUEUE; i++)
4771 {
4772 if ((i== TXCMD_QUEUE) || (i == HCCA_QUEUE) )
4773 continue;
4774 if (atomic_read(&priv->tx_pending[i]))
4775 {
4776 printk("===>tx queue is not empty:%d, %d\n", i, atomic_read(&priv->tx_pending[i]));
4777 return 0;
4778 }
4779 }
4780 return 1;
4781 }
4782 #if 0
4783 void rtl8192_rq_tx_ack(struct net_device *dev)
4784 {
4785 struct r8192_priv *priv = ieee80211_priv(dev);
4786 priv->ieee80211->ack_tx_to_ieee = 1;
4787 }
4788 #endif
4789 void rtl8192_hw_sleep_down(struct net_device *dev)
4790 {
4791 RT_TRACE(COMP_POWER, "%s()============>come to sleep down\n", __FUNCTION__);
4792 #ifdef TODO
4793 // MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
4794 #endif
4795 }
4796 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
4797 void rtl8192_hw_sleep_wq (struct work_struct *work)
4798 {
4799 // struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
4800 // struct ieee80211_device * ieee = (struct ieee80211_device*)
4801 // container_of(work, struct ieee80211_device, watch_dog_wq);
4802 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4803 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
4804 struct net_device *dev = ieee->dev;
4805 #else
4806 void rtl8192_hw_sleep_wq(struct net_device* dev)
4807 {
4808 #endif
4809 //printk("=========>%s()\n", __FUNCTION__);
4810 rtl8192_hw_sleep_down(dev);
4811 }
4812 // printk("dev is %d\n",dev);
4813 // printk("&*&(^*(&(&=========>%s()\n", __FUNCTION__);
4814 void rtl8192_hw_wakeup(struct net_device* dev)
4815 {
4816 // u32 flags = 0;
4817
4818 // spin_lock_irqsave(&priv->ps_lock,flags);
4819 RT_TRACE(COMP_POWER, "%s()============>come to wake up\n", __FUNCTION__);
4820 #ifdef TODO
4821 // MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
4822 #endif
4823 //FIXME: will we send package stored while nic is sleep?
4824 // spin_unlock_irqrestore(&priv->ps_lock,flags);
4825 }
4826 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
4827 void rtl8192_hw_wakeup_wq (struct work_struct *work)
4828 {
4829 // struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
4830 // struct ieee80211_device * ieee = (struct ieee80211_device*)
4831 // container_of(work, struct ieee80211_device, watch_dog_wq);
4832 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4833 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
4834 struct net_device *dev = ieee->dev;
4835 #else
4836 void rtl8192_hw_wakeup_wq(struct net_device* dev)
4837 {
4838 #endif
4839 rtl8192_hw_wakeup(dev);
4840
4841 }
4842
4843 #define MIN_SLEEP_TIME 50
4844 #define MAX_SLEEP_TIME 10000
4845 void rtl8192_hw_to_sleep(struct net_device *dev, u32 th, u32 tl)
4846 {
4847
4848 struct r8192_priv *priv = ieee80211_priv(dev);
4849
4850 u32 rb = jiffies;
4851 unsigned long flags;
4852
4853 spin_lock_irqsave(&priv->ps_lock,flags);
4854
4855 /* Writing HW register with 0 equals to disable
4856 * the timer, that is not really what we want
4857 */
4858 tl -= MSECS(4+16+7);
4859
4860 //if(tl == 0) tl = 1;
4861
4862 /* FIXME HACK FIXME HACK */
4863 // force_pci_posting(dev);
4864 //mdelay(1);
4865
4866 // rb = read_nic_dword(dev, TSFTR);
4867
4868 /* If the interval in witch we are requested to sleep is too
4869 * short then give up and remain awake
4870 */
4871 if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
4872 ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
4873 spin_unlock_irqrestore(&priv->ps_lock,flags);
4874 printk("too short to sleep\n");
4875 return;
4876 }
4877
4878 // write_nic_dword(dev, TimerInt, tl);
4879 // rb = read_nic_dword(dev, TSFTR);
4880 {
4881 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
4882 // if (tl<rb)
4883
4884 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
4885 schedule_task(&priv->ieee80211->hw_wakeup_wq);
4886 #else
4887 queue_delayed_work(priv->ieee80211->wq, &priv->ieee80211->hw_wakeup_wq, tmp); //as tl may be less than rb
4888 #endif
4889 }
4890 /* if we suspect the TimerInt is gone beyond tl
4891 * while setting it, then give up
4892 */
4893 #if 1
4894 if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
4895 ((tl < rb) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))) {
4896 printk("========>too long to sleep:%x, %x, %lx\n", tl, rb, MSECS(MAX_SLEEP_TIME));
4897 spin_unlock_irqrestore(&priv->ps_lock,flags);
4898 return;
4899 }
4900 #endif
4901 // if(priv->rf_sleep)
4902 // priv->rf_sleep(dev);
4903
4904 //printk("<=========%s()\n", __FUNCTION__);
4905 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
4906 schedule_task(&priv->ieee80211->hw_sleep_wq);
4907 #else
4908 queue_delayed_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_sleep_wq,0);
4909 #endif
4910 spin_unlock_irqrestore(&priv->ps_lock,flags);
4911 }
4912 //init priv variables here. only non_zero value should be initialized here.
4913 static void rtl8192_init_priv_variable(struct net_device* dev)
4914 {
4915 struct r8192_priv *priv = ieee80211_priv(dev);
4916 u8 i;
4917 priv->card_8192 = NIC_8192U;
4918 priv->chan = 1; //set to channel 1
4919 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
4920 priv->ieee80211->iw_mode = IW_MODE_INFRA;
4921 priv->ieee80211->ieee_up=0;
4922 priv->retry_rts = DEFAULT_RETRY_RTS;
4923 priv->retry_data = DEFAULT_RETRY_DATA;
4924 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
4925 priv->ieee80211->rate = 110; //11 mbps
4926 priv->ieee80211->short_slot = 1;
4927 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4928 priv->CckPwEnl = 6;
4929 //for silent reset
4930 priv->IrpPendingCount = 1;
4931 priv->ResetProgress = RESET_TYPE_NORESET;
4932 priv->bForcedSilentReset = 0;
4933 priv->bDisableNormalResetCheck = false;
4934 priv->force_reset = false;
4935
4936 priv->ieee80211->FwRWRF = 0; //we don't use FW read/write RF until stable firmware is available.
4937 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
4938 priv->ieee80211->iw_mode = IW_MODE_INFRA;
4939 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
4940 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
4941 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
4942 IEEE_SOFTMAC_BEACONS;//added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
4943
4944 priv->ieee80211->active_scan = 1;
4945 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
4946 priv->ieee80211->host_encrypt = 1;
4947 priv->ieee80211->host_decrypt = 1;
4948 priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
4949 priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
4950 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
4951 priv->ieee80211->set_chan = rtl8192_set_chan;
4952 priv->ieee80211->link_change = priv->ops->rtl819x_link_change;
4953 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
4954 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
4955 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
4956 priv->ieee80211->init_wmmparam_flag = 0;
4957 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
4958 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
4959 priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
4960 priv->ieee80211->qos_support = 1;
4961
4962 //added by WB
4963 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
4964 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
4965 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
4966 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
4967 //for LPS
4968 priv->ieee80211->sta_wake_up = rtl8192_hw_wakeup;
4969 // priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
4970 priv->ieee80211->enter_sleep_state = rtl8192_hw_to_sleep;
4971 priv->ieee80211->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
4972 //added by david
4973 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
4974 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
4975 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
4976 //added by amy
4977 priv->ieee80211->InitialGainHandler = priv->ops->rtl819x_initial_gain;
4978 priv->card_type = USB;
4979
4980 #ifdef RTL8192SU
4981 //1 RTL8192SU/
4982 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
4983 priv->ieee80211->SetFwCmdHandler = HalSetFwCmd8192S;
4984 priv->bRFSiOrPi = 0;//o=si,1=pi;
4985 //lzm add
4986 priv->bInHctTest = false;
4987
4988 priv->MidHighPwrTHR_L1 = 0x3B;
4989 priv->MidHighPwrTHR_L2 = 0x40;
4990
4991 if(priv->bInHctTest)
4992 {
4993 priv->ShortRetryLimit = HAL_RETRY_LIMIT_AP_ADHOC;
4994 priv->LongRetryLimit = HAL_RETRY_LIMIT_AP_ADHOC;
4995 }
4996 else
4997 {
4998 priv->ShortRetryLimit = HAL_RETRY_LIMIT_INFRA;
4999 priv->LongRetryLimit = HAL_RETRY_LIMIT_INFRA;
5000 }
5001
5002 priv->SetFwCmdInProgress = false; //is set FW CMD in Progress? 92S only
5003 priv->CurrentFwCmdIO = 0;
5004
5005 priv->MinSpaceCfg = 0;
5006
5007 priv->EarlyRxThreshold = 7;
5008 priv->enable_gpio0 = 0;
5009 priv->TransmitConfig =
5010 ((u32)TCR_MXDMA_2048<<TCR_MXDMA_OFFSET) | // Max DMA Burst Size per Tx DMA Burst, 7: reservied.
5011 (priv->ShortRetryLimit<<TCR_SRL_OFFSET) | // Short retry limit
5012 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
5013 (false ? TCR_SAT : 0); // FALSE: HW provies PLCP length and LENGEXT, TURE: SW proiveds them
5014 if(priv->bInHctTest)
5015 priv->ReceiveConfig = //priv->CSMethod |
5016 RCR_AMF | RCR_ADF | //RCR_AAP | //accept management/data
5017 RCR_ACF |RCR_APPFCS| //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
5018 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
5019 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
5020 RCR_APP_PHYST_STAFF | RCR_APP_PHYST_RXFF | // Accept PHY status
5021 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
5022 (priv->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
5023 (priv->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt:0);
5024 else
5025 priv->ReceiveConfig = //priv->CSMethod |
5026 RCR_AMF | RCR_ADF | RCR_AB |
5027 RCR_AM | RCR_APM |RCR_AAP |RCR_ADD3|RCR_APP_ICV|
5028 RCR_APP_PHYST_STAFF | RCR_APP_PHYST_RXFF | // Accept PHY status
5029 RCR_APP_MIC | RCR_APPFCS;
5030
5031 // <Roger_EXP> 2008.06.16.
5032 priv->IntrMask = (u16)(IMR_ROK | IMR_VODOK | IMR_VIDOK | IMR_BEDOK | IMR_BKDOK | \
5033 IMR_HCCADOK | IMR_MGNTDOK | IMR_COMDOK | IMR_HIGHDOK | \
5034 IMR_BDOK | IMR_RXCMDOK | /*IMR_TIMEOUT0 |*/ IMR_RDU | IMR_RXFOVW | \
5035 IMR_TXFOVW | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
5036
5037 //1 End
5038
5039 #else
5040
5041 #ifdef TO_DO_LIST
5042 if(Adapter->bInHctTest)
5043 {
5044 pHalData->ShortRetryLimit = 7;
5045 pHalData->LongRetryLimit = 7;
5046 }
5047 #endif
5048 {
5049 priv->ShortRetryLimit = 0x30;
5050 priv->LongRetryLimit = 0x30;
5051 }
5052 priv->EarlyRxThreshold = 7;
5053 priv->enable_gpio0 = 0;
5054 priv->TransmitConfig =
5055 // TCR_DurProcMode | //for RTL8185B, duration setting by HW
5056 //? TCR_DISReqQsize |
5057 (TCR_MXDMA_2048<<TCR_MXDMA_OFFSET)| // Max DMA Burst Size per Tx DMA Burst, 7: reservied.
5058 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)| // Short retry limit
5059 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
5060 (false ? TCR_SAT: 0); // FALSE: HW provies PLCP length and LENGEXT, TURE: SW proiveds them
5061 #ifdef TO_DO_LIST
5062 if(Adapter->bInHctTest)
5063 pHalData->ReceiveConfig = pHalData->CSMethod |
5064 RCR_AMF | RCR_ADF | //RCR_AAP | //accept management/data
5065 //guangan200710
5066 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
5067 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
5068 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
5069 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
5070 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
5071 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt:0);
5072 else
5073
5074 #endif
5075 priv->ReceiveConfig =
5076 RCR_AMF | RCR_ADF | //accept management/data
5077 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
5078 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
5079 //RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
5080 ((u32)7<<RCR_MXDMA_OFFSET)| // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
5081 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) | // Rx FIFO Threshold, 7: No Rx threshold.
5082 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT:0);
5083 #endif
5084
5085 priv->AcmControl = 0;
5086 priv->pFirmware = (rt_firmware*)vmalloc(sizeof(rt_firmware));
5087 if (priv->pFirmware)
5088 memset(priv->pFirmware, 0, sizeof(rt_firmware));
5089
5090 /* rx related queue */
5091 skb_queue_head_init(&priv->rx_queue);
5092 skb_queue_head_init(&priv->skb_queue);
5093
5094 /* Tx related queue */
5095 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
5096 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
5097 }
5098 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
5099 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
5100 }
5101 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
5102 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ [i]);
5103 }
5104 priv->rf_set_chan = rtl8192_phy_SwChnl;
5105 }
5106
5107 //init lock here
5108 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
5109 {
5110 spin_lock_init(&priv->tx_lock);
5111 spin_lock_init(&priv->irq_lock);//added by thomas
5112 //spin_lock_init(&priv->rf_lock);//use rf_sem, or will crash in some OS.
5113 sema_init(&priv->wx_sem,1);
5114 sema_init(&priv->rf_sem,1);
5115 spin_lock_init(&priv->ps_lock);
5116 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16))
5117 sema_init(&priv->mutex, 1);
5118 #else
5119 mutex_init(&priv->mutex);
5120 #endif
5121 }
5122
5123 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
5124 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
5125 #else
5126 extern void rtl819x_watchdog_wqcallback(struct net_device *dev);
5127 #endif
5128
5129 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
5130 //init tasklet and wait_queue here. only 2.6 above kernel is considered
5131 #define DRV_NAME "wlan0"
5132 static void rtl8192_init_priv_task(struct net_device* dev)
5133 {
5134 struct r8192_priv *priv = ieee80211_priv(dev);
5135
5136 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
5137 #ifdef PF_SYNCTHREAD
5138 priv->priv_wq = create_workqueue(DRV_NAME,0);
5139 #else
5140 priv->priv_wq = create_workqueue(DRV_NAME);
5141 #endif
5142 #endif
5143
5144 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
5145 INIT_WORK(&priv->reset_wq, rtl8192_restart);
5146
5147 //INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
5148 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
5149 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
5150 // INIT_DELAYED_WORK(&priv->gpio_change_rf_wq, dm_gpio_change_rf_callback);
5151 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
5152 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
5153 INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
5154 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
5155 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
5156 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
5157 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq);
5158 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq);
5159
5160 #else
5161 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
5162 tq_init(&priv->reset_wq, (void*)rtl8192_restart, dev);
5163 tq_init(&priv->watch_dog_wq, (void*)rtl819x_watchdog_wqcallback, dev);
5164 tq_init(&priv->txpower_tracking_wq, (void*)dm_txpower_trackingcallback, dev);
5165 tq_init(&priv->rfpath_check_wq, (void*)dm_rf_pathcheck_workitemcallback, dev);
5166 tq_init(&priv->update_beacon_wq, (void*)rtl8192_update_beacon, dev);
5167 //tq_init(&priv->SwChnlWorkItem, (void*) rtl8192_SwChnl_WorkItem, dev);
5168 //tq_init(&priv->SetBWModeWorkItem, (void*)rtl8192_SetBWModeWorkItem, dev);
5169 tq_init(&priv->qos_activate, (void *)rtl8192_qos_activate, dev);
5170 tq_init(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq, dev);
5171 tq_init(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq, dev);
5172
5173 #else
5174 INIT_WORK(&priv->reset_wq,(void(*)(void*)) rtl8192_restart,dev);
5175 //INIT_WORK(&priv->watch_dog_wq, (void(*)(void*)) hal_dm_watchdog,dev);
5176 INIT_WORK(&priv->watch_dog_wq, (void(*)(void*)) rtl819x_watchdog_wqcallback,dev);
5177 INIT_WORK(&priv->txpower_tracking_wq, (void(*)(void*)) dm_txpower_trackingcallback,dev);
5178 // INIT_WORK(&priv->gpio_change_rf_wq, (void(*)(void*)) dm_gpio_change_rf_callback,dev);
5179 INIT_WORK(&priv->rfpath_check_wq, (void(*)(void*)) dm_rf_pathcheck_workitemcallback,dev);
5180 INIT_WORK(&priv->update_beacon_wq, (void(*)(void*))rtl8192_update_beacon,dev);
5181 INIT_WORK(&priv->initialgain_operate_wq, (void(*)(void*))InitialGainOperateWorkItemCallBack,dev);
5182 //INIT_WORK(&priv->SwChnlWorkItem, (void(*)(void*)) rtl8192_SwChnl_WorkItem, dev);
5183 //INIT_WORK(&priv->SetBWModeWorkItem, (void(*)(void*)) rtl8192_SetBWModeWorkItem, dev);
5184 INIT_WORK(&priv->qos_activate, (void(*)(void *))rtl8192_qos_activate, dev);
5185 INIT_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq, dev);
5186 INIT_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq, dev);
5187 #endif
5188 #endif
5189
5190 tasklet_init(&priv->irq_rx_tasklet,
5191 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
5192 (unsigned long)priv);
5193 }
5194
5195 static void rtl8192_get_eeprom_size(struct net_device* dev)
5196 {
5197 u16 curCR = 0;
5198 struct r8192_priv *priv = ieee80211_priv(dev);
5199 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
5200 curCR = read_nic_word_E(dev,EPROM_CMD);
5201 RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
5202 //whether need I consider BIT5?
5203 priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
5204 RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
5205 }
5206
5207 //used to swap endian. as ntohl & htonl are not neccessary to swap endian, so use this instead.
5208 static inline u16 endian_swap(u16* data)
5209 {
5210 u16 tmp = *data;
5211 *data = (tmp >> 8) | (tmp << 8);
5212 return *data;
5213 }
5214
5215 #ifdef RTL8192SU
5216 u8 rtl8192SU_UsbOptionToEndPointNumber(u8 UsbOption)
5217 {
5218 u8 nEndPoint = 0;
5219 switch(UsbOption)
5220 {
5221 case 0:
5222 nEndPoint = 6;
5223 break;
5224 case 1:
5225 nEndPoint = 11;
5226 break;
5227 case 2:
5228 nEndPoint = 4;
5229 break;
5230 default:
5231 RT_TRACE(COMP_INIT, "UsbOptionToEndPointNumber(): Invalid UsbOption(%#x)\n", UsbOption);
5232 break;
5233 }
5234 return nEndPoint;
5235 }
5236
5237 u8 rtl8192SU_BoardTypeToRFtype(struct net_device* dev, u8 Boardtype)
5238 {
5239 u8 RFtype = RF_1T2R;
5240
5241 switch(Boardtype)
5242 {
5243 case 0:
5244 RFtype = RF_1T1R;
5245 break;
5246 case 1:
5247 RFtype = RF_1T2R;
5248 break;
5249 case 2:
5250 RFtype = RF_2T2R;
5251 break;
5252 case 3:
5253 RFtype = RF_2T2R_GREEN;
5254 break;
5255 default:
5256 break;
5257 }
5258
5259 return RFtype;
5260 }
5261
5262 //
5263 // Description:
5264 // Config HW adapter information into initial value.
5265 //
5266 // Assumption:
5267 // 1. After Auto load fail(i.e, check CR9346 fail)
5268 //
5269 // Created by Roger, 2008.10.21.
5270 //
5271 void
5272 rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device* dev)
5273 {
5274 struct r8192_priv *priv = ieee80211_priv(dev);
5275 //u16 i,usValue;
5276 //u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x92, 0x00};
5277 u8 rf_path, index; // For EEPROM/EFUSE After V0.6_1117
5278 int i;
5279
5280 RT_TRACE(COMP_INIT, "====> ConfigAdapterInfo8192SForAutoLoadFail\n");
5281
5282 write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader
5283 //PlatformStallExecution(10000);
5284 mdelay(10);
5285 write_nic_byte(dev, PMC_FSM, 0x02); // Enable Loader Data Keep
5286
5287 //RT_ASSERT(priv->AutoloadFailFlag==TRUE, ("ReadAdapterInfo8192SEEPROM(): AutoloadFailFlag !=TRUE\n"));
5288
5289 // Initialize IC Version && Channel Plan
5290 priv->eeprom_vid = 0;
5291 priv->eeprom_pid = 0;
5292 priv->card_8192_version = 0;
5293 priv->eeprom_ChannelPlan = 0;
5294 priv->eeprom_CustomerID = 0;
5295 priv->eeprom_SubCustomerID = 0;
5296 priv->bIgnoreDiffRateTxPowerOffset = false;
5297
5298 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
5299 RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid);
5300 RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
5301 RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n", priv->eeprom_SubCustomerID);
5302 RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", priv->eeprom_ChannelPlan);
5303 RT_TRACE(COMP_INIT, "IgnoreDiffRateTxPowerOffset = %d\n", priv->bIgnoreDiffRateTxPowerOffset);
5304
5305
5306
5307 priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC;
5308 RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption);
5309
5310 for(i=0; i<5; i++)
5311 priv->EEPROMUsbPhyParam[i] = EEPROM_USB_Default_PHY_PARAM;
5312
5313 //RT_PRINT_DATA(COMP_INIT|COMP_EFUSE, DBG_LOUD, ("EFUSE USB PHY Param: \n"), priv->EEPROMUsbPhyParam, 5);
5314
5315 {
5316 //<Roger_Notes> In this case, we random assigh MAC address here. 2008.10.15.
5317 static u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x92, 0x00};
5318 u8 i;
5319
5320 //sMacAddr[5] = (u8)GetRandomNumber(1, 254);
5321
5322 for(i = 0; i < 6; i++)
5323 dev->dev_addr[i] = sMacAddr[i];
5324 }
5325 //NicIFSetMacAddress(Adapter, Adapter->PermanentAddress);
5326 write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
5327 write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
5328
5329 RT_TRACE(COMP_INIT, "ReadAdapterInfo8192SEFuse(), Permanent Address = %02x-%02x-%02x-%02x-%02x-%02x\n",
5330 dev->dev_addr[0], dev->dev_addr[1],
5331 dev->dev_addr[2], dev->dev_addr[3],
5332 dev->dev_addr[4], dev->dev_addr[5]);
5333
5334 priv->EEPROMBoardType = EEPROM_Default_BoardType;
5335 priv->rf_type = RF_1T2R; //RF_2T2R
5336 priv->EEPROMTxPowerDiff = EEPROM_Default_PwDiff;
5337 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
5338 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
5339 priv->EEPROMTxPwrBase = EEPROM_Default_TxPowerBase;
5340 priv->EEPROMTSSI_A = EEPROM_Default_TSSI;
5341 priv->EEPROMTSSI_B = EEPROM_Default_TSSI;
5342 priv->EEPROMTxPwrTkMode = EEPROM_Default_TxPwrTkMode;
5343
5344
5345 #ifdef EEPROM_OLD_FORMAT_SUPPORT
5346 for(i=0; i<6; i++)
5347 {
5348 priv->EEPROMHT2T_TxPwr[i] = EEPROM_Default_HT2T_TxPwr;
5349 }
5350
5351 for(i=0; i<14; i++)
5352 {
5353 priv->EEPROMTxPowerLevelCCK24G[i] = (u8)(EEPROM_Default_TxPower & 0xff);
5354 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8)(EEPROM_Default_TxPower & 0xff);
5355 }
5356
5357 //
5358 // Update HAL variables.
5359 //
5360 memcpy( priv->TxPowerLevelOFDM24G, priv->EEPROMTxPowerLevelOFDM24G, 14);
5361 memcpy( priv->TxPowerLevelCCK, priv->EEPROMTxPowerLevelCCK24G, 14);
5362 //RT_PRINT_DATA(COMP_INIT|COMP_EFUSE, DBG_LOUD, ("HAL CCK 2.4G TxPwr: \n"), priv->TxPowerLevelCCK, 14);
5363 //RT_PRINT_DATA(COMP_INIT|COMP_EFUSE, DBG_LOUD, ("HAL OFDM 2.4G TxPwr: \n"), priv->TxPowerLevelOFDM24G, 14);
5364 #else
5365
5366 for (rf_path = 0; rf_path < 2; rf_path++)
5367 {
5368 for (i = 0; i < 3; i++)
5369 {
5370 // Read CCK RF A & B Tx power
5371 priv->RfCckChnlAreaTxPwr[rf_path][i] =
5372 priv->RfOfdmChnlAreaTxPwr1T[rf_path][i] =
5373 priv->RfOfdmChnlAreaTxPwr2T[rf_path][i] =
5374 (u8)(EEPROM_Default_TxPower & 0xff);
5375 }
5376 }
5377
5378 for (i = 0; i < 3; i++)
5379 {
5380 //RT_TRACE((COMP_EFUSE), "CCK RF-%d CHan_Area-%d = 0x%x\n", rf_path, i,
5381 //priv->RfCckChnlAreaTxPwr[rf_path][i]);
5382 //RT_TRACE((COMP_EFUSE), "OFDM-1T RF-%d CHan_Area-%d = 0x%x\n", rf_path, i,
5383 //priv->RfOfdmChnlAreaTxPwr1T[rf_path][i]);
5384 //RT_TRACE((COMP_EFUSE), "OFDM-2T RF-%d CHan_Area-%d = 0x%x\n", rf_path, i,
5385 //priv->RfOfdmChnlAreaTxPwr2T[rf_path][i]);
5386 }
5387
5388 // Assign dedicated channel tx power
5389 for(i=0; i<14; i++) // channel 1~3 use the same Tx Power Level.
5390 {
5391 if (i < 3) // Cjanel 1-3
5392 index = 0;
5393 else if (i < 9) // Channel 4-9
5394 index = 1;
5395 else // Channel 10-14
5396 index = 2;
5397
5398 // Record A & B CCK /OFDM - 1T/2T Channel area tx power
5399 priv->RfTxPwrLevelCck[rf_path][i] =
5400 priv->RfCckChnlAreaTxPwr[rf_path][index];
5401 priv->RfTxPwrLevelOfdm1T[rf_path][i] =
5402 priv->RfOfdmChnlAreaTxPwr1T[rf_path][index];
5403 priv->RfTxPwrLevelOfdm2T[rf_path][i] =
5404 priv->RfOfdmChnlAreaTxPwr2T[rf_path][index];
5405 }
5406
5407 for(i=0; i<14; i++)
5408 {
5409 //RT_TRACE((COMP_EFUSE), "Rf-%d TxPwr CH-%d CCK OFDM_1T OFDM_2T= 0x%x/0x%x/0x%x\n",
5410 //rf_path, i, priv->RfTxPwrLevelCck[0][i],
5411 //priv->RfTxPwrLevelOfdm1T[0][i] ,
5412 //priv->RfTxPwrLevelOfdm2T[0][i] );
5413 }
5414 #endif
5415
5416 //
5417 // Update remained HAL variables.
5418 //
5419 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
5420 priv->LegacyHTTxPowerDiff = priv->EEPROMTxPowerDiff;//new
5421 priv->TxPowerDiff = priv->EEPROMTxPowerDiff;
5422 //priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);// Antenna B gain offset to antenna A, bit0~3
5423 //priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);// Antenna C gain offset to antenna A, bit4~7
5424 priv->CrystalCap = priv->EEPROMCrystalCap; // CrystalCap, bit12~15
5425 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;// ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
5426 priv->LedStrategy = SW_LED_MODE0;
5427
5428 init_rate_adaptive(dev);
5429
5430 RT_TRACE(COMP_INIT, "<==== ConfigAdapterInfo8192SForAutoLoadFail\n");
5431
5432 }
5433
5434 #if 0
5435 static void rtl8192SU_ReadAdapterInfo8192SEEPROM(struct net_device* dev)
5436 {
5437 u16 EEPROMId = 0;
5438 u8 bLoad_From_EEPOM = false;
5439 struct r8192_priv *priv = ieee80211_priv(dev);
5440 u16 tmpValue = 0;
5441 u8 tmpBuffer[30];
5442 int i;
5443
5444 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
5445
5446
5447 write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader
5448 udelay(10000);
5449 write_nic_byte(dev, PMC_FSM, 0x02); // Enable Loader Data Keep
5450
5451
5452 EEPROMId = eprom_read(dev, 0); //first read EEPROM ID out;
5453 RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", EEPROMId);
5454
5455 if (EEPROMId != RTL8190_EEPROM_ID)
5456 {
5457 priv->AutoloadFailFlag = true;
5458 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", EEPROMId, RTL8190_EEPROM_ID);
5459 }
5460 else
5461 {
5462 priv->AutoloadFailFlag = false;
5463 bLoad_From_EEPOM = true;
5464 }
5465
5466 if (bLoad_From_EEPOM)
5467 {
5468 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
5469 priv->eeprom_vid = endian_swap(&tmpValue);
5470 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
5471
5472 // Version ID, Channel plan
5473 tmpValue = eprom_read(dev, (EEPROM_Version>>1));
5474 //pHalData->card_8192_version = (VERSION_8192S)((usValue&0x00ff));
5475 priv->eeprom_ChannelPlan =(tmpValue&0xff00)>>8;
5476 priv->bTXPowerDataReadFromEEPORM = true;
5477
5478 // Customer ID, 0x00 and 0xff are reserved for Realtek.
5479 tmpValue = eprom_read(dev, (u16)(EEPROM_CustomID>>1)) ;
5480 priv->eeprom_CustomerID = (u8)( tmpValue & 0xff);
5481 priv->eeprom_SubCustomerID = (u8)((tmpValue & 0xff00)>>8);
5482 }
5483 else
5484 {
5485 priv->eeprom_vid = 0;
5486 priv->eeprom_pid = 0;
5487 //priv->card_8192_version = VERSION_8192SU_A;
5488 priv->eeprom_ChannelPlan = 0;
5489 priv->eeprom_CustomerID = 0;
5490 priv->eeprom_SubCustomerID = 0;
5491 }
5492 RT_TRACE(COMP_EPROM, "vid:0x%4x, pid:0x%4x, CustomID:0x%2x, ChanPlan:0x%x\n", priv->eeprom_vid, priv->eeprom_pid, priv->eeprom_CustomerID, priv->eeprom_ChannelPlan);
5493 //set channelplan from eeprom
5494 priv->ChannelPlan = priv->eeprom_ChannelPlan;// FIXLZM
5495
5496 RT_TRACE(COMP_INIT, "EEPROMId = 0x%4x\n", EEPROMId);
5497 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
5498 RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid);
5499 //RT_TRACE(COMP_INIT, DBG_LOUD, ("EEPROM Version ID: 0x%2x\n", pHalData->VersionID));
5500 RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
5501 RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n", priv->eeprom_SubCustomerID);
5502 RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", priv->eeprom_ChannelPlan);
5503
5504 // Read USB optional function.
5505 if(bLoad_From_EEPOM)
5506 {
5507 tmpValue = eprom_read(dev, (EEPROM_USB_OPTIONAL>>1));
5508 priv->EEPROMUsbOption = (u8)(tmpValue&0xff);
5509 }
5510 else
5511 {
5512 priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC;
5513 }
5514
5515 RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption);
5516
5517
5518 if (bLoad_From_EEPOM)
5519 {
5520 int i;
5521 for (i=0; i<6; i+=2)
5522 {
5523 u16 tmp = 0;
5524 tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
5525 *(u16*)(&dev->dev_addr[i]) = tmp;
5526 }
5527 }
5528 else
5529 {
5530 //<Roger_Notes> In this case, we random assigh MAC address here. 2008.10.15.
5531 static u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x92, 0x00};
5532 u8 i;
5533
5534 //sMacAddr[5] = (u8)GetRandomNumber(1, 254);
5535
5536 for(i = 0; i < 6; i++)
5537 dev->dev_addr[i] = sMacAddr[i];
5538
5539 //memcpy(dev->dev_addr, sMacAddr, 6);
5540 //should I set IDR0 here?
5541 }
5542 write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
5543 write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
5544 RT_TRACE(COMP_EPROM, "MAC addr:"MAC_FMT"\n", MAC_ARG(dev->dev_addr));
5545
5546 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
5547 #if (defined (RTL8192SU_FPGA_2MAC_VERIFICATION)||defined (RTL8192SU_ASIC_VERIFICATION))
5548 priv->rf_chip = RF_6052;
5549 priv->rf_type = RTL819X_DEFAULT_RF_TYPE;
5550 //priv->card_8192_version = VERSION_8192SU_A; //Over write for temporally experiment. 2008.10.16. By Roger.
5551 #else
5552 priv->rf_chip = RF_8256;
5553 #endif
5554
5555 {
5556 #if 0
5557 if(bLoad_From_EEPOM)
5558 {
5559 tempval = (ReadEEprom(Adapter, (EEPROM_RFInd_PowerDiff>>1))) & 0xff;
5560 if (tempval&0x80) //RF-indication, bit[7]
5561 pHalData->RF_Type = RF_1T2R;
5562 else
5563 pHalData->RF_Type = RF_2T4R;
5564 }
5565 #endif
5566
5567 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPowerDiff;
5568 RT_TRACE(COMP_INIT, "TxPowerDiff = %#x\n", priv->EEPROMTxPowerDiff);
5569
5570
5571 //
5572 // Read antenna tx power offset of B/C/D to A from EEPROM
5573 // and read ThermalMeter from EEPROM
5574 //
5575 if(bLoad_From_EEPOM)
5576 {
5577 tmpValue = eprom_read(dev, (EEPROM_PwDiff>>1));
5578 priv->EEPROMPwDiff = tmpValue&0x00ff;
5579 priv->EEPROMThermalMeter = (tmpValue&0xff00)>>8;
5580 }
5581 else
5582 {
5583 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
5584 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
5585 }
5586 RT_TRACE(COMP_INIT, "PwDiff = %#x\n", priv->EEPROMPwDiff);
5587 RT_TRACE(COMP_INIT, "ThermalMeter = %#x\n", priv->EEPROMThermalMeter);
5588
5589 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
5590
5591
5592 // Read CrystalCap from EEPROM
5593 if(bLoad_From_EEPOM)
5594 {
5595 priv->EEPROMCrystalCap =(u8) (((eprom_read(dev, (EEPROM_CrystalCap>>1)))&0xf000)>>12);
5596 }
5597 else
5598 {
5599 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
5600 }
5601 RT_TRACE(COMP_INIT, "CrystalCap = %#x\n", priv->EEPROMCrystalCap);
5602
5603
5604 //if(pHalData->EEPROM_Def_Ver == 0) // old eeprom definition
5605 {
5606
5607 //
5608 // Get Tx Power Base.//===>
5609 //
5610 if(bLoad_From_EEPOM)
5611 {
5612 priv->EEPROMTxPwrBase =(u8) ((eprom_read(dev, (EEPROM_TxPowerBase>>1)))&0xff);
5613 }
5614 else
5615 {
5616 priv->EEPROMTxPwrBase = EEPROM_Default_TxPowerBase;
5617 }
5618
5619 RT_TRACE(COMP_INIT, "TxPwrBase = %#x\n", priv->EEPROMTxPwrBase);
5620
5621 //
5622 // Get CustomerID(Boad Type)
5623 // i.e., 0x0: RTL8188SU, 0x1: RTL8191SU, 0x2: RTL8192SU, 0x3: RTL8191GU.
5624 // Others: Reserved. Default is 0x2: RTL8192SU.
5625 //
5626 if(bLoad_From_EEPOM)
5627 {
5628 tmpValue = eprom_read(dev, (u16) (EEPROM_BoardType>>1));
5629 priv->EEPROMBoardType = (u8)(tmpValue&0xff);
5630 }
5631 else
5632 {
5633 priv->EEPROMBoardType = EEPROM_Default_BoardType;
5634 }
5635
5636 RT_TRACE(COMP_INIT, "BoardType = %#x\n", priv->EEPROMBoardType);
5637
5638 #ifdef EEPROM_OLD_FORMAT_SUPPORT
5639
5640 //
5641 // Buffer TxPwIdx(i.e., from offset 0x58~0x75, total 30Bytes)
5642 //
5643 if(bLoad_From_EEPOM)
5644 {
5645 for(i = 0; i < 30; i += 2)
5646 {
5647 tmpValue = eprom_read(dev, (u16) ((EEPROM_TxPowerBase+i)>>1));
5648 *((u16 *)(&tmpBuffer[i])) = tmpValue;
5649 }
5650 }
5651
5652 //
5653 // Update CCK, OFDM Tx Power Index from above buffer.
5654 //
5655 if(bLoad_From_EEPOM)
5656 {
5657 for(i=0; i<14; i++)
5658 {
5659 priv->EEPROMTxPowerLevelCCK24G[i] = (u8)tmpBuffer[i+1];
5660 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8)tmpBuffer[i+15];
5661 }
5662
5663 }
5664 else
5665 {
5666 for(i=0; i<14; i++)
5667 {
5668 priv->EEPROMTxPowerLevelCCK24G[i] = (u8)(EEPROM_Default_TxPower & 0xff);
5669 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8)(EEPROM_Default_TxPower & 0xff);
5670 }
5671 }
5672
5673 for(i=0; i<14; i++)
5674 {
5675 RT_TRACE(COMP_INIT, "CCK 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK24G[i]);
5676 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelOFDM24G[i]);
5677 }
5678 #else
5679 // Please add code in the section!!!!
5680 // And merge tx power difference section.
5681 #endif
5682
5683 //
5684 // Get TSSI value for each path.
5685 //
5686 if(bLoad_From_EEPOM)
5687 {
5688 tmpValue = eprom_read(dev, (u16) ((EEPROM_TSSI_A)>>1));
5689 priv->EEPROMTSSI_A = (u8)((tmpValue&0xff00)>>8);
5690 }
5691 else
5692 { // Default setting for Empty EEPROM
5693 priv->EEPROMTSSI_A = EEPROM_Default_TSSI;
5694 }
5695
5696 if(bLoad_From_EEPOM)
5697 {
5698 tmpValue = eprom_read(dev, (u16) ((EEPROM_TSSI_B)>>1));
5699 priv->EEPROMTSSI_B = (u8)(tmpValue&0xff);
5700 priv->EEPROMTxPwrTkMode = (u8)((tmpValue&0xff00)>>8);
5701 }
5702 else
5703 { // Default setting for Empty EEPROM
5704 priv->EEPROMTSSI_B = EEPROM_Default_TSSI;
5705 priv->EEPROMTxPwrTkMode = EEPROM_Default_TxPwrTkMode;
5706 }
5707
5708 RT_TRACE(COMP_INIT, "TSSI_A = %#x, TSSI_B = %#x\n", priv->EEPROMTSSI_A, priv->EEPROMTSSI_B);
5709 RT_TRACE(COMP_INIT, "TxPwrTkMod = %#x\n", priv->EEPROMTxPwrTkMode);
5710
5711 #ifdef EEPROM_OLD_FORMAT_SUPPORT
5712 //
5713 // Get HT 2T Path A and B Power Index.
5714 //
5715 if(bLoad_From_EEPOM)
5716 {
5717 for(i = 0; i < 6; i += 2)
5718 {
5719 tmpValue = eprom_read(dev, (u16) ((EEPROM_HT2T_CH1_A+i)>>1));
5720 *((u16*)(&priv->EEPROMHT2T_TxPwr[i])) = tmpValue;
5721 }
5722 }
5723 else
5724 { // Default setting for Empty EEPROM
5725 for(i=0; i<6; i++)
5726 {
5727 priv->EEPROMHT2T_TxPwr[i] = EEPROM_Default_HT2T_TxPwr;
5728 }
5729 }
5730
5731 for(i=0; i<6; i++)
5732 {
5733 RT_TRACE(COMP_INIT, "EEPROMHT2T_TxPwr, Index %d = 0x%02x\n", i, priv->EEPROMHT2T_TxPwr[i]);
5734 }
5735 #else
5736
5737 #endif
5738 }
5739
5740 #ifdef EEPROM_OLD_FORMAT_SUPPORT
5741 //
5742 // Update HAL variables.
5743 //
5744 for(i=0; i<14; i++)
5745 {
5746 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[i];
5747 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK24G[i];
5748 }
5749 #else
5750
5751 #endif
5752 priv->TxPowerDiff = priv->EEPROMPwDiff;
5753 // Antenna B gain offset to antenna A, bit0~3
5754 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
5755 // Antenna C gain offset to antenna A, bit4~7
5756 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
5757 // CrystalCap, bit12~15
5758 priv->CrystalCap = priv->EEPROMCrystalCap;
5759 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
5760 // 92U does not enable TX power tracking.
5761 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
5762 }
5763
5764 priv->LedStrategy = SW_LED_MODE0;
5765
5766 if(priv->rf_type == RF_1T2R)
5767 {
5768 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
5769 }
5770 else
5771 {
5772 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
5773 }
5774
5775 // 2008/01/16 MH We can only know RF type in the function. So we have to init
5776 // DIG RATR table again.
5777 init_rate_adaptive(dev);
5778 //we need init DIG RATR table here again.
5779
5780 RT_TRACE(COMP_EPROM, "<===========%s()\n", __FUNCTION__);
5781 return;
5782 }
5783
5784 //
5785 // Description:
5786 // 1. Read HW adapter information by E-Fuse.
5787 // 2. Refered from SD1 Richard.
5788 //
5789 // Assumption:
5790 // 1. Boot from E-Fuse and CR9346 regiser has verified.
5791 // 2. PASSIVE_LEVEL (USB interface)
5792 //
5793 // Created by Roger, 2008.10.21.
5794 //
5795 void
5796 rtl8192SU_ReadAdapterInfo8192SEFuse(struct net_device* dev)
5797 {
5798 struct r8192_priv *priv = ieee80211_priv(dev);
5799 u16 i,usValue;
5800 u16 EEPROMId;
5801 u8 readbyte;
5802 u8 OFDMTxPwr[14];
5803 u8 CCKTxPwr[14];
5804 u8 HT2T_TxPwr[6];
5805 u8 UsbPhyParam[5];
5806 u8 hwinfo[HWSET_MAX_SIZE_92S];
5807
5808
5809 RT_TRACE(COMP_INIT, "====> ReadAdapterInfo8192SEFuse\n");
5810
5811 //
5812 // <Roger_Notes> We set Isolation signals from Loader and reset EEPROM after system resuming
5813 // from suspend mode.
5814 // 2008.10.21.
5815 //
5816 write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader
5817 //PlatformStallExecution(10000);
5818 mdelay(10);
5819 write_nic_byte(dev, SYS_FUNC_EN+1, 0x40);
5820 write_nic_byte(dev, SYS_FUNC_EN+1, 0x50);
5821
5822 readbyte = read_nic_byte(dev, EFUSE_TEST+3);
5823 write_nic_byte(dev, EFUSE_TEST+3, (readbyte | 0x80));
5824 write_nic_byte(dev, EFUSE_TEST+3, 0x72);
5825 write_nic_byte(dev, EFUSE_CLK, 0x03);
5826
5827 //
5828 // Dump EFUSe at init time for later use
5829 //
5830 // Read EFUSE real map to shadow!!
5831 EFUSE_ShadowMapUpdate(dev);
5832
5833 memcpy(hwinfo, (void*)&priv->EfuseMap[EFUSE_INIT_MAP][0], HWSET_MAX_SIZE_92S);
5834 //RT_PRINT_DATA(COMP_INIT, DBG_LOUD, ("MAP \n"), hwinfo, HWSET_MAX_SIZE_92S);
5835
5836 //
5837 // <Roger_Notes> Event though CR9346 regiser can verify whether Autoload is success or not, but we still
5838 // double check ID codes for 92S here(e.g., due to HW GPIO polling fail issue).
5839 // 2008.10.21.
5840 //
5841 ReadEFuse(dev, 0, 2, (unsigned char*) &EEPROMId);
5842
5843 if( EEPROMId != RTL8190_EEPROM_ID )
5844 {
5845 RT_TRACE(COMP_INIT, "EEPROM ID(%#x) is invalid!!\n", EEPROMId);
5846 priv->AutoloadFailFlag=true;
5847 }
5848 else
5849 {
5850 priv->AutoloadFailFlag=false;
5851 }
5852
5853 // Read IC Version && Channel Plan
5854 if(!priv->AutoloadFailFlag)
5855 {
5856
5857 // VID, PID
5858 ReadEFuse(dev, EEPROM_VID, 2, (unsigned char*) &priv->eeprom_vid);
5859 ReadEFuse(dev, EEPROM_PID, 2, (unsigned char*) &priv->eeprom_pid);
5860
5861 // Version ID, Channel plan
5862 ReadEFuse(dev, EEPROM_Version, 2, (unsigned char*) &usValue);
5863 //pHalData->VersionID = (VERSION_8192S)(usValue&0x00ff);
5864 priv->eeprom_ChannelPlan = (usValue&0xff00>>8);
5865 priv->bTXPowerDataReadFromEEPORM = true;
5866
5867 // Customer ID, 0x00 and 0xff are reserved for Realtek.
5868 ReadEFuse(dev, EEPROM_CustomID, 2, (unsigned char*) &usValue);
5869 priv->eeprom_CustomerID = (u8)( usValue & 0xff);
5870 priv->eeprom_SubCustomerID = (u8)((usValue & 0xff00)>>8);
5871 }
5872 else
5873 {
5874 priv->eeprom_vid = 0;
5875 priv->eeprom_pid = 0;
5876 priv->eeprom_ChannelPlan = 0;
5877 priv->eeprom_CustomerID = 0;
5878 priv->eeprom_SubCustomerID = 0;
5879 }
5880
5881 RT_TRACE(COMP_INIT, "EEPROM Id = 0x%4x\n", EEPROMId);
5882 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
5883 RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid);
5884 //RT_TRACE(COMP_INIT, DBG_LOUD, ("EEPROM Version ID: 0x%2x\n", pHalData->VersionID));
5885 RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
5886 RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n", priv->eeprom_SubCustomerID);
5887 RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", priv->eeprom_ChannelPlan);
5888
5889
5890 // Read USB optional function.
5891 if(!priv->AutoloadFailFlag)
5892 {
5893 ReadEFuse(dev, EEPROM_USB_OPTIONAL, 1, (unsigned char*) &priv->EEPROMUsbOption);
5894 }
5895 else
5896 {
5897 priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC;
5898 }
5899
5900 RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption);
5901
5902
5903 // Read USB PHY parameters.
5904 if(!priv->AutoloadFailFlag)
5905 {
5906 ReadEFuse(dev, EEPROM_USB_PHY_PARA1, 5, (unsigned char*)UsbPhyParam);
5907 for(i=0; i<5; i++)
5908 {
5909 priv->EEPROMUsbPhyParam[i] = UsbPhyParam[i];
5910 RT_TRACE(COMP_INIT, "USB Param = index(%d) = %#x\n", i, priv->EEPROMUsbPhyParam[i]);
5911 }
5912 }
5913 else
5914 {
5915 for(i=0; i<5; i++)
5916 {
5917 priv->EEPROMUsbPhyParam[i] = EEPROM_USB_Default_PHY_PARAM;
5918 RT_TRACE(COMP_INIT, "USB Param = index(%d) = %#x\n", i, priv->EEPROMUsbPhyParam[i]);
5919 }
5920 }
5921
5922
5923 //Read Permanent MAC address
5924 if(!priv->AutoloadFailFlag)
5925 {
5926 u8 macaddr[6] = {0x00, 0xe1, 0x86, 0x4c, 0x92, 0x00};
5927
5928 ReadEFuse(dev, EEPROM_NODE_ADDRESS_BYTE_0, 6, (unsigned char*)macaddr);
5929 for(i=0; i<6; i++)
5930 dev->dev_addr[i] = macaddr[i];
5931 }
5932 else
5933 {//Auto load fail
5934
5935 //<Roger_Notes> In this case, we random assigh MAC address here. 2008.10.15.
5936 static u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x92, 0x00};
5937 u8 i;
5938
5939 //if(!Adapter->bInHctTest)
5940 //sMacAddr[5] = (u8)GetRandomNumber(1, 254);
5941
5942 for(i = 0; i < 6; i++)
5943 dev->dev_addr[i] = sMacAddr[i];
5944 }
5945
5946 //NicIFSetMacAddress(Adapter, Adapter->PermanentAddress);
5947 write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
5948 write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
5949
5950 RT_TRACE(COMP_INIT, "ReadAdapterInfo8192SEFuse(), Permanent Address = %02x-%02x-%02x-%02x-%02x-%02x\n",
5951 dev->dev_addr[0], dev->dev_addr[1],
5952 dev->dev_addr[2], dev->dev_addr[3],
5953 dev->dev_addr[4], dev->dev_addr[5]);
5954
5955 // 2007/11/15 MH For RTL8192USB we assign as 1T2R now.
5956 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; // default : 1T2R
5957
5958 #if (defined (RTL8192SU_FPGA_2MAC_VERIFICATION)||defined (RTL8192SU_ASIC_VERIFICATION))
5959 priv->rf_chip = RF_6052;
5960 priv->rf_type = RTL819X_DEFAULT_RF_TYPE;
5961 #else
5962 priv->rf_chip = RF_8256;
5963 #endif
5964
5965 {
5966 //
5967 // Read antenna tx power offset of B/C/D to A from EEPROM
5968 // and read ThermalMeter from EEPROM
5969 //
5970 if(!priv->AutoloadFailFlag)
5971 {
5972 ReadEFuse(dev, EEPROM_PwDiff, 2, (unsigned char*) &usValue);
5973 priv->EEPROMPwDiff = usValue&0x00ff;
5974 priv->EEPROMThermalMeter = (usValue&0xff00)>>8;
5975 }
5976 else
5977 {
5978 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
5979 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
5980 }
5981
5982 RT_TRACE(COMP_INIT, "PwDiff = %#x\n", priv->EEPROMPwDiff);
5983 RT_TRACE(COMP_INIT, "ThermalMeter = %#x\n", priv->EEPROMThermalMeter);
5984
5985 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
5986
5987 //
5988 // Read Tx Power gain offset of legacy OFDM to HT rate.
5989 // Read CrystalCap from EEPROM
5990 //
5991 if(!priv->AutoloadFailFlag)
5992 {
5993 ReadEFuse(dev, EEPROM_CrystalCap, 1, (unsigned char*) &usValue);
5994 priv->EEPROMCrystalCap = (u8)((usValue&0xf0)>>4);
5995 }
5996 else
5997 {
5998 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
5999 }
6000
6001 RT_TRACE(COMP_INIT, "CrystalCap = %#x\n", priv->EEPROMCrystalCap);
6002
6003 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPowerDiff;
6004 RT_TRACE(COMP_INIT, "TxPowerDiff = %d\n", priv->EEPROMTxPowerDiff);
6005
6006
6007 //
6008 // Get Tx Power Base.
6009 //
6010 if(!priv->AutoloadFailFlag)
6011 {
6012 ReadEFuse(dev, EEPROM_TxPowerBase, 1, (unsigned char*) &priv->EEPROMTxPwrBase );
6013 }
6014 else
6015 {
6016 priv->EEPROMTxPwrBase = EEPROM_Default_TxPowerBase;
6017 }
6018
6019 RT_TRACE(COMP_INIT, "TxPwrBase = %#x\n", priv->EEPROMTxPwrBase);
6020
6021 //
6022 // Get CustomerID(Boad Type)
6023 // i.e., 0x0: RTL8188SU, 0x1: RTL8191SU, 0x2: RTL8192SU, 0x3: RTL8191GU.
6024 // Others: Reserved. Default is 0x2: RTL8192SU.
6025 //
6026 if(!priv->AutoloadFailFlag)
6027 {
6028 ReadEFuse(dev, EEPROM_BoardType, 1, (unsigned char*) &priv->EEPROMBoardType );
6029 }
6030 else
6031 {
6032 priv->EEPROMBoardType = EEPROM_Default_BoardType;
6033 }
6034
6035 RT_TRACE(COMP_INIT, "BoardType = %#x\n", priv->EEPROMBoardType);
6036
6037 //if(pHalData->EEPROM_Def_Ver == 0)
6038 {
6039 #ifdef EEPROM_OLD_FORMAT_SUPPORT
6040 //
6041 // Get CCK Tx Power Index.
6042 //
6043 if(!priv->AutoloadFailFlag)
6044 {
6045 ReadEFuse(dev, EEPROM_TxPwIndex_CCK_24G, 14, (unsigned char*)CCKTxPwr);
6046 for(i=0; i<14; i++)
6047 {
6048 RT_TRACE(COMP_INIT, "CCK 2.4G Tx Power Level, Index %d = 0x%02x\n", i, CCKTxPwr[i]);
6049 priv->EEPROMTxPowerLevelCCK24G[i] = CCKTxPwr[i];
6050 }
6051 }
6052 else
6053 { // Default setting for Empty EEPROM
6054 for(i=0; i<14; i++)
6055 priv->EEPROMTxPowerLevelCCK24G[i] = (u8)(EEPROM_Default_TxPower & 0xff);
6056 }
6057
6058 //
6059 // Get OFDM Tx Power Index.
6060 //
6061 if(!priv->AutoloadFailFlag)
6062 {
6063 ReadEFuse(dev, EEPROM_TxPwIndex_OFDM_24G, 14, (unsigned char*)OFDMTxPwr);
6064 for(i=0; i<14; i++)
6065 {
6066 RT_TRACE(COMP_INIT, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, OFDMTxPwr[i]);
6067 priv->EEPROMTxPowerLevelOFDM24G[i] = OFDMTxPwr[i];
6068 }
6069 }
6070 else
6071 { // Default setting for Empty EEPROM
6072 usValue = 0x10;
6073 for(i=0; i<14; i++)
6074 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8)usValue;
6075 }
6076 #else
6077 // Please add code in the section!!!!
6078 // And merge tx power difference section.
6079 #endif
6080
6081 //
6082 // Get TSSI value for each path.
6083 //
6084 if(!priv->AutoloadFailFlag)
6085 {
6086 ReadEFuse(dev, EEPROM_TSSI_A, 2, (unsigned char*)&usValue);
6087 priv->EEPROMTSSI_A = (u8)(usValue&0xff);
6088 priv->EEPROMTSSI_B = (u8)((usValue&0xff00)>>8);
6089 }
6090 else
6091 { // Default setting for Empty EEPROM
6092 priv->EEPROMTSSI_A = EEPROM_Default_TSSI;
6093 priv->EEPROMTSSI_B = EEPROM_Default_TSSI;
6094 }
6095
6096 RT_TRACE(COMP_INIT, "TSSI_A = %#x, TSSI_B = %#x\n",
6097 priv->EEPROMTSSI_A, priv->EEPROMTSSI_B);
6098
6099 //
6100 // Get Tx Power tracking mode.
6101 //
6102 if(!priv->AutoloadFailFlag)
6103 {
6104 ReadEFuse(dev, EEPROM_TxPwTkMode, 1, (unsigned char*)&priv->EEPROMTxPwrTkMode);
6105 }
6106 else
6107 { // Default setting for Empty EEPROM
6108 priv->EEPROMTxPwrTkMode = EEPROM_Default_TxPwrTkMode;
6109 }
6110
6111 RT_TRACE(COMP_INIT, "TxPwrTkMod = %#x\n", priv->EEPROMTxPwrTkMode);
6112
6113
6114 // TODO: The following HT 2T Path A and B Power Index should be updated.!! Added by Roger, 2008.20.23.
6115
6116 //
6117 // Get HT 2T Path A and B Power Index.
6118 //
6119 if(!priv->AutoloadFailFlag)
6120 {
6121 ReadEFuse(dev, EEPROM_HT2T_CH1_A, 6, (unsigned char*)HT2T_TxPwr);
6122 for(i=0; i<6; i++)
6123 {
6124 priv->EEPROMHT2T_TxPwr[i] = HT2T_TxPwr[i];
6125 }
6126 }
6127 else
6128 { // Default setting for Empty EEPROM
6129 for(i=0; i<6; i++)
6130 {
6131 priv->EEPROMHT2T_TxPwr[i] = EEPROM_Default_HT2T_TxPwr;
6132 }
6133 }
6134
6135 for(i=0; i<6; i++)
6136 {
6137 RT_TRACE(COMP_INIT, "EEPROMHT2T_TxPwr, Index %d = 0x%02x\n",
6138 i, priv->EEPROMHT2T_TxPwr[i]);
6139 }
6140 }
6141
6142 #ifdef EEPROM_OLD_FORMAT_SUPPORT
6143 //
6144 // Update HAL variables.
6145 //
6146 for(i=0; i<14; i++)
6147 {
6148 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[i];
6149 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK24G[i];
6150 }
6151 #else
6152
6153 #endif
6154 priv->TxPowerDiff = priv->EEPROMPwDiff;
6155 // Antenna B gain offset to antenna A, bit0~3
6156 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
6157 // Antenna C gain offset to antenna A, bit4~7
6158 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
6159 // CrystalCap, bit12~15
6160 priv->CrystalCap = priv->EEPROMCrystalCap;
6161 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
6162 // 92U does not enable TX power tracking.
6163 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
6164 }
6165
6166 priv->LedStrategy = SW_LED_MODE0;
6167
6168 init_rate_adaptive(dev);
6169
6170 RT_TRACE(COMP_INIT, "<==== ReadAdapterInfo8192SEFuse\n");
6171
6172 }
6173 #endif
6174
6175 //
6176 // Description:
6177 // Read HW adapter information by E-Fuse or EEPROM according CR9346 reported.
6178 //
6179 // Assumption:
6180 // 1. CR9346 regiser has verified.
6181 // 2. PASSIVE_LEVEL (USB interface)
6182 //
6183 // Created by Roger, 2008.10.21.
6184 //
6185 void
6186 rtl8192SU_ReadAdapterInfo8192SUsb(struct net_device* dev)
6187 {
6188 struct r8192_priv *priv = ieee80211_priv(dev);
6189 u16 i,usValue;
6190 u8 tmpU1b, tempval;
6191 u16 EEPROMId;
6192 u8 hwinfo[HWSET_MAX_SIZE_92S];
6193 u8 rf_path, index; // For EEPROM/EFUSE After V0.6_1117
6194
6195
6196 RT_TRACE(COMP_INIT, "====> ReadAdapterInfo8192SUsb\n");
6197
6198 //
6199 // <Roger_Note> The following operation are prevent Efuse leakage by turn on 2.5V.
6200 // 2008.11.25.
6201 //
6202 tmpU1b = read_nic_byte(dev, EFUSE_TEST+3);
6203 write_nic_byte(dev, EFUSE_TEST+3, tmpU1b|0x80);
6204 //PlatformStallExecution(1000);
6205 mdelay(10);
6206 write_nic_byte(dev, EFUSE_TEST+3, (tmpU1b&(~BIT7)));
6207
6208 // Retrieve Chip version.
6209 priv->card_8192_version = (VERSION_8192S)((read_nic_dword(dev, PMC_FSM)>>16)&0xF);
6210 RT_TRACE(COMP_INIT, "Chip Version ID: 0x%2x\n", priv->card_8192_version);
6211
6212 switch(priv->card_8192_version)
6213 {
6214 case 0:
6215 RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_ACUT.\n");
6216 break;
6217 case 1:
6218 RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_BCUT.\n");
6219 break;
6220 case 2:
6221 RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_CCUT.\n");
6222 break;
6223 default:
6224 RT_TRACE(COMP_INIT, "Unknown Chip Version!!\n");
6225 priv->card_8192_version = VERSION_8192S_BCUT;
6226 break;
6227 }
6228
6229 //if (IS_BOOT_FROM_EEPROM(Adapter))
6230 if(priv->EepromOrEfuse)
6231 { // Read frin EEPROM
6232 write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader
6233 //PlatformStallExecution(10000);
6234 mdelay(10);
6235 write_nic_byte(dev, PMC_FSM, 0x02); // Enable Loader Data Keep
6236 // Read all Content from EEPROM or EFUSE.
6237 for(i = 0; i < HWSET_MAX_SIZE_92S; i += 2)
6238 {
6239 usValue = eprom_read(dev, (u16) (i>>1));
6240 *((u16*)(&hwinfo[i])) = usValue;
6241 }
6242 }
6243 else if (!(priv->EepromOrEfuse))
6244 { // Read from EFUSE
6245
6246 //
6247 // <Roger_Notes> We set Isolation signals from Loader and reset EEPROM after system resuming
6248 // from suspend mode.
6249 // 2008.10.21.
6250 //
6251 //PlatformEFIOWrite1Byte(Adapter, SYS_ISO_CTRL+1, 0xE8); // Isolation signals from Loader
6252 //PlatformStallExecution(10000);
6253 //PlatformEFIOWrite1Byte(Adapter, SYS_FUNC_EN+1, 0x40);
6254 //PlatformEFIOWrite1Byte(Adapter, SYS_FUNC_EN+1, 0x50);
6255
6256 //tmpU1b = PlatformEFIORead1Byte(Adapter, EFUSE_TEST+3);
6257 //PlatformEFIOWrite1Byte(Adapter, EFUSE_TEST+3, (tmpU1b | 0x80));
6258 //PlatformEFIOWrite1Byte(Adapter, EFUSE_TEST+3, 0x72);
6259 //PlatformEFIOWrite1Byte(Adapter, EFUSE_CLK, 0x03);
6260
6261 // Read EFUSE real map to shadow.
6262 EFUSE_ShadowMapUpdate(dev);
6263 memcpy(hwinfo, &priv->EfuseMap[EFUSE_INIT_MAP][0], HWSET_MAX_SIZE_92S);
6264 }
6265 else
6266 {
6267 RT_TRACE(COMP_INIT, "ReadAdapterInfo8192SUsb(): Invalid boot type!!\n");
6268 }
6269
6270 //YJ,test,090106
6271 //dump_buf(hwinfo,HWSET_MAX_SIZE_92S);
6272 //
6273 // <Roger_Notes> The following are EFUSE/EEPROM independent operations!!
6274 //
6275 //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("MAP: \n"), hwinfo, HWSET_MAX_SIZE_92S);
6276
6277 //
6278 // <Roger_Notes> Event though CR9346 regiser can verify whether Autoload is success or not, but we still
6279 // double check ID codes for 92S here(e.g., due to HW GPIO polling fail issue).
6280 // 2008.10.21.
6281 //
6282 EEPROMId = *((u16 *)&hwinfo[0]);
6283
6284 if( EEPROMId != RTL8190_EEPROM_ID )
6285 {
6286 RT_TRACE(COMP_INIT, "ID(%#x) is invalid!!\n", EEPROMId);
6287 priv->bTXPowerDataReadFromEEPORM = FALSE;
6288 priv->AutoloadFailFlag=TRUE;
6289 }
6290 else
6291 {
6292 priv->AutoloadFailFlag=FALSE;
6293 #if RTL8192SU_USE_PARAM_TXPWR
6294 priv->bTXPowerDataReadFromEEPORM = FALSE;
6295 #else
6296 priv->bTXPowerDataReadFromEEPORM = TRUE;
6297 #endif
6298
6299 }
6300 // Read IC Version && Channel Plan
6301 if(!priv->AutoloadFailFlag)
6302 {
6303 // VID, PID
6304 priv->eeprom_vid = *(u16 *)&hwinfo[EEPROM_VID];
6305 priv->eeprom_pid = *(u16 *)&hwinfo[EEPROM_PID];
6306 priv->bIgnoreDiffRateTxPowerOffset = false; //cosa for test
6307
6308
6309 // EEPROM Version ID, Channel plan
6310 priv->EEPROMVersion = *(u8 *)&hwinfo[EEPROM_Version];
6311 priv->eeprom_ChannelPlan = *(u8 *)&hwinfo[EEPROM_ChannelPlan];
6312
6313 // Customer ID, 0x00 and 0xff are reserved for Realtek.
6314 priv->eeprom_CustomerID = *(u8 *)&hwinfo[EEPROM_CustomID];
6315 priv->eeprom_SubCustomerID = *(u8 *)&hwinfo[EEPROM_SubCustomID];
6316 }
6317 else
6318 {
6319 //priv->eeprom_vid = 0;
6320 //priv->eeprom_pid = 0;
6321 //priv->EEPROMVersion = 0;
6322 //priv->eeprom_ChannelPlan = 0;
6323 //priv->eeprom_CustomerID = 0;
6324 //priv->eeprom_SubCustomerID = 0;
6325
6326 rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(dev);
6327 return;
6328 }
6329
6330
6331 RT_TRACE(COMP_INIT, "EEPROM Id = 0x%4x\n", EEPROMId);
6332 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
6333 RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid);
6334 RT_TRACE(COMP_INIT, "EEPROM Version ID: 0x%2x\n", priv->EEPROMVersion);
6335 RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
6336 RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n", priv->eeprom_SubCustomerID);
6337 RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", priv->eeprom_ChannelPlan);
6338 RT_TRACE(COMP_INIT, "bIgnoreDiffRateTxPowerOffset = %d\n", priv->bIgnoreDiffRateTxPowerOffset);
6339
6340
6341 // Read USB optional function.
6342 if(!priv->AutoloadFailFlag)
6343 {
6344 priv->EEPROMUsbOption = *(u8 *)&hwinfo[EEPROM_USB_OPTIONAL];
6345 }
6346 else
6347 {
6348 priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC;
6349 }
6350
6351
6352 priv->EEPROMUsbEndPointNumber = rtl8192SU_UsbOptionToEndPointNumber((priv->EEPROMUsbOption&EEPROM_EP_NUMBER)>>3);
6353
6354 RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption);
6355 RT_TRACE(COMP_INIT, "EndPoint Number = %#x\n", priv->EEPROMUsbEndPointNumber);
6356
6357 #ifdef TO_DO_LIST
6358 //
6359 // Decide CustomerID according to VID/DID or EEPROM
6360 //
6361 switch(pHalData->EEPROMCustomerID)
6362 {
6363 case EEPROM_CID_ALPHA:
6364 pMgntInfo->CustomerID = RT_CID_819x_ALPHA;
6365 break;
6366
6367 case EEPROM_CID_CAMEO:
6368 pMgntInfo->CustomerID = RT_CID_819x_CAMEO;
6369 break;
6370
6371 case EEPROM_CID_SITECOM:
6372 pMgntInfo->CustomerID = RT_CID_819x_Sitecom;
6373 RT_TRACE(COMP_INIT, DBG_LOUD, ("CustomerID = 0x%4x\n", pMgntInfo->CustomerID));
6374
6375 break;
6376
6377 case EEPROM_CID_WHQL:
6378 Adapter->bInHctTest = TRUE;
6379
6380 pMgntInfo->bSupportTurboMode = FALSE;
6381 pMgntInfo->bAutoTurboBy8186 = FALSE;
6382
6383 pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
6384 pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
6385 pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
6386 pMgntInfo->keepAliveLevel = 0;
6387 break;
6388
6389 default:
6390 pMgntInfo->CustomerID = RT_CID_DEFAULT;
6391 break;
6392
6393 }
6394
6395 //
6396 // Led mode
6397 //
6398 switch(pMgntInfo->CustomerID)
6399 {
6400 case RT_CID_DEFAULT:
6401 case RT_CID_819x_ALPHA:
6402 pHalData->LedStrategy = SW_LED_MODE1;
6403 pHalData->bRegUseLed = TRUE;
6404 pHalData->SwLed1.bLedOn = TRUE;
6405 break;
6406 case RT_CID_819x_CAMEO:
6407 pHalData->LedStrategy = SW_LED_MODE1;
6408 pHalData->bRegUseLed = TRUE;
6409 break;
6410
6411 case RT_CID_819x_Sitecom:
6412 pHalData->LedStrategy = SW_LED_MODE2;
6413 pHalData->bRegUseLed = TRUE;
6414 break;
6415
6416 default:
6417 pHalData->LedStrategy = SW_LED_MODE0;
6418 break;
6419 }
6420 #endif
6421
6422 // Read USB PHY parameters.
6423 for(i=0; i<5; i++)
6424 priv->EEPROMUsbPhyParam[i] = *(u8 *)&hwinfo[EEPROM_USB_PHY_PARA1+i];
6425
6426 //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("USB PHY Param: \n"), pHalData->EEPROMUsbPhyParam, 5);
6427
6428
6429 //Read Permanent MAC address
6430 for(i=0; i<6; i++)
6431 dev->dev_addr[i] = *(u8 *)&hwinfo[EEPROM_NODE_ADDRESS_BYTE_0+i];
6432
6433 //NicIFSetMacAddress(Adapter, Adapter->PermanentAddress);
6434 write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
6435 write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
6436
6437 RT_TRACE(COMP_INIT, "ReadAdapterInfo8192SEFuse(), Permanent Address = %02x-%02x-%02x-%02x-%02x-%02x\n",
6438 dev->dev_addr[0], dev->dev_addr[1],
6439 dev->dev_addr[2], dev->dev_addr[3],
6440 dev->dev_addr[4], dev->dev_addr[5]);
6441
6442 //
6443 // Get CustomerID(Boad Type)
6444 // i.e., 0x0: RTL8188SU, 0x1: RTL8191SU, 0x2: RTL8192SU, 0x3: RTL8191GU.
6445 // Others: Reserved. Default is 0x2: RTL8192SU.
6446 //
6447 //if(!priv->AutoloadFailFlag)
6448 //{
6449 priv->EEPROMBoardType = *(u8 *)&hwinfo[EEPROM_BoardType];
6450 priv->rf_type = rtl8192SU_BoardTypeToRFtype(dev, priv->EEPROMBoardType);
6451 //}
6452 //else
6453 //{
6454 // priv->EEPROMBoardType = EEPROM_Default_BoardType;
6455 // priv->rf_type = RF_1T2R;
6456 //}
6457
6458 #if (defined (RTL8192SU_FPGA_2MAC_VERIFICATION)||defined (RTL8192SU_ASIC_VERIFICATION))
6459 priv->rf_chip = RF_6052;
6460 #else
6461 priv->rf_chip = RF_8256;
6462 #endif
6463
6464 priv->rf_chip = RF_6052;//lzm test
6465 RT_TRACE(COMP_INIT, "BoardType = 0x%2x\n", priv->EEPROMBoardType);
6466 RT_TRACE(COMP_INIT, "RF_Type = 0x%2x\n", priv->rf_type);
6467
6468 //
6469 // Read antenna tx power offset of B/C/D to A from EEPROM
6470 // and read ThermalMeter from EEPROM
6471 //
6472 //if(!priv->AutoloadFailFlag)
6473 {
6474 priv->EEPROMTxPowerDiff = *(u8 *)&hwinfo[EEPROM_PwDiff];
6475 priv->EEPROMThermalMeter = *(u8 *)&hwinfo[EEPROM_ThermalMeter];
6476 }
6477 //else
6478 //{
6479 // priv->EEPROMTxPowerDiff = EEPROM_Default_PwDiff;
6480 // priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
6481 //}
6482
6483 RT_TRACE(COMP_INIT, "PwDiff = %#x\n", priv->EEPROMTxPowerDiff);
6484 RT_TRACE(COMP_INIT, "ThermalMeter = %#x\n", priv->EEPROMThermalMeter);
6485
6486 //
6487 // Read Tx Power gain offset of legacy OFDM to HT rate.
6488 // Read CrystalCap from EEPROM
6489 //
6490 //if(!priv->AutoloadFailFlag)
6491 {
6492 priv->EEPROMCrystalCap = *(u8 *)&hwinfo[EEPROM_CrystalCap];
6493 }
6494 //else
6495 //{
6496 // priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
6497 //}
6498
6499 RT_TRACE(COMP_INIT, "CrystalCap = %#x\n", priv->EEPROMCrystalCap);
6500
6501 //
6502 // Get Tx Power Base.
6503 //
6504 //if(!priv->AutoloadFailFlag)
6505 {
6506 priv->EEPROMTxPwrBase = *(u8 *)&hwinfo[EEPROM_TxPowerBase];
6507 }
6508 //else
6509 //{
6510 // priv->EEPROMTxPwrBase = EEPROM_Default_TxPowerBase;
6511 //}
6512
6513 RT_TRACE(COMP_INIT, "TxPwrBase = %#x\n", priv->EEPROMTxPwrBase);
6514
6515
6516 //
6517 // Get TSSI value for each path.
6518 //
6519 //if(!priv->AutoloadFailFlag)
6520 {
6521 priv->EEPROMTSSI_A = *(u8 *)&hwinfo[EEPROM_TSSI_A];
6522 priv->EEPROMTSSI_B = *(u8 *)&hwinfo[EEPROM_TSSI_B];
6523 }
6524 //else
6525 //{ // Default setting for Empty EEPROM
6526 // priv->EEPROMTSSI_A = EEPROM_Default_TSSI;
6527 // priv->EEPROMTSSI_B = EEPROM_Default_TSSI;
6528 //}
6529
6530 RT_TRACE(COMP_INIT, "TSSI_A = %#x, TSSI_B = %#x\n", priv->EEPROMTSSI_A, priv->EEPROMTSSI_B);
6531
6532 //
6533 // Get Tx Power tracking mode.
6534 //
6535 //if(!priv->AutoloadFailFlag)
6536 {
6537 priv->EEPROMTxPwrTkMode = *(u8 *)&hwinfo[EEPROM_TxPwTkMode];
6538 }
6539
6540 RT_TRACE(COMP_INIT, "TxPwrTkMod = %#x\n", priv->EEPROMTxPwrTkMode);
6541
6542
6543 #ifdef EEPROM_OLD_FORMAT_SUPPORT
6544
6545 //
6546 // <Roger_Notes> The following settings are EFUSE version dependence.
6547 // So we need to adjust reading offset.
6548 // 2008.11.22.
6549 //
6550 {
6551 //
6552 // Get HT 2T Path A and B Power Index.
6553 //
6554 //if(!priv->AutoloadFailFlag)
6555 {
6556 for(i=0; i<6; i++)
6557 {
6558 priv->EEPROMHT2T_TxPwr[i] = *(u8 *)&hwinfo[EEPROM_HT2T_CH1_A+i];
6559 }
6560 }
6561
6562 //RT_PRINT_DATA(COMP_EFUSE, "HT2T TxPwr: \n"), pHalData->EEPROMHT2T_TxPwr, 6);
6563
6564 //
6565 // Get CCK and OFDM Tx Power Index.
6566 //
6567 //if(!priv->AutoloadFailFlag)
6568 {
6569 for(i=0; i<14; i++)
6570 {
6571 priv->EEPROMTxPowerLevelCCK24G[i] = *(u8 *)&hwinfo[EEPROM_TxPwIndex_CCK_24G+i];
6572 priv->EEPROMTxPowerLevelOFDM24G[i] = *(u8 *)&hwinfo[EEPROM_TxPwIndex_OFDM_24G+i];
6573 }
6574 }
6575
6576 //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("CCK 2.4G TxPwr: \n"), pHalData->EEPROMTxPowerLevelCCK24G, 14);
6577 //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("OFDM 2.4G TxPwr: \n"), pHalData->EEPROMTxPowerLevelOFDM24G, 14);
6578
6579 //
6580 // Update HAL variables.
6581 //
6582 memcpy( priv->TxPowerLevelOFDM24G, priv->EEPROMTxPowerLevelOFDM24G, 14);
6583 memcpy( priv->TxPowerLevelCCK, priv->EEPROMTxPowerLevelCCK24G, 14);
6584 //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("HAL CCK 2.4G TxPwr: \n"), pHalData->TxPowerLevelCCK, 14);
6585 //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("HAL OFDM 2.4G TxPwr: \n"), pHalData->TxPowerLevelOFDM24G, 14);
6586
6587 }
6588 #else // Support new version of EFUSE content, 2008.11.22.
6589 {
6590 //
6591 // Buffer TxPwIdx(i.e., from offset 0x55~0x66, total 18Bytes)
6592 // Update CCK, OFDM (1T/2T)Tx Power Index from above buffer.
6593 //
6594
6595 //
6596 // Get Tx Power Level by Channel
6597 //
6598 //if(!priv->AutoloadFailFlag)
6599 {
6600 // Read Tx power of Channel 1 ~ 14 from EFUSE.
6601 // 92S suupport RF A & B
6602 for (rf_path = 0; rf_path < 2; rf_path++)
6603 {
6604 for (i = 0; i < 3; i++)
6605 {
6606 // Read CCK RF A & B Tx power
6607 priv->RfCckChnlAreaTxPwr[rf_path][i] =
6608 hwinfo[EEPROM_TxPwIndex+rf_path*3+i];
6609
6610 // Read OFDM RF A & B Tx power for 1T
6611 priv->RfOfdmChnlAreaTxPwr1T[rf_path][i] =
6612 hwinfo[EEPROM_TxPwIndex+6+rf_path*3+i];
6613
6614 // Read OFDM RF A & B Tx power for 2T
6615 priv->RfOfdmChnlAreaTxPwr2T[rf_path][i] =
6616 hwinfo[EEPROM_TxPwIndex+12+rf_path*3+i];
6617 }
6618 }
6619
6620 }
6621 //
6622 // Update Tx Power HAL variables.
6623 //
6624 for (rf_path = 0; rf_path < 2; rf_path++)
6625 {
6626 for (i = 0; i < 3; i++)
6627 {
6628 RT_TRACE((COMP_INIT), "CCK RF-%d CHan_Area-%d = 0x%x\n", rf_path, i,
6629 priv->RfCckChnlAreaTxPwr[rf_path][i]);
6630 RT_TRACE((COMP_INIT), "OFDM-1T RF-%d CHan_Area-%d = 0x%x\n", rf_path, i,
6631 priv->RfOfdmChnlAreaTxPwr1T[rf_path][i]);
6632 RT_TRACE((COMP_INIT), "OFDM-2T RF-%d CHan_Area-%d = 0x%x\n", rf_path, i, priv->RfOfdmChnlAreaTxPwr2T[rf_path][i]);
6633 }
6634
6635 // Assign dedicated channel tx power
6636 for(i=0; i<14; i++) // channel 1~3 use the same Tx Power Level.
6637 {
6638 if (i < 3) // Cjanel 1-3
6639 index = 0;
6640 else if (i < 9) // Channel 4-9
6641 index = 1;
6642 else // Channel 10-14
6643 index = 2;
6644
6645 // Record A & B CCK /OFDM - 1T/2T Channel area tx power
6646 priv->RfTxPwrLevelCck[rf_path][i] =
6647 priv->RfCckChnlAreaTxPwr[rf_path][index];
6648 priv->RfTxPwrLevelOfdm1T[rf_path][i] =
6649 priv->RfOfdmChnlAreaTxPwr1T[rf_path][index];
6650 priv->RfTxPwrLevelOfdm2T[rf_path][i] =
6651 priv->RfOfdmChnlAreaTxPwr2T[rf_path][index];
6652 if (rf_path == 0)
6653 {
6654 priv->TxPowerLevelOFDM24G[i] = priv->RfTxPwrLevelOfdm1T[rf_path][i] ;
6655 priv->TxPowerLevelCCK[i] = priv->RfTxPwrLevelCck[rf_path][i];
6656 }
6657 }
6658
6659 for(i=0; i<14; i++)
6660 {
6661 RT_TRACE((COMP_INIT),
6662 "Rf-%d TxPwr CH-%d CCK OFDM_1T OFDM_2T= 0x%x/0x%x/0x%x\n",
6663 rf_path, i, priv->RfTxPwrLevelCck[rf_path][i],
6664 priv->RfTxPwrLevelOfdm1T[rf_path][i] ,
6665 priv->RfTxPwrLevelOfdm2T[rf_path][i] );
6666 }
6667 }
6668 }
6669
6670 //
6671 // 2009/02/09 Cosa add for new EEPROM format
6672 //
6673 for(i=0; i<14; i++) // channel 1~3 use the same Tx Power Level.
6674 {
6675 // Read tx power difference between HT OFDM 20/40 MHZ
6676 if (i < 3) // Cjanel 1-3
6677 index = 0;
6678 else if (i < 9) // Channel 4-9
6679 index = 1;
6680 else // Channel 10-14
6681 index = 2;
6682
6683 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_HT20_DIFF+index])&0xff;
6684 priv->TxPwrHt20Diff[RF90_PATH_A][i] = (tempval&0xF);
6685 priv->TxPwrHt20Diff[RF90_PATH_B][i] = ((tempval>>4)&0xF);
6686
6687 // Read OFDM<->HT tx power diff
6688 if (i < 3) // Cjanel 1-3
6689 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_OFDM_DIFF])&0xff;
6690 else if (i < 9) // Channel 4-9
6691 tempval = (*(u8 *)&hwinfo[EEPROM_PwDiff])&0xff;
6692 else // Channel 10-14
6693 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_OFDM_DIFF+1])&0xff;
6694
6695 //cosa tempval = (*(u1Byte *)&hwinfo[EEPROM_TX_PWR_OFDM_DIFF+index])&0xff;
6696 priv->TxPwrLegacyHtDiff[RF90_PATH_A][i] = (tempval&0xF);
6697 priv->TxPwrLegacyHtDiff[RF90_PATH_B][i] = ((tempval>>4)&0xF);
6698
6699 //
6700 // Read Band Edge tx power offset and check if user enable the ability
6701 //
6702 // HT 40 band edge channel
6703 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE])&0xff;
6704 priv->TxPwrbandEdgeHt40[RF90_PATH_A][0] = (tempval&0xF); // Band edge low channel
6705 priv->TxPwrbandEdgeHt40[RF90_PATH_A][1] = ((tempval>>4)&0xF); // Band edge high channel
6706 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+1])&0xff;
6707 priv->TxPwrbandEdgeHt40[RF90_PATH_B][0] = (tempval&0xF); // Band edge low channel
6708 priv->TxPwrbandEdgeHt40[RF90_PATH_B][1] = ((tempval>>4)&0xF); // Band edge high channel
6709 // HT 20 band edge channel
6710 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+2])&0xff;
6711 priv->TxPwrbandEdgeHt20[RF90_PATH_A][0] = (tempval&0xF); // Band edge low channel
6712 priv->TxPwrbandEdgeHt20[RF90_PATH_A][1] = ((tempval>>4)&0xF); // Band edge high channel
6713 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+3])&0xff;
6714 priv->TxPwrbandEdgeHt20[RF90_PATH_B][0] = (tempval&0xF); // Band edge low channel
6715 priv->TxPwrbandEdgeHt20[RF90_PATH_B][1] = ((tempval>>4)&0xF); // Band edge high channel
6716 // OFDM band edge channel
6717 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+4])&0xff;
6718 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][0] = (tempval&0xF); // Band edge low channel
6719 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][1] = ((tempval>>4)&0xF); // Band edge high channel
6720 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+5])&0xff;
6721 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][0] = (tempval&0xF); // Band edge low channel
6722 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][1] = ((tempval>>4)&0xF); // Band edge high channel
6723
6724 priv->TxPwrbandEdgeFlag = (*(u8 *)&hwinfo[TX_PWR_BAND_EDGE_CHK]);
6725 }
6726
6727 for(i=0; i<14; i++)
6728 RT_TRACE(COMP_INIT, "RF-A Ht20 to HT40 Diff[%d] = 0x%x\n", i, priv->TxPwrHt20Diff[RF90_PATH_A][i]);
6729 for(i=0; i<14; i++)
6730 RT_TRACE(COMP_INIT, "RF-A Legacy to Ht40 Diff[%d] = 0x%x\n", i, priv->TxPwrLegacyHtDiff[RF90_PATH_A][i]);
6731 for(i=0; i<14; i++)
6732 RT_TRACE(COMP_INIT, "RF-B Ht20 to HT40 Diff[%d] = 0x%x\n", i, priv->TxPwrHt20Diff[RF90_PATH_B][i]);
6733 for(i=0; i<14; i++)
6734 RT_TRACE(COMP_INIT, "RF-B Legacy to HT40 Diff[%d] = 0x%x\n", i, priv->TxPwrLegacyHtDiff[RF90_PATH_B][i]);
6735 RT_TRACE(COMP_INIT, "RF-A HT40 band-edge low/high power diff = 0x%x/0x%x\n",
6736 priv->TxPwrbandEdgeHt40[RF90_PATH_A][0],
6737 priv->TxPwrbandEdgeHt40[RF90_PATH_A][1]);
6738 RT_TRACE((COMP_INIT&COMP_DBG), "RF-B HT40 band-edge low/high power diff = 0x%x/0x%x\n",
6739 priv->TxPwrbandEdgeHt40[RF90_PATH_B][0],
6740 priv->TxPwrbandEdgeHt40[RF90_PATH_B][1]);
6741
6742 RT_TRACE((COMP_INIT&COMP_DBG), "RF-A HT20 band-edge low/high power diff = 0x%x/0x%x\n",
6743 priv->TxPwrbandEdgeHt20[RF90_PATH_A][0],
6744 priv->TxPwrbandEdgeHt20[RF90_PATH_A][1]);
6745 RT_TRACE((COMP_INIT&COMP_DBG), "RF-B HT20 band-edge low/high power diff = 0x%x/0x%x\n",
6746 priv->TxPwrbandEdgeHt20[RF90_PATH_B][0],
6747 priv->TxPwrbandEdgeHt20[RF90_PATH_B][1]);
6748
6749 RT_TRACE((COMP_INIT&COMP_DBG), "RF-A OFDM band-edge low/high power diff = 0x%x/0x%x\n",
6750 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][0],
6751 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][1]);
6752 RT_TRACE((COMP_INIT&COMP_DBG), "RF-B OFDM band-edge low/high power diff = 0x%x/0x%x\n",
6753 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][0],
6754 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][1]);
6755 RT_TRACE((COMP_INIT&COMP_DBG), "Band-edge enable flag = %d\n", priv->TxPwrbandEdgeFlag);
6756 #endif
6757
6758 //
6759 // Update remained HAL variables.
6760 //
6761 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
6762 priv->LegacyHTTxPowerDiff = priv->EEPROMTxPowerDiff;
6763 priv->TxPowerDiff = priv->EEPROMTxPowerDiff;
6764 //priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);// Antenna B gain offset to antenna A, bit[3:0]
6765 //priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);// Antenna C gain offset to antenna A, bit[7:4]
6766 priv->CrystalCap = priv->EEPROMCrystalCap; // CrystalCap, bit[15:12]
6767 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter&0x1f);// ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
6768 priv->LedStrategy = SW_LED_MODE0;
6769
6770 init_rate_adaptive(dev);
6771
6772 RT_TRACE(COMP_INIT, "<==== ReadAdapterInfo8192SUsb\n");
6773
6774 //return RT_STATUS_SUCCESS;
6775 }
6776
6777
6778 //
6779 // Description:
6780 // Read HW adapter information by E-Fuse or EEPROM according CR9346 reported.
6781 //
6782 // Assumption:
6783 // 1. CR9346 regiser has verified.
6784 // 2. PASSIVE_LEVEL (USB interface)
6785 //
6786 // Created by Roger, 2008.10.21.
6787 //
6788 static void rtl8192SU_read_eeprom_info(struct net_device *dev)
6789 {
6790 struct r8192_priv *priv = ieee80211_priv(dev);
6791 u8 tmpU1b;
6792
6793 RT_TRACE(COMP_INIT, "====> ReadAdapterInfo8192SUsb\n");
6794
6795 // Retrieve Chip version.
6796 priv->card_8192_version = (VERSION_8192S)((read_nic_dword(dev, PMC_FSM)>>16)&0xF);
6797 RT_TRACE(COMP_INIT, "Chip Version ID: 0x%2x\n", priv->card_8192_version);
6798
6799 tmpU1b = read_nic_byte(dev, EPROM_CMD);//CR9346
6800
6801 // To check system boot selection.
6802 if (tmpU1b & CmdEERPOMSEL)
6803 {
6804 RT_TRACE(COMP_INIT, "Boot from EEPROM\n");
6805 priv->EepromOrEfuse = TRUE;
6806 }
6807 else
6808 {
6809 RT_TRACE(COMP_INIT, "Boot from EFUSE\n");
6810 priv->EepromOrEfuse = FALSE;
6811 }
6812
6813 // To check autoload success or not.
6814 if (tmpU1b & CmdEEPROM_En)
6815 {
6816 RT_TRACE(COMP_INIT, "Autoload OK!!\n");
6817 priv->AutoloadFailFlag=FALSE;
6818 rtl8192SU_ReadAdapterInfo8192SUsb(dev);//eeprom or e-fuse
6819 }
6820 else
6821 { // Auto load fail.
6822 RT_TRACE(COMP_INIT, "AutoLoad Fail reported from CR9346!!\n");
6823 priv->AutoloadFailFlag=TRUE;
6824 rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(dev);
6825
6826 //if (IS_BOOT_FROM_EFUSE(Adapter))
6827 if(!priv->EepromOrEfuse)
6828 {
6829 RT_TRACE(COMP_INIT, "Update shadow map for EFuse future use!!\n");
6830 EFUSE_ShadowMapUpdate(dev);
6831 }
6832 }
6833 #ifdef TO_DO_LIST
6834 if((priv->RegChannelPlan >= RT_CHANNEL_DOMAIN_MAX) || (pHalData->EEPROMChannelPlan & EEPROM_CHANNEL_PLAN_BY_HW_MASK))
6835 {
6836 pMgntInfo->ChannelPlan = HalMapChannelPlan8192S(Adapter, (pHalData->EEPROMChannelPlan & (~(EEPROM_CHANNEL_PLAN_BY_HW_MASK))));
6837 pMgntInfo->bChnlPlanFromHW = (pHalData->EEPROMChannelPlan & EEPROM_CHANNEL_PLAN_BY_HW_MASK) ? TRUE : FALSE; // User cannot change channel plan.
6838 }
6839 else
6840 {
6841 pMgntInfo->ChannelPlan = (RT_CHANNEL_DOMAIN)pMgntInfo->RegChannelPlan;
6842 }
6843
6844 switch(pMgntInfo->ChannelPlan)
6845 {
6846 case RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN:
6847 {
6848 PRT_DOT11D_INFO pDot11dInfo = GET_DOT11D_INFO(pMgntInfo);
6849
6850 pDot11dInfo->bEnabled = TRUE;
6851 }
6852 RT_TRACE(COMP_INIT, DBG_LOUD, ("ReadAdapterInfo8187(): Enable dot11d when RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN!\n"));
6853 break;
6854 }
6855
6856 RT_TRACE(COMP_INIT, DBG_LOUD, ("RegChannelPlan(%d) EEPROMChannelPlan(%d)", pMgntInfo->RegChannelPlan, pHalData->EEPROMChannelPlan));
6857 RT_TRACE(COMP_INIT, DBG_LOUD, ("ChannelPlan = %d\n" , pMgntInfo->ChannelPlan));
6858
6859 RT_TRACE(COMP_INIT, DBG_LOUD, ("<==== ReadAdapterInfo8192S\n"));
6860 #endif
6861
6862 RT_TRACE(COMP_INIT, "<==== ReadAdapterInfo8192SUsb\n");
6863
6864 //return RT_STATUS_SUCCESS;
6865 }
6866 #else
6867 static void rtl8192_read_eeprom_info(struct net_device* dev)
6868 {
6869 u16 wEPROM_ID = 0;
6870 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
6871 u8 bLoad_From_EEPOM = false;
6872 struct r8192_priv *priv = ieee80211_priv(dev);
6873 u16 tmpValue = 0;
6874 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
6875 wEPROM_ID = eprom_read(dev, 0); //first read EEPROM ID out;
6876 RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
6877
6878 if (wEPROM_ID != RTL8190_EEPROM_ID)
6879 {
6880 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", wEPROM_ID, RTL8190_EEPROM_ID);
6881 }
6882 else
6883 bLoad_From_EEPOM = true;
6884
6885 if (bLoad_From_EEPOM)
6886 {
6887 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
6888 priv->eeprom_vid = endian_swap(&tmpValue);
6889 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
6890 tmpValue = eprom_read(dev, (EEPROM_ChannelPlan>>1));
6891 priv->eeprom_ChannelPlan =((tmpValue&0xff00)>>8);
6892 priv->btxpowerdata_readfromEEPORM = true;
6893 priv->eeprom_CustomerID = eprom_read(dev, (EEPROM_Customer_ID>>1)) >>8;
6894 }
6895 else
6896 {
6897 priv->eeprom_vid = 0;
6898 priv->eeprom_pid = 0;
6899 priv->card_8192_version = VERSION_819xU_B;
6900 priv->eeprom_ChannelPlan = 0;
6901 priv->eeprom_CustomerID = 0;
6902 }
6903 RT_TRACE(COMP_EPROM, "vid:0x%4x, pid:0x%4x, CustomID:0x%2x, ChanPlan:0x%x\n", priv->eeprom_vid, priv->eeprom_pid, priv->eeprom_CustomerID, priv->eeprom_ChannelPlan);
6904 //set channelplan from eeprom
6905 priv->ChannelPlan = priv->eeprom_ChannelPlan;
6906 if (bLoad_From_EEPOM)
6907 {
6908 int i;
6909 for (i=0; i<6; i+=2)
6910 {
6911 u16 tmp = 0;
6912 tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
6913 *(u16*)(&dev->dev_addr[i]) = tmp;
6914 }
6915 }
6916 else
6917 {
6918 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
6919 //should I set IDR0 here?
6920 }
6921 RT_TRACE(COMP_EPROM, "MAC addr:"MAC_FMT"\n", MAC_ARG(dev->dev_addr));
6922 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
6923 priv->rf_chip = RF_8256;
6924
6925 if (priv->card_8192_version == (u8)VERSION_819xU_A)
6926 {
6927 //read Tx power gain offset of legacy OFDM to HT rate
6928 if (bLoad_From_EEPOM)
6929 priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff>>1))&0xff00) >> 8;
6930 else
6931 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
6932 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
6933 //read ThermalMeter from EEPROM
6934 if (bLoad_From_EEPOM)
6935 priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter>>1))&0x00ff);
6936 else
6937 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
6938 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
6939 //vivi, for tx power track
6940 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
6941 //read antenna tx power offset of B/C/D to A from EEPROM
6942 if (bLoad_From_EEPOM)
6943 priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff>>1))&0x0f00)>>8;
6944 else
6945 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
6946 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
6947 // Read CrystalCap from EEPROM
6948 if (bLoad_From_EEPOM)
6949 priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap>>1))&0x0f);
6950 else
6951 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
6952 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
6953 //get per-channel Tx power level
6954 if (bLoad_From_EEPOM)
6955 priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver>>1))&0xff00)>>8;
6956 else
6957 priv->EEPROM_Def_Ver = 1;
6958 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
6959 if (priv->EEPROM_Def_Ver == 0) //old eeprom definition
6960 {
6961 int i;
6962 if (bLoad_From_EEPOM)
6963 priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK>>1))&0xff) >> 8;
6964 else
6965 priv->EEPROMTxPowerLevelCCK = 0x10;
6966 RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
6967 for (i=0; i<3; i++)
6968 {
6969 if (bLoad_From_EEPOM)
6970 {
6971 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G+i)>>1);
6972 if (((EEPROM_TxPwIndex_OFDM_24G+i) % 2) == 0)
6973 tmpValue = tmpValue & 0x00ff;
6974 else
6975 tmpValue = (tmpValue & 0xff00) >> 8;
6976 }
6977 else
6978 tmpValue = 0x10;
6979 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8) tmpValue;
6980 RT_TRACE(COMP_EPROM, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK);
6981 }
6982 }//end if EEPROM_DEF_VER == 0
6983 else if (priv->EEPROM_Def_Ver == 1)
6984 {
6985 if (bLoad_From_EEPOM)
6986 {
6987 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1>>1));
6988 tmpValue = (tmpValue & 0xff00) >> 8;
6989 }
6990 else
6991 tmpValue = 0x10;
6992 priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
6993
6994 if (bLoad_From_EEPOM)
6995 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2)>>1);
6996 else
6997 tmpValue = 0x1010;
6998 *((u16*)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
6999 if (bLoad_From_EEPOM)
7000 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1>>1));
7001 else
7002 tmpValue = 0x1010;
7003 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[0])) = tmpValue;
7004 if (bLoad_From_EEPOM)
7005 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1+2)>>1);
7006 else
7007 tmpValue = 0x10;
7008 priv->EEPROMTxPowerLevelOFDM24G[2] = (u8)tmpValue;
7009 }//endif EEPROM_Def_Ver == 1
7010
7011 //update HAL variables
7012 //
7013 {
7014 int i;
7015 for (i=0; i<14; i++)
7016 {
7017 if (i<=3)
7018 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[0];
7019 else if (i>=4 && i<=9)
7020 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[1];
7021 else
7022 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[2];
7023 }
7024
7025 for (i=0; i<14; i++)
7026 {
7027 if (priv->EEPROM_Def_Ver == 0)
7028 {
7029 if (i<=3)
7030 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[0] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
7031 else if (i>=4 && i<=9)
7032 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK;
7033 else
7034 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[2] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
7035 }
7036 else if (priv->EEPROM_Def_Ver == 1)
7037 {
7038 if (i<=3)
7039 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[0];
7040 else if (i>=4 && i<=9)
7041 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[1];
7042 else
7043 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[2];
7044 }
7045 }
7046 }//end update HAL variables
7047 priv->TxPowerDiff = priv->EEPROMPwDiff;
7048 // Antenna B gain offset to antenna A, bit0~3
7049 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
7050 // Antenna C gain offset to antenna A, bit4~7
7051 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
7052 // CrystalCap, bit12~15
7053 priv->CrystalCap = priv->EEPROMCrystalCap;
7054 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
7055 // 92U does not enable TX power tracking.
7056 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
7057 }//end if VersionID == VERSION_819xU_A
7058
7059 //added by vivi, for dlink led, 20080416
7060 switch(priv->eeprom_CustomerID)
7061 {
7062 case EEPROM_CID_RUNTOP:
7063 priv->CustomerID = RT_CID_819x_RUNTOP;
7064 break;
7065
7066 case EEPROM_CID_DLINK:
7067 priv->CustomerID = RT_CID_DLINK;
7068 break;
7069
7070 default:
7071 priv->CustomerID = RT_CID_DEFAULT;
7072 break;
7073
7074 }
7075
7076 switch(priv->CustomerID)
7077 {
7078 case RT_CID_819x_RUNTOP:
7079 priv->LedStrategy = SW_LED_MODE2;
7080 break;
7081
7082 case RT_CID_DLINK:
7083 priv->LedStrategy = SW_LED_MODE4;
7084 break;
7085
7086 default:
7087 priv->LedStrategy = SW_LED_MODE0;
7088 break;
7089
7090 }
7091
7092
7093 if(priv->rf_type == RF_1T2R)
7094 {
7095 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
7096 }
7097 else
7098 {
7099 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
7100 }
7101
7102 // 2008/01/16 MH We can only know RF type in the function. So we have to init
7103 // DIG RATR table again.
7104 init_rate_adaptive(dev);
7105 //we need init DIG RATR table here again.
7106
7107 RT_TRACE(COMP_EPROM, "<===========%s()\n", __FUNCTION__);
7108 return;
7109 }
7110 #endif
7111
7112 short rtl8192_get_channel_map(struct net_device * dev)
7113 {
7114 struct r8192_priv *priv = ieee80211_priv(dev);
7115 #ifdef ENABLE_DOT11D
7116 if(priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN){
7117 printk("rtl8180_init:Error channel plan! Set to default.\n");
7118 priv->ChannelPlan= 0;
7119 }
7120 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
7121
7122 rtl819x_set_channel_map(priv->ChannelPlan, priv);
7123 #else
7124 int ch,i;
7125 //Set Default Channel Plan
7126 if(!channels){
7127 DMESG("No channels, aborting");
7128 return -1;
7129 }
7130 ch=channels;
7131 priv->ChannelPlan= 0;//hikaru
7132 // set channels 1..14 allowed in given locale
7133 for (i=1; i<=14; i++) {
7134 (priv->ieee80211->channel_map)[i] = (u8)(ch & 0x01);
7135 ch >>= 1;
7136 }
7137 #endif
7138 return 0;
7139 }
7140
7141 short rtl8192_init(struct net_device *dev)
7142 {
7143
7144 struct r8192_priv *priv = ieee80211_priv(dev);
7145
7146 #ifndef RTL8192SU
7147 memset(&(priv->stats),0,sizeof(struct Stats));
7148 memset(priv->txqueue_to_outpipemap,0,9);
7149 #ifdef PIPE12
7150 {
7151 int i=0;
7152 u8 queuetopipe[]={3,2,1,0,4,8,7,6,5};
7153 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
7154 /* for(i=0;i<9;i++)
7155 printk("%d ",priv->txqueue_to_outpipemap[i]);
7156 printk("\n");*/
7157 }
7158 #else
7159 {
7160 u8 queuetopipe[]={3,2,1,0,4,4,0,4,4};
7161 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
7162 /* for(i=0;i<9;i++)
7163 printk("%d ",priv->txqueue_to_outpipemap[i]);
7164 printk("\n");*/
7165 }
7166 #endif
7167 #endif
7168 rtl8192_init_priv_variable(dev);
7169 rtl8192_init_priv_lock(priv);
7170 rtl8192_init_priv_task(dev);
7171 rtl8192_get_eeprom_size(dev);
7172 priv->ops->rtl819x_read_eeprom_info(dev);
7173 rtl8192_get_channel_map(dev);
7174 init_hal_dm(dev);
7175 init_timer(&priv->watch_dog_timer);
7176 priv->watch_dog_timer.data = (unsigned long)dev;
7177 priv->watch_dog_timer.function = watch_dog_timer_callback;
7178
7179 //rtl8192_adapter_start(dev);
7180 #ifdef DEBUG_EPROM
7181 dump_eprom(dev);
7182 #endif
7183 return 0;
7184 }
7185
7186 /******************************************************************************
7187 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
7188 * not to do all the hw config as its name says
7189 * input: net_device dev
7190 * output: none
7191 * return: none
7192 * notice: This part need to modified according to the rate set we filtered
7193 * ****************************************************************************/
7194 void rtl8192_hwconfig(struct net_device* dev)
7195 {
7196 u32 regRATR = 0, regRRSR = 0;
7197 u8 regBwOpMode = 0, regTmp = 0;
7198 struct r8192_priv *priv = ieee80211_priv(dev);
7199
7200 // Set RRSR, RATR, and BW_OPMODE registers
7201 //
7202 switch(priv->ieee80211->mode)
7203 {
7204 case WIRELESS_MODE_B:
7205 regBwOpMode = BW_OPMODE_20MHZ;
7206 regRATR = RATE_ALL_CCK;
7207 regRRSR = RATE_ALL_CCK;
7208 break;
7209 case WIRELESS_MODE_A:
7210 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
7211 regRATR = RATE_ALL_OFDM_AG;
7212 regRRSR = RATE_ALL_OFDM_AG;
7213 break;
7214 case WIRELESS_MODE_G:
7215 regBwOpMode = BW_OPMODE_20MHZ;
7216 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7217 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7218 break;
7219 case WIRELESS_MODE_AUTO:
7220 #ifdef TO_DO_LIST
7221 if (Adapter->bInHctTest)
7222 {
7223 regBwOpMode = BW_OPMODE_20MHZ;
7224 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7225 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7226 }
7227 else
7228 #endif
7229 {
7230 regBwOpMode = BW_OPMODE_20MHZ;
7231 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
7232 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7233 }
7234 break;
7235 case WIRELESS_MODE_N_24G:
7236 // It support CCK rate by default.
7237 // CCK rate will be filtered out only when associated AP does not support it.
7238 regBwOpMode = BW_OPMODE_20MHZ;
7239 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
7240 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7241 break;
7242 case WIRELESS_MODE_N_5G:
7243 regBwOpMode = BW_OPMODE_5G;
7244 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
7245 regRRSR = RATE_ALL_OFDM_AG;
7246 break;
7247 }
7248
7249 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
7250 {
7251 u32 ratr_value = 0;
7252 ratr_value = regRATR;
7253 if (priv->rf_type == RF_1T2R)
7254 {
7255 ratr_value &= ~(RATE_ALL_OFDM_2SS);
7256 }
7257 write_nic_dword(dev, RATR0, ratr_value);
7258 write_nic_byte(dev, UFWP, 1);
7259 }
7260 regTmp = read_nic_byte(dev, 0x313);
7261 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
7262 write_nic_dword(dev, RRSR, regRRSR);
7263
7264 //
7265 // Set Retry Limit here
7266 //
7267 write_nic_word(dev, RETRY_LIMIT,
7268 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | \
7269 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
7270 // Set Contention Window here
7271
7272 // Set Tx AGC
7273
7274 // Set Tx Antenna including Feedback control
7275
7276 // Set Auto Rate fallback control
7277
7278
7279 }
7280
7281 #ifdef RTL8192SU
7282 #ifdef USB_RX_AGGREGATION_SUPPORT
7283 u8 rtl8192SU_MapRxPageSizeToIdx(u16 RxPktSize )
7284 {
7285 switch(RxPktSize)
7286 {
7287 case 64: return 0; break;
7288 case 128 : return 1; break;
7289 case 256: return 2; break;
7290 case 512: return 3; break;
7291 case 1024: return 4; break;
7292 default: return 0; // We use 64bytes in defult.
7293 }
7294 }
7295 #endif
7296
7297 //
7298 // Description:
7299 // Initial HW relted registers.
7300 //
7301 // Assumption:
7302 // Config RTL8192S USB MAC, we should config MAC before download FW.
7303 //
7304 // 2008.09.03, Added by Roger.
7305 //
7306 static void rtl8192SU_MacConfigBeforeFwDownloadASIC(struct net_device *dev)
7307 {
7308 u8 tmpU1b;// i;
7309 // u16 tmpU2b;
7310 // u32 tmpU4b;
7311 u8 PollingCnt = 20;
7312
7313 RT_TRACE(COMP_INIT, "--->MacConfigBeforeFwDownloadASIC()\n");
7314
7315 //2MAC Initialization for power on sequence, Revised by Roger. 2008.09.03.
7316
7317 //
7318 //<Roger_Notes> Set control path switch to HW control and reset Digital Core, CPU Core and
7319 // MAC I/O to solve FW download fail when system from resume sate.
7320 // 2008.11.04.
7321 //
7322 tmpU1b = read_nic_byte(dev, SYS_CLKR+1);
7323 if(tmpU1b & 0x80)
7324 {
7325 tmpU1b &= 0x3f;
7326 write_nic_byte(dev, SYS_CLKR+1, tmpU1b);
7327 }
7328 // Clear FW RPWM for FW control LPS. by tynli. 2009.02.23
7329 write_nic_byte(dev, RPWM, 0x0);
7330
7331 tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
7332 tmpU1b &= 0x73;
7333 write_nic_byte(dev, SYS_FUNC_EN+1, tmpU1b);
7334 udelay(1000);
7335
7336 //Revised POS, suggested by SD1 Alex, 2008.09.27.
7337 write_nic_byte(dev, SPS0_CTRL+1, 0x53);
7338 write_nic_byte(dev, SPS0_CTRL, 0x57);
7339
7340 //Enable AFE Macro Block's Bandgap adn Enable AFE Macro Block's Mbias
7341 tmpU1b = read_nic_byte(dev, AFE_MISC);
7342 write_nic_byte(dev, AFE_MISC, (tmpU1b|AFE_BGEN|AFE_MBEN));
7343
7344 //Enable PLL Power (LDOA15V)
7345 tmpU1b = read_nic_byte(dev, LDOA15_CTRL);
7346 write_nic_byte(dev, LDOA15_CTRL, (tmpU1b|LDA15_EN));
7347
7348 //Enable LDOV12D block
7349 tmpU1b = read_nic_byte(dev, LDOV12D_CTRL);
7350 write_nic_byte(dev, LDOV12D_CTRL, (tmpU1b|LDV12_EN));
7351
7352 //mpU1b = read_nic_byte(Adapter, SPS1_CTRL);
7353 //write_nic_byte(dev, SPS1_CTRL, (tmpU1b|SPS1_LDEN));
7354
7355 //PlatformSleepUs(2000);
7356
7357 //Enable Switch Regulator Block
7358 //tmpU1b = read_nic_byte(Adapter, SPS1_CTRL);
7359 //write_nic_byte(dev, SPS1_CTRL, (tmpU1b|SPS1_SWEN));
7360
7361 //write_nic_dword(Adapter, SPS1_CTRL, 0x00a7b267);
7362
7363 tmpU1b = read_nic_byte(dev, SYS_ISO_CTRL+1);
7364 write_nic_byte(dev, SYS_ISO_CTRL+1, (tmpU1b|0x08));
7365
7366 //Engineer Packet CP test Enable
7367 tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
7368 write_nic_byte(dev, SYS_FUNC_EN+1, (tmpU1b|0x20));
7369
7370 //Support 64k IMEM, suggested by SD1 Alex.
7371 tmpU1b = read_nic_byte(dev, SYS_ISO_CTRL+1);
7372 write_nic_byte(dev, SYS_ISO_CTRL+1, (tmpU1b& 0x68));
7373
7374 //Enable AFE clock
7375 tmpU1b = read_nic_byte(dev, AFE_XTAL_CTRL+1);
7376 write_nic_byte(dev, AFE_XTAL_CTRL+1, (tmpU1b& 0xfb));
7377
7378 //Enable AFE PLL Macro Block
7379 tmpU1b = read_nic_byte(dev, AFE_PLL_CTRL);
7380 write_nic_byte(dev, AFE_PLL_CTRL, (tmpU1b|0x11));
7381
7382 //Attatch AFE PLL to MACTOP/BB/PCIe Digital
7383 tmpU1b = read_nic_byte(dev, SYS_ISO_CTRL);
7384 write_nic_byte(dev, SYS_ISO_CTRL, (tmpU1b&0xEE));
7385
7386 // Switch to 40M clock
7387 write_nic_byte(dev, SYS_CLKR, 0x00);
7388
7389 //SSC Disable
7390 tmpU1b = read_nic_byte(dev, SYS_CLKR);
7391 //write_nic_byte(dev, SYS_CLKR, (tmpU1b&0x5f));
7392 write_nic_byte(dev, SYS_CLKR, (tmpU1b|0xa0));
7393
7394 //Enable MAC clock
7395 tmpU1b = read_nic_byte(dev, SYS_CLKR+1);
7396 write_nic_byte(dev, SYS_CLKR+1, (tmpU1b|0x18));
7397
7398 //Revised POS, suggested by SD1 Alex, 2008.09.27.
7399 write_nic_byte(dev, PMC_FSM, 0x02);
7400
7401 //Enable Core digital and enable IOREG R/W
7402 tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
7403 write_nic_byte(dev, SYS_FUNC_EN+1, (tmpU1b|0x08));
7404
7405 //Enable REG_EN
7406 tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
7407 write_nic_byte(dev, SYS_FUNC_EN+1, (tmpU1b|0x80));
7408
7409 //Switch the control path to FW
7410 tmpU1b = read_nic_byte(dev, SYS_CLKR+1);
7411 write_nic_byte(dev, SYS_CLKR+1, (tmpU1b|0x80)& 0xBF);
7412
7413 write_nic_byte(dev, CMDR, 0xFC);
7414 write_nic_byte(dev, CMDR+1, 0x37);
7415
7416 //Fix the RX FIFO issue(usb error), 970410
7417 tmpU1b = read_nic_byte_E(dev, 0x5c);
7418 write_nic_byte_E(dev, 0x5c, (tmpU1b|BIT7));
7419
7420 //For power save, used this in the bit file after 970621
7421 tmpU1b = read_nic_byte(dev, SYS_CLKR);
7422 write_nic_byte(dev, SYS_CLKR, tmpU1b&(~SYS_CPU_CLKSEL));
7423
7424 // Revised for 8051 ROM code wrong operation. Added by Roger. 2008.10.16.
7425 write_nic_byte_E(dev, 0x1c, 0x80);
7426
7427 //
7428 // <Roger_EXP> To make sure that TxDMA can ready to download FW.
7429 // We should reset TxDMA if IMEM RPT was not ready.
7430 // Suggested by SD1 Alex. 2008.10.23.
7431 //
7432 do
7433 {
7434 tmpU1b = read_nic_byte(dev, TCR);
7435 if((tmpU1b & TXDMA_INIT_VALUE) == TXDMA_INIT_VALUE)
7436 break;
7437 //PlatformStallExecution(5);
7438 udelay(5);
7439 }while(PollingCnt--); // Delay 1ms
7440
7441 if(PollingCnt <= 0 )
7442 {
7443 RT_TRACE(COMP_INIT, "MacConfigBeforeFwDownloadASIC(): Polling TXDMA_INIT_VALUE timeout!! Current TCR(%#x)\n", tmpU1b);
7444 tmpU1b = read_nic_byte(dev, CMDR);
7445 write_nic_byte(dev, CMDR, tmpU1b&(~TXDMA_EN));
7446 udelay(2);
7447 write_nic_byte(dev, CMDR, tmpU1b|TXDMA_EN);// Reset TxDMA
7448 }
7449
7450
7451 RT_TRACE(COMP_INIT, "<---MacConfigBeforeFwDownloadASIC()\n");
7452 }
7453 #ifdef USB_RX_AGGREGATION_SUPPORT
7454 void rtl8192SU_HalUsbRxAggr8192SUsb(struct net_device *dev, bool Value)
7455 {
7456 struct r8192_priv *priv = ieee80211_priv((struct net_device *)dev);
7457 PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;;
7458
7459
7460 //
7461 // <Roger_Notes> We decrease Rx page aggregated threshold in B/G mode.
7462 // 2008.10.29
7463 //
7464 if(priv->ieee80211->mode == WIRELESS_MODE_B || priv->ieee80211->mode == WIRELESS_MODE_G)
7465 {// Overwrite current settings to disable Rx Aggregation.
7466 Value = false;
7467 }
7468
7469 // Alway set Rx Aggregation to Disable if current platform is Win2K USB 1.1, by Emily
7470 //if(PLATFORM_LIMITED_RX_BUF_SIZE(Adapter))
7471 // Value = FALSE;
7472
7473 // Always set Rx Aggregation to Disable if connected AP is Realtek AP, by Joseph
7474 //if(pHTInfo->bCurrentRT2RTAggregation)
7475 // Value = FALSE;
7476
7477 // The RX aggregation may be enabled/disabled dynamically according current traffic stream.
7478 //Enable Rx aggregation if downlink traffic is busier than uplink traffic. by Guangan
7479 if(priv->bCurrentRxAggrEnable != Value)
7480 {
7481 priv->bCurrentRxAggrEnable = Value;
7482 //Adapter->HalFunc.SetHwRegHandler(Adapter, HW_VAR_USB_RX_AGGR, (pu1Byte)&pHalData->bCurrentRxAggrEnable);
7483 {
7484 //u8 Setting = ((pu1Byte)(val))[0];
7485 u8 Setting = priv->bCurrentRxAggrEnable
7486 u32 ulValue;
7487
7488 if(Setting==0)
7489 {
7490 //
7491 // <Roger_Notes> Reduce aggregated page threshold to 0x01 and set minimal threshold 0x0a.
7492 // i.e., disable Rx aggregation.
7493 //
7494 ulValue = 0x0001000a;
7495 }
7496 else
7497 {
7498 //PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
7499 //HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
7500
7501 if (priv->bForcedUsbRxAggr)
7502 {// Using forced settings.
7503 ulValue = priv->ForcedUsbRxAggrInfo;
7504 }
7505 else
7506 {// Using default settings.
7507
7508 ulValue = (pHTInfo->UsbRxFwAggrEn<<24) | (pHTInfo->UsbRxFwAggrPageNum<<16) |
7509 (pHTInfo->UsbRxFwAggrPacketNum<<8) | (pHTInfo->UsbRxFwAggrTimeout);
7510 }
7511 }
7512
7513 write_nic_byte(dev, RXDMA_AGG_PG_TH, (u8)((ulValue&0xff0000)>>16));
7514 write_nic_byte_E(dev, USB_RX_AGG_TIMEOUT, (u8)(ulValue&0xff));
7515
7516 priv->LastUsbRxAggrInfoSetting = ulValue;
7517
7518 RT_TRACE(COMP_HT|COMP_RECV, "Set HW_VAR_USB_RX_AGGR: ulValue(%#x)\n", ulValue);
7519 }
7520 RT_TRACE(COMP_RECV, "HalUsbRxAggr8192SUsb() : Set RxAggregation to %s\n", Value?"ON":"OFF");
7521 }
7522
7523 }
7524 #endif
7525
7526 #ifdef USB_RX_AGGREGATION_SUPPORT
7527 void rtl8192SU_HalUsbRxAggr8192SUsb(struct net_device *dev, bool Value)
7528 {
7529 struct r8192_priv *priv = ieee80211_priv((struct net_device *)dev);
7530 PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;;
7531
7532
7533 //
7534 // <Roger_Notes> We decrease Rx page aggregated threshold in B/G mode.
7535 // 2008.10.29
7536 //
7537 if((priv->ieee80211->mode & WIRELESS_MODE_B) || (priv->ieee80211->mode & WIRELESS_MODE_G))
7538 {// Overwrite current settings to disable Rx Aggregation.
7539 Value = false;
7540 }
7541
7542 // Alway set Rx Aggregation to Disable if current platform is Win2K USB 1.1, by Emily
7543 //if(PLATFORM_LIMITED_RX_BUF_SIZE(Adapter))
7544 // Value = FALSE;
7545
7546 // Always set Rx Aggregation to Disable if connected AP is Realtek AP, by Joseph
7547 //if(pHTInfo->bCurrentRT2RTAggregation)
7548 // Value = FALSE;
7549
7550 // The RX aggregation may be enabled/disabled dynamically according current traffic stream.
7551 //Enable Rx aggregation if downlink traffic is busier than uplink traffic. by Guangan
7552 if(priv->bCurrentRxAggrEnable != Value)
7553 {
7554 priv->bCurrentRxAggrEnable = Value;
7555 //Adapter->HalFunc.SetHwRegHandler(Adapter, HW_VAR_USB_RX_AGGR, (pu1Byte)&pHalData->bCurrentRxAggrEnable);
7556 {
7557 //u8 Setting = ((pu1Byte)(val))[0];
7558 u8 Setting = priv->bCurrentRxAggrEnable
7559 u32 ulValue;
7560
7561 if(Setting==0)
7562 {
7563 //
7564 // <Roger_Notes> Reduce aggregated page threshold to 0x01 and set minimal threshold 0x0a.
7565 // i.e., disable Rx aggregation.
7566 //
7567 ulValue = 0x0001000a;
7568 }
7569 else
7570 {
7571 //PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
7572 //HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
7573
7574 if (priv->bForcedUsbRxAggr)
7575 {// Using forced settings.
7576 ulValue = priv->ForcedUsbRxAggrInfo;
7577 }
7578 else
7579 {// Using default settings.
7580
7581 ulValue = (pHTInfo->UsbRxFwAggrEn<<24) | (pHTInfo->UsbRxFwAggrPageNum<<16) |
7582 (pHTInfo->UsbRxFwAggrPacketNum<<8) | (pHTInfo->UsbRxFwAggrTimeout);
7583 }
7584 }
7585
7586 write_nic_byte(dev, RXDMA_AGG_PG_TH, (u8)((ulValue&0xff0000)>>16));
7587 write_nic_byte_E(dev, USB_RX_AGG_TIMEOUT, (u8)(ulValue&0xff));
7588
7589 priv->LastUsbRxAggrInfoSetting = ulValue;
7590
7591 RT_TRACE(COMP_HT|COMP_RECV, "Set HW_VAR_USB_RX_AGGR: ulValue(%#x)\n", ulValue);
7592 }
7593 RT_TRACE(COMP_RECV, "HalUsbRxAggr8192SUsb() : Set RxAggregation to %s\n", Value?"ON":"OFF");
7594 }
7595
7596 }
7597
7598 u8 rtl8192SU_MapRxPageSizeToIdx(u16 RxPktSize )
7599 {
7600 switch(RxPktSize)
7601 {
7602 case 64: return 0; break;
7603 case 128 : return 1; break;
7604 case 256: return 2; break;
7605 case 512: return 3; break;
7606 case 1024: return 4; break;
7607 default: return 0; // We use 64bytes in defult.
7608 }
7609 }
7610 #endif
7611
7612 #if 0
7613 static void rtl8192SU_SetHwRegAmpduMinSpace(struct net_device *dev, u8 MinSpaceCfg)
7614 {
7615 struct r8192_priv *priv = ieee80211_priv((struct net_device *)dev);
7616 struct ieee80211_device* ieee = priv->ieee80211;
7617 u8 MinSpacingToSet;
7618 u8 SecMinSpace;
7619
7620 #ifdef RTL8192S_PREPARE_FOR_NORMAL_RELEASE
7621 MinSpacingToSet = MinSpaceCfg;
7622 if(MinSpacingToSet <= 7)
7623 {
7624 switch(ieee->pairwise_key_type)
7625 {
7626 case KEY_TYPE_NA: SecMinSpace = 0; break;
7627 case KEY_TYPE_CCMP:
7628 case KEY_TYPE_WEP40:
7629 case KEY_TYPE_WEP104:
7630 case KEY_TYPE_TKIP: SecMinSpace = 6; break;
7631 default: SecMinSpace = 7; break;
7632 }
7633
7634 if(MinSpacingToSet < SecMinSpace)
7635 MinSpacingToSet = SecMinSpace;
7636 priv->MinSpaceCfg = ((priv->MinSpaceCfg&0xf8) |MinSpacingToSet);
7637 RT_TRACE(COMP_SEC, "Set AMPDU_MIN_SPACE: %x\n", priv->MinSpaceCfg);
7638 write_nic_byte(dev, AMPDU_MIN_SPACE, priv->MinSpaceCfg);
7639 }
7640
7641 #else
7642 MinSpacingToSet = MinSpaceCfg;
7643 MinSpacingToSet &= 0x07; // We only care about bit[2:0]
7644 priv->MinSpaceCfg |= MinSpacingToSet;
7645 RT_TRACE(COMP_SEC, "Set AMPDU_MIN_SPACE: %x\n", priv->MinSpaceCfg);
7646 write_nic_byte(dev, AMPDU_MIN_SPACE, priv->MinSpaceCfg);//FIXLZM
7647 #endif
7648 }
7649 #endif
7650
7651 //
7652 // Description:
7653 // Initial HW relted registers.
7654 //
7655 // Assumption:
7656 // 1. This function is only invoked at driver intialization once.
7657 // 2. PASSIVE LEVEL.
7658 //
7659 // 2008.06.10, Added by Roger.
7660 //
7661 static void rtl8192SU_MacConfigAfterFwDownload(struct net_device *dev)
7662 {
7663 struct r8192_priv *priv = ieee80211_priv((struct net_device *)dev);
7664 //PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
7665 //u8 tmpU1b, RxPageCfg, i;
7666 u16 tmpU2b;
7667 u8 tmpU1b;//, i;
7668
7669
7670 RT_TRACE(COMP_INIT, "--->MacConfigAfterFwDownload()\n");
7671
7672 // Enable Tx/Rx
7673 tmpU2b = (BBRSTn|BB_GLB_RSTn|SCHEDULE_EN|MACRXEN|MACTXEN|DDMA_EN|
7674 FW2HW_EN|RXDMA_EN|TXDMA_EN|HCI_RXDMA_EN|HCI_TXDMA_EN); //3
7675 //Adapter->HalFunc.SetHwRegHandler( Adapter, HW_VAR_COMMAND, &tmpU1b );
7676 write_nic_word(dev, CMDR, tmpU2b); //LZM REGISTER COM 090305
7677
7678 // Loopback mode or not
7679 priv->LoopbackMode = RTL8192SU_NO_LOOPBACK; // Set no loopback as default.
7680 if(priv->LoopbackMode == RTL8192SU_NO_LOOPBACK)
7681 tmpU1b = LBK_NORMAL;
7682 else if (priv->LoopbackMode == RTL8192SU_MAC_LOOPBACK )
7683 tmpU1b = LBK_MAC_DLB;
7684 else
7685 RT_TRACE(COMP_INIT, "Serious error: wrong loopback mode setting\n");
7686
7687 //Adapter->HalFunc.SetHwRegHandler( Adapter, HW_VAR_LBK_MODE, &tmpU1b);
7688 write_nic_byte(dev, LBKMD_SEL, tmpU1b);
7689
7690 // Set RCR
7691 write_nic_dword(dev, RCR, priv->ReceiveConfig);
7692 RT_TRACE(COMP_INIT, "MacConfigAfterFwDownload(): Current RCR settings(%#x)\n", priv->ReceiveConfig);
7693
7694
7695 // Set RQPN
7696 //
7697 // <Roger_Notes> 2008.08.18.
7698 // 6 endpoints:
7699 // (1) Page number on CMDQ is 0x03.
7700 // (2) Page number on BCNQ, HQ and MGTQ is 0.
7701 // (3) Page number on BKQ, BEQ, VIQ and VOQ are 0x07.
7702 // (4) Page number on PUBQ is 0xdd
7703 //
7704 // 11 endpoints:
7705 // (1) Page number on CMDQ is 0x00.
7706 // (2) Page number on BCNQ is 0x02, HQ and MGTQ are 0x03.
7707 // (3) Page number on BKQ, BEQ, VIQ and VOQ are 0x07.
7708 // (4) Page number on PUBQ is 0xd8
7709 //
7710 //write_nic_dword(Adapter, 0xa0, 0x07070707); //BKQ, BEQ, VIQ and VOQ
7711 //write_nic_byte(dev, 0xa4, 0x00); // HCCAQ
7712 #if 0 //LZM 090219
7713 #ifdef USE_SIX_USB_ENDPOINT
7714 //write_nic_dword(Adapter, 0xa5, 0x00000003); //CMDQ, MGTQ, HQ and BCNQ
7715 //write_nic_byte(dev, 0xa9, 0xdd); // PUBQ
7716 tmpU1b = read_nic_byte(dev, 0xab); // RQPN
7717 write_nic_byte(dev, 0xab, tmpU1b|BIT7|BIT6);// reduce to 6 endpoints.
7718 #else
7719 write_nic_dword(dev, 0xa5, 0x02030300); //CMDQ, MGTQ, HQ and BCNQ
7720 write_nic_byte(dev, 0xa9, 0xd8); // PUBQ
7721 tmpU1b = read_nic_byte(dev, 0xab); // RQPN
7722 write_nic_byte(dev, 0xab, (tmpU1b&(~BIT6))|BIT7); // Disable reduced endpoint.
7723 #endif
7724 #endif
7725
7726 #ifdef USB_RX_AGGREGATION_SUPPORT
7727 // Size of Tx/Rx packet buffer.
7728 tmpU1b = read_nic_byte(dev, PBP);
7729 RxPageCfg = rtl8192SU_MapRxPageSizeToIdx(priv->ieee80211->pHTInfo.UsbRxPageSize);
7730 write_nic_byte(dev, PBP, tmpU1b|RxPageCfg); // Set page size of Rx packet buffer to 128 bytes.
7731 tmpU1b = read_nic_byte(dev, RXDMA);
7732
7733 write_nic_byte(dev, RXDMA, tmpU1b|RXDMA_AGG_EN); // Rx aggregation enable.
7734 //PlatformIOWrite1Byte(Adapter, RXDMA_AGG_PG_TH, 0x14); // Set page size of RxDMA aggregation threshold, default: 20.
7735 //write_nic_byte(dev, RXDMA_AGG_PG_TH, 0x40); // By Scott's suggestion, 2008.09.30.//92su del
7736 //write_nic_byte(dev, USB_RX_AGG_TIMEOUT, RXDMA_AGG_TIMEOUT_17_4_MS); // Set aggregation time-out to 17ms/4.
7737 rtl8192SU_HalUsbRxAggr8192SUsb(dev, true);
7738 #endif
7739
7740 // Fix the RX FIFO issue(USB error), Rivesed by Roger, 2008-06-14
7741 tmpU1b = read_nic_byte_E(dev, 0x5C);
7742 write_nic_byte_E(dev, 0x5C, tmpU1b|BIT7);
7743
7744 //
7745 // Revise USB PHY to solve the issue of Rx payload error, Rivesed by Roger, 2008-04-10
7746 // Suggest by SD1 Alex.
7747 //
7748 // <Roger_Notes> The following operation are ONLY for USB PHY test chip.
7749 // 2008.10.07.
7750 //
7751 #if RTL8192SU_USB_PHY_TEST
7752 write_nic_byte(dev, 0x41,0xf4);
7753 write_nic_byte(dev, 0x40,0x00);
7754 write_nic_byte(dev, 0x42,0x00);
7755 write_nic_byte(dev, 0x42,0x01);
7756 write_nic_byte(dev, 0x40,0x0f);
7757 write_nic_byte(dev, 0x42,0x00);
7758 write_nic_byte(dev, 0x42,0x01);
7759 #endif
7760
7761 #if 0 //LZM 090219
7762 //
7763 // Suggested by SD1 Alex, 2008-06-14.
7764 //
7765 write_nic_byte(dev, TXOP_STALL_CTRL, 0x80);//NAV
7766
7767
7768 //
7769 // Set Data Auto Rate Fallback Retry Count register.
7770 //
7771 write_nic_dword(dev, DARFRC, 0x04010000);
7772 write_nic_dword(dev, DARFRC+4, 0x09070605);
7773 write_nic_dword(dev, RARFRC, 0x04010000);
7774 write_nic_dword(dev, RARFRC+4, 0x09070605);
7775
7776 // Set Data Auto Rate Fallback Reg. Added by Roger, 2008.09.22.
7777 for (i = 0; i < 8; i++)
7778 #ifdef RTL8192SU_DISABLE_CCK_RATE
7779 write_nic_dword(dev, ARFR0+i*4, 0x1f0ff0f0);
7780 #else
7781 write_nic_dword(dev, ARFR0+i*4, 0x1f0ffff0);
7782 #endif
7783
7784 //
7785 // Set driver info, we only accept PHY status now.
7786 //
7787 //write_nic_byte(dev, RXDRVINFO_SZ, 4);
7788
7789 //
7790 // Aggregation length limit. Revised by Roger. 2008.09.22.
7791 //
7792 write_nic_dword(dev, AGGLEN_LMT_L, 0x66666666); // Long GI
7793 write_nic_byte(dev, AGGLEN_LMT_H, 0x06); // Set AMPDU length to 12Kbytes for ShortGI case.
7794
7795 //
7796 // For Min Spacing configuration.
7797 //
7798 //Adapter->HalFunc.SetHwRegHandler(Adapter, HW_VAR_AMPDU_MIN_SPACE, (u8*)(&Adapter->MgntInfo.MinSpaceCfg));
7799 rtl8192SU_SetHwRegAmpduMinSpace(dev,priv->MinSpaceCfg);
7800 #endif
7801
7802 // For EFUSE init configuration.
7803 //if (IS_BOOT_FROM_EFUSE(Adapter)) // We may R/W EFUSE in EFUSE mode
7804 if (priv->bBootFromEfuse)
7805 {
7806 u8 tempval;
7807
7808 tempval = read_nic_byte(dev, SYS_ISO_CTRL+1);
7809 tempval &= 0xFE;
7810 write_nic_byte(dev, SYS_ISO_CTRL+1, tempval);
7811
7812 // Enable LDO 2.5V for write action
7813 //tempval = read_nic_byte(Adapter, EFUSE_TEST+3);
7814 //write_nic_byte(Adapter, EFUSE_TEST+3, (tempval | 0x80));
7815
7816 // Change Efuse Clock for write action
7817 //write_nic_byte(Adapter, EFUSE_CLK, 0x03);
7818
7819 // Change Program timing
7820 write_nic_byte(dev, EFUSE_CTRL+3, 0x72);
7821 //printk("!!!!!!!!!!!!!!!!!!!!!%s: write 0x33 with 0x72\n",__FUNCTION__);
7822 RT_TRACE(COMP_INIT, "EFUSE CONFIG OK\n");
7823 }
7824
7825
7826 RT_TRACE(COMP_INIT, "<---MacConfigAfterFwDownload()\n");
7827 }
7828
7829 void rtl8192SU_HwConfigureRTL8192SUsb(struct net_device *dev)
7830 {
7831
7832 struct r8192_priv *priv = ieee80211_priv(dev);
7833 u8 regBwOpMode = 0;
7834 u32 regRATR = 0, regRRSR = 0;
7835 u8 regTmp = 0;
7836 u32 i = 0;
7837
7838 //1 This part need to modified according to the rate set we filtered!!
7839 //
7840 // Set RRSR, RATR, and BW_OPMODE registers
7841 //
7842 switch(priv->ieee80211->mode)
7843 {
7844 case WIRELESS_MODE_B:
7845 regBwOpMode = BW_OPMODE_20MHZ;
7846 regRATR = RATE_ALL_CCK;
7847 regRRSR = RATE_ALL_CCK;
7848 break;
7849 case WIRELESS_MODE_A:
7850 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
7851 regRATR = RATE_ALL_OFDM_AG;
7852 regRRSR = RATE_ALL_OFDM_AG;
7853 break;
7854 case WIRELESS_MODE_G:
7855 regBwOpMode = BW_OPMODE_20MHZ;
7856 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7857 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7858 break;
7859 case WIRELESS_MODE_AUTO:
7860 if (priv->bInHctTest)
7861 {
7862 regBwOpMode = BW_OPMODE_20MHZ;
7863 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7864 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7865 }
7866 else
7867 {
7868 regBwOpMode = BW_OPMODE_20MHZ;
7869 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
7870 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7871 }
7872 break;
7873 case WIRELESS_MODE_N_24G:
7874 // It support CCK rate by default.
7875 // CCK rate will be filtered out only when associated AP does not support it.
7876 regBwOpMode = BW_OPMODE_20MHZ;
7877 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
7878 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
7879 break;
7880 case WIRELESS_MODE_N_5G:
7881 regBwOpMode = BW_OPMODE_5G;
7882 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
7883 regRRSR = RATE_ALL_OFDM_AG;
7884 break;
7885 }
7886
7887 //
7888 // <Roger_Notes> We disable CCK response rate until FIB CCK rate IC's back.
7889 // 2008.09.23.
7890 //
7891 regTmp = read_nic_byte(dev, INIRTSMCS_SEL);
7892 #ifdef RTL8192SU_DISABLE_CCK_RATE
7893 regRRSR = ((regRRSR & 0x000ffff0)<<8) | regTmp;
7894 #else
7895 regRRSR = ((regRRSR & 0x000fffff)<<8) | regTmp;
7896 #endif
7897
7898 //
7899 // Update SIFS timing.
7900 //
7901 //priv->SifsTime = 0x0e0e0a0a;
7902 //Adapter->HalFunc.SetHwRegHandler( Adapter, HW_VAR_SIFS, (pu1Byte)&pHalData->SifsTime);
7903 { u8 val[4] = {0x0e, 0x0e, 0x0a, 0x0a};
7904 // SIFS for CCK Data ACK
7905 write_nic_byte(dev, SIFS_CCK, val[0]);
7906 // SIFS for CCK consecutive tx like CTS data!
7907 write_nic_byte(dev, SIFS_CCK+1, val[1]);
7908
7909 // SIFS for OFDM Data ACK
7910 write_nic_byte(dev, SIFS_OFDM, val[2]);
7911 // SIFS for OFDM consecutive tx like CTS data!
7912 write_nic_byte(dev, SIFS_OFDM+1, val[3]);
7913 }
7914
7915 write_nic_dword(dev, INIRTSMCS_SEL, regRRSR);
7916 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
7917
7918 //
7919 // Suggested by SD1 Alex, 2008-06-14.
7920 //
7921 //PlatformEFIOWrite1Byte(Adapter, TXOP_STALL_CTRL, 0x80);//NAV to protect all TXOP.
7922
7923 //
7924 // Set Data Auto Rate Fallback Retry Count register.
7925 //
7926 write_nic_dword(dev, DARFRC, 0x02010000);
7927 write_nic_dword(dev, DARFRC+4, 0x06050403);
7928 write_nic_dword(dev, RARFRC, 0x02010000);
7929 write_nic_dword(dev, RARFRC+4, 0x06050403);
7930
7931 // Set Data Auto Rate Fallback Reg. Added by Roger, 2008.09.22.
7932 for (i = 0; i < 8; i++)
7933 #ifdef RTL8192SU_DISABLE_CCK_RATE
7934 write_nic_dword(dev, ARFR0+i*4, 0x1f0ff0f0);
7935 #else
7936 write_nic_dword(dev, ARFR0+i*4, 0x1f0ffff0);
7937 #endif
7938
7939 //
7940 // Aggregation length limit. Revised by Roger. 2008.09.22.
7941 //
7942 write_nic_byte(dev, AGGLEN_LMT_H, 0x0f); // Set AMPDU length to 12Kbytes for ShortGI case.
7943 write_nic_dword(dev, AGGLEN_LMT_L, 0xddd77442); // Long GI
7944 write_nic_dword(dev, AGGLEN_LMT_L+4, 0xfffdd772);
7945
7946 // Set NAV protection length
7947 write_nic_word(dev, NAV_PROT_LEN, 0x0080);
7948
7949 // Set TXOP stall control for several queue/HI/BCN/MGT/
7950 write_nic_byte(dev, TXOP_STALL_CTRL, 0x00); // NAV Protect next packet.
7951
7952 // Set MSDU lifetime.
7953 write_nic_byte(dev, MLT, 0x8f);
7954
7955 // Set CCK/OFDM SIFS
7956 write_nic_word(dev, SIFS_CCK, 0x0a0a); // CCK SIFS shall always be 10us.
7957 write_nic_word(dev, SIFS_OFDM, 0x0e0e);
7958
7959 write_nic_byte(dev, ACK_TIMEOUT, 0x40);
7960
7961 // CF-END Threshold
7962 write_nic_byte(dev, CFEND_TH, 0xFF);
7963
7964 //
7965 // For Min Spacing configuration.
7966 //
7967 switch(priv->rf_type)
7968 {
7969 case RF_1T2R:
7970 case RF_1T1R:
7971 RT_TRACE(COMP_INIT, "Initializeadapter: RF_Type%s\n", (priv->rf_type==RF_1T1R? "(1T1R)":"(1T2R)"));
7972 priv->MinSpaceCfg = (MAX_MSS_DENSITY_1T<<3);
7973 break;
7974 case RF_2T2R:
7975 case RF_2T2R_GREEN:
7976 RT_TRACE(COMP_INIT, "Initializeadapter:RF_Type(2T2R)\n");
7977 priv->MinSpaceCfg = (MAX_MSS_DENSITY_2T<<3);
7978 break;
7979 }
7980 write_nic_byte(dev, AMPDU_MIN_SPACE, priv->MinSpaceCfg);
7981
7982 //LZM 090219
7983 //
7984 // For Min Spacing configuration.
7985 //
7986 //priv->MinSpaceCfg = 0x00;
7987 //rtl8192SU_SetHwRegAmpduMinSpace(dev, priv->MinSpaceCfg);
7988 }
7989
7990 #endif
7991
7992 #ifdef RTL8192SU
7993 // Description: Initial HW relted registers.
7994 //
7995 // Assumption: This function is only invoked at driver intialization once.
7996 //
7997 // 2008.06.10, Added by Roger.
7998 bool rtl8192SU_adapter_start(struct net_device *dev)
7999 {
8000 struct r8192_priv *priv = ieee80211_priv(dev);
8001 //u32 dwRegRead = 0;
8002 //bool init_status = true;
8003 //u32 ulRegRead;
8004 bool rtStatus = true;
8005 //u8 PipeIndex;
8006 //u8 eRFPath, tmpU1b;
8007 u8 fw_download_times = 1;
8008
8009
8010 RT_TRACE(COMP_INIT, "--->InitializeAdapter8192SUsb()\n");
8011
8012 //pHalData->bGPIOChangeRF = FALSE;
8013
8014
8015 //
8016 // <Roger_Notes> 2008.06.15.
8017 //
8018 // Initialization Steps on RTL8192SU:
8019 // a. MAC initialization prior to sending down firmware code.
8020 // b. Download firmware code step by step(i.e., IMEM, EMEM, DMEM).
8021 // c. MAC configuration after firmware has been download successfully.
8022 // d. Initialize BB related configurations.
8023 // e. Initialize RF related configurations.
8024 // f. Start to BulkIn transfer.
8025 //
8026
8027 //
8028 //a. MAC initialization prior to send down firmware code.
8029 //
8030 start:
8031 rtl8192SU_MacConfigBeforeFwDownloadASIC(dev);
8032
8033 //
8034 //b. Download firmware code step by step(i.e., IMEM, EMEM, DMEM).
8035 //
8036 rtStatus = FirmwareDownload92S(dev);
8037 if(rtStatus != true)
8038 {
8039 if(fw_download_times == 1){
8040 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Download Firmware failed once, Download again!!\n");
8041 fw_download_times = fw_download_times + 1;
8042 goto start;
8043 }else{
8044 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Download Firmware failed twice, end!!\n");
8045 goto end;
8046 }
8047 }
8048 //
8049 //c. MAC configuration after firmware has been download successfully.
8050 //
8051 rtl8192SU_MacConfigAfterFwDownload(dev);
8052
8053 #if (RTL8192S_DISABLE_FW_DM == 1)
8054 write_nic_dword(dev, WFM5, FW_DM_DISABLE);
8055 #endif
8056 //priv->bLbusEnable = TRUE;
8057 //if(priv->RegRfOff == TRUE)
8058 // priv->eRFPowerState = eRfOff;
8059
8060 // Save target channel
8061 // <Roger_Notes> Current Channel will be updated again later.
8062 //priv->CurrentChannel = Channel;
8063 rtStatus = PHY_MACConfig8192S(dev);//===>ok
8064 if(rtStatus != true)
8065 {
8066 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Fail to configure MAC!!\n");
8067 goto end;
8068 }
8069 if (1){
8070 int i;
8071 for (i=0; i<4; i++)
8072 write_nic_dword(dev,WDCAPARA_ADD[i], 0x5e4322);
8073 write_nic_byte(dev,AcmHwCtrl, 0x01);
8074 }
8075
8076
8077 //
8078 //d. Initialize BB related configurations.
8079 //
8080
8081 rtStatus = PHY_BBConfig8192S(dev);//===>ok
8082 if(rtStatus != true)
8083 {
8084 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Fail to configure BB!!\n");
8085 goto end;
8086 }
8087
8088 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter2, 0xff, 0x58);//===>ok
8089
8090 //
8091 // e. Initialize RF related configurations.
8092 //
8093 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
8094 priv->Rf_Mode = RF_OP_By_SW_3wire;
8095
8096 // For RF test only from Scott's suggestion
8097 //write_nic_byte(dev, 0x27, 0xDB);
8098 //write_nic_byte(dev, 0x1B, 0x07);
8099
8100
8101 write_nic_byte(dev, AFE_XTAL_CTRL+1, 0xDB);
8102
8103 // <Roger_Notes> The following IOs are configured for each RF modules.
8104 // Enable RF module and reset RF and SDM module. 2008.11.17.
8105 if(priv->card_8192_version == VERSION_8192S_ACUT)
8106 write_nic_byte(dev, SPS1_CTRL+3, (u8)(RF_EN|RF_RSTB|RF_SDMRSTB)); // Fix A-Cut bug.
8107 else
8108 write_nic_byte(dev, RF_CTRL, (u8)(RF_EN|RF_RSTB|RF_SDMRSTB));
8109
8110 rtStatus = PHY_RFConfig8192S(dev);//===>ok
8111 if(rtStatus != true)
8112 {
8113 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Fail to configure RF!!\n");
8114 goto end;
8115 }
8116
8117
8118 // Set CCK and OFDM Block "ON"
8119 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
8120 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
8121
8122 //
8123 // Turn off Radio B while RF type is 1T1R by SD3 Wilsion's request.
8124 // Revised by Roger, 2008.12.18.
8125 //
8126 if(priv->rf_type == RF_1T1R)
8127 {
8128 // This is needed for PHY_REG after 20081219
8129 rtl8192_setBBreg(dev, rFPGA0_RFMOD, 0xff000000, 0x03);
8130 // This is needed for PHY_REG before 20081219
8131 //PHY_SetBBReg(Adapter, rOFDM0_TRxPathEnable, bMaskByte0, 0x11);
8132 }
8133
8134 #if (RTL8192SU_DISABLE_IQK==0)
8135 // For 1T2R IQK only currently.
8136 if (priv->card_8192_version == VERSION_8192S_BCUT)
8137 {
8138 PHY_IQCalibrateBcut(dev);
8139 }
8140 else if (priv->card_8192_version == VERSION_8192S_ACUT)
8141 {
8142 PHY_IQCalibrate(dev);
8143 }
8144 #endif
8145
8146 //LZM 090219
8147 // Set CCK and OFDM Block "ON"
8148 //rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
8149 //rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
8150
8151
8152 //3//Get hardware version, do it in read eeprom?
8153 //GetHardwareVersion819xUsb(Adapter);
8154
8155 //3//
8156 //3 //Set Hardware
8157 //3//
8158 rtl8192SU_HwConfigureRTL8192SUsb(dev);//==>ok
8159
8160 //
8161 // <Roger_Notes> We set MAC address here if autoload was failed before,
8162 // otherwise IDR0 will NOT contain any value.
8163 //
8164 write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
8165 write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
8166 if(!priv->bInHctTest)
8167 {
8168 if(priv->ResetProgress == RESET_TYPE_NORESET)
8169 {
8170 //RT_TRACE(COMP_MLME, DBG_LOUD, ("Initializeadapter8192SUsb():RegWirelessMode(%#x) \n", Adapter->RegWirelessMode));
8171 //Adapter->HalFunc.SetWirelessModeHandler(Adapter, Adapter->RegWirelessMode);
8172 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);//===>ok
8173 }
8174 }
8175 else
8176 {
8177 priv->ieee80211->mode = WIRELESS_MODE_G;
8178 rtl8192_SetWirelessMode(dev, WIRELESS_MODE_G);
8179 }
8180
8181 //Security related.
8182 //-----------------------------------------------------------------------------
8183 // Set up security related. 070106, by rcnjko:
8184 // 1. Clear all H/W keys.
8185 // 2. Enable H/W encryption/decryption.
8186 //-----------------------------------------------------------------------------
8187 //CamResetAllEntry(Adapter);
8188 //Adapter->HalFunc.EnableHWSecCfgHandler(Adapter);
8189
8190 //SecClearAllKeys(Adapter);
8191 CamResetAllEntry(dev);
8192 //SecInit(Adapter);
8193 {
8194 u8 SECR_value = 0x0;
8195 SECR_value |= SCR_TxEncEnable;
8196 SECR_value |= SCR_RxDecEnable;
8197 SECR_value |= SCR_NoSKMC;
8198 write_nic_byte(dev, SECR, SECR_value);
8199 }
8200
8201 #if 0
8202
8203 if(pHalData->VersionID == VERSION_8192SU_A)
8204 {
8205 // cosa add for tx power level initialization.
8206 GetTxPowerOriginalOffset(Adapter);
8207 SetTxPowerLevel819xUsb(Adapter, Channel);
8208 }
8209 #endif
8210
8211
8212 #ifdef TO_DO_LIST
8213
8214 //PHY_UpdateInitialGain(dev);
8215
8216 if(priv->RegRfOff == true)
8217 { // User disable RF via registry.
8218 u8 eRFPath = 0;
8219
8220 RT_TRACE((COMP_INIT|COMP_RF), "InitializeAdapter8192SUsb(): Turn off RF for RegRfOff ----------\n");
8221 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW);
8222 // Those action will be discard in MgntActSet_RF_State because off the same state
8223 for(eRFPath = 0; eRFPath <priv->NumTotalRFPath; eRFPath++)
8224 rtl8192_setBBreg(dev, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
8225 }
8226 else if(priv->RfOffReason > RF_CHANGE_BY_PS)
8227 { // H/W or S/W RF OFF before sleep.
8228 RT_TRACE((COMP_INIT|COMP_RF), "InitializeAdapter8192SUsb(): Turn off RF for RfOffReason(%d) ----------\n", priv->RfOffReason);
8229 MgntActSet_RF_State(dev, eRfOff, priv->RfOffReason);
8230 }
8231 else
8232 {
8233 priv->eRFPowerState = eRfOn;
8234 priv->RfOffReason = 0;
8235 RT_TRACE((COMP_INIT|COMP_RF), "InitializeAdapter8192SUsb(): RF is on ----------\n");
8236 }
8237
8238 #endif
8239
8240
8241 //
8242 // f. Start to BulkIn transfer.
8243 //
8244 #ifdef TO_DO_LIST
8245
8246 #ifndef UNDER_VISTA
8247 {
8248 u8 i;
8249 PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
8250
8251 for(PipeIndex=0; PipeIndex < MAX_RX_QUEUE; PipeIndex++)
8252 {
8253 if (PipeIndex == 0)
8254 {
8255 for(i=0; i<32; i++)
8256 HalUsbInMpdu(Adapter, PipeIndex);
8257 }
8258 else
8259 {
8260 //HalUsbInMpdu(Adapter, PipeIndex);
8261 //HalUsbInMpdu(Adapter, PipeIndex);
8262 //HalUsbInMpdu(Adapter, PipeIndex);
8263 }
8264 }
8265 PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
8266 }
8267 #else
8268 // Joseph add to 819X code base for Vista USB platform.
8269 // This part may need to be add to Hal819xU code base. too.
8270 PlatformUsbEnableInPipes(Adapter);
8271 #endif
8272
8273 RT_TRACE(COMP_INIT, "HighestOperaRate = %x\n", Adapter->MgntInfo.HighestOperaRate);
8274
8275 PlatformStartWorkItem( &(pHalData->RtUsbCheckForHangWorkItem) );
8276
8277 //
8278 // <Roger_EXP> The following configurations are for ASIC verification temporally.
8279 // 2008.07.10.
8280 //
8281
8282 #endif
8283
8284 //
8285 // Read EEPROM TX power index and PHY_REG_PG.txt to capture correct
8286 // TX power index for different rate set.
8287 //
8288 //if(priv->card_8192_version >= VERSION_8192S_ACUT)
8289 {
8290 // Get original hw reg values
8291 PHY_GetHWRegOriginalValue(dev);
8292
8293 // Write correct tx power index//FIXLZM
8294 PHY_SetTxPowerLevel8192S(dev, priv->chan);
8295 }
8296
8297 {
8298 u8 tmpU1b = 0;
8299 // EEPROM R/W workaround
8300 tmpU1b = read_nic_byte(dev, MAC_PINMUX_CFG);
8301 write_nic_byte(dev, MAC_PINMUX_CFG, tmpU1b&(~GPIOMUX_EN));
8302 }
8303
8304 //
8305 //<Roger_Notes> 2008.08.19.
8306 // We return status here for temporal FPGA verification, 2008.08.19.
8307
8308 #ifdef RTL8192SU_FW_IQK
8309 write_nic_dword(dev, WFM5, FW_IQK_ENABLE);
8310 ChkFwCmdIoDone(dev);
8311 #endif
8312
8313 //
8314 // <Roger_Notes> We enable high power mechanism after NIC initialized.
8315 // 2008.11.27.
8316 //
8317 write_nic_dword(dev, WFM5, FW_RA_RESET);
8318 ChkFwCmdIoDone(dev);
8319 write_nic_dword(dev, WFM5, FW_RA_ACTIVE);
8320 ChkFwCmdIoDone(dev);
8321 write_nic_dword(dev, WFM5, FW_RA_REFRESH);
8322 ChkFwCmdIoDone(dev);
8323 write_nic_dword(dev, WFM5, FW_BB_RESET_ENABLE);
8324
8325 // <Roger_Notes> We return status here for temporal FPGA verification. 2008.05.12.
8326 //
8327 #if RTL8192SU_FPGA_UNSPECIFIED_NETWORK
8328 //
8329 // To send specific number of packets to verify MAC Lookback mode.
8330 //
8331 //SendRandomTxPkt(Adapter, 0); // Burst mode for verification.
8332 //rtStatus = RT_STATUS_FAILURE;
8333 rtStatus = true;
8334 goto end;
8335 #endif
8336
8337 // The following IO was for FPGA verification purpose. Added by Roger, 2008.09.11.
8338 #if 0
8339 // 2008/08/19 MH From SD1 Jong, we must write some register for true PHY/MAC FPGA.
8340 write_nic_byte(dev, rOFDM0_XAAGCCore1, 0x30);
8341 write_nic_byte(dev, rOFDM0_XBAGCCore1, 0x30);
8342
8343 write_nic_byte(dev, rOFDM0_RxDetector1, 0x42);
8344
8345 //write_nic_dword(Adapter, RCR, 0x817FF02F);
8346
8347 write_nic_dword(Adapter, rTxAGC_Mcs15_Mcs12, 0x06060606);
8348 #endif
8349 end:
8350 return rtStatus;
8351 }
8352
8353 #else
8354
8355 //InitializeAdapter and PhyCfg
8356 bool rtl8192_adapter_start(struct net_device *dev)
8357 {
8358 struct r8192_priv *priv = ieee80211_priv(dev);
8359 u32 dwRegRead = 0;
8360 bool init_status = true;
8361 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
8362 priv->Rf_Mode = RF_OP_By_SW_3wire;
8363 //for ASIC power on sequence
8364 write_nic_byte_E(dev, 0x5f, 0x80);
8365 mdelay(50);
8366 write_nic_byte_E(dev, 0x5f, 0xf0);
8367 write_nic_byte_E(dev, 0x5d, 0x00);
8368 write_nic_byte_E(dev, 0x5e, 0x80);
8369 write_nic_byte(dev, 0x17, 0x37);
8370 mdelay(10);
8371 //#ifdef TO_DO_LIST
8372 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
8373 //config CPUReset Register
8374 //Firmware Reset or not?
8375 dwRegRead = read_nic_dword(dev, CPU_GEN);
8376 if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
8377 dwRegRead |= CPU_GEN_SYSTEM_RESET; //do nothing here?
8378 else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY)
8379 dwRegRead |= CPU_GEN_FIRMWARE_RESET;
8380 else
8381 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
8382
8383 write_nic_dword(dev, CPU_GEN, dwRegRead);
8384 //mdelay(30);
8385 //config BB.
8386 rtl8192_BBConfig(dev);
8387
8388 #if 1
8389 //Loopback mode or not
8390 priv->LoopbackMode = RTL819xU_NO_LOOPBACK;
8391 // priv->LoopbackMode = RTL819xU_MAC_LOOPBACK;
8392
8393 dwRegRead = read_nic_dword(dev, CPU_GEN);
8394 if (priv->LoopbackMode == RTL819xU_NO_LOOPBACK)
8395 dwRegRead = ((dwRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
8396 else if (priv->LoopbackMode == RTL819xU_MAC_LOOPBACK)
8397 dwRegRead |= CPU_CCK_LOOPBACK;
8398 else
8399 RT_TRACE(COMP_ERR, "Serious error in %s(): wrong loopback mode setting(%d)\n", __FUNCTION__, priv->LoopbackMode);
8400
8401 write_nic_dword(dev, CPU_GEN, dwRegRead);
8402
8403 //after reset cpu, we need wait for a seconds to write in register.
8404 udelay(500);
8405
8406 //xiong add for new bitfile:usb suspend reset pin set to 1. //do we need?
8407 write_nic_byte_E(dev, 0x5f, (read_nic_byte_E(dev, 0x5f)|0x20));
8408
8409 //Set Hardware
8410 rtl8192_hwconfig(dev);
8411
8412 //turn on Tx/Rx
8413 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
8414
8415 //set IDR0 here
8416 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
8417 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
8418
8419 //set RCR
8420 write_nic_dword(dev, RCR, priv->ReceiveConfig);
8421
8422 //Initialize Number of Reserved Pages in Firmware Queue
8423 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |\
8424 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT | \
8425 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT | \
8426 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
8427 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT |\
8428 NUM_OF_PAGE_IN_FW_QUEUE_CMD << RSVD_FW_QUEUE_PAGE_CMD_SHIFT);
8429 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW| \
8430 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
8431 // | NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
8432 );
8433 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
8434
8435 //Set AckTimeout
8436 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
8437 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
8438
8439 // RT_TRACE(COMP_INIT, "%s():priv->ResetProgress is %d\n", __FUNCTION__,priv->ResetProgress);
8440 if(priv->ResetProgress == RESET_TYPE_NORESET)
8441 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
8442 if(priv->ResetProgress == RESET_TYPE_NORESET){
8443 CamResetAllEntry(dev);
8444 {
8445 u8 SECR_value = 0x0;
8446 SECR_value |= SCR_TxEncEnable;
8447 SECR_value |= SCR_RxDecEnable;
8448 SECR_value |= SCR_NoSKMC;
8449 write_nic_byte(dev, SECR, SECR_value);
8450 }
8451 }
8452
8453 //Beacon related
8454 write_nic_word(dev, ATIMWND, 2);
8455 write_nic_word(dev, BCN_INTERVAL, 100);
8456
8457 {
8458 #define DEFAULT_EDCA 0x005e4332
8459 int i;
8460 for (i=0; i<QOS_QUEUE_NUM; i++)
8461 write_nic_dword(dev, WDCAPARA_ADD[i], DEFAULT_EDCA);
8462 }
8463 #ifdef USB_RX_AGGREGATION_SUPPORT
8464 //3 For usb rx firmware aggregation control
8465 if(priv->ResetProgress == RESET_TYPE_NORESET)
8466 {
8467 u32 ulValue;
8468 PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
8469 ulValue = (pHTInfo->UsbRxFwAggrEn<<24) | (pHTInfo->UsbRxFwAggrPageNum<<16) |
8470 (pHTInfo->UsbRxFwAggrPacketNum<<8) | (pHTInfo->UsbRxFwAggrTimeout);
8471 /*
8472 * If usb rx firmware aggregation is enabled,
8473 * when anyone of three threshold conditions above is reached,
8474 * firmware will send aggregated packet to driver.
8475 */
8476 write_nic_dword(dev, 0x1a8, ulValue);
8477 priv->bCurrentRxAggrEnable = true;
8478 }
8479 #endif
8480
8481 rtl8192_phy_configmac(dev);
8482
8483 if (priv->card_8192_version == (u8) VERSION_819xU_A)
8484 {
8485 rtl8192_phy_getTxPower(dev);
8486 rtl8192_phy_setTxPower(dev, priv->chan);
8487 }
8488
8489
8490 priv->usb_error = false;
8491 //Firmware download
8492 init_status = init_firmware(dev);
8493 if(!init_status)
8494 {
8495 RT_TRACE(COMP_ERR,"ERR!!! %s(): Firmware download is failed\n", __FUNCTION__);
8496 return init_status;
8497 }
8498 RT_TRACE(COMP_INIT, "%s():after firmware download\n", __FUNCTION__);
8499 //
8500 #ifdef TO_DO_LIST
8501 if(Adapter->ResetProgress == RESET_TYPE_NORESET)
8502 {
8503 if(pMgntInfo->RegRfOff == TRUE)
8504 { // User disable RF via registry.
8505 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
8506 MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
8507 // Those action will be discard in MgntActSet_RF_State because off the same state
8508 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
8509 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
8510 }
8511 else if(pMgntInfo->RfOffReason > RF_CHANGE_BY_PS)
8512 { // H/W or S/W RF OFF before sleep.
8513 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RfOffReason(%d) ----------\n", pMgntInfo->RfOffReason));
8514 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
8515 }
8516 else
8517 {
8518 pHalData->eRFPowerState = eRfOn;
8519 pMgntInfo->RfOffReason = 0;
8520 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): RF is on ----------\n"));
8521 }
8522 }
8523 else
8524 {
8525 if(pHalData->eRFPowerState == eRfOff)
8526 {
8527 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
8528 // Those action will be discard in MgntActSet_RF_State because off the same state
8529 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
8530 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
8531 }
8532 }
8533 #endif
8534 //config RF.
8535 if(priv->ResetProgress == RESET_TYPE_NORESET){
8536 rtl8192_phy_RFConfig(dev);
8537 RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __FUNCTION__);
8538 }
8539
8540
8541 if(priv->ieee80211->FwRWRF)
8542 // We can force firmware to do RF-R/W
8543 priv->Rf_Mode = RF_OP_By_FW;
8544 else
8545 priv->Rf_Mode = RF_OP_By_SW_3wire;
8546
8547
8548 rtl8192_phy_updateInitGain(dev);
8549 /*--set CCK and OFDM Block "ON"--*/
8550 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
8551 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
8552
8553 if(priv->ResetProgress == RESET_TYPE_NORESET)
8554 {
8555 //if D or C cut
8556 u8 tmpvalue = read_nic_byte(dev, 0x301);
8557 if(tmpvalue ==0x03)
8558 {
8559 priv->bDcut = TRUE;
8560 RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
8561 }
8562 else
8563 {
8564 priv->bDcut = FALSE;
8565 RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
8566 }
8567 dm_initialize_txpower_tracking(dev);
8568
8569 if(priv->bDcut == TRUE)
8570 {
8571 u32 i, TempCCk;
8572 u32 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
8573 // u32 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
8574 for(i = 0; i<TxBBGainTableLength; i++)
8575 {
8576 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
8577 {
8578 priv->rfa_txpowertrackingindex= (u8)i;
8579 priv->rfa_txpowertrackingindex_real= (u8)i;
8580 priv->rfa_txpowertracking_default= priv->rfa_txpowertrackingindex;
8581 break;
8582 }
8583 }
8584
8585 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
8586
8587 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
8588 {
8589
8590 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
8591 {
8592 priv->cck_present_attentuation_20Mdefault=(u8) i;
8593 break;
8594 }
8595 }
8596 priv->cck_present_attentuation_40Mdefault= 0;
8597 priv->cck_present_attentuation_difference= 0;
8598 priv->cck_present_attentuation = priv->cck_present_attentuation_20Mdefault;
8599
8600 // pMgntInfo->bTXPowerTracking = FALSE;//TEMPLY DISABLE
8601 }
8602 }
8603 write_nic_byte(dev, 0x87, 0x0);
8604
8605
8606 #endif
8607 return init_status;
8608 }
8609
8610 #endif
8611 /* this configures registers for beacon tx and enables it via
8612 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
8613 * be used to stop beacon transmission
8614 */
8615 #if 0
8616 void rtl8192_start_tx_beacon(struct net_device *dev)
8617 {
8618 int i;
8619 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
8620 u16 word;
8621 DMESG("Enabling beacon TX");
8622 //write_nic_byte(dev, TX_CONF,0xe6);// TX_CONF
8623 //rtl8192_init_beacon(dev);
8624 //set_nic_txring(dev);
8625 // rtl8192_prepare_beacon(dev);
8626 rtl8192_irq_disable(dev);
8627 // rtl8192_beacon_tx_enable(dev);
8628 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
8629 //write_nic_byte(dev,0x9d,0x20); //DMA Poll
8630 //write_nic_word(dev,0x7a,0);
8631 //write_nic_word(dev,0x7a,0x8000);
8632
8633
8634 word = read_nic_word(dev, BcnItv);
8635 word &= ~BcnItv_BcnItv; // clear Bcn_Itv
8636 write_nic_word(dev, BcnItv, word);
8637
8638 write_nic_word(dev, AtimWnd,
8639 read_nic_word(dev, AtimWnd) &~ AtimWnd_AtimWnd);
8640
8641 word = read_nic_word(dev, BCN_INTR_ITV);
8642 word &= ~BCN_INTR_ITV_MASK;
8643
8644 //word |= priv->ieee80211->beacon_interval *
8645 // ((priv->txbeaconcount > 1)?(priv->txbeaconcount-1):1);
8646 // FIXME:FIXME check if correct ^^ worked with 0x3e8;
8647
8648 write_nic_word(dev, BCN_INTR_ITV, word);
8649
8650 //write_nic_word(dev,0x2e,0xe002);
8651 //write_nic_dword(dev,0x30,0xb8c7832e);
8652 for(i=0; i<ETH_ALEN; i++)
8653 write_nic_byte(dev, BSSID+i, priv->ieee80211->beacon_cell_ssid[i]);
8654
8655 // rtl8192_update_msr(dev);
8656
8657
8658 //write_nic_byte(dev,CONFIG4,3); /* !!!!!!!!!! */
8659
8660 rtl8192_set_mode(dev, EPROM_CMD_NORMAL);
8661
8662 rtl8192_irq_enable(dev);
8663
8664 /* VV !!!!!!!!!! VV*/
8665 /*
8666 rtl8192_set_mode(dev,EPROM_CMD_CONFIG);
8667 write_nic_byte(dev,0x9d,0x00);
8668 rtl8192_set_mode(dev,EPROM_CMD_NORMAL);
8669 */
8670 }
8671 #endif
8672 /***************************************************************************
8673 -------------------------------NET STUFF---------------------------
8674 ***************************************************************************/
8675
8676 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
8677 {
8678 struct r8192_priv *priv = ieee80211_priv(dev);
8679
8680 return &priv->ieee80211->stats;
8681 }
8682
8683 bool
8684 HalTxCheckStuck819xUsb(
8685 struct net_device *dev
8686 )
8687 {
8688 struct r8192_priv *priv = ieee80211_priv(dev);
8689 u16 RegTxCounter = read_nic_word(dev, 0x128);
8690 bool bStuck = FALSE;
8691 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
8692 if(priv->TxCounter==RegTxCounter)
8693 bStuck = TRUE;
8694
8695 priv->TxCounter = RegTxCounter;
8696
8697 return bStuck;
8698 }
8699
8700 /*
8701 * <Assumption: RT_TX_SPINLOCK is acquired.>
8702 * First added: 2006.11.19 by emily
8703 */
8704 RESET_TYPE
8705 TxCheckStuck(struct net_device *dev)
8706 {
8707 struct r8192_priv *priv = ieee80211_priv(dev);
8708 u8 QueueID;
8709 // PRT_TCB pTcb;
8710 // u8 ResetThreshold;
8711 bool bCheckFwTxCnt = false;
8712 //unsigned long flags;
8713
8714 //
8715 // Decide Stuch threshold according to current power save mode
8716 //
8717
8718 // RT_TRACE(COMP_RESET, " ==> TxCheckStuck()\n");
8719 // PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK);
8720 // spin_lock_irqsave(&priv->ieee80211->lock,flags);
8721 for (QueueID = 0; QueueID<=BEACON_QUEUE;QueueID ++)
8722 {
8723 if(QueueID == TXCMD_QUEUE)
8724 continue;
8725 #if 1
8726 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
8727 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_drv_aggQ[QueueID]) == 0))
8728 #else
8729 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
8730 #endif
8731 continue;
8732 #endif
8733
8734 bCheckFwTxCnt = true;
8735 }
8736 // PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
8737 // spin_unlock_irqrestore(&priv->ieee80211->lock,flags);
8738 // RT_TRACE(COMP_RESET,"bCheckFwTxCnt is %d\n",bCheckFwTxCnt);
8739 #if 1
8740 if(bCheckFwTxCnt)
8741 {
8742 if(HalTxCheckStuck819xUsb(dev))
8743 {
8744 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
8745 return RESET_TYPE_SILENT;
8746 }
8747 }
8748 #endif
8749 return RESET_TYPE_NORESET;
8750 }
8751
8752 bool
8753 HalRxCheckStuck819xUsb(struct net_device *dev)
8754 {
8755 u16 RegRxCounter = read_nic_word(dev, 0x130);
8756 struct r8192_priv *priv = ieee80211_priv(dev);
8757 bool bStuck = FALSE;
8758 //#ifdef RTL8192SU
8759
8760 //#else
8761 static u8 rx_chk_cnt = 0;
8762 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
8763 // If rssi is small, we should check rx for long time because of bad rx.
8764 // or maybe it will continuous silent reset every 2 seconds.
8765 rx_chk_cnt++;
8766 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
8767 {
8768 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
8769 }
8770 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
8771 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
8772 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
8773 {
8774 if(rx_chk_cnt < 2)
8775 {
8776 return bStuck;
8777 }
8778 else
8779 {
8780 rx_chk_cnt = 0;
8781 }
8782 }
8783 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
8784 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
8785 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
8786 {
8787 if(rx_chk_cnt < 4)
8788 {
8789 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
8790 return bStuck;
8791 }
8792 else
8793 {
8794 rx_chk_cnt = 0;
8795 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
8796 }
8797 }
8798 else
8799 {
8800 if(rx_chk_cnt < 8)
8801 {
8802 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
8803 return bStuck;
8804 }
8805 else
8806 {
8807 rx_chk_cnt = 0;
8808 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
8809 }
8810 }
8811 //#endif
8812
8813 if(priv->RxCounter==RegRxCounter)
8814 bStuck = TRUE;
8815
8816 priv->RxCounter = RegRxCounter;
8817
8818 return bStuck;
8819 }
8820
8821 RESET_TYPE
8822 RxCheckStuck(struct net_device *dev)
8823 {
8824 struct r8192_priv *priv = ieee80211_priv(dev);
8825 //int i;
8826 bool bRxCheck = FALSE;
8827
8828 // RT_TRACE(COMP_RESET," ==> RxCheckStuck()\n");
8829 //PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
8830
8831 if(priv->IrpPendingCount > 1)
8832 bRxCheck = TRUE;
8833 //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
8834
8835 // RT_TRACE(COMP_RESET,"bRxCheck is %d \n",bRxCheck);
8836 if(bRxCheck)
8837 {
8838 if(HalRxCheckStuck819xUsb(dev))
8839 {
8840 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
8841 return RESET_TYPE_SILENT;
8842 }
8843 }
8844 return RESET_TYPE_NORESET;
8845 }
8846
8847
8848 /**
8849 * This function is called by Checkforhang to check whether we should ask OS to reset driver
8850 *
8851 * \param pAdapter The adapter context for this miniport
8852 *
8853 * Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
8854 * to judge whether there is tx stuck.
8855 * Note: This function may be required to be rewrite for Vista OS.
8856 * <<<Assumption: Tx spinlock has been acquired >>>
8857 *
8858 * 8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
8859 */
8860 RESET_TYPE
8861 rtl819x_ifcheck_resetornot(struct net_device *dev)
8862 {
8863 struct r8192_priv *priv = ieee80211_priv(dev);
8864 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
8865 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
8866 RT_RF_POWER_STATE rfState;
8867
8868 #if (defined (RTL8192SU_FPGA_2MAC_VERIFICATION)||defined (RTL8192SU_ASIC_VERIFICATION))
8869 return RESET_TYPE_NORESET;
8870 #endif
8871
8872 rfState = priv->ieee80211->eRFPowerState;
8873
8874 TxResetType = TxCheckStuck(dev);
8875 #if 1
8876 if( rfState != eRfOff ||
8877 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
8878 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
8879 {
8880 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
8881 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
8882 // if driver is in firmware download failure status, driver should initialize RF in the following
8883 // silent reset procedure Emily, 2008.01.21
8884
8885 // Driver should not check RX stuck in IBSS mode because it is required to
8886 // set Check BSSID in order to send beacon, however, if check BSSID is
8887 // set, STA cannot hear any packet a all. Emily, 2008.04.12
8888 RxResetType = RxCheckStuck(dev);
8889 }
8890 #endif
8891 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
8892 return RESET_TYPE_NORMAL;
8893 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT){
8894 RT_TRACE(COMP_RESET,"%s():silent reset\n",__FUNCTION__);
8895 return RESET_TYPE_SILENT;
8896 }
8897 else
8898 return RESET_TYPE_NORESET;
8899
8900 }
8901
8902 void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
8903 int _rtl8192_up(struct net_device *dev);
8904 int rtl8192_close(struct net_device *dev);
8905
8906
8907
8908 void
8909 CamRestoreAllEntry( struct net_device *dev)
8910 {
8911 u8 EntryId = 0;
8912 struct r8192_priv *priv = ieee80211_priv(dev);
8913 u8* MacAddr = priv->ieee80211->current_network.bssid;
8914
8915 static u8 CAM_CONST_ADDR[4][6] = {
8916 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
8917 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
8918 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
8919 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
8920 static u8 CAM_CONST_BROAD[] =
8921 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
8922
8923 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
8924
8925
8926 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
8927 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
8928 {
8929
8930 for(EntryId=0; EntryId<4; EntryId++)
8931 {
8932 {
8933 MacAddr = CAM_CONST_ADDR[EntryId];
8934 setKey(dev,
8935 EntryId ,
8936 EntryId,
8937 priv->ieee80211->pairwise_key_type,
8938 MacAddr,
8939 0,
8940 NULL);
8941 }
8942 }
8943
8944 }
8945 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
8946 {
8947
8948 {
8949 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
8950 setKey(dev,
8951 4,
8952 0,
8953 priv->ieee80211->pairwise_key_type,
8954 (u8*)dev->dev_addr,
8955 0,
8956 NULL);
8957 else
8958 setKey(dev,
8959 4,
8960 0,
8961 priv->ieee80211->pairwise_key_type,
8962 MacAddr,
8963 0,
8964 NULL);
8965 }
8966 }
8967 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
8968 {
8969
8970 {
8971 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
8972 setKey(dev,
8973 4,
8974 0,
8975 priv->ieee80211->pairwise_key_type,
8976 (u8*)dev->dev_addr,
8977 0,
8978 NULL);
8979 else
8980 setKey(dev,
8981 4,
8982 0,
8983 priv->ieee80211->pairwise_key_type,
8984 MacAddr,
8985 0,
8986 NULL);
8987 }
8988 }
8989
8990
8991
8992 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
8993 {
8994 MacAddr = CAM_CONST_BROAD;
8995 for(EntryId=1 ; EntryId<4 ; EntryId++)
8996 {
8997 {
8998 setKey(dev,
8999 EntryId,
9000 EntryId,
9001 priv->ieee80211->group_key_type,
9002 MacAddr,
9003 0,
9004 NULL);
9005 }
9006 }
9007 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
9008 setKey(dev,
9009 0,
9010 0,
9011 priv->ieee80211->group_key_type,
9012 CAM_CONST_ADDR[0],
9013 0,
9014 NULL);
9015 }
9016 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
9017 {
9018 MacAddr = CAM_CONST_BROAD;
9019 for(EntryId=1; EntryId<4 ; EntryId++)
9020 {
9021 {
9022 setKey(dev,
9023 EntryId ,
9024 EntryId,
9025 priv->ieee80211->group_key_type,
9026 MacAddr,
9027 0,
9028 NULL);
9029 }
9030 }
9031
9032 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
9033 setKey(dev,
9034 0 ,
9035 0,
9036 priv->ieee80211->group_key_type,
9037 CAM_CONST_ADDR[0],
9038 0,
9039 NULL);
9040 }
9041 }
9042 //////////////////////////////////////////////////////////////
9043 // This function is used to fix Tx/Rx stop bug temporarily.
9044 // This function will do "system reset" to NIC when Tx or Rx is stuck.
9045 // The method checking Tx/Rx stuck of this function is supported by FW,
9046 // which reports Tx and Rx counter to register 0x128 and 0x130.
9047 //////////////////////////////////////////////////////////////
9048 void
9049 rtl819x_ifsilentreset(struct net_device *dev)
9050 {
9051 //OCTET_STRING asocpdu;
9052 struct r8192_priv *priv = ieee80211_priv(dev);
9053 u8 reset_times = 0;
9054 int reset_status = 0;
9055 struct ieee80211_device *ieee = priv->ieee80211;
9056
9057
9058 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
9059 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
9060
9061 if(priv->ResetProgress==RESET_TYPE_NORESET)
9062 {
9063 RESET_START:
9064
9065 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
9066
9067 // Set the variable for reset.
9068 priv->ResetProgress = RESET_TYPE_SILENT;
9069 // rtl8192_close(dev);
9070 #if 1
9071 down(&priv->wx_sem);
9072 if(priv->up == 0)
9073 {
9074 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
9075 up(&priv->wx_sem);
9076 return ;
9077 }
9078 priv->up = 0;
9079 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
9080 // if(!netif_queue_stopped(dev))
9081 // netif_stop_queue(dev);
9082
9083 rtl8192_rtx_disable(dev);
9084 rtl8192_cancel_deferred_work(priv);
9085 deinit_hal_dm(dev);
9086 del_timer_sync(&priv->watch_dog_timer);
9087
9088 ieee->sync_scan_hurryup = 1;
9089 if(ieee->state == IEEE80211_LINKED)
9090 {
9091 down(&ieee->wx_sem);
9092 printk("ieee->state is IEEE80211_LINKED\n");
9093 ieee80211_stop_send_beacons(priv->ieee80211);
9094 del_timer_sync(&ieee->associate_timer);
9095 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
9096 cancel_delayed_work(&ieee->associate_retry_wq);
9097 #endif
9098 ieee80211_stop_scan(ieee);
9099 netif_carrier_off(dev);
9100 up(&ieee->wx_sem);
9101 }
9102 else{
9103 printk("ieee->state is NOT LINKED\n");
9104 ieee80211_softmac_stop_protocol(priv->ieee80211); }
9105 up(&priv->wx_sem);
9106 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
9107 //rtl8192_irq_disable(dev);
9108 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
9109 reset_status = _rtl8192_up(dev);
9110
9111 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
9112 if(reset_status == -EAGAIN)
9113 {
9114 if(reset_times < 3)
9115 {
9116 reset_times++;
9117 goto RESET_START;
9118 }
9119 else
9120 {
9121 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n", __FUNCTION__);
9122 }
9123 }
9124 #endif
9125 ieee->is_silent_reset = 1;
9126 #if 1
9127 EnableHWSecurityConfig8192(dev);
9128 #if 1
9129 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
9130 {
9131 ieee->set_chan(ieee->dev, ieee->current_network.channel);
9132
9133 #if 1
9134 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
9135 queue_work(ieee->wq, &ieee->associate_complete_wq);
9136 #else
9137 schedule_task(&ieee->associate_complete_wq);
9138 #endif
9139 #endif
9140
9141 }
9142 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
9143 {
9144 ieee->set_chan(ieee->dev, ieee->current_network.channel);
9145 ieee->link_change(ieee->dev);
9146
9147 // notify_wx_assoc_event(ieee);
9148
9149 ieee80211_start_send_beacons(ieee);
9150
9151 if (ieee->data_hard_resume)
9152 ieee->data_hard_resume(ieee->dev);
9153 netif_carrier_on(ieee->dev);
9154 }
9155 #endif
9156
9157 CamRestoreAllEntry(dev);
9158
9159 priv->ResetProgress = RESET_TYPE_NORESET;
9160 priv->reset_count++;
9161
9162 priv->bForcedSilentReset =false;
9163 priv->bResetInProgress = false;
9164
9165 // For test --> force write UFWP.
9166 write_nic_byte(dev, UFWP, 1);
9167 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
9168 #endif
9169 }
9170 }
9171
9172 void CAM_read_entry(
9173 struct net_device *dev,
9174 u32 iIndex
9175 )
9176 {
9177 u32 target_command=0;
9178 u32 target_content=0;
9179 u8 entry_i=0;
9180 u32 ulStatus;
9181 s32 i=100;
9182 // printk("=======>start read CAM\n");
9183 for(entry_i=0;entry_i<CAM_CONTENT_COUNT;entry_i++)
9184 {
9185 // polling bit, and No Write enable, and address
9186 target_command= entry_i+CAM_CONTENT_COUNT*iIndex;
9187 target_command= target_command | BIT31;
9188
9189 //Check polling bit is clear
9190 // mdelay(1);
9191 #if 1
9192 while((i--)>=0)
9193 {
9194 ulStatus = read_nic_dword(dev, RWCAM);
9195 if(ulStatus & BIT31){
9196 continue;
9197 }
9198 else{
9199 break;
9200 }
9201 }
9202 #endif
9203 write_nic_dword(dev, RWCAM, target_command);
9204 RT_TRACE(COMP_SEC,"CAM_read_entry(): WRITE A0: %x \n",target_command);
9205 // printk("CAM_read_entry(): WRITE A0: %lx \n",target_command);
9206 target_content = read_nic_dword(dev, RCAMO);
9207 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A8: %x \n",target_content);
9208 // printk("CAM_read_entry(): WRITE A8: %lx \n",target_content);
9209 }
9210 printk("\n");
9211 }
9212
9213 void rtl819x_update_rxcounts(
9214 struct r8192_priv *priv,
9215 u32* TotalRxBcnNum,
9216 u32* TotalRxDataNum
9217 )
9218 {
9219 u16 SlotIndex;
9220 u8 i;
9221
9222 *TotalRxBcnNum = 0;
9223 *TotalRxDataNum = 0;
9224
9225 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
9226 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
9227 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
9228 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
9229 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
9230 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
9231 }
9232 }
9233
9234
9235 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
9236 extern void rtl819x_watchdog_wqcallback(struct work_struct *work)
9237 {
9238 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
9239 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
9240 struct net_device *dev = priv->ieee80211->dev;
9241 #else
9242 extern void rtl819x_watchdog_wqcallback(struct net_device *dev)
9243 {
9244 struct r8192_priv *priv = ieee80211_priv(dev);
9245 #endif
9246 struct ieee80211_device* ieee = priv->ieee80211;
9247 RESET_TYPE ResetType = RESET_TYPE_NORESET;
9248 static u8 check_reset_cnt=0;
9249 bool bBusyTraffic = false;
9250
9251 if(!priv->up)
9252 return;
9253 hal_dm_watchdog(dev);
9254
9255 {//to get busy traffic condition
9256 if(ieee->state == IEEE80211_LINKED)
9257 {
9258 //windows mod 666 to 100.
9259 //if( ieee->LinkDetectInfo.NumRxOkInPeriod> 666 ||
9260 // ieee->LinkDetectInfo.NumTxOkInPeriod> 666 ) {
9261 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 100 ||
9262 ieee->LinkDetectInfo.NumTxOkInPeriod> 100 ) {
9263 bBusyTraffic = true;
9264 }
9265 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
9266 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
9267 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
9268 }
9269 }
9270 //added by amy for AP roaming
9271 {
9272 if(priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA)
9273 {
9274 u32 TotalRxBcnNum = 0;
9275 u32 TotalRxDataNum = 0;
9276
9277 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
9278 if((TotalRxBcnNum+TotalRxDataNum) == 0)
9279 {
9280 #ifdef TODO
9281 if(rfState == eRfOff)
9282 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
9283 #endif
9284 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
9285 // Dot11d_Reset(dev);
9286 priv->ieee80211->state = IEEE80211_ASSOCIATING;
9287 notify_wx_assoc_event(priv->ieee80211);
9288 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
9289 ieee->is_roaming = true;
9290 priv->ieee80211->link_change(dev);
9291 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
9292 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
9293 #else
9294 schedule_task(&priv->ieee80211->associate_procedure_wq);
9295 #endif
9296
9297 }
9298 }
9299 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod=0;
9300 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod=0;
9301 }
9302 // CAM_read_entry(dev,4);
9303 //check if reset the driver
9304 if(check_reset_cnt++ >= 3 && !ieee->is_roaming)
9305 {
9306 ResetType = rtl819x_ifcheck_resetornot(dev);
9307 check_reset_cnt = 3;
9308 //DbgPrint("Start to check silent reset\n");
9309 }
9310 // 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);
9311 #if 1
9312 if( (priv->force_reset) || (priv->ResetProgress==RESET_TYPE_NORESET &&
9313 (priv->bForcedSilentReset ||
9314 (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT)))) // This is control by OID set in Pomelo
9315 {
9316 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);
9317 rtl819x_ifsilentreset(dev);
9318 }
9319 #endif
9320 priv->force_reset = false;
9321 priv->bForcedSilentReset = false;
9322 priv->bResetInProgress = false;
9323 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
9324
9325 }
9326
9327 void watch_dog_timer_callback(unsigned long data)
9328 {
9329 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
9330 //printk("===============>watch_dog timer\n");
9331 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
9332 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq, 0);
9333 #else
9334 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
9335 schedule_task(&priv->watch_dog_wq);
9336 #else
9337 queue_work(priv->priv_wq,&priv->watch_dog_wq);
9338 #endif
9339 #endif
9340 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
9341 #if 0
9342 priv->watch_dog_timer.expires = jiffies + MSECS(IEEE80211_WATCH_DOG_TIME);
9343 add_timer(&priv->watch_dog_timer);
9344 #endif
9345 }
9346 int _rtl8192_up(struct net_device *dev)
9347 {
9348 struct r8192_priv *priv = ieee80211_priv(dev);
9349 //int i;
9350 int init_status = 0;
9351 priv->up=1;
9352 priv->ieee80211->ieee_up=1;
9353 RT_TRACE(COMP_INIT, "Bringing up iface");
9354 init_status = priv->ops->rtl819x_adapter_start(dev);
9355 if(!init_status)
9356 {
9357 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n", __FUNCTION__);
9358 priv->up=priv->ieee80211->ieee_up = 0;
9359 return -EAGAIN;
9360 }
9361 RT_TRACE(COMP_INIT, "start adapter finished\n");
9362 rtl8192_rx_enable(dev);
9363 // rtl8192_tx_enable(dev);
9364 if(priv->ieee80211->state != IEEE80211_LINKED)
9365 ieee80211_softmac_start_protocol(priv->ieee80211);
9366 ieee80211_reset_queue(priv->ieee80211);
9367 watch_dog_timer_callback((unsigned long) dev);
9368 if(!netif_queue_stopped(dev))
9369 netif_start_queue(dev);
9370 else
9371 netif_wake_queue(dev);
9372
9373 /*
9374 * Make sure that drop_unencrypted is initialized as "0"
9375 * No packets will be sent in non-security mode if we had set drop_unencrypted.
9376 * ex, After kill wpa_supplicant process, make the driver up again.
9377 * drop_unencrypted remains as "1", which is set by wpa_supplicant. 2008/12/04.john
9378 */
9379 priv->ieee80211->drop_unencrypted = 0;
9380
9381 return 0;
9382 }
9383
9384
9385 int rtl8192_open(struct net_device *dev)
9386 {
9387 struct r8192_priv *priv = ieee80211_priv(dev);
9388 int ret;
9389 down(&priv->wx_sem);
9390 ret = rtl8192_up(dev);
9391 up(&priv->wx_sem);
9392 return ret;
9393
9394 }
9395
9396
9397 int rtl8192_up(struct net_device *dev)
9398 {
9399 struct r8192_priv *priv = ieee80211_priv(dev);
9400
9401 if (priv->up == 1) return -1;
9402
9403 return _rtl8192_up(dev);
9404 }
9405
9406
9407 int rtl8192_close(struct net_device *dev)
9408 {
9409 struct r8192_priv *priv = ieee80211_priv(dev);
9410 int ret;
9411
9412 down(&priv->wx_sem);
9413
9414 ret = rtl8192_down(dev);
9415
9416 up(&priv->wx_sem);
9417
9418 return ret;
9419
9420 }
9421
9422 int rtl8192_down(struct net_device *dev)
9423 {
9424 struct r8192_priv *priv = ieee80211_priv(dev);
9425 int i;
9426
9427 if (priv->up == 0) return -1;
9428
9429 priv->up=0;
9430 priv->ieee80211->ieee_up = 0;
9431 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
9432 /* FIXME */
9433 if (!netif_queue_stopped(dev))
9434 netif_stop_queue(dev);
9435
9436 rtl8192_rtx_disable(dev);
9437 //rtl8192_irq_disable(dev);
9438
9439 /* Tx related queue release */
9440 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
9441 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
9442 }
9443 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
9444 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
9445 }
9446
9447 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
9448 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ [i]);
9449 }
9450
9451 //as cancel_delayed_work will del work->timer, so if work is not definedas struct delayed_work, it will corrupt
9452 // flush_scheduled_work();
9453 rtl8192_cancel_deferred_work(priv);
9454 deinit_hal_dm(dev);
9455 del_timer_sync(&priv->watch_dog_timer);
9456
9457
9458 ieee80211_softmac_stop_protocol(priv->ieee80211);
9459 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
9460 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
9461
9462 return 0;
9463 }
9464
9465
9466 void rtl8192_commit(struct net_device *dev)
9467 {
9468 struct r8192_priv *priv = ieee80211_priv(dev);
9469 int reset_status = 0;
9470 //u8 reset_times = 0;
9471 if (priv->up == 0) return ;
9472 priv->up = 0;
9473
9474 rtl8192_cancel_deferred_work(priv);
9475 del_timer_sync(&priv->watch_dog_timer);
9476 //cancel_delayed_work(&priv->SwChnlWorkItem);
9477
9478 ieee80211_softmac_stop_protocol(priv->ieee80211);
9479
9480 //rtl8192_irq_disable(dev);
9481 rtl8192_rtx_disable(dev);
9482 reset_status = _rtl8192_up(dev);
9483
9484 }
9485
9486 /*
9487 void rtl8192_restart(struct net_device *dev)
9488 {
9489 struct r8192_priv *priv = ieee80211_priv(dev);
9490 */
9491 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
9492 void rtl8192_restart(struct work_struct *work)
9493 {
9494 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
9495 struct net_device *dev = priv->ieee80211->dev;
9496 #else
9497 void rtl8192_restart(struct net_device *dev)
9498 {
9499
9500 struct r8192_priv *priv = ieee80211_priv(dev);
9501 #endif
9502
9503 down(&priv->wx_sem);
9504
9505 rtl8192_commit(dev);
9506
9507 up(&priv->wx_sem);
9508 }
9509
9510 static void r8192_set_multicast(struct net_device *dev)
9511 {
9512 struct r8192_priv *priv = ieee80211_priv(dev);
9513 short promisc;
9514
9515 //down(&priv->wx_sem);
9516
9517 /* FIXME FIXME */
9518
9519 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
9520
9521 if (promisc != priv->promisc)
9522 // rtl8192_commit(dev);
9523
9524 priv->promisc = promisc;
9525
9526 //schedule_work(&priv->reset_wq);
9527 //up(&priv->wx_sem);
9528 }
9529
9530
9531 int r8192_set_mac_adr(struct net_device *dev, void *mac)
9532 {
9533 struct r8192_priv *priv = ieee80211_priv(dev);
9534 struct sockaddr *addr = mac;
9535
9536 down(&priv->wx_sem);
9537
9538 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
9539
9540 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
9541 schedule_work(&priv->reset_wq);
9542 #else
9543 schedule_task(&priv->reset_wq);
9544 #endif
9545 up(&priv->wx_sem);
9546
9547 return 0;
9548 }
9549
9550 /* based on ipw2200 driver */
9551 int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
9552 {
9553 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
9554 struct iwreq *wrq = (struct iwreq *)rq;
9555 int ret=-1;
9556 struct ieee80211_device *ieee = priv->ieee80211;
9557 u32 key[4];
9558 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
9559 u8 zero_addr[6] = {0};
9560 struct iw_point *p = &wrq->u.data;
9561 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
9562
9563 down(&priv->wx_sem);
9564
9565
9566 if (p->length < sizeof(struct ieee_param) || !p->pointer){
9567 ret = -EINVAL;
9568 goto out;
9569 }
9570
9571 ipw = (struct ieee_param *)kmalloc(p->length, GFP_KERNEL);
9572 if (ipw == NULL){
9573 ret = -ENOMEM;
9574 goto out;
9575 }
9576 if (copy_from_user(ipw, p->pointer, p->length)) {
9577 kfree(ipw);
9578 ret = -EFAULT;
9579 goto out;
9580 }
9581
9582 switch (cmd) {
9583 case RTL_IOCTL_WPA_SUPPLICANT:
9584 //parse here for HW security
9585 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
9586 {
9587 if (ipw->u.crypt.set_tx)
9588 {
9589 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
9590 ieee->pairwise_key_type = KEY_TYPE_CCMP;
9591 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
9592 ieee->pairwise_key_type = KEY_TYPE_TKIP;
9593 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
9594 {
9595 if (ipw->u.crypt.key_len == 13)
9596 ieee->pairwise_key_type = KEY_TYPE_WEP104;
9597 else if (ipw->u.crypt.key_len == 5)
9598 ieee->pairwise_key_type = KEY_TYPE_WEP40;
9599 }
9600 else
9601 ieee->pairwise_key_type = KEY_TYPE_NA;
9602
9603 if (ieee->pairwise_key_type)
9604 {
9605 // FIXME:these two lines below just to fix ipw interface bug, that is, it will never set mode down to driver. So treat it as ADHOC mode, if no association procedure. WB. 2009.02.04
9606 if (memcmp(ieee->ap_mac_addr, zero_addr, 6) == 0)
9607 ieee->iw_mode = IW_MODE_ADHOC;
9608 memcpy((u8*)key, ipw->u.crypt.key, 16);
9609 EnableHWSecurityConfig8192(dev);
9610 //we fill both index entry and 4th entry for pairwise key as in IPW interface, adhoc will only get here, so we need index entry for its default key serching!
9611 //added by WB.
9612 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
9613 if (ieee->iw_mode == IW_MODE_ADHOC)
9614 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
9615 }
9616 }
9617 else //if (ipw->u.crypt.idx) //group key use idx > 0
9618 {
9619 memcpy((u8*)key, ipw->u.crypt.key, 16);
9620 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
9621 ieee->group_key_type= KEY_TYPE_CCMP;
9622 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
9623 ieee->group_key_type = KEY_TYPE_TKIP;
9624 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
9625 {
9626 if (ipw->u.crypt.key_len == 13)
9627 ieee->group_key_type = KEY_TYPE_WEP104;
9628 else if (ipw->u.crypt.key_len == 5)
9629 ieee->group_key_type = KEY_TYPE_WEP40;
9630 }
9631 else
9632 ieee->group_key_type = KEY_TYPE_NA;
9633
9634 if (ieee->group_key_type)
9635 {
9636 setKey( dev,
9637 ipw->u.crypt.idx,
9638 ipw->u.crypt.idx, //KeyIndex
9639 ieee->group_key_type, //KeyType
9640 broadcast_addr, //MacAddr
9641 0, //DefaultKey
9642 key); //KeyContent
9643 }
9644 }
9645 }
9646 #ifdef JOHN_HWSEC_DEBUG
9647 //john's test 0711
9648 printk("@@ wrq->u pointer = ");
9649 for(i=0;i<wrq->u.data.length;i++){
9650 if(i%10==0) printk("\n");
9651 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
9652 }
9653 printk("\n");
9654 #endif /*JOHN_HWSEC_DEBUG*/
9655 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
9656 break;
9657
9658 default:
9659 ret = -EOPNOTSUPP;
9660 break;
9661 }
9662 kfree(ipw);
9663 ipw = NULL;
9664 out:
9665 up(&priv->wx_sem);
9666 return ret;
9667 }
9668
9669 #ifdef RTL8192SU
9670 u8 rtl8192SU_HwRateToMRate(bool bIsHT, u8 rate,bool bFirstAMPDU)
9671 {
9672
9673 u8 ret_rate = 0x02;
9674
9675 if( bFirstAMPDU )
9676 {
9677 if(!bIsHT)
9678 {
9679 switch(rate)
9680 {
9681
9682 case DESC92S_RATE1M: ret_rate = MGN_1M; break;
9683 case DESC92S_RATE2M: ret_rate = MGN_2M; break;
9684 case DESC92S_RATE5_5M: ret_rate = MGN_5_5M; break;
9685 case DESC92S_RATE11M: ret_rate = MGN_11M; break;
9686 case DESC92S_RATE6M: ret_rate = MGN_6M; break;
9687 case DESC92S_RATE9M: ret_rate = MGN_9M; break;
9688 case DESC92S_RATE12M: ret_rate = MGN_12M; break;
9689 case DESC92S_RATE18M: ret_rate = MGN_18M; break;
9690 case DESC92S_RATE24M: ret_rate = MGN_24M; break;
9691 case DESC92S_RATE36M: ret_rate = MGN_36M; break;
9692 case DESC92S_RATE48M: ret_rate = MGN_48M; break;
9693 case DESC92S_RATE54M: ret_rate = MGN_54M; break;
9694
9695 default:
9696 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
9697 break;
9698 }
9699 }
9700 else
9701 {
9702 switch(rate)
9703 {
9704
9705 case DESC92S_RATEMCS0: ret_rate = MGN_MCS0; break;
9706 case DESC92S_RATEMCS1: ret_rate = MGN_MCS1; break;
9707 case DESC92S_RATEMCS2: ret_rate = MGN_MCS2; break;
9708 case DESC92S_RATEMCS3: ret_rate = MGN_MCS3; break;
9709 case DESC92S_RATEMCS4: ret_rate = MGN_MCS4; break;
9710 case DESC92S_RATEMCS5: ret_rate = MGN_MCS5; break;
9711 case DESC92S_RATEMCS6: ret_rate = MGN_MCS6; break;
9712 case DESC92S_RATEMCS7: ret_rate = MGN_MCS7; break;
9713 case DESC92S_RATEMCS8: ret_rate = MGN_MCS8; break;
9714 case DESC92S_RATEMCS9: ret_rate = MGN_MCS9; break;
9715 case DESC92S_RATEMCS10: ret_rate = MGN_MCS10; break;
9716 case DESC92S_RATEMCS11: ret_rate = MGN_MCS11; break;
9717 case DESC92S_RATEMCS12: ret_rate = MGN_MCS12; break;
9718 case DESC92S_RATEMCS13: ret_rate = MGN_MCS13; break;
9719 case DESC92S_RATEMCS14: ret_rate = MGN_MCS14; break;
9720 case DESC92S_RATEMCS15: ret_rate = MGN_MCS15; break;
9721 case DESC92S_RATEMCS32: ret_rate = (0x80|0x20); break;
9722
9723 default:
9724 RT_TRACE(COMP_RECV, "HwRateToMRate92S(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT );
9725 break;
9726 }
9727
9728 }
9729 }
9730 else
9731 {
9732 switch(rate)
9733 {
9734
9735 case DESC92S_RATE1M: ret_rate = MGN_1M; break;
9736 case DESC92S_RATE2M: ret_rate = MGN_2M; break;
9737 case DESC92S_RATE5_5M: ret_rate = MGN_5_5M; break;
9738 case DESC92S_RATE11M: ret_rate = MGN_11M; break;
9739 case DESC92S_RATE6M: ret_rate = MGN_6M; break;
9740 case DESC92S_RATE9M: ret_rate = MGN_9M; break;
9741 case DESC92S_RATE12M: ret_rate = MGN_12M; break;
9742 case DESC92S_RATE18M: ret_rate = MGN_18M; break;
9743 case DESC92S_RATE24M: ret_rate = MGN_24M; break;
9744 case DESC92S_RATE36M: ret_rate = MGN_36M; break;
9745 case DESC92S_RATE48M: ret_rate = MGN_48M; break;
9746 case DESC92S_RATE54M: ret_rate = MGN_54M; break;
9747 case DESC92S_RATEMCS0: ret_rate = MGN_MCS0; break;
9748 case DESC92S_RATEMCS1: ret_rate = MGN_MCS1; break;
9749 case DESC92S_RATEMCS2: ret_rate = MGN_MCS2; break;
9750 case DESC92S_RATEMCS3: ret_rate = MGN_MCS3; break;
9751 case DESC92S_RATEMCS4: ret_rate = MGN_MCS4; break;
9752 case DESC92S_RATEMCS5: ret_rate = MGN_MCS5; break;
9753 case DESC92S_RATEMCS6: ret_rate = MGN_MCS6; break;
9754 case DESC92S_RATEMCS7: ret_rate = MGN_MCS7; break;
9755 case DESC92S_RATEMCS8: ret_rate = MGN_MCS8; break;
9756 case DESC92S_RATEMCS9: ret_rate = MGN_MCS9; break;
9757 case DESC92S_RATEMCS10: ret_rate = MGN_MCS10; break;
9758 case DESC92S_RATEMCS11: ret_rate = MGN_MCS11; break;
9759 case DESC92S_RATEMCS12: ret_rate = MGN_MCS12; break;
9760 case DESC92S_RATEMCS13: ret_rate = MGN_MCS13; break;
9761 case DESC92S_RATEMCS14: ret_rate = MGN_MCS14; break;
9762 case DESC92S_RATEMCS15: ret_rate = MGN_MCS15; break;
9763 case DESC92S_RATEMCS32: ret_rate = (0x80|0x20); break;
9764
9765 default:
9766 RT_TRACE(COMP_RECV, "HwRateToMRate92S(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT );
9767 break;
9768 }
9769 }
9770 return ret_rate;
9771 }
9772 #endif
9773
9774 u8 HwRateToMRate90(bool bIsHT, u8 rate)
9775 {
9776 u8 ret_rate = 0xff;
9777
9778 if(!bIsHT) {
9779 switch(rate) {
9780 case DESC90_RATE1M: ret_rate = MGN_1M; break;
9781 case DESC90_RATE2M: ret_rate = MGN_2M; break;
9782 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
9783 case DESC90_RATE11M: ret_rate = MGN_11M; break;
9784 case DESC90_RATE6M: ret_rate = MGN_6M; break;
9785 case DESC90_RATE9M: ret_rate = MGN_9M; break;
9786 case DESC90_RATE12M: ret_rate = MGN_12M; break;
9787 case DESC90_RATE18M: ret_rate = MGN_18M; break;
9788 case DESC90_RATE24M: ret_rate = MGN_24M; break;
9789 case DESC90_RATE36M: ret_rate = MGN_36M; break;
9790 case DESC90_RATE48M: ret_rate = MGN_48M; break;
9791 case DESC90_RATE54M: ret_rate = MGN_54M; break;
9792
9793 default:
9794 ret_rate = 0xff;
9795 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
9796 break;
9797 }
9798
9799 } else {
9800 switch(rate) {
9801 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
9802 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
9803 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
9804 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
9805 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
9806 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
9807 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
9808 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
9809 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
9810 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
9811 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
9812 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
9813 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
9814 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
9815 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
9816 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
9817 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
9818
9819 default:
9820 ret_rate = 0xff;
9821 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
9822 break;
9823 }
9824 }
9825
9826 return ret_rate;
9827 }
9828
9829 /**
9830 * Function: UpdateRxPktTimeStamp
9831 * Overview: Recored down the TSF time stamp when receiving a packet
9832 *
9833 * Input:
9834 * PADAPTER Adapter
9835 * PRT_RFD pRfd,
9836 *
9837 * Output:
9838 * PRT_RFD pRfd
9839 * (pRfd->Status.TimeStampHigh is updated)
9840 * (pRfd->Status.TimeStampLow is updated)
9841 * Return:
9842 * None
9843 */
9844 void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
9845 {
9846 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
9847
9848 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
9849 stats->mac_time[0] = priv->LastRxDescTSFLow;
9850 stats->mac_time[1] = priv->LastRxDescTSFHigh;
9851 } else {
9852 priv->LastRxDescTSFLow = stats->mac_time[0];
9853 priv->LastRxDescTSFHigh = stats->mac_time[1];
9854 }
9855 }
9856
9857 //by amy 080606
9858
9859 long rtl819x_translate_todbm(u8 signal_strength_index )// 0-100 index.
9860 {
9861 long signal_power; // in dBm.
9862
9863 // Translate to dBm (x=0.5y-95).
9864 signal_power = (long)((signal_strength_index + 1) >> 1);
9865 signal_power -= 95;
9866
9867 return signal_power;
9868 }
9869
9870
9871 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
9872 be a local static. Otherwise, it may increase when we return from S3/S4. The
9873 value will be kept in memory or disk. We must delcare the value in adapter
9874 and it will be reinitialized when return from S3/S4. */
9875 void rtl8192_process_phyinfo(struct r8192_priv * priv,u8* buffer, struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
9876 {
9877 bool bcheck = false;
9878 u8 rfpath;
9879 u32 nspatial_stream, tmp_val;
9880 //u8 i;
9881 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
9882 static u32 slide_evm_index=0, slide_evm_statistics=0;
9883 static u32 last_rssi=0, last_evm=0;
9884
9885 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
9886 static u32 last_beacon_adc_pwdb=0;
9887
9888 struct ieee80211_hdr_3addr *hdr;
9889 u16 sc ;
9890 unsigned int frag,seq;
9891 hdr = (struct ieee80211_hdr_3addr *)buffer;
9892 sc = le16_to_cpu(hdr->seq_ctl);
9893 frag = WLAN_GET_SEQ_FRAG(sc);
9894 seq = WLAN_GET_SEQ_SEQ(sc);
9895 //cosa add 04292008 to record the sequence number
9896 pcurrent_stats->Seq_Num = seq;
9897 //
9898 // Check whether we should take the previous packet into accounting
9899 //
9900 if(!pprevious_stats->bIsAMPDU)
9901 {
9902 // if previous packet is not aggregated packet
9903 bcheck = true;
9904 }else
9905 {
9906 #if 0
9907 // if previous packet is aggregated packet, and current packet
9908 // (1) is not AMPDU
9909 // (2) is the first packet of one AMPDU
9910 // that means the previous packet is the last one aggregated packet
9911 if( !pcurrent_stats->bIsAMPDU || pcurrent_stats->bFirstMPDU)
9912 bcheck = true;
9913 #endif
9914 }
9915
9916
9917 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
9918 {
9919 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
9920 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
9921 priv->stats.slide_rssi_total -= last_rssi;
9922 }
9923 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
9924
9925 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
9926 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
9927 slide_rssi_index = 0;
9928
9929 // <1> Showed on UI for user, in dbm
9930 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
9931 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
9932 pcurrent_stats->rssi = priv->stats.signal_strength;
9933 //
9934 // If the previous packet does not match the criteria, neglect it
9935 //
9936 if(!pprevious_stats->bPacketMatchBSSID)
9937 {
9938 if(!pprevious_stats->bToSelfBA)
9939 return;
9940 }
9941
9942 if(!bcheck)
9943 return;
9944
9945
9946 //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
9947
9948 //
9949 // Check RSSI
9950 //
9951 priv->stats.num_process_phyinfo++;
9952
9953 /* record the general signal strength to the sliding window. */
9954
9955
9956 // <2> Showed on UI for engineering
9957 // hardware does not provide rssi information for each rf path in CCK
9958 if(!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA))
9959 {
9960 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++)
9961 {
9962 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
9963 continue;
9964
9965 //Fixed by Jacken 2008-03-20
9966 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
9967 {
9968 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
9969 //DbgPrint("MIMO RSSI initialize \n");
9970 }
9971 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
9972 {
9973 priv->stats.rx_rssi_percentage[rfpath] =
9974 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
9975 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
9976 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
9977 }
9978 else
9979 {
9980 priv->stats.rx_rssi_percentage[rfpath] =
9981 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
9982 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
9983 }
9984 RT_TRACE(COMP_DBG,"priv->stats.rx_rssi_percentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
9985 }
9986 }
9987
9988
9989 //
9990 // Check PWDB.
9991 //
9992 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
9993 pprevious_stats->bIsCCK? "CCK": "OFDM",
9994 pprevious_stats->RxPWDBAll);
9995
9996 if(pprevious_stats->bPacketBeacon)
9997 {
9998 /* record the beacon pwdb to the sliding window. */
9999 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
10000 {
10001 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
10002 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
10003 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
10004 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
10005 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
10006 }
10007 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
10008 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
10009 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
10010 slide_beacon_adc_pwdb_index++;
10011 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
10012 slide_beacon_adc_pwdb_index = 0;
10013 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
10014 if(pprevious_stats->RxPWDBAll >= 3)
10015 pprevious_stats->RxPWDBAll -= 3;
10016 }
10017
10018 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
10019 pprevious_stats->bIsCCK? "CCK": "OFDM",
10020 pprevious_stats->RxPWDBAll);
10021
10022
10023 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
10024 {
10025 if(priv->undecorated_smoothed_pwdb < 0) // initialize
10026 {
10027 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
10028 //DbgPrint("First pwdb initialize \n");
10029 }
10030 #if 1
10031 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
10032 {
10033 priv->undecorated_smoothed_pwdb =
10034 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
10035 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
10036 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
10037 }
10038 else
10039 {
10040 priv->undecorated_smoothed_pwdb =
10041 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
10042 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
10043 }
10044 #else
10045 //Fixed by Jacken 2008-03-20
10046 if(pPreviousRfd->Status.RxPWDBAll > (u32)pHalData->UndecoratedSmoothedPWDB)
10047 {
10048 pHalData->UndecoratedSmoothedPWDB =
10049 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
10050 pHalData->UndecoratedSmoothedPWDB = pHalData->UndecoratedSmoothedPWDB + 1;
10051 }
10052 else
10053 {
10054 pHalData->UndecoratedSmoothedPWDB =
10055 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
10056 }
10057 #endif
10058
10059 }
10060
10061 //
10062 // Check EVM
10063 //
10064 /* record the general EVM to the sliding window. */
10065 if(pprevious_stats->SignalQuality == 0)
10066 {
10067 }
10068 else
10069 {
10070 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
10071 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
10072 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
10073 last_evm = priv->stats.slide_evm[slide_evm_index];
10074 priv->stats.slide_evm_total -= last_evm;
10075 }
10076
10077 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
10078
10079 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
10080 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
10081 slide_evm_index = 0;
10082
10083 // <1> Showed on UI for user, in percentage.
10084 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
10085 priv->stats.signal_quality = tmp_val;
10086 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
10087 priv->stats.last_signal_strength_inpercent = tmp_val;
10088 }
10089
10090 // <2> Showed on UI for engineering
10091 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
10092 {
10093 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
10094 {
10095 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
10096 {
10097 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
10098 {
10099 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
10100 }
10101 priv->stats.rx_evm_percentage[nspatial_stream] =
10102 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
10103 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
10104 }
10105 }
10106 }
10107 }
10108
10109
10110 }
10111
10112 /*-----------------------------------------------------------------------------
10113 * Function: rtl819x_query_rxpwrpercentage()
10114 *
10115 * Overview:
10116 *
10117 * Input: char antpower
10118 *
10119 * Output: NONE
10120 *
10121 * Return: 0-100 percentage
10122 *
10123 * Revised History:
10124 * When Who Remark
10125 * 05/26/2008 amy Create Version 0 porting from windows code.
10126 *
10127 *---------------------------------------------------------------------------*/
10128 static u8 rtl819x_query_rxpwrpercentage(
10129 char antpower
10130 )
10131 {
10132 if ((antpower <= -100) || (antpower >= 20))
10133 {
10134 return 0;
10135 }
10136 else if (antpower >= 0)
10137 {
10138 return 100;
10139 }
10140 else
10141 {
10142 return (100+antpower);
10143 }
10144
10145 } /* QueryRxPwrPercentage */
10146
10147 static u8
10148 rtl819x_evm_dbtopercentage(
10149 char value
10150 )
10151 {
10152 char ret_val;
10153
10154 ret_val = value;
10155
10156 if(ret_val >= 0)
10157 ret_val = 0;
10158 if(ret_val <= -33)
10159 ret_val = -33;
10160 ret_val = 0 - ret_val;
10161 ret_val*=3;
10162 if(ret_val == 99)
10163 ret_val = 100;
10164 return(ret_val);
10165 }
10166 //
10167 // Description:
10168 // We want good-looking for signal strength/quality
10169 // 2007/7/19 01:09, by cosa.
10170 //
10171 long
10172 rtl819x_signal_scale_mapping(
10173 long currsig
10174 )
10175 {
10176 long retsig;
10177
10178 // Step 1. Scale mapping.
10179 if(currsig >= 61 && currsig <= 100)
10180 {
10181 retsig = 90 + ((currsig - 60) / 4);
10182 }
10183 else if(currsig >= 41 && currsig <= 60)
10184 {
10185 retsig = 78 + ((currsig - 40) / 2);
10186 }
10187 else if(currsig >= 31 && currsig <= 40)
10188 {
10189 retsig = 66 + (currsig - 30);
10190 }
10191 else if(currsig >= 21 && currsig <= 30)
10192 {
10193 retsig = 54 + (currsig - 20);
10194 }
10195 else if(currsig >= 5 && currsig <= 20)
10196 {
10197 retsig = 42 + (((currsig - 5) * 2) / 3);
10198 }
10199 else if(currsig == 4)
10200 {
10201 retsig = 36;
10202 }
10203 else if(currsig == 3)
10204 {
10205 retsig = 27;
10206 }
10207 else if(currsig == 2)
10208 {
10209 retsig = 18;
10210 }
10211 else if(currsig == 1)
10212 {
10213 retsig = 9;
10214 }
10215 else
10216 {
10217 retsig = currsig;
10218 }
10219
10220 return retsig;
10221 }
10222
10223 #ifdef RTL8192SU
10224 /*-----------------------------------------------------------------------------
10225 * Function: QueryRxPhyStatus8192S()
10226 *
10227 * Overview:
10228 *
10229 * Input: NONE
10230 *
10231 * Output: NONE
10232 *
10233 * Return: NONE
10234 *
10235 * Revised History:
10236 * When Who Remark
10237 * 06/01/2007 MHC Create Version 0.
10238 * 06/05/2007 MHC Accordign to HW's new data sheet, we add CCK and OFDM
10239 * descriptor definition.
10240 * 07/04/2007 MHC According to Jerry and Bryant's document. We read
10241 * ir_isolation and ext_lna for RF's init value and use
10242 * to compensate RSSI after receiving packets.
10243 * 09/10/2008 MHC Modify name and PHY status field for 92SE.
10244 * 09/19/2008 MHC Add CCK/OFDM SS/SQ for 92S series.
10245 *
10246 *---------------------------------------------------------------------------*/
10247 static void rtl8192SU_query_rxphystatus(
10248 struct r8192_priv * priv,
10249 struct ieee80211_rx_stats * pstats,
10250 rx_desc_819x_usb *pDesc,
10251 rx_drvinfo_819x_usb * pdrvinfo,
10252 struct ieee80211_rx_stats * precord_stats,
10253 bool bpacket_match_bssid,
10254 bool bpacket_toself,
10255 bool bPacketBeacon,
10256 bool bToSelfBA
10257 )
10258 {
10259 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
10260 //PHY_STS_CCK_8192S_T *pCck_buf;
10261 phy_sts_cck_819xusb_t * pcck_buf;
10262 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
10263 //u8 *prxpkt;
10264 //u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
10265 u8 i, max_spatial_stream, rxsc_sgien_exflg;
10266 char rx_pwr[4], rx_pwr_all=0;
10267 //long rx_avg_pwr = 0;
10268 //char rx_snrX, rx_evmX;
10269 u8 evm, pwdb_all;
10270 u32 RSSI, total_rssi=0;//, total_evm=0;
10271 // long signal_strength_index = 0;
10272 u8 is_cck_rate=0;
10273 u8 rf_rx_num = 0;
10274
10275
10276
10277 priv->stats.numqry_phystatus++;
10278
10279 is_cck_rate = rx_hal_is_cck_rate(pDesc);
10280
10281 // Record it for next packet processing
10282 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
10283 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
10284 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
10285 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
10286 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
10287 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
10288
10289 #ifndef RTL8192SU
10290 phy_sts_ofdm_819xusb_t* pofdm_buf = NULL;
10291 prxpkt = (u8*)pdrvinfo;
10292
10293 /* Move pointer to the 16th bytes. Phy status start address. */
10294 prxpkt += sizeof(rx_drvinfo_819x_usb);
10295
10296 /* Initial the cck and ofdm buffer pointer */
10297 pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
10298 pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
10299 #endif
10300
10301 pstats->RxMIMOSignalQuality[0] = -1;
10302 pstats->RxMIMOSignalQuality[1] = -1;
10303 precord_stats->RxMIMOSignalQuality[0] = -1;
10304 precord_stats->RxMIMOSignalQuality[1] = -1;
10305
10306 if(is_cck_rate)
10307 {
10308 u8 report;//, tmp_pwdb;
10309 //char cck_adc_pwdb[4];
10310
10311 // CCK Driver info Structure is not the same as OFDM packet.
10312 pcck_buf = (phy_sts_cck_819xusb_t *)pdrvinfo;
10313
10314 //
10315 // (1)Hardware does not provide RSSI for CCK
10316 //
10317
10318 //
10319 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
10320 //
10321
10322 priv->stats.numqry_phystatusCCK++;
10323
10324 if(!priv->bCckHighPower)
10325 {
10326 report = pcck_buf->cck_agc_rpt & 0xc0;
10327 report = report>>6;
10328 switch(report)
10329 {
10330 //Fixed by Jacken from Bryant 2008-03-20
10331 //Original value is -38 , -26 , -14 , -2
10332 //Fixed value is -35 , -23 , -11 , 6
10333 case 0x3:
10334 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
10335 break;
10336 case 0x2:
10337 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
10338 break;
10339 case 0x1:
10340 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
10341 break;
10342 case 0x0:
10343 rx_pwr_all = 8 - (pcck_buf->cck_agc_rpt & 0x3e);//6->8
10344 break;
10345 }
10346 }
10347 else
10348 {
10349 report = pdrvinfo->cfosho[0] & 0x60;
10350 report = report>>5;
10351 switch(report)
10352 {
10353 case 0x3:
10354 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
10355 break;
10356 case 0x2:
10357 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
10358 break;
10359 case 0x1:
10360 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
10361 break;
10362 case 0x0:
10363 rx_pwr_all = -8 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;//6->-8
10364 break;
10365 }
10366 }
10367
10368 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);//check it
10369 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
10370 //pstats->RecvSignalPower = pwdb_all;
10371 pstats->RecvSignalPower = rx_pwr_all;
10372
10373 //
10374 // (3) Get Signal Quality (EVM)
10375 //
10376 //if(bpacket_match_bssid)
10377 {
10378 u8 sq;
10379
10380 if(pstats->RxPWDBAll > 40)
10381 {
10382 sq = 100;
10383 }else
10384 {
10385 sq = pcck_buf->sq_rpt;
10386
10387 if(pcck_buf->sq_rpt > 64)
10388 sq = 0;
10389 else if (pcck_buf->sq_rpt < 20)
10390 sq = 100;
10391 else
10392 sq = ((64-sq) * 100) / 44;
10393 }
10394 pstats->SignalQuality = precord_stats->SignalQuality = sq;
10395 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
10396 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
10397 }
10398 }
10399 else
10400 {
10401 priv->stats.numqry_phystatusHT++;
10402
10403 // 2008/09/19 MH For 92S debug, RX RF path always enable!!
10404 priv->brfpath_rxenable[0] = priv->brfpath_rxenable[1] = TRUE;
10405
10406 //
10407 // (1)Get RSSI for HT rate
10408 //
10409 //for(i=RF90_PATH_A; i<priv->NumTotalRFPath; i++)
10410 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
10411 {
10412 // 2008/01/30 MH we will judge RF RX path now.
10413 if (priv->brfpath_rxenable[i])
10414 rf_rx_num++;
10415 //else
10416 // continue;
10417
10418 //if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
10419 // continue;
10420
10421 //Fixed by Jacken from Bryant 2008-03-20
10422 //Original value is 106
10423 //rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
10424 rx_pwr[i] = ((pdrvinfo->gain_trsw[i]&0x3F)*2) - 110;
10425
10426 /* Translate DBM to percentage. */
10427 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]); //check ok
10428 total_rssi += RSSI;
10429 RT_TRACE(COMP_RF, "RF-%d RXPWR=%x RSSI=%d\n", i, rx_pwr[i], RSSI);
10430
10431 //Get Rx snr value in DB
10432 //tmp_rxsnr = pofdm_buf->rxsnr_X[i];
10433 //rx_snrX = (char)(tmp_rxsnr);
10434 //rx_snrX /= 2;
10435 //priv->stats.rxSNRdB[i] = (long)rx_snrX;
10436 priv->stats.rxSNRdB[i] = (long)(pdrvinfo->rxsnr[i]/2);
10437
10438 /* Translate DBM to percentage. */
10439 //RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
10440 //total_rssi += RSSI;
10441
10442 /* Record Signal Strength for next packet */
10443 //if(bpacket_match_bssid)
10444 {
10445 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
10446 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
10447 }
10448 }
10449
10450
10451 //
10452 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
10453 //
10454 //Fixed by Jacken from Bryant 2008-03-20
10455 //Original value is 106
10456 //rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
10457 rx_pwr_all = (((pdrvinfo->pwdb_all ) >> 1 )& 0x7f) -106;
10458 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
10459
10460 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
10461 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
10462 pstats->RecvSignalPower = rx_pwr_all;
10463
10464 //
10465 // (3)EVM of HT rate
10466 //
10467 //if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
10468 // pdrvinfo->RxRate<=DESC90_RATEMCS15)
10469 if(pDesc->RxHT && pDesc->RxMCS>=DESC92S_RATEMCS8 &&
10470 pDesc->RxMCS<=DESC92S_RATEMCS15)
10471 max_spatial_stream = 2; //both spatial stream make sense
10472 else
10473 max_spatial_stream = 1; //only spatial stream 1 makes sense
10474
10475 for(i=0; i<max_spatial_stream; i++)
10476 {
10477 //tmp_rxevm = pofdm_buf->rxevm_X[i];
10478 //rx_evmX = (char)(tmp_rxevm);
10479
10480 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
10481 // fill most significant bit to "zero" when doing shifting operation which may change a negative
10482 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
10483 //rx_evmX /= 2; //dbm
10484
10485 //evm = rtl819x_evm_dbtopercentage(rx_evmX);
10486 evm = rtl819x_evm_dbtopercentage( (pdrvinfo->rxevm[i] /*/ 2*/)); //dbm
10487 RT_TRACE(COMP_RF, "RXRATE=%x RXEVM=%x EVM=%s%d\n", pDesc->RxMCS, pdrvinfo->rxevm[i], "%", evm);
10488 #if 0
10489 EVM = SignalScaleMapping(EVM);//make it good looking, from 0~100//=====>from here
10490 #endif
10491
10492 //if(bpacket_match_bssid)
10493 {
10494 if(i==0) // Fill value in RFD, Get the first spatial stream only
10495 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
10496 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
10497 }
10498 }
10499
10500
10501 /* record rx statistics for debug */
10502 //rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
10503 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
10504 //if(pdrvinfo->BW) //40M channel
10505 if(pDesc->BW) //40M channel
10506 priv->stats.received_bwtype[1+pdrvinfo->rxsc]++;
10507 else //20M channel
10508 priv->stats.received_bwtype[0]++;
10509 }
10510
10511 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
10512 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
10513 if(is_cck_rate)
10514 {
10515 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;//check ok
10516
10517 }
10518 else
10519 {
10520 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u8)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u8)(total_rssi/=RF90_PATH_MAX);
10521 // We can judge RX path number now.
10522 if (rf_rx_num != 0)
10523 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
10524 }
10525 }/* QueryRxPhyStatus8192S */
10526 #else
10527 static void rtl8192_query_rxphystatus(
10528 struct r8192_priv * priv,
10529 struct ieee80211_rx_stats * pstats,
10530 rx_drvinfo_819x_usb * pdrvinfo,
10531 struct ieee80211_rx_stats * precord_stats,
10532 bool bpacket_match_bssid,
10533 bool bpacket_toself,
10534 bool bPacketBeacon,
10535 bool bToSelfBA
10536 )
10537 {
10538 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
10539 phy_sts_ofdm_819xusb_t* pofdm_buf;
10540 phy_sts_cck_819xusb_t * pcck_buf;
10541 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
10542 u8 *prxpkt;
10543 u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
10544 char rx_pwr[4], rx_pwr_all=0;
10545 //long rx_avg_pwr = 0;
10546 char rx_snrX, rx_evmX;
10547 u8 evm, pwdb_all;
10548 u32 RSSI, total_rssi=0;//, total_evm=0;
10549 // long signal_strength_index = 0;
10550 u8 is_cck_rate=0;
10551 u8 rf_rx_num = 0;
10552
10553
10554 priv->stats.numqry_phystatus++;
10555
10556 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
10557
10558 // Record it for next packet processing
10559 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
10560 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
10561 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
10562 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
10563 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
10564 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
10565
10566 prxpkt = (u8*)pdrvinfo;
10567
10568 /* Move pointer to the 16th bytes. Phy status start address. */
10569 prxpkt += sizeof(rx_drvinfo_819x_usb);
10570
10571 /* Initial the cck and ofdm buffer pointer */
10572 pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
10573 pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
10574
10575 pstats->RxMIMOSignalQuality[0] = -1;
10576 pstats->RxMIMOSignalQuality[1] = -1;
10577 precord_stats->RxMIMOSignalQuality[0] = -1;
10578 precord_stats->RxMIMOSignalQuality[1] = -1;
10579
10580 if(is_cck_rate)
10581 {
10582 //
10583 // (1)Hardware does not provide RSSI for CCK
10584 //
10585
10586 //
10587 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
10588 //
10589 u8 report;//, cck_agc_rpt;
10590
10591 priv->stats.numqry_phystatusCCK++;
10592
10593 if(!priv->bCckHighPower)
10594 {
10595 report = pcck_buf->cck_agc_rpt & 0xc0;
10596 report = report>>6;
10597 switch(report)
10598 {
10599 //Fixed by Jacken from Bryant 2008-03-20
10600 //Original value is -38 , -26 , -14 , -2
10601 //Fixed value is -35 , -23 , -11 , 6
10602 case 0x3:
10603 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
10604 break;
10605 case 0x2:
10606 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
10607 break;
10608 case 0x1:
10609 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
10610 break;
10611 case 0x0:
10612 rx_pwr_all = 6 - (pcck_buf->cck_agc_rpt & 0x3e);
10613 break;
10614 }
10615 }
10616 else
10617 {
10618 report = pcck_buf->cck_agc_rpt & 0x60;
10619 report = report>>5;
10620 switch(report)
10621 {
10622 case 0x3:
10623 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
10624 break;
10625 case 0x2:
10626 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
10627 break;
10628 case 0x1:
10629 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
10630 break;
10631 case 0x0:
10632 rx_pwr_all = 6 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
10633 break;
10634 }
10635 }
10636
10637 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
10638 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
10639 pstats->RecvSignalPower = pwdb_all;
10640
10641 //
10642 // (3) Get Signal Quality (EVM)
10643 //
10644 //if(bpacket_match_bssid)
10645 {
10646 u8 sq;
10647
10648 if(pstats->RxPWDBAll > 40)
10649 {
10650 sq = 100;
10651 }else
10652 {
10653 sq = pcck_buf->sq_rpt;
10654
10655 if(pcck_buf->sq_rpt > 64)
10656 sq = 0;
10657 else if (pcck_buf->sq_rpt < 20)
10658 sq = 100;
10659 else
10660 sq = ((64-sq) * 100) / 44;
10661 }
10662 pstats->SignalQuality = precord_stats->SignalQuality = sq;
10663 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
10664 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
10665 }
10666 }
10667 else
10668 {
10669 priv->stats.numqry_phystatusHT++;
10670 //
10671 // (1)Get RSSI for HT rate
10672 //
10673 for(i=RF90_PATH_A; i<priv->NumTotalRFPath; i++)
10674 {
10675 // 2008/01/30 MH we will judge RF RX path now.
10676 if (priv->brfpath_rxenable[i])
10677 rf_rx_num++;
10678 else
10679 continue;
10680
10681 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
10682 continue;
10683
10684 //Fixed by Jacken from Bryant 2008-03-20
10685 //Original value is 106
10686 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
10687
10688 //Get Rx snr value in DB
10689 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
10690 rx_snrX = (char)(tmp_rxsnr);
10691 //rx_snrX >>= 1;;
10692 rx_snrX /= 2;
10693 priv->stats.rxSNRdB[i] = (long)rx_snrX;
10694
10695 /* Translate DBM to percentage. */
10696 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
10697 total_rssi += RSSI;
10698
10699 /* Record Signal Strength for next packet */
10700 //if(bpacket_match_bssid)
10701 {
10702 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
10703 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
10704 }
10705 }
10706
10707
10708 //
10709 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
10710 //
10711 //Fixed by Jacken from Bryant 2008-03-20
10712 //Original value is 106
10713 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
10714 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
10715
10716 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
10717 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
10718
10719 //
10720 // (3)EVM of HT rate
10721 //
10722 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
10723 pdrvinfo->RxRate<=DESC90_RATEMCS15)
10724 max_spatial_stream = 2; //both spatial stream make sense
10725 else
10726 max_spatial_stream = 1; //only spatial stream 1 makes sense
10727
10728 for(i=0; i<max_spatial_stream; i++)
10729 {
10730 tmp_rxevm = pofdm_buf->rxevm_X[i];
10731 rx_evmX = (char)(tmp_rxevm);
10732
10733 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
10734 // fill most significant bit to "zero" when doing shifting operation which may change a negative
10735 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
10736 rx_evmX /= 2; //dbm
10737
10738 evm = rtl819x_evm_dbtopercentage(rx_evmX);
10739 #if 0
10740 EVM = SignalScaleMapping(EVM);//make it good looking, from 0~100
10741 #endif
10742 //if(bpacket_match_bssid)
10743 {
10744 if(i==0) // Fill value in RFD, Get the first spatial stream only
10745 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
10746 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
10747 }
10748 }
10749
10750
10751 /* record rx statistics for debug */
10752 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
10753 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
10754 if(pdrvinfo->BW) //40M channel
10755 priv->stats.received_bwtype[1+prxsc->rxsc]++;
10756 else //20M channel
10757 priv->stats.received_bwtype[0]++;
10758 }
10759
10760 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
10761 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
10762 if(is_cck_rate)
10763 {
10764 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
10765
10766 }
10767 else
10768 {
10769 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u8)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u8)(total_rssi/=RF90_PATH_MAX);
10770 // We can judge RX path number now.
10771 if (rf_rx_num != 0)
10772 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
10773 }
10774 } /* QueryRxPhyStatus8190Pci */
10775 #endif
10776
10777 void
10778 rtl8192_record_rxdesc_forlateruse(
10779 struct ieee80211_rx_stats * psrc_stats,
10780 struct ieee80211_rx_stats * ptarget_stats
10781 )
10782 {
10783 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
10784 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
10785 ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
10786 }
10787
10788 #ifdef RTL8192SU
10789 static void rtl8192SU_query_rxphystatus(
10790 struct r8192_priv * priv,
10791 struct ieee80211_rx_stats * pstats,
10792 rx_desc_819x_usb *pDesc,
10793 rx_drvinfo_819x_usb * pdrvinfo,
10794 struct ieee80211_rx_stats * precord_stats,
10795 bool bpacket_match_bssid,
10796 bool bpacket_toself,
10797 bool bPacketBeacon,
10798 bool bToSelfBA
10799 );
10800 void rtl8192SU_TranslateRxSignalStuff(struct sk_buff *skb,
10801 struct ieee80211_rx_stats * pstats,
10802 rx_desc_819x_usb *pDesc,
10803 rx_drvinfo_819x_usb *pdrvinfo)
10804 {
10805 // TODO: We must only check packet for current MAC address. Not finish
10806 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
10807 struct net_device *dev=info->dev;
10808 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
10809 bool bpacket_match_bssid, bpacket_toself;
10810 bool bPacketBeacon=FALSE, bToSelfBA=FALSE;
10811 static struct ieee80211_rx_stats previous_stats;
10812 struct ieee80211_hdr_3addr *hdr;//by amy
10813 u16 fc,type;
10814
10815 // Get Signal Quality for only RX data queue (but not command queue)
10816
10817 u8* tmp_buf;
10818 //u16 tmp_buf_len = 0;
10819 u8 *praddr;
10820
10821 /* Get MAC frame start address. */
10822 tmp_buf = (u8*)skb->data;// + get_rxpacket_shiftbytes_819xusb(pstats);
10823
10824 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
10825 fc = le16_to_cpu(hdr->frame_ctl);
10826 type = WLAN_FC_GET_TYPE(fc);
10827 praddr = hdr->addr1;
10828
10829 /* Check if the received packet is acceptabe. */
10830 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
10831 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
10832 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
10833 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
10834
10835 #if 1//cosa
10836 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
10837 {
10838 bPacketBeacon = true;
10839 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
10840 }
10841 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
10842 {
10843 if((eqMacAddr(praddr,dev->dev_addr)))
10844 bToSelfBA = true;
10845 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
10846 }
10847
10848 #endif
10849
10850
10851 if(bpacket_match_bssid)
10852 {
10853 priv->stats.numpacket_matchbssid++;
10854 }
10855 if(bpacket_toself){
10856 priv->stats.numpacket_toself++;
10857 }
10858 //
10859 // Process PHY information for previous packet (RSSI/PWDB/EVM)
10860 //
10861 // Because phy information is contained in the last packet of AMPDU only, so driver
10862 // should process phy information of previous packet
10863 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
10864 rtl8192SU_query_rxphystatus(priv, pstats, pDesc, pdrvinfo, &previous_stats, bpacket_match_bssid,bpacket_toself,bPacketBeacon,bToSelfBA);
10865 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
10866
10867 }
10868 #else
10869 void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
10870 struct ieee80211_rx_stats * pstats,
10871 rx_drvinfo_819x_usb *pdrvinfo)
10872 {
10873 // TODO: We must only check packet for current MAC address. Not finish
10874 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
10875 struct net_device *dev=info->dev;
10876 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
10877 bool bpacket_match_bssid, bpacket_toself;
10878 bool bPacketBeacon=FALSE, bToSelfBA=FALSE;
10879 static struct ieee80211_rx_stats previous_stats;
10880 struct ieee80211_hdr_3addr *hdr;//by amy
10881 u16 fc,type;
10882
10883 // Get Signal Quality for only RX data queue (but not command queue)
10884
10885 u8* tmp_buf;
10886 //u16 tmp_buf_len = 0;
10887 u8 *praddr;
10888
10889 /* Get MAC frame start address. */
10890 tmp_buf = (u8*)skb->data;// + get_rxpacket_shiftbytes_819xusb(pstats);
10891
10892 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
10893 fc = le16_to_cpu(hdr->frame_ctl);
10894 type = WLAN_FC_GET_TYPE(fc);
10895 praddr = hdr->addr1;
10896
10897 /* Check if the received packet is acceptabe. */
10898 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
10899 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
10900 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
10901 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
10902
10903 #if 1//cosa
10904 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
10905 {
10906 bPacketBeacon = true;
10907 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
10908 }
10909 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
10910 {
10911 if((eqMacAddr(praddr,dev->dev_addr)))
10912 bToSelfBA = true;
10913 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
10914 }
10915
10916 #endif
10917
10918
10919 if(bpacket_match_bssid)
10920 {
10921 priv->stats.numpacket_matchbssid++;
10922 }
10923 if(bpacket_toself){
10924 priv->stats.numpacket_toself++;
10925 }
10926 //
10927 // Process PHY information for previous packet (RSSI/PWDB/EVM)
10928 //
10929 // Because phy information is contained in the last packet of AMPDU only, so driver
10930 // should process phy information of previous packet
10931 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
10932 rtl8192_query_rxphystatus(priv, pstats, pdrvinfo, &previous_stats, bpacket_match_bssid,bpacket_toself,bPacketBeacon,bToSelfBA);
10933 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
10934
10935 }
10936 #endif
10937
10938 /**
10939 * Function: UpdateReceivedRateHistogramStatistics
10940 * Overview: Recored down the received data rate
10941 *
10942 * Input:
10943 * struct net_device *dev
10944 * struct ieee80211_rx_stats *stats
10945 *
10946 * Output:
10947 *
10948 * (priv->stats.ReceivedRateHistogram[] is updated)
10949 * Return:
10950 * None
10951 */
10952 void
10953 UpdateReceivedRateHistogramStatistics8190(
10954 struct net_device *dev,
10955 struct ieee80211_rx_stats *stats
10956 )
10957 {
10958 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
10959 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
10960 u32 rateIndex;
10961 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
10962
10963
10964 if(stats->bCRC)
10965 rcvType = 2;
10966 else if(stats->bICV)
10967 rcvType = 3;
10968
10969 if(stats->bShortPreamble)
10970 preamble_guardinterval = 1;// short
10971 else
10972 preamble_guardinterval = 0;// long
10973
10974 switch(stats->rate)
10975 {
10976 //
10977 // CCK rate
10978 //
10979 case MGN_1M: rateIndex = 0; break;
10980 case MGN_2M: rateIndex = 1; break;
10981 case MGN_5_5M: rateIndex = 2; break;
10982 case MGN_11M: rateIndex = 3; break;
10983 //
10984 // Legacy OFDM rate
10985 //
10986 case MGN_6M: rateIndex = 4; break;
10987 case MGN_9M: rateIndex = 5; break;
10988 case MGN_12M: rateIndex = 6; break;
10989 case MGN_18M: rateIndex = 7; break;
10990 case MGN_24M: rateIndex = 8; break;
10991 case MGN_36M: rateIndex = 9; break;
10992 case MGN_48M: rateIndex = 10; break;
10993 case MGN_54M: rateIndex = 11; break;
10994 //
10995 // 11n High throughput rate
10996 //
10997 case MGN_MCS0: rateIndex = 12; break;
10998 case MGN_MCS1: rateIndex = 13; break;
10999 case MGN_MCS2: rateIndex = 14; break;
11000 case MGN_MCS3: rateIndex = 15; break;
11001 case MGN_MCS4: rateIndex = 16; break;
11002 case MGN_MCS5: rateIndex = 17; break;
11003 case MGN_MCS6: rateIndex = 18; break;
11004 case MGN_MCS7: rateIndex = 19; break;
11005 case MGN_MCS8: rateIndex = 20; break;
11006 case MGN_MCS9: rateIndex = 21; break;
11007 case MGN_MCS10: rateIndex = 22; break;
11008 case MGN_MCS11: rateIndex = 23; break;
11009 case MGN_MCS12: rateIndex = 24; break;
11010 case MGN_MCS13: rateIndex = 25; break;
11011 case MGN_MCS14: rateIndex = 26; break;
11012 case MGN_MCS15: rateIndex = 27; break;
11013 default: rateIndex = 28; break;
11014 }
11015 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
11016 priv->stats.received_rate_histogram[0][rateIndex]++; //total
11017 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
11018 }
11019
11020 #ifdef RTL8192SU
11021 void rtl8192SU_query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe)
11022 {
11023 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
11024 struct net_device *dev=info->dev;
11025 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
11026 //rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
11027 rx_drvinfo_819x_usb *driver_info = NULL;
11028
11029 //PRT_RFD_STATUS pRtRfdStatus = &pRfd->Status;
11030 //PHAL_DATA_8192SUSB pHalData = GET_HAL_DATA(Adapter);
11031 //pu1Byte pDesc = (pu1Byte)pDescIn;
11032 //PRX_DRIVER_INFO_8192S pDrvInfo;
11033
11034 #ifdef USB_RX_AGGREGATION_SUPPORT//FIXLZM
11035 //if (bIsRxAggrSubframe)
11036 rx_desc_819x_usb_aggr_subframe *desc = (rx_desc_819x_usb_aggr_subframe *)skb->data;
11037 else
11038 #endif
11039 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
11040
11041 if(0)
11042 {
11043 int m = 0;
11044 printk("========================");
11045 for(m=0; m<skb->len; m++){
11046 if((m%32) == 0)
11047 printk("\n");
11048 printk("%2x ",((u8*)skb->data)[m]);
11049 }
11050 printk("\n========================\n");
11051
11052 }
11053
11054
11055 //
11056 //Get Rx Descriptor Raw Information
11057 //
11058 stats->Length = desc->Length ;
11059 stats->RxDrvInfoSize = desc->RxDrvInfoSize*RX_DRV_INFO_SIZE_UNIT;
11060 stats->RxBufShift = (desc->Shift)&0x03;
11061 stats->bICV = desc->ICV;
11062 stats->bCRC = desc->CRC32;
11063 stats->bHwError = stats->bCRC|stats->bICV;
11064 stats->Decrypted = !desc->SWDec;//RTL8190 set this bit to indicate that Hw does not decrypt packet
11065 stats->bIsAMPDU = (desc->AMSDU==1);
11066 stats->bFirstMPDU = (desc->PAGGR==1) && (desc->FAGGR==1);
11067 stats->bShortPreamble = desc->SPLCP;
11068 stats->RxIs40MHzPacket = (desc->BW==1);
11069 stats->TimeStampLow = desc->TSFL;
11070
11071 if((desc->FAGGR==1) || (desc->PAGGR==1))
11072 {// Rx A-MPDU
11073 RT_TRACE(COMP_RXDESC, "FirstAGGR = %d, PartAggr = %d\n", desc->FAGGR, desc->PAGGR);
11074 }
11075 //YJ,test,090310
11076 if(stats->bHwError)
11077 {
11078 if(stats->bICV)
11079 printk("%s: Receive ICV error!!!!!!!!!!!!!!!!!!!!!!\n", __FUNCTION__);
11080 if(stats->bCRC)
11081 printk("%s: Receive CRC error!!!!!!!!!!!!!!!!!!!!!!\n", __FUNCTION__);
11082 }
11083
11084 if(IS_UNDER_11N_AES_MODE(priv->ieee80211))
11085 {
11086 // Always received ICV error packets in AES mode.
11087 // This fixed HW later MIC write bug.
11088 if(stats->bICV && !stats->bCRC)
11089 {
11090 stats->bICV = FALSE;
11091 stats->bHwError = FALSE;
11092 }
11093 }
11094
11095 // Transform HwRate to MRate
11096 if(!stats->bHwError)
11097 //stats->DataRate = HwRateToMRate(
11098 // (BOOLEAN)GET_RX_DESC_RXHT(pDesc),
11099 // (u1Byte)GET_RX_DESC_RXMCS(pDesc),
11100 // (BOOLEAN)GET_RX_DESC_PAGGR(pDesc));
11101 stats->rate = rtl8192SU_HwRateToMRate(desc->RxHT, desc->RxMCS, desc->PAGGR);
11102 else
11103 stats->rate = MGN_1M;
11104
11105 //
11106 // Collect Rx rate/AMPDU/TSFL
11107 //
11108 //UpdateRxdRateHistogramStatistics8192S(Adapter, pRfd);
11109 //UpdateRxAMPDUHistogramStatistics8192S(Adapter, pRfd);
11110 //UpdateRxPktTimeStamp8192S(Adapter, pRfd);
11111 UpdateReceivedRateHistogramStatistics8190(dev, stats);
11112 //UpdateRxAMPDUHistogramStatistics8192S(dev, stats); //FIXLZM
11113 UpdateRxPktTimeStamp8190(dev, stats);
11114
11115 //
11116 // Get PHY Status and RSVD parts.
11117 // <Roger_Notes> It only appears on last aggregated packet.
11118 //
11119 if (desc->PHYStatus)
11120 {
11121 //driver_info = (rx_drvinfo_819x_usb *)(skb->data + RX_DESC_SIZE + stats->RxBufShift);
11122 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) + \
11123 stats->RxBufShift);
11124 if(0)
11125 {
11126 int m = 0;
11127 printk("========================\n");
11128 printk("RX_DESC_SIZE:%d, RxBufShift:%d, RxDrvInfoSize:%d\n",
11129 RX_DESC_SIZE, stats->RxBufShift, stats->RxDrvInfoSize);
11130 for(m=0; m<32; m++){
11131 printk("%2x ",((u8*)driver_info)[m]);
11132 }
11133 printk("\n========================\n");
11134
11135 }
11136
11137 }
11138
11139 //YJ,add,090107
11140 skb_pull(skb, sizeof(rx_desc_819x_usb));
11141 //YJ,add,090107,end
11142
11143 //
11144 // Get Total offset of MPDU Frame Body
11145 //
11146 if((stats->RxBufShift + stats->RxDrvInfoSize) > 0)
11147 {
11148 stats->bShift = 1;
11149 //YJ,add,090107
11150 skb_pull(skb, stats->RxBufShift + stats->RxDrvInfoSize);
11151 //YJ,add,090107,end
11152 }
11153
11154 //
11155 // Get PHY Status and RSVD parts.
11156 // <Roger_Notes> It only appears on last aggregated packet.
11157 //
11158 if (desc->PHYStatus)
11159 {
11160 rtl8192SU_TranslateRxSignalStuff(skb, stats, desc, driver_info);
11161 }
11162 }
11163 #else
11164 void query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe)
11165 {
11166 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
11167 struct net_device *dev=info->dev;
11168 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
11169 //rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
11170 rx_drvinfo_819x_usb *driver_info = NULL;
11171
11172 //
11173 //Get Rx Descriptor Information
11174 //
11175 #ifdef USB_RX_AGGREGATION_SUPPORT
11176 if (bIsRxAggrSubframe)
11177 {
11178 rx_desc_819x_usb_aggr_subframe *desc = (rx_desc_819x_usb_aggr_subframe *)skb->data;
11179 stats->Length = desc->Length ;
11180 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
11181 stats->RxBufShift = 0; //RxBufShift = 2 in RxDesc, but usb didn't shift bytes in fact.
11182 stats->bICV = desc->ICV;
11183 stats->bCRC = desc->CRC32;
11184 stats->bHwError = stats->bCRC|stats->bICV;
11185 stats->Decrypted = !desc->SWDec;//RTL8190 set this bit to indicate that Hw does not decrypt packet
11186 } else
11187 #endif
11188 {
11189 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
11190
11191 stats->Length = desc->Length;
11192 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
11193 stats->RxBufShift = 0;//desc->Shift&0x03;
11194 stats->bICV = desc->ICV;
11195 stats->bCRC = desc->CRC32;
11196 stats->bHwError = stats->bCRC|stats->bICV;
11197 //RTL8190 set this bit to indicate that Hw does not decrypt packet
11198 stats->Decrypted = !desc->SWDec;
11199 }
11200
11201 if((priv->ieee80211->pHTInfo->bCurrentHTSupport == true) && (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP))
11202 {
11203 stats->bHwError = false;
11204 }
11205 else
11206 {
11207 stats->bHwError = stats->bCRC|stats->bICV;
11208 }
11209
11210 if(stats->Length < 24 || stats->Length > MAX_8192U_RX_SIZE)
11211 stats->bHwError |= 1;
11212 //
11213 //Get Driver Info
11214 //
11215 // TODO: Need to verify it on FGPA platform
11216 //Driver info are written to the RxBuffer following rx desc
11217 if (stats->RxDrvInfoSize != 0) {
11218 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) + \
11219 stats->RxBufShift);
11220 /* unit: 0.5M */
11221 /* TODO */
11222 if(!stats->bHwError){
11223 u8 ret_rate;
11224 ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
11225 if(ret_rate == 0xff)
11226 {
11227 // Abnormal Case: Receive CRC OK packet with Rx descriptor indicating non supported rate.
11228 // Special Error Handling here, 2008.05.16, by Emily
11229
11230 stats->bHwError = 1;
11231 stats->rate = MGN_1M; //Set 1M rate by default
11232 }else
11233 {
11234 stats->rate = ret_rate;
11235 }
11236 }
11237 else
11238 stats->rate = 0x02;
11239
11240 stats->bShortPreamble = driver_info->SPLCP;
11241
11242
11243 UpdateReceivedRateHistogramStatistics8190(dev, stats);
11244
11245 stats->bIsAMPDU = (driver_info->PartAggr==1);
11246 stats->bFirstMPDU = (driver_info->PartAggr==1) && (driver_info->FirstAGGR==1);
11247 #if 0
11248 // TODO: it is debug only. It should be disabled in released driver. 2007.1.12 by Joseph
11249 UpdateRxAMPDUHistogramStatistics8190(Adapter, pRfd);
11250 #endif
11251 stats->TimeStampLow = driver_info->TSFL;
11252 // xiong mask it, 070514
11253 //pRfd->Status.TimeStampHigh = PlatformEFIORead4Byte(Adapter, TSFR+4);
11254 // stats->TimeStampHigh = read_nic_dword(dev, TSFR+4);
11255
11256 UpdateRxPktTimeStamp8190(dev, stats);
11257
11258 //
11259 // Rx A-MPDU
11260 //
11261 if(driver_info->FirstAGGR==1 || driver_info->PartAggr == 1)
11262 RT_TRACE(COMP_RXDESC, "driver_info->FirstAGGR = %d, driver_info->PartAggr = %d\n",
11263 driver_info->FirstAGGR, driver_info->PartAggr);
11264
11265 }
11266
11267 skb_pull(skb,sizeof(rx_desc_819x_usb));
11268 //
11269 // Get Total offset of MPDU Frame Body
11270 //
11271 if((stats->RxBufShift + stats->RxDrvInfoSize) > 0) {
11272 stats->bShift = 1;
11273 skb_pull(skb,stats->RxBufShift + stats->RxDrvInfoSize);
11274 }
11275
11276 #ifdef USB_RX_AGGREGATION_SUPPORT
11277 /* for the rx aggregated sub frame, the redundant space truelly contained in the packet */
11278 if(bIsRxAggrSubframe) {
11279 skb_pull(skb, 8);
11280 }
11281 #endif
11282 /* for debug 2008.5.29 */
11283 #if 0
11284 {
11285 int i;
11286 printk("\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
11287 for(i = 0; i < skb->len; i++) {
11288 if(i % 10 == 0) printk("\n");
11289 printk("%02x ", skb->data[i]);
11290 }
11291 printk("\n<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n");
11292 }
11293 #endif
11294
11295 //added by vivi, for MP, 20080108
11296 stats->RxIs40MHzPacket = driver_info->BW;
11297 if(stats->RxDrvInfoSize != 0)
11298 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
11299
11300 }
11301 #endif
11302
11303 #ifdef RTL8192SU
11304 #if 0
11305 /*-----------------------------------------------------------------------------
11306 * Function: UpdateRxAMPDUHistogramStatistics8192S
11307 *
11308 * Overview: Recored down the received A-MPDU aggregation size and pkt number
11309 *
11310 * Input: Adapter
11311 *
11312 * Output: Adapter
11313 * (Adapter->RxStats.RxAMPDUSizeHistogram[] is updated)
11314 * (Adapter->RxStats.RxAMPDUNumHistogram[] is updated)
11315 *
11316 * Return: NONE
11317 *
11318 * Revised History:
11319 * When Who Remark
11320 * 09/18/2008 MHC Create Version 0.
11321 *
11322 *---------------------------------------------------------------------------*/
11323 static void
11324 UpdateRxAMPDUHistogramStatistics8192S(
11325 struct net_device *dev,
11326 struct ieee80211_rx_stats *stats
11327 )
11328 {
11329 //HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
11330 u8 size_index;
11331 u8 num_index;
11332 u16 update_size = 0;
11333 u8 update_num = 0;
11334
11335 if(stats->bIsAMPDU)
11336 {
11337 if(stats->bFirstMPDU)
11338 {
11339 if(stats->nRxAMPDU_Size!=0 && stats->nRxAMPDU_AggrNum!=0)
11340 {
11341 update_size = stats->nRxAMPDU_Size;
11342 update_num = stats->nRxAMPDU_AggrNum;
11343 }
11344 stats->nRxAMPDU_Size = stats->Length;
11345 stats->nRxAMPDU_AggrNum = 1;
11346 }
11347 else
11348 {
11349 stats->nRxAMPDU_Size += stats->Length;
11350 stats->nRxAMPDU_AggrNum++;
11351 }
11352 }
11353 else
11354 {
11355 if(stats->nRxAMPDU_Size!=0 && stats->nRxAMPDU_AggrNum!=0)
11356 {
11357 update_size = stats->nRxAMPDU_Size;
11358 update_num = stats->nRxAMPDU_AggrNum;
11359 }
11360 stats->nRxAMPDU_Size = 0;
11361 stats->nRxAMPDU_AggrNum = 0;
11362 }
11363
11364 if(update_size!=0 && update_num!= 0)
11365 {
11366 if(update_size < 4096)
11367 size_index = 0;
11368 else if(update_size < 8192)
11369 size_index = 1;
11370 else if(update_size < 16384)
11371 size_index = 2;
11372 else if(update_size < 32768)
11373 size_index = 3;
11374 else if(update_size < 65536)
11375 size_index = 4;
11376 else
11377 {
11378 RT_TRACE(COMP_RXDESC,
11379 ("UpdateRxAMPDUHistogramStatistics8192S(): A-MPDU too large\n");
11380 }
11381
11382 Adapter->RxStats.RxAMPDUSizeHistogram[size_index]++;
11383
11384 if(update_num < 5)
11385 num_index = 0;
11386 else if(update_num < 10)
11387 num_index = 1;
11388 else if(update_num < 20)
11389 num_index = 2;
11390 else if(update_num < 40)
11391 num_index = 3;
11392 else
11393 num_index = 4;
11394
11395 Adapter->RxStats.RxAMPDUNumHistogram[num_index]++;
11396 }
11397 } // UpdateRxAMPDUHistogramStatistics8192S
11398 #endif
11399
11400 #endif
11401
11402
11403 #ifdef RTL8192SU
11404 //
11405 // Description:
11406 // The strarting address of wireless lan header will shift 1 or 2 or 3 or "more" bytes for the following reason :
11407 // (1) QoS control : shift 2 bytes
11408 // (2) Mesh Network : shift 1 or 3 bytes
11409 // (3) RxDriverInfo occupies the front parts of Rx Packets buffer(shift units is in 8Bytes)
11410 //
11411 // It is because Lextra CPU used by 8186 or 865x series assert exception if the statrting address
11412 // of IP header is not double word alignment.
11413 // This features is supported in 818xb and 8190 only, but not 818x.
11414 //
11415 // parameter: PRT_RFD, Pointer of Reeceive frame descriptor which is initialized according to
11416 // Rx Descriptor
11417 // return value: unsigned int, number of total shifted bytes
11418 //
11419 // Notes: 2008/06/28, created by Roger
11420 //
11421 u32 GetRxPacketShiftBytes8192SU(struct ieee80211_rx_stats *Status, bool bIsRxAggrSubframe)
11422 {
11423 //PRT_RFD_STATUS pRtRfdStatus = &pRfd->Status;
11424
11425 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize + Status->RxBufShift);
11426 }
11427
11428 void rtl8192SU_rx_nomal(struct sk_buff* skb)
11429 {
11430 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
11431 struct net_device *dev=info->dev;
11432 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
11433 struct ieee80211_rx_stats stats = {
11434 .signal = 0,
11435 .noise = -98,
11436 .rate = 0,
11437 // .mac_time = jiffies,
11438 .freq = IEEE80211_24GHZ_BAND,
11439 };
11440 u32 rx_pkt_len = 0;
11441 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
11442 bool unicast_packet = false;
11443
11444 #ifdef USB_RX_AGGREGATION_SUPPORT
11445 struct sk_buff *agg_skb = NULL;
11446 u32 TotalLength = 0;//Total packet length for all aggregated packets.
11447 u32 TempDWord = 0;
11448 u32 PacketLength = 0;// Per-packet length include size of RxDesc.
11449 u32 PacketOccupiedLendth = 0;
11450 u8 TempByte = 0;
11451 u32 PacketShiftBytes = 0;
11452 rx_desc_819x_usb_aggr_subframe *RxDescr = NULL;
11453 u8 PaddingBytes = 0;
11454 //add just for testing
11455 u8 testing;
11456
11457 u8 TotalAggPkt = 0;
11458 PRT_HIGH_THROUGHPUT pHTInfo =priv-> ieee80211->pHTInfo;
11459 u16 RxPageSize = pHTInfo->UsbRxPageSize;
11460
11461 stats->nTotalAggPkt = 0;
11462 //stats->bIsRxAggrSubframe = FALSE;
11463
11464 #endif
11465 //printk("**********skb->len = %d\n", skb->len);
11466 /* 20 is for ps-poll */
11467 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
11468
11469 /* first packet should not contain Rx aggregation header */
11470 rtl8192SU_query_rxdesc_status(skb, &stats, false);
11471 /* TODO */
11472
11473 /* hardware related info */
11474 #ifdef USB_RX_AGGREGATION_SUPPORT
11475 TotalAggPkt = stats->nTotalAggPkt;
11476 PacketLength = stats->Length + GetRxPacketShiftBytes8192SU(&stats, false);
11477
11478 agg_skb = skb;
11479 skb = dev_alloc_skb(PacketLength);
11480 memcpy(skb_put(skb,PacketLength),agg_skb->data,PacketLength);
11481 #endif
11482 priv->stats.rxoktotal++; //YJ,test,090108
11483
11484 /* Process the MPDU recevied */
11485 skb_trim(skb, skb->len - 4/*sCrcLng*/);//FIXLZM
11486
11487 rx_pkt_len = skb->len;
11488 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
11489 unicast_packet = false;
11490 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
11491 //TODO
11492 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
11493 //TODO
11494 }else {
11495 /* unicast packet */
11496 unicast_packet = true;
11497 }
11498
11499 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
11500 dev_kfree_skb_any(skb);
11501 } else {
11502 // priv->stats.rxoktotal++; //YJ,test,090108
11503 if(unicast_packet) {
11504 priv->stats.rxbytesunicast += rx_pkt_len;
11505 }
11506 }
11507
11508 //up is firs pkt, follow is next and next
11509 #ifdef USB_RX_AGGREGATION_SUPPORT
11510 //
11511 // The following operations are for processing Rx aggregated packets.
11512 //
11513 if(TotalAggPkt>0)
11514 TotalAggPkt--;
11515
11516 while ( TotalAggPkt>0 )
11517 {// More aggregated packets need to process.
11518
11519 u8 tmpCRC = 0, tmpICV = 0;
11520
11521 //Page size must align to multiple of 128-Bytes.
11522 if((PacketLength%RxPageSize) != 0)
11523 //PacketLength = ((PacketLength/RxPageSize)+1)*RxPageSize;
11524 PacketLength = ((PacketLength>>7)+1)*RxPageSize; // RxPageSize is 128bytes as default.
11525
11526 // Current total packet occupied length in this buffer.
11527 PacketOccupiedLendth += PacketLength;
11528
11529 #if (defined (RTL8192SU_FPGA_2MAC_VERIFICATION)||defined (RTL8192SU_ASIC_VERIFICATION))
11530 //if(PacketOccupiedLendth>pContext->BufLenUsed)
11531 if(PacketOccupiedLendth>skb->len)
11532 {
11533 RT_TRACE(COMP_RECV, "(1)HalUsbInMpduComplete8192SUsb(): pRtRfdStatus->Length(%#x)!!\n", stats->Length);
11534 RT_TRACE(COMP_RECV, "(1)HalUsbInMpduComplete8192SUsb(): Invalid PacketOccupiedLendth(%#x)!!, BufLenUsed(%#x)\n", PacketOccupiedLendth, stats->BufLenUsed);
11535 break;
11536 }
11537 #endif
11538
11539 skb_pull(agg_skb, PacketLength);
11540
11541 //
11542 // Process the MPDU recevied.
11543 //
11544 //RT_TRACE(COMP_RECV,"%s:aggred pkt,total_len = %d\n",__FUNCTION__,agg_skb->len);
11545 RxDescr = (rx_desc_819x_usb_aggr_subframe *)(agg_skb->data);
11546
11547 #if 0//92SU del
11548 tmpCRC = RxDescr->CRC32;
11549 tmpICV = RxDescr->ICV;
11550 memcpy(agg_skb->data, &agg_skb->data[44], 2);
11551 RxDescr->CRC32 = tmpCRC;
11552 RxDescr->ICV = tmpICV;
11553 #endif
11554 memset(&stats, 0, sizeof(struct ieee80211_rx_stats));
11555 stats.signal = 0;
11556 stats.noise = -98;
11557 stats.rate = 0;
11558 stats.freq = IEEE80211_24GHZ_BAND;
11559
11560 rtl8192SU_query_rxdesc_status(agg_skb, &stats, true);
11561 //PacketLength = stats.Length;
11562 PacketLength = stats.Length + GetRxPacketShiftBytes8192SU(&stats, true);
11563
11564 #if (defined (RTL8192SU_FPGA_2MAC_VERIFICATION)||defined (RTL8192SU_ASIC_VERIFICATION))
11565 if((PacketOccupiedLendth+PacketLength)>skb->len)
11566 {
11567 RT_TRACE(COMP_RECV, "(2)HalUsbInMpduComplete8192SUsb(): Invalid PacketOccupiedLendth(%#x)+PacketLength(%#x)!!, BufLenUsed(%#x)\n",
11568 PacketOccupiedLendth, PacketLength, pContext->BufLenUsed);
11569 break;
11570 }
11571 #endif
11572
11573 if(PacketLength > agg_skb->len) {
11574 break;
11575 }
11576
11577 /* Process the MPDU recevied */
11578 skb = dev_alloc_skb(PacketLength);
11579 memcpy(skb_put(skb,PacketLength),agg_skb->data, PacketLength);
11580 skb_trim(skb, skb->len - 4/*sCrcLng*/);
11581
11582 rx_pkt_len = skb->len;
11583 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
11584 unicast_packet = false;
11585 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
11586 //TODO
11587 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
11588 //TODO
11589 }else {
11590 /* unicast packet */
11591 unicast_packet = true;
11592 }
11593 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
11594 dev_kfree_skb_any(skb);
11595 } else {
11596 priv->stats.rxoktotal++;
11597 if(unicast_packet) {
11598 priv->stats.rxbytesunicast += rx_pkt_len;
11599 }
11600 }
11601
11602 TotalAggPkt--;
11603
11604 skb_pull(agg_skb, TempDWord);
11605 }
11606
11607 dev_kfree_skb(agg_skb);
11608 #endif
11609 }
11610 else
11611 {
11612 priv->stats.rxurberr++;
11613 printk("actual_length:%d\n", skb->len);
11614 dev_kfree_skb_any(skb);
11615 }
11616
11617 }
11618 #else
11619 u32 GetRxPacketShiftBytes819xUsb(struct ieee80211_rx_stats *Status, bool bIsRxAggrSubframe)
11620 {
11621 #ifdef USB_RX_AGGREGATION_SUPPORT
11622 if (bIsRxAggrSubframe)
11623 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
11624 + Status->RxBufShift + 8);
11625 else
11626 #endif
11627 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
11628 + Status->RxBufShift);
11629 }
11630
11631 void rtl8192_rx_nomal(struct sk_buff* skb)
11632 {
11633 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
11634 struct net_device *dev=info->dev;
11635 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
11636 struct ieee80211_rx_stats stats = {
11637 .signal = 0,
11638 .noise = -98,
11639 .rate = 0,
11640 // .mac_time = jiffies,
11641 .freq = IEEE80211_24GHZ_BAND,
11642 };
11643 u32 rx_pkt_len = 0;
11644 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
11645 bool unicast_packet = false;
11646 #ifdef USB_RX_AGGREGATION_SUPPORT
11647 struct sk_buff *agg_skb = NULL;
11648 u32 TotalLength = 0;
11649 u32 TempDWord = 0;
11650 u32 PacketLength = 0;
11651 u32 PacketOccupiedLendth = 0;
11652 u8 TempByte = 0;
11653 u32 PacketShiftBytes = 0;
11654 rx_desc_819x_usb_aggr_subframe *RxDescr = NULL;
11655 u8 PaddingBytes = 0;
11656 //add just for testing
11657 u8 testing;
11658
11659 #endif
11660
11661 /* 20 is for ps-poll */
11662 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
11663 #ifdef USB_RX_AGGREGATION_SUPPORT
11664 TempByte = *(skb->data + sizeof(rx_desc_819x_usb));
11665 #endif
11666 /* first packet should not contain Rx aggregation header */
11667 query_rxdesc_status(skb, &stats, false);
11668 /* TODO */
11669 /* hardware related info */
11670 #ifdef USB_RX_AGGREGATION_SUPPORT
11671 if (TempByte & BIT0) {
11672 agg_skb = skb;
11673 //TotalLength = agg_skb->len - 4; /*sCrcLng*/
11674 TotalLength = stats.Length - 4; /*sCrcLng*/
11675 //RT_TRACE(COMP_RECV, "%s:first aggregated packet!Length=%d\n",__FUNCTION__,TotalLength);
11676 /* though the head pointer has passed this position */
11677 TempDWord = *(u32 *)(agg_skb->data - 4);
11678 PacketLength = (u16)(TempDWord & 0x3FFF); /*sCrcLng*/
11679 skb = dev_alloc_skb(PacketLength);
11680 memcpy(skb_put(skb,PacketLength),agg_skb->data,PacketLength);
11681 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, false);
11682 }
11683 #endif
11684 /* Process the MPDU recevied */
11685 skb_trim(skb, skb->len - 4/*sCrcLng*/);
11686
11687 rx_pkt_len = skb->len;
11688 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
11689 unicast_packet = false;
11690 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
11691 //TODO
11692 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
11693 //TODO
11694 }else {
11695 /* unicast packet */
11696 unicast_packet = true;
11697 }
11698
11699 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
11700 dev_kfree_skb_any(skb);
11701 } else {
11702 priv->stats.rxoktotal++;
11703 if(unicast_packet) {
11704 priv->stats.rxbytesunicast += rx_pkt_len;
11705 }
11706 }
11707 #ifdef USB_RX_AGGREGATION_SUPPORT
11708 testing = 1;
11709 // (PipeIndex == 0) && (TempByte & BIT0) => TotalLength > 0.
11710 if (TotalLength > 0) {
11711 PacketOccupiedLendth = PacketLength + (PacketShiftBytes + 8);
11712 if ((PacketOccupiedLendth & 0xFF) != 0)
11713 PacketOccupiedLendth = (PacketOccupiedLendth & 0xFFFFFF00) + 256;
11714 PacketOccupiedLendth -= 8;
11715 TempDWord = PacketOccupiedLendth - PacketShiftBytes; /*- PacketLength */
11716 if (agg_skb->len > TempDWord)
11717 skb_pull(agg_skb, TempDWord);
11718 else
11719 agg_skb->len = 0;
11720
11721 while (agg_skb->len>=GetRxPacketShiftBytes819xUsb(&stats, true)) {
11722 u8 tmpCRC = 0, tmpICV = 0;
11723 //RT_TRACE(COMP_RECV,"%s:aggred pkt,total_len = %d\n",__FUNCTION__,agg_skb->len);
11724 RxDescr = (rx_desc_819x_usb_aggr_subframe *)(agg_skb->data);
11725 tmpCRC = RxDescr->CRC32;
11726 tmpICV = RxDescr->ICV;
11727 memcpy(agg_skb->data, &agg_skb->data[44], 2);
11728 RxDescr->CRC32 = tmpCRC;
11729 RxDescr->ICV = tmpICV;
11730
11731 memset(&stats, 0, sizeof(struct ieee80211_rx_stats));
11732 stats.signal = 0;
11733 stats.noise = -98;
11734 stats.rate = 0;
11735 stats.freq = IEEE80211_24GHZ_BAND;
11736 query_rxdesc_status(agg_skb, &stats, true);
11737 PacketLength = stats.Length;
11738
11739 if(PacketLength > agg_skb->len) {
11740 break;
11741 }
11742 /* Process the MPDU recevied */
11743 skb = dev_alloc_skb(PacketLength);
11744 memcpy(skb_put(skb,PacketLength),agg_skb->data, PacketLength);
11745 skb_trim(skb, skb->len - 4/*sCrcLng*/);
11746
11747 rx_pkt_len = skb->len;
11748 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
11749 unicast_packet = false;
11750 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
11751 //TODO
11752 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
11753 //TODO
11754 }else {
11755 /* unicast packet */
11756 unicast_packet = true;
11757 }
11758 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
11759 dev_kfree_skb_any(skb);
11760 } else {
11761 priv->stats.rxoktotal++;
11762 if(unicast_packet) {
11763 priv->stats.rxbytesunicast += rx_pkt_len;
11764 }
11765 }
11766 /* should trim the packet which has been copied to target skb */
11767 skb_pull(agg_skb, PacketLength);
11768 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, true);
11769 PacketOccupiedLendth = PacketLength + PacketShiftBytes;
11770 if ((PacketOccupiedLendth & 0xFF) != 0) {
11771 PaddingBytes = 256 - (PacketOccupiedLendth & 0xFF);
11772 if (agg_skb->len > PaddingBytes)
11773 skb_pull(agg_skb, PaddingBytes);
11774 else
11775 agg_skb->len = 0;
11776 }
11777 }
11778 dev_kfree_skb(agg_skb);
11779 }
11780 #endif
11781 } else {
11782 priv->stats.rxurberr++;
11783 printk("actual_length:%d\n", skb->len);
11784 dev_kfree_skb_any(skb);
11785 }
11786
11787 }
11788
11789 #endif
11790
11791 void
11792 rtl819xusb_process_received_packet(
11793 struct net_device *dev,
11794 struct ieee80211_rx_stats *pstats
11795 )
11796 {
11797 // bool bfreerfd=false, bqueued=false;
11798 u8* frame;
11799 u16 frame_len=0;
11800 struct r8192_priv *priv = ieee80211_priv(dev);
11801 // u8 index = 0;
11802 // u8 TID = 0;
11803 //u16 seqnum = 0;
11804 //PRX_TS_RECORD pts = NULL;
11805
11806 // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
11807 //porting by amy 080508
11808 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
11809 frame = pstats->virtual_address;
11810 frame_len = pstats->packetlength;
11811 #ifdef TODO // by amy about HCT
11812 if(!Adapter->bInHctTest)
11813 CountRxErrStatistics(Adapter, pRfd);
11814 #endif
11815 {
11816 #ifdef ENABLE_PS //by amy for adding ps function in future
11817 RT_RF_POWER_STATE rtState;
11818 // When RF is off, we should not count the packet for hw/sw synchronize
11819 // reason, ie. there may be a duration while sw switch is changed and hw
11820 // switch is being changed. 2006.12.04, by shien chang.
11821 Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8* )(&rtState));
11822 if (rtState == eRfOff)
11823 {
11824 return;
11825 }
11826 #endif
11827 priv->stats.rxframgment++;
11828
11829 }
11830 #ifdef TODO
11831 RmMonitorSignalStrength(Adapter, pRfd);
11832 #endif
11833 /* 2007/01/16 MH Add RX command packet handle here. */
11834 /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
11835 if (rtl819xusb_rx_command_packet(dev, pstats))
11836 {
11837 return;
11838 }
11839
11840 #ifdef SW_CRC_CHECK
11841 SwCrcCheck();
11842 #endif
11843
11844
11845 }
11846
11847 void query_rx_cmdpkt_desc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats)
11848 {
11849 // rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
11850 // struct net_device *dev=info->dev;
11851 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
11852 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
11853 // rx_drvinfo_819x_usb *driver_info;
11854
11855 //
11856 //Get Rx Descriptor Information
11857 //
11858 stats->virtual_address = (u8*)skb->data;
11859 stats->Length = desc->Length;
11860 stats->RxDrvInfoSize = 0;
11861 stats->RxBufShift = 0;
11862 stats->packetlength = stats->Length-scrclng;
11863 stats->fraglength = stats->packetlength;
11864 stats->fragoffset = 0;
11865 stats->ntotalfrag = 1;
11866 }
11867
11868 #ifdef RTL8192SU
11869 void rtl8192SU_rx_cmd(struct sk_buff *skb)
11870 {
11871 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
11872 struct net_device *dev = info->dev;
11873
11874 /* TODO */
11875 struct ieee80211_rx_stats stats = {
11876 .signal = 0,
11877 .noise = -98,
11878 .rate = 0,
11879 // .mac_time = jiffies,
11880 .freq = IEEE80211_24GHZ_BAND,
11881 };
11882
11883 //
11884 // Check buffer length to determine if this is a valid MPDU.
11885 //
11886 if( (skb->len >= sizeof(rx_desc_819x_usb)) && (skb->len <= RX_URB_SIZE) )//&&
11887 //(pHalData->SwChnlInProgress == FALSE))
11888 {
11889 //
11890 // Collection information in Rx descriptor.
11891 //
11892 #if 0
11893 pRxDesc = pContext->Buffer;
11894
11895 pRfd->Buffer.VirtualAddress = pContext->Buffer; // 061109, rcnjko, for multi-platform consideration..
11896
11897 pRtRfdStatus->Length = (u2Byte)GET_RX_DESC_PKT_LEN(pRxDesc);
11898 pRtRfdStatus->RxDrvInfoSize = 0;
11899 pRtRfdStatus->RxBufShift = 0;
11900
11901 pRfd->PacketLength = pRfd->Status.Length - sCrcLng;
11902 pRfd->FragLength = pRfd->PacketLength;
11903 pRfd->FragOffset = 0;
11904 pRfd->nTotalFrag = 1;
11905 pRfd->queue_id = PipeIndex;
11906 #endif
11907 query_rx_cmdpkt_desc_status(skb,&stats);
11908 // this is to be done by amy 080508 prfd->queue_id = 1;
11909
11910 //
11911 // Process the MPDU recevied.
11912 //
11913 rtl819xusb_process_received_packet(dev,&stats);
11914
11915 dev_kfree_skb_any(skb);
11916 }
11917 else
11918 {
11919 //RTInsertTailListWithCnt(&pAdapter->RfdIdleQueue, &pRfd->List, &pAdapter->NumIdleRfd);
11920 //RT_ASSERT(pAdapter->NumIdleRfd <= pAdapter->NumRfd, ("HalUsbInCommandComplete8192SUsb(): Adapter->NumIdleRfd(%d)\n", pAdapter->NumIdleRfd));
11921 //RT_TRACE(COMP_RECV, DBG_LOUD, ("HalUsbInCommandComplete8192SUsb(): NOT enough Resources!! BufLenUsed(%d), NumIdleRfd(%d)\n",
11922 //pContext->BufLenUsed, pAdapter->NumIdleRfd));
11923 }
11924
11925 //
11926 // Reuse USB_IN_CONTEXT since we had finished processing the
11927 // buffer in USB_IN_CONTEXT.
11928 //
11929 //HalUsbReturnInContext(pAdapter, pContext);
11930
11931 //
11932 // Issue another bulk IN transfer.
11933 //
11934 //HalUsbInMpdu(pAdapter, PipeIndex);
11935
11936 RT_TRACE(COMP_RECV, "<--- HalUsbInCommandComplete8192SUsb()\n");
11937
11938 }
11939 #else
11940 void rtl8192_rx_cmd(struct sk_buff *skb)
11941 {
11942 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
11943 struct net_device *dev = info->dev;
11944 //int ret;
11945 // struct urb *rx_urb = info->urb;
11946 /* TODO */
11947 struct ieee80211_rx_stats stats = {
11948 .signal = 0,
11949 .noise = -98,
11950 .rate = 0,
11951 // .mac_time = jiffies,
11952 .freq = IEEE80211_24GHZ_BAND,
11953 };
11954
11955 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE))
11956 {
11957
11958 query_rx_cmdpkt_desc_status(skb,&stats);
11959 // this is to be done by amy 080508 prfd->queue_id = 1;
11960
11961
11962 //
11963 // Process the command packet received.
11964 //
11965
11966 rtl819xusb_process_received_packet(dev,&stats);
11967
11968 dev_kfree_skb_any(skb);
11969 }
11970 else
11971 ;
11972
11973
11974 #if 0
11975 desc = (u32*)(skb->data);
11976 cmd = (desc[0] >> 30) & 0x03;
11977
11978 if(cmd == 0x00) {//beacon interrupt
11979 //send beacon packet
11980 skb = ieee80211_get_beacon(priv->ieee80211);
11981
11982 if(!skb){
11983 DMESG("not enought memory for allocating beacon");
11984 return;
11985 }
11986 skb->cb[0] = BEACON_PRIORITY;
11987 skb->cb[1] = 0;
11988 skb->cb[2] = ieeerate2rtlrate(priv->ieee80211->basic_rate);
11989 ret = rtl8192_tx(dev, skb);
11990
11991 if( ret != 0 ){
11992 printk(KERN_ALERT "tx beacon packet error : %d !\n", ret);
11993 }
11994 dev_kfree_skb_any(skb);
11995 } else {//0x00
11996 //{ log the device information
11997 // At present, It is not implemented just now.
11998 //}
11999 }
12000 #endif
12001 }
12002 #endif
12003
12004 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
12005 {
12006 struct sk_buff *skb;
12007 struct rtl8192_rx_info *info;
12008
12009 while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
12010 info = (struct rtl8192_rx_info *)skb->cb;
12011 switch (info->out_pipe) {
12012 /* Nomal packet pipe */
12013 case 3:
12014 //RT_TRACE(COMP_RECV, "normal in-pipe index(%d)\n",info->out_pipe);
12015 priv->IrpPendingCount--;
12016 priv->ops->rtl819x_rx_nomal(skb);
12017 break;
12018
12019 /* Command packet pipe */
12020 case 9:
12021 RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",\
12022 info->out_pipe);
12023 priv->ops->rtl819x_rx_cmd(skb);
12024 break;
12025
12026 default: /* should never get here! */
12027 RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",\
12028 info->out_pipe);
12029 dev_kfree_skb(skb);
12030 break;
12031
12032 }
12033 }
12034 }
12035
12036
12037
12038 /****************************************************************************
12039 ---------------------------- USB_STUFF---------------------------
12040 *****************************************************************************/
12041 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
12042 //LZM Merge from windows HalUsbSetQueuePipeMapping8192SUsb 090319
12043 static void HalUsbSetQueuePipeMapping8192SUsb(struct usb_interface *intf, struct net_device *dev)
12044 {
12045 struct r8192_priv *priv = ieee80211_priv(dev);
12046 struct usb_host_interface *iface_desc;
12047 struct usb_endpoint_descriptor *endpoint;
12048 u8 i = 0;
12049
12050 priv->ep_in_num = 0;
12051 priv->ep_out_num = 0;
12052 memset(priv->RtOutPipes,0,16);
12053 memset(priv->RtInPipes,0,16);
12054
12055 #ifndef USE_ONE_PIPE
12056 iface_desc = intf->cur_altsetting;
12057 priv->ep_num = iface_desc->desc.bNumEndpoints;
12058
12059 for (i = 0; i < priv->ep_num; ++i) {
12060 endpoint = &iface_desc->endpoint[i].desc;
12061 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
12062 if (usb_endpoint_is_bulk_in(endpoint)) {
12063 priv->RtInPipes[priv->ep_in_num] = usb_endpoint_num(endpoint);
12064 priv->ep_in_num ++;
12065 //printk("in_endpoint_idx = %d\n", usb_endpoint_num(endpoint));
12066 } else if (usb_endpoint_is_bulk_out(endpoint)) {
12067 priv->RtOutPipes[priv->ep_out_num] = usb_endpoint_num(endpoint);
12068 priv->ep_out_num ++;
12069 //printk("out_endpoint_idx = %d\n", usb_endpoint_num(endpoint));
12070 }
12071 #else
12072 if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) &&
12073 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)) {
12074 /* we found a bulk in endpoint */
12075 priv->RtInPipes[priv->ep_in_num] = (endpoint->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
12076 priv->ep_in_num ++;
12077 } else if (((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) &&
12078 ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)) {
12079 /* We found bulk out endpoint */
12080 priv->RtOutPipes[priv->ep_out_num] = endpoint->bEndpointAddress;
12081 priv->ep_out_num ++;
12082 }
12083 #endif
12084 }
12085 {
12086 memset(priv->txqueue_to_outpipemap,0,9);
12087 if (priv->ep_num == 6) {
12088 // BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON
12089 u8 queuetopipe[] = {3, 2, 1, 0, 4, 4, 4, 4, 4};
12090
12091 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
12092 } else if (priv->ep_num == 4) {
12093 // BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON
12094 u8 queuetopipe[] = {1, 1, 0, 0, 2, 2, 2, 2, 2};
12095
12096 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
12097 } else if (priv->ep_num > 9) {
12098 // BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON
12099 u8 queuetopipe[] = {3, 2, 1, 0, 4, 8, 7, 6, 5};
12100
12101 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
12102 } else {//use sigle pipe
12103 // BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON
12104 u8 queuetopipe[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
12105 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
12106 }
12107 }
12108 printk("==>ep_num:%d, in_ep_num:%d, out_ep_num:%d\n", priv->ep_num, priv->ep_in_num, priv->ep_out_num);
12109
12110 printk("==>RtInPipes:");
12111 for(i=0; i < priv->ep_in_num; i++)
12112 printk("%d ", priv->RtInPipes[i]);
12113 printk("\n");
12114
12115 printk("==>RtOutPipes:");
12116 for(i=0; i < priv->ep_out_num; i++)
12117 printk("%d ", priv->RtOutPipes[i]);
12118 printk("\n");
12119
12120 printk("==>txqueue_to_outpipemap for BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON:\n");
12121 for(i=0; i < 9; i++)
12122 printk("%d ", priv->txqueue_to_outpipemap[i]);
12123 printk("\n");
12124 #else
12125 {
12126 memset(priv->txqueue_to_outpipemap,0,9);
12127 memset(priv->RtOutPipes,4,16);//all use endpoint 4 for out
12128 }
12129 #endif
12130
12131 return;
12132 }
12133 #endif
12134
12135 static const struct net_device_ops rtl8192_netdev_ops = {
12136 .ndo_open = rtl8192_open,
12137 .ndo_stop = rtl8192_close,
12138 .ndo_get_stats = rtl8192_stats,
12139 .ndo_tx_timeout = tx_timeout,
12140 .ndo_do_ioctl = rtl8192_ioctl,
12141 .ndo_set_multicast_list = r8192_set_multicast,
12142 .ndo_set_mac_address = r8192_set_mac_adr,
12143 .ndo_validate_addr = eth_validate_addr,
12144 .ndo_change_mtu = eth_change_mtu,
12145 .ndo_start_xmit = rtl8192_ieee80211_xmit,
12146 };
12147
12148 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
12149 static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
12150 const struct usb_device_id *id)
12151 #else
12152 static void * __devinit rtl8192_usb_probe(struct usb_device *udev,
12153 unsigned int ifnum,
12154 const struct usb_device_id *id)
12155 #endif
12156 {
12157 // unsigned long ioaddr = 0;
12158 struct net_device *dev = NULL;
12159 struct r8192_priv *priv= NULL;
12160 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
12161 struct usb_device *udev = interface_to_usbdev(intf);
12162 #endif
12163 RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
12164
12165 dev = alloc_ieee80211(sizeof(struct r8192_priv));
12166
12167 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
12168 SET_MODULE_OWNER(dev);
12169 #endif
12170
12171 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
12172 usb_set_intfdata(intf, dev);
12173 SET_NETDEV_DEV(dev, &intf->dev);
12174 #endif
12175 priv = ieee80211_priv(dev);
12176 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
12177 priv->ieee80211 = netdev_priv(dev);
12178 #else
12179 priv->ieee80211 = (struct net_device *)dev->priv;
12180 #endif
12181 priv->udev=udev;
12182
12183 #ifdef RTL8192SU
12184 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
12185 HalUsbSetQueuePipeMapping8192SUsb(intf, dev);
12186 #else//use one pipe
12187 {
12188 memset(priv->txqueue_to_outpipemap,0,9);
12189 memset(priv->RtOutPipes,4,16);//all use endpoint 4 for out
12190 }
12191 #endif
12192 #endif
12193
12194 #ifdef RTL8192SU
12195 //printk("===============>NIC 8192SU\n");
12196 priv->ops = &rtl8192su_ops;
12197 #else
12198 //printk("===============>NIC 8192U\n");
12199 priv->ops = &rtl8192u_ops;
12200 #endif
12201
12202 dev->netdev_ops = &rtl8192_netdev_ops;
12203
12204 //DMESG("Oops: i'm coming\n");
12205 #if WIRELESS_EXT >= 12
12206 #if WIRELESS_EXT < 17
12207 dev->get_wireless_stats = r8192_get_wireless_stats;
12208 #endif
12209 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
12210 #endif
12211 dev->type=ARPHRD_ETHER;
12212
12213 dev->watchdog_timeo = HZ*3; //modified by john, 0805
12214
12215 if (dev_alloc_name(dev, ifname) < 0){
12216 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
12217 ifname = "wlan%d";
12218 dev_alloc_name(dev, ifname);
12219 }
12220
12221 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
12222 #if 1
12223 if(rtl8192_init(dev)!=0){
12224 RT_TRACE(COMP_ERR, "Initialization failed");
12225 goto fail;
12226 }
12227 #endif
12228 netif_carrier_off(dev);
12229 netif_stop_queue(dev);
12230
12231 register_netdev(dev);
12232 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
12233 rtl8192_proc_init_one(dev);
12234
12235
12236 RT_TRACE(COMP_INIT, "Driver probe completed\n");
12237 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
12238 return dev;
12239 #else
12240 return 0;
12241 #endif
12242
12243
12244 fail:
12245 free_ieee80211(dev);
12246
12247 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
12248 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
12249 return NULL;
12250 #else
12251 return -ENODEV;
12252 #endif
12253
12254 }
12255
12256 //detach all the work and timer structure declared or inititialize in r8192U_init function.
12257 void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
12258 {
12259 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22)
12260 cancel_work_sync(&priv->reset_wq);
12261 cancel_work_sync(&priv->qos_activate);
12262 cancel_delayed_work(&priv->watch_dog_wq);
12263 cancel_delayed_work(&priv->update_beacon_wq);
12264 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
12265 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
12266 //cancel_work_sync(&priv->SetBWModeWorkItem);
12267 //cancel_work_sync(&priv->SwChnlWorkItem);
12268 #else
12269 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
12270 cancel_delayed_work(&priv->reset_wq);
12271 cancel_delayed_work(&priv->qos_activate);
12272 cancel_delayed_work(&priv->watch_dog_wq);
12273 cancel_delayed_work(&priv->update_beacon_wq);
12274 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
12275 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
12276
12277 //cancel_delayed_work(&priv->SetBWModeWorkItem);
12278 //cancel_delayed_work(&priv->SwChnlWorkItem);
12279 #endif
12280 #endif
12281
12282 }
12283
12284
12285 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
12286 static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf)
12287 #else
12288 static void __devexit rtl8192_usb_disconnect(struct usb_device *udev, void *ptr)
12289 #endif
12290 {
12291 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
12292 struct net_device *dev = usb_get_intfdata(intf);
12293 #else
12294 struct net_device *dev = (struct net_device *)ptr;
12295 #endif
12296
12297 struct r8192_priv *priv = ieee80211_priv(dev);
12298 if(dev){
12299
12300 unregister_netdev(dev);
12301
12302 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
12303 rtl8192_proc_remove_one(dev);
12304
12305 rtl8192_down(dev);
12306 if (priv->pFirmware)
12307 {
12308 vfree(priv->pFirmware);
12309 priv->pFirmware = NULL;
12310 }
12311 // priv->rf_close(dev);
12312 // rtl8192_SetRFPowerState(dev, eRfOff);
12313 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
12314 destroy_workqueue(priv->priv_wq);
12315 #endif
12316 //rtl8192_irq_disable(dev);
12317 //rtl8192_reset(dev);
12318 mdelay(10);
12319
12320 }
12321 free_ieee80211(dev);
12322 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
12323 }
12324
12325 static int __init rtl8192_usb_module_init(void)
12326 {
12327 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
12328 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
12329 RT_TRACE(COMP_INIT, "Initializing module");
12330 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
12331 rtl8192_proc_module_init();
12332 return usb_register(&rtl8192_usb_driver);
12333 }
12334
12335
12336 static void __exit rtl8192_usb_module_exit(void)
12337 {
12338 usb_deregister(&rtl8192_usb_driver);
12339
12340 RT_TRACE(COMP_DOWN, "Exiting");
12341 rtl8192_proc_module_remove();
12342 }
12343
12344
12345 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
12346 {
12347 unsigned long flags;
12348 short enough_desc;
12349 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
12350
12351 spin_lock_irqsave(&priv->tx_lock,flags);
12352 enough_desc = check_nic_enough_desc(dev,pri);
12353 spin_unlock_irqrestore(&priv->tx_lock,flags);
12354
12355 if(enough_desc)
12356 ieee80211_wake_queue(priv->ieee80211);
12357 }
12358
12359 #if 0
12360 void DisableHWSecurityConfig8192SUsb(struct net_device *dev)
12361 {
12362 u8 SECR_value = 0x0;
12363 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
12364 }
12365 #endif
12366
12367 void EnableHWSecurityConfig8192(struct net_device *dev)
12368 {
12369 u8 SECR_value = 0x0;
12370 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
12371 struct ieee80211_device* ieee = priv->ieee80211;
12372
12373 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
12374 #if 1
12375 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
12376 {
12377 SECR_value |= SCR_RxUseDK;
12378 SECR_value |= SCR_TxUseDK;
12379 }
12380 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
12381 {
12382 SECR_value |= SCR_RxUseDK;
12383 SECR_value |= SCR_TxUseDK;
12384 }
12385 #endif
12386 //add HWSec active enable here.
12387 //default using hwsec. when peer AP is in N mode only and pairwise_key_type is none_aes(which HT_IOT_ACT_PURE_N_MODE indicates it), use software security. when peer AP is in b,g,n mode mixed and pairwise_key_type is none_aes, use g mode hw security. WB on 2008.7.4
12388
12389 ieee->hwsec_active = 1;
12390
12391 if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep)//!ieee->hwsec_support) //add hwsec_support flag to totol control hw_sec on/off
12392 {
12393 ieee->hwsec_active = 0;
12394 SECR_value &= ~SCR_RxDecEnable;
12395 }
12396
12397 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__, \
12398 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
12399 {
12400 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
12401 }
12402 }
12403
12404
12405 void setKey( struct net_device *dev,
12406 u8 EntryNo,
12407 u8 KeyIndex,
12408 u16 KeyType,
12409 u8 *MacAddr,
12410 u8 DefaultKey,
12411 u32 *KeyContent )
12412 {
12413 u32 TargetCommand = 0;
12414 u32 TargetContent = 0;
12415 u16 usConfig = 0;
12416 u8 i;
12417 if (EntryNo >= TOTAL_CAM_ENTRY)
12418 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
12419
12420 RT_TRACE(COMP_SEC, "====>to setKey(), dev:%p, EntryNo:%d, KeyIndex:%d, KeyType:%d, MacAddr"MAC_FMT"\n", dev,EntryNo, KeyIndex, KeyType, MAC_ARG(MacAddr));
12421
12422 if (DefaultKey)
12423 usConfig |= BIT15 | (KeyType<<2);
12424 else
12425 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
12426 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
12427
12428
12429 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
12430 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
12431 TargetCommand |= BIT31|BIT16;
12432
12433 if(i==0){//MAC|Config
12434 TargetContent = (u32)(*(MacAddr+0)) << 16|
12435 (u32)(*(MacAddr+1)) << 24|
12436 (u32)usConfig;
12437
12438 write_nic_dword(dev, WCAMI, TargetContent);
12439 write_nic_dword(dev, RWCAM, TargetCommand);
12440 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
12441 }
12442 else if(i==1){//MAC
12443 TargetContent = (u32)(*(MacAddr+2)) |
12444 (u32)(*(MacAddr+3)) << 8|
12445 (u32)(*(MacAddr+4)) << 16|
12446 (u32)(*(MacAddr+5)) << 24;
12447 write_nic_dword(dev, WCAMI, TargetContent);
12448 write_nic_dword(dev, RWCAM, TargetCommand);
12449 }
12450 else {
12451 //Key Material
12452 if(KeyContent !=NULL){
12453 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
12454 write_nic_dword(dev, RWCAM, TargetCommand);
12455 }
12456 }
12457 }
12458
12459 }
12460
12461 /***************************************************************************
12462 ------------------- module init / exit stubs ----------------
12463 ****************************************************************************/
12464 module_init(rtl8192_usb_module_init);
12465 module_exit(rtl8192_usb_module_exit);
CJK support for tty framebuffer vt