?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: rtl8192u: remove dead code
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / rtl8192u / r8192U_core.c
blobadade13e1e19fc98fa3c85a0ba53ebc355868f15
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 #include <asm/uaccess.h>
62 #include "r8192U_hw.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 #include "r819xU_phy.h" //added by WB 4.30.2008
68 #include "r819xU_phyreg.h"
69 #include "r819xU_cmdpkt.h"
70 #include "r8192U_dm.h"
71 //#include "r8192xU_phyreg.h"
72 #include <linux/usb.h>
73 // FIXME: check if 2.6.7 is ok
74
75 #ifdef CONFIG_RTL8192_PM
76 #include "r8192_pm.h"
77 #endif
78
79 #ifdef ENABLE_DOT11D
80 #include "dot11d.h"
81 #endif
82 //set here to open your trace code. //WB
83 u32 rt_global_debug_component = \
84 // COMP_INIT |
85 // COMP_DBG |
86 // COMP_EPROM |
87 // COMP_PHY |
88 // COMP_RF |
89 // COMP_FIRMWARE |
90 // COMP_CH |
91 // COMP_POWER_TRACKING |
92 // COMP_RATE |
93 // COMP_TXAGC |
94 // COMP_TRACE |
95 COMP_DOWN |
96 // COMP_RECV |
97 // COMP_SWBW |
98 COMP_SEC |
99 // COMP_RESET |
100 // COMP_SEND |
101 // COMP_EVENTS |
102 COMP_ERR ; //always open err flags on
103
104 #define TOTAL_CAM_ENTRY 32
105 #define CAM_CONTENT_COUNT 8
106
107 static struct usb_device_id rtl8192_usb_id_tbl[] = {
108 /* Realtek */
109 {USB_DEVICE(0x0bda, 0x8192)},
110 {USB_DEVICE(0x0bda, 0x8709)},
111 /* Corega */
112 {USB_DEVICE(0x07aa, 0x0043)},
113 /* Belkin */
114 {USB_DEVICE(0x050d, 0x805E)},
115 /* Sitecom */
116 {USB_DEVICE(0x0df6, 0x0031)},
117 /* EnGenius */
118 {USB_DEVICE(0x1740, 0x9201)},
119 /* Dlink */
120 {USB_DEVICE(0x2001, 0x3301)},
121 /* Zinwell */
122 {USB_DEVICE(0x5a57, 0x0290)},
123 {}
124 };
125
126 MODULE_LICENSE("GPL");
127 MODULE_VERSION("V 1.1");
128 MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
129 MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
130
131 static char* ifname = "wlan%d";
132 static int hwwep = 1; //default use hw. set 0 to use software security
133 static int channels = 0x3fff;
134
135
136
137 module_param(ifname, charp, S_IRUGO|S_IWUSR );
138 //module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
139 module_param(hwwep,int, S_IRUGO|S_IWUSR);
140 module_param(channels,int, S_IRUGO|S_IWUSR);
141
142 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
143 //MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
144 MODULE_PARM_DESC(hwwep," Try to use hardware security support. ");
145 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
146
147 static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
148 const struct usb_device_id *id);
149 static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf);
150
151
152 static struct usb_driver rtl8192_usb_driver = {
153 .name = RTL819xU_MODULE_NAME, /* Driver name */
154 .id_table = rtl8192_usb_id_tbl, /* PCI_ID table */
155 .probe = rtl8192_usb_probe, /* probe fn */
156 .disconnect = rtl8192_usb_disconnect, /* remove fn */
157 #ifdef CONFIG_RTL8192_PM
158 .suspend = rtl8192_suspend, /* PM suspend fn */
159 .resume = rtl8192_resume, /* PM resume fn */
160 #else
161 .suspend = NULL, /* PM suspend fn */
162 .resume = NULL, /* PM resume fn */
163 #endif
164 };
165
166 #ifdef ENABLE_DOT11D
167
168 typedef struct _CHANNEL_LIST
169 {
170 u8 Channel[32];
171 u8 Len;
172 }CHANNEL_LIST, *PCHANNEL_LIST;
173
174 static CHANNEL_LIST ChannelPlan[] = {
175 {{1,2,3,4,5,6,7,8,9,10,11,36,40,44,48,52,56,60,64,149,153,157,161,165},24}, //FCC
176 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
177 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
178 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
179 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
180 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, //MKK //MKK
181 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
182 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
183 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22}, // For 11a , TELEC
184 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
185 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14},14} //For Global Domain. 1-11:active scan, 12-14 passive scan. //+YJ, 080626
186 };
187
188 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
189 {
190 int i, max_chan=-1, min_chan=-1;
191 struct ieee80211_device* ieee = priv->ieee80211;
192 switch (channel_plan)
193 {
194 case COUNTRY_CODE_FCC:
195 case COUNTRY_CODE_IC:
196 case COUNTRY_CODE_ETSI:
197 case COUNTRY_CODE_SPAIN:
198 case COUNTRY_CODE_FRANCE:
199 case COUNTRY_CODE_MKK:
200 case COUNTRY_CODE_MKK1:
201 case COUNTRY_CODE_ISRAEL:
202 case COUNTRY_CODE_TELEC:
203 case COUNTRY_CODE_MIC:
204 {
205 Dot11d_Init(ieee);
206 ieee->bGlobalDomain = false;
207 //acturally 8225 & 8256 rf chip only support B,G,24N mode
208 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256))
209 {
210 min_chan = 1;
211 max_chan = 14;
212 }
213 else
214 {
215 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
216 }
217 if (ChannelPlan[channel_plan].Len != 0){
218 // Clear old channel map
219 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
220 // Set new channel map
221 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
222 {
223 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
224 break;
225 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
226 }
227 }
228 break;
229 }
230 case COUNTRY_CODE_GLOBAL_DOMAIN:
231 {
232 GET_DOT11D_INFO(ieee)->bEnabled = 0;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
233 Dot11d_Reset(ieee);
234 ieee->bGlobalDomain = true;
235 break;
236 }
237 default:
238 break;
239 }
240 return;
241 }
242 #endif
243
244 #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 )
245
246 #define rx_hal_is_cck_rate(_pdrvinfo)\
247 (_pdrvinfo->RxRate == DESC90_RATE1M ||\
248 _pdrvinfo->RxRate == DESC90_RATE2M ||\
249 _pdrvinfo->RxRate == DESC90_RATE5_5M ||\
250 _pdrvinfo->RxRate == DESC90_RATE11M) &&\
251 !_pdrvinfo->RxHT\
252
253
254 void CamResetAllEntry(struct net_device *dev)
255 {
256 u32 ulcommand = 0;
257 //2004/02/11 In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
258 // However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
259 // In this condition, Cam can not be reset because upper layer will not set this static key again.
260 //if(Adapter->EncAlgorithm == WEP_Encryption)
261 // return;
262 //debug
263 //DbgPrint("========================================\n");
264 //DbgPrint(" Call ResetAllEntry \n");
265 //DbgPrint("========================================\n\n");
266 ulcommand |= BIT31|BIT30;
267 write_nic_dword(dev, RWCAM, ulcommand);
268
269 }
270
271
272 void write_cam(struct net_device *dev, u8 addr, u32 data)
273 {
274 write_nic_dword(dev, WCAMI, data);
275 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
276 }
277
278 u32 read_cam(struct net_device *dev, u8 addr)
279 {
280 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
281 return read_nic_dword(dev, 0xa8);
282 }
283
284 void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
285 {
286 int status;
287 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
288 struct usb_device *udev = priv->udev;
289
290 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
291 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
292 indx|0xfe00, 0, &data, 1, HZ / 2);
293
294 if (status < 0)
295 {
296 printk("write_nic_byte_E TimeOut! status:%d\n", status);
297 }
298 }
299
300 u8 read_nic_byte_E(struct net_device *dev, int indx)
301 {
302 int status;
303 u8 data;
304 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
305 struct usb_device *udev = priv->udev;
306
307 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
308 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
309 indx|0xfe00, 0, &data, 1, HZ / 2);
310
311 if (status < 0)
312 {
313 printk("read_nic_byte_E TimeOut! status:%d\n", status);
314 }
315
316 return data;
317 }
318 //as 92U has extend page from 4 to 16, so modify functions below.
319 void write_nic_byte(struct net_device *dev, int indx, u8 data)
320 {
321 int status;
322
323 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
324 struct usb_device *udev = priv->udev;
325
326 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
327 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
328 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
329
330 if (status < 0)
331 {
332 printk("write_nic_byte TimeOut! status:%d\n", status);
333 }
334
335
336 }
337
338
339 void write_nic_word(struct net_device *dev, int indx, u16 data)
340 {
341
342 int status;
343
344 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
345 struct usb_device *udev = priv->udev;
346
347 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
348 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
349 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 2, HZ / 2);
350
351 if (status < 0)
352 {
353 printk("write_nic_word TimeOut! status:%d\n", status);
354 }
355
356 }
357
358
359 void write_nic_dword(struct net_device *dev, int indx, u32 data)
360 {
361
362 int status;
363
364 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
365 struct usb_device *udev = priv->udev;
366
367 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
368 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
369 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 4, HZ / 2);
370
371
372 if (status < 0)
373 {
374 printk("write_nic_dword TimeOut! status:%d\n", status);
375 }
376
377 }
378
379
380
381 u8 read_nic_byte(struct net_device *dev, int indx)
382 {
383 u8 data;
384 int status;
385 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
386 struct usb_device *udev = priv->udev;
387
388 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
389 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
390 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 1, HZ / 2);
391
392 if (status < 0)
393 {
394 printk("read_nic_byte TimeOut! status:%d\n", status);
395 }
396
397 return data;
398 }
399
400
401
402 u16 read_nic_word(struct net_device *dev, int indx)
403 {
404 u16 data;
405 int status;
406 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
407 struct usb_device *udev = priv->udev;
408
409 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
410 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
411 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 2, HZ / 2);
412
413 if (status < 0)
414 {
415 printk("read_nic_word TimeOut! status:%d\n", status);
416 }
417
418
419 return data;
420 }
421
422 u16 read_nic_word_E(struct net_device *dev, int indx)
423 {
424 u16 data;
425 int status;
426 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
427 struct usb_device *udev = priv->udev;
428
429 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
430 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
431 indx|0xfe00, 0, &data, 2, HZ / 2);
432
433 if (status < 0)
434 {
435 printk("read_nic_word TimeOut! status:%d\n", status);
436 }
437
438
439 return data;
440 }
441
442 u32 read_nic_dword(struct net_device *dev, int indx)
443 {
444 u32 data;
445 int status;
446 // int result;
447
448 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
449 struct usb_device *udev = priv->udev;
450
451 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
452 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
453 (indx&0xff)|0xff00, (indx>>8)&0x0f, &data, 4, HZ / 2);
454 // if(0 != result) {
455 // printk(KERN_WARNING "read size of data = %d\, date = %d\n", result, data);
456 // }
457
458 if (status < 0)
459 {
460 printk("read_nic_dword TimeOut! status:%d\n", status);
461 }
462
463
464
465 return data;
466 }
467
468
469 //u8 read_phy_cck(struct net_device *dev, u8 adr);
470 //u8 read_phy_ofdm(struct net_device *dev, u8 adr);
471 /* this might still called in what was the PHY rtl8185/rtl8192 common code
472 * plans are to possibilty turn it again in one common code...
473 */
474 inline void force_pci_posting(struct net_device *dev)
475 {
476 }
477
478
479 static struct net_device_stats *rtl8192_stats(struct net_device *dev);
480 void rtl8192_commit(struct net_device *dev);
481 //void rtl8192_restart(struct net_device *dev);
482 void rtl8192_restart(struct work_struct *work);
483 //void rtl8192_rq_tx_ack(struct work_struct *work);
484
485 void watch_dog_timer_callback(unsigned long data);
486
487 /****************************************************************************
488 -----------------------------PROCFS STUFF-------------------------
489 *****************************************************************************/
490
491 static struct proc_dir_entry *rtl8192_proc = NULL;
492
493
494
495 static int proc_get_stats_ap(char *page, char **start,
496 off_t offset, int count,
497 int *eof, void *data)
498 {
499 struct net_device *dev = data;
500 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
501 struct ieee80211_device *ieee = priv->ieee80211;
502 struct ieee80211_network *target;
503
504 int len = 0;
505
506 list_for_each_entry(target, &ieee->network_list, list) {
507
508 len += snprintf(page + len, count - len,
509 "%s ", target->ssid);
510
511 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
512 len += snprintf(page + len, count - len,
513 "WPA\n");
514 }
515 else{
516 len += snprintf(page + len, count - len,
517 "non_WPA\n");
518 }
519
520 }
521
522 *eof = 1;
523 return len;
524 }
525
526 static int proc_get_registers(char *page, char **start,
527 off_t offset, int count,
528 int *eof, void *data)
529 {
530 struct net_device *dev = data;
531 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
532
533 int len = 0;
534 int i,n;
535
536 int max=0xff;
537
538 /* This dump the current register page */
539 len += snprintf(page + len, count - len,
540 "\n####################page 0##################\n ");
541
542 for(n=0;n<=max;)
543 {
544 //printk( "\nD: %2x> ", n);
545 len += snprintf(page + len, count - len,
546 "\nD: %2x > ",n);
547
548 for(i=0;i<16 && n<=max;i++,n++)
549 len += snprintf(page + len, count - len,
550 "%2x ",read_nic_byte(dev,0x000|n));
551
552 // printk("%2x ",read_nic_byte(dev,n));
553 }
554 len += snprintf(page + len, count - len,
555 "\n####################page 1##################\n ");
556 for(n=0;n<=max;)
557 {
558 //printk( "\nD: %2x> ", n);
559 len += snprintf(page + len, count - len,
560 "\nD: %2x > ",n);
561
562 for(i=0;i<16 && n<=max;i++,n++)
563 len += snprintf(page + len, count - len,
564 "%2x ",read_nic_byte(dev,0x100|n));
565
566 // printk("%2x ",read_nic_byte(dev,n));
567 }
568 len += snprintf(page + len, count - len,
569 "\n####################page 3##################\n ");
570 for(n=0;n<=max;)
571 {
572 //printk( "\nD: %2x> ", n);
573 len += snprintf(page + len, count - len,
574 "\nD: %2x > ",n);
575
576 for(i=0;i<16 && n<=max;i++,n++)
577 len += snprintf(page + len, count - len,
578 "%2x ",read_nic_byte(dev,0x300|n));
579
580 // printk("%2x ",read_nic_byte(dev,n));
581 }
582
583
584 len += snprintf(page + len, count - len,"\n");
585 *eof = 1;
586 return len;
587
588 }
589
590
591
592
593
594 static int proc_get_stats_tx(char *page, char **start,
595 off_t offset, int count,
596 int *eof, void *data)
597 {
598 struct net_device *dev = data;
599 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
600
601 int len = 0;
602
603 len += snprintf(page + len, count - len,
604 "TX VI priority ok int: %lu\n"
605 "TX VI priority error int: %lu\n"
606 "TX VO priority ok int: %lu\n"
607 "TX VO priority error int: %lu\n"
608 "TX BE priority ok int: %lu\n"
609 "TX BE priority error int: %lu\n"
610 "TX BK priority ok int: %lu\n"
611 "TX BK priority error int: %lu\n"
612 "TX MANAGE priority ok int: %lu\n"
613 "TX MANAGE priority error int: %lu\n"
614 "TX BEACON priority ok int: %lu\n"
615 "TX BEACON priority error int: %lu\n"
616 // "TX high priority ok int: %lu\n"
617 // "TX high priority failed error int: %lu\n"
618 "TX queue resume: %lu\n"
619 "TX queue stopped?: %d\n"
620 "TX fifo overflow: %lu\n"
621 // "TX beacon: %lu\n"
622 "TX VI queue: %d\n"
623 "TX VO queue: %d\n"
624 "TX BE queue: %d\n"
625 "TX BK queue: %d\n"
626 // "TX HW queue: %d\n"
627 "TX VI dropped: %lu\n"
628 "TX VO dropped: %lu\n"
629 "TX BE dropped: %lu\n"
630 "TX BK dropped: %lu\n"
631 "TX total data packets %lu\n",
632 // "TX beacon aborted: %lu\n",
633 priv->stats.txviokint,
634 priv->stats.txvierr,
635 priv->stats.txvookint,
636 priv->stats.txvoerr,
637 priv->stats.txbeokint,
638 priv->stats.txbeerr,
639 priv->stats.txbkokint,
640 priv->stats.txbkerr,
641 priv->stats.txmanageokint,
642 priv->stats.txmanageerr,
643 priv->stats.txbeaconokint,
644 priv->stats.txbeaconerr,
645 // priv->stats.txhpokint,
646 // priv->stats.txhperr,
647 priv->stats.txresumed,
648 netif_queue_stopped(dev),
649 priv->stats.txoverflow,
650 // priv->stats.txbeacon,
651 atomic_read(&(priv->tx_pending[VI_PRIORITY])),
652 atomic_read(&(priv->tx_pending[VO_PRIORITY])),
653 atomic_read(&(priv->tx_pending[BE_PRIORITY])),
654 atomic_read(&(priv->tx_pending[BK_PRIORITY])),
655 // read_nic_byte(dev, TXFIFOCOUNT),
656 priv->stats.txvidrop,
657 priv->stats.txvodrop,
658 priv->stats.txbedrop,
659 priv->stats.txbkdrop,
660 priv->stats.txdatapkt
661 // priv->stats.txbeaconerr
662 );
663
664 *eof = 1;
665 return len;
666 }
667
668
669
670 static int proc_get_stats_rx(char *page, char **start,
671 off_t offset, int count,
672 int *eof, void *data)
673 {
674 struct net_device *dev = data;
675 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
676
677 int len = 0;
678
679 len += snprintf(page + len, count - len,
680 "RX packets: %lu\n"
681 "RX urb status error: %lu\n"
682 "RX invalid urb error: %lu\n",
683 priv->stats.rxoktotal,
684 priv->stats.rxstaterr,
685 priv->stats.rxurberr);
686
687 *eof = 1;
688 return len;
689 }
690 void rtl8192_proc_module_init(void)
691 {
692 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
693 rtl8192_proc=create_proc_entry(RTL819xU_MODULE_NAME, S_IFDIR, init_net.proc_net);
694 }
695
696
697 void rtl8192_proc_module_remove(void)
698 {
699 remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
700 }
701
702
703 void rtl8192_proc_remove_one(struct net_device *dev)
704 {
705 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
706
707
708 if (priv->dir_dev) {
709 // remove_proc_entry("stats-hw", priv->dir_dev);
710 remove_proc_entry("stats-tx", priv->dir_dev);
711 remove_proc_entry("stats-rx", priv->dir_dev);
712 // remove_proc_entry("stats-ieee", priv->dir_dev);
713 remove_proc_entry("stats-ap", priv->dir_dev);
714 remove_proc_entry("registers", priv->dir_dev);
715 // remove_proc_entry("cck-registers",priv->dir_dev);
716 // remove_proc_entry("ofdm-registers",priv->dir_dev);
717 //remove_proc_entry(dev->name, rtl8192_proc);
718 remove_proc_entry("wlan0", rtl8192_proc);
719 priv->dir_dev = NULL;
720 }
721 }
722
723
724 void rtl8192_proc_init_one(struct net_device *dev)
725 {
726 struct proc_dir_entry *e;
727 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
728 priv->dir_dev = create_proc_entry(dev->name,
729 S_IFDIR | S_IRUGO | S_IXUGO,
730 rtl8192_proc);
731 if (!priv->dir_dev) {
732 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
733 dev->name);
734 return;
735 }
736 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
737 priv->dir_dev, proc_get_stats_rx, dev);
738
739 if (!e) {
740 RT_TRACE(COMP_ERR,"Unable to initialize "
741 "/proc/net/rtl8192/%s/stats-rx\n",
742 dev->name);
743 }
744
745
746 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
747 priv->dir_dev, proc_get_stats_tx, dev);
748
749 if (!e) {
750 RT_TRACE(COMP_ERR, "Unable to initialize "
751 "/proc/net/rtl8192/%s/stats-tx\n",
752 dev->name);
753 }
754
755 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
756 priv->dir_dev, proc_get_stats_ap, dev);
757
758 if (!e) {
759 RT_TRACE(COMP_ERR, "Unable to initialize "
760 "/proc/net/rtl8192/%s/stats-ap\n",
761 dev->name);
762 }
763
764 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
765 priv->dir_dev, proc_get_registers, dev);
766 if (!e) {
767 RT_TRACE(COMP_ERR, "Unable to initialize "
768 "/proc/net/rtl8192/%s/registers\n",
769 dev->name);
770 }
771 }
772 /****************************************************************************
773 -----------------------------MISC STUFF-------------------------
774 *****************************************************************************/
775
776 /* this is only for debugging */
777 void print_buffer(u32 *buffer, int len)
778 {
779 int i;
780 u8 *buf =(u8*)buffer;
781
782 printk("ASCII BUFFER DUMP (len: %x):\n",len);
783
784 for(i=0;i<len;i++)
785 printk("%c",buf[i]);
786
787 printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
788
789 for(i=0;i<len;i++)
790 printk("%x",buf[i]);
791
792 printk("\n");
793 }
794
795 //short check_nic_enough_desc(struct net_device *dev, priority_t priority)
796 short check_nic_enough_desc(struct net_device *dev,int queue_index)
797 {
798 struct r8192_priv *priv = ieee80211_priv(dev);
799 int used = atomic_read(&priv->tx_pending[queue_index]);
800
801 return (used < MAX_TX_URB);
802 }
803
804 void tx_timeout(struct net_device *dev)
805 {
806 struct r8192_priv *priv = ieee80211_priv(dev);
807 //rtl8192_commit(dev);
808
809 schedule_work(&priv->reset_wq);
810 //DMESG("TXTIMEOUT");
811 }
812
813
814 /* this is only for debug */
815 void dump_eprom(struct net_device *dev)
816 {
817 int i;
818 for(i=0; i<63; i++)
819 RT_TRACE(COMP_EPROM, "EEPROM addr %x : %x", i, eprom_read(dev,i));
820 }
821
822 /* this is only for debug */
823 void rtl8192_dump_reg(struct net_device *dev)
824 {
825 int i;
826 int n;
827 int max=0x1ff;
828
829 RT_TRACE(COMP_PHY, "Dumping NIC register map");
830
831 for(n=0;n<=max;)
832 {
833 printk( "\nD: %2x> ", n);
834 for(i=0;i<16 && n<=max;i++,n++)
835 printk("%2x ",read_nic_byte(dev,n));
836 }
837 printk("\n");
838 }
839
840 /****************************************************************************
841 ------------------------------HW STUFF---------------------------
842 *****************************************************************************/
843
844
845 void rtl8192_set_mode(struct net_device *dev,int mode)
846 {
847 u8 ecmd;
848 ecmd=read_nic_byte(dev, EPROM_CMD);
849 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
850 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
851 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
852 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
853 write_nic_byte(dev, EPROM_CMD, ecmd);
854 }
855
856
857 void rtl8192_update_msr(struct net_device *dev)
858 {
859 struct r8192_priv *priv = ieee80211_priv(dev);
860 u8 msr;
861
862 msr = read_nic_byte(dev, MSR);
863 msr &= ~ MSR_LINK_MASK;
864
865 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
866 * msr must be updated if the state is ASSOCIATING.
867 * this is intentional and make sense for ad-hoc and
868 * master (see the create BSS/IBSS func)
869 */
870 if (priv->ieee80211->state == IEEE80211_LINKED){
871
872 if (priv->ieee80211->iw_mode == IW_MODE_INFRA)
873 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
874 else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
875 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
876 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
877 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
878
879 }else
880 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
881
882 write_nic_byte(dev, MSR, msr);
883 }
884
885 void rtl8192_set_chan(struct net_device *dev,short ch)
886 {
887 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
888 // u32 tx;
889 RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
890 priv->chan=ch;
891
892 /* this hack should avoid frame TX during channel setting*/
893
894
895 // tx = read_nic_dword(dev,TX_CONF);
896 // tx &= ~TX_LOOPBACK_MASK;
897
898 #ifndef LOOP_TEST
899 // write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
900
901 //need to implement rf set channel here WB
902
903 if (priv->rf_set_chan)
904 priv->rf_set_chan(dev,priv->chan);
905 mdelay(10);
906 // write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
907 #endif
908 }
909
910 static void rtl8192_rx_isr(struct urb *urb);
911 //static void rtl8192_rx_isr(struct urb *rx_urb);
912
913 u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
914 {
915
916 #ifdef USB_RX_AGGREGATION_SUPPORT
917 if (pstats->bisrxaggrsubframe)
918 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
919 + pstats->RxBufShift + 8);
920 else
921 #endif
922 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
923 + pstats->RxBufShift);
924
925 }
926 static int rtl8192_rx_initiate(struct net_device*dev)
927 {
928 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
929 struct urb *entry;
930 struct sk_buff *skb;
931 struct rtl8192_rx_info *info;
932
933 /* nomal packet rx procedure */
934 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
935 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
936 if (!skb)
937 break;
938 entry = usb_alloc_urb(0, GFP_KERNEL);
939 if (!entry) {
940 kfree_skb(skb);
941 break;
942 }
943 // printk("nomal packet IN request!\n");
944 usb_fill_bulk_urb(entry, priv->udev,
945 usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
946 RX_URB_SIZE, rtl8192_rx_isr, skb);
947 info = (struct rtl8192_rx_info *) skb->cb;
948 info->urb = entry;
949 info->dev = dev;
950 info->out_pipe = 3; //denote rx normal packet queue
951 skb_queue_tail(&priv->rx_queue, skb);
952 usb_submit_urb(entry, GFP_KERNEL);
953 }
954
955 /* command packet rx procedure */
956 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
957 // printk("command packet IN request!\n");
958 skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL);
959 if (!skb)
960 break;
961 entry = usb_alloc_urb(0, GFP_KERNEL);
962 if (!entry) {
963 kfree_skb(skb);
964 break;
965 }
966 usb_fill_bulk_urb(entry, priv->udev,
967 usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
968 RX_URB_SIZE, rtl8192_rx_isr, skb);
969 info = (struct rtl8192_rx_info *) skb->cb;
970 info->urb = entry;
971 info->dev = dev;
972 info->out_pipe = 9; //denote rx cmd packet queue
973 skb_queue_tail(&priv->rx_queue, skb);
974 usb_submit_urb(entry, GFP_KERNEL);
975 }
976
977 return 0;
978 }
979
980 void rtl8192_set_rxconf(struct net_device *dev)
981 {
982 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
983 u32 rxconf;
984
985 rxconf=read_nic_dword(dev,RCR);
986 rxconf = rxconf &~ MAC_FILTER_MASK;
987 rxconf = rxconf | RCR_AMF;
988 rxconf = rxconf | RCR_ADF;
989 rxconf = rxconf | RCR_AB;
990 rxconf = rxconf | RCR_AM;
991 //rxconf = rxconf | RCR_ACF;
992
993 if (dev->flags & IFF_PROMISC) {DMESG ("NIC in promisc mode");}
994
995 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
996 dev->flags & IFF_PROMISC){
997 rxconf = rxconf | RCR_AAP;
998 } /*else if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
999 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
1000 rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
1001 }*/else{
1002 rxconf = rxconf | RCR_APM;
1003 rxconf = rxconf | RCR_CBSSID;
1004 }
1005
1006
1007 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
1008 rxconf = rxconf | RCR_AICV;
1009 rxconf = rxconf | RCR_APWRMGT;
1010 }
1011
1012 if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
1013 rxconf = rxconf | RCR_ACRC32;
1014
1015
1016 rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
1017 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
1018 rxconf = rxconf &~ MAX_RX_DMA_MASK;
1019 rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
1020
1021 // rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
1022 rxconf = rxconf | RCR_ONLYERLPKT;
1023
1024 // rxconf = rxconf &~ RCR_CS_MASK;
1025 // rxconf = rxconf | (1<<RCR_CS_SHIFT);
1026
1027 write_nic_dword(dev, RCR, rxconf);
1028
1029 #ifdef DEBUG_RX
1030 DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RCR));
1031 #endif
1032 }
1033 //wait to be removed
1034 void rtl8192_rx_enable(struct net_device *dev)
1035 {
1036 //u8 cmd;
1037
1038 //struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1039
1040 rtl8192_rx_initiate(dev);
1041
1042 // rtl8192_set_rxconf(dev);
1043 }
1044
1045
1046 void rtl8192_tx_enable(struct net_device *dev)
1047 {
1048 }
1049
1050
1051
1052 void rtl8192_rtx_disable(struct net_device *dev)
1053 {
1054 u8 cmd;
1055 struct r8192_priv *priv = ieee80211_priv(dev);
1056 struct sk_buff *skb;
1057 struct rtl8192_rx_info *info;
1058
1059 cmd=read_nic_byte(dev,CMDR);
1060 write_nic_byte(dev, CMDR, cmd &~ \
1061 (CR_TE|CR_RE));
1062 force_pci_posting(dev);
1063 mdelay(10);
1064
1065 while ((skb = __skb_dequeue(&priv->rx_queue))) {
1066 info = (struct rtl8192_rx_info *) skb->cb;
1067 if (!info->urb)
1068 continue;
1069
1070 usb_kill_urb(info->urb);
1071 kfree_skb(skb);
1072 }
1073
1074 if (skb_queue_len(&priv->skb_queue)) {
1075 printk(KERN_WARNING "skb_queue not empty\n");
1076 }
1077
1078 skb_queue_purge(&priv->skb_queue);
1079 return;
1080 }
1081
1082
1083 int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
1084 {
1085 return 0;
1086 }
1087
1088 inline u16 ieeerate2rtlrate(int rate)
1089 {
1090 switch(rate){
1091 case 10:
1092 return 0;
1093 case 20:
1094 return 1;
1095 case 55:
1096 return 2;
1097 case 110:
1098 return 3;
1099 case 60:
1100 return 4;
1101 case 90:
1102 return 5;
1103 case 120:
1104 return 6;
1105 case 180:
1106 return 7;
1107 case 240:
1108 return 8;
1109 case 360:
1110 return 9;
1111 case 480:
1112 return 10;
1113 case 540:
1114 return 11;
1115 default:
1116 return 3;
1117
1118 }
1119 }
1120 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
1121 inline u16 rtl8192_rate2rate(short rate)
1122 {
1123 if (rate >11) return 0;
1124 return rtl_rate[rate];
1125 }
1126
1127
1128 /* The protype of rx_isr has changed since one verion of Linux Kernel */
1129 static void rtl8192_rx_isr(struct urb *urb)
1130 {
1131 struct sk_buff *skb = (struct sk_buff *) urb->context;
1132 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
1133 struct net_device *dev = info->dev;
1134 struct r8192_priv *priv = ieee80211_priv(dev);
1135 int out_pipe = info->out_pipe;
1136 int err;
1137 if(!priv->up)
1138 return;
1139 if (unlikely(urb->status)) {
1140 info->urb = NULL;
1141 priv->stats.rxstaterr++;
1142 priv->ieee80211->stats.rx_errors++;
1143 usb_free_urb(urb);
1144 // printk("%s():rx status err\n",__FUNCTION__);
1145 return;
1146 }
1147 skb_unlink(skb, &priv->rx_queue);
1148 skb_put(skb, urb->actual_length);
1149
1150 skb_queue_tail(&priv->skb_queue, skb);
1151 tasklet_schedule(&priv->irq_rx_tasklet);
1152
1153 skb = dev_alloc_skb(RX_URB_SIZE);
1154 if (unlikely(!skb)) {
1155 usb_free_urb(urb);
1156 printk("%s():can,t alloc skb\n",__FUNCTION__);
1157 /* TODO check rx queue length and refill *somewhere* */
1158 return;
1159 }
1160
1161 usb_fill_bulk_urb(urb, priv->udev,
1162 usb_rcvbulkpipe(priv->udev, out_pipe), skb_tail_pointer(skb),
1163 RX_URB_SIZE, rtl8192_rx_isr, skb);
1164
1165 info = (struct rtl8192_rx_info *) skb->cb;
1166 info->urb = urb;
1167 info->dev = dev;
1168 info->out_pipe = out_pipe;
1169
1170 urb->transfer_buffer = skb_tail_pointer(skb);
1171 urb->context = skb;
1172 skb_queue_tail(&priv->rx_queue, skb);
1173 err = usb_submit_urb(urb, GFP_ATOMIC);
1174 if(err && err != EPERM)
1175 printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
1176 }
1177
1178 u32
1179 rtl819xusb_rx_command_packet(
1180 struct net_device *dev,
1181 struct ieee80211_rx_stats *pstats
1182 )
1183 {
1184 u32 status;
1185
1186 //RT_TRACE(COMP_RECV, DBG_TRACE, ("---> RxCommandPacketHandle819xUsb()\n"));
1187
1188 status = cmpk_message_handle_rx(dev, pstats);
1189 if (status)
1190 {
1191 DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
1192 }
1193 else
1194 {
1195 //RT_TRACE(COMP_RECV, DBG_TRACE, ("RxCommandPacketHandle819xUsb: It is not a command packet\n"));
1196 }
1197
1198 //RT_TRACE(COMP_RECV, DBG_TRACE, ("<--- RxCommandPacketHandle819xUsb()\n"));
1199 return status;
1200 }
1201
1202
1203 void rtl8192_data_hard_stop(struct net_device *dev)
1204 {
1205 //FIXME !!
1206 }
1207
1208
1209 void rtl8192_data_hard_resume(struct net_device *dev)
1210 {
1211 // FIXME !!
1212 }
1213
1214 /* this function TX data frames when the ieee80211 stack requires this.
1215 * It checks also if we need to stop the ieee tx queue, eventually do it
1216 */
1217 void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
1218 {
1219 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1220 int ret;
1221 unsigned long flags;
1222 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1223 u8 queue_index = tcb_desc->queue_index;
1224
1225 /* shall not be referred by command packet */
1226 assert(queue_index != TXCMD_QUEUE);
1227
1228 spin_lock_irqsave(&priv->tx_lock,flags);
1229
1230 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1231 // tcb_desc->RATRIndex = 7;
1232 // tcb_desc->bTxDisableRateFallBack = 1;
1233 // tcb_desc->bTxUseDriverAssingedRate = 1;
1234 tcb_desc->bTxEnableFwCalcDur = 1;
1235 skb_push(skb, priv->ieee80211->tx_headroom);
1236 ret = rtl8192_tx(dev, skb);
1237
1238 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1239 //priv->ieee80211->stats.tx_packets++;
1240
1241 spin_unlock_irqrestore(&priv->tx_lock,flags);
1242
1243 // return ret;
1244 return;
1245 }
1246
1247 /* This is a rough attempt to TX a frame
1248 * This is called by the ieee 80211 stack to TX management frames.
1249 * If the ring is full packet are dropped (for data frame the queue
1250 * is stopped before this can happen).
1251 */
1252 int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1253 {
1254 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1255 int ret;
1256 unsigned long flags;
1257 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1258 u8 queue_index = tcb_desc->queue_index;
1259
1260
1261 spin_lock_irqsave(&priv->tx_lock,flags);
1262
1263 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1264 if(queue_index == TXCMD_QUEUE) {
1265 skb_push(skb, USB_HWDESC_HEADER_LEN);
1266 rtl819xU_tx_cmd(dev, skb);
1267 ret = 1;
1268 spin_unlock_irqrestore(&priv->tx_lock,flags);
1269 return ret;
1270 } else {
1271 skb_push(skb, priv->ieee80211->tx_headroom);
1272 ret = rtl8192_tx(dev, skb);
1273 }
1274
1275 spin_unlock_irqrestore(&priv->tx_lock,flags);
1276
1277 return ret;
1278 }
1279
1280
1281 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1282
1283 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1284 u16 DrvAggr_PaddingAdd(struct net_device *dev, struct sk_buff *skb)
1285 {
1286 u16 PaddingNum = 256 - ((skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES) % 256);
1287 return (PaddingNum&0xff);
1288 }
1289
1290 u8 MRateToHwRate8190Pci(u8 rate);
1291 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc);
1292 u8 MapHwQueueToFirmwareQueue(u8 QueueID);
1293 struct sk_buff *DrvAggr_Aggregation(struct net_device *dev, struct ieee80211_drv_agg_txb *pSendList)
1294 {
1295 struct ieee80211_device *ieee = netdev_priv(dev);
1296 struct r8192_priv *priv = ieee80211_priv(dev);
1297 cb_desc *tcb_desc = NULL;
1298 u8 i;
1299 u32 TotalLength;
1300 struct sk_buff *skb;
1301 struct sk_buff *agg_skb;
1302 tx_desc_819x_usb_aggr_subframe *tx_agg_desc = NULL;
1303 tx_fwinfo_819x_usb *tx_fwinfo = NULL;
1304
1305 //
1306 // Local variable initialization.
1307 //
1308 /* first skb initialization */
1309 skb = pSendList->tx_agg_frames[0];
1310 TotalLength = skb->len;
1311
1312 /* Get the total aggregation length including the padding space and
1313 * sub frame header.
1314 */
1315 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1316 TotalLength += DrvAggr_PaddingAdd(dev, skb);
1317 skb = pSendList->tx_agg_frames[i];
1318 TotalLength += (skb->len + TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1319 }
1320
1321 /* allocate skb to contain the aggregated packets */
1322 agg_skb = dev_alloc_skb(TotalLength + ieee->tx_headroom);
1323 memset(agg_skb->data, 0, agg_skb->len);
1324 skb_reserve(agg_skb, ieee->tx_headroom);
1325
1326 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
1327 /* reserve info for first subframe Tx descriptor to be set in the tx function */
1328 skb = pSendList->tx_agg_frames[0];
1329 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1330 tcb_desc->drv_agg_enable = 1;
1331 tcb_desc->pkt_size = skb->len;
1332 tcb_desc->DrvAggrNum = pSendList->nr_drv_agg_frames;
1333 printk("DrvAggNum = %d\n", tcb_desc->DrvAggrNum);
1334 // RT_DEBUG_DATA(COMP_SEND, skb->cb, sizeof(skb->cb));
1335 // printk("========>skb->data ======> \n");
1336 // RT_DEBUG_DATA(COMP_SEND, skb->data, skb->len);
1337 memcpy(agg_skb->cb, skb->cb, sizeof(skb->cb));
1338 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1339
1340 for(i = 1; i < pSendList->nr_drv_agg_frames; i++) {
1341 /* push the next sub frame to be 256 byte aline */
1342 skb_put(agg_skb,DrvAggr_PaddingAdd(dev,skb));
1343
1344 /* Subframe drv Tx descriptor and firmware info setting */
1345 skb = pSendList->tx_agg_frames[i];
1346 tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1347 tx_agg_desc = (tx_desc_819x_usb_aggr_subframe *)agg_skb->tail;
1348 tx_fwinfo = (tx_fwinfo_819x_usb *)(agg_skb->tail + sizeof(tx_desc_819x_usb_aggr_subframe));
1349
1350 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
1351 /* DWORD 0 */
1352 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
1353 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
1354 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
1355 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
1356 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
1357 tx_fwinfo->AllowAggregation = 1;
1358 /* DWORD 1 */
1359 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
1360 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
1361 } else {
1362 tx_fwinfo->AllowAggregation = 0;
1363 /* DWORD 1 */
1364 tx_fwinfo->RxMF = 0;
1365 tx_fwinfo->RxAMD = 0;
1366 }
1367
1368 /* Protection mode related */
1369 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
1370 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
1371 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
1372 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
1373 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
1374 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
1375 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
1376 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
1377 (tcb_desc->bRTSUseShortGI?1:0);
1378
1379 /* Set Bandwidth and sub-channel settings. */
1380 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
1381 {
1382 if(tcb_desc->bPacketBW) {
1383 tx_fwinfo->TxBandwidth = 1;
1384 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
1385 } else {
1386 tx_fwinfo->TxBandwidth = 0;
1387 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
1388 }
1389 } else {
1390 tx_fwinfo->TxBandwidth = 0;
1391 tx_fwinfo->TxSubCarrier = 0;
1392 }
1393
1394 /* Fill Tx descriptor */
1395 memset(tx_agg_desc, 0, sizeof(tx_desc_819x_usb_aggr_subframe));
1396 /* DWORD 0 */
1397 //tx_agg_desc->LINIP = 0;
1398 //tx_agg_desc->CmdInit = 1;
1399 tx_agg_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
1400 /* already raw data, need not to substract header length */
1401 tx_agg_desc->PktSize = skb->len & 0xffff;
1402
1403 /*DWORD 1*/
1404 tx_agg_desc->SecCAMID= 0;
1405 tx_agg_desc->RATid = tcb_desc->RATRIndex;
1406 {
1407 //MPDUOverhead = 0;
1408 tx_agg_desc->NoEnc = 1;
1409 }
1410 tx_agg_desc->SecType = 0x0;
1411
1412 if (tcb_desc->bHwSec) {
1413 switch (priv->ieee80211->pairwise_key_type)
1414 {
1415 case KEY_TYPE_WEP40:
1416 case KEY_TYPE_WEP104:
1417 tx_agg_desc->SecType = 0x1;
1418 tx_agg_desc->NoEnc = 0;
1419 break;
1420 case KEY_TYPE_TKIP:
1421 tx_agg_desc->SecType = 0x2;
1422 tx_agg_desc->NoEnc = 0;
1423 break;
1424 case KEY_TYPE_CCMP:
1425 tx_agg_desc->SecType = 0x3;
1426 tx_agg_desc->NoEnc = 0;
1427 break;
1428 case KEY_TYPE_NA:
1429 tx_agg_desc->SecType = 0x0;
1430 tx_agg_desc->NoEnc = 1;
1431 break;
1432 }
1433 }
1434
1435 tx_agg_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
1436 tx_agg_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
1437
1438 tx_agg_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
1439 tx_agg_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
1440
1441 tx_agg_desc->OWN = 1;
1442
1443 //DWORD 2
1444 /* According windows driver, it seems that there no need to fill this field */
1445 //tx_agg_desc->TxBufferSize= (u32)(skb->len - USB_HWDESC_HEADER_LEN);
1446
1447 /* to fill next packet */
1448 skb_put(agg_skb,TX_PACKET_DRVAGGR_SUBFRAME_SHIFT_BYTES);
1449 memcpy(skb_put(agg_skb,skb->len),skb->data,skb->len);
1450 }
1451
1452 for(i = 0; i < pSendList->nr_drv_agg_frames; i++) {
1453 dev_kfree_skb_any(pSendList->tx_agg_frames[i]);
1454 }
1455
1456 return agg_skb;
1457 }
1458
1459 /* NOTE:
1460 This function return a list of PTCB which is proper to be aggregate with the input TCB.
1461 If no proper TCB is found to do aggregation, SendList will only contain the input TCB.
1462 */
1463 u8 DrvAggr_GetAggregatibleList(struct net_device *dev, struct sk_buff *skb,
1464 struct ieee80211_drv_agg_txb *pSendList)
1465 {
1466 struct ieee80211_device *ieee = netdev_priv(dev);
1467 PRT_HIGH_THROUGHPUT pHTInfo = ieee->pHTInfo;
1468 u16 nMaxAggrNum = pHTInfo->UsbTxAggrNum;
1469 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1470 u8 QueueID = tcb_desc->queue_index;
1471
1472 do {
1473 pSendList->tx_agg_frames[pSendList->nr_drv_agg_frames++] = skb;
1474 if(pSendList->nr_drv_agg_frames >= nMaxAggrNum) {
1475 break;
1476 }
1477
1478 } while((skb = skb_dequeue(&ieee->skb_drv_aggQ[QueueID])));
1479
1480 RT_TRACE(COMP_AMSDU, "DrvAggr_GetAggregatibleList, nAggrTcbNum = %d \n", pSendList->nr_drv_agg_frames);
1481 return pSendList->nr_drv_agg_frames;
1482 }
1483 #endif
1484
1485 static void rtl8192_tx_isr(struct urb *tx_urb)
1486 {
1487 struct sk_buff *skb = (struct sk_buff*)tx_urb->context;
1488 struct net_device *dev = NULL;
1489 struct r8192_priv *priv = NULL;
1490 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1491 u8 queue_index = tcb_desc->queue_index;
1492 // bool bToSend0Byte;
1493 // u16 BufLen = skb->len;
1494
1495 memcpy(&dev,(struct net_device*)(skb->cb),sizeof(struct net_device*));
1496 priv = ieee80211_priv(dev);
1497
1498 if(tcb_desc->queue_index != TXCMD_QUEUE) {
1499 if(tx_urb->status == 0) {
1500 dev->trans_start = jiffies;
1501 // As act as station mode, destion shall be unicast address.
1502 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1503 //priv->ieee80211->stats.tx_packets++;
1504 priv->stats.txoktotal++;
1505 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
1506 priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
1507 } else {
1508 priv->ieee80211->stats.tx_errors++;
1509 //priv->stats.txmanageerr++;
1510 /* TODO */
1511 }
1512 }
1513
1514 /* free skb and tx_urb */
1515 if(skb != NULL) {
1516 dev_kfree_skb_any(skb);
1517 usb_free_urb(tx_urb);
1518 atomic_dec(&priv->tx_pending[queue_index]);
1519 }
1520
1521 {
1522 //
1523 // Handle HW Beacon:
1524 // We had transfer our beacon frame to host controler at this moment.
1525 //
1526 //
1527 // Caution:
1528 // Handling the wait queue of command packets.
1529 // For Tx command packets, we must not do TCB fragment because it is not handled right now.
1530 // We must cut the packets to match the size of TX_CMD_PKT before we send it.
1531 //
1532
1533 /* Handle MPDU in wait queue. */
1534 if(queue_index != BEACON_QUEUE) {
1535 /* Don't send data frame during scanning.*/
1536 if((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0)&&\
1537 (!(priv->ieee80211->queue_stop))) {
1538 if(NULL != (skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]))))
1539 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1540
1541 return; //modified by david to avoid further processing AMSDU
1542 }
1543 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
1544 else if ((skb_queue_len(&priv->ieee80211->skb_drv_aggQ[queue_index])!= 0)&&\
1545 (!(priv->ieee80211->queue_stop))) {
1546 // Tx Driver Aggregation process
1547 /* The driver will aggregation the packets according to the following stets
1548 * 1. check whether there's tx irq available, for it's a completion return
1549 * function, it should contain enough tx irq;
1550 * 2. check pakcet type;
1551 * 3. intialize sendlist, check whether the to-be send packet no greater than 1
1552 * 4. aggregation the packets, and fill firmware info and tx desc to it, etc.
1553 * 5. check whehter the packet could be sent, otherwise just insert to wait head
1554 * */
1555 skb = skb_dequeue(&priv->ieee80211->skb_drv_aggQ[queue_index]);
1556 if(!check_nic_enough_desc(dev, queue_index)) {
1557 skb_queue_head(&(priv->ieee80211->skb_drv_aggQ[queue_index]), skb);
1558 return;
1559 }
1560
1561 {
1562 /*TODO*/
1563 /*
1564 u8* pHeader = skb->data;
1565
1566 if(IsMgntQosData(pHeader) ||
1567 IsMgntQData_Ack(pHeader) ||
1568 IsMgntQData_Poll(pHeader) ||
1569 IsMgntQData_Poll_Ack(pHeader)
1570 )
1571 */
1572 {
1573 struct ieee80211_drv_agg_txb SendList;
1574
1575 memset(&SendList, 0, sizeof(struct ieee80211_drv_agg_txb));
1576 if(DrvAggr_GetAggregatibleList(dev, skb, &SendList) > 1) {
1577 skb = DrvAggr_Aggregation(dev, &SendList);
1578
1579 }
1580 }
1581 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1582 }
1583 }
1584 #endif
1585 }
1586 }
1587
1588 }
1589
1590 void rtl8192_beacon_stop(struct net_device *dev)
1591 {
1592 u8 msr, msrm, msr2;
1593 struct r8192_priv *priv = ieee80211_priv(dev);
1594
1595 msr = read_nic_byte(dev, MSR);
1596 msrm = msr & MSR_LINK_MASK;
1597 msr2 = msr & ~MSR_LINK_MASK;
1598
1599 if(NIC_8192U == priv->card_8192) {
1600 usb_kill_urb(priv->rx_urb[MAX_RX_URB]);
1601 }
1602 if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
1603 (msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
1604 write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
1605 write_nic_byte(dev, MSR, msr);
1606 }
1607 }
1608
1609 void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1610 {
1611 struct r8192_priv *priv = ieee80211_priv(dev);
1612 struct ieee80211_network *net;
1613 u8 i=0, basic_rate = 0;
1614 net = & priv->ieee80211->current_network;
1615
1616 for (i=0; i<net->rates_len; i++)
1617 {
1618 basic_rate = net->rates[i]&0x7f;
1619 switch(basic_rate)
1620 {
1621 case MGN_1M: *rate_config |= RRSR_1M; break;
1622 case MGN_2M: *rate_config |= RRSR_2M; break;
1623 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1624 case MGN_11M: *rate_config |= RRSR_11M; break;
1625 case MGN_6M: *rate_config |= RRSR_6M; break;
1626 case MGN_9M: *rate_config |= RRSR_9M; break;
1627 case MGN_12M: *rate_config |= RRSR_12M; break;
1628 case MGN_18M: *rate_config |= RRSR_18M; break;
1629 case MGN_24M: *rate_config |= RRSR_24M; break;
1630 case MGN_36M: *rate_config |= RRSR_36M; break;
1631 case MGN_48M: *rate_config |= RRSR_48M; break;
1632 case MGN_54M: *rate_config |= RRSR_54M; break;
1633 }
1634 }
1635 for (i=0; i<net->rates_ex_len; i++)
1636 {
1637 basic_rate = net->rates_ex[i]&0x7f;
1638 switch(basic_rate)
1639 {
1640 case MGN_1M: *rate_config |= RRSR_1M; break;
1641 case MGN_2M: *rate_config |= RRSR_2M; break;
1642 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1643 case MGN_11M: *rate_config |= RRSR_11M; break;
1644 case MGN_6M: *rate_config |= RRSR_6M; break;
1645 case MGN_9M: *rate_config |= RRSR_9M; break;
1646 case MGN_12M: *rate_config |= RRSR_12M; break;
1647 case MGN_18M: *rate_config |= RRSR_18M; break;
1648 case MGN_24M: *rate_config |= RRSR_24M; break;
1649 case MGN_36M: *rate_config |= RRSR_36M; break;
1650 case MGN_48M: *rate_config |= RRSR_48M; break;
1651 case MGN_54M: *rate_config |= RRSR_54M; break;
1652 }
1653 }
1654 }
1655
1656
1657 #define SHORT_SLOT_TIME 9
1658 #define NON_SHORT_SLOT_TIME 20
1659
1660 void rtl8192_update_cap(struct net_device* dev, u16 cap)
1661 {
1662 u32 tmp = 0;
1663 struct r8192_priv *priv = ieee80211_priv(dev);
1664 struct ieee80211_network *net = &priv->ieee80211->current_network;
1665 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1666 tmp = priv->basic_rate;
1667 if (priv->short_preamble)
1668 tmp |= BRSR_AckShortPmb;
1669 write_nic_dword(dev, RRSR, tmp);
1670
1671 if (net->mode & (IEEE_G|IEEE_N_24G))
1672 {
1673 u8 slot_time = 0;
1674 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1675 {//short slot time
1676 slot_time = SHORT_SLOT_TIME;
1677 }
1678 else //long slot time
1679 slot_time = NON_SHORT_SLOT_TIME;
1680 priv->slot_time = slot_time;
1681 write_nic_byte(dev, SLOT_TIME, slot_time);
1682 }
1683
1684 }
1685 void rtl8192_net_update(struct net_device *dev)
1686 {
1687
1688 struct r8192_priv *priv = ieee80211_priv(dev);
1689 struct ieee80211_network *net;
1690 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1691 u16 rate_config = 0;
1692 net = & priv->ieee80211->current_network;
1693
1694 rtl8192_config_rate(dev, &rate_config);
1695 priv->basic_rate = rate_config &= 0x15f;
1696
1697 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1698 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1699 //for(i=0;i<ETH_ALEN;i++)
1700 // write_nic_byte(dev,BSSID+i,net->bssid[i]);
1701
1702 rtl8192_update_msr(dev);
1703 // rtl8192_update_cap(dev, net->capability);
1704 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1705 {
1706 write_nic_word(dev, ATIMWND, 2);
1707 write_nic_word(dev, BCN_DMATIME, 1023);
1708 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1709 // write_nic_word(dev, BcnIntTime, 100);
1710 write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
1711 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1712 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1713 // TODO: BcnIFS may required to be changed on ASIC
1714 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1715
1716 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1717 }
1718
1719
1720
1721 }
1722
1723 //temporary hw beacon is not used any more.
1724 //open it when necessary
1725 void rtl819xusb_beacon_tx(struct net_device *dev,u16 tx_rate)
1726 {
1727
1728 }
1729 inline u8 rtl8192_IsWirelessBMode(u16 rate)
1730 {
1731 if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
1732 return 1;
1733 else return 0;
1734 }
1735
1736 u16 N_DBPSOfRate(u16 DataRate);
1737
1738 u16 ComputeTxTime(
1739 u16 FrameLength,
1740 u16 DataRate,
1741 u8 bManagementFrame,
1742 u8 bShortPreamble
1743 )
1744 {
1745 u16 FrameTime;
1746 u16 N_DBPS;
1747 u16 Ceiling;
1748
1749 if( rtl8192_IsWirelessBMode(DataRate) )
1750 {
1751 if( bManagementFrame || !bShortPreamble || DataRate == 10 )
1752 { // long preamble
1753 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1754 }
1755 else
1756 { // Short preamble
1757 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1758 }
1759 if( ( FrameLength*8 % (DataRate/10) ) != 0 ) //Get the Ceilling
1760 FrameTime ++;
1761 } else { //802.11g DSSS-OFDM PLCP length field calculation.
1762 N_DBPS = N_DBPSOfRate(DataRate);
1763 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1764 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1765 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1766 }
1767 return FrameTime;
1768 }
1769
1770 u16 N_DBPSOfRate(u16 DataRate)
1771 {
1772 u16 N_DBPS = 24;
1773
1774 switch(DataRate)
1775 {
1776 case 60:
1777 N_DBPS = 24;
1778 break;
1779
1780 case 90:
1781 N_DBPS = 36;
1782 break;
1783
1784 case 120:
1785 N_DBPS = 48;
1786 break;
1787
1788 case 180:
1789 N_DBPS = 72;
1790 break;
1791
1792 case 240:
1793 N_DBPS = 96;
1794 break;
1795
1796 case 360:
1797 N_DBPS = 144;
1798 break;
1799
1800 case 480:
1801 N_DBPS = 192;
1802 break;
1803
1804 case 540:
1805 N_DBPS = 216;
1806 break;
1807
1808 default:
1809 break;
1810 }
1811
1812 return N_DBPS;
1813 }
1814
1815 void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
1816 {
1817 usb_free_urb(tx_cmd_urb);
1818 }
1819
1820 unsigned int txqueue2outpipe(struct r8192_priv* priv,unsigned int tx_queue) {
1821
1822 if(tx_queue >= 9)
1823 {
1824 RT_TRACE(COMP_ERR,"%s():Unknown queue ID!!!\n",__FUNCTION__);
1825 return 0x04;
1826 }
1827 return priv->txqueue_to_outpipemap[tx_queue];
1828 }
1829
1830 short rtl819xU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1831 {
1832 struct r8192_priv *priv = ieee80211_priv(dev);
1833 //u8 *tx;
1834 int status;
1835 struct urb *tx_urb;
1836 //int urb_buf_len;
1837 unsigned int idx_pipe;
1838 tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
1839 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1840 u8 queue_index = tcb_desc->queue_index;
1841
1842 //printk("\n %s::queue_index = %d\n",__FUNCTION__, queue_index);
1843 atomic_inc(&priv->tx_pending[queue_index]);
1844 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
1845 if(!tx_urb){
1846 dev_kfree_skb(skb);
1847 return -ENOMEM;
1848 }
1849
1850 memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
1851 /* Tx descriptor ought to be set according to the skb->cb */
1852 pdesc->FirstSeg = 1;//bFirstSeg;
1853 pdesc->LastSeg = 1;//bLastSeg;
1854 pdesc->CmdInit = tcb_desc->bCmdOrInit;
1855 pdesc->TxBufferSize = tcb_desc->txbuf_size;
1856 pdesc->OWN = 1;
1857 pdesc->LINIP = tcb_desc->bLastIniPkt;
1858
1859 //----------------------------------------------------------------------------
1860 // Fill up USB_OUT_CONTEXT.
1861 //----------------------------------------------------------------------------
1862 // Get index to out pipe from specified QueueID.
1863 #ifndef USE_ONE_PIPE
1864 idx_pipe = txqueue2outpipe(priv,queue_index);
1865 #else
1866 idx_pipe = 0x04;
1867 #endif
1868 #ifdef JOHN_DUMP_TXDESC
1869 int i;
1870 printk("<Tx descriptor>--rate %x---",rate);
1871 for (i = 0; i < 8; i++)
1872 printk("%8x ", tx[i]);
1873 printk("\n");
1874 #endif
1875 usb_fill_bulk_urb(tx_urb,priv->udev, usb_sndbulkpipe(priv->udev,idx_pipe), \
1876 skb->data, skb->len, rtl8192_tx_isr, skb);
1877
1878 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
1879
1880 if (!status){
1881 return 0;
1882 }else{
1883 DMESGE("Error TX CMD URB, error %d",
1884 status);
1885 return -1;
1886 }
1887 }
1888
1889 /*
1890 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
1891 * in TxFwInfo data structure
1892 * 2006.10.30 by Emily
1893 *
1894 * \param QUEUEID Software Queue
1895 */
1896 u8 MapHwQueueToFirmwareQueue(u8 QueueID)
1897 {
1898 u8 QueueSelect = 0x0; //defualt set to
1899
1900 switch(QueueID) {
1901 case BE_QUEUE:
1902 QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
1903 break;
1904
1905 case BK_QUEUE:
1906 QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
1907 break;
1908
1909 case VO_QUEUE:
1910 QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
1911 break;
1912
1913 case VI_QUEUE:
1914 QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
1915 break;
1916 case MGNT_QUEUE:
1917 QueueSelect = QSLT_MGNT;
1918 break;
1919
1920 case BEACON_QUEUE:
1921 QueueSelect = QSLT_BEACON;
1922 break;
1923
1924 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
1925 // TODO: Remove Assertions
1926 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
1927 case TXCMD_QUEUE:
1928 QueueSelect = QSLT_CMD;
1929 break;
1930 //#endif
1931 case HIGH_QUEUE:
1932 QueueSelect = QSLT_HIGH;
1933 break;
1934
1935 default:
1936 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
1937 break;
1938 }
1939 return QueueSelect;
1940 }
1941
1942 u8 MRateToHwRate8190Pci(u8 rate)
1943 {
1944 u8 ret = DESC90_RATE1M;
1945
1946 switch(rate) {
1947 case MGN_1M: ret = DESC90_RATE1M; break;
1948 case MGN_2M: ret = DESC90_RATE2M; break;
1949 case MGN_5_5M: ret = DESC90_RATE5_5M; break;
1950 case MGN_11M: ret = DESC90_RATE11M; break;
1951 case MGN_6M: ret = DESC90_RATE6M; break;
1952 case MGN_9M: ret = DESC90_RATE9M; break;
1953 case MGN_12M: ret = DESC90_RATE12M; break;
1954 case MGN_18M: ret = DESC90_RATE18M; break;
1955 case MGN_24M: ret = DESC90_RATE24M; break;
1956 case MGN_36M: ret = DESC90_RATE36M; break;
1957 case MGN_48M: ret = DESC90_RATE48M; break;
1958 case MGN_54M: ret = DESC90_RATE54M; break;
1959
1960 // HT rate since here
1961 case MGN_MCS0: ret = DESC90_RATEMCS0; break;
1962 case MGN_MCS1: ret = DESC90_RATEMCS1; break;
1963 case MGN_MCS2: ret = DESC90_RATEMCS2; break;
1964 case MGN_MCS3: ret = DESC90_RATEMCS3; break;
1965 case MGN_MCS4: ret = DESC90_RATEMCS4; break;
1966 case MGN_MCS5: ret = DESC90_RATEMCS5; break;
1967 case MGN_MCS6: ret = DESC90_RATEMCS6; break;
1968 case MGN_MCS7: ret = DESC90_RATEMCS7; break;
1969 case MGN_MCS8: ret = DESC90_RATEMCS8; break;
1970 case MGN_MCS9: ret = DESC90_RATEMCS9; break;
1971 case MGN_MCS10: ret = DESC90_RATEMCS10; break;
1972 case MGN_MCS11: ret = DESC90_RATEMCS11; break;
1973 case MGN_MCS12: ret = DESC90_RATEMCS12; break;
1974 case MGN_MCS13: ret = DESC90_RATEMCS13; break;
1975 case MGN_MCS14: ret = DESC90_RATEMCS14; break;
1976 case MGN_MCS15: ret = DESC90_RATEMCS15; break;
1977 case (0x80|0x20): ret = DESC90_RATEMCS32; break;
1978
1979 default: break;
1980 }
1981 return ret;
1982 }
1983
1984
1985 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
1986 {
1987 u8 tmp_Short;
1988
1989 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
1990
1991 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
1992 tmp_Short = 0;
1993
1994 return tmp_Short;
1995 }
1996
1997 static void tx_zero_isr(struct urb *tx_urb)
1998 {
1999 return;
2000 }
2001
2002 /*
2003 * The tx procedure is just as following,
2004 * skb->cb will contain all the following information,
2005 * priority, morefrag, rate, &dev.
2006 * */
2007 short rtl8192_tx(struct net_device *dev, struct sk_buff* skb)
2008 {
2009 struct r8192_priv *priv = ieee80211_priv(dev);
2010 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2011 tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
2012 tx_fwinfo_819x_usb *tx_fwinfo = (tx_fwinfo_819x_usb *)(skb->data + USB_HWDESC_HEADER_LEN);
2013 struct usb_device *udev = priv->udev;
2014 int pend;
2015 int status;
2016 struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
2017 //int urb_len;
2018 unsigned int idx_pipe;
2019 // RT_DEBUG_DATA(COMP_SEND, tcb_desc, sizeof(cb_desc));
2020 // printk("=============> %s\n", __FUNCTION__);
2021 pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
2022 /* we are locked here so the two atomic_read and inc are executed
2023 * without interleaves
2024 * !!! For debug purpose
2025 */
2026 if( pend > MAX_TX_URB){
2027 printk("To discard skb packet!\n");
2028 dev_kfree_skb_any(skb);
2029 return -1;
2030 }
2031
2032 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
2033 if(!tx_urb){
2034 dev_kfree_skb_any(skb);
2035 return -ENOMEM;
2036 }
2037
2038 /* Fill Tx firmware info */
2039 memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
2040 /* DWORD 0 */
2041 tx_fwinfo->TxHT = (tcb_desc->data_rate&0x80)?1:0;
2042 tx_fwinfo->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
2043 tx_fwinfo->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
2044 tx_fwinfo->Short = QueryIsShort(tx_fwinfo->TxHT, tx_fwinfo->TxRate, tcb_desc);
2045 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
2046 tx_fwinfo->AllowAggregation = 1;
2047 /* DWORD 1 */
2048 tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
2049 tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
2050 } else {
2051 tx_fwinfo->AllowAggregation = 0;
2052 /* DWORD 1 */
2053 tx_fwinfo->RxMF = 0;
2054 tx_fwinfo->RxAMD = 0;
2055 }
2056
2057 /* Protection mode related */
2058 tx_fwinfo->RtsEnable = (tcb_desc->bRTSEnable)?1:0;
2059 tx_fwinfo->CtsEnable = (tcb_desc->bCTSEnable)?1:0;
2060 tx_fwinfo->RtsSTBC = (tcb_desc->bRTSSTBC)?1:0;
2061 tx_fwinfo->RtsHT = (tcb_desc->rts_rate&0x80)?1:0;
2062 tx_fwinfo->RtsRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
2063 tx_fwinfo->RtsSubcarrier = (tx_fwinfo->RtsHT==0)?(tcb_desc->RTSSC):0;
2064 tx_fwinfo->RtsBandwidth = (tx_fwinfo->RtsHT==1)?((tcb_desc->bRTSBW)?1:0):0;
2065 tx_fwinfo->RtsShort = (tx_fwinfo->RtsHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
2066 (tcb_desc->bRTSUseShortGI?1:0);
2067
2068 /* Set Bandwidth and sub-channel settings. */
2069 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
2070 {
2071 if(tcb_desc->bPacketBW) {
2072 tx_fwinfo->TxBandwidth = 1;
2073 tx_fwinfo->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
2074 } else {
2075 tx_fwinfo->TxBandwidth = 0;
2076 tx_fwinfo->TxSubCarrier = priv->nCur40MhzPrimeSC;
2077 }
2078 } else {
2079 tx_fwinfo->TxBandwidth = 0;
2080 tx_fwinfo->TxSubCarrier = 0;
2081 }
2082
2083 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2084 if (tcb_desc->drv_agg_enable)
2085 {
2086 tx_fwinfo->Tx_INFO_RSVD = (tcb_desc->DrvAggrNum & 0x1f) << 1;
2087 }
2088 #endif
2089 /* Fill Tx descriptor */
2090 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
2091 /* DWORD 0 */
2092 tx_desc->LINIP = 0;
2093 tx_desc->CmdInit = 1;
2094 tx_desc->Offset = sizeof(tx_fwinfo_819x_usb) + 8;
2095
2096 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2097 if (tcb_desc->drv_agg_enable) {
2098 tx_desc->PktSize = tcb_desc->pkt_size;
2099 } else
2100 #endif
2101 {
2102 tx_desc->PktSize = (skb->len - TX_PACKET_SHIFT_BYTES) & 0xffff;
2103 }
2104
2105 /*DWORD 1*/
2106 tx_desc->SecCAMID= 0;
2107 tx_desc->RATid = tcb_desc->RATRIndex;
2108 {
2109 //MPDUOverhead = 0;
2110 tx_desc->NoEnc = 1;
2111 }
2112 tx_desc->SecType = 0x0;
2113 if (tcb_desc->bHwSec)
2114 {
2115 switch (priv->ieee80211->pairwise_key_type)
2116 {
2117 case KEY_TYPE_WEP40:
2118 case KEY_TYPE_WEP104:
2119 tx_desc->SecType = 0x1;
2120 tx_desc->NoEnc = 0;
2121 break;
2122 case KEY_TYPE_TKIP:
2123 tx_desc->SecType = 0x2;
2124 tx_desc->NoEnc = 0;
2125 break;
2126 case KEY_TYPE_CCMP:
2127 tx_desc->SecType = 0x3;
2128 tx_desc->NoEnc = 0;
2129 break;
2130 case KEY_TYPE_NA:
2131 tx_desc->SecType = 0x0;
2132 tx_desc->NoEnc = 1;
2133 break;
2134 }
2135 }
2136
2137 tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
2138 tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);
2139
2140 tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
2141 tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
2142
2143 /* Fill fields that are required to be initialized in all of the descriptors */
2144 //DWORD 0
2145 tx_desc->FirstSeg = 1;
2146 tx_desc->LastSeg = 1;
2147 tx_desc->OWN = 1;
2148
2149 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
2150 if (tcb_desc->drv_agg_enable) {
2151 tx_desc->TxBufferSize = tcb_desc->pkt_size + sizeof(tx_fwinfo_819x_usb);
2152 } else
2153 #endif
2154 {
2155 //DWORD 2
2156 tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
2157 }
2158 /* Get index to out pipe from specified QueueID */
2159 #ifndef USE_ONE_PIPE
2160 idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
2161 #else
2162 idx_pipe = 0x5;
2163 #endif
2164
2165 //RT_DEBUG_DATA(COMP_SEND,tx_fwinfo,sizeof(tx_fwinfo_819x_usb));
2166 //RT_DEBUG_DATA(COMP_SEND,tx_desc,sizeof(tx_desc_819x_usb));
2167
2168 /* To submit bulk urb */
2169 usb_fill_bulk_urb(tx_urb,udev,
2170 usb_sndbulkpipe(udev,idx_pipe), skb->data,
2171 skb->len, rtl8192_tx_isr, skb);
2172
2173 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
2174 if (!status){
2175 //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
2176 bool bSend0Byte = false;
2177 u8 zero = 0;
2178 if(udev->speed == USB_SPEED_HIGH)
2179 {
2180 if (skb->len > 0 && skb->len % 512 == 0)
2181 bSend0Byte = true;
2182 }
2183 else
2184 {
2185 if (skb->len > 0 && skb->len % 64 == 0)
2186 bSend0Byte = true;
2187 }
2188 if (bSend0Byte)
2189 {
2190 tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
2191 if(!tx_urb_zero){
2192 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
2193 return -ENOMEM;
2194 }
2195 usb_fill_bulk_urb(tx_urb_zero,udev,
2196 usb_sndbulkpipe(udev,idx_pipe), &zero,
2197 0, tx_zero_isr, dev);
2198 status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
2199 if (status){
2200 RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
2201 return -1;
2202 }
2203 }
2204 dev->trans_start = jiffies;
2205 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
2206 return 0;
2207 }else{
2208 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
2209 status);
2210 return -1;
2211 }
2212 }
2213
2214 short rtl8192_usb_initendpoints(struct net_device *dev)
2215 {
2216 struct r8192_priv *priv = ieee80211_priv(dev);
2217
2218 priv->rx_urb = (struct urb**) kmalloc (sizeof(struct urb*) * (MAX_RX_URB+1), GFP_KERNEL);
2219
2220 #ifndef JACKSON_NEW_RX
2221 for(i=0;i<(MAX_RX_URB+1);i++){
2222
2223 priv->rx_urb[i] = usb_alloc_urb(0,GFP_KERNEL);
2224
2225 priv->rx_urb[i]->transfer_buffer = kmalloc(RX_URB_SIZE, GFP_KERNEL);
2226
2227 priv->rx_urb[i]->transfer_buffer_length = RX_URB_SIZE;
2228 }
2229 #endif
2230
2231 #ifdef THOMAS_BEACON
2232 {
2233 long align = 0;
2234 void *oldaddr, *newaddr;
2235
2236 priv->rx_urb[16] = usb_alloc_urb(0, GFP_KERNEL);
2237 priv->oldaddr = kmalloc(16, GFP_KERNEL);
2238 oldaddr = priv->oldaddr;
2239 align = ((long)oldaddr) & 3;
2240 if (align) {
2241 newaddr = oldaddr + 4 - align;
2242 priv->rx_urb[16]->transfer_buffer_length = 16 - 4 + align;
2243 } else {
2244 newaddr = oldaddr;
2245 priv->rx_urb[16]->transfer_buffer_length = 16;
2246 }
2247 priv->rx_urb[16]->transfer_buffer = newaddr;
2248 }
2249 #endif
2250
2251 memset(priv->rx_urb, 0, sizeof(struct urb*) * MAX_RX_URB);
2252 priv->pp_rxskb = (struct sk_buff **)kmalloc(sizeof(struct sk_buff *) * MAX_RX_URB, GFP_KERNEL);
2253 if (priv->pp_rxskb == NULL)
2254 goto destroy;
2255
2256 memset(priv->pp_rxskb, 0, sizeof(struct sk_buff*) * MAX_RX_URB);
2257
2258 goto _middle;
2259
2260
2261 destroy:
2262 if (priv->pp_rxskb) {
2263 kfree(priv->pp_rxskb);
2264 }
2265 if (priv->rx_urb) {
2266 kfree(priv->rx_urb);
2267 }
2268
2269 priv->pp_rxskb = NULL;
2270 priv->rx_urb = NULL;
2271
2272 DMESGE("Endpoint Alloc Failure");
2273 return -ENOMEM;
2274
2275
2276 _middle:
2277
2278 printk("End of initendpoints\n");
2279 return 0;
2280
2281 }
2282 #ifdef THOMAS_BEACON
2283 void rtl8192_usb_deleteendpoints(struct net_device *dev)
2284 {
2285 int i;
2286 struct r8192_priv *priv = ieee80211_priv(dev);
2287
2288 if(priv->rx_urb){
2289 for(i=0;i<(MAX_RX_URB+1);i++){
2290 usb_kill_urb(priv->rx_urb[i]);
2291 usb_free_urb(priv->rx_urb[i]);
2292 }
2293 kfree(priv->rx_urb);
2294 priv->rx_urb = NULL;
2295 }
2296 if(priv->oldaddr){
2297 kfree(priv->oldaddr);
2298 priv->oldaddr = NULL;
2299 }
2300 if (priv->pp_rxskb) {
2301 kfree(priv->pp_rxskb);
2302 priv->pp_rxskb = 0;
2303 }
2304 }
2305 #else
2306 void rtl8192_usb_deleteendpoints(struct net_device *dev)
2307 {
2308 int i;
2309 struct r8192_priv *priv = ieee80211_priv(dev);
2310
2311 #ifndef JACKSON_NEW_RX
2312
2313 if(priv->rx_urb){
2314 for(i=0;i<(MAX_RX_URB+1);i++){
2315 usb_kill_urb(priv->rx_urb[i]);
2316 kfree(priv->rx_urb[i]->transfer_buffer);
2317 usb_free_urb(priv->rx_urb[i]);
2318 }
2319 kfree(priv->rx_urb);
2320 priv->rx_urb = NULL;
2321
2322 }
2323 #else
2324 if(priv->rx_urb){
2325 kfree(priv->rx_urb);
2326 priv->rx_urb = NULL;
2327 }
2328 if(priv->oldaddr){
2329 kfree(priv->oldaddr);
2330 priv->oldaddr = NULL;
2331 }
2332 if (priv->pp_rxskb) {
2333 kfree(priv->pp_rxskb);
2334 priv->pp_rxskb = 0;
2335
2336 }
2337
2338 #endif
2339 }
2340 #endif
2341
2342 extern void rtl8192_update_ratr_table(struct net_device* dev);
2343 void rtl8192_link_change(struct net_device *dev)
2344 {
2345 // int i;
2346
2347 struct r8192_priv *priv = ieee80211_priv(dev);
2348 struct ieee80211_device* ieee = priv->ieee80211;
2349 //write_nic_word(dev, BCN_INTR_ITV, net->beacon_interval);
2350 if (ieee->state == IEEE80211_LINKED)
2351 {
2352 rtl8192_net_update(dev);
2353 rtl8192_update_ratr_table(dev);
2354 //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
2355 if ((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type))
2356 EnableHWSecurityConfig8192(dev);
2357 }
2358 /*update timing params*/
2359 // RT_TRACE(COMP_CH, "========>%s(), chan:%d\n", __FUNCTION__, priv->chan);
2360 // rtl8192_set_chan(dev, priv->chan);
2361 if (ieee->iw_mode == IW_MODE_INFRA || ieee->iw_mode == IW_MODE_ADHOC)
2362 {
2363 u32 reg = 0;
2364 reg = read_nic_dword(dev, RCR);
2365 if (priv->ieee80211->state == IEEE80211_LINKED)
2366 priv->ReceiveConfig = reg |= RCR_CBSSID;
2367 else
2368 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
2369 write_nic_dword(dev, RCR, reg);
2370 }
2371
2372 // rtl8192_set_rxconf(dev);
2373 }
2374
2375 static struct ieee80211_qos_parameters def_qos_parameters = {
2376 {3,3,3,3},/* cw_min */
2377 {7,7,7,7},/* cw_max */
2378 {2,2,2,2},/* aifs */
2379 {0,0,0,0},/* flags */
2380 {0,0,0,0} /* tx_op_limit */
2381 };
2382
2383
2384 void rtl8192_update_beacon(struct work_struct * work)
2385 {
2386 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
2387 struct net_device *dev = priv->ieee80211->dev;
2388 struct ieee80211_device* ieee = priv->ieee80211;
2389 struct ieee80211_network* net = &ieee->current_network;
2390
2391 if (ieee->pHTInfo->bCurrentHTSupport)
2392 HTUpdateSelfAndPeerSetting(ieee, net);
2393 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
2394 rtl8192_update_cap(dev, net->capability);
2395 }
2396 /*
2397 * background support to run QoS activate functionality
2398 */
2399 int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
2400 void rtl8192_qos_activate(struct work_struct * work)
2401 {
2402 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
2403 struct net_device *dev = priv->ieee80211->dev;
2404 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
2405 u8 mode = priv->ieee80211->current_network.mode;
2406 //u32 size = sizeof(struct ieee80211_qos_parameters);
2407 u8 u1bAIFS;
2408 u32 u4bAcParam;
2409 int i;
2410
2411 if (priv == NULL)
2412 return;
2413
2414 mutex_lock(&priv->mutex);
2415 if(priv->ieee80211->state != IEEE80211_LINKED)
2416 goto success;
2417 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
2418 /* It better set slot time at first */
2419 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
2420 /* update the ac parameter to related registers */
2421 for(i = 0; i < QOS_QUEUE_NUM; i++) {
2422 //Mode G/A: slotTimeTimer = 9; Mode B: 20
2423 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
2424 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
2425 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
2426 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
2427 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
2428
2429 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
2430 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4332);
2431 }
2432
2433 success:
2434 mutex_unlock(&priv->mutex);
2435 }
2436
2437 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
2438 int active_network,
2439 struct ieee80211_network *network)
2440 {
2441 int ret = 0;
2442 u32 size = sizeof(struct ieee80211_qos_parameters);
2443
2444 if(priv->ieee80211->state !=IEEE80211_LINKED)
2445 return ret;
2446
2447 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2448 return ret;
2449
2450 if (network->flags & NETWORK_HAS_QOS_MASK) {
2451 if (active_network &&
2452 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
2453 network->qos_data.active = network->qos_data.supported;
2454
2455 if ((network->qos_data.active == 1) && (active_network == 1) &&
2456 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
2457 (network->qos_data.old_param_count !=
2458 network->qos_data.param_count)) {
2459 network->qos_data.old_param_count =
2460 network->qos_data.param_count;
2461 queue_work(priv->priv_wq, &priv->qos_activate);
2462 RT_TRACE (COMP_QOS, "QoS parameters change call "
2463 "qos_activate\n");
2464 }
2465 } else {
2466 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2467 &def_qos_parameters, size);
2468
2469 if ((network->qos_data.active == 1) && (active_network == 1)) {
2470 queue_work(priv->priv_wq, &priv->qos_activate);
2471 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
2472 }
2473 network->qos_data.active = 0;
2474 network->qos_data.supported = 0;
2475 }
2476
2477 return 0;
2478 }
2479
2480 /* handle manage frame frame beacon and probe response */
2481 static int rtl8192_handle_beacon(struct net_device * dev,
2482 struct ieee80211_beacon * beacon,
2483 struct ieee80211_network * network)
2484 {
2485 struct r8192_priv *priv = ieee80211_priv(dev);
2486
2487 rtl8192_qos_handle_probe_response(priv,1,network);
2488 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
2489 return 0;
2490
2491 }
2492
2493 /*
2494 * handling the beaconing responses. if we get different QoS setting
2495 * off the network from the associated setting, adjust the QoS
2496 * setting
2497 */
2498 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
2499 struct ieee80211_network *network)
2500 {
2501 int ret = 0;
2502 unsigned long flags;
2503 u32 size = sizeof(struct ieee80211_qos_parameters);
2504 int set_qos_param = 0;
2505
2506 if ((priv == NULL) || (network == NULL))
2507 return ret;
2508
2509 if(priv->ieee80211->state !=IEEE80211_LINKED)
2510 return ret;
2511
2512 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2513 return ret;
2514
2515 spin_lock_irqsave(&priv->ieee80211->lock, flags);
2516 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
2517 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2518 &network->qos_data.parameters,\
2519 sizeof(struct ieee80211_qos_parameters));
2520 priv->ieee80211->current_network.qos_data.active = 1;
2521 {
2522 set_qos_param = 1;
2523 /* update qos parameter for current network */
2524 priv->ieee80211->current_network.qos_data.old_param_count = \
2525 priv->ieee80211->current_network.qos_data.param_count;
2526 priv->ieee80211->current_network.qos_data.param_count = \
2527 network->qos_data.param_count;
2528 }
2529 } else {
2530 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2531 &def_qos_parameters, size);
2532 priv->ieee80211->current_network.qos_data.active = 0;
2533 priv->ieee80211->current_network.qos_data.supported = 0;
2534 set_qos_param = 1;
2535 }
2536
2537 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
2538
2539 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
2540 if (set_qos_param == 1)
2541 queue_work(priv->priv_wq, &priv->qos_activate);
2542
2543
2544 return ret;
2545 }
2546
2547
2548 static int rtl8192_handle_assoc_response(struct net_device *dev,
2549 struct ieee80211_assoc_response_frame *resp,
2550 struct ieee80211_network *network)
2551 {
2552 struct r8192_priv *priv = ieee80211_priv(dev);
2553 rtl8192_qos_association_resp(priv, network);
2554 return 0;
2555 }
2556
2557
2558 void rtl8192_update_ratr_table(struct net_device* dev)
2559 // POCTET_STRING posLegacyRate,
2560 // u8* pMcsRate)
2561 // PRT_WLAN_STA pEntry)
2562 {
2563 struct r8192_priv* priv = ieee80211_priv(dev);
2564 struct ieee80211_device* ieee = priv->ieee80211;
2565 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2566 //struct ieee80211_network *net = &ieee->current_network;
2567 u32 ratr_value = 0;
2568 u8 rate_index = 0;
2569 rtl8192_config_rate(dev, (u16*)(&ratr_value));
2570 ratr_value |= (*(u16*)(pMcsRate)) << 12;
2571 // switch (net->mode)
2572 switch (ieee->mode)
2573 {
2574 case IEEE_A:
2575 ratr_value &= 0x00000FF0;
2576 break;
2577 case IEEE_B:
2578 ratr_value &= 0x0000000F;
2579 break;
2580 case IEEE_G:
2581 ratr_value &= 0x00000FF7;
2582 break;
2583 case IEEE_N_24G:
2584 case IEEE_N_5G:
2585 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
2586 ratr_value &= 0x0007F007;
2587 else{
2588 if (priv->rf_type == RF_1T2R)
2589 ratr_value &= 0x000FF007;
2590 else
2591 ratr_value &= 0x0F81F007;
2592 }
2593 break;
2594 default:
2595 break;
2596 }
2597 ratr_value &= 0x0FFFFFFF;
2598 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
2599 ratr_value |= 0x80000000;
2600 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
2601 ratr_value |= 0x80000000;
2602 }
2603 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2604 write_nic_byte(dev, UFWP, 1);
2605 }
2606
2607 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
2608 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2609 bool GetNmodeSupportBySecCfg8192(struct net_device*dev)
2610 {
2611 struct r8192_priv* priv = ieee80211_priv(dev);
2612 struct ieee80211_device* ieee = priv->ieee80211;
2613 struct ieee80211_network * network = &ieee->current_network;
2614 int wpa_ie_len= ieee->wpa_ie_len;
2615 struct ieee80211_crypt_data* crypt;
2616 int encrypt;
2617
2618 crypt = ieee->crypt[ieee->tx_keyidx];
2619 //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
2620 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2621
2622 /* simply judge */
2623 if(encrypt && (wpa_ie_len == 0)) {
2624 /* wep encryption, no N mode setting */
2625 return false;
2626 // } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
2627 } else if((wpa_ie_len != 0)) {
2628 /* parse pairwise key type */
2629 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
2630 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))))
2631 return true;
2632 else
2633 return false;
2634 } else {
2635 return true;
2636 }
2637
2638 return true;
2639 }
2640
2641 bool GetHalfNmodeSupportByAPs819xUsb(struct net_device* dev)
2642 {
2643 bool Reval;
2644 struct r8192_priv* priv = ieee80211_priv(dev);
2645 struct ieee80211_device* ieee = priv->ieee80211;
2646
2647 if(ieee->bHalfWirelessN24GMode == true)
2648 Reval = true;
2649 else
2650 Reval = false;
2651
2652 return Reval;
2653 }
2654
2655 void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2656 {
2657 struct ieee80211_device* ieee = priv->ieee80211;
2658 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
2659 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2660 {
2661 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2662 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
2663 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
2664 }
2665 else
2666 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2667 return;
2668 }
2669
2670 u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2671 {
2672 struct r8192_priv *priv = ieee80211_priv(dev);
2673 u8 ret = 0;
2674 switch(priv->rf_chip)
2675 {
2676 case RF_8225:
2677 case RF_8256:
2678 case RF_PSEUDO_11N:
2679 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2680 break;
2681 case RF_8258:
2682 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2683 break;
2684 default:
2685 ret = WIRELESS_MODE_B;
2686 break;
2687 }
2688 return ret;
2689 }
2690 void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2691 {
2692 struct r8192_priv *priv = ieee80211_priv(dev);
2693 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2694
2695 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2696 {
2697 if(bSupportMode & WIRELESS_MODE_N_24G)
2698 {
2699 wireless_mode = WIRELESS_MODE_N_24G;
2700 }
2701 else if(bSupportMode & WIRELESS_MODE_N_5G)
2702 {
2703 wireless_mode = WIRELESS_MODE_N_5G;
2704 }
2705 else if((bSupportMode & WIRELESS_MODE_A))
2706 {
2707 wireless_mode = WIRELESS_MODE_A;
2708 }
2709 else if((bSupportMode & WIRELESS_MODE_G))
2710 {
2711 wireless_mode = WIRELESS_MODE_G;
2712 }
2713 else if((bSupportMode & WIRELESS_MODE_B))
2714 {
2715 wireless_mode = WIRELESS_MODE_B;
2716 }
2717 else{
2718 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2719 wireless_mode = WIRELESS_MODE_B;
2720 }
2721 }
2722 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we shoud wait for FPGA
2723 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2724 #endif
2725 priv->ieee80211->mode = wireless_mode;
2726
2727 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2728 priv->ieee80211->pHTInfo->bEnableHT = 1;
2729 else
2730 priv->ieee80211->pHTInfo->bEnableHT = 0;
2731 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2732 rtl8192_refresh_supportrate(priv);
2733
2734 }
2735 //init priv variables here. only non_zero value should be initialized here.
2736 static void rtl8192_init_priv_variable(struct net_device* dev)
2737 {
2738 struct r8192_priv *priv = ieee80211_priv(dev);
2739 u8 i;
2740 priv->card_8192 = NIC_8192U;
2741 priv->chan = 1; //set to channel 1
2742 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
2743 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2744 priv->ieee80211->ieee_up=0;
2745 priv->retry_rts = DEFAULT_RETRY_RTS;
2746 priv->retry_data = DEFAULT_RETRY_DATA;
2747 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
2748 priv->ieee80211->rate = 110; //11 mbps
2749 priv->ieee80211->short_slot = 1;
2750 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
2751 priv->CckPwEnl = 6;
2752 //for silent reset
2753 priv->IrpPendingCount = 1;
2754 priv->ResetProgress = RESET_TYPE_NORESET;
2755 priv->bForcedSilentReset = 0;
2756 priv->bDisableNormalResetCheck = false;
2757 priv->force_reset = false;
2758
2759 priv->ieee80211->FwRWRF = 0; //we don't use FW read/write RF until stable firmware is available.
2760 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
2761 priv->ieee80211->iw_mode = IW_MODE_INFRA;
2762 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
2763 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
2764 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
2765 IEEE_SOFTMAC_BEACONS;//added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
2766
2767 priv->ieee80211->active_scan = 1;
2768 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
2769 priv->ieee80211->host_encrypt = 1;
2770 priv->ieee80211->host_decrypt = 1;
2771 priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
2772 priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
2773 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
2774 priv->ieee80211->set_chan = rtl8192_set_chan;
2775 priv->ieee80211->link_change = rtl8192_link_change;
2776 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
2777 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
2778 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
2779 priv->ieee80211->init_wmmparam_flag = 0;
2780 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
2781 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
2782 priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
2783 priv->ieee80211->qos_support = 1;
2784
2785 //added by WB
2786 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
2787 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
2788 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
2789 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
2790 //added by david
2791 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
2792 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
2793 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
2794 //added by amy
2795 priv->ieee80211->InitialGainHandler = InitialGain819xUsb;
2796 priv->card_type = USB;
2797 #ifdef TO_DO_LIST
2798 if(Adapter->bInHctTest)
2799 {
2800 pHalData->ShortRetryLimit = 7;
2801 pHalData->LongRetryLimit = 7;
2802 }
2803 #endif
2804 {
2805 priv->ShortRetryLimit = 0x30;
2806 priv->LongRetryLimit = 0x30;
2807 }
2808 priv->EarlyRxThreshold = 7;
2809 priv->enable_gpio0 = 0;
2810 priv->TransmitConfig =
2811 // TCR_DurProcMode | //for RTL8185B, duration setting by HW
2812 //? TCR_DISReqQsize |
2813 (TCR_MXDMA_2048<<TCR_MXDMA_OFFSET)| // Max DMA Burst Size per Tx DMA Burst, 7: reservied.
2814 (priv->ShortRetryLimit<<TCR_SRL_OFFSET)| // Short retry limit
2815 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
2816 (false ? TCR_SAT: 0); // FALSE: HW provies PLCP length and LENGEXT, TURE: SW proiveds them
2817 #ifdef TO_DO_LIST
2818 if(Adapter->bInHctTest)
2819 pHalData->ReceiveConfig = pHalData->CSMethod |
2820 RCR_AMF | RCR_ADF | //RCR_AAP | //accept management/data
2821 //guangan200710
2822 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2823 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2824 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2825 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2826 (pHalData->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
2827 (pHalData->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt:0);
2828 else
2829
2830 #endif
2831 priv->ReceiveConfig =
2832 RCR_AMF | RCR_ADF | //accept management/data
2833 RCR_ACF | //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
2834 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
2835 //RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
2836 ((u32)7<<RCR_MXDMA_OFFSET)| // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
2837 (priv->EarlyRxThreshold<<RX_FIFO_THRESHOLD_SHIFT) | // Rx FIFO Threshold, 7: No Rx threshold.
2838 (priv->EarlyRxThreshold == 7 ? RCR_ONLYERLPKT:0);
2839
2840 priv->AcmControl = 0;
2841 priv->pFirmware = (rt_firmware*)kmalloc(sizeof(rt_firmware), GFP_KERNEL);
2842 if (priv->pFirmware)
2843 memset(priv->pFirmware, 0, sizeof(rt_firmware));
2844
2845 /* rx related queue */
2846 skb_queue_head_init(&priv->rx_queue);
2847 skb_queue_head_init(&priv->skb_queue);
2848
2849 /* Tx related queue */
2850 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2851 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
2852 }
2853 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2854 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
2855 }
2856 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
2857 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ [i]);
2858 }
2859 priv->rf_set_chan = rtl8192_phy_SwChnl;
2860 }
2861
2862 //init lock here
2863 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
2864 {
2865 spin_lock_init(&priv->tx_lock);
2866 spin_lock_init(&priv->irq_lock);//added by thomas
2867 //spin_lock_init(&priv->rf_lock);
2868 sema_init(&priv->wx_sem,1);
2869 sema_init(&priv->rf_sem,1);
2870 mutex_init(&priv->mutex);
2871 }
2872
2873 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
2874
2875 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
2876 //init tasklet and wait_queue here. only 2.6 above kernel is considered
2877 #define DRV_NAME "wlan0"
2878 static void rtl8192_init_priv_task(struct net_device* dev)
2879 {
2880 struct r8192_priv *priv = ieee80211_priv(dev);
2881
2882 #ifdef PF_SYNCTHREAD
2883 priv->priv_wq = create_workqueue(DRV_NAME,0);
2884 #else
2885 priv->priv_wq = create_workqueue(DRV_NAME);
2886 #endif
2887
2888 INIT_WORK(&priv->reset_wq, rtl8192_restart);
2889
2890 //INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
2891 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
2892 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
2893 // INIT_DELAYED_WORK(&priv->gpio_change_rf_wq, dm_gpio_change_rf_callback);
2894 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
2895 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
2896 INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
2897 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
2898 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
2899 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
2900
2901 tasklet_init(&priv->irq_rx_tasklet,
2902 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
2903 (unsigned long)priv);
2904 }
2905
2906 static void rtl8192_get_eeprom_size(struct net_device* dev)
2907 {
2908 u16 curCR = 0;
2909 struct r8192_priv *priv = ieee80211_priv(dev);
2910 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2911 curCR = read_nic_word_E(dev,EPROM_CMD);
2912 RT_TRACE(COMP_EPROM, "read from Reg EPROM_CMD(%x):%x\n", EPROM_CMD, curCR);
2913 //whether need I consider BIT5?
2914 priv->epromtype = (curCR & Cmd9346CR_9356SEL) ? EPROM_93c56 : EPROM_93c46;
2915 RT_TRACE(COMP_EPROM, "<===========%s(), epromtype:%d\n", __FUNCTION__, priv->epromtype);
2916 }
2917
2918 //used to swap endian. as ntohl & htonl are not neccessary to swap endian, so use this instead.
2919 static inline u16 endian_swap(u16* data)
2920 {
2921 u16 tmp = *data;
2922 *data = (tmp >> 8) | (tmp << 8);
2923 return *data;
2924 }
2925 static void rtl8192_read_eeprom_info(struct net_device* dev)
2926 {
2927 u16 wEPROM_ID = 0;
2928 u8 bMac_Tmp_Addr[6] = {0x00, 0xe0, 0x4c, 0x00, 0x00, 0x02};
2929 u8 bLoad_From_EEPOM = false;
2930 struct r8192_priv *priv = ieee80211_priv(dev);
2931 u16 tmpValue = 0;
2932 RT_TRACE(COMP_EPROM, "===========>%s()\n", __FUNCTION__);
2933 wEPROM_ID = eprom_read(dev, 0); //first read EEPROM ID out;
2934 RT_TRACE(COMP_EPROM, "EEPROM ID is 0x%x\n", wEPROM_ID);
2935
2936 if (wEPROM_ID != RTL8190_EEPROM_ID)
2937 {
2938 RT_TRACE(COMP_ERR, "EEPROM ID is invalid(is 0x%x(should be 0x%x)\n", wEPROM_ID, RTL8190_EEPROM_ID);
2939 }
2940 else
2941 bLoad_From_EEPOM = true;
2942
2943 if (bLoad_From_EEPOM)
2944 {
2945 tmpValue = eprom_read(dev, (EEPROM_VID>>1));
2946 priv->eeprom_vid = endian_swap(&tmpValue);
2947 priv->eeprom_pid = eprom_read(dev, (EEPROM_PID>>1));
2948 tmpValue = eprom_read(dev, (EEPROM_ChannelPlan>>1));
2949 priv->eeprom_ChannelPlan =((tmpValue&0xff00)>>8);
2950 priv->btxpowerdata_readfromEEPORM = true;
2951 priv->eeprom_CustomerID = eprom_read(dev, (EEPROM_Customer_ID>>1)) >>8;
2952 }
2953 else
2954 {
2955 priv->eeprom_vid = 0;
2956 priv->eeprom_pid = 0;
2957 priv->card_8192_version = VERSION_819xU_B;
2958 priv->eeprom_ChannelPlan = 0;
2959 priv->eeprom_CustomerID = 0;
2960 }
2961 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);
2962 //set channelplan from eeprom
2963 priv->ChannelPlan = priv->eeprom_ChannelPlan;
2964 if (bLoad_From_EEPOM)
2965 {
2966 int i;
2967 for (i=0; i<6; i+=2)
2968 {
2969 u16 tmp = 0;
2970 tmp = eprom_read(dev, (u16)((EEPROM_NODE_ADDRESS_BYTE_0 + i)>>1));
2971 *(u16*)(&dev->dev_addr[i]) = tmp;
2972 }
2973 }
2974 else
2975 {
2976 memcpy(dev->dev_addr, bMac_Tmp_Addr, 6);
2977 //should I set IDR0 here?
2978 }
2979 RT_TRACE(COMP_EPROM, "MAC addr:"MAC_FMT"\n", MAC_ARG(dev->dev_addr));
2980 priv->rf_type = RTL819X_DEFAULT_RF_TYPE; //default 1T2R
2981 priv->rf_chip = RF_8256;
2982
2983 if (priv->card_8192_version == (u8)VERSION_819xU_A)
2984 {
2985 //read Tx power gain offset of legacy OFDM to HT rate
2986 if (bLoad_From_EEPOM)
2987 priv->EEPROMTxPowerDiff = (eprom_read(dev, (EEPROM_TxPowerDiff>>1))&0xff00) >> 8;
2988 else
2989 priv->EEPROMTxPowerDiff = EEPROM_Default_TxPower;
2990 RT_TRACE(COMP_EPROM, "TxPowerDiff:%d\n", priv->EEPROMTxPowerDiff);
2991 //read ThermalMeter from EEPROM
2992 if (bLoad_From_EEPOM)
2993 priv->EEPROMThermalMeter = (u8)(eprom_read(dev, (EEPROM_ThermalMeter>>1))&0x00ff);
2994 else
2995 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
2996 RT_TRACE(COMP_EPROM, "ThermalMeter:%d\n", priv->EEPROMThermalMeter);
2997 //vivi, for tx power track
2998 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
2999 //read antenna tx power offset of B/C/D to A from EEPROM
3000 if (bLoad_From_EEPOM)
3001 priv->EEPROMPwDiff = (eprom_read(dev, (EEPROM_PwDiff>>1))&0x0f00)>>8;
3002 else
3003 priv->EEPROMPwDiff = EEPROM_Default_PwDiff;
3004 RT_TRACE(COMP_EPROM, "TxPwDiff:%d\n", priv->EEPROMPwDiff);
3005 // Read CrystalCap from EEPROM
3006 if (bLoad_From_EEPOM)
3007 priv->EEPROMCrystalCap = (eprom_read(dev, (EEPROM_CrystalCap>>1))&0x0f);
3008 else
3009 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
3010 RT_TRACE(COMP_EPROM, "CrystalCap = %d\n", priv->EEPROMCrystalCap);
3011 //get per-channel Tx power level
3012 if (bLoad_From_EEPOM)
3013 priv->EEPROM_Def_Ver = (eprom_read(dev, (EEPROM_TxPwIndex_Ver>>1))&0xff00)>>8;
3014 else
3015 priv->EEPROM_Def_Ver = 1;
3016 RT_TRACE(COMP_EPROM, "EEPROM_DEF_VER:%d\n", priv->EEPROM_Def_Ver);
3017 if (priv->EEPROM_Def_Ver == 0) //old eeprom definition
3018 {
3019 int i;
3020 if (bLoad_From_EEPOM)
3021 priv->EEPROMTxPowerLevelCCK = (eprom_read(dev, (EEPROM_TxPwIndex_CCK>>1))&0xff) >> 8;
3022 else
3023 priv->EEPROMTxPowerLevelCCK = 0x10;
3024 RT_TRACE(COMP_EPROM, "CCK Tx Power Levl: 0x%02x\n", priv->EEPROMTxPowerLevelCCK);
3025 for (i=0; i<3; i++)
3026 {
3027 if (bLoad_From_EEPOM)
3028 {
3029 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G+i)>>1);
3030 if (((EEPROM_TxPwIndex_OFDM_24G+i) % 2) == 0)
3031 tmpValue = tmpValue & 0x00ff;
3032 else
3033 tmpValue = (tmpValue & 0xff00) >> 8;
3034 }
3035 else
3036 tmpValue = 0x10;
3037 priv->EEPROMTxPowerLevelOFDM24G[i] = (u8) tmpValue;
3038 RT_TRACE(COMP_EPROM, "OFDM 2.4G Tx Power Level, Index %d = 0x%02x\n", i, priv->EEPROMTxPowerLevelCCK);
3039 }
3040 }//end if EEPROM_DEF_VER == 0
3041 else if (priv->EEPROM_Def_Ver == 1)
3042 {
3043 if (bLoad_From_EEPOM)
3044 {
3045 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1>>1));
3046 tmpValue = (tmpValue & 0xff00) >> 8;
3047 }
3048 else
3049 tmpValue = 0x10;
3050 priv->EEPROMTxPowerLevelCCK_V1[0] = (u8)tmpValue;
3051
3052 if (bLoad_From_EEPOM)
3053 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_CCK_V1 + 2)>>1);
3054 else
3055 tmpValue = 0x1010;
3056 *((u16*)(&priv->EEPROMTxPowerLevelCCK_V1[1])) = tmpValue;
3057 if (bLoad_From_EEPOM)
3058 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1>>1));
3059 else
3060 tmpValue = 0x1010;
3061 *((u16*)(&priv->EEPROMTxPowerLevelOFDM24G[0])) = tmpValue;
3062 if (bLoad_From_EEPOM)
3063 tmpValue = eprom_read(dev, (EEPROM_TxPwIndex_OFDM_24G_V1+2)>>1);
3064 else
3065 tmpValue = 0x10;
3066 priv->EEPROMTxPowerLevelOFDM24G[2] = (u8)tmpValue;
3067 }//endif EEPROM_Def_Ver == 1
3068
3069 //update HAL variables
3070 //
3071 {
3072 int i;
3073 for (i=0; i<14; i++)
3074 {
3075 if (i<=3)
3076 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[0];
3077 else if (i>=4 && i<=9)
3078 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[1];
3079 else
3080 priv->TxPowerLevelOFDM24G[i] = priv->EEPROMTxPowerLevelOFDM24G[2];
3081 }
3082
3083 for (i=0; i<14; i++)
3084 {
3085 if (priv->EEPROM_Def_Ver == 0)
3086 {
3087 if (i<=3)
3088 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[0] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
3089 else if (i>=4 && i<=9)
3090 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK;
3091 else
3092 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelOFDM24G[2] + (priv->EEPROMTxPowerLevelCCK - priv->EEPROMTxPowerLevelOFDM24G[1]);
3093 }
3094 else if (priv->EEPROM_Def_Ver == 1)
3095 {
3096 if (i<=3)
3097 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[0];
3098 else if (i>=4 && i<=9)
3099 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[1];
3100 else
3101 priv->TxPowerLevelCCK[i] = priv->EEPROMTxPowerLevelCCK_V1[2];
3102 }
3103 }
3104 }//end update HAL variables
3105 priv->TxPowerDiff = priv->EEPROMPwDiff;
3106 // Antenna B gain offset to antenna A, bit0~3
3107 priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);
3108 // Antenna C gain offset to antenna A, bit4~7
3109 priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);
3110 // CrystalCap, bit12~15
3111 priv->CrystalCap = priv->EEPROMCrystalCap;
3112 // ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
3113 // 92U does not enable TX power tracking.
3114 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
3115 }//end if VersionID == VERSION_819xU_A
3116
3117 //added by vivi, for dlink led, 20080416
3118 switch(priv->eeprom_CustomerID)
3119 {
3120 case EEPROM_CID_RUNTOP:
3121 priv->CustomerID = RT_CID_819x_RUNTOP;
3122 break;
3123
3124 case EEPROM_CID_DLINK:
3125 priv->CustomerID = RT_CID_DLINK;
3126 break;
3127
3128 default:
3129 priv->CustomerID = RT_CID_DEFAULT;
3130 break;
3131
3132 }
3133
3134 switch(priv->CustomerID)
3135 {
3136 case RT_CID_819x_RUNTOP:
3137 priv->LedStrategy = SW_LED_MODE2;
3138 break;
3139
3140 case RT_CID_DLINK:
3141 priv->LedStrategy = SW_LED_MODE4;
3142 break;
3143
3144 default:
3145 priv->LedStrategy = SW_LED_MODE0;
3146 break;
3147
3148 }
3149
3150
3151 if(priv->rf_type == RF_1T2R)
3152 {
3153 RT_TRACE(COMP_EPROM, "\n1T2R config\n");
3154 }
3155 else
3156 {
3157 RT_TRACE(COMP_EPROM, "\n2T4R config\n");
3158 }
3159
3160 // 2008/01/16 MH We can only know RF type in the function. So we have to init
3161 // DIG RATR table again.
3162 init_rate_adaptive(dev);
3163 //we need init DIG RATR table here again.
3164
3165 RT_TRACE(COMP_EPROM, "<===========%s()\n", __FUNCTION__);
3166 return;
3167 }
3168
3169 short rtl8192_get_channel_map(struct net_device * dev)
3170 {
3171 struct r8192_priv *priv = ieee80211_priv(dev);
3172 #ifdef ENABLE_DOT11D
3173 if(priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN){
3174 printk("rtl8180_init:Error channel plan! Set to default.\n");
3175 priv->ChannelPlan= 0;
3176 }
3177 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
3178
3179 rtl819x_set_channel_map(priv->ChannelPlan, priv);
3180 #else
3181 int ch,i;
3182 //Set Default Channel Plan
3183 if(!channels){
3184 DMESG("No channels, aborting");
3185 return -1;
3186 }
3187 ch=channels;
3188 priv->ChannelPlan= 0;//hikaru
3189 // set channels 1..14 allowed in given locale
3190 for (i=1; i<=14; i++) {
3191 (priv->ieee80211->channel_map)[i] = (u8)(ch & 0x01);
3192 ch >>= 1;
3193 }
3194 #endif
3195 return 0;
3196 }
3197
3198 short rtl8192_init(struct net_device *dev)
3199 {
3200
3201 struct r8192_priv *priv = ieee80211_priv(dev);
3202
3203 memset(&(priv->stats),0,sizeof(struct Stats));
3204 memset(priv->txqueue_to_outpipemap,0,9);
3205 #ifdef PIPE12
3206 {
3207 int i=0;
3208 u8 queuetopipe[]={3,2,1,0,4,8,7,6,5};
3209 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3210 /* for(i=0;i<9;i++)
3211 printk("%d ",priv->txqueue_to_outpipemap[i]);
3212 printk("\n");*/
3213 }
3214 #else
3215 {
3216 u8 queuetopipe[]={3,2,1,0,4,4,0,4,4};
3217 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
3218 /* for(i=0;i<9;i++)
3219 printk("%d ",priv->txqueue_to_outpipemap[i]);
3220 printk("\n");*/
3221 }
3222 #endif
3223 rtl8192_init_priv_variable(dev);
3224 rtl8192_init_priv_lock(priv);
3225 rtl8192_init_priv_task(dev);
3226 rtl8192_get_eeprom_size(dev);
3227 rtl8192_read_eeprom_info(dev);
3228 rtl8192_get_channel_map(dev);
3229 init_hal_dm(dev);
3230 init_timer(&priv->watch_dog_timer);
3231 priv->watch_dog_timer.data = (unsigned long)dev;
3232 priv->watch_dog_timer.function = watch_dog_timer_callback;
3233 if(rtl8192_usb_initendpoints(dev)!=0){
3234 DMESG("Endopoints initialization failed");
3235 return -ENOMEM;
3236 }
3237
3238 //rtl8192_adapter_start(dev);
3239 #ifdef DEBUG_EPROM
3240 dump_eprom(dev);
3241 #endif
3242 return 0;
3243 }
3244
3245 /******************************************************************************
3246 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
3247 * not to do all the hw config as its name says
3248 * input: net_device dev
3249 * output: none
3250 * return: none
3251 * notice: This part need to modified according to the rate set we filtered
3252 * ****************************************************************************/
3253 void rtl8192_hwconfig(struct net_device* dev)
3254 {
3255 u32 regRATR = 0, regRRSR = 0;
3256 u8 regBwOpMode = 0, regTmp = 0;
3257 struct r8192_priv *priv = ieee80211_priv(dev);
3258
3259 // Set RRSR, RATR, and BW_OPMODE registers
3260 //
3261 switch(priv->ieee80211->mode)
3262 {
3263 case WIRELESS_MODE_B:
3264 regBwOpMode = BW_OPMODE_20MHZ;
3265 regRATR = RATE_ALL_CCK;
3266 regRRSR = RATE_ALL_CCK;
3267 break;
3268 case WIRELESS_MODE_A:
3269 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
3270 regRATR = RATE_ALL_OFDM_AG;
3271 regRRSR = RATE_ALL_OFDM_AG;
3272 break;
3273 case WIRELESS_MODE_G:
3274 regBwOpMode = BW_OPMODE_20MHZ;
3275 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3276 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3277 break;
3278 case WIRELESS_MODE_AUTO:
3279 #ifdef TO_DO_LIST
3280 if (Adapter->bInHctTest)
3281 {
3282 regBwOpMode = BW_OPMODE_20MHZ;
3283 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3284 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3285 }
3286 else
3287 #endif
3288 {
3289 regBwOpMode = BW_OPMODE_20MHZ;
3290 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3291 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3292 }
3293 break;
3294 case WIRELESS_MODE_N_24G:
3295 // It support CCK rate by default.
3296 // CCK rate will be filtered out only when associated AP does not support it.
3297 regBwOpMode = BW_OPMODE_20MHZ;
3298 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3299 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
3300 break;
3301 case WIRELESS_MODE_N_5G:
3302 regBwOpMode = BW_OPMODE_5G;
3303 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
3304 regRRSR = RATE_ALL_OFDM_AG;
3305 break;
3306 }
3307
3308 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
3309 {
3310 u32 ratr_value = 0;
3311 ratr_value = regRATR;
3312 if (priv->rf_type == RF_1T2R)
3313 {
3314 ratr_value &= ~(RATE_ALL_OFDM_2SS);
3315 }
3316 write_nic_dword(dev, RATR0, ratr_value);
3317 write_nic_byte(dev, UFWP, 1);
3318 }
3319 regTmp = read_nic_byte(dev, 0x313);
3320 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
3321 write_nic_dword(dev, RRSR, regRRSR);
3322
3323 //
3324 // Set Retry Limit here
3325 //
3326 write_nic_word(dev, RETRY_LIMIT,
3327 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | \
3328 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
3329 // Set Contention Window here
3330
3331 // Set Tx AGC
3332
3333 // Set Tx Antenna including Feedback control
3334
3335 // Set Auto Rate fallback control
3336
3337
3338 }
3339
3340
3341 //InitializeAdapter and PhyCfg
3342 bool rtl8192_adapter_start(struct net_device *dev)
3343 {
3344 struct r8192_priv *priv = ieee80211_priv(dev);
3345 u32 dwRegRead = 0;
3346 bool init_status = true;
3347 RT_TRACE(COMP_INIT, "====>%s()\n", __FUNCTION__);
3348 priv->Rf_Mode = RF_OP_By_SW_3wire;
3349 //for ASIC power on sequence
3350 write_nic_byte_E(dev, 0x5f, 0x80);
3351 mdelay(50);
3352 write_nic_byte_E(dev, 0x5f, 0xf0);
3353 write_nic_byte_E(dev, 0x5d, 0x00);
3354 write_nic_byte_E(dev, 0x5e, 0x80);
3355 write_nic_byte(dev, 0x17, 0x37);
3356 mdelay(10);
3357 //#ifdef TO_DO_LIST
3358 priv->pFirmware->firmware_status = FW_STATUS_0_INIT;
3359 //config CPUReset Register
3360 //Firmware Reset or not?
3361 dwRegRead = read_nic_dword(dev, CPU_GEN);
3362 if (priv->pFirmware->firmware_status == FW_STATUS_0_INIT)
3363 dwRegRead |= CPU_GEN_SYSTEM_RESET; //do nothing here?
3364 else if (priv->pFirmware->firmware_status == FW_STATUS_5_READY)
3365 dwRegRead |= CPU_GEN_FIRMWARE_RESET;
3366 else
3367 RT_TRACE(COMP_ERR, "ERROR in %s(): undefined firmware state(%d)\n", __FUNCTION__, priv->pFirmware->firmware_status);
3368
3369 write_nic_dword(dev, CPU_GEN, dwRegRead);
3370 //mdelay(30);
3371 //config BB.
3372 rtl8192_BBConfig(dev);
3373
3374 //Loopback mode or not
3375 priv->LoopbackMode = RTL819xU_NO_LOOPBACK;
3376 // priv->LoopbackMode = RTL819xU_MAC_LOOPBACK;
3377
3378 dwRegRead = read_nic_dword(dev, CPU_GEN);
3379 if (priv->LoopbackMode == RTL819xU_NO_LOOPBACK)
3380 dwRegRead = ((dwRegRead & CPU_GEN_NO_LOOPBACK_MSK) | CPU_GEN_NO_LOOPBACK_SET);
3381 else if (priv->LoopbackMode == RTL819xU_MAC_LOOPBACK)
3382 dwRegRead |= CPU_CCK_LOOPBACK;
3383 else
3384 RT_TRACE(COMP_ERR, "Serious error in %s(): wrong loopback mode setting(%d)\n", __FUNCTION__, priv->LoopbackMode);
3385
3386 write_nic_dword(dev, CPU_GEN, dwRegRead);
3387
3388 //after reset cpu, we need wait for a seconds to write in register.
3389 udelay(500);
3390
3391 //xiong add for new bitfile:usb suspend reset pin set to 1. //do we need?
3392 write_nic_byte_E(dev, 0x5f, (read_nic_byte_E(dev, 0x5f)|0x20));
3393
3394 //Set Hardware
3395 rtl8192_hwconfig(dev);
3396
3397 //turn on Tx/Rx
3398 write_nic_byte(dev, CMDR, CR_RE|CR_TE);
3399
3400 //set IDR0 here
3401 write_nic_dword(dev, MAC0, ((u32*)dev->dev_addr)[0]);
3402 write_nic_word(dev, MAC4, ((u16*)(dev->dev_addr + 4))[0]);
3403
3404 //set RCR
3405 write_nic_dword(dev, RCR, priv->ReceiveConfig);
3406
3407 //Initialize Number of Reserved Pages in Firmware Queue
3408 write_nic_dword(dev, RQPN1, NUM_OF_PAGE_IN_FW_QUEUE_BK << RSVD_FW_QUEUE_PAGE_BK_SHIFT |\
3409 NUM_OF_PAGE_IN_FW_QUEUE_BE << RSVD_FW_QUEUE_PAGE_BE_SHIFT | \
3410 NUM_OF_PAGE_IN_FW_QUEUE_VI << RSVD_FW_QUEUE_PAGE_VI_SHIFT | \
3411 NUM_OF_PAGE_IN_FW_QUEUE_VO <<RSVD_FW_QUEUE_PAGE_VO_SHIFT);
3412 write_nic_dword(dev, RQPN2, NUM_OF_PAGE_IN_FW_QUEUE_MGNT << RSVD_FW_QUEUE_PAGE_MGNT_SHIFT |\
3413 NUM_OF_PAGE_IN_FW_QUEUE_CMD << RSVD_FW_QUEUE_PAGE_CMD_SHIFT);
3414 write_nic_dword(dev, RQPN3, APPLIED_RESERVED_QUEUE_IN_FW| \
3415 NUM_OF_PAGE_IN_FW_QUEUE_BCN<<RSVD_FW_QUEUE_PAGE_BCN_SHIFT
3416 // | NUM_OF_PAGE_IN_FW_QUEUE_PUB<<RSVD_FW_QUEUE_PAGE_PUB_SHIFT
3417 );
3418 write_nic_dword(dev, RATR0+4*7, (RATE_ALL_OFDM_AG | RATE_ALL_CCK));
3419
3420 //Set AckTimeout
3421 // TODO: (it value is only for FPGA version). need to be changed!!2006.12.18, by Emily
3422 write_nic_byte(dev, ACK_TIMEOUT, 0x30);
3423
3424 // RT_TRACE(COMP_INIT, "%s():priv->ResetProgress is %d\n", __FUNCTION__,priv->ResetProgress);
3425 if(priv->ResetProgress == RESET_TYPE_NORESET)
3426 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);
3427 if(priv->ResetProgress == RESET_TYPE_NORESET){
3428 CamResetAllEntry(dev);
3429 {
3430 u8 SECR_value = 0x0;
3431 SECR_value |= SCR_TxEncEnable;
3432 SECR_value |= SCR_RxDecEnable;
3433 SECR_value |= SCR_NoSKMC;
3434 write_nic_byte(dev, SECR, SECR_value);
3435 }
3436 }
3437
3438 //Beacon related
3439 write_nic_word(dev, ATIMWND, 2);
3440 write_nic_word(dev, BCN_INTERVAL, 100);
3441
3442 {
3443 #define DEFAULT_EDCA 0x005e4332
3444 int i;
3445 for (i=0; i<QOS_QUEUE_NUM; i++)
3446 write_nic_dword(dev, WDCAPARA_ADD[i], DEFAULT_EDCA);
3447 }
3448 #ifdef USB_RX_AGGREGATION_SUPPORT
3449 //3 For usb rx firmware aggregation control
3450 if(priv->ResetProgress == RESET_TYPE_NORESET)
3451 {
3452 u32 ulValue;
3453 PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
3454 ulValue = (pHTInfo->UsbRxFwAggrEn<<24) | (pHTInfo->UsbRxFwAggrPageNum<<16) |
3455 (pHTInfo->UsbRxFwAggrPacketNum<<8) | (pHTInfo->UsbRxFwAggrTimeout);
3456 /*
3457 * If usb rx firmware aggregation is enabled,
3458 * when anyone of three threshold conditions above is reached,
3459 * firmware will send aggregated packet to driver.
3460 */
3461 write_nic_dword(dev, 0x1a8, ulValue);
3462 priv->bCurrentRxAggrEnable = true;
3463 }
3464 #endif
3465
3466 rtl8192_phy_configmac(dev);
3467
3468 if (priv->card_8192_version == (u8) VERSION_819xU_A)
3469 {
3470 rtl8192_phy_getTxPower(dev);
3471 rtl8192_phy_setTxPower(dev, priv->chan);
3472 }
3473
3474 //Firmware download
3475 init_status = init_firmware(dev);
3476 if(!init_status)
3477 {
3478 RT_TRACE(COMP_ERR,"ERR!!! %s(): Firmware download is failed\n", __FUNCTION__);
3479 return init_status;
3480 }
3481 RT_TRACE(COMP_INIT, "%s():after firmware download\n", __FUNCTION__);
3482 //
3483 #ifdef TO_DO_LIST
3484 if(Adapter->ResetProgress == RESET_TYPE_NORESET)
3485 {
3486 if(pMgntInfo->RegRfOff == TRUE)
3487 { // User disable RF via registry.
3488 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RegRfOff ----------\n"));
3489 MgntActSet_RF_State(Adapter, eRfOff, RF_CHANGE_BY_SW);
3490 // Those action will be discard in MgntActSet_RF_State because off the same state
3491 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3492 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3493 }
3494 else if(pMgntInfo->RfOffReason > RF_CHANGE_BY_PS)
3495 { // H/W or S/W RF OFF before sleep.
3496 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): Turn off RF for RfOffReason(%d) ----------\n", pMgntInfo->RfOffReason));
3497 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3498 }
3499 else
3500 {
3501 pHalData->eRFPowerState = eRfOn;
3502 pMgntInfo->RfOffReason = 0;
3503 RT_TRACE((COMP_INIT|COMP_RF), DBG_LOUD, ("InitializeAdapter819xUsb(): RF is on ----------\n"));
3504 }
3505 }
3506 else
3507 {
3508 if(pHalData->eRFPowerState == eRfOff)
3509 {
3510 MgntActSet_RF_State(Adapter, eRfOff, pMgntInfo->RfOffReason);
3511 // Those action will be discard in MgntActSet_RF_State because off the same state
3512 for(eRFPath = 0; eRFPath <pHalData->NumTotalRFPath; eRFPath++)
3513 PHY_SetRFReg(Adapter, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
3514 }
3515 }
3516 #endif
3517 //config RF.
3518 if(priv->ResetProgress == RESET_TYPE_NORESET){
3519 rtl8192_phy_RFConfig(dev);
3520 RT_TRACE(COMP_INIT, "%s():after phy RF config\n", __FUNCTION__);
3521 }
3522
3523
3524 if(priv->ieee80211->FwRWRF)
3525 // We can force firmware to do RF-R/W
3526 priv->Rf_Mode = RF_OP_By_FW;
3527 else
3528 priv->Rf_Mode = RF_OP_By_SW_3wire;
3529
3530
3531 rtl8192_phy_updateInitGain(dev);
3532 /*--set CCK and OFDM Block "ON"--*/
3533 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
3534 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
3535
3536 if(priv->ResetProgress == RESET_TYPE_NORESET)
3537 {
3538 //if D or C cut
3539 u8 tmpvalue = read_nic_byte(dev, 0x301);
3540 if(tmpvalue ==0x03)
3541 {
3542 priv->bDcut = TRUE;
3543 RT_TRACE(COMP_POWER_TRACKING, "D-cut\n");
3544 }
3545 else
3546 {
3547 priv->bDcut = FALSE;
3548 RT_TRACE(COMP_POWER_TRACKING, "C-cut\n");
3549 }
3550 dm_initialize_txpower_tracking(dev);
3551
3552 if(priv->bDcut == TRUE)
3553 {
3554 u32 i, TempCCk;
3555 u32 tmpRegA= rtl8192_QueryBBReg(dev,rOFDM0_XATxIQImbalance,bMaskDWord);
3556 // u32 tmpRegC= rtl8192_QueryBBReg(dev,rOFDM0_XCTxIQImbalance,bMaskDWord);
3557 for(i = 0; i<TxBBGainTableLength; i++)
3558 {
3559 if(tmpRegA == priv->txbbgain_table[i].txbbgain_value)
3560 {
3561 priv->rfa_txpowertrackingindex= (u8)i;
3562 priv->rfa_txpowertrackingindex_real= (u8)i;
3563 priv->rfa_txpowertracking_default= priv->rfa_txpowertrackingindex;
3564 break;
3565 }
3566 }
3567
3568 TempCCk = rtl8192_QueryBBReg(dev, rCCK0_TxFilter1, bMaskByte2);
3569
3570 for(i=0 ; i<CCKTxBBGainTableLength ; i++)
3571 {
3572
3573 if(TempCCk == priv->cck_txbbgain_table[i].ccktxbb_valuearray[0])
3574 {
3575 priv->cck_present_attentuation_20Mdefault=(u8) i;
3576 break;
3577 }
3578 }
3579 priv->cck_present_attentuation_40Mdefault= 0;
3580 priv->cck_present_attentuation_difference= 0;
3581 priv->cck_present_attentuation = priv->cck_present_attentuation_20Mdefault;
3582
3583 // pMgntInfo->bTXPowerTracking = FALSE;//TEMPLY DISABLE
3584 }
3585 }
3586 write_nic_byte(dev, 0x87, 0x0);
3587
3588
3589 return init_status;
3590 }
3591
3592 /* this configures registers for beacon tx and enables it via
3593 * rtl8192_beacon_tx_enable(). rtl8192_beacon_tx_disable() might
3594 * be used to stop beacon transmission
3595 */
3596 /***************************************************************************
3597 -------------------------------NET STUFF---------------------------
3598 ***************************************************************************/
3599
3600 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
3601 {
3602 struct r8192_priv *priv = ieee80211_priv(dev);
3603
3604 return &priv->ieee80211->stats;
3605 }
3606
3607 bool
3608 HalTxCheckStuck819xUsb(
3609 struct net_device *dev
3610 )
3611 {
3612 struct r8192_priv *priv = ieee80211_priv(dev);
3613 u16 RegTxCounter = read_nic_word(dev, 0x128);
3614 bool bStuck = FALSE;
3615 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
3616 if(priv->TxCounter==RegTxCounter)
3617 bStuck = TRUE;
3618
3619 priv->TxCounter = RegTxCounter;
3620
3621 return bStuck;
3622 }
3623
3624 /*
3625 * <Assumption: RT_TX_SPINLOCK is acquired.>
3626 * First added: 2006.11.19 by emily
3627 */
3628 RESET_TYPE
3629 TxCheckStuck(struct net_device *dev)
3630 {
3631 struct r8192_priv *priv = ieee80211_priv(dev);
3632 u8 QueueID;
3633 // PRT_TCB pTcb;
3634 // u8 ResetThreshold;
3635 bool bCheckFwTxCnt = false;
3636 //unsigned long flags;
3637
3638 //
3639 // Decide Stuch threshold according to current power save mode
3640 //
3641
3642 // RT_TRACE(COMP_RESET, " ==> TxCheckStuck()\n");
3643 // PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK);
3644 // spin_lock_irqsave(&priv->ieee80211->lock,flags);
3645 for (QueueID = 0; QueueID<=BEACON_QUEUE;QueueID ++)
3646 {
3647 if(QueueID == TXCMD_QUEUE)
3648 continue;
3649 #ifdef USB_TX_DRIVER_AGGREGATION_ENABLE
3650 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))
3651 #else
3652 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
3653 #endif
3654 continue;
3655
3656 bCheckFwTxCnt = true;
3657 }
3658 // PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
3659 // spin_unlock_irqrestore(&priv->ieee80211->lock,flags);
3660 // RT_TRACE(COMP_RESET,"bCheckFwTxCnt is %d\n",bCheckFwTxCnt);
3661 if(bCheckFwTxCnt)
3662 {
3663 if(HalTxCheckStuck819xUsb(dev))
3664 {
3665 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
3666 return RESET_TYPE_SILENT;
3667 }
3668 }
3669 return RESET_TYPE_NORESET;
3670 }
3671
3672 bool
3673 HalRxCheckStuck819xUsb(struct net_device *dev)
3674 {
3675 u16 RegRxCounter = read_nic_word(dev, 0x130);
3676 struct r8192_priv *priv = ieee80211_priv(dev);
3677 bool bStuck = FALSE;
3678 static u8 rx_chk_cnt = 0;
3679 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
3680 // If rssi is small, we should check rx for long time because of bad rx.
3681 // or maybe it will continuous silent reset every 2 seconds.
3682 rx_chk_cnt++;
3683 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
3684 {
3685 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
3686 }
3687 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
3688 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
3689 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
3690 {
3691 if(rx_chk_cnt < 2)
3692 {
3693 return bStuck;
3694 }
3695 else
3696 {
3697 rx_chk_cnt = 0;
3698 }
3699 }
3700 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
3701 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
3702 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
3703 {
3704 if(rx_chk_cnt < 4)
3705 {
3706 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3707 return bStuck;
3708 }
3709 else
3710 {
3711 rx_chk_cnt = 0;
3712 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
3713 }
3714 }
3715 else
3716 {
3717 if(rx_chk_cnt < 8)
3718 {
3719 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
3720 return bStuck;
3721 }
3722 else
3723 {
3724 rx_chk_cnt = 0;
3725 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
3726 }
3727 }
3728
3729 if(priv->RxCounter==RegRxCounter)
3730 bStuck = TRUE;
3731
3732 priv->RxCounter = RegRxCounter;
3733
3734 return bStuck;
3735 }
3736
3737 RESET_TYPE
3738 RxCheckStuck(struct net_device *dev)
3739 {
3740 struct r8192_priv *priv = ieee80211_priv(dev);
3741 //int i;
3742 bool bRxCheck = FALSE;
3743
3744 // RT_TRACE(COMP_RESET," ==> RxCheckStuck()\n");
3745 //PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
3746
3747 if(priv->IrpPendingCount > 1)
3748 bRxCheck = TRUE;
3749 //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
3750
3751 // RT_TRACE(COMP_RESET,"bRxCheck is %d \n",bRxCheck);
3752 if(bRxCheck)
3753 {
3754 if(HalRxCheckStuck819xUsb(dev))
3755 {
3756 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
3757 return RESET_TYPE_SILENT;
3758 }
3759 }
3760 return RESET_TYPE_NORESET;
3761 }
3762
3763
3764 /**
3765 * This function is called by Checkforhang to check whether we should ask OS to reset driver
3766 *
3767 * \param pAdapter The adapter context for this miniport
3768 *
3769 * Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
3770 * to judge whether there is tx stuck.
3771 * Note: This function may be required to be rewrite for Vista OS.
3772 * <<<Assumption: Tx spinlock has been acquired >>>
3773 *
3774 * 8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
3775 */
3776 RESET_TYPE
3777 rtl819x_ifcheck_resetornot(struct net_device *dev)
3778 {
3779 struct r8192_priv *priv = ieee80211_priv(dev);
3780 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
3781 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
3782 RT_RF_POWER_STATE rfState;
3783
3784 rfState = priv->ieee80211->eRFPowerState;
3785
3786 TxResetType = TxCheckStuck(dev);
3787 if( rfState != eRfOff ||
3788 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
3789 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
3790 {
3791 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
3792 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
3793 // if driver is in firmware download failure status, driver should initialize RF in the following
3794 // silent reset procedure Emily, 2008.01.21
3795
3796 // Driver should not check RX stuck in IBSS mode because it is required to
3797 // set Check BSSID in order to send beacon, however, if check BSSID is
3798 // set, STA cannot hear any packet a all. Emily, 2008.04.12
3799 RxResetType = RxCheckStuck(dev);
3800 }
3801 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
3802 return RESET_TYPE_NORMAL;
3803 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT){
3804 RT_TRACE(COMP_RESET,"%s():silent reset\n",__FUNCTION__);
3805 return RESET_TYPE_SILENT;
3806 }
3807 else
3808 return RESET_TYPE_NORESET;
3809
3810 }
3811
3812 void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
3813 int _rtl8192_up(struct net_device *dev);
3814 int rtl8192_close(struct net_device *dev);
3815
3816
3817
3818 void
3819 CamRestoreAllEntry( struct net_device *dev)
3820 {
3821 u8 EntryId = 0;
3822 struct r8192_priv *priv = ieee80211_priv(dev);
3823 u8* MacAddr = priv->ieee80211->current_network.bssid;
3824
3825 static u8 CAM_CONST_ADDR[4][6] = {
3826 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
3827 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
3828 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
3829 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
3830 static u8 CAM_CONST_BROAD[] =
3831 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
3832
3833 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
3834
3835
3836 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
3837 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
3838 {
3839
3840 for(EntryId=0; EntryId<4; EntryId++)
3841 {
3842 {
3843 MacAddr = CAM_CONST_ADDR[EntryId];
3844 setKey(dev,
3845 EntryId ,
3846 EntryId,
3847 priv->ieee80211->pairwise_key_type,
3848 MacAddr,
3849 0,
3850 NULL);
3851 }
3852 }
3853
3854 }
3855 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
3856 {
3857
3858 {
3859 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3860 setKey(dev,
3861 4,
3862 0,
3863 priv->ieee80211->pairwise_key_type,
3864 (u8*)dev->dev_addr,
3865 0,
3866 NULL);
3867 else
3868 setKey(dev,
3869 4,
3870 0,
3871 priv->ieee80211->pairwise_key_type,
3872 MacAddr,
3873 0,
3874 NULL);
3875 }
3876 }
3877 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
3878 {
3879
3880 {
3881 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3882 setKey(dev,
3883 4,
3884 0,
3885 priv->ieee80211->pairwise_key_type,
3886 (u8*)dev->dev_addr,
3887 0,
3888 NULL);
3889 else
3890 setKey(dev,
3891 4,
3892 0,
3893 priv->ieee80211->pairwise_key_type,
3894 MacAddr,
3895 0,
3896 NULL);
3897 }
3898 }
3899
3900
3901
3902 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
3903 {
3904 MacAddr = CAM_CONST_BROAD;
3905 for(EntryId=1 ; EntryId<4 ; EntryId++)
3906 {
3907 {
3908 setKey(dev,
3909 EntryId,
3910 EntryId,
3911 priv->ieee80211->group_key_type,
3912 MacAddr,
3913 0,
3914 NULL);
3915 }
3916 }
3917 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3918 setKey(dev,
3919 0,
3920 0,
3921 priv->ieee80211->group_key_type,
3922 CAM_CONST_ADDR[0],
3923 0,
3924 NULL);
3925 }
3926 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
3927 {
3928 MacAddr = CAM_CONST_BROAD;
3929 for(EntryId=1; EntryId<4 ; EntryId++)
3930 {
3931 {
3932 setKey(dev,
3933 EntryId ,
3934 EntryId,
3935 priv->ieee80211->group_key_type,
3936 MacAddr,
3937 0,
3938 NULL);
3939 }
3940 }
3941
3942 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
3943 setKey(dev,
3944 0 ,
3945 0,
3946 priv->ieee80211->group_key_type,
3947 CAM_CONST_ADDR[0],
3948 0,
3949 NULL);
3950 }
3951 }
3952 //////////////////////////////////////////////////////////////
3953 // This function is used to fix Tx/Rx stop bug temporarily.
3954 // This function will do "system reset" to NIC when Tx or Rx is stuck.
3955 // The method checking Tx/Rx stuck of this function is supported by FW,
3956 // which reports Tx and Rx counter to register 0x128 and 0x130.
3957 //////////////////////////////////////////////////////////////
3958 void
3959 rtl819x_ifsilentreset(struct net_device *dev)
3960 {
3961 //OCTET_STRING asocpdu;
3962 struct r8192_priv *priv = ieee80211_priv(dev);
3963 u8 reset_times = 0;
3964 int reset_status = 0;
3965 struct ieee80211_device *ieee = priv->ieee80211;
3966
3967
3968 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
3969 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
3970
3971 if(priv->ResetProgress==RESET_TYPE_NORESET)
3972 {
3973 RESET_START:
3974
3975 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
3976
3977 // Set the variable for reset.
3978 priv->ResetProgress = RESET_TYPE_SILENT;
3979 // rtl8192_close(dev);
3980 down(&priv->wx_sem);
3981 if(priv->up == 0)
3982 {
3983 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
3984 up(&priv->wx_sem);
3985 return ;
3986 }
3987 priv->up = 0;
3988 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
3989 // if(!netif_queue_stopped(dev))
3990 // netif_stop_queue(dev);
3991
3992 rtl8192_rtx_disable(dev);
3993 rtl8192_cancel_deferred_work(priv);
3994 deinit_hal_dm(dev);
3995 del_timer_sync(&priv->watch_dog_timer);
3996
3997 ieee->sync_scan_hurryup = 1;
3998 if(ieee->state == IEEE80211_LINKED)
3999 {
4000 down(&ieee->wx_sem);
4001 printk("ieee->state is IEEE80211_LINKED\n");
4002 ieee80211_stop_send_beacons(priv->ieee80211);
4003 del_timer_sync(&ieee->associate_timer);
4004 cancel_delayed_work(&ieee->associate_retry_wq);
4005 ieee80211_stop_scan(ieee);
4006 netif_carrier_off(dev);
4007 up(&ieee->wx_sem);
4008 }
4009 else{
4010 printk("ieee->state is NOT LINKED\n");
4011 ieee80211_softmac_stop_protocol(priv->ieee80211); }
4012 up(&priv->wx_sem);
4013 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
4014 //rtl8192_irq_disable(dev);
4015 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
4016 reset_status = _rtl8192_up(dev);
4017
4018 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
4019 if(reset_status == -EAGAIN)
4020 {
4021 if(reset_times < 3)
4022 {
4023 reset_times++;
4024 goto RESET_START;
4025 }
4026 else
4027 {
4028 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n", __FUNCTION__);
4029 }
4030 }
4031 ieee->is_silent_reset = 1;
4032 EnableHWSecurityConfig8192(dev);
4033 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
4034 {
4035 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4036
4037 queue_work(ieee->wq, &ieee->associate_complete_wq);
4038
4039 }
4040 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
4041 {
4042 ieee->set_chan(ieee->dev, ieee->current_network.channel);
4043 ieee->link_change(ieee->dev);
4044
4045 // notify_wx_assoc_event(ieee);
4046
4047 ieee80211_start_send_beacons(ieee);
4048
4049 if (ieee->data_hard_resume)
4050 ieee->data_hard_resume(ieee->dev);
4051 netif_carrier_on(ieee->dev);
4052 }
4053
4054 CamRestoreAllEntry(dev);
4055
4056 priv->ResetProgress = RESET_TYPE_NORESET;
4057 priv->reset_count++;
4058
4059 priv->bForcedSilentReset =false;
4060 priv->bResetInProgress = false;
4061
4062 // For test --> force write UFWP.
4063 write_nic_byte(dev, UFWP, 1);
4064 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
4065 }
4066 }
4067
4068 void CAM_read_entry(
4069 struct net_device *dev,
4070 u32 iIndex
4071 )
4072 {
4073 u32 target_command=0;
4074 u32 target_content=0;
4075 u8 entry_i=0;
4076 u32 ulStatus;
4077 s32 i=100;
4078 // printk("=======>start read CAM\n");
4079 for(entry_i=0;entry_i<CAM_CONTENT_COUNT;entry_i++)
4080 {
4081 // polling bit, and No Write enable, and address
4082 target_command= entry_i+CAM_CONTENT_COUNT*iIndex;
4083 target_command= target_command | BIT31;
4084
4085 //Check polling bit is clear
4086 // mdelay(1);
4087 while((i--)>=0)
4088 {
4089 ulStatus = read_nic_dword(dev, RWCAM);
4090 if(ulStatus & BIT31){
4091 continue;
4092 }
4093 else{
4094 break;
4095 }
4096 }
4097 write_nic_dword(dev, RWCAM, target_command);
4098 RT_TRACE(COMP_SEC,"CAM_read_entry(): WRITE A0: %x \n",target_command);
4099 // printk("CAM_read_entry(): WRITE A0: %lx \n",target_command);
4100 target_content = read_nic_dword(dev, RCAMO);
4101 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A8: %x \n",target_content);
4102 // printk("CAM_read_entry(): WRITE A8: %lx \n",target_content);
4103 }
4104 printk("\n");
4105 }
4106
4107 void rtl819x_update_rxcounts(
4108 struct r8192_priv *priv,
4109 u32* TotalRxBcnNum,
4110 u32* TotalRxDataNum
4111 )
4112 {
4113 u16 SlotIndex;
4114 u8 i;
4115
4116 *TotalRxBcnNum = 0;
4117 *TotalRxDataNum = 0;
4118
4119 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
4120 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
4121 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
4122 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
4123 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
4124 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
4125 }
4126 }
4127
4128
4129 extern void rtl819x_watchdog_wqcallback(struct work_struct *work)
4130 {
4131 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
4132 struct r8192_priv *priv = container_of(dwork,struct r8192_priv,watch_dog_wq);
4133 struct net_device *dev = priv->ieee80211->dev;
4134 struct ieee80211_device* ieee = priv->ieee80211;
4135 RESET_TYPE ResetType = RESET_TYPE_NORESET;
4136 static u8 check_reset_cnt=0;
4137 bool bBusyTraffic = false;
4138
4139 if(!priv->up)
4140 return;
4141 hal_dm_watchdog(dev);
4142
4143 {//to get busy traffic condition
4144 if(ieee->state == IEEE80211_LINKED)
4145 {
4146 if( ieee->LinkDetectInfo.NumRxOkInPeriod> 666 ||
4147 ieee->LinkDetectInfo.NumTxOkInPeriod> 666 ) {
4148 bBusyTraffic = true;
4149 }
4150 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
4151 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
4152 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
4153 }
4154 }
4155 //added by amy for AP roaming
4156 {
4157 if(priv->ieee80211->state == IEEE80211_LINKED && priv->ieee80211->iw_mode == IW_MODE_INFRA)
4158 {
4159 u32 TotalRxBcnNum = 0;
4160 u32 TotalRxDataNum = 0;
4161
4162 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
4163 if((TotalRxBcnNum+TotalRxDataNum) == 0)
4164 {
4165 #ifdef TODO
4166 if(rfState == eRfOff)
4167 RT_TRACE(COMP_ERR,"========>%s()\n",__FUNCTION__);
4168 #endif
4169 printk("===>%s(): AP is power off,connect another one\n",__FUNCTION__);
4170 // Dot11d_Reset(dev);
4171 priv->ieee80211->state = IEEE80211_ASSOCIATING;
4172 notify_wx_assoc_event(priv->ieee80211);
4173 RemovePeerTS(priv->ieee80211,priv->ieee80211->current_network.bssid);
4174 priv->ieee80211->link_change(dev);
4175 queue_work(priv->ieee80211->wq, &priv->ieee80211->associate_procedure_wq);
4176
4177 }
4178 }
4179 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod=0;
4180 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod=0;
4181 }
4182 // CAM_read_entry(dev,4);
4183 //check if reset the driver
4184 if(check_reset_cnt++ >= 3)
4185 {
4186 ResetType = rtl819x_ifcheck_resetornot(dev);
4187 check_reset_cnt = 3;
4188 //DbgPrint("Start to check silent reset\n");
4189 }
4190 // 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);
4191 if( (priv->force_reset) || (priv->ResetProgress==RESET_TYPE_NORESET &&
4192 (priv->bForcedSilentReset ||
4193 (!priv->bDisableNormalResetCheck && ResetType==RESET_TYPE_SILENT)))) // This is control by OID set in Pomelo
4194 {
4195 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);
4196 rtl819x_ifsilentreset(dev);
4197 }
4198 priv->force_reset = false;
4199 priv->bForcedSilentReset = false;
4200 priv->bResetInProgress = false;
4201 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
4202
4203 }
4204
4205 void watch_dog_timer_callback(unsigned long data)
4206 {
4207 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
4208 //printk("===============>watch_dog timer\n");
4209 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq, 0);
4210 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
4211 }
4212 int _rtl8192_up(struct net_device *dev)
4213 {
4214 struct r8192_priv *priv = ieee80211_priv(dev);
4215 //int i;
4216 int init_status = 0;
4217 priv->up=1;
4218 priv->ieee80211->ieee_up=1;
4219 RT_TRACE(COMP_INIT, "Bringing up iface");
4220 init_status = rtl8192_adapter_start(dev);
4221 if(!init_status)
4222 {
4223 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n", __FUNCTION__);
4224 priv->up=priv->ieee80211->ieee_up = 0;
4225 return -EAGAIN;
4226 }
4227 RT_TRACE(COMP_INIT, "start adapter finished\n");
4228 rtl8192_rx_enable(dev);
4229 // rtl8192_tx_enable(dev);
4230 if(priv->ieee80211->state != IEEE80211_LINKED)
4231 ieee80211_softmac_start_protocol(priv->ieee80211);
4232 ieee80211_reset_queue(priv->ieee80211);
4233 watch_dog_timer_callback((unsigned long) dev);
4234 if(!netif_queue_stopped(dev))
4235 netif_start_queue(dev);
4236 else
4237 netif_wake_queue(dev);
4238
4239 return 0;
4240 }
4241
4242
4243 int rtl8192_open(struct net_device *dev)
4244 {
4245 struct r8192_priv *priv = ieee80211_priv(dev);
4246 int ret;
4247 down(&priv->wx_sem);
4248 ret = rtl8192_up(dev);
4249 up(&priv->wx_sem);
4250 return ret;
4251
4252 }
4253
4254
4255 int rtl8192_up(struct net_device *dev)
4256 {
4257 struct r8192_priv *priv = ieee80211_priv(dev);
4258
4259 if (priv->up == 1) return -1;
4260
4261 return _rtl8192_up(dev);
4262 }
4263
4264
4265 int rtl8192_close(struct net_device *dev)
4266 {
4267 struct r8192_priv *priv = ieee80211_priv(dev);
4268 int ret;
4269
4270 down(&priv->wx_sem);
4271
4272 ret = rtl8192_down(dev);
4273
4274 up(&priv->wx_sem);
4275
4276 return ret;
4277
4278 }
4279
4280 int rtl8192_down(struct net_device *dev)
4281 {
4282 struct r8192_priv *priv = ieee80211_priv(dev);
4283 int i;
4284
4285 if (priv->up == 0) return -1;
4286
4287 priv->up=0;
4288 priv->ieee80211->ieee_up = 0;
4289 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
4290 /* FIXME */
4291 if (!netif_queue_stopped(dev))
4292 netif_stop_queue(dev);
4293
4294 rtl8192_rtx_disable(dev);
4295 //rtl8192_irq_disable(dev);
4296
4297 /* Tx related queue release */
4298 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4299 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
4300 }
4301 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4302 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
4303 }
4304
4305 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
4306 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ [i]);
4307 }
4308
4309 //as cancel_delayed_work will del work->timer, so if work is not definedas struct delayed_work, it will corrupt
4310 // flush_scheduled_work();
4311 rtl8192_cancel_deferred_work(priv);
4312 deinit_hal_dm(dev);
4313 del_timer_sync(&priv->watch_dog_timer);
4314
4315
4316 ieee80211_softmac_stop_protocol(priv->ieee80211);
4317 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
4318 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
4319
4320 return 0;
4321 }
4322
4323
4324 void rtl8192_commit(struct net_device *dev)
4325 {
4326 struct r8192_priv *priv = ieee80211_priv(dev);
4327 int reset_status = 0;
4328 //u8 reset_times = 0;
4329 if (priv->up == 0) return ;
4330 priv->up = 0;
4331
4332 rtl8192_cancel_deferred_work(priv);
4333 del_timer_sync(&priv->watch_dog_timer);
4334 //cancel_delayed_work(&priv->SwChnlWorkItem);
4335
4336 ieee80211_softmac_stop_protocol(priv->ieee80211);
4337
4338 //rtl8192_irq_disable(dev);
4339 rtl8192_rtx_disable(dev);
4340 reset_status = _rtl8192_up(dev);
4341
4342 }
4343
4344 /*
4345 void rtl8192_restart(struct net_device *dev)
4346 {
4347 struct r8192_priv *priv = ieee80211_priv(dev);
4348 */
4349 void rtl8192_restart(struct work_struct *work)
4350 {
4351 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
4352 struct net_device *dev = priv->ieee80211->dev;
4353
4354 down(&priv->wx_sem);
4355
4356 rtl8192_commit(dev);
4357
4358 up(&priv->wx_sem);
4359 }
4360
4361 static void r8192_set_multicast(struct net_device *dev)
4362 {
4363 struct r8192_priv *priv = ieee80211_priv(dev);
4364 short promisc;
4365
4366 //down(&priv->wx_sem);
4367
4368 /* FIXME FIXME */
4369
4370 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
4371
4372 if (promisc != priv->promisc)
4373 // rtl8192_commit(dev);
4374
4375 priv->promisc = promisc;
4376
4377 //schedule_work(&priv->reset_wq);
4378 //up(&priv->wx_sem);
4379 }
4380
4381
4382 int r8192_set_mac_adr(struct net_device *dev, void *mac)
4383 {
4384 struct r8192_priv *priv = ieee80211_priv(dev);
4385 struct sockaddr *addr = mac;
4386
4387 down(&priv->wx_sem);
4388
4389 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
4390
4391 schedule_work(&priv->reset_wq);
4392 up(&priv->wx_sem);
4393
4394 return 0;
4395 }
4396
4397 /* based on ipw2200 driver */
4398 int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
4399 {
4400 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4401 struct iwreq *wrq = (struct iwreq *)rq;
4402 int ret=-1;
4403 struct ieee80211_device *ieee = priv->ieee80211;
4404 u32 key[4];
4405 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
4406 struct iw_point *p = &wrq->u.data;
4407 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
4408
4409 down(&priv->wx_sem);
4410
4411
4412 if (p->length < sizeof(struct ieee_param) || !p->pointer){
4413 ret = -EINVAL;
4414 goto out;
4415 }
4416
4417 ipw = (struct ieee_param *)kmalloc(p->length, GFP_KERNEL);
4418 if (ipw == NULL){
4419 ret = -ENOMEM;
4420 goto out;
4421 }
4422 if (copy_from_user(ipw, p->pointer, p->length)) {
4423 kfree(ipw);
4424 ret = -EFAULT;
4425 goto out;
4426 }
4427
4428 switch (cmd) {
4429 case RTL_IOCTL_WPA_SUPPLICANT:
4430 //parse here for HW security
4431 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
4432 {
4433 if (ipw->u.crypt.set_tx)
4434 {
4435 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4436 ieee->pairwise_key_type = KEY_TYPE_CCMP;
4437 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4438 ieee->pairwise_key_type = KEY_TYPE_TKIP;
4439 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4440 {
4441 if (ipw->u.crypt.key_len == 13)
4442 ieee->pairwise_key_type = KEY_TYPE_WEP104;
4443 else if (ipw->u.crypt.key_len == 5)
4444 ieee->pairwise_key_type = KEY_TYPE_WEP40;
4445 }
4446 else
4447 ieee->pairwise_key_type = KEY_TYPE_NA;
4448
4449 if (ieee->pairwise_key_type)
4450 {
4451 memcpy((u8*)key, ipw->u.crypt.key, 16);
4452 EnableHWSecurityConfig8192(dev);
4453 //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!
4454 //added by WB.
4455 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4456 if (ieee->auth_mode != 2)
4457 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
4458 }
4459 }
4460 else //if (ipw->u.crypt.idx) //group key use idx > 0
4461 {
4462 memcpy((u8*)key, ipw->u.crypt.key, 16);
4463 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
4464 ieee->group_key_type= KEY_TYPE_CCMP;
4465 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
4466 ieee->group_key_type = KEY_TYPE_TKIP;
4467 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
4468 {
4469 if (ipw->u.crypt.key_len == 13)
4470 ieee->group_key_type = KEY_TYPE_WEP104;
4471 else if (ipw->u.crypt.key_len == 5)
4472 ieee->group_key_type = KEY_TYPE_WEP40;
4473 }
4474 else
4475 ieee->group_key_type = KEY_TYPE_NA;
4476
4477 if (ieee->group_key_type)
4478 {
4479 setKey( dev,
4480 ipw->u.crypt.idx,
4481 ipw->u.crypt.idx, //KeyIndex
4482 ieee->group_key_type, //KeyType
4483 broadcast_addr, //MacAddr
4484 0, //DefaultKey
4485 key); //KeyContent
4486 }
4487 }
4488 }
4489 #ifdef JOHN_HWSEC_DEBUG
4490 //john's test 0711
4491 printk("@@ wrq->u pointer = ");
4492 for(i=0;i<wrq->u.data.length;i++){
4493 if(i%10==0) printk("\n");
4494 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
4495 }
4496 printk("\n");
4497 #endif /*JOHN_HWSEC_DEBUG*/
4498 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
4499 break;
4500
4501 default:
4502 ret = -EOPNOTSUPP;
4503 break;
4504 }
4505 kfree(ipw);
4506 ipw = NULL;
4507 out:
4508 up(&priv->wx_sem);
4509 return ret;
4510 }
4511
4512 u8 HwRateToMRate90(bool bIsHT, u8 rate)
4513 {
4514 u8 ret_rate = 0xff;
4515
4516 if(!bIsHT) {
4517 switch(rate) {
4518 case DESC90_RATE1M: ret_rate = MGN_1M; break;
4519 case DESC90_RATE2M: ret_rate = MGN_2M; break;
4520 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
4521 case DESC90_RATE11M: ret_rate = MGN_11M; break;
4522 case DESC90_RATE6M: ret_rate = MGN_6M; break;
4523 case DESC90_RATE9M: ret_rate = MGN_9M; break;
4524 case DESC90_RATE12M: ret_rate = MGN_12M; break;
4525 case DESC90_RATE18M: ret_rate = MGN_18M; break;
4526 case DESC90_RATE24M: ret_rate = MGN_24M; break;
4527 case DESC90_RATE36M: ret_rate = MGN_36M; break;
4528 case DESC90_RATE48M: ret_rate = MGN_48M; break;
4529 case DESC90_RATE54M: ret_rate = MGN_54M; break;
4530
4531 default:
4532 ret_rate = 0xff;
4533 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
4534 break;
4535 }
4536
4537 } else {
4538 switch(rate) {
4539 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
4540 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
4541 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
4542 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
4543 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
4544 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
4545 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
4546 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
4547 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
4548 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
4549 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
4550 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
4551 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
4552 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
4553 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
4554 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
4555 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
4556
4557 default:
4558 ret_rate = 0xff;
4559 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
4560 break;
4561 }
4562 }
4563
4564 return ret_rate;
4565 }
4566
4567 /**
4568 * Function: UpdateRxPktTimeStamp
4569 * Overview: Recored down the TSF time stamp when receiving a packet
4570 *
4571 * Input:
4572 * PADAPTER Adapter
4573 * PRT_RFD pRfd,
4574 *
4575 * Output:
4576 * PRT_RFD pRfd
4577 * (pRfd->Status.TimeStampHigh is updated)
4578 * (pRfd->Status.TimeStampLow is updated)
4579 * Return:
4580 * None
4581 */
4582 void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
4583 {
4584 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
4585
4586 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
4587 stats->mac_time[0] = priv->LastRxDescTSFLow;
4588 stats->mac_time[1] = priv->LastRxDescTSFHigh;
4589 } else {
4590 priv->LastRxDescTSFLow = stats->mac_time[0];
4591 priv->LastRxDescTSFHigh = stats->mac_time[1];
4592 }
4593 }
4594
4595 //by amy 080606
4596
4597 long rtl819x_translate_todbm(u8 signal_strength_index )// 0-100 index.
4598 {
4599 long signal_power; // in dBm.
4600
4601 // Translate to dBm (x=0.5y-95).
4602 signal_power = (long)((signal_strength_index + 1) >> 1);
4603 signal_power -= 95;
4604
4605 return signal_power;
4606 }
4607
4608
4609 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
4610 be a local static. Otherwise, it may increase when we return from S3/S4. The
4611 value will be kept in memory or disk. We must delcare the value in adapter
4612 and it will be reinitialized when return from S3/S4. */
4613 void rtl8192_process_phyinfo(struct r8192_priv * priv,u8* buffer, struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
4614 {
4615 bool bcheck = false;
4616 u8 rfpath;
4617 u32 nspatial_stream, tmp_val;
4618 //u8 i;
4619 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
4620 static u32 slide_evm_index=0, slide_evm_statistics=0;
4621 static u32 last_rssi=0, last_evm=0;
4622
4623 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
4624 static u32 last_beacon_adc_pwdb=0;
4625
4626 struct ieee80211_hdr_3addr *hdr;
4627 u16 sc ;
4628 unsigned int frag,seq;
4629 hdr = (struct ieee80211_hdr_3addr *)buffer;
4630 sc = le16_to_cpu(hdr->seq_ctl);
4631 frag = WLAN_GET_SEQ_FRAG(sc);
4632 seq = WLAN_GET_SEQ_SEQ(sc);
4633 //cosa add 04292008 to record the sequence number
4634 pcurrent_stats->Seq_Num = seq;
4635 //
4636 // Check whether we should take the previous packet into accounting
4637 //
4638 if(!pprevious_stats->bIsAMPDU)
4639 {
4640 // if previous packet is not aggregated packet
4641 bcheck = true;
4642 }else
4643 {
4644 }
4645
4646
4647 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
4648 {
4649 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
4650 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
4651 priv->stats.slide_rssi_total -= last_rssi;
4652 }
4653 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
4654
4655 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
4656 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
4657 slide_rssi_index = 0;
4658
4659 // <1> Showed on UI for user, in dbm
4660 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
4661 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
4662 pcurrent_stats->rssi = priv->stats.signal_strength;
4663 //
4664 // If the previous packet does not match the criteria, neglect it
4665 //
4666 if(!pprevious_stats->bPacketMatchBSSID)
4667 {
4668 if(!pprevious_stats->bToSelfBA)
4669 return;
4670 }
4671
4672 if(!bcheck)
4673 return;
4674
4675
4676 //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
4677
4678 //
4679 // Check RSSI
4680 //
4681 priv->stats.num_process_phyinfo++;
4682
4683 /* record the general signal strength to the sliding window. */
4684
4685
4686 // <2> Showed on UI for engineering
4687 // hardware does not provide rssi information for each rf path in CCK
4688 if(!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA))
4689 {
4690 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++)
4691 {
4692 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
4693 continue;
4694
4695 //Fixed by Jacken 2008-03-20
4696 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
4697 {
4698 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
4699 //DbgPrint("MIMO RSSI initialize \n");
4700 }
4701 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
4702 {
4703 priv->stats.rx_rssi_percentage[rfpath] =
4704 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4705 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4706 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
4707 }
4708 else
4709 {
4710 priv->stats.rx_rssi_percentage[rfpath] =
4711 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
4712 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
4713 }
4714 RT_TRACE(COMP_DBG,"priv->stats.rx_rssi_percentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
4715 }
4716 }
4717
4718
4719 //
4720 // Check PWDB.
4721 //
4722 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4723 pprevious_stats->bIsCCK? "CCK": "OFDM",
4724 pprevious_stats->RxPWDBAll);
4725
4726 if(pprevious_stats->bPacketBeacon)
4727 {
4728 /* record the beacon pwdb to the sliding window. */
4729 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4730 {
4731 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
4732 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
4733 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
4734 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
4735 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
4736 }
4737 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
4738 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
4739 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
4740 slide_beacon_adc_pwdb_index++;
4741 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
4742 slide_beacon_adc_pwdb_index = 0;
4743 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
4744 if(pprevious_stats->RxPWDBAll >= 3)
4745 pprevious_stats->RxPWDBAll -= 3;
4746 }
4747
4748 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
4749 pprevious_stats->bIsCCK? "CCK": "OFDM",
4750 pprevious_stats->RxPWDBAll);
4751
4752
4753 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4754 {
4755 if(priv->undecorated_smoothed_pwdb < 0) // initialize
4756 {
4757 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
4758 //DbgPrint("First pwdb initialize \n");
4759 }
4760 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
4761 {
4762 priv->undecorated_smoothed_pwdb =
4763 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4764 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4765 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
4766 }
4767 else
4768 {
4769 priv->undecorated_smoothed_pwdb =
4770 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
4771 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
4772 }
4773
4774 }
4775
4776 //
4777 // Check EVM
4778 //
4779 /* record the general EVM to the sliding window. */
4780 if(pprevious_stats->SignalQuality == 0)
4781 {
4782 }
4783 else
4784 {
4785 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
4786 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
4787 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
4788 last_evm = priv->stats.slide_evm[slide_evm_index];
4789 priv->stats.slide_evm_total -= last_evm;
4790 }
4791
4792 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
4793
4794 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
4795 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
4796 slide_evm_index = 0;
4797
4798 // <1> Showed on UI for user, in percentage.
4799 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
4800 priv->stats.signal_quality = tmp_val;
4801 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
4802 priv->stats.last_signal_strength_inpercent = tmp_val;
4803 }
4804
4805 // <2> Showed on UI for engineering
4806 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
4807 {
4808 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
4809 {
4810 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
4811 {
4812 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
4813 {
4814 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
4815 }
4816 priv->stats.rx_evm_percentage[nspatial_stream] =
4817 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
4818 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
4819 }
4820 }
4821 }
4822 }
4823
4824
4825 }
4826
4827 /*-----------------------------------------------------------------------------
4828 * Function: rtl819x_query_rxpwrpercentage()
4829 *
4830 * Overview:
4831 *
4832 * Input: char antpower
4833 *
4834 * Output: NONE
4835 *
4836 * Return: 0-100 percentage
4837 *
4838 * Revised History:
4839 * When Who Remark
4840 * 05/26/2008 amy Create Version 0 porting from windows code.
4841 *
4842 *---------------------------------------------------------------------------*/
4843 static u8 rtl819x_query_rxpwrpercentage(
4844 char antpower
4845 )
4846 {
4847 if ((antpower <= -100) || (antpower >= 20))
4848 {
4849 return 0;
4850 }
4851 else if (antpower >= 0)
4852 {
4853 return 100;
4854 }
4855 else
4856 {
4857 return (100+antpower);
4858 }
4859
4860 } /* QueryRxPwrPercentage */
4861
4862 static u8
4863 rtl819x_evm_dbtopercentage(
4864 char value
4865 )
4866 {
4867 char ret_val;
4868
4869 ret_val = value;
4870
4871 if(ret_val >= 0)
4872 ret_val = 0;
4873 if(ret_val <= -33)
4874 ret_val = -33;
4875 ret_val = 0 - ret_val;
4876 ret_val*=3;
4877 if(ret_val == 99)
4878 ret_val = 100;
4879 return(ret_val);
4880 }
4881 //
4882 // Description:
4883 // We want good-looking for signal strength/quality
4884 // 2007/7/19 01:09, by cosa.
4885 //
4886 long
4887 rtl819x_signal_scale_mapping(
4888 long currsig
4889 )
4890 {
4891 long retsig;
4892
4893 // Step 1. Scale mapping.
4894 if(currsig >= 61 && currsig <= 100)
4895 {
4896 retsig = 90 + ((currsig - 60) / 4);
4897 }
4898 else if(currsig >= 41 && currsig <= 60)
4899 {
4900 retsig = 78 + ((currsig - 40) / 2);
4901 }
4902 else if(currsig >= 31 && currsig <= 40)
4903 {
4904 retsig = 66 + (currsig - 30);
4905 }
4906 else if(currsig >= 21 && currsig <= 30)
4907 {
4908 retsig = 54 + (currsig - 20);
4909 }
4910 else if(currsig >= 5 && currsig <= 20)
4911 {
4912 retsig = 42 + (((currsig - 5) * 2) / 3);
4913 }
4914 else if(currsig == 4)
4915 {
4916 retsig = 36;
4917 }
4918 else if(currsig == 3)
4919 {
4920 retsig = 27;
4921 }
4922 else if(currsig == 2)
4923 {
4924 retsig = 18;
4925 }
4926 else if(currsig == 1)
4927 {
4928 retsig = 9;
4929 }
4930 else
4931 {
4932 retsig = currsig;
4933 }
4934
4935 return retsig;
4936 }
4937
4938 static void rtl8192_query_rxphystatus(
4939 struct r8192_priv * priv,
4940 struct ieee80211_rx_stats * pstats,
4941 rx_drvinfo_819x_usb * pdrvinfo,
4942 struct ieee80211_rx_stats * precord_stats,
4943 bool bpacket_match_bssid,
4944 bool bpacket_toself,
4945 bool bPacketBeacon,
4946 bool bToSelfBA
4947 )
4948 {
4949 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
4950 phy_sts_ofdm_819xusb_t* pofdm_buf;
4951 phy_sts_cck_819xusb_t * pcck_buf;
4952 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
4953 u8 *prxpkt;
4954 u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
4955 char rx_pwr[4], rx_pwr_all=0;
4956 //long rx_avg_pwr = 0;
4957 char rx_snrX, rx_evmX;
4958 u8 evm, pwdb_all;
4959 u32 RSSI, total_rssi=0;//, total_evm=0;
4960 // long signal_strength_index = 0;
4961 u8 is_cck_rate=0;
4962 u8 rf_rx_num = 0;
4963
4964
4965 priv->stats.numqry_phystatus++;
4966
4967 is_cck_rate = rx_hal_is_cck_rate(pdrvinfo);
4968
4969 // Record it for next packet processing
4970 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
4971 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
4972 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
4973 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
4974 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
4975 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
4976
4977 prxpkt = (u8*)pdrvinfo;
4978
4979 /* Move pointer to the 16th bytes. Phy status start address. */
4980 prxpkt += sizeof(rx_drvinfo_819x_usb);
4981
4982 /* Initial the cck and ofdm buffer pointer */
4983 pcck_buf = (phy_sts_cck_819xusb_t *)prxpkt;
4984 pofdm_buf = (phy_sts_ofdm_819xusb_t *)prxpkt;
4985
4986 pstats->RxMIMOSignalQuality[0] = -1;
4987 pstats->RxMIMOSignalQuality[1] = -1;
4988 precord_stats->RxMIMOSignalQuality[0] = -1;
4989 precord_stats->RxMIMOSignalQuality[1] = -1;
4990
4991 if(is_cck_rate)
4992 {
4993 //
4994 // (1)Hardware does not provide RSSI for CCK
4995 //
4996
4997 //
4998 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
4999 //
5000 u8 report;//, cck_agc_rpt;
5001
5002 priv->stats.numqry_phystatusCCK++;
5003
5004 if(!priv->bCckHighPower)
5005 {
5006 report = pcck_buf->cck_agc_rpt & 0xc0;
5007 report = report>>6;
5008 switch(report)
5009 {
5010 //Fixed by Jacken from Bryant 2008-03-20
5011 //Original value is -38 , -26 , -14 , -2
5012 //Fixed value is -35 , -23 , -11 , 6
5013 case 0x3:
5014 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
5015 break;
5016 case 0x2:
5017 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
5018 break;
5019 case 0x1:
5020 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
5021 break;
5022 case 0x0:
5023 rx_pwr_all = 6 - (pcck_buf->cck_agc_rpt & 0x3e);
5024 break;
5025 }
5026 }
5027 else
5028 {
5029 report = pcck_buf->cck_agc_rpt & 0x60;
5030 report = report>>5;
5031 switch(report)
5032 {
5033 case 0x3:
5034 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5035 break;
5036 case 0x2:
5037 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
5038 break;
5039 case 0x1:
5040 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5041 break;
5042 case 0x0:
5043 rx_pwr_all = 6 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
5044 break;
5045 }
5046 }
5047
5048 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5049 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5050 pstats->RecvSignalPower = pwdb_all;
5051
5052 //
5053 // (3) Get Signal Quality (EVM)
5054 //
5055 //if(bpacket_match_bssid)
5056 {
5057 u8 sq;
5058
5059 if(pstats->RxPWDBAll > 40)
5060 {
5061 sq = 100;
5062 }else
5063 {
5064 sq = pcck_buf->sq_rpt;
5065
5066 if(pcck_buf->sq_rpt > 64)
5067 sq = 0;
5068 else if (pcck_buf->sq_rpt < 20)
5069 sq = 100;
5070 else
5071 sq = ((64-sq) * 100) / 44;
5072 }
5073 pstats->SignalQuality = precord_stats->SignalQuality = sq;
5074 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
5075 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
5076 }
5077 }
5078 else
5079 {
5080 priv->stats.numqry_phystatusHT++;
5081 //
5082 // (1)Get RSSI for HT rate
5083 //
5084 for(i=RF90_PATH_A; i<priv->NumTotalRFPath; i++)
5085 {
5086 // 2008/01/30 MH we will judge RF RX path now.
5087 if (priv->brfpath_rxenable[i])
5088 rf_rx_num++;
5089 else
5090 continue;
5091
5092 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
5093 continue;
5094
5095 //Fixed by Jacken from Bryant 2008-03-20
5096 //Original value is 106
5097 rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
5098
5099 //Get Rx snr value in DB
5100 tmp_rxsnr = pofdm_buf->rxsnr_X[i];
5101 rx_snrX = (char)(tmp_rxsnr);
5102 //rx_snrX >>= 1;;
5103 rx_snrX /= 2;
5104 priv->stats.rxSNRdB[i] = (long)rx_snrX;
5105
5106 /* Translate DBM to percentage. */
5107 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
5108 total_rssi += RSSI;
5109
5110 /* Record Signal Strength for next packet */
5111 //if(bpacket_match_bssid)
5112 {
5113 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
5114 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
5115 }
5116 }
5117
5118
5119 //
5120 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
5121 //
5122 //Fixed by Jacken from Bryant 2008-03-20
5123 //Original value is 106
5124 rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
5125 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
5126
5127 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
5128 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
5129
5130 //
5131 // (3)EVM of HT rate
5132 //
5133 if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
5134 pdrvinfo->RxRate<=DESC90_RATEMCS15)
5135 max_spatial_stream = 2; //both spatial stream make sense
5136 else
5137 max_spatial_stream = 1; //only spatial stream 1 makes sense
5138
5139 for(i=0; i<max_spatial_stream; i++)
5140 {
5141 tmp_rxevm = pofdm_buf->rxevm_X[i];
5142 rx_evmX = (char)(tmp_rxevm);
5143
5144 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
5145 // fill most significant bit to "zero" when doing shifting operation which may change a negative
5146 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
5147 rx_evmX /= 2; //dbm
5148
5149 evm = rtl819x_evm_dbtopercentage(rx_evmX);
5150 //if(bpacket_match_bssid)
5151 {
5152 if(i==0) // Fill value in RFD, Get the first spatial stream only
5153 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
5154 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
5155 }
5156 }
5157
5158
5159 /* record rx statistics for debug */
5160 rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
5161 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
5162 if(pdrvinfo->BW) //40M channel
5163 priv->stats.received_bwtype[1+prxsc->rxsc]++;
5164 else //20M channel
5165 priv->stats.received_bwtype[0]++;
5166 }
5167
5168 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
5169 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
5170 if(is_cck_rate)
5171 {
5172 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;
5173
5174 }
5175 else
5176 {
5177 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u8)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u8)(total_rssi/=RF90_PATH_MAX);
5178 // We can judge RX path number now.
5179 if (rf_rx_num != 0)
5180 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
5181 }
5182 } /* QueryRxPhyStatus8190Pci */
5183
5184 void
5185 rtl8192_record_rxdesc_forlateruse(
5186 struct ieee80211_rx_stats * psrc_stats,
5187 struct ieee80211_rx_stats * ptarget_stats
5188 )
5189 {
5190 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
5191 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
5192 ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
5193 }
5194
5195
5196 void TranslateRxSignalStuff819xUsb(struct sk_buff *skb,
5197 struct ieee80211_rx_stats * pstats,
5198 rx_drvinfo_819x_usb *pdrvinfo)
5199 {
5200 // TODO: We must only check packet for current MAC address. Not finish
5201 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5202 struct net_device *dev=info->dev;
5203 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5204 bool bpacket_match_bssid, bpacket_toself;
5205 bool bPacketBeacon=FALSE, bToSelfBA=FALSE;
5206 static struct ieee80211_rx_stats previous_stats;
5207 struct ieee80211_hdr_3addr *hdr;//by amy
5208 u16 fc,type;
5209
5210 // Get Signal Quality for only RX data queue (but not command queue)
5211
5212 u8* tmp_buf;
5213 //u16 tmp_buf_len = 0;
5214 u8 *praddr;
5215
5216 /* Get MAC frame start address. */
5217 tmp_buf = (u8*)skb->data;// + get_rxpacket_shiftbytes_819xusb(pstats);
5218
5219 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
5220 fc = le16_to_cpu(hdr->frame_ctl);
5221 type = WLAN_FC_GET_TYPE(fc);
5222 praddr = hdr->addr1;
5223
5224 /* Check if the received packet is acceptabe. */
5225 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
5226 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
5227 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
5228 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
5229
5230 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
5231 {
5232 bPacketBeacon = true;
5233 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5234 }
5235 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
5236 {
5237 if((eqMacAddr(praddr,dev->dev_addr)))
5238 bToSelfBA = true;
5239 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
5240 }
5241
5242
5243
5244 if(bpacket_match_bssid)
5245 {
5246 priv->stats.numpacket_matchbssid++;
5247 }
5248 if(bpacket_toself){
5249 priv->stats.numpacket_toself++;
5250 }
5251 //
5252 // Process PHY information for previous packet (RSSI/PWDB/EVM)
5253 //
5254 // Because phy information is contained in the last packet of AMPDU only, so driver
5255 // should process phy information of previous packet
5256 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
5257 rtl8192_query_rxphystatus(priv, pstats, pdrvinfo, &previous_stats, bpacket_match_bssid,bpacket_toself,bPacketBeacon,bToSelfBA);
5258 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
5259
5260 }
5261
5262 /**
5263 * Function: UpdateReceivedRateHistogramStatistics
5264 * Overview: Recored down the received data rate
5265 *
5266 * Input:
5267 * struct net_device *dev
5268 * struct ieee80211_rx_stats *stats
5269 *
5270 * Output:
5271 *
5272 * (priv->stats.ReceivedRateHistogram[] is updated)
5273 * Return:
5274 * None
5275 */
5276 void
5277 UpdateReceivedRateHistogramStatistics8190(
5278 struct net_device *dev,
5279 struct ieee80211_rx_stats *stats
5280 )
5281 {
5282 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5283 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
5284 u32 rateIndex;
5285 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
5286
5287
5288 if(stats->bCRC)
5289 rcvType = 2;
5290 else if(stats->bICV)
5291 rcvType = 3;
5292
5293 if(stats->bShortPreamble)
5294 preamble_guardinterval = 1;// short
5295 else
5296 preamble_guardinterval = 0;// long
5297
5298 switch(stats->rate)
5299 {
5300 //
5301 // CCK rate
5302 //
5303 case MGN_1M: rateIndex = 0; break;
5304 case MGN_2M: rateIndex = 1; break;
5305 case MGN_5_5M: rateIndex = 2; break;
5306 case MGN_11M: rateIndex = 3; break;
5307 //
5308 // Legacy OFDM rate
5309 //
5310 case MGN_6M: rateIndex = 4; break;
5311 case MGN_9M: rateIndex = 5; break;
5312 case MGN_12M: rateIndex = 6; break;
5313 case MGN_18M: rateIndex = 7; break;
5314 case MGN_24M: rateIndex = 8; break;
5315 case MGN_36M: rateIndex = 9; break;
5316 case MGN_48M: rateIndex = 10; break;
5317 case MGN_54M: rateIndex = 11; break;
5318 //
5319 // 11n High throughput rate
5320 //
5321 case MGN_MCS0: rateIndex = 12; break;
5322 case MGN_MCS1: rateIndex = 13; break;
5323 case MGN_MCS2: rateIndex = 14; break;
5324 case MGN_MCS3: rateIndex = 15; break;
5325 case MGN_MCS4: rateIndex = 16; break;
5326 case MGN_MCS5: rateIndex = 17; break;
5327 case MGN_MCS6: rateIndex = 18; break;
5328 case MGN_MCS7: rateIndex = 19; break;
5329 case MGN_MCS8: rateIndex = 20; break;
5330 case MGN_MCS9: rateIndex = 21; break;
5331 case MGN_MCS10: rateIndex = 22; break;
5332 case MGN_MCS11: rateIndex = 23; break;
5333 case MGN_MCS12: rateIndex = 24; break;
5334 case MGN_MCS13: rateIndex = 25; break;
5335 case MGN_MCS14: rateIndex = 26; break;
5336 case MGN_MCS15: rateIndex = 27; break;
5337 default: rateIndex = 28; break;
5338 }
5339 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
5340 priv->stats.received_rate_histogram[0][rateIndex]++; //total
5341 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
5342 }
5343
5344
5345 void query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe)
5346 {
5347 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5348 struct net_device *dev=info->dev;
5349 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5350 //rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5351 rx_drvinfo_819x_usb *driver_info = NULL;
5352
5353 //
5354 //Get Rx Descriptor Information
5355 //
5356 #ifdef USB_RX_AGGREGATION_SUPPORT
5357 if (bIsRxAggrSubframe)
5358 {
5359 rx_desc_819x_usb_aggr_subframe *desc = (rx_desc_819x_usb_aggr_subframe *)skb->data;
5360 stats->Length = desc->Length ;
5361 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5362 stats->RxBufShift = 0; //RxBufShift = 2 in RxDesc, but usb didn't shift bytes in fact.
5363 stats->bICV = desc->ICV;
5364 stats->bCRC = desc->CRC32;
5365 stats->bHwError = stats->bCRC|stats->bICV;
5366 stats->Decrypted = !desc->SWDec;//RTL8190 set this bit to indicate that Hw does not decrypt packet
5367 } else
5368 #endif
5369 {
5370 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5371
5372 stats->Length = desc->Length;
5373 stats->RxDrvInfoSize = desc->RxDrvInfoSize;
5374 stats->RxBufShift = 0;//desc->Shift&0x03;
5375 stats->bICV = desc->ICV;
5376 stats->bCRC = desc->CRC32;
5377 stats->bHwError = stats->bCRC|stats->bICV;
5378 //RTL8190 set this bit to indicate that Hw does not decrypt packet
5379 stats->Decrypted = !desc->SWDec;
5380 }
5381
5382 if((priv->ieee80211->pHTInfo->bCurrentHTSupport == true) && (priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP))
5383 {
5384 stats->bHwError = false;
5385 }
5386 else
5387 {
5388 stats->bHwError = stats->bCRC|stats->bICV;
5389 }
5390
5391 if(stats->Length < 24 || stats->Length > MAX_8192U_RX_SIZE)
5392 stats->bHwError |= 1;
5393 //
5394 //Get Driver Info
5395 //
5396 // TODO: Need to verify it on FGPA platform
5397 //Driver info are written to the RxBuffer following rx desc
5398 if (stats->RxDrvInfoSize != 0) {
5399 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) + \
5400 stats->RxBufShift);
5401 /* unit: 0.5M */
5402 /* TODO */
5403 if(!stats->bHwError){
5404 u8 ret_rate;
5405 ret_rate = HwRateToMRate90(driver_info->RxHT, driver_info->RxRate);
5406 if(ret_rate == 0xff)
5407 {
5408 // Abnormal Case: Receive CRC OK packet with Rx descriptor indicating non supported rate.
5409 // Special Error Handling here, 2008.05.16, by Emily
5410
5411 stats->bHwError = 1;
5412 stats->rate = MGN_1M; //Set 1M rate by default
5413 }else
5414 {
5415 stats->rate = ret_rate;
5416 }
5417 }
5418 else
5419 stats->rate = 0x02;
5420
5421 stats->bShortPreamble = driver_info->SPLCP;
5422
5423
5424 UpdateReceivedRateHistogramStatistics8190(dev, stats);
5425
5426 stats->bIsAMPDU = (driver_info->PartAggr==1);
5427 stats->bFirstMPDU = (driver_info->PartAggr==1) && (driver_info->FirstAGGR==1);
5428 stats->TimeStampLow = driver_info->TSFL;
5429 // xiong mask it, 070514
5430 //pRfd->Status.TimeStampHigh = PlatformEFIORead4Byte(Adapter, TSFR+4);
5431 // stats->TimeStampHigh = read_nic_dword(dev, TSFR+4);
5432
5433 UpdateRxPktTimeStamp8190(dev, stats);
5434
5435 //
5436 // Rx A-MPDU
5437 //
5438 if(driver_info->FirstAGGR==1 || driver_info->PartAggr == 1)
5439 RT_TRACE(COMP_RXDESC, "driver_info->FirstAGGR = %d, driver_info->PartAggr = %d\n",
5440 driver_info->FirstAGGR, driver_info->PartAggr);
5441
5442 }
5443
5444 skb_pull(skb,sizeof(rx_desc_819x_usb));
5445 //
5446 // Get Total offset of MPDU Frame Body
5447 //
5448 if((stats->RxBufShift + stats->RxDrvInfoSize) > 0) {
5449 stats->bShift = 1;
5450 skb_pull(skb,stats->RxBufShift + stats->RxDrvInfoSize);
5451 }
5452
5453 #ifdef USB_RX_AGGREGATION_SUPPORT
5454 /* for the rx aggregated sub frame, the redundant space truelly contained in the packet */
5455 if(bIsRxAggrSubframe) {
5456 skb_pull(skb, 8);
5457 }
5458 #endif
5459 /* for debug 2008.5.29 */
5460
5461 //added by vivi, for MP, 20080108
5462 stats->RxIs40MHzPacket = driver_info->BW;
5463 if(stats->RxDrvInfoSize != 0)
5464 TranslateRxSignalStuff819xUsb(skb, stats, driver_info);
5465
5466 }
5467
5468 u32 GetRxPacketShiftBytes819xUsb(struct ieee80211_rx_stats *Status, bool bIsRxAggrSubframe)
5469 {
5470 #ifdef USB_RX_AGGREGATION_SUPPORT
5471 if (bIsRxAggrSubframe)
5472 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5473 + Status->RxBufShift + 8);
5474 else
5475 #endif
5476 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize
5477 + Status->RxBufShift);
5478 }
5479
5480 void rtl8192_rx_nomal(struct sk_buff* skb)
5481 {
5482 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5483 struct net_device *dev=info->dev;
5484 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5485 struct ieee80211_rx_stats stats = {
5486 .signal = 0,
5487 .noise = -98,
5488 .rate = 0,
5489 // .mac_time = jiffies,
5490 .freq = IEEE80211_24GHZ_BAND,
5491 };
5492 u32 rx_pkt_len = 0;
5493 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
5494 bool unicast_packet = false;
5495 #ifdef USB_RX_AGGREGATION_SUPPORT
5496 struct sk_buff *agg_skb = NULL;
5497 u32 TotalLength = 0;
5498 u32 TempDWord = 0;
5499 u32 PacketLength = 0;
5500 u32 PacketOccupiedLendth = 0;
5501 u8 TempByte = 0;
5502 u32 PacketShiftBytes = 0;
5503 rx_desc_819x_usb_aggr_subframe *RxDescr = NULL;
5504 u8 PaddingBytes = 0;
5505 //add just for testing
5506 u8 testing;
5507
5508 #endif
5509
5510 /* 20 is for ps-poll */
5511 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
5512 #ifdef USB_RX_AGGREGATION_SUPPORT
5513 TempByte = *(skb->data + sizeof(rx_desc_819x_usb));
5514 #endif
5515 /* first packet should not contain Rx aggregation header */
5516 query_rxdesc_status(skb, &stats, false);
5517 /* TODO */
5518 /* hardware related info */
5519 #ifdef USB_RX_AGGREGATION_SUPPORT
5520 if (TempByte & BIT0) {
5521 agg_skb = skb;
5522 //TotalLength = agg_skb->len - 4; /*sCrcLng*/
5523 TotalLength = stats.Length - 4; /*sCrcLng*/
5524 //RT_TRACE(COMP_RECV, "%s:first aggregated packet!Length=%d\n",__FUNCTION__,TotalLength);
5525 /* though the head pointer has passed this position */
5526 TempDWord = *(u32 *)(agg_skb->data - 4);
5527 PacketLength = (u16)(TempDWord & 0x3FFF); /*sCrcLng*/
5528 skb = dev_alloc_skb(PacketLength);
5529 memcpy(skb_put(skb,PacketLength),agg_skb->data,PacketLength);
5530 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, false);
5531 }
5532 #endif
5533 /* Process the MPDU recevied */
5534 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5535
5536 rx_pkt_len = skb->len;
5537 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5538 unicast_packet = false;
5539 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5540 //TODO
5541 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5542 //TODO
5543 }else {
5544 /* unicast packet */
5545 unicast_packet = true;
5546 }
5547
5548 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5549 dev_kfree_skb_any(skb);
5550 } else {
5551 priv->stats.rxoktotal++;
5552 if(unicast_packet) {
5553 priv->stats.rxbytesunicast += rx_pkt_len;
5554 }
5555 }
5556 #ifdef USB_RX_AGGREGATION_SUPPORT
5557 testing = 1;
5558 // (PipeIndex == 0) && (TempByte & BIT0) => TotalLength > 0.
5559 if (TotalLength > 0) {
5560 PacketOccupiedLendth = PacketLength + (PacketShiftBytes + 8);
5561 if ((PacketOccupiedLendth & 0xFF) != 0)
5562 PacketOccupiedLendth = (PacketOccupiedLendth & 0xFFFFFF00) + 256;
5563 PacketOccupiedLendth -= 8;
5564 TempDWord = PacketOccupiedLendth - PacketShiftBytes; /*- PacketLength */
5565 if (agg_skb->len > TempDWord)
5566 skb_pull(agg_skb, TempDWord);
5567 else
5568 agg_skb->len = 0;
5569
5570 while (agg_skb->len>=GetRxPacketShiftBytes819xUsb(&stats, true)) {
5571 u8 tmpCRC = 0, tmpICV = 0;
5572 //RT_TRACE(COMP_RECV,"%s:aggred pkt,total_len = %d\n",__FUNCTION__,agg_skb->len);
5573 RxDescr = (rx_desc_819x_usb_aggr_subframe *)(agg_skb->data);
5574 tmpCRC = RxDescr->CRC32;
5575 tmpICV = RxDescr->ICV;
5576 memcpy(agg_skb->data, &agg_skb->data[44], 2);
5577 RxDescr->CRC32 = tmpCRC;
5578 RxDescr->ICV = tmpICV;
5579
5580 memset(&stats, 0, sizeof(struct ieee80211_rx_stats));
5581 stats.signal = 0;
5582 stats.noise = -98;
5583 stats.rate = 0;
5584 stats.freq = IEEE80211_24GHZ_BAND;
5585 query_rxdesc_status(agg_skb, &stats, true);
5586 PacketLength = stats.Length;
5587
5588 if(PacketLength > agg_skb->len) {
5589 break;
5590 }
5591 /* Process the MPDU recevied */
5592 skb = dev_alloc_skb(PacketLength);
5593 memcpy(skb_put(skb,PacketLength),agg_skb->data, PacketLength);
5594 skb_trim(skb, skb->len - 4/*sCrcLng*/);
5595
5596 rx_pkt_len = skb->len;
5597 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
5598 unicast_packet = false;
5599 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
5600 //TODO
5601 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
5602 //TODO
5603 }else {
5604 /* unicast packet */
5605 unicast_packet = true;
5606 }
5607 if(!ieee80211_rx(priv->ieee80211,skb, &stats)) {
5608 dev_kfree_skb_any(skb);
5609 } else {
5610 priv->stats.rxoktotal++;
5611 if(unicast_packet) {
5612 priv->stats.rxbytesunicast += rx_pkt_len;
5613 }
5614 }
5615 /* should trim the packet which has been copied to target skb */
5616 skb_pull(agg_skb, PacketLength);
5617 PacketShiftBytes = GetRxPacketShiftBytes819xUsb(&stats, true);
5618 PacketOccupiedLendth = PacketLength + PacketShiftBytes;
5619 if ((PacketOccupiedLendth & 0xFF) != 0) {
5620 PaddingBytes = 256 - (PacketOccupiedLendth & 0xFF);
5621 if (agg_skb->len > PaddingBytes)
5622 skb_pull(agg_skb, PaddingBytes);
5623 else
5624 agg_skb->len = 0;
5625 }
5626 }
5627 dev_kfree_skb(agg_skb);
5628 }
5629 #endif
5630 } else {
5631 priv->stats.rxurberr++;
5632 printk("actual_length:%d\n", skb->len);
5633 dev_kfree_skb_any(skb);
5634 }
5635
5636 }
5637
5638 void
5639 rtl819xusb_process_received_packet(
5640 struct net_device *dev,
5641 struct ieee80211_rx_stats *pstats
5642 )
5643 {
5644 // bool bfreerfd=false, bqueued=false;
5645 u8* frame;
5646 u16 frame_len=0;
5647 struct r8192_priv *priv = ieee80211_priv(dev);
5648 // u8 index = 0;
5649 // u8 TID = 0;
5650 //u16 seqnum = 0;
5651 //PRX_TS_RECORD pts = NULL;
5652
5653 // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
5654 //porting by amy 080508
5655 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
5656 frame = pstats->virtual_address;
5657 frame_len = pstats->packetlength;
5658 #ifdef TODO // by amy about HCT
5659 if(!Adapter->bInHctTest)
5660 CountRxErrStatistics(Adapter, pRfd);
5661 #endif
5662 {
5663 #ifdef ENABLE_PS //by amy for adding ps function in future
5664 RT_RF_POWER_STATE rtState;
5665 // When RF is off, we should not count the packet for hw/sw synchronize
5666 // reason, ie. there may be a duration while sw switch is changed and hw
5667 // switch is being changed. 2006.12.04, by shien chang.
5668 Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8* )(&rtState));
5669 if (rtState == eRfOff)
5670 {
5671 return;
5672 }
5673 #endif
5674 priv->stats.rxframgment++;
5675
5676 }
5677 #ifdef TODO
5678 RmMonitorSignalStrength(Adapter, pRfd);
5679 #endif
5680 /* 2007/01/16 MH Add RX command packet handle here. */
5681 /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
5682 if (rtl819xusb_rx_command_packet(dev, pstats))
5683 {
5684 return;
5685 }
5686
5687 #ifdef SW_CRC_CHECK
5688 SwCrcCheck();
5689 #endif
5690
5691
5692 }
5693
5694 void query_rx_cmdpkt_desc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats)
5695 {
5696 // rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5697 // struct net_device *dev=info->dev;
5698 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5699 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
5700 // rx_drvinfo_819x_usb *driver_info;
5701
5702 //
5703 //Get Rx Descriptor Information
5704 //
5705 stats->virtual_address = (u8*)skb->data;
5706 stats->Length = desc->Length;
5707 stats->RxDrvInfoSize = 0;
5708 stats->RxBufShift = 0;
5709 stats->packetlength = stats->Length-scrclng;
5710 stats->fraglength = stats->packetlength;
5711 stats->fragoffset = 0;
5712 stats->ntotalfrag = 1;
5713 }
5714
5715
5716 void rtl8192_rx_cmd(struct sk_buff *skb)
5717 {
5718 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
5719 struct net_device *dev = info->dev;
5720 //int ret;
5721 // struct urb *rx_urb = info->urb;
5722 /* TODO */
5723 struct ieee80211_rx_stats stats = {
5724 .signal = 0,
5725 .noise = -98,
5726 .rate = 0,
5727 // .mac_time = jiffies,
5728 .freq = IEEE80211_24GHZ_BAND,
5729 };
5730
5731 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE))
5732 {
5733
5734 query_rx_cmdpkt_desc_status(skb,&stats);
5735 // this is to be done by amy 080508 prfd->queue_id = 1;
5736
5737
5738 //
5739 // Process the command packet received.
5740 //
5741
5742 rtl819xusb_process_received_packet(dev,&stats);
5743
5744 dev_kfree_skb_any(skb);
5745 }
5746 else
5747 ;
5748
5749
5750 }
5751
5752 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
5753 {
5754 struct sk_buff *skb;
5755 struct rtl8192_rx_info *info;
5756
5757 while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
5758 info = (struct rtl8192_rx_info *)skb->cb;
5759 switch (info->out_pipe) {
5760 /* Nomal packet pipe */
5761 case 3:
5762 //RT_TRACE(COMP_RECV, "normal in-pipe index(%d)\n",info->out_pipe);
5763 priv->IrpPendingCount--;
5764 rtl8192_rx_nomal(skb);
5765 break;
5766
5767 /* Command packet pipe */
5768 case 9:
5769 RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",\
5770 info->out_pipe);
5771
5772 rtl8192_rx_cmd(skb);
5773 break;
5774
5775 default: /* should never get here! */
5776 RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",\
5777 info->out_pipe);
5778 dev_kfree_skb(skb);
5779 break;
5780
5781 }
5782 }
5783 }
5784
5785 static const struct net_device_ops rtl8192_netdev_ops = {
5786 .ndo_open = rtl8192_open,
5787 .ndo_stop = rtl8192_close,
5788 .ndo_get_stats = rtl8192_stats,
5789 .ndo_tx_timeout = tx_timeout,
5790 .ndo_do_ioctl = rtl8192_ioctl,
5791 .ndo_set_multicast_list = r8192_set_multicast,
5792 .ndo_set_mac_address = r8192_set_mac_adr,
5793 .ndo_validate_addr = eth_validate_addr,
5794 .ndo_change_mtu = eth_change_mtu,
5795 .ndo_start_xmit = ieee80211_xmit,
5796 };
5797
5798
5799 /****************************************************************************
5800 ---------------------------- USB_STUFF---------------------------
5801 *****************************************************************************/
5802
5803 static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
5804 const struct usb_device_id *id)
5805 {
5806 // unsigned long ioaddr = 0;
5807 struct net_device *dev = NULL;
5808 struct r8192_priv *priv= NULL;
5809 struct usb_device *udev = interface_to_usbdev(intf);
5810 RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
5811
5812 dev = alloc_ieee80211(sizeof(struct r8192_priv));
5813
5814
5815 usb_set_intfdata(intf, dev);
5816 SET_NETDEV_DEV(dev, &intf->dev);
5817 priv = ieee80211_priv(dev);
5818 priv->ieee80211 = netdev_priv(dev);
5819 priv->udev=udev;
5820
5821 dev->netdev_ops = &rtl8192_netdev_ops;
5822
5823 //DMESG("Oops: i'm coming\n");
5824 #if WIRELESS_EXT >= 12
5825 #if WIRELESS_EXT < 17
5826 dev->get_wireless_stats = r8192_get_wireless_stats;
5827 #endif
5828 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
5829 #endif
5830 dev->type=ARPHRD_ETHER;
5831
5832 dev->watchdog_timeo = HZ*3; //modified by john, 0805
5833
5834 if (dev_alloc_name(dev, ifname) < 0){
5835 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
5836 ifname = "wlan%d";
5837 dev_alloc_name(dev, ifname);
5838 }
5839
5840 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
5841 if(rtl8192_init(dev)!=0){
5842 RT_TRACE(COMP_ERR, "Initialization failed");
5843 goto fail;
5844 }
5845 netif_carrier_off(dev);
5846 netif_stop_queue(dev);
5847
5848 register_netdev(dev);
5849 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
5850 rtl8192_proc_init_one(dev);
5851
5852
5853 RT_TRACE(COMP_INIT, "Driver probe completed\n");
5854 return 0;
5855
5856
5857 fail:
5858 free_ieee80211(dev);
5859
5860 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
5861 return -ENODEV;
5862
5863 }
5864
5865 //detach all the work and timer structure declared or inititialize in r8192U_init function.
5866 void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
5867 {
5868
5869 cancel_work_sync(&priv->reset_wq);
5870 cancel_delayed_work(&priv->watch_dog_wq);
5871 cancel_delayed_work(&priv->update_beacon_wq);
5872 cancel_work_sync(&priv->qos_activate);
5873 //cancel_work_sync(&priv->SetBWModeWorkItem);
5874 //cancel_work_sync(&priv->SwChnlWorkItem);
5875
5876 }
5877
5878
5879 static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf)
5880 {
5881 struct net_device *dev = usb_get_intfdata(intf);
5882
5883 struct r8192_priv *priv = ieee80211_priv(dev);
5884 if(dev){
5885
5886 unregister_netdev(dev);
5887
5888 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
5889 rtl8192_proc_remove_one(dev);
5890
5891 rtl8192_down(dev);
5892 if (priv->pFirmware)
5893 {
5894 kfree(priv->pFirmware);
5895 priv->pFirmware = NULL;
5896 }
5897 // priv->rf_close(dev);
5898 // rtl8192_SetRFPowerState(dev, eRfOff);
5899 rtl8192_usb_deleteendpoints(dev);
5900 destroy_workqueue(priv->priv_wq);
5901 //rtl8192_irq_disable(dev);
5902 //rtl8192_reset(dev);
5903 mdelay(10);
5904
5905 }
5906 free_ieee80211(dev);
5907 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
5908 }
5909
5910 /* fun with the built-in ieee80211 stack... */
5911 extern int ieee80211_debug_init(void);
5912 extern void ieee80211_debug_exit(void);
5913 extern int ieee80211_crypto_init(void);
5914 extern void ieee80211_crypto_deinit(void);
5915 extern int ieee80211_crypto_tkip_init(void);
5916 extern void ieee80211_crypto_tkip_exit(void);
5917 extern int ieee80211_crypto_ccmp_init(void);
5918 extern void ieee80211_crypto_ccmp_exit(void);
5919 extern int ieee80211_crypto_wep_init(void);
5920 extern void ieee80211_crypto_wep_exit(void);
5921
5922 static int __init rtl8192_usb_module_init(void)
5923 {
5924 int ret;
5925
5926 #ifdef CONFIG_IEEE80211_DEBUG
5927 ret = ieee80211_debug_init();
5928 if (ret) {
5929 printk(KERN_ERR "ieee80211_debug_init() failed %d\n", ret);
5930 return ret;
5931 }
5932 #endif
5933 ret = ieee80211_crypto_init();
5934 if (ret) {
5935 printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
5936 return ret;
5937 }
5938
5939 ret = ieee80211_crypto_tkip_init();
5940 if (ret) {
5941 printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n",
5942 ret);
5943 return ret;
5944 }
5945
5946 ret = ieee80211_crypto_ccmp_init();
5947 if (ret) {
5948 printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n",
5949 ret);
5950 return ret;
5951 }
5952
5953 ret = ieee80211_crypto_wep_init();
5954 if (ret) {
5955 printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
5956 return ret;
5957 }
5958
5959 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
5960 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
5961 RT_TRACE(COMP_INIT, "Initializing module");
5962 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
5963 rtl8192_proc_module_init();
5964 return usb_register(&rtl8192_usb_driver);
5965 }
5966
5967
5968 static void __exit rtl8192_usb_module_exit(void)
5969 {
5970 usb_deregister(&rtl8192_usb_driver);
5971
5972 RT_TRACE(COMP_DOWN, "Exiting");
5973 // rtl8192_proc_module_remove();
5974 }
5975
5976
5977 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
5978 {
5979 unsigned long flags;
5980 short enough_desc;
5981 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5982
5983 spin_lock_irqsave(&priv->tx_lock,flags);
5984 enough_desc = check_nic_enough_desc(dev,pri);
5985 spin_unlock_irqrestore(&priv->tx_lock,flags);
5986
5987 if(enough_desc)
5988 ieee80211_wake_queue(priv->ieee80211);
5989 }
5990
5991 void EnableHWSecurityConfig8192(struct net_device *dev)
5992 {
5993 u8 SECR_value = 0x0;
5994 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5995 struct ieee80211_device* ieee = priv->ieee80211;
5996 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
5997 if (((KEY_TYPE_WEP40 == ieee->pairwise_key_type) || (KEY_TYPE_WEP104 == ieee->pairwise_key_type)) && (priv->ieee80211->auth_mode != 2))
5998 {
5999 SECR_value |= SCR_RxUseDK;
6000 SECR_value |= SCR_TxUseDK;
6001 }
6002 else if ((ieee->iw_mode == IW_MODE_ADHOC) && (ieee->pairwise_key_type & (KEY_TYPE_CCMP | KEY_TYPE_TKIP)))
6003 {
6004 SECR_value |= SCR_RxUseDK;
6005 SECR_value |= SCR_TxUseDK;
6006 }
6007 //add HWSec active enable here.
6008 //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
6009
6010 ieee->hwsec_active = 1;
6011
6012 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
6013 {
6014 ieee->hwsec_active = 0;
6015 SECR_value &= ~SCR_RxDecEnable;
6016 }
6017 RT_TRACE(COMP_SEC,"%s:, hwsec:%d, pairwise_key:%d, SECR_value:%x\n", __FUNCTION__, \
6018 ieee->hwsec_active, ieee->pairwise_key_type, SECR_value);
6019 {
6020 write_nic_byte(dev, SECR, SECR_value);//SECR_value | SCR_UseDK );
6021 }
6022 }
6023
6024
6025 void setKey( struct net_device *dev,
6026 u8 EntryNo,
6027 u8 KeyIndex,
6028 u16 KeyType,
6029 u8 *MacAddr,
6030 u8 DefaultKey,
6031 u32 *KeyContent )
6032 {
6033 u32 TargetCommand = 0;
6034 u32 TargetContent = 0;
6035 u16 usConfig = 0;
6036 u8 i;
6037 if (EntryNo >= TOTAL_CAM_ENTRY)
6038 RT_TRACE(COMP_ERR, "cam entry exceeds in setKey()\n");
6039
6040 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));
6041
6042 if (DefaultKey)
6043 usConfig |= BIT15 | (KeyType<<2);
6044 else
6045 usConfig |= BIT15 | (KeyType<<2) | KeyIndex;
6046 // usConfig |= BIT15 | (KeyType<<2) | (DefaultKey<<5) | KeyIndex;
6047
6048
6049 for(i=0 ; i<CAM_CONTENT_COUNT; i++){
6050 TargetCommand = i+CAM_CONTENT_COUNT*EntryNo;
6051 TargetCommand |= BIT31|BIT16;
6052
6053 if(i==0){//MAC|Config
6054 TargetContent = (u32)(*(MacAddr+0)) << 16|
6055 (u32)(*(MacAddr+1)) << 24|
6056 (u32)usConfig;
6057
6058 write_nic_dword(dev, WCAMI, TargetContent);
6059 write_nic_dword(dev, RWCAM, TargetCommand);
6060 // printk("setkey cam =%8x\n", read_cam(dev, i+6*EntryNo));
6061 }
6062 else if(i==1){//MAC
6063 TargetContent = (u32)(*(MacAddr+2)) |
6064 (u32)(*(MacAddr+3)) << 8|
6065 (u32)(*(MacAddr+4)) << 16|
6066 (u32)(*(MacAddr+5)) << 24;
6067 write_nic_dword(dev, WCAMI, TargetContent);
6068 write_nic_dword(dev, RWCAM, TargetCommand);
6069 }
6070 else {
6071 //Key Material
6072 if(KeyContent !=NULL){
6073 write_nic_dword(dev, WCAMI, (u32)(*(KeyContent+i-2)) );
6074 write_nic_dword(dev, RWCAM, TargetCommand);
6075 }
6076 }
6077 }
6078
6079 }
6080
6081 /***************************************************************************
6082 ------------------- module init / exit stubs ----------------
6083 ****************************************************************************/
6084 module_init(rtl8192_usb_module_init);
6085 module_exit(rtl8192_usb_module_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree