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