?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: rtl8192s_usb: Remove duplicate device ID
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / rtl8192su / r8192U_core.c
blob1b6890611fb6dc822156e6ffbee719fb156712c3
1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 * Linux device driver for RTL8192U
4 *
5 * Based on the r8187 driver, which is:
6 * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 *
20 * The full GNU General Public License is included in this distribution in the
21 * file called LICENSE.
22 *
23 * Contact Information:
24 * Jerry chuang <wlanfae@realtek.com>
25 */
26
27 #include <linux/vmalloc.h>
28 #include <linux/slab.h>
29 #include <linux/eeprom_93cx6.h>
30
31 #undef LOOP_TEST
32 #undef DUMP_RX
33 #undef DUMP_TX
34 #undef DEBUG_TX_DESC2
35 #undef RX_DONT_PASS_UL
36 #undef DEBUG_EPROM
37 #undef DEBUG_RX_VERBOSE
38 #undef DUMMY_RX
39 #undef DEBUG_ZERO_RX
40 #undef DEBUG_RX_SKB
41 #undef DEBUG_TX_FRAG
42 #undef DEBUG_RX_FRAG
43 #undef DEBUG_TX_FILLDESC
44 #undef DEBUG_TX
45 #undef DEBUG_IRQ
46 #undef DEBUG_RX
47 #undef DEBUG_RXALLOC
48 #undef DEBUG_REGISTERS
49 #undef DEBUG_RING
50 #undef DEBUG_IRQ_TASKLET
51 #undef DEBUG_TX_ALLOC
52 #undef DEBUG_TX_DESC
53
54 #define CONFIG_RTL8192_IO_MAP
55
56 #include <asm/uaccess.h>
57 #include "r8192U.h"
58 #include "r8192U_wx.h"
59
60 #include "r8192S_rtl8225.h"
61 #include "r8192S_hw.h"
62 #include "r8192S_phy.h"
63 #include "r8192S_phyreg.h"
64 #include "r8192S_Efuse.h"
65
66 #include "r819xU_cmdpkt.h"
67 #include "r8192U_dm.h"
68 //#include "r8192xU_phyreg.h"
69 #include <linux/usb.h>
70
71 #include "r8192U_pm.h"
72
73 #include "ieee80211/dot11d.h"
74
75
76
77 u32 rt_global_debug_component = \
78 // COMP_TRACE |
79 // COMP_DBG |
80 // COMP_INIT |
81 // COMP_RECV |
82 // COMP_SEND |
83 // COMP_IO |
84 COMP_POWER |
85 // COMP_EPROM |
86 COMP_SWBW |
87 COMP_POWER_TRACKING |
88 COMP_TURBO |
89 COMP_QOS |
90 // COMP_RATE |
91 // COMP_RM |
92 COMP_DIG |
93 // COMP_EFUSE |
94 // COMP_CH |
95 // COMP_TXAGC |
96 COMP_HIPWR |
97 // COMP_HALDM |
98 COMP_SEC |
99 COMP_LED |
100 // COMP_RF |
101 // COMP_RXDESC |
102 COMP_FIRMWARE |
103 COMP_HT |
104 COMP_AMSDU |
105 COMP_SCAN |
106 // COMP_CMD |
107 COMP_DOWN |
108 COMP_RESET |
109 COMP_ERR; //always open err flags on
110
111 #define TOTAL_CAM_ENTRY 32
112 #define CAM_CONTENT_COUNT 8
113
114 static const struct usb_device_id rtl8192_usb_id_tbl[] = {
115 {USB_DEVICE(0x0bda, 0x8171)}, /* Realtek */
116 {USB_DEVICE(0x0bda, 0x8172)},
117 {USB_DEVICE(0x0bda, 0x8173)},
118 {USB_DEVICE(0x0bda, 0x8174)},
119 {USB_DEVICE(0x0bda, 0x8712)},
120 {USB_DEVICE(0x0bda, 0x8713)},
121 {USB_DEVICE(0x07aa, 0x0047)},
122 {USB_DEVICE(0x07d1, 0x3303)},
123 {USB_DEVICE(0x07d1, 0x3302)},
124 {USB_DEVICE(0x07d1, 0x3300)},
125 {USB_DEVICE(0x1740, 0x9603)},
126 {USB_DEVICE(0x1740, 0x9605)},
127 {USB_DEVICE(0x050d, 0x815F)},
128 {USB_DEVICE(0x06f8, 0xe031)},
129 {USB_DEVICE(0x7392, 0x7611)},
130 {USB_DEVICE(0x7392, 0x7612)},
131 {USB_DEVICE(0x7392, 0x7622)},
132 {USB_DEVICE(0x0DF6, 0x0045)},
133 {USB_DEVICE(0x0E66, 0x0015)},
134 {USB_DEVICE(0x0E66, 0x0016)},
135 {USB_DEVICE(0x0b05, 0x1786)},
136 /* these are not in the official list */
137 {USB_DEVICE(0x0df6, 0x004b)}, /* WL-349 */
138 {}
139 };
140
141 MODULE_LICENSE("GPL");
142 MODULE_VERSION("V 1.1");
143 MODULE_DEVICE_TABLE(usb, rtl8192_usb_id_tbl);
144 MODULE_DESCRIPTION("Linux driver for Realtek RTL8192 USB WiFi cards");
145
146 static char* ifname = "wlan%d";
147 static int hwwep = 1; //default use hw. set 0 to use software security
148 static int channels = 0x3fff;
149
150
151
152 module_param(ifname, charp, S_IRUGO|S_IWUSR );
153 //module_param(hwseqnum,int, S_IRUGO|S_IWUSR);
154 module_param(hwwep,int, S_IRUGO|S_IWUSR);
155 module_param(channels,int, S_IRUGO|S_IWUSR);
156
157 MODULE_PARM_DESC(ifname," Net interface name, wlan%d=default");
158 //MODULE_PARM_DESC(hwseqnum," Try to use hardware 802.11 header sequence numbers. Zero=default");
159 MODULE_PARM_DESC(hwwep," Try to use hardware security support. ");
160 MODULE_PARM_DESC(channels," Channel bitmask for specific locales. NYI");
161
162 static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
163 const struct usb_device_id *id);
164 static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf);
165
166 static struct usb_driver rtl8192_usb_driver = {
167 .name = RTL819xU_MODULE_NAME, /* Driver name */
168 .id_table = rtl8192_usb_id_tbl, /* PCI_ID table */
169 .probe = rtl8192_usb_probe, /* probe fn */
170 .disconnect = rtl8192_usb_disconnect, /* remove fn */
171 .suspend = rtl8192U_suspend, /* PM suspend fn */
172 .resume = rtl8192U_resume, /* PM resume fn */
173 .reset_resume = rtl8192U_resume, /* PM reset resume fn */
174 };
175
176
177 static void rtl8192SU_read_eeprom_info(struct net_device *dev);
178 short rtl8192SU_tx(struct net_device *dev, struct sk_buff* skb);
179 void rtl8192SU_rx_nomal(struct sk_buff* skb);
180 void rtl8192SU_rx_cmd(struct sk_buff *skb);
181 bool rtl8192SU_adapter_start(struct net_device *dev);
182 short rtl8192SU_tx_cmd(struct net_device *dev, struct sk_buff *skb);
183 void rtl8192SU_link_change(struct net_device *dev);
184 void InitialGain8192S(struct net_device *dev,u8 Operation);
185 void rtl8192SU_query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe);
186
187 struct rtl819x_ops rtl8192su_ops = {
188 .nic_type = NIC_8192SU,
189 .rtl819x_read_eeprom_info = rtl8192SU_read_eeprom_info,
190 .rtl819x_tx = rtl8192SU_tx,
191 .rtl819x_tx_cmd = rtl8192SU_tx_cmd,
192 .rtl819x_rx_nomal = rtl8192SU_rx_nomal,
193 .rtl819x_rx_cmd = rtl8192SU_rx_cmd,
194 .rtl819x_adapter_start = rtl8192SU_adapter_start,
195 .rtl819x_link_change = rtl8192SU_link_change,
196 .rtl819x_initial_gain = InitialGain8192S,
197 .rtl819x_query_rxdesc_status = rtl8192SU_query_rxdesc_status,
198 };
199
200
201 typedef struct _CHANNEL_LIST
202 {
203 u8 Channel[32];
204 u8 Len;
205 }CHANNEL_LIST, *PCHANNEL_LIST;
206
207 static CHANNEL_LIST ChannelPlan[] = {
208 {{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
209 {{1,2,3,4,5,6,7,8,9,10,11},11}, //IC
210 {{1,2,3,4,5,6,7,8,9,10,11,12,13,36,40,44,48,52,56,60,64},21}, //ETSI
211 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Spain. Change to ETSI.
212 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //France. Change to ETSI.
213 {{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
214 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64},22},//MKK1
215 {{1,2,3,4,5,6,7,8,9,10,11,12,13},13}, //Israel.
216 {{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
217 {{1,2,3,4,5,6,7,8,9,10,11,12,13,14,36,40,44,48,52,56,60,64}, 22}, //MIC
218 {{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
219 };
220
221 static void rtl819x_eeprom_register_read(struct eeprom_93cx6 *eeprom)
222 {
223 struct net_device *dev = eeprom->data;
224 u8 reg = read_nic_byte(dev, EPROM_CMD);
225
226 eeprom->reg_data_in = reg & RTL819X_EEPROM_CMD_WRITE;
227 eeprom->reg_data_out = reg & RTL819X_EEPROM_CMD_READ;
228 eeprom->reg_data_clock = reg & RTL819X_EEPROM_CMD_CK;
229 eeprom->reg_chip_select = reg & RTL819X_EEPROM_CMD_CS;
230 }
231
232 static void rtl819x_eeprom_register_write(struct eeprom_93cx6 *eeprom)
233 {
234 struct net_device *dev = eeprom->data;
235 u8 reg = 2 << 6;
236
237 if (eeprom->reg_data_in)
238 reg |= RTL819X_EEPROM_CMD_WRITE;
239 if (eeprom->reg_data_out)
240 reg |= RTL819X_EEPROM_CMD_READ;
241 if (eeprom->reg_data_clock)
242 reg |= RTL819X_EEPROM_CMD_CK;
243 if (eeprom->reg_chip_select)
244 reg |= RTL819X_EEPROM_CMD_CS;
245
246 write_nic_byte(dev, EPROM_CMD, reg);
247 read_nic_byte(dev, EPROM_CMD);
248 udelay(10);
249 }
250
251 static void rtl819x_set_channel_map(u8 channel_plan, struct r8192_priv* priv)
252 {
253 int i, max_chan=-1, min_chan=-1;
254 struct ieee80211_device* ieee = priv->ieee80211;
255 switch (channel_plan)
256 {
257 case COUNTRY_CODE_FCC:
258 case COUNTRY_CODE_IC:
259 case COUNTRY_CODE_ETSI:
260 case COUNTRY_CODE_SPAIN:
261 case COUNTRY_CODE_FRANCE:
262 case COUNTRY_CODE_MKK:
263 case COUNTRY_CODE_MKK1:
264 case COUNTRY_CODE_ISRAEL:
265 case COUNTRY_CODE_TELEC:
266 case COUNTRY_CODE_MIC:
267 {
268 Dot11d_Init(ieee);
269 ieee->bGlobalDomain = false;
270 //acturally 8225 & 8256 rf chip only support B,G,24N mode
271 if ((priv->rf_chip == RF_8225) || (priv->rf_chip == RF_8256) || (priv->rf_chip == RF_6052))
272 {
273 min_chan = 1;
274 max_chan = 14;
275 }
276 else
277 {
278 RT_TRACE(COMP_ERR, "unknown rf chip, can't set channel map in function:%s()\n", __FUNCTION__);
279 }
280 if (ChannelPlan[channel_plan].Len != 0){
281 // Clear old channel map
282 memset(GET_DOT11D_INFO(ieee)->channel_map, 0, sizeof(GET_DOT11D_INFO(ieee)->channel_map));
283 // Set new channel map
284 for (i=0;i<ChannelPlan[channel_plan].Len;i++)
285 {
286 if (ChannelPlan[channel_plan].Channel[i] < min_chan || ChannelPlan[channel_plan].Channel[i] > max_chan)
287 break;
288 GET_DOT11D_INFO(ieee)->channel_map[ChannelPlan[channel_plan].Channel[i]] = 1;
289 }
290 }
291 break;
292 }
293 case COUNTRY_CODE_GLOBAL_DOMAIN:
294 {
295 GET_DOT11D_INFO(ieee)->bEnabled = 0;//this flag enabled to follow 11d country IE setting, otherwise, it shall follow global domain settings.
296 Dot11d_Reset(ieee);
297 ieee->bGlobalDomain = true;
298 break;
299 }
300 default:
301 break;
302 }
303 return;
304 }
305
306 #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 )
307
308 #define rx_hal_is_cck_rate(_pDesc)\
309 ((_pDesc->RxMCS == DESC92S_RATE1M ||\
310 _pDesc->RxMCS == DESC92S_RATE2M ||\
311 _pDesc->RxMCS == DESC92S_RATE5_5M ||\
312 _pDesc->RxMCS == DESC92S_RATE11M) &&\
313 !_pDesc->RxHT)
314
315 #define tx_hal_is_cck_rate(_DataRate)\
316 ( _DataRate == MGN_1M ||\
317 _DataRate == MGN_2M ||\
318 _DataRate == MGN_5_5M ||\
319 _DataRate == MGN_11M )
320
321
322
323
324 void CamResetAllEntry(struct net_device *dev)
325 {
326 #if 1
327 u32 ulcommand = 0;
328 //2004/02/11 In static WEP, OID_ADD_KEY or OID_ADD_WEP are set before STA associate to AP.
329 // However, ResetKey is called on OID_802_11_INFRASTRUCTURE_MODE and MlmeAssociateRequest
330 // In this condition, Cam can not be reset because upper layer will not set this static key again.
331 //if(Adapter->EncAlgorithm == WEP_Encryption)
332 // return;
333 //debug
334 //DbgPrint("========================================\n");
335 //DbgPrint(" Call ResetAllEntry \n");
336 //DbgPrint("========================================\n\n");
337 ulcommand |= BIT31|BIT30;
338 write_nic_dword(dev, RWCAM, ulcommand);
339 #else
340 for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
341 CAM_mark_invalid(dev, ucIndex);
342 for(ucIndex=0;ucIndex<TOTAL_CAM_ENTRY;ucIndex++)
343 CAM_empty_entry(dev, ucIndex);
344 #endif
345
346 }
347
348
349 void write_cam(struct net_device *dev, u8 addr, u32 data)
350 {
351 write_nic_dword(dev, WCAMI, data);
352 write_nic_dword(dev, RWCAM, BIT31|BIT16|(addr&0xff) );
353 }
354
355 u32 read_cam(struct net_device *dev, u8 addr)
356 {
357 write_nic_dword(dev, RWCAM, 0x80000000|(addr&0xff) );
358 return read_nic_dword(dev, 0xa8);
359 }
360
361 void write_nic_byte_E(struct net_device *dev, int indx, u8 data)
362 {
363 int status;
364 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
365 struct usb_device *udev = priv->udev;
366
367 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
368 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
369 indx|0xfe00, 0, &data, 1, HZ / 2);
370
371 if (status < 0)
372 {
373 printk("write_nic_byte_E TimeOut! status:%d\n", status);
374 }
375 }
376
377 u8 read_nic_byte_E(struct net_device *dev, int indx)
378 {
379 int status;
380 u8 data;
381 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
382 struct usb_device *udev = priv->udev;
383
384 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
385 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
386 indx|0xfe00, 0, &data, 1, HZ / 2);
387
388 if (status < 0)
389 {
390 printk("read_nic_byte_E TimeOut! status:%d\n", status);
391 }
392
393 return data;
394 }
395 //as 92U has extend page from 4 to 16, so modify functions below.
396 void write_nic_byte(struct net_device *dev, int indx, u8 data)
397 {
398 int status;
399
400 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
401 struct usb_device *udev = priv->udev;
402
403 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
404 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
405 indx, 0, &data, 1, HZ / 2);
406
407 if (status < 0)
408 {
409 printk("write_nic_byte TimeOut! status:%d\n", status);
410 }
411
412
413 }
414
415
416 void write_nic_word(struct net_device *dev, int indx, u16 data)
417 {
418
419 int status;
420
421 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
422 struct usb_device *udev = priv->udev;
423
424 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
425 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
426 indx, 0, &data, 2, HZ / 2);
427
428 if (status < 0)
429 {
430 printk("write_nic_word TimeOut! status:%d\n", status);
431 }
432
433 }
434
435
436 void write_nic_dword(struct net_device *dev, int indx, u32 data)
437 {
438
439 int status;
440
441 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
442 struct usb_device *udev = priv->udev;
443
444 status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
445 RTL8187_REQ_SET_REGS, RTL8187_REQT_WRITE,
446 indx, 0, &data, 4, HZ / 2);
447
448
449 if (status < 0)
450 {
451 printk("write_nic_dword TimeOut! status:%d\n", status);
452 }
453
454 }
455
456
457
458 u8 read_nic_byte(struct net_device *dev, int indx)
459 {
460 u8 data;
461 int status;
462 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
463 struct usb_device *udev = priv->udev;
464
465 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
466 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
467 indx, 0, &data, 1, HZ / 2);
468
469 if (status < 0)
470 {
471 printk("read_nic_byte TimeOut! status:%d\n", status);
472 }
473
474 return data;
475 }
476
477
478
479 u16 read_nic_word(struct net_device *dev, int indx)
480 {
481 u16 data;
482 int status;
483 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
484 struct usb_device *udev = priv->udev;
485
486 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
487 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
488 indx, 0, &data, 2, HZ / 2);
489
490 if (status < 0)
491 {
492 printk("read_nic_word TimeOut! status:%d\n", status);
493 }
494
495
496 return data;
497 }
498
499 u16 read_nic_word_E(struct net_device *dev, int indx)
500 {
501 u16 data;
502 int status;
503 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
504 struct usb_device *udev = priv->udev;
505
506 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
507 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
508 indx|0xfe00, 0, &data, 2, HZ / 2);
509
510 if (status < 0)
511 {
512 printk("read_nic_word TimeOut! status:%d\n", status);
513 }
514
515
516 return data;
517 }
518
519 u32 read_nic_dword(struct net_device *dev, int indx)
520 {
521 u32 data;
522 int status;
523 // int result;
524
525 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
526 struct usb_device *udev = priv->udev;
527
528 status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
529 RTL8187_REQ_GET_REGS, RTL8187_REQT_READ,
530 indx, 0, &data, 4, HZ / 2);
531 // if(0 != result) {
532 // printk(KERN_WARNING "read size of data = %d\, date = %d\n", result, data);
533 // }
534
535 if (status < 0)
536 {
537 printk("read_nic_dword TimeOut! status:%d\n", status);
538 if(status == -ENODEV) {
539 priv->usb_error = true;
540 }
541 }
542
543
544
545 return data;
546 }
547
548
549 //u8 read_phy_cck(struct net_device *dev, u8 adr);
550 //u8 read_phy_ofdm(struct net_device *dev, u8 adr);
551 /* this might still called in what was the PHY rtl8185/rtl8192 common code
552 * plans are to possibilty turn it again in one common code...
553 */
554 inline void force_pci_posting(struct net_device *dev)
555 {
556 }
557
558
559 static struct net_device_stats *rtl8192_stats(struct net_device *dev);
560 void rtl8192_commit(struct net_device *dev);
561 //void rtl8192_restart(struct net_device *dev);
562 void rtl8192_restart(struct work_struct *work);
563 //void rtl8192_rq_tx_ack(struct work_struct *work);
564
565 void watch_dog_timer_callback(unsigned long data);
566
567 /****************************************************************************
568 -----------------------------PROCFS STUFF-------------------------
569 *****************************************************************************/
570
571 static struct proc_dir_entry *rtl8192_proc = NULL;
572
573
574
575 static int proc_get_stats_ap(char *page, char **start,
576 off_t offset, int count,
577 int *eof, void *data)
578 {
579 struct net_device *dev = data;
580 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
581 struct ieee80211_device *ieee = priv->ieee80211;
582 struct ieee80211_network *target;
583
584 int len = 0;
585
586 list_for_each_entry(target, &ieee->network_list, list) {
587
588 len += snprintf(page + len, count - len,
589 "%s ", target->ssid);
590
591 if(target->wpa_ie_len>0 || target->rsn_ie_len>0){
592 len += snprintf(page + len, count - len,
593 "WPA\n");
594 }
595 else{
596 len += snprintf(page + len, count - len,
597 "non_WPA\n");
598 }
599
600 }
601
602 *eof = 1;
603 return len;
604 }
605
606 static int proc_get_registers(char *page, char **start,
607 off_t offset, int count,
608 int *eof, void *data)
609 {
610 struct net_device *dev = data;
611 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
612
613 int len = 0;
614 int i,n,page0,page1,page2;
615
616 int max=0xff;
617 page0 = 0x000;
618 page1 = 0x100;
619 page2 = 0x800;
620
621 /* This dump the current register page */
622 if(!IS_BB_REG_OFFSET_92S(page0)){
623 len += snprintf(page + len, count - len,
624 "\n####################page %x##################\n ", (page0>>8));
625 for(n=0;n<=max;)
626 {
627 len += snprintf(page + len, count - len,
628 "\nD: %2x > ",n);
629 for(i=0;i<16 && n<=max;i++,n++)
630 len += snprintf(page + len, count - len,
631 "%2.2x ",read_nic_byte(dev,(page0|n)));
632 }
633 }else{
634 len += snprintf(page + len, count - len,
635 "\n####################page %x##################\n ", (page0>>8));
636 for(n=0;n<=max;)
637 {
638 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
639 for(i=0;i<4 && n<=max;n+=4,i++)
640 len += snprintf(page + len, count - len,
641 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
642 }
643 }
644 len += snprintf(page + len, count - len,"\n");
645 *eof = 1;
646 return len;
647
648 }
649 static int proc_get_registers_1(char *page, char **start,
650 off_t offset, int count,
651 int *eof, void *data)
652 {
653 struct net_device *dev = data;
654 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
655
656 int len = 0;
657 int i,n,page0;
658
659 int max=0xff;
660 page0 = 0x100;
661
662 /* This dump the current register page */
663 len += snprintf(page + len, count - len,
664 "\n####################page %x##################\n ", (page0>>8));
665 for(n=0;n<=max;)
666 {
667 len += snprintf(page + len, count - len,
668 "\nD: %2x > ",n);
669 for(i=0;i<16 && n<=max;i++,n++)
670 len += snprintf(page + len, count - len,
671 "%2.2x ",read_nic_byte(dev,(page0|n)));
672 }
673 len += snprintf(page + len, count - len,"\n");
674 *eof = 1;
675 return len;
676
677 }
678 static int proc_get_registers_2(char *page, char **start,
679 off_t offset, int count,
680 int *eof, void *data)
681 {
682 struct net_device *dev = data;
683 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
684
685 int len = 0;
686 int i,n,page0;
687
688 int max=0xff;
689 page0 = 0x200;
690
691 /* This dump the current register page */
692 len += snprintf(page + len, count - len,
693 "\n####################page %x##################\n ", (page0>>8));
694 for(n=0;n<=max;)
695 {
696 len += snprintf(page + len, count - len,
697 "\nD: %2x > ",n);
698 for(i=0;i<16 && n<=max;i++,n++)
699 len += snprintf(page + len, count - len,
700 "%2.2x ",read_nic_byte(dev,(page0|n)));
701 }
702 len += snprintf(page + len, count - len,"\n");
703 *eof = 1;
704 return len;
705
706 }
707 static int proc_get_registers_8(char *page, char **start,
708 off_t offset, int count,
709 int *eof, void *data)
710 {
711 struct net_device *dev = data;
712
713 int len = 0;
714 int i,n,page0;
715
716 int max=0xff;
717 page0 = 0x800;
718
719 /* This dump the current register page */
720 len += snprintf(page + len, count - len,
721 "\n####################page %x##################\n ", (page0>>8));
722 for(n=0;n<=max;)
723 {
724 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
725 for(i=0;i<4 && n<=max;n+=4,i++)
726 len += snprintf(page + len, count - len,
727 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
728 }
729 len += snprintf(page + len, count - len,"\n");
730 *eof = 1;
731 return len;
732
733 }
734 static int proc_get_registers_9(char *page, char **start,
735 off_t offset, int count,
736 int *eof, void *data)
737 {
738 struct net_device *dev = data;
739 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
740
741 int len = 0;
742 int i,n,page0;
743
744 int max=0xff;
745 page0 = 0x900;
746
747 /* This dump the current register page */
748 len += snprintf(page + len, count - len,
749 "\n####################page %x##################\n ", (page0>>8));
750 for(n=0;n<=max;)
751 {
752 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
753 for(i=0;i<4 && n<=max;n+=4,i++)
754 len += snprintf(page + len, count - len,
755 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
756 }
757 len += snprintf(page + len, count - len,"\n");
758 *eof = 1;
759 return len;
760 }
761 static int proc_get_registers_a(char *page, char **start,
762 off_t offset, int count,
763 int *eof, void *data)
764 {
765 struct net_device *dev = data;
766 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
767
768 int len = 0;
769 int i,n,page0;
770
771 int max=0xff;
772 page0 = 0xa00;
773
774 /* This dump the current register page */
775 len += snprintf(page + len, count - len,
776 "\n####################page %x##################\n ", (page0>>8));
777 for(n=0;n<=max;)
778 {
779 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
780 for(i=0;i<4 && n<=max;n+=4,i++)
781 len += snprintf(page + len, count - len,
782 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
783 }
784 len += snprintf(page + len, count - len,"\n");
785 *eof = 1;
786 return len;
787 }
788 static int proc_get_registers_b(char *page, char **start,
789 off_t offset, int count,
790 int *eof, void *data)
791 {
792 struct net_device *dev = data;
793 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
794
795 int len = 0;
796 int i,n,page0;
797
798 int max=0xff;
799 page0 = 0xb00;
800
801 /* This dump the current register page */
802 len += snprintf(page + len, count - len,
803 "\n####################page %x##################\n ", (page0>>8));
804 for(n=0;n<=max;)
805 {
806 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
807 for(i=0;i<4 && n<=max;n+=4,i++)
808 len += snprintf(page + len, count - len,
809 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
810 }
811 len += snprintf(page + len, count - len,"\n");
812 *eof = 1;
813 return len;
814 }
815 static int proc_get_registers_c(char *page, char **start,
816 off_t offset, int count,
817 int *eof, void *data)
818 {
819 struct net_device *dev = data;
820 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
821
822 int len = 0;
823 int i,n,page0;
824
825 int max=0xff;
826 page0 = 0xc00;
827
828 /* This dump the current register page */
829 len += snprintf(page + len, count - len,
830 "\n####################page %x##################\n ", (page0>>8));
831 for(n=0;n<=max;)
832 {
833 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
834 for(i=0;i<4 && n<=max;n+=4,i++)
835 len += snprintf(page + len, count - len,
836 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
837 }
838 len += snprintf(page + len, count - len,"\n");
839 *eof = 1;
840 return len;
841 }
842 static int proc_get_registers_d(char *page, char **start,
843 off_t offset, int count,
844 int *eof, void *data)
845 {
846 struct net_device *dev = data;
847 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
848
849 int len = 0;
850 int i,n,page0;
851
852 int max=0xff;
853 page0 = 0xd00;
854
855 /* This dump the current register page */
856 len += snprintf(page + len, count - len,
857 "\n####################page %x##################\n ", (page0>>8));
858 for(n=0;n<=max;)
859 {
860 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
861 for(i=0;i<4 && n<=max;n+=4,i++)
862 len += snprintf(page + len, count - len,
863 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
864 }
865 len += snprintf(page + len, count - len,"\n");
866 *eof = 1;
867 return len;
868 }
869 static int proc_get_registers_e(char *page, char **start,
870 off_t offset, int count,
871 int *eof, void *data)
872 {
873 struct net_device *dev = data;
874 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
875
876 int len = 0;
877 int i,n,page0;
878
879 int max=0xff;
880 page0 = 0xe00;
881
882 /* This dump the current register page */
883 len += snprintf(page + len, count - len,
884 "\n####################page %x##################\n ", (page0>>8));
885 for(n=0;n<=max;)
886 {
887 len += snprintf(page + len, count - len, "\nD: %2x > ",n);
888 for(i=0;i<4 && n<=max;n+=4,i++)
889 len += snprintf(page + len, count - len,
890 "%8.8x ",rtl8192_QueryBBReg(dev,(page0|n), bMaskDWord));
891 }
892 len += snprintf(page + len, count - len,"\n");
893 *eof = 1;
894 return len;
895 }
896
897 static int proc_get_stats_tx(char *page, char **start,
898 off_t offset, int count,
899 int *eof, void *data)
900 {
901 struct net_device *dev = data;
902 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
903
904 int len = 0;
905
906 len += snprintf(page + len, count - len,
907 "TX VI priority ok int: %lu\n"
908 "TX VI priority error int: %lu\n"
909 "TX VO priority ok int: %lu\n"
910 "TX VO priority error int: %lu\n"
911 "TX BE priority ok int: %lu\n"
912 "TX BE priority error int: %lu\n"
913 "TX BK priority ok int: %lu\n"
914 "TX BK priority error int: %lu\n"
915 "TX MANAGE priority ok int: %lu\n"
916 "TX MANAGE priority error int: %lu\n"
917 "TX BEACON priority ok int: %lu\n"
918 "TX BEACON priority error int: %lu\n"
919 // "TX high priority ok int: %lu\n"
920 // "TX high priority failed error int: %lu\n"
921 "TX queue resume: %lu\n"
922 "TX queue stopped?: %d\n"
923 "TX fifo overflow: %lu\n"
924 // "TX beacon: %lu\n"
925 "TX VI queue: %d\n"
926 "TX VO queue: %d\n"
927 "TX BE queue: %d\n"
928 "TX BK queue: %d\n"
929 // "TX HW queue: %d\n"
930 "TX VI dropped: %lu\n"
931 "TX VO dropped: %lu\n"
932 "TX BE dropped: %lu\n"
933 "TX BK dropped: %lu\n"
934 "TX total data packets %lu\n",
935 // "TX beacon aborted: %lu\n",
936 priv->stats.txviokint,
937 priv->stats.txvierr,
938 priv->stats.txvookint,
939 priv->stats.txvoerr,
940 priv->stats.txbeokint,
941 priv->stats.txbeerr,
942 priv->stats.txbkokint,
943 priv->stats.txbkerr,
944 priv->stats.txmanageokint,
945 priv->stats.txmanageerr,
946 priv->stats.txbeaconokint,
947 priv->stats.txbeaconerr,
948 // priv->stats.txhpokint,
949 // priv->stats.txhperr,
950 priv->stats.txresumed,
951 netif_queue_stopped(dev),
952 priv->stats.txoverflow,
953 // priv->stats.txbeacon,
954 atomic_read(&(priv->tx_pending[VI_PRIORITY])),
955 atomic_read(&(priv->tx_pending[VO_PRIORITY])),
956 atomic_read(&(priv->tx_pending[BE_PRIORITY])),
957 atomic_read(&(priv->tx_pending[BK_PRIORITY])),
958 // read_nic_byte(dev, TXFIFOCOUNT),
959 priv->stats.txvidrop,
960 priv->stats.txvodrop,
961 priv->stats.txbedrop,
962 priv->stats.txbkdrop,
963 priv->stats.txdatapkt
964 // priv->stats.txbeaconerr
965 );
966
967 *eof = 1;
968 return len;
969 }
970
971
972
973 static int proc_get_stats_rx(char *page, char **start,
974 off_t offset, int count,
975 int *eof, void *data)
976 {
977 struct net_device *dev = data;
978 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
979
980 int len = 0;
981
982 len += snprintf(page + len, count - len,
983 "RX packets: %lu\n"
984 "RX urb status error: %lu\n"
985 "RX invalid urb error: %lu\n",
986 priv->stats.rxoktotal,
987 priv->stats.rxstaterr,
988 priv->stats.rxurberr);
989
990 *eof = 1;
991 return len;
992 }
993
994 void rtl8192_proc_module_init(void)
995 {
996 RT_TRACE(COMP_INIT, "Initializing proc filesystem");
997 rtl8192_proc=create_proc_entry(RTL819xU_MODULE_NAME, S_IFDIR, init_net.proc_net);
998 }
999
1000
1001 void rtl8192_proc_module_remove(void)
1002 {
1003 remove_proc_entry(RTL819xU_MODULE_NAME, init_net.proc_net);
1004 }
1005
1006
1007 void rtl8192_proc_remove_one(struct net_device *dev)
1008 {
1009 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1010
1011
1012 if (priv->dir_dev) {
1013 // remove_proc_entry("stats-hw", priv->dir_dev);
1014 remove_proc_entry("stats-tx", priv->dir_dev);
1015 remove_proc_entry("stats-rx", priv->dir_dev);
1016 // remove_proc_entry("stats-ieee", priv->dir_dev);
1017 remove_proc_entry("stats-ap", priv->dir_dev);
1018 remove_proc_entry("registers", priv->dir_dev);
1019 remove_proc_entry("registers-1", priv->dir_dev);
1020 remove_proc_entry("registers-2", priv->dir_dev);
1021 remove_proc_entry("registers-8", priv->dir_dev);
1022 remove_proc_entry("registers-9", priv->dir_dev);
1023 remove_proc_entry("registers-a", priv->dir_dev);
1024 remove_proc_entry("registers-b", priv->dir_dev);
1025 remove_proc_entry("registers-c", priv->dir_dev);
1026 remove_proc_entry("registers-d", priv->dir_dev);
1027 remove_proc_entry("registers-e", priv->dir_dev);
1028 // remove_proc_entry("cck-registers",priv->dir_dev);
1029 // remove_proc_entry("ofdm-registers",priv->dir_dev);
1030 //remove_proc_entry(dev->name, rtl8192_proc);
1031 remove_proc_entry("wlan0", rtl8192_proc);
1032 priv->dir_dev = NULL;
1033 }
1034 }
1035
1036
1037 void rtl8192_proc_init_one(struct net_device *dev)
1038 {
1039 struct proc_dir_entry *e;
1040 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1041 priv->dir_dev = create_proc_entry(dev->name,
1042 S_IFDIR | S_IRUGO | S_IXUGO,
1043 rtl8192_proc);
1044 if (!priv->dir_dev) {
1045 RT_TRACE(COMP_ERR, "Unable to initialize /proc/net/rtl8192/%s\n",
1046 dev->name);
1047 return;
1048 }
1049 e = create_proc_read_entry("stats-rx", S_IFREG | S_IRUGO,
1050 priv->dir_dev, proc_get_stats_rx, dev);
1051
1052 if (!e) {
1053 RT_TRACE(COMP_ERR,"Unable to initialize "
1054 "/proc/net/rtl8192/%s/stats-rx\n",
1055 dev->name);
1056 }
1057
1058
1059 e = create_proc_read_entry("stats-tx", S_IFREG | S_IRUGO,
1060 priv->dir_dev, proc_get_stats_tx, dev);
1061
1062 if (!e) {
1063 RT_TRACE(COMP_ERR, "Unable to initialize "
1064 "/proc/net/rtl8192/%s/stats-tx\n",
1065 dev->name);
1066 }
1067
1068 e = create_proc_read_entry("stats-ap", S_IFREG | S_IRUGO,
1069 priv->dir_dev, proc_get_stats_ap, dev);
1070
1071 if (!e) {
1072 RT_TRACE(COMP_ERR, "Unable to initialize "
1073 "/proc/net/rtl8192/%s/stats-ap\n",
1074 dev->name);
1075 }
1076
1077 e = create_proc_read_entry("registers", S_IFREG | S_IRUGO,
1078 priv->dir_dev, proc_get_registers, dev);
1079 if (!e) {
1080 RT_TRACE(COMP_ERR, "Unable to initialize "
1081 "/proc/net/rtl8192/%s/registers\n",
1082 dev->name);
1083 }
1084 e = create_proc_read_entry("registers-1", S_IFREG | S_IRUGO,
1085 priv->dir_dev, proc_get_registers_1, dev);
1086 if (!e) {
1087 RT_TRACE(COMP_ERR, "Unable to initialize "
1088 "/proc/net/rtl8192/%s/registers-1\n",
1089 dev->name);
1090 }
1091 e = create_proc_read_entry("registers-2", S_IFREG | S_IRUGO,
1092 priv->dir_dev, proc_get_registers_2, dev);
1093 if (!e) {
1094 RT_TRACE(COMP_ERR, "Unable to initialize "
1095 "/proc/net/rtl8192/%s/registers-2\n",
1096 dev->name);
1097 }
1098 e = create_proc_read_entry("registers-8", S_IFREG | S_IRUGO,
1099 priv->dir_dev, proc_get_registers_8, dev);
1100 if (!e) {
1101 RT_TRACE(COMP_ERR, "Unable to initialize "
1102 "/proc/net/rtl8192/%s/registers-8\n",
1103 dev->name);
1104 }
1105 e = create_proc_read_entry("registers-9", S_IFREG | S_IRUGO,
1106 priv->dir_dev, proc_get_registers_9, dev);
1107 if (!e) {
1108 RT_TRACE(COMP_ERR, "Unable to initialize "
1109 "/proc/net/rtl8192/%s/registers-9\n",
1110 dev->name);
1111 }
1112 e = create_proc_read_entry("registers-a", S_IFREG | S_IRUGO,
1113 priv->dir_dev, proc_get_registers_a, dev);
1114 if (!e) {
1115 RT_TRACE(COMP_ERR, "Unable to initialize "
1116 "/proc/net/rtl8192/%s/registers-a\n",
1117 dev->name);
1118 }
1119 e = create_proc_read_entry("registers-b", S_IFREG | S_IRUGO,
1120 priv->dir_dev, proc_get_registers_b, dev);
1121 if (!e) {
1122 RT_TRACE(COMP_ERR, "Unable to initialize "
1123 "/proc/net/rtl8192/%s/registers-b\n",
1124 dev->name);
1125 }
1126 e = create_proc_read_entry("registers-c", S_IFREG | S_IRUGO,
1127 priv->dir_dev, proc_get_registers_c, dev);
1128 if (!e) {
1129 RT_TRACE(COMP_ERR, "Unable to initialize "
1130 "/proc/net/rtl8192/%s/registers-c\n",
1131 dev->name);
1132 }
1133 e = create_proc_read_entry("registers-d", S_IFREG | S_IRUGO,
1134 priv->dir_dev, proc_get_registers_d, dev);
1135 if (!e) {
1136 RT_TRACE(COMP_ERR, "Unable to initialize "
1137 "/proc/net/rtl8192/%s/registers-d\n",
1138 dev->name);
1139 }
1140 e = create_proc_read_entry("registers-e", S_IFREG | S_IRUGO,
1141 priv->dir_dev, proc_get_registers_e, dev);
1142 if (!e) {
1143 RT_TRACE(COMP_ERR, "Unable to initialize "
1144 "/proc/net/rtl8192/%s/registers-e\n",
1145 dev->name);
1146 }
1147 }
1148 /****************************************************************************
1149 -----------------------------MISC STUFF-------------------------
1150 *****************************************************************************/
1151
1152 /* this is only for debugging */
1153 void print_buffer(u32 *buffer, int len)
1154 {
1155 int i;
1156 u8 *buf =(u8*)buffer;
1157
1158 printk("ASCII BUFFER DUMP (len: %x):\n",len);
1159
1160 for(i=0;i<len;i++)
1161 printk("%c",buf[i]);
1162
1163 printk("\nBINARY BUFFER DUMP (len: %x):\n",len);
1164
1165 for(i=0;i<len;i++)
1166 printk("%x",buf[i]);
1167
1168 printk("\n");
1169 }
1170
1171 //short check_nic_enough_desc(struct net_device *dev, priority_t priority)
1172 short check_nic_enough_desc(struct net_device *dev,int queue_index)
1173 {
1174 struct r8192_priv *priv = ieee80211_priv(dev);
1175 int used = atomic_read(&priv->tx_pending[queue_index]);
1176
1177 return (used < MAX_TX_URB);
1178 }
1179
1180 void tx_timeout(struct net_device *dev)
1181 {
1182 struct r8192_priv *priv = ieee80211_priv(dev);
1183 //rtl8192_commit(dev);
1184
1185 schedule_work(&priv->reset_wq);
1186 //DMESG("TXTIMEOUT");
1187 }
1188
1189 /* this is only for debug */
1190 void rtl8192_dump_reg(struct net_device *dev)
1191 {
1192 int i;
1193 int n;
1194 int max=0x1ff;
1195
1196 RT_TRACE(COMP_PHY, "Dumping NIC register map");
1197
1198 for(n=0;n<=max;)
1199 {
1200 printk( "\nD: %2x> ", n);
1201 for(i=0;i<16 && n<=max;i++,n++)
1202 printk("%2x ",read_nic_byte(dev,n));
1203 }
1204 printk("\n");
1205 }
1206
1207 /****************************************************************************
1208 ------------------------------HW STUFF---------------------------
1209 *****************************************************************************/
1210
1211 void rtl8192_set_mode(struct net_device *dev,int mode)
1212 {
1213 u8 ecmd;
1214 ecmd=read_nic_byte(dev, EPROM_CMD);
1215 ecmd=ecmd &~ EPROM_CMD_OPERATING_MODE_MASK;
1216 ecmd=ecmd | (mode<<EPROM_CMD_OPERATING_MODE_SHIFT);
1217 ecmd=ecmd &~ (1<<EPROM_CS_SHIFT);
1218 ecmd=ecmd &~ (1<<EPROM_CK_SHIFT);
1219 write_nic_byte(dev, EPROM_CMD, ecmd);
1220 }
1221
1222
1223 void rtl8192_update_msr(struct net_device *dev)
1224 {
1225 struct r8192_priv *priv = ieee80211_priv(dev);
1226 LED_CTL_MODE LedAction = LED_CTL_NO_LINK;
1227 u8 msr;
1228
1229 msr = read_nic_byte(dev, MSR);
1230 msr &= ~ MSR_LINK_MASK;
1231
1232 /* do not change in link_state != WLAN_LINK_ASSOCIATED.
1233 * msr must be updated if the state is ASSOCIATING.
1234 * this is intentional and make sense for ad-hoc and
1235 * master (see the create BSS/IBSS func)
1236 */
1237 if (priv->ieee80211->state == IEEE80211_LINKED) {
1238
1239 if (priv->ieee80211->iw_mode == IW_MODE_INFRA) {
1240 msr |= (MSR_LINK_MANAGED<<MSR_LINK_SHIFT);
1241 LedAction = LED_CTL_LINK;
1242 } else if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1243 msr |= (MSR_LINK_ADHOC<<MSR_LINK_SHIFT);
1244 else if (priv->ieee80211->iw_mode == IW_MODE_MASTER)
1245 msr |= (MSR_LINK_MASTER<<MSR_LINK_SHIFT);
1246
1247 } else
1248 msr |= (MSR_LINK_NONE<<MSR_LINK_SHIFT);
1249
1250 write_nic_byte(dev, MSR, msr);
1251
1252 if(priv->ieee80211->LedControlHandler != NULL)
1253 priv->ieee80211->LedControlHandler(dev, LedAction);
1254 }
1255
1256 void rtl8192_set_chan(struct net_device *dev,short ch)
1257 {
1258 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1259 // u32 tx;
1260 RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __FUNCTION__, ch);
1261 //printk("=====>%s()====ch:%d\n", __FUNCTION__, ch);
1262 priv->chan=ch;
1263
1264 /* this hack should avoid frame TX during channel setting*/
1265
1266
1267 // tx = read_nic_dword(dev,TX_CONF);
1268 // tx &= ~TX_LOOPBACK_MASK;
1269
1270 #ifndef LOOP_TEST
1271 // write_nic_dword(dev,TX_CONF, tx |( TX_LOOPBACK_MAC<<TX_LOOPBACK_SHIFT));
1272
1273 //need to implement rf set channel here WB
1274
1275 if (priv->rf_set_chan)
1276 priv->rf_set_chan(dev,priv->chan);
1277 mdelay(10);
1278 // write_nic_dword(dev,TX_CONF,tx | (TX_LOOPBACK_NONE<<TX_LOOPBACK_SHIFT));
1279 #endif
1280 }
1281
1282 static void rtl8192_rx_isr(struct urb *urb);
1283
1284 u32 get_rxpacket_shiftbytes_819xusb(struct ieee80211_rx_stats *pstats)
1285 {
1286
1287 return (sizeof(rx_desc_819x_usb) + pstats->RxDrvInfoSize
1288 + pstats->RxBufShift);
1289
1290 }
1291 static int rtl8192_rx_initiate(struct net_device*dev)
1292 {
1293 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1294 struct urb *entry;
1295 struct sk_buff *skb;
1296 struct rtl8192_rx_info *info;
1297
1298 /* nomal packet rx procedure */
1299 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB) {
1300 skb = __dev_alloc_skb(RX_URB_SIZE, GFP_KERNEL);
1301 if (!skb)
1302 break;
1303 entry = usb_alloc_urb(0, GFP_KERNEL);
1304 if (!entry) {
1305 kfree_skb(skb);
1306 break;
1307 }
1308 usb_fill_bulk_urb(entry, priv->udev,
1309 usb_rcvbulkpipe(priv->udev, 3), skb_tail_pointer(skb),
1310 RX_URB_SIZE, rtl8192_rx_isr, skb);
1311 info = (struct rtl8192_rx_info *) skb->cb;
1312 info->urb = entry;
1313 info->dev = dev;
1314 info->out_pipe = 3; //denote rx normal packet queue
1315 skb_queue_tail(&priv->rx_queue, skb);
1316 usb_submit_urb(entry, GFP_KERNEL);
1317 }
1318
1319 /* command packet rx procedure */
1320 while (skb_queue_len(&priv->rx_queue) < MAX_RX_URB + 3) {
1321 skb = __dev_alloc_skb(RX_URB_SIZE ,GFP_KERNEL);
1322 if (!skb)
1323 break;
1324 entry = usb_alloc_urb(0, GFP_KERNEL);
1325 if (!entry) {
1326 kfree_skb(skb);
1327 break;
1328 }
1329 usb_fill_bulk_urb(entry, priv->udev,
1330 usb_rcvbulkpipe(priv->udev, 9), skb_tail_pointer(skb),
1331 RX_URB_SIZE, rtl8192_rx_isr, skb);
1332 info = (struct rtl8192_rx_info *) skb->cb;
1333 info->urb = entry;
1334 info->dev = dev;
1335 info->out_pipe = 9; //denote rx cmd packet queue
1336 skb_queue_tail(&priv->rx_queue, skb);
1337 usb_submit_urb(entry, GFP_KERNEL);
1338 }
1339
1340 return 0;
1341 }
1342
1343 void rtl8192_set_rxconf(struct net_device *dev)
1344 {
1345 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1346 u32 rxconf;
1347
1348 rxconf=read_nic_dword(dev,RCR);
1349 rxconf = rxconf &~ MAC_FILTER_MASK;
1350 rxconf = rxconf | RCR_AMF;
1351 rxconf = rxconf | RCR_ADF;
1352 rxconf = rxconf | RCR_AB;
1353 rxconf = rxconf | RCR_AM;
1354 //rxconf = rxconf | RCR_ACF;
1355
1356 if (dev->flags & IFF_PROMISC) {DMESG ("NIC in promisc mode");}
1357
1358 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR || \
1359 dev->flags & IFF_PROMISC){
1360 rxconf = rxconf | RCR_AAP;
1361 } /*else if(priv->ieee80211->iw_mode == IW_MODE_MASTER){
1362 rxconf = rxconf | (1<<ACCEPT_ALLMAC_FRAME_SHIFT);
1363 rxconf = rxconf | (1<<RX_CHECK_BSSID_SHIFT);
1364 }*/else{
1365 rxconf = rxconf | RCR_APM;
1366 rxconf = rxconf | RCR_CBSSID;
1367 }
1368
1369
1370 if(priv->ieee80211->iw_mode == IW_MODE_MONITOR){
1371 rxconf = rxconf | RCR_AICV;
1372 rxconf = rxconf | RCR_APWRMGT;
1373 }
1374
1375 if( priv->crcmon == 1 && priv->ieee80211->iw_mode == IW_MODE_MONITOR)
1376 rxconf = rxconf | RCR_ACRC32;
1377
1378
1379 rxconf = rxconf &~ RX_FIFO_THRESHOLD_MASK;
1380 rxconf = rxconf | (RX_FIFO_THRESHOLD_NONE<<RX_FIFO_THRESHOLD_SHIFT);
1381 rxconf = rxconf &~ MAX_RX_DMA_MASK;
1382 rxconf = rxconf | ((u32)7<<RCR_MXDMA_OFFSET);
1383
1384 // rxconf = rxconf | (1<<RX_AUTORESETPHY_SHIFT);
1385 rxconf = rxconf | RCR_ONLYERLPKT;
1386
1387 // rxconf = rxconf &~ RCR_CS_MASK;
1388 // rxconf = rxconf | (1<<RCR_CS_SHIFT);
1389
1390 write_nic_dword(dev, RCR, rxconf);
1391
1392 #ifdef DEBUG_RX
1393 DMESG("rxconf: %x %x",rxconf ,read_nic_dword(dev,RCR));
1394 #endif
1395 }
1396 //wait to be removed
1397 void rtl8192_rx_enable(struct net_device *dev)
1398 {
1399 //u8 cmd;
1400
1401 //struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1402
1403 rtl8192_rx_initiate(dev);
1404
1405 // rtl8192_set_rxconf(dev);
1406 }
1407
1408
1409 void rtl8192_tx_enable(struct net_device *dev)
1410 {
1411 }
1412
1413 void rtl8192_rtx_disable(struct net_device *dev)
1414 {
1415 u8 cmd;
1416 struct r8192_priv *priv = ieee80211_priv(dev);
1417 struct sk_buff *skb;
1418 struct rtl8192_rx_info *info;
1419
1420 cmd=read_nic_byte(dev,CMDR);
1421 write_nic_byte(dev, CMDR, cmd &~ \
1422 (CR_TE|CR_RE));
1423 force_pci_posting(dev);
1424 mdelay(10);
1425
1426 while ((skb = __skb_dequeue(&priv->rx_queue))) {
1427 info = (struct rtl8192_rx_info *) skb->cb;
1428 if (!info->urb)
1429 continue;
1430
1431 usb_kill_urb(info->urb);
1432 kfree_skb(skb);
1433 }
1434
1435 if (skb_queue_len(&priv->skb_queue)) {
1436 printk(KERN_WARNING "skb_queue not empty\n");
1437 }
1438
1439 skb_queue_purge(&priv->skb_queue);
1440 return;
1441 }
1442
1443
1444 int alloc_tx_beacon_desc_ring(struct net_device *dev, int count)
1445 {
1446 return 0;
1447 }
1448
1449 inline u16 ieeerate2rtlrate(int rate)
1450 {
1451 switch(rate){
1452 case 10:
1453 return 0;
1454 case 20:
1455 return 1;
1456 case 55:
1457 return 2;
1458 case 110:
1459 return 3;
1460 case 60:
1461 return 4;
1462 case 90:
1463 return 5;
1464 case 120:
1465 return 6;
1466 case 180:
1467 return 7;
1468 case 240:
1469 return 8;
1470 case 360:
1471 return 9;
1472 case 480:
1473 return 10;
1474 case 540:
1475 return 11;
1476 default:
1477 return 3;
1478
1479 }
1480 }
1481 static u16 rtl_rate[] = {10,20,55,110,60,90,120,180,240,360,480,540};
1482 inline u16 rtl8192_rate2rate(short rate)
1483 {
1484 if (rate >11) return 0;
1485 return rtl_rate[rate];
1486 }
1487
1488 static void rtl8192_rx_isr(struct urb *urb)
1489 {
1490 struct sk_buff *skb = (struct sk_buff *) urb->context;
1491 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
1492 struct net_device *dev = info->dev;
1493 struct r8192_priv *priv = ieee80211_priv(dev);
1494 int out_pipe = info->out_pipe;
1495 int err;
1496 if(!priv->up)
1497 return;
1498 if (unlikely(urb->status)) {
1499 info->urb = NULL;
1500 priv->stats.rxstaterr++;
1501 priv->ieee80211->stats.rx_errors++;
1502 usb_free_urb(urb);
1503 // printk("%s():rx status err\n",__FUNCTION__);
1504 return;
1505 }
1506
1507 skb_unlink(skb, &priv->rx_queue);
1508 skb_put(skb, urb->actual_length);
1509
1510 skb_queue_tail(&priv->skb_queue, skb);
1511 tasklet_schedule(&priv->irq_rx_tasklet);
1512
1513 skb = dev_alloc_skb(RX_URB_SIZE);
1514 if (unlikely(!skb)) {
1515 usb_free_urb(urb);
1516 printk("%s():can,t alloc skb\n",__FUNCTION__);
1517 /* TODO check rx queue length and refill *somewhere* */
1518 return;
1519 }
1520
1521 usb_fill_bulk_urb(urb, priv->udev,
1522 usb_rcvbulkpipe(priv->udev, out_pipe),
1523 skb_tail_pointer(skb),
1524 RX_URB_SIZE, rtl8192_rx_isr, skb);
1525
1526 info = (struct rtl8192_rx_info *) skb->cb;
1527 info->urb = urb;
1528 info->dev = dev;
1529 info->out_pipe = out_pipe;
1530
1531 urb->transfer_buffer = skb_tail_pointer(skb);
1532 urb->context = skb;
1533 skb_queue_tail(&priv->rx_queue, skb);
1534 err = usb_submit_urb(urb, GFP_ATOMIC);
1535 if(err && err != -EPERM)
1536 printk("can not submit rxurb, err is %x,URB status is %x\n",err,urb->status);
1537 }
1538
1539 u32
1540 rtl819xusb_rx_command_packet(
1541 struct net_device *dev,
1542 struct ieee80211_rx_stats *pstats
1543 )
1544 {
1545 u32 status;
1546
1547 //RT_TRACE(COMP_RECV, DBG_TRACE, ("---> RxCommandPacketHandle819xUsb()\n"));
1548
1549 status = cmpk_message_handle_rx(dev, pstats);
1550 if (status)
1551 {
1552 DMESG("rxcommandpackethandle819xusb: It is a command packet\n");
1553 }
1554 else
1555 {
1556 //RT_TRACE(COMP_RECV, DBG_TRACE, ("RxCommandPacketHandle819xUsb: It is not a command packet\n"));
1557 }
1558
1559 //RT_TRACE(COMP_RECV, DBG_TRACE, ("<--- RxCommandPacketHandle819xUsb()\n"));
1560 return status;
1561 }
1562
1563 void rtl8192_data_hard_stop(struct net_device *dev)
1564 {
1565 //FIXME !!
1566 }
1567
1568
1569 void rtl8192_data_hard_resume(struct net_device *dev)
1570 {
1571 // FIXME !!
1572 }
1573
1574 /* this function TX data frames when the ieee80211 stack requires this.
1575 * It checks also if we need to stop the ieee tx queue, eventually do it
1576 */
1577 void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev, int rate)
1578 {
1579 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1580 int ret;
1581 unsigned long flags;
1582 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1583 u8 queue_index = tcb_desc->queue_index;
1584
1585 /* shall not be referred by command packet */
1586 assert(queue_index != TXCMD_QUEUE);
1587
1588 spin_lock_irqsave(&priv->tx_lock,flags);
1589
1590 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1591 // tcb_desc->RATRIndex = 7;
1592 // tcb_desc->bTxDisableRateFallBack = 1;
1593 // tcb_desc->bTxUseDriverAssingedRate = 1;
1594 tcb_desc->bTxEnableFwCalcDur = 1;
1595 skb_push(skb, priv->ieee80211->tx_headroom);
1596 ret = priv->ops->rtl819x_tx(dev, skb);
1597
1598 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1599 //priv->ieee80211->stats.tx_packets++;
1600
1601 spin_unlock_irqrestore(&priv->tx_lock,flags);
1602
1603 // return ret;
1604 return;
1605 }
1606
1607 /* This is a rough attempt to TX a frame
1608 * This is called by the ieee 80211 stack to TX management frames.
1609 * If the ring is full packet are dropped (for data frame the queue
1610 * is stopped before this can happen).
1611 */
1612 int rtl8192_hard_start_xmit(struct sk_buff *skb,struct net_device *dev)
1613 {
1614 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
1615 int ret;
1616 unsigned long flags;
1617 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1618 u8 queue_index = tcb_desc->queue_index;
1619
1620
1621 spin_lock_irqsave(&priv->tx_lock,flags);
1622
1623 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
1624 if(queue_index == TXCMD_QUEUE) {
1625 skb_push(skb, USB_HWDESC_HEADER_LEN);
1626 priv->ops->rtl819x_tx_cmd(dev, skb);
1627 ret = 1;
1628 spin_unlock_irqrestore(&priv->tx_lock,flags);
1629 return ret;
1630 } else {
1631 skb_push(skb, priv->ieee80211->tx_headroom);
1632 ret = priv->ops->rtl819x_tx(dev, skb);
1633 }
1634
1635 spin_unlock_irqrestore(&priv->tx_lock,flags);
1636
1637 return ret;
1638 }
1639
1640
1641 void rtl8192_try_wake_queue(struct net_device *dev, int pri);
1642
1643
1644 static void rtl8192_tx_isr(struct urb *tx_urb)
1645 {
1646 struct sk_buff *skb = (struct sk_buff*)tx_urb->context;
1647 struct net_device *dev = NULL;
1648 struct r8192_priv *priv = NULL;
1649 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1650 u8 queue_index = tcb_desc->queue_index;
1651 // bool bToSend0Byte;
1652 // u16 BufLen = skb->len;
1653
1654 memcpy(&dev,(struct net_device*)(skb->cb),sizeof(struct net_device*));
1655 priv = ieee80211_priv(dev);
1656
1657 if(tcb_desc->queue_index != TXCMD_QUEUE) {
1658 if(tx_urb->status == 0) {
1659 // dev->trans_start = jiffies;
1660 // As act as station mode, destion shall be unicast address.
1661 //priv->ieee80211->stats.tx_bytes+=(skb->len - priv->ieee80211->tx_headroom);
1662 //priv->ieee80211->stats.tx_packets++;
1663 priv->stats.txoktotal++;
1664 priv->ieee80211->LinkDetectInfo.NumTxOkInPeriod++;
1665 priv->stats.txbytesunicast += (skb->len - priv->ieee80211->tx_headroom);
1666 } else {
1667 priv->ieee80211->stats.tx_errors++;
1668 //priv->stats.txmanageerr++;
1669 /* TODO */
1670 }
1671 }
1672
1673 /* free skb and tx_urb */
1674 if(skb != NULL) {
1675 dev_kfree_skb_any(skb);
1676 usb_free_urb(tx_urb);
1677 atomic_dec(&priv->tx_pending[queue_index]);
1678 }
1679
1680 {
1681 //
1682 // Handle HW Beacon:
1683 // We had transfer our beacon frame to host controler at this moment.
1684 //
1685 //
1686 // Caution:
1687 // Handling the wait queue of command packets.
1688 // For Tx command packets, we must not do TCB fragment because it is not handled right now.
1689 // We must cut the packets to match the size of TX_CMD_PKT before we send it.
1690 //
1691 if (queue_index == MGNT_QUEUE){
1692 if (priv->ieee80211->ack_tx_to_ieee){
1693 if (rtl8192_is_tx_queue_empty(dev)){
1694 priv->ieee80211->ack_tx_to_ieee = 0;
1695 ieee80211_ps_tx_ack(priv->ieee80211, 1);
1696 }
1697 }
1698 }
1699 /* Handle MPDU in wait queue. */
1700 if(queue_index != BEACON_QUEUE) {
1701 /* Don't send data frame during scanning.*/
1702 if((skb_queue_len(&priv->ieee80211->skb_waitQ[queue_index]) != 0)&&\
1703 (!(priv->ieee80211->queue_stop))) {
1704 if(NULL != (skb = skb_dequeue(&(priv->ieee80211->skb_waitQ[queue_index]))))
1705 priv->ieee80211->softmac_hard_start_xmit(skb, dev);
1706
1707 return; //modified by david to avoid further processing AMSDU
1708 }
1709 }
1710 }
1711 }
1712
1713 void rtl8192_beacon_stop(struct net_device *dev)
1714 {
1715 u8 msr, msrm, msr2;
1716 struct r8192_priv *priv = ieee80211_priv(dev);
1717
1718 msr = read_nic_byte(dev, MSR);
1719 msrm = msr & MSR_LINK_MASK;
1720 msr2 = msr & ~MSR_LINK_MASK;
1721
1722 if(NIC_8192U == priv->card_8192) {
1723 usb_kill_urb(priv->rx_urb[MAX_RX_URB]);
1724 }
1725 if ((msrm == (MSR_LINK_ADHOC<<MSR_LINK_SHIFT) ||
1726 (msrm == (MSR_LINK_MASTER<<MSR_LINK_SHIFT)))){
1727 write_nic_byte(dev, MSR, msr2 | MSR_LINK_NONE);
1728 write_nic_byte(dev, MSR, msr);
1729 }
1730 }
1731
1732 void rtl8192_config_rate(struct net_device* dev, u16* rate_config)
1733 {
1734 struct r8192_priv *priv = ieee80211_priv(dev);
1735 struct ieee80211_network *net;
1736 u8 i=0, basic_rate = 0;
1737 net = & priv->ieee80211->current_network;
1738
1739 for (i=0; i<net->rates_len; i++)
1740 {
1741 basic_rate = net->rates[i]&0x7f;
1742 switch(basic_rate)
1743 {
1744 case MGN_1M: *rate_config |= RRSR_1M; break;
1745 case MGN_2M: *rate_config |= RRSR_2M; break;
1746 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1747 case MGN_11M: *rate_config |= RRSR_11M; break;
1748 case MGN_6M: *rate_config |= RRSR_6M; break;
1749 case MGN_9M: *rate_config |= RRSR_9M; break;
1750 case MGN_12M: *rate_config |= RRSR_12M; break;
1751 case MGN_18M: *rate_config |= RRSR_18M; break;
1752 case MGN_24M: *rate_config |= RRSR_24M; break;
1753 case MGN_36M: *rate_config |= RRSR_36M; break;
1754 case MGN_48M: *rate_config |= RRSR_48M; break;
1755 case MGN_54M: *rate_config |= RRSR_54M; break;
1756 }
1757 }
1758 for (i=0; i<net->rates_ex_len; i++)
1759 {
1760 basic_rate = net->rates_ex[i]&0x7f;
1761 switch(basic_rate)
1762 {
1763 case MGN_1M: *rate_config |= RRSR_1M; break;
1764 case MGN_2M: *rate_config |= RRSR_2M; break;
1765 case MGN_5_5M: *rate_config |= RRSR_5_5M; break;
1766 case MGN_11M: *rate_config |= RRSR_11M; break;
1767 case MGN_6M: *rate_config |= RRSR_6M; break;
1768 case MGN_9M: *rate_config |= RRSR_9M; break;
1769 case MGN_12M: *rate_config |= RRSR_12M; break;
1770 case MGN_18M: *rate_config |= RRSR_18M; break;
1771 case MGN_24M: *rate_config |= RRSR_24M; break;
1772 case MGN_36M: *rate_config |= RRSR_36M; break;
1773 case MGN_48M: *rate_config |= RRSR_48M; break;
1774 case MGN_54M: *rate_config |= RRSR_54M; break;
1775 }
1776 }
1777 }
1778
1779
1780 #define SHORT_SLOT_TIME 9
1781 #define NON_SHORT_SLOT_TIME 20
1782
1783 void rtl8192_update_cap(struct net_device* dev, u16 cap)
1784 {
1785 //u32 tmp = 0;
1786 struct r8192_priv *priv = ieee80211_priv(dev);
1787 struct ieee80211_network *net = &priv->ieee80211->current_network;
1788 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
1789
1790 //LZM MOD 090303 HW_VAR_ACK_PREAMBLE
1791 if(0)
1792 {
1793 u8 tmp = 0;
1794 tmp = ((priv->nCur40MhzPrimeSC) << 5);
1795 if (priv->short_preamble)
1796 tmp |= 0x80;
1797 write_nic_byte(dev, RRSR+2, tmp);
1798 }
1799
1800 if (net->mode & (IEEE_G|IEEE_N_24G))
1801 {
1802 u8 slot_time = 0;
1803 if ((cap & WLAN_CAPABILITY_SHORT_SLOT)&&(!priv->ieee80211->pHTInfo->bCurrentRT2RTLongSlotTime))
1804 {//short slot time
1805 slot_time = SHORT_SLOT_TIME;
1806 }
1807 else //long slot time
1808 slot_time = NON_SHORT_SLOT_TIME;
1809 priv->slot_time = slot_time;
1810 write_nic_byte(dev, SLOT_TIME, slot_time);
1811 }
1812
1813 }
1814 void rtl8192_net_update(struct net_device *dev)
1815 {
1816
1817 struct r8192_priv *priv = ieee80211_priv(dev);
1818 struct ieee80211_network *net;
1819 u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
1820 u16 rate_config = 0;
1821 net = & priv->ieee80211->current_network;
1822
1823 rtl8192_config_rate(dev, &rate_config);
1824 priv->basic_rate = rate_config &= 0x15f;
1825
1826 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
1827 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
1828 //for(i=0;i<ETH_ALEN;i++)
1829 // write_nic_byte(dev,BSSID+i,net->bssid[i]);
1830
1831 rtl8192_update_msr(dev);
1832 // rtl8192_update_cap(dev, net->capability);
1833 if (priv->ieee80211->iw_mode == IW_MODE_ADHOC)
1834 {
1835 write_nic_word(dev, ATIMWND, 2);
1836 write_nic_word(dev, BCN_DMATIME, 1023);
1837 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
1838 // write_nic_word(dev, BcnIntTime, 100);
1839 write_nic_word(dev, BCN_DRV_EARLY_INT, 1);
1840 write_nic_byte(dev, BCN_ERR_THRESH, 100);
1841 BcnTimeCfg |= (BcnCW<<BCN_TCFG_CW_SHIFT);
1842 // TODO: BcnIFS may required to be changed on ASIC
1843 BcnTimeCfg |= BcnIFS<<BCN_TCFG_IFS;
1844
1845 write_nic_word(dev, BCN_TCFG, BcnTimeCfg);
1846 }
1847
1848
1849
1850 }
1851
1852 //temporary hw beacon is not used any more.
1853 //open it when necessary
1854 #if 1
1855 void rtl819xusb_beacon_tx(struct net_device *dev,u16 tx_rate)
1856 {
1857 }
1858 #endif
1859 inline u8 rtl8192_IsWirelessBMode(u16 rate)
1860 {
1861 if( ((rate <= 110) && (rate != 60) && (rate != 90)) || (rate == 220) )
1862 return 1;
1863 else return 0;
1864 }
1865
1866 u16 N_DBPSOfRate(u16 DataRate);
1867
1868 u16 ComputeTxTime(
1869 u16 FrameLength,
1870 u16 DataRate,
1871 u8 bManagementFrame,
1872 u8 bShortPreamble
1873 )
1874 {
1875 u16 FrameTime;
1876 u16 N_DBPS;
1877 u16 Ceiling;
1878
1879 if( rtl8192_IsWirelessBMode(DataRate) )
1880 {
1881 if( bManagementFrame || !bShortPreamble || DataRate == 10 )
1882 { // long preamble
1883 FrameTime = (u16)(144+48+(FrameLength*8/(DataRate/10)));
1884 }
1885 else
1886 { // Short preamble
1887 FrameTime = (u16)(72+24+(FrameLength*8/(DataRate/10)));
1888 }
1889 if( ( FrameLength*8 % (DataRate/10) ) != 0 ) //Get the Ceilling
1890 FrameTime ++;
1891 } else { //802.11g DSSS-OFDM PLCP length field calculation.
1892 N_DBPS = N_DBPSOfRate(DataRate);
1893 Ceiling = (16 + 8*FrameLength + 6) / N_DBPS
1894 + (((16 + 8*FrameLength + 6) % N_DBPS) ? 1 : 0);
1895 FrameTime = (u16)(16 + 4 + 4*Ceiling + 6);
1896 }
1897 return FrameTime;
1898 }
1899
1900 u16 N_DBPSOfRate(u16 DataRate)
1901 {
1902 u16 N_DBPS = 24;
1903
1904 switch(DataRate)
1905 {
1906 case 60:
1907 N_DBPS = 24;
1908 break;
1909
1910 case 90:
1911 N_DBPS = 36;
1912 break;
1913
1914 case 120:
1915 N_DBPS = 48;
1916 break;
1917
1918 case 180:
1919 N_DBPS = 72;
1920 break;
1921
1922 case 240:
1923 N_DBPS = 96;
1924 break;
1925
1926 case 360:
1927 N_DBPS = 144;
1928 break;
1929
1930 case 480:
1931 N_DBPS = 192;
1932 break;
1933
1934 case 540:
1935 N_DBPS = 216;
1936 break;
1937
1938 default:
1939 break;
1940 }
1941
1942 return N_DBPS;
1943 }
1944
1945 void rtl819xU_cmd_isr(struct urb *tx_cmd_urb, struct pt_regs *regs)
1946 {
1947 usb_free_urb(tx_cmd_urb);
1948 }
1949
1950 unsigned int txqueue2outpipe(struct r8192_priv* priv,unsigned int tx_queue) {
1951
1952 if(tx_queue >= 9)
1953 {
1954 RT_TRACE(COMP_ERR,"%s():Unknown queue ID!!!\n",__FUNCTION__);
1955 return 0x04;
1956 }
1957 return priv->txqueue_to_outpipemap[tx_queue];
1958 }
1959
1960 short rtl8192SU_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1961 {
1962 struct r8192_priv *priv = ieee80211_priv(dev);
1963 int status;
1964 struct urb *tx_urb;
1965 unsigned int idx_pipe;
1966 tx_desc_cmd_819x_usb *pdesc = (tx_desc_cmd_819x_usb *)skb->data;
1967 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
1968 u8 queue_index = tcb_desc->queue_index;
1969 u32 PktSize = 0;
1970
1971 //printk("\n %s::::::::::::::::::::::queue_index = %d\n",__FUNCTION__, queue_index);
1972 atomic_inc(&priv->tx_pending[queue_index]);
1973
1974 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
1975 if(!tx_urb){
1976 dev_kfree_skb(skb);
1977 return -ENOMEM;
1978 }
1979
1980 memset(pdesc, 0, USB_HWDESC_HEADER_LEN);
1981
1982 /* Tx descriptor ought to be set according to the skb->cb */
1983 pdesc->LINIP = tcb_desc->bLastIniPkt;
1984 PktSize = (u16)(skb->len - USB_HWDESC_HEADER_LEN);
1985 pdesc->PktSize = PktSize;
1986 //printk("PKTSize = %d %x\n",pdesc->PktSize,pdesc->PktSize);
1987 //----------------------------------------------------------------------------
1988 // Fill up USB_OUT_CONTEXT.
1989 //----------------------------------------------------------------------------
1990 // Get index to out pipe from specified QueueID.
1991 idx_pipe = txqueue2outpipe(priv,queue_index);
1992 //printk("=============>%s queue_index:%d, outpipe:%d\n", __func__,queue_index,priv->RtOutPipes[idx_pipe]);
1993
1994 usb_fill_bulk_urb(tx_urb,
1995 priv->udev,
1996 usb_sndbulkpipe(priv->udev,priv->RtOutPipes[idx_pipe]),
1997 skb->data,
1998 skb->len,
1999 rtl8192_tx_isr,
2000 skb);
2001
2002 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
2003 if (!status){
2004 return 0;
2005 }else{
2006 printk("Error TX CMD URB, error %d",
2007 status);
2008 return -1;
2009 }
2010 }
2011
2012 /*
2013 * Mapping Software/Hardware descriptor queue id to "Queue Select Field"
2014 * in TxFwInfo data structure
2015 * 2006.10.30 by Emily
2016 *
2017 * \param QUEUEID Software Queue
2018 */
2019 u8 MapHwQueueToFirmwareQueue(u8 QueueID)
2020 {
2021 u8 QueueSelect = 0x0; //defualt set to
2022
2023 switch(QueueID) {
2024 case BE_QUEUE:
2025 QueueSelect = QSLT_BE; //or QSelect = pTcb->priority;
2026 break;
2027
2028 case BK_QUEUE:
2029 QueueSelect = QSLT_BK; //or QSelect = pTcb->priority;
2030 break;
2031
2032 case VO_QUEUE:
2033 QueueSelect = QSLT_VO; //or QSelect = pTcb->priority;
2034 break;
2035
2036 case VI_QUEUE:
2037 QueueSelect = QSLT_VI; //or QSelect = pTcb->priority;
2038 break;
2039 case MGNT_QUEUE:
2040 QueueSelect = QSLT_MGNT;
2041 break;
2042
2043 case BEACON_QUEUE:
2044 QueueSelect = QSLT_BEACON;
2045 break;
2046
2047 // TODO: 2006.10.30 mark other queue selection until we verify it is OK
2048 // TODO: Remove Assertions
2049 //#if (RTL819X_FPGA_VER & RTL819X_FPGA_GUANGAN_070502)
2050 case TXCMD_QUEUE:
2051 QueueSelect = QSLT_CMD;
2052 break;
2053 //#endif
2054 case HIGH_QUEUE:
2055 QueueSelect = QSLT_HIGH;
2056 break;
2057
2058 default:
2059 RT_TRACE(COMP_ERR, "TransmitTCB(): Impossible Queue Selection: %d \n", QueueID);
2060 break;
2061 }
2062 return QueueSelect;
2063 }
2064
2065 u8 MRateToHwRate8190Pci(u8 rate)
2066 {
2067 u8 ret = DESC92S_RATE1M;
2068
2069 switch(rate)
2070 {
2071 // CCK and OFDM non-HT rates
2072 case MGN_1M: ret = DESC92S_RATE1M; break;
2073 case MGN_2M: ret = DESC92S_RATE2M; break;
2074 case MGN_5_5M: ret = DESC92S_RATE5_5M; break;
2075 case MGN_11M: ret = DESC92S_RATE11M; break;
2076 case MGN_6M: ret = DESC92S_RATE6M; break;
2077 case MGN_9M: ret = DESC92S_RATE9M; break;
2078 case MGN_12M: ret = DESC92S_RATE12M; break;
2079 case MGN_18M: ret = DESC92S_RATE18M; break;
2080 case MGN_24M: ret = DESC92S_RATE24M; break;
2081 case MGN_36M: ret = DESC92S_RATE36M; break;
2082 case MGN_48M: ret = DESC92S_RATE48M; break;
2083 case MGN_54M: ret = DESC92S_RATE54M; break;
2084
2085 // HT rates since here
2086 case MGN_MCS0: ret = DESC92S_RATEMCS0; break;
2087 case MGN_MCS1: ret = DESC92S_RATEMCS1; break;
2088 case MGN_MCS2: ret = DESC92S_RATEMCS2; break;
2089 case MGN_MCS3: ret = DESC92S_RATEMCS3; break;
2090 case MGN_MCS4: ret = DESC92S_RATEMCS4; break;
2091 case MGN_MCS5: ret = DESC92S_RATEMCS5; break;
2092 case MGN_MCS6: ret = DESC92S_RATEMCS6; break;
2093 case MGN_MCS7: ret = DESC92S_RATEMCS7; break;
2094 case MGN_MCS8: ret = DESC92S_RATEMCS8; break;
2095 case MGN_MCS9: ret = DESC92S_RATEMCS9; break;
2096 case MGN_MCS10: ret = DESC92S_RATEMCS10; break;
2097 case MGN_MCS11: ret = DESC92S_RATEMCS11; break;
2098 case MGN_MCS12: ret = DESC92S_RATEMCS12; break;
2099 case MGN_MCS13: ret = DESC92S_RATEMCS13; break;
2100 case MGN_MCS14: ret = DESC92S_RATEMCS14; break;
2101 case MGN_MCS15: ret = DESC92S_RATEMCS15; break;
2102
2103 // Set the highest SG rate
2104 case MGN_MCS0_SG:
2105 case MGN_MCS1_SG:
2106 case MGN_MCS2_SG:
2107 case MGN_MCS3_SG:
2108 case MGN_MCS4_SG:
2109 case MGN_MCS5_SG:
2110 case MGN_MCS6_SG:
2111 case MGN_MCS7_SG:
2112 case MGN_MCS8_SG:
2113 case MGN_MCS9_SG:
2114 case MGN_MCS10_SG:
2115 case MGN_MCS11_SG:
2116 case MGN_MCS12_SG:
2117 case MGN_MCS13_SG:
2118 case MGN_MCS14_SG:
2119 case MGN_MCS15_SG:
2120 {
2121 ret = DESC92S_RATEMCS15_SG;
2122 break;
2123 }
2124
2125 default: break;
2126 }
2127 return ret;
2128 }
2129
2130 u8 QueryIsShort(u8 TxHT, u8 TxRate, cb_desc *tcb_desc)
2131 {
2132 u8 tmp_Short;
2133
2134 tmp_Short = (TxHT==1)?((tcb_desc->bUseShortGI)?1:0):((tcb_desc->bUseShortPreamble)?1:0);
2135
2136 if(TxHT==1 && TxRate != DESC90_RATEMCS15)
2137 tmp_Short = 0;
2138
2139 return tmp_Short;
2140 }
2141
2142 static void tx_zero_isr(struct urb *tx_urb)
2143 {
2144 return;
2145 }
2146
2147
2148 /*
2149 * The tx procedure is just as following, skb->cb will contain all the following
2150 *information: * priority, morefrag, rate, &dev.
2151 * */
2152 // <Note> Buffer format for 8192S Usb bulk out:
2153 //
2154 // --------------------------------------------------
2155 // | 8192S Usb Tx Desc | 802_11_MAC_header | data |
2156 // --------------------------------------------------
2157 // | 32 bytes | 24 bytes |0-2318 bytes|
2158 // --------------------------------------------------
2159 // |<------------ BufferLen ------------------------->|
2160
2161 short rtl8192SU_tx(struct net_device *dev, struct sk_buff* skb)
2162 {
2163 struct r8192_priv *priv = ieee80211_priv(dev);
2164 cb_desc *tcb_desc = (cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
2165 tx_desc_819x_usb *tx_desc = (tx_desc_819x_usb *)skb->data;
2166 struct usb_device *udev = priv->udev;
2167 int pend;
2168 int status;
2169 struct urb *tx_urb = NULL, *tx_urb_zero = NULL;
2170 unsigned int idx_pipe;
2171 u16 MPDUOverhead = 0;
2172 u16 type = 0;
2173
2174 pend = atomic_read(&priv->tx_pending[tcb_desc->queue_index]);
2175 /* we are locked here so the two atomic_read and inc are executed
2176 * without interleaves * !!! For debug purpose */
2177 if( pend > MAX_TX_URB){
2178 switch (tcb_desc->queue_index) {
2179 case VO_PRIORITY:
2180 priv->stats.txvodrop++;
2181 break;
2182 case VI_PRIORITY:
2183 priv->stats.txvidrop++;
2184 break;
2185 case BE_PRIORITY:
2186 priv->stats.txbedrop++;
2187 break;
2188 default://BK_PRIORITY
2189 priv->stats.txbkdrop++;
2190 break;
2191 }
2192 printk("To discard skb packet!\n");
2193 dev_kfree_skb_any(skb);
2194 return -1;
2195 }
2196
2197 tx_urb = usb_alloc_urb(0,GFP_ATOMIC);
2198 if(!tx_urb){
2199 dev_kfree_skb_any(skb);
2200 return -ENOMEM;
2201 }
2202
2203 memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
2204
2205
2206 tx_desc->NonQos = (IsQoSDataFrame(skb->data)==TRUE)? 0:1;
2207
2208 /* Fill Tx descriptor */
2209 //memset(tx_fwinfo,0,sizeof(tx_fwinfo_819x_usb));
2210
2211 // This part can just fill to the first descriptor of the frame.
2212 /* DWORD 0 */
2213 tx_desc->TxHT = (tcb_desc->data_rate&0x80)?1:0;
2214
2215
2216 tx_desc->TxRate = MRateToHwRate8190Pci(tcb_desc->data_rate);
2217 //tx_desc->EnableCPUDur = tcb_desc->bTxEnableFwCalcDur;
2218 tx_desc->TxShort = QueryIsShort(tx_desc->TxHT, tx_desc->TxRate, tcb_desc);
2219
2220
2221 // Aggregation related
2222 if(tcb_desc->bAMPDUEnable) {//AMPDU enabled
2223 tx_desc->AllowAggregation = 1;
2224 /* DWORD 1 */
2225 //tx_fwinfo->RxMF = tcb_desc->ampdu_factor;
2226 //tx_fwinfo->RxAMD = tcb_desc->ampdu_density&0x07;//ampdudensity
2227 } else {
2228 tx_desc->AllowAggregation = 0;
2229 /* DWORD 1 */
2230 //tx_fwinfo->RxMF = 0;
2231 //tx_fwinfo->RxAMD = 0;
2232 }
2233
2234 //
2235 // <Roger_Notes> For AMPDU case, we must insert SSN into TX_DESC,
2236 // FW according as this SSN to do necessary packet retry.
2237 // 2008.06.06.
2238 //
2239 {
2240 u8 *pSeq;
2241 u16 Temp;
2242 //pSeq = (u8 *)(VirtualAddress+USB_HWDESC_HEADER_LEN + FRAME_OFFSET_SEQUENCE);
2243 pSeq = (u8 *)(skb->data+USB_HWDESC_HEADER_LEN + 22);
2244 Temp = pSeq[0];
2245 Temp <<= 12;
2246 Temp |= (*(u16 *)pSeq)>>4;
2247 tx_desc->Seq = Temp;
2248 }
2249
2250 /* Protection mode related */
2251 tx_desc->RTSEn = (tcb_desc->bRTSEnable)?1:0;
2252 tx_desc->CTS2Self = (tcb_desc->bCTSEnable)?1:0;
2253 tx_desc->RTSSTBC = (tcb_desc->bRTSSTBC)?1:0;
2254 tx_desc->RTSHT = (tcb_desc->rts_rate&0x80)?1:0;
2255 tx_desc->RTSRate = MRateToHwRate8190Pci((u8)tcb_desc->rts_rate);
2256 tx_desc->RTSSubcarrier = (tx_desc->RTSHT==0)?(tcb_desc->RTSSC):0;
2257 tx_desc->RTSBW = (tx_desc->RTSHT==1)?((tcb_desc->bRTSBW)?1:0):0;
2258 tx_desc->RTSShort = (tx_desc->RTSHT==0)?(tcb_desc->bRTSUseShortPreamble?1:0):\
2259 (tcb_desc->bRTSUseShortGI?1:0);
2260 //LZM 090219
2261 tx_desc->DisRTSFB = 0;
2262 tx_desc->RTSRateFBLmt = 0xf;
2263
2264 // <Roger_EXP> 2008.09.22. We disable RTS rate fallback temporarily.
2265 //tx_desc->DisRTSFB = 0x01;
2266
2267 /* Set Bandwidth and sub-channel settings. */
2268 if(priv->CurrentChannelBW == HT_CHANNEL_WIDTH_20_40)
2269 {
2270 if(tcb_desc->bPacketBW) {
2271 tx_desc->TxBandwidth = 1;
2272 tx_desc->TxSubCarrier = 0; //By SD3's Jerry suggestion, use duplicated mode
2273 } else {
2274 tx_desc->TxBandwidth = 0;
2275 tx_desc->TxSubCarrier = priv->nCur40MhzPrimeSC;
2276 }
2277 } else {
2278 tx_desc->TxBandwidth = 0;
2279 tx_desc->TxSubCarrier = 0;
2280 }
2281
2282
2283 //memset(tx_desc, 0, sizeof(tx_desc_819x_usb));
2284 /* DWORD 0 */
2285 tx_desc->LINIP = 0;
2286 //tx_desc->CmdInit = 1; //92su del
2287 tx_desc->Offset = USB_HWDESC_HEADER_LEN;
2288
2289 {
2290 tx_desc->PktSize = (skb->len - USB_HWDESC_HEADER_LEN) & 0xffff;
2291 }
2292
2293 /*DWORD 1*/
2294 //tx_desc->SecCAMID= 0;//92su del
2295 tx_desc->RaBRSRID= tcb_desc->RATRIndex;
2296 //#ifdef RTL8192S_PREPARE_FOR_NORMAL_RELEASE
2297
2298 {
2299 MPDUOverhead = 0;
2300 //tx_desc->NoEnc = 1;//92su del
2301 }
2302
2303 tx_desc->SecType = 0x0;
2304
2305 if (tcb_desc->bHwSec)
2306 {
2307 switch (priv->ieee80211->pairwise_key_type)
2308 {
2309 case KEY_TYPE_WEP40:
2310 case KEY_TYPE_WEP104:
2311 tx_desc->SecType = 0x1;
2312 //tx_desc->NoEnc = 0;//92su del
2313 break;
2314 case KEY_TYPE_TKIP:
2315 tx_desc->SecType = 0x2;
2316 //tx_desc->NoEnc = 0;//92su del
2317 break;
2318 case KEY_TYPE_CCMP:
2319 tx_desc->SecType = 0x3;
2320 //tx_desc->NoEnc = 0;//92su del
2321 break;
2322 case KEY_TYPE_NA:
2323 tx_desc->SecType = 0x0;
2324 //tx_desc->NoEnc = 1;//92su del
2325 break;
2326 default:
2327 tx_desc->SecType = 0x0;
2328 //tx_desc->NoEnc = 1;//92su del
2329 break;
2330 }
2331 }
2332
2333 //tx_desc->TxFWInfoSize = sizeof(tx_fwinfo_819x_usb);//92su del
2334
2335
2336 tx_desc->USERATE = tcb_desc->bTxUseDriverAssingedRate;
2337 tx_desc->DISFB = tcb_desc->bTxDisableRateFallBack;
2338 tx_desc->DataRateFBLmt = 0x1F;// Alwasy enable all rate fallback range
2339
2340 tx_desc->QueueSelect = MapHwQueueToFirmwareQueue(tcb_desc->queue_index);
2341
2342
2343 /* Fill fields that are required to be initialized in all of the descriptors */
2344 //DWORD 0
2345 tx_desc->FirstSeg = 1;
2346 tx_desc->LastSeg = 1;
2347 tx_desc->OWN = 1;
2348
2349 {
2350 //DWORD 2
2351 //tx_desc->TxBufferSize = (u32)(skb->len - USB_HWDESC_HEADER_LEN);
2352 tx_desc->TxBufferSize = (u32)(skb->len);//92su mod FIXLZM
2353 }
2354
2355 /* Get index to out pipe from specified QueueID */
2356 idx_pipe = txqueue2outpipe(priv,tcb_desc->queue_index);
2357 //printk("=============>%s queue_index:%d, outpipe:%d\n", __func__,tcb_desc->queue_index,priv->RtOutPipes[idx_pipe]);
2358
2359 //RT_DEBUG_DATA(COMP_SEND,tx_fwinfo,sizeof(tx_fwinfo_819x_usb));
2360 //RT_DEBUG_DATA(COMP_SEND,tx_desc,sizeof(tx_desc_819x_usb));
2361
2362 /* To submit bulk urb */
2363 usb_fill_bulk_urb(tx_urb,
2364 udev,
2365 usb_sndbulkpipe(udev,priv->RtOutPipes[idx_pipe]),
2366 skb->data,
2367 skb->len, rtl8192_tx_isr, skb);
2368
2369 if (type == IEEE80211_FTYPE_DATA) {
2370 if (priv->ieee80211->LedControlHandler != NULL)
2371 priv->ieee80211->LedControlHandler(dev, LED_CTL_TX);
2372 }
2373
2374 status = usb_submit_urb(tx_urb, GFP_ATOMIC);
2375 if (!status) {
2376 /*
2377 * we need to send 0 byte packet whenever 512N bytes/64N(HIGN SPEED/NORMAL SPEED) bytes packet has been transmitted.
2378 * Otherwise, it will be halt to wait for another packet. WB. 2008.08.27
2379 */
2380 bool bSend0Byte = false;
2381 u8 zero = 0;
2382 if(udev->speed == USB_SPEED_HIGH) {
2383 if (skb->len > 0 && skb->len % 512 == 0)
2384 bSend0Byte = true;
2385 }
2386 else {
2387 if (skb->len > 0 && skb->len % 64 == 0)
2388 bSend0Byte = true;
2389 }
2390 if (bSend0Byte) {
2391 tx_urb_zero = usb_alloc_urb(0,GFP_ATOMIC);
2392 if(!tx_urb_zero) {
2393 RT_TRACE(COMP_ERR, "can't alloc urb for zero byte\n");
2394 return -ENOMEM;
2395 }
2396 usb_fill_bulk_urb(tx_urb_zero,udev,
2397 usb_sndbulkpipe(udev,idx_pipe), &zero,
2398 0, tx_zero_isr, dev);
2399 status = usb_submit_urb(tx_urb_zero, GFP_ATOMIC);
2400 switch (status) {
2401 case 0:
2402 break;
2403 case -ECONNRESET:
2404 case -ENOENT:
2405 case -ESHUTDOWN:
2406 break;
2407 default:
2408 RT_TRACE(COMP_ERR, "Error TX URB for zero byte %d, error %d",
2409 atomic_read(&priv->tx_pending[tcb_desc->queue_index]), status);
2410 return -1;
2411 }
2412 }
2413 dev->trans_start = jiffies;
2414 atomic_inc(&priv->tx_pending[tcb_desc->queue_index]);
2415 return 0;
2416 } else {
2417 RT_TRACE(COMP_ERR, "Error TX URB %d, error %d", atomic_read(&priv->tx_pending[tcb_desc->queue_index]),
2418 status);
2419 return -1;
2420 }
2421 }
2422
2423 void rtl8192SU_net_update(struct net_device *dev)
2424 {
2425
2426 struct r8192_priv *priv = ieee80211_priv(dev);
2427 struct ieee80211_device* ieee = priv->ieee80211;
2428 struct ieee80211_network *net = &priv->ieee80211->current_network;
2429 //u16 BcnTimeCfg = 0, BcnCW = 6, BcnIFS = 0xf;
2430 u16 rate_config = 0;
2431 u32 regTmp = 0;
2432 u8 rateIndex = 0;
2433 u8 retrylimit = 0x30;
2434 u16 cap = net->capability;
2435
2436 priv->short_preamble = cap & WLAN_CAPABILITY_SHORT_PREAMBLE;
2437
2438 //HW_VAR_BASIC_RATE
2439 //update Basic rate: RR, BRSR
2440 rtl8192_config_rate(dev, &rate_config); //HalSetBrateCfg
2441
2442 priv->basic_rate = rate_config = rate_config & 0x15f;
2443
2444 // Set RRSR rate table.
2445 write_nic_byte(dev, RRSR, rate_config&0xff);
2446 write_nic_byte(dev, RRSR+1, (rate_config>>8)&0xff);
2447
2448 // Set RTS initial rate
2449 while(rate_config > 0x1)
2450 {
2451 rate_config = (rate_config>> 1);
2452 rateIndex++;
2453 }
2454 write_nic_byte(dev, INIRTSMCS_SEL, rateIndex);
2455 //HW_VAR_BASIC_RATE
2456
2457 //set ack preample
2458 regTmp = (priv->nCur40MhzPrimeSC) << 5;
2459 if (priv->short_preamble)
2460 regTmp |= 0x80;
2461 write_nic_byte(dev, RRSR+2, regTmp);
2462
2463 write_nic_dword(dev,BSSIDR,((u32*)net->bssid)[0]);
2464 write_nic_word(dev,BSSIDR+4,((u16*)net->bssid)[2]);
2465
2466 write_nic_word(dev, BCN_INTERVAL, net->beacon_interval);
2467 //2008.10.24 added by tynli for beacon changed.
2468 PHY_SetBeaconHwReg( dev, net->beacon_interval);
2469
2470 rtl8192_update_cap(dev, cap);
2471
2472 if (ieee->iw_mode == IW_MODE_ADHOC){
2473 retrylimit = 7;
2474 //we should enable ibss interrupt here, but disable it temporarily
2475 if (0){
2476 priv->irq_mask |= (IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
2477 //rtl8192_irq_disable(dev);
2478 //rtl8192_irq_enable(dev);
2479 }
2480 }
2481 else{
2482 if (0){
2483 priv->irq_mask &= ~(IMR_BcnInt | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
2484 //rtl8192_irq_disable(dev);
2485 //rtl8192_irq_enable(dev);
2486 }
2487 }
2488
2489 priv->ShortRetryLimit = priv->LongRetryLimit = retrylimit;
2490
2491 write_nic_word(dev, RETRY_LIMIT,
2492 retrylimit << RETRY_LIMIT_SHORT_SHIFT | \
2493 retrylimit << RETRY_LIMIT_LONG_SHIFT);
2494 }
2495
2496 void rtl8192SU_update_ratr_table(struct net_device* dev)
2497 {
2498 struct r8192_priv* priv = ieee80211_priv(dev);
2499 struct ieee80211_device* ieee = priv->ieee80211;
2500 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2501 //struct ieee80211_network *net = &ieee->current_network;
2502 u32 ratr_value = 0;
2503
2504 u8 rate_index = 0;
2505 int WirelessMode = ieee->mode;
2506 u8 MimoPs = ieee->pHTInfo->PeerMimoPs;
2507
2508 u8 bNMode = 0;
2509
2510 rtl8192_config_rate(dev, (u16*)(&ratr_value));
2511 ratr_value |= (*(u16*)(pMcsRate)) << 12;
2512
2513 //switch (ieee->mode)
2514 switch (WirelessMode)
2515 {
2516 case IEEE_A:
2517 ratr_value &= 0x00000FF0;
2518 break;
2519 case IEEE_B:
2520 ratr_value &= 0x0000000D;
2521 break;
2522 case IEEE_G:
2523 ratr_value &= 0x00000FF5;
2524 break;
2525 case IEEE_N_24G:
2526 case IEEE_N_5G:
2527 {
2528 bNMode = 1;
2529
2530 if (MimoPs == 0) //MIMO_PS_STATIC
2531 {
2532 ratr_value &= 0x0007F005;
2533 }
2534 else
2535 { // MCS rate only => for 11N mode.
2536 u32 ratr_mask;
2537
2538 // 1T2R or 1T1R, Spatial Stream 2 should be disabled
2539 if ( priv->rf_type == RF_1T2R ||
2540 priv->rf_type == RF_1T1R ||
2541 (ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_TX_2SS) )
2542 ratr_mask = 0x000ff005;
2543 else
2544 ratr_mask = 0x0f0ff005;
2545
2546 if((ieee->pHTInfo->bCurTxBW40MHz) &&
2547 !(ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_TX_40_MHZ))
2548 ratr_mask |= 0x00000010; // Set 6MBps
2549
2550 // Select rates for rate adaptive mechanism.
2551 ratr_value &= ratr_mask;
2552 }
2553 }
2554 break;
2555 default:
2556 if(0)
2557 {
2558 if(priv->rf_type == RF_1T2R) // 1T2R, Spatial Stream 2 should be disabled
2559 {
2560 ratr_value &= 0x000ff0f5;
2561 }
2562 else
2563 {
2564 ratr_value &= 0x0f0ff0f5;
2565 }
2566 }
2567 //printk("====>%s(), mode is not correct:%x\n", __FUNCTION__, ieee->mode);
2568 break;
2569 }
2570
2571 ratr_value &= 0x0FFFFFFF;
2572
2573 // Get MAX MCS available.
2574 if ( (bNMode && ((ieee->pHTInfo->IOTAction & HT_IOT_ACT_DISABLE_SHORT_GI)==0)) &&
2575 ((ieee->pHTInfo->bCurBW40MHz && ieee->pHTInfo->bCurShortGI40MHz) ||
2576 (!ieee->pHTInfo->bCurBW40MHz && ieee->pHTInfo->bCurShortGI20MHz)))
2577 {
2578 u8 shortGI_rate = 0;
2579 u32 tmp_ratr_value = 0;
2580 ratr_value |= 0x10000000;//???
2581 tmp_ratr_value = (ratr_value>>12);
2582 for(shortGI_rate=15; shortGI_rate>0; shortGI_rate--)
2583 {
2584 if((1<<shortGI_rate) & tmp_ratr_value)
2585 break;
2586 }
2587 shortGI_rate = (shortGI_rate<<12)|(shortGI_rate<<8)|(shortGI_rate<<4)|(shortGI_rate);
2588 write_nic_byte(dev, SG_RATE, shortGI_rate);
2589 //printk("==>SG_RATE:%x\n", read_nic_byte(dev, SG_RATE));
2590 }
2591 write_nic_dword(dev, ARFR0+rate_index*4, ratr_value);
2592 printk("=============>ARFR0+rate_index*4:%#x\n", ratr_value);
2593
2594 //2 UFWP
2595 if (ratr_value & 0xfffff000){
2596 //printk("===>set to N mode\n");
2597 HalSetFwCmd8192S(dev, FW_CMD_RA_REFRESH_N);
2598 }
2599 else {
2600 //printk("===>set to B/G mode\n");
2601 HalSetFwCmd8192S(dev, FW_CMD_RA_REFRESH_BG);
2602 }
2603 }
2604
2605 void rtl8192SU_link_change(struct net_device *dev)
2606 {
2607 struct r8192_priv *priv = ieee80211_priv(dev);
2608 struct ieee80211_device *ieee = priv->ieee80211;
2609 u32 reg = 0;
2610
2611 reg = read_nic_dword(dev, RCR);
2612 if (ieee->state == IEEE80211_LINKED) {
2613 rtl8192SU_net_update(dev);
2614 rtl8192SU_update_ratr_table(dev);
2615 ieee->SetFwCmdHandler(dev, FW_CMD_HIGH_PWR_ENABLE);
2616 priv->ReceiveConfig = reg |= RCR_CBSSID;
2617
2618 } else
2619 priv->ReceiveConfig = reg &= ~RCR_CBSSID;
2620 write_nic_dword(dev, RCR, reg);
2621 rtl8192_update_msr(dev);
2622 }
2623
2624 static struct ieee80211_qos_parameters def_qos_parameters = {
2625 {3,3,3,3},/* cw_min */
2626 {7,7,7,7},/* cw_max */
2627 {2,2,2,2},/* aifs */
2628 {0,0,0,0},/* flags */
2629 {0,0,0,0} /* tx_op_limit */
2630 };
2631
2632
2633 void rtl8192_update_beacon(struct work_struct * work)
2634 {
2635 struct r8192_priv *priv = container_of(work, struct r8192_priv, update_beacon_wq.work);
2636 struct net_device *dev = priv->ieee80211->dev;
2637 struct ieee80211_device* ieee = priv->ieee80211;
2638 struct ieee80211_network* net = &ieee->current_network;
2639
2640 if (ieee->pHTInfo->bCurrentHTSupport)
2641 HTUpdateSelfAndPeerSetting(ieee, net);
2642 ieee->pHTInfo->bCurrentRT2RTLongSlotTime = net->bssht.bdRT2RTLongSlotTime;
2643 // Joseph test for turbo mode with AP
2644 ieee->pHTInfo->RT2RT_HT_Mode = net->bssht.RT2RT_HT_Mode;
2645 rtl8192_update_cap(dev, net->capability);
2646 }
2647 /*
2648 * background support to run QoS activate functionality
2649 */
2650 int WDCAPARA_ADD[] = {EDCAPARA_BE,EDCAPARA_BK,EDCAPARA_VI,EDCAPARA_VO};
2651
2652 void rtl8192_qos_activate(struct work_struct * work)
2653 {
2654 struct r8192_priv *priv = container_of(work, struct r8192_priv, qos_activate);
2655 struct net_device *dev = priv->ieee80211->dev;
2656 struct ieee80211_qos_parameters *qos_parameters = &priv->ieee80211->current_network.qos_data.parameters;
2657 u8 mode = priv->ieee80211->current_network.mode;
2658 //u32 size = sizeof(struct ieee80211_qos_parameters);
2659 u8 u1bAIFS;
2660 u32 u4bAcParam;
2661 int i;
2662
2663 if (priv == NULL)
2664 return;
2665
2666 mutex_lock(&priv->mutex);
2667
2668 if(priv->ieee80211->state != IEEE80211_LINKED)
2669 goto success;
2670 RT_TRACE(COMP_QOS,"qos active process with associate response received\n");
2671 /* It better set slot time at first */
2672 /* For we just support b/g mode at present, let the slot time at 9/20 selection */
2673 /* update the ac parameter to related registers */
2674 for(i = 0; i < QOS_QUEUE_NUM; i++) {
2675 //Mode G/A: slotTimeTimer = 9; Mode B: 20
2676 u1bAIFS = qos_parameters->aifs[i] * ((mode&(IEEE_G|IEEE_N_24G)) ?9:20) + aSifsTime;
2677 u4bAcParam = ((((u32)(qos_parameters->tx_op_limit[i]))<< AC_PARAM_TXOP_LIMIT_OFFSET)|
2678 (((u32)(qos_parameters->cw_max[i]))<< AC_PARAM_ECW_MAX_OFFSET)|
2679 (((u32)(qos_parameters->cw_min[i]))<< AC_PARAM_ECW_MIN_OFFSET)|
2680 ((u32)u1bAIFS << AC_PARAM_AIFS_OFFSET));
2681
2682 write_nic_dword(dev, WDCAPARA_ADD[i], u4bAcParam);
2683 //write_nic_dword(dev, WDCAPARA_ADD[i], 0x005e4322);
2684 }
2685
2686 success:
2687 mutex_unlock(&priv->mutex);
2688 }
2689
2690 static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
2691 int active_network,
2692 struct ieee80211_network *network)
2693 {
2694 int ret = 0;
2695 u32 size = sizeof(struct ieee80211_qos_parameters);
2696
2697 if(priv->ieee80211->state !=IEEE80211_LINKED)
2698 return ret;
2699
2700 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2701 return ret;
2702
2703 if (network->flags & NETWORK_HAS_QOS_MASK) {
2704 if (active_network &&
2705 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
2706 network->qos_data.active = network->qos_data.supported;
2707
2708 if ((network->qos_data.active == 1) && (active_network == 1) &&
2709 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
2710 (network->qos_data.old_param_count !=
2711 network->qos_data.param_count)) {
2712 network->qos_data.old_param_count =
2713 network->qos_data.param_count;
2714 queue_work(priv->priv_wq, &priv->qos_activate);
2715 RT_TRACE (COMP_QOS, "QoS parameters change call "
2716 "qos_activate\n");
2717 }
2718 } else {
2719 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2720 &def_qos_parameters, size);
2721
2722 if ((network->qos_data.active == 1) && (active_network == 1)) {
2723 queue_work(priv->priv_wq, &priv->qos_activate);
2724 RT_TRACE(COMP_QOS, "QoS was disabled call qos_activate \n");
2725 }
2726 network->qos_data.active = 0;
2727 network->qos_data.supported = 0;
2728 }
2729
2730 return 0;
2731 }
2732
2733 /* handle manage frame frame beacon and probe response */
2734 static int rtl8192_handle_beacon(struct net_device * dev,
2735 struct ieee80211_probe_response *beacon,
2736 struct ieee80211_network *network)
2737 {
2738 struct r8192_priv *priv = ieee80211_priv(dev);
2739
2740 rtl8192_qos_handle_probe_response(priv,1,network);
2741 queue_delayed_work(priv->priv_wq, &priv->update_beacon_wq, 0);
2742
2743 return 0;
2744
2745 }
2746
2747 /*
2748 * handling the beaconing responses. if we get different QoS setting
2749 * off the network from the associated setting, adjust the QoS
2750 * setting
2751 */
2752 static int rtl8192_qos_association_resp(struct r8192_priv *priv,
2753 struct ieee80211_network *network)
2754 {
2755 int ret = 0;
2756 unsigned long flags;
2757 u32 size = sizeof(struct ieee80211_qos_parameters);
2758 int set_qos_param = 0;
2759
2760 if ((priv == NULL) || (network == NULL))
2761 return ret;
2762
2763 if(priv->ieee80211->state !=IEEE80211_LINKED)
2764 return ret;
2765
2766 if ((priv->ieee80211->iw_mode != IW_MODE_INFRA))
2767 return ret;
2768
2769 spin_lock_irqsave(&priv->ieee80211->lock, flags);
2770 if(network->flags & NETWORK_HAS_QOS_PARAMETERS) {
2771 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2772 &network->qos_data.parameters,\
2773 sizeof(struct ieee80211_qos_parameters));
2774 priv->ieee80211->current_network.qos_data.active = 1;
2775 {
2776 set_qos_param = 1;
2777 /* update qos parameter for current network */
2778 priv->ieee80211->current_network.qos_data.old_param_count = \
2779 priv->ieee80211->current_network.qos_data.param_count;
2780 priv->ieee80211->current_network.qos_data.param_count = \
2781 network->qos_data.param_count;
2782 }
2783 } else {
2784 memcpy(&priv->ieee80211->current_network.qos_data.parameters,\
2785 &def_qos_parameters, size);
2786 priv->ieee80211->current_network.qos_data.active = 0;
2787 priv->ieee80211->current_network.qos_data.supported = 0;
2788 set_qos_param = 1;
2789 }
2790
2791 spin_unlock_irqrestore(&priv->ieee80211->lock, flags);
2792
2793 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n",__FUNCTION__,network->flags ,priv->ieee80211->current_network.qos_data.active);
2794 if (set_qos_param == 1)
2795 queue_work(priv->priv_wq, &priv->qos_activate);
2796
2797 return ret;
2798 }
2799
2800
2801 static int rtl8192_handle_assoc_response(struct net_device *dev,
2802 struct ieee80211_assoc_response_frame *resp,
2803 struct ieee80211_network *network)
2804 {
2805 struct r8192_priv *priv = ieee80211_priv(dev);
2806 rtl8192_qos_association_resp(priv, network);
2807 return 0;
2808 }
2809
2810
2811 void rtl8192_update_ratr_table(struct net_device* dev)
2812 // POCTET_STRING posLegacyRate,
2813 // u8* pMcsRate)
2814 // PRT_WLAN_STA pEntry)
2815 {
2816 struct r8192_priv* priv = ieee80211_priv(dev);
2817 struct ieee80211_device* ieee = priv->ieee80211;
2818 u8* pMcsRate = ieee->dot11HTOperationalRateSet;
2819 //struct ieee80211_network *net = &ieee->current_network;
2820 u32 ratr_value = 0;
2821 u8 rate_index = 0;
2822 rtl8192_config_rate(dev, (u16*)(&ratr_value));
2823 ratr_value |= (*(u16*)(pMcsRate)) << 12;
2824 // switch (net->mode)
2825 switch (ieee->mode)
2826 {
2827 case IEEE_A:
2828 ratr_value &= 0x00000FF0;
2829 break;
2830 case IEEE_B:
2831 ratr_value &= 0x0000000F;
2832 break;
2833 case IEEE_G:
2834 ratr_value &= 0x00000FF7;
2835 break;
2836 case IEEE_N_24G:
2837 case IEEE_N_5G:
2838 if (ieee->pHTInfo->PeerMimoPs == 0) //MIMO_PS_STATIC
2839 ratr_value &= 0x0007F007;
2840 else{
2841 if (priv->rf_type == RF_1T2R)
2842 ratr_value &= 0x000FF007;
2843 else
2844 ratr_value &= 0x0F81F007;
2845 }
2846 break;
2847 default:
2848 break;
2849 }
2850 ratr_value &= 0x0FFFFFFF;
2851 if(ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI40MHz){
2852 ratr_value |= 0x80000000;
2853 }else if(!ieee->pHTInfo->bCurTxBW40MHz && ieee->pHTInfo->bCurShortGI20MHz){
2854 ratr_value |= 0x80000000;
2855 }
2856 write_nic_dword(dev, RATR0+rate_index*4, ratr_value);
2857 write_nic_byte(dev, UFWP, 1);
2858 }
2859
2860 static u8 ccmp_ie[4] = {0x00,0x50,0xf2,0x04};
2861 static u8 ccmp_rsn_ie[4] = {0x00, 0x0f, 0xac, 0x04};
2862 bool GetNmodeSupportBySecCfg8192(struct net_device*dev)
2863 {
2864 #if 1
2865 struct r8192_priv* priv = ieee80211_priv(dev);
2866 struct ieee80211_device* ieee = priv->ieee80211;
2867 struct ieee80211_network * network = &ieee->current_network;
2868 int wpa_ie_len= ieee->wpa_ie_len;
2869 struct ieee80211_crypt_data* crypt;
2870 int encrypt;
2871 return TRUE;
2872
2873 crypt = ieee->crypt[ieee->tx_keyidx];
2874 //we use connecting AP's capability instead of only security config on our driver to distinguish whether it should use N mode or G mode
2875 encrypt = (network->capability & WLAN_CAPABILITY_PRIVACY) || (ieee->host_encrypt && crypt && crypt->ops && (0 == strcmp(crypt->ops->name,"WEP")));
2876
2877 /* simply judge */
2878 if(encrypt && (wpa_ie_len == 0)) {
2879 /* wep encryption, no N mode setting */
2880 return false;
2881 // } else if((wpa_ie_len != 0)&&(memcmp(&(ieee->wpa_ie[14]),ccmp_ie,4))) {
2882 } else if((wpa_ie_len != 0)) {
2883 /* parse pairwise key type */
2884 //if((pairwisekey = WEP40)||(pairwisekey = WEP104)||(pairwisekey = TKIP))
2885 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))))
2886 return true;
2887 else
2888 return false;
2889 } else {
2890 return true;
2891 }
2892
2893 return true;
2894 #endif
2895 }
2896
2897 bool GetHalfNmodeSupportByAPs819xUsb(struct net_device* dev)
2898 {
2899 bool Reval;
2900 struct r8192_priv* priv = ieee80211_priv(dev);
2901 struct ieee80211_device* ieee = priv->ieee80211;
2902
2903 // Added by Roger, 2008.08.29.
2904 return false;
2905
2906 if(ieee->bHalfWirelessN24GMode == true)
2907 Reval = true;
2908 else
2909 Reval = false;
2910
2911 return Reval;
2912 }
2913
2914 void rtl8192_refresh_supportrate(struct r8192_priv* priv)
2915 {
2916 struct ieee80211_device* ieee = priv->ieee80211;
2917 //we donot consider set support rate for ABG mode, only HT MCS rate is set here.
2918 if (ieee->mode == WIRELESS_MODE_N_24G || ieee->mode == WIRELESS_MODE_N_5G)
2919 {
2920 memcpy(ieee->Regdot11HTOperationalRateSet, ieee->RegHTSuppRateSet, 16);
2921 //RT_DEBUG_DATA(COMP_INIT, ieee->RegHTSuppRateSet, 16);
2922 //RT_DEBUG_DATA(COMP_INIT, ieee->Regdot11HTOperationalRateSet, 16);
2923 }
2924 else
2925 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
2926 return;
2927 }
2928
2929 u8 rtl8192_getSupportedWireleeMode(struct net_device*dev)
2930 {
2931 struct r8192_priv *priv = ieee80211_priv(dev);
2932 u8 ret = 0;
2933 switch(priv->rf_chip)
2934 {
2935 case RF_8225:
2936 case RF_8256:
2937 case RF_PSEUDO_11N:
2938 case RF_6052:
2939 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G|WIRELESS_MODE_B);
2940 break;
2941 case RF_8258:
2942 ret = (WIRELESS_MODE_A|WIRELESS_MODE_N_5G);
2943 break;
2944 default:
2945 ret = WIRELESS_MODE_B;
2946 break;
2947 }
2948 return ret;
2949 }
2950 void rtl8192_SetWirelessMode(struct net_device* dev, u8 wireless_mode)
2951 {
2952 struct r8192_priv *priv = ieee80211_priv(dev);
2953 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
2954
2955 #if 1
2956 if ((wireless_mode == WIRELESS_MODE_AUTO) || ((wireless_mode&bSupportMode)==0))
2957 {
2958 if(bSupportMode & WIRELESS_MODE_N_24G)
2959 {
2960 wireless_mode = WIRELESS_MODE_N_24G;
2961 }
2962 else if(bSupportMode & WIRELESS_MODE_N_5G)
2963 {
2964 wireless_mode = WIRELESS_MODE_N_5G;
2965 }
2966 else if((bSupportMode & WIRELESS_MODE_A))
2967 {
2968 wireless_mode = WIRELESS_MODE_A;
2969 }
2970 else if((bSupportMode & WIRELESS_MODE_G))
2971 {
2972 wireless_mode = WIRELESS_MODE_G;
2973 }
2974 else if((bSupportMode & WIRELESS_MODE_B))
2975 {
2976 wireless_mode = WIRELESS_MODE_B;
2977 }
2978 else{
2979 RT_TRACE(COMP_ERR, "%s(), No valid wireless mode supported, SupportedWirelessMode(%x)!!!\n", __FUNCTION__,bSupportMode);
2980 wireless_mode = WIRELESS_MODE_B;
2981 }
2982 }
2983 #ifdef TO_DO_LIST //// TODO: this function doesn't work well at this time, we should wait for FPGA
2984 ActUpdateChannelAccessSetting( pAdapter, pHalData->CurrentWirelessMode, &pAdapter->MgntInfo.Info8185.ChannelAccessSetting );
2985 #endif
2986 //LZM 090306 usb crash here, mark it temp
2987 //write_nic_word(dev, SIFS_OFDM, 0x0e0e);
2988 priv->ieee80211->mode = wireless_mode;
2989
2990 if ((wireless_mode == WIRELESS_MODE_N_24G) || (wireless_mode == WIRELESS_MODE_N_5G))
2991 priv->ieee80211->pHTInfo->bEnableHT = 1;
2992 else
2993 priv->ieee80211->pHTInfo->bEnableHT = 0;
2994 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
2995 rtl8192_refresh_supportrate(priv);
2996 #endif
2997
2998 }
2999
3000
3001 short rtl8192_is_tx_queue_empty(struct net_device *dev)
3002 {
3003 int i=0;
3004 struct r8192_priv *priv = ieee80211_priv(dev);
3005 //struct ieee80211_device* ieee = priv->ieee80211;
3006 for (i=0; i<=MGNT_QUEUE; i++)
3007 {
3008 if ((i== TXCMD_QUEUE) || (i == HCCA_QUEUE) )
3009 continue;
3010 if (atomic_read(&priv->tx_pending[i]))
3011 {
3012 printk("===>tx queue is not empty:%d, %d\n", i, atomic_read(&priv->tx_pending[i]));
3013 return 0;
3014 }
3015 }
3016 return 1;
3017 }
3018
3019 void rtl8192_hw_sleep_down(struct net_device *dev)
3020 {
3021 RT_TRACE(COMP_POWER, "%s()============>come to sleep down\n", __FUNCTION__);
3022 #ifdef TODO
3023 // MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
3024 #endif
3025 }
3026
3027 void rtl8192_hw_sleep_wq (struct work_struct *work)
3028 {
3029 // struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
3030 // struct ieee80211_device * ieee = (struct ieee80211_device*)
3031 // container_of(work, struct ieee80211_device, watch_dog_wq);
3032 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
3033 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_sleep_wq);
3034 struct net_device *dev = ieee->dev;
3035
3036 //printk("=========>%s()\n", __FUNCTION__);
3037 rtl8192_hw_sleep_down(dev);
3038 }
3039 // printk("dev is %d\n",dev);
3040 // printk("&*&(^*(&(&=========>%s()\n", __FUNCTION__);
3041 void rtl8192_hw_wakeup(struct net_device* dev)
3042 {
3043 // u32 flags = 0;
3044
3045 // spin_lock_irqsave(&priv->ps_lock,flags);
3046 RT_TRACE(COMP_POWER, "%s()============>come to wake up\n", __FUNCTION__);
3047 #ifdef TODO
3048 // MgntActSet_RF_State(dev, eRfSleep, RF_CHANGE_BY_PS);
3049 #endif
3050 //FIXME: will we send package stored while nic is sleep?
3051 // spin_unlock_irqrestore(&priv->ps_lock,flags);
3052 }
3053
3054 void rtl8192_hw_wakeup_wq (struct work_struct *work)
3055 {
3056 // struct r8180_priv *priv = container_of(work, struct r8180_priv, watch_dog_wq);
3057 // struct ieee80211_device * ieee = (struct ieee80211_device*)
3058 // container_of(work, struct ieee80211_device, watch_dog_wq);
3059 struct delayed_work *dwork = container_of(work,struct delayed_work,work);
3060 struct ieee80211_device *ieee = container_of(dwork,struct ieee80211_device,hw_wakeup_wq);
3061 struct net_device *dev = ieee->dev;
3062
3063 rtl8192_hw_wakeup(dev);
3064 }
3065
3066 #define MIN_SLEEP_TIME 50
3067 #define MAX_SLEEP_TIME 10000
3068 void rtl8192_hw_to_sleep(struct net_device *dev, u32 th, u32 tl)
3069 {
3070
3071 struct r8192_priv *priv = ieee80211_priv(dev);
3072
3073 u32 rb = jiffies;
3074 unsigned long flags;
3075
3076 spin_lock_irqsave(&priv->ps_lock,flags);
3077
3078 /* Writing HW register with 0 equals to disable
3079 * the timer, that is not really what we want
3080 */
3081 tl -= MSECS(4+16+7);
3082
3083 //if(tl == 0) tl = 1;
3084
3085 /* FIXME HACK FIXME HACK */
3086 // force_pci_posting(dev);
3087 //mdelay(1);
3088
3089 // rb = read_nic_dword(dev, TSFTR);
3090
3091 /* If the interval in witch we are requested to sleep is too
3092 * short then give up and remain awake
3093 */
3094 if(((tl>=rb)&& (tl-rb) <= MSECS(MIN_SLEEP_TIME))
3095 ||((rb>tl)&& (rb-tl) < MSECS(MIN_SLEEP_TIME))) {
3096 spin_unlock_irqrestore(&priv->ps_lock,flags);
3097 printk("too short to sleep\n");
3098 return;
3099 }
3100
3101 // write_nic_dword(dev, TimerInt, tl);
3102 // rb = read_nic_dword(dev, TSFTR);
3103 {
3104 u32 tmp = (tl>rb)?(tl-rb):(rb-tl);
3105 // if (tl<rb)
3106
3107 queue_delayed_work(priv->ieee80211->wq, &priv->ieee80211->hw_wakeup_wq, tmp); //as tl may be less than rb
3108 }
3109 /* if we suspect the TimerInt is gone beyond tl
3110 * while setting it, then give up
3111 */
3112 #if 1
3113 if(((tl > rb) && ((tl-rb) > MSECS(MAX_SLEEP_TIME)))||
3114 ((tl < rb) && ((rb-tl) > MSECS(MAX_SLEEP_TIME)))) {
3115 printk("========>too long to sleep:%x, %x, %lx\n", tl, rb, MSECS(MAX_SLEEP_TIME));
3116 spin_unlock_irqrestore(&priv->ps_lock,flags);
3117 return;
3118 }
3119 #endif
3120 // if(priv->rf_sleep)
3121 // priv->rf_sleep(dev);
3122
3123 //printk("<=========%s()\n", __FUNCTION__);
3124 queue_delayed_work(priv->ieee80211->wq, (void *)&priv->ieee80211->hw_sleep_wq,0);
3125
3126 spin_unlock_irqrestore(&priv->ps_lock,flags);
3127 }
3128 //init priv variables here. only non_zero value should be initialized here.
3129 static void rtl8192_init_priv_variable(struct net_device* dev)
3130 {
3131 struct r8192_priv *priv = ieee80211_priv(dev);
3132 u8 i;
3133 priv->card_8192 = NIC_8192U;
3134 priv->chan = 1; //set to channel 1
3135 priv->ieee80211->mode = WIRELESS_MODE_AUTO; //SET AUTO
3136 priv->ieee80211->iw_mode = IW_MODE_INFRA;
3137 priv->ieee80211->ieee_up=0;
3138 priv->retry_rts = DEFAULT_RETRY_RTS;
3139 priv->retry_data = DEFAULT_RETRY_DATA;
3140 priv->ieee80211->rts = DEFAULT_RTS_THRESHOLD;
3141 priv->ieee80211->rate = 110; //11 mbps
3142 priv->ieee80211->short_slot = 1;
3143 priv->promisc = (dev->flags & IFF_PROMISC) ? 1:0;
3144 priv->CckPwEnl = 6;
3145 //for silent reset
3146 priv->IrpPendingCount = 1;
3147 priv->ResetProgress = RESET_TYPE_NORESET;
3148 priv->bForcedSilentReset = 0;
3149 priv->bDisableNormalResetCheck = false;
3150 priv->force_reset = false;
3151
3152 priv->ieee80211->FwRWRF = 0; //we don't use FW read/write RF until stable firmware is available.
3153 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
3154 priv->ieee80211->iw_mode = IW_MODE_INFRA;
3155 priv->ieee80211->softmac_features = IEEE_SOFTMAC_SCAN |
3156 IEEE_SOFTMAC_ASSOCIATE | IEEE_SOFTMAC_PROBERQ |
3157 IEEE_SOFTMAC_PROBERS | IEEE_SOFTMAC_TX_QUEUE |
3158 IEEE_SOFTMAC_BEACONS;//added by amy 080604 //| //IEEE_SOFTMAC_SINGLE_QUEUE;
3159
3160 priv->ieee80211->active_scan = 1;
3161 priv->ieee80211->modulation = IEEE80211_CCK_MODULATION | IEEE80211_OFDM_MODULATION;
3162 priv->ieee80211->host_encrypt = 1;
3163 priv->ieee80211->host_decrypt = 1;
3164 priv->ieee80211->start_send_beacons = NULL;//rtl819xusb_beacon_tx;//-by amy 080604
3165 priv->ieee80211->stop_send_beacons = NULL;//rtl8192_beacon_stop;//-by amy 080604
3166 priv->ieee80211->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
3167 priv->ieee80211->set_chan = rtl8192_set_chan;
3168 priv->ieee80211->link_change = priv->ops->rtl819x_link_change;
3169 priv->ieee80211->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
3170 priv->ieee80211->data_hard_stop = rtl8192_data_hard_stop;
3171 priv->ieee80211->data_hard_resume = rtl8192_data_hard_resume;
3172 priv->ieee80211->init_wmmparam_flag = 0;
3173 priv->ieee80211->fts = DEFAULT_FRAG_THRESHOLD;
3174 priv->ieee80211->check_nic_enough_desc = check_nic_enough_desc;
3175 priv->ieee80211->tx_headroom = TX_PACKET_SHIFT_BYTES;
3176 priv->ieee80211->qos_support = 1;
3177
3178 //added by WB
3179 // priv->ieee80211->SwChnlByTimerHandler = rtl8192_phy_SwChnl;
3180 priv->ieee80211->SetBWModeHandler = rtl8192_SetBWMode;
3181 priv->ieee80211->handle_assoc_response = rtl8192_handle_assoc_response;
3182 priv->ieee80211->handle_beacon = rtl8192_handle_beacon;
3183 //for LPS
3184 priv->ieee80211->sta_wake_up = rtl8192_hw_wakeup;
3185 // priv->ieee80211->ps_request_tx_ack = rtl8192_rq_tx_ack;
3186 priv->ieee80211->enter_sleep_state = rtl8192_hw_to_sleep;
3187 priv->ieee80211->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
3188 //added by david
3189 priv->ieee80211->GetNmodeSupportBySecCfg = GetNmodeSupportBySecCfg8192;
3190 priv->ieee80211->GetHalfNmodeSupportByAPsHandler = GetHalfNmodeSupportByAPs819xUsb;
3191 priv->ieee80211->SetWirelessMode = rtl8192_SetWirelessMode;
3192 //added by amy
3193 priv->ieee80211->InitialGainHandler = priv->ops->rtl819x_initial_gain;
3194 priv->card_type = USB;
3195
3196 //1 RTL8192SU/
3197 priv->ieee80211->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
3198 priv->ieee80211->SetFwCmdHandler = HalSetFwCmd8192S;
3199 priv->bRFSiOrPi = 0;//o=si,1=pi;
3200 //lzm add
3201 priv->bInHctTest = false;
3202
3203 priv->MidHighPwrTHR_L1 = 0x3B;
3204 priv->MidHighPwrTHR_L2 = 0x40;
3205
3206 if(priv->bInHctTest)
3207 {
3208 priv->ShortRetryLimit = HAL_RETRY_LIMIT_AP_ADHOC;
3209 priv->LongRetryLimit = HAL_RETRY_LIMIT_AP_ADHOC;
3210 }
3211 else
3212 {
3213 priv->ShortRetryLimit = HAL_RETRY_LIMIT_INFRA;
3214 priv->LongRetryLimit = HAL_RETRY_LIMIT_INFRA;
3215 }
3216
3217 priv->SetFwCmdInProgress = false; //is set FW CMD in Progress? 92S only
3218 priv->CurrentFwCmdIO = 0;
3219
3220 priv->MinSpaceCfg = 0;
3221
3222 priv->EarlyRxThreshold = 7;
3223 priv->enable_gpio0 = 0;
3224 priv->TransmitConfig =
3225 ((u32)TCR_MXDMA_2048<<TCR_MXDMA_OFFSET) | // Max DMA Burst Size per Tx DMA Burst, 7: reservied.
3226 (priv->ShortRetryLimit<<TCR_SRL_OFFSET) | // Short retry limit
3227 (priv->LongRetryLimit<<TCR_LRL_OFFSET) | // Long retry limit
3228 (false ? TCR_SAT : 0); // FALSE: HW provies PLCP length and LENGEXT, TURE: SW proiveds them
3229 if(priv->bInHctTest)
3230 priv->ReceiveConfig = //priv->CSMethod |
3231 RCR_AMF | RCR_ADF | //RCR_AAP | //accept management/data
3232 RCR_ACF |RCR_APPFCS| //accept control frame for SW AP needs PS-poll, 2005.07.07, by rcnjko.
3233 RCR_AB | RCR_AM | RCR_APM | //accept BC/MC/UC
3234 RCR_AICV | RCR_ACRC32 | //accept ICV/CRC error packet
3235 RCR_APP_PHYST_STAFF | RCR_APP_PHYST_RXFF | // Accept PHY status
3236 ((u32)7<<RCR_MXDMA_OFFSET) | // Max DMA Burst Size per Rx DMA Burst, 7: unlimited.
3237 (priv->EarlyRxThreshold<<RCR_FIFO_OFFSET) | // Rx FIFO Threshold, 7: No Rx threshold.
3238 (priv->EarlyRxThreshold == 7 ? RCR_OnlyErlPkt:0);
3239 else
3240 priv->ReceiveConfig = //priv->CSMethod |
3241 RCR_AMF | RCR_ADF | RCR_AB |
3242 RCR_AM | RCR_APM |RCR_AAP |RCR_ADD3|RCR_APP_ICV|
3243 RCR_APP_PHYST_STAFF | RCR_APP_PHYST_RXFF | // Accept PHY status
3244 RCR_APP_MIC | RCR_APPFCS;
3245
3246 // <Roger_EXP> 2008.06.16.
3247 priv->IntrMask = (u16)(IMR_ROK | IMR_VODOK | IMR_VIDOK | IMR_BEDOK | IMR_BKDOK | \
3248 IMR_HCCADOK | IMR_MGNTDOK | IMR_COMDOK | IMR_HIGHDOK | \
3249 IMR_BDOK | IMR_RXCMDOK | /*IMR_TIMEOUT0 |*/ IMR_RDU | IMR_RXFOVW | \
3250 IMR_TXFOVW | IMR_BcnInt | IMR_TBDOK | IMR_TBDER);
3251
3252 //1 End
3253
3254
3255 priv->AcmControl = 0;
3256 priv->pFirmware = (rt_firmware*)vmalloc(sizeof(rt_firmware));
3257 if (priv->pFirmware)
3258 memset(priv->pFirmware, 0, sizeof(rt_firmware));
3259
3260 /* rx related queue */
3261 skb_queue_head_init(&priv->rx_queue);
3262 skb_queue_head_init(&priv->skb_queue);
3263
3264 /* Tx related queue */
3265 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
3266 skb_queue_head_init(&priv->ieee80211->skb_waitQ [i]);
3267 }
3268 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
3269 skb_queue_head_init(&priv->ieee80211->skb_aggQ [i]);
3270 }
3271 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
3272 skb_queue_head_init(&priv->ieee80211->skb_drv_aggQ [i]);
3273 }
3274 priv->rf_set_chan = rtl8192_phy_SwChnl;
3275 }
3276
3277 //init lock here
3278 static void rtl8192_init_priv_lock(struct r8192_priv* priv)
3279 {
3280 spin_lock_init(&priv->tx_lock);
3281 spin_lock_init(&priv->irq_lock);//added by thomas
3282 //spin_lock_init(&priv->rf_lock);//use rf_sem, or will crash in some OS.
3283 sema_init(&priv->wx_sem,1);
3284 sema_init(&priv->rf_sem,1);
3285 spin_lock_init(&priv->ps_lock);
3286 mutex_init(&priv->mutex);
3287 }
3288
3289 extern void rtl819x_watchdog_wqcallback(struct work_struct *work);
3290
3291 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv);
3292 //init tasklet and wait_queue here. only 2.6 above kernel is considered
3293 #define DRV_NAME "wlan0"
3294 static void rtl8192_init_priv_task(struct net_device* dev)
3295 {
3296 struct r8192_priv *priv = ieee80211_priv(dev);
3297
3298 #ifdef PF_SYNCTHREAD
3299 priv->priv_wq = create_workqueue(DRV_NAME,0);
3300 #else
3301 priv->priv_wq = create_workqueue(DRV_NAME);
3302 #endif
3303
3304 INIT_WORK(&priv->reset_wq, rtl8192_restart);
3305
3306 //INIT_DELAYED_WORK(&priv->watch_dog_wq, hal_dm_watchdog);
3307 INIT_DELAYED_WORK(&priv->watch_dog_wq, rtl819x_watchdog_wqcallback);
3308 INIT_DELAYED_WORK(&priv->txpower_tracking_wq, dm_txpower_trackingcallback);
3309 // INIT_DELAYED_WORK(&priv->gpio_change_rf_wq, dm_gpio_change_rf_callback);
3310 INIT_DELAYED_WORK(&priv->rfpath_check_wq, dm_rf_pathcheck_workitemcallback);
3311 INIT_DELAYED_WORK(&priv->update_beacon_wq, rtl8192_update_beacon);
3312 INIT_DELAYED_WORK(&priv->initialgain_operate_wq, InitialGainOperateWorkItemCallBack);
3313 //INIT_WORK(&priv->SwChnlWorkItem, rtl8192_SwChnl_WorkItem);
3314 //INIT_WORK(&priv->SetBWModeWorkItem, rtl8192_SetBWModeWorkItem);
3315 INIT_WORK(&priv->qos_activate, rtl8192_qos_activate);
3316 INIT_DELAYED_WORK(&priv->ieee80211->hw_wakeup_wq,(void*) rtl8192_hw_wakeup_wq);
3317 INIT_DELAYED_WORK(&priv->ieee80211->hw_sleep_wq,(void*) rtl8192_hw_sleep_wq);
3318
3319 tasklet_init(&priv->irq_rx_tasklet,
3320 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
3321 (unsigned long)priv);
3322 }
3323
3324 //used to swap endian. as ntohl & htonl are not neccessary to swap endian, so use this instead.
3325 static inline u16 endian_swap(u16* data)
3326 {
3327 u16 tmp = *data;
3328 *data = (tmp >> 8) | (tmp << 8);
3329 return *data;
3330 }
3331
3332 u8 rtl8192SU_UsbOptionToEndPointNumber(u8 UsbOption)
3333 {
3334 u8 nEndPoint = 0;
3335 switch(UsbOption)
3336 {
3337 case 0:
3338 nEndPoint = 6;
3339 break;
3340 case 1:
3341 nEndPoint = 11;
3342 break;
3343 case 2:
3344 nEndPoint = 4;
3345 break;
3346 default:
3347 RT_TRACE(COMP_INIT, "UsbOptionToEndPointNumber(): Invalid UsbOption(%#x)\n", UsbOption);
3348 break;
3349 }
3350 return nEndPoint;
3351 }
3352
3353 u8 rtl8192SU_BoardTypeToRFtype(struct net_device* dev, u8 Boardtype)
3354 {
3355 u8 RFtype = RF_1T2R;
3356
3357 switch(Boardtype)
3358 {
3359 case 0:
3360 RFtype = RF_1T1R;
3361 break;
3362 case 1:
3363 RFtype = RF_1T2R;
3364 break;
3365 case 2:
3366 RFtype = RF_2T2R;
3367 break;
3368 case 3:
3369 RFtype = RF_2T2R_GREEN;
3370 break;
3371 default:
3372 break;
3373 }
3374
3375 return RFtype;
3376 }
3377
3378 void update_hal_variables(struct r8192_priv *priv)
3379 {
3380 int rf_path;
3381 int i;
3382 u8 index;
3383
3384 for (rf_path = 0; rf_path < 2; rf_path++) {
3385 for (i = 0; i < 3; i++) {
3386 RT_TRACE((COMP_INIT), "CCK RF-%d CHan_Area-%d = 0x%x\n", rf_path, i, priv->RfCckChnlAreaTxPwr[rf_path][i]);
3387 RT_TRACE((COMP_INIT), "OFDM-1T RF-%d CHan_Area-%d = 0x%x\n", rf_path, i, priv->RfOfdmChnlAreaTxPwr1T[rf_path][i]);
3388 RT_TRACE((COMP_INIT), "OFDM-2T RF-%d CHan_Area-%d = 0x%x\n", rf_path, i, priv->RfOfdmChnlAreaTxPwr2T[rf_path][i]);
3389 }
3390 /* Assign dedicated channel tx power */
3391 for(i = 0; i < 14; i++) {
3392 /* channel 1-3 use the same Tx Power Level. */
3393 if (i < 3) /* Channel 1-3 */
3394 index = 0;
3395 else if (i < 9) /* Channel 4-9 */
3396 index = 1;
3397 else /* Channel 10-14 */
3398 index = 2;
3399 /* Record A & B CCK /OFDM - 1T/2T Channel area tx power */
3400 priv->RfTxPwrLevelCck[rf_path][i] = priv->RfCckChnlAreaTxPwr[rf_path][index];
3401 priv->RfTxPwrLevelOfdm1T[rf_path][i] = priv->RfOfdmChnlAreaTxPwr1T[rf_path][index];
3402 priv->RfTxPwrLevelOfdm2T[rf_path][i] = priv->RfOfdmChnlAreaTxPwr2T[rf_path][index];
3403 if (rf_path == 0) {
3404 priv->TxPowerLevelOFDM24G[i] = priv->RfTxPwrLevelOfdm1T[rf_path][i] ;
3405 priv->TxPowerLevelCCK[i] = priv->RfTxPwrLevelCck[rf_path][i];
3406 }
3407 }
3408 for(i = 0; i < 14; i++) {
3409 RT_TRACE((COMP_INIT),
3410 "Rf-%d TxPwr CH-%d CCK OFDM_1T OFDM_2T= 0x%x/0x%x/0x%x\n",
3411 rf_path, i, priv->RfTxPwrLevelCck[rf_path][i],
3412 priv->RfTxPwrLevelOfdm1T[rf_path][i] ,
3413 priv->RfTxPwrLevelOfdm2T[rf_path][i] );
3414 }
3415 }
3416 }
3417
3418 /*
3419 * Description:
3420 * Config HW adapter information into initial value.
3421 *
3422 * Assumption:
3423 * 1. After Auto load fail(i.e, check CR9346 fail)
3424 *
3425 */
3426 void rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(struct net_device *dev)
3427 {
3428 struct r8192_priv *priv = ieee80211_priv(dev);
3429 u8 rf_path; /* For EEPROM/EFUSE After V0.6_1117 */
3430 int i;
3431
3432 RT_TRACE(COMP_INIT, "====> ConfigAdapterInfo8192SForAutoLoadFail\n");
3433
3434 /* Isolation signals from Loader */
3435 write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8);
3436 mdelay(10);
3437 write_nic_byte(dev, PMC_FSM, 0x02); /* Enable Loader Data Keep */
3438
3439 /* Initialize IC Version && Channel Plan */
3440 priv->eeprom_vid = 0;
3441 priv->eeprom_pid = 0;
3442 priv->card_8192_version = 0;
3443 priv->eeprom_ChannelPlan = 0;
3444 priv->eeprom_CustomerID = 0;
3445 priv->eeprom_SubCustomerID = 0;
3446 priv->bIgnoreDiffRateTxPowerOffset = false;
3447
3448 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
3449 RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid);
3450 RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n",
3451 priv->eeprom_CustomerID);
3452 RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n",
3453 priv->eeprom_SubCustomerID);
3454 RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n",
3455 priv->eeprom_ChannelPlan);
3456 RT_TRACE(COMP_INIT, "IgnoreDiffRateTxPowerOffset = %d\n",
3457 priv->bIgnoreDiffRateTxPowerOffset);
3458
3459 priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC;
3460 RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption);
3461
3462 for(i=0; i<5; i++)
3463 priv->EEPROMUsbPhyParam[i] = EEPROM_USB_Default_PHY_PARAM;
3464
3465 {
3466 /*
3467 * In this case, we randomly assign a MAC address here.
3468 */
3469 static u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0x81, 0x92, 0x00};
3470 for(i = 0; i < 6; i++)
3471 dev->dev_addr[i] = sMacAddr[i];
3472 }
3473 /* NicIFSetMacAddress(Adapter, Adapter->PermanentAddress); */
3474 write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
3475 write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
3476
3477 RT_TRACE(COMP_INIT,
3478 "ReadAdapterInfo8192SEFuse(), Permanent Address = %pM\n",
3479 dev->dev_addr);
3480
3481 priv->EEPROMBoardType = EEPROM_Default_BoardType;
3482 priv->rf_type = RF_1T2R; /* RF_2T2R */
3483 priv->EEPROMTxPowerDiff = EEPROM_Default_PwDiff;
3484 priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
3485 priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
3486 priv->EEPROMTxPwrBase = EEPROM_Default_TxPowerBase;
3487 priv->EEPROMTSSI_A = EEPROM_Default_TSSI;
3488 priv->EEPROMTSSI_B = EEPROM_Default_TSSI;
3489 priv->EEPROMTxPwrTkMode = EEPROM_Default_TxPwrTkMode;
3490
3491 for (rf_path = 0; rf_path < 2; rf_path++)
3492 {
3493 for (i = 0; i < 3; i++)
3494 {
3495 /* Read CCK RF A & B Tx power */
3496 priv->RfCckChnlAreaTxPwr[rf_path][i] =
3497 priv->RfOfdmChnlAreaTxPwr1T[rf_path][i] =
3498 priv->RfOfdmChnlAreaTxPwr2T[rf_path][i] =
3499 (u8)(EEPROM_Default_TxPower & 0xff);
3500 }
3501 }
3502
3503 update_hal_variables(priv);
3504
3505 /*
3506 * Update remaining HAL variables.
3507 */
3508 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
3509 priv->LegacyHTTxPowerDiff = priv->EEPROMTxPowerDiff; /* new */
3510 priv->TxPowerDiff = priv->EEPROMTxPowerDiff;
3511 /* Antenna B gain offset to antenna A, bit0~3 */
3512 /* priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf); */
3513 /* Antenna C gain offset to antenna A, bit4~7 */
3514 /* priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4); */
3515 /* CrystalCap, bit12~15 */
3516 priv->CrystalCap = priv->EEPROMCrystalCap;
3517 /* ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2 */
3518 priv->ThermalMeter[0] = priv->EEPROMThermalMeter;
3519 priv->LedStrategy = SW_LED_MODE0;
3520
3521 init_rate_adaptive(dev);
3522
3523 RT_TRACE(COMP_INIT, "<==== ConfigAdapterInfo8192SForAutoLoadFail\n");
3524 }
3525
3526 /*
3527 * Description:
3528 * Read HW adapter information by E-Fuse
3529 * or EEPROM according CR9346 reported.
3530 *
3531 * Assumption:
3532 * 1. CR9346 regiser has verified.
3533 * 2. PASSIVE_LEVEL (USB interface)
3534 */
3535 void rtl8192SU_ReadAdapterInfo8192SUsb(struct net_device *dev)
3536 {
3537 struct r8192_priv *priv = ieee80211_priv(dev);
3538 u16 i;
3539 u8 tmpU1b, tempval;
3540 u16 EEPROMId;
3541 u8 hwinfo[HWSET_MAX_SIZE_92S];
3542 u8 rf_path, index; /* For EEPROM/EFUSE After V0.6_1117 */
3543 struct eeprom_93cx6 eeprom;
3544 u16 eeprom_val;
3545
3546 eeprom.data = dev;
3547 eeprom.register_read = rtl819x_eeprom_register_read;
3548 eeprom.register_write = rtl819x_eeprom_register_write;
3549 eeprom.width = PCI_EEPROM_WIDTH_93C46;
3550
3551 /*
3552 * The following operation are prevent Efuse leakage by turn on 2.5V.
3553 */
3554 tmpU1b = read_nic_byte(dev, EFUSE_TEST+3);
3555 write_nic_byte(dev, EFUSE_TEST+3, tmpU1b|0x80);
3556 mdelay(10);
3557 write_nic_byte(dev, EFUSE_TEST+3, (tmpU1b&(~BIT7)));
3558
3559 /* Retrieve Chip version. */
3560 priv->card_8192_version = (VERSION_8192S)((read_nic_dword(dev, PMC_FSM)>>16)&0xF);
3561 RT_TRACE(COMP_INIT, "Chip Version ID: 0x%2x\n", priv->card_8192_version);
3562
3563 switch (priv->card_8192_version) {
3564 case 0:
3565 RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_ACUT.\n");
3566 break;
3567 case 1:
3568 RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_BCUT.\n");
3569 break;
3570 case 2:
3571 RT_TRACE(COMP_INIT, "Chip Version ID: VERSION_8192S_CCUT.\n");
3572 break;
3573 default:
3574 RT_TRACE(COMP_INIT, "Unknown Chip Version!!\n");
3575 priv->card_8192_version = VERSION_8192S_BCUT;
3576 break;
3577 }
3578
3579 if (priv->EepromOrEfuse) { /* Read from EEPROM */
3580 /* Isolation signals from Loader */
3581 write_nic_byte(dev, SYS_ISO_CTRL+1, 0xE8);
3582 mdelay(10);
3583 /* Enable Loader Data Keep */
3584 write_nic_byte(dev, PMC_FSM, 0x02);
3585 /* Read all Content from EEPROM or EFUSE. */
3586 for (i = 0; i < HWSET_MAX_SIZE_92S; i += 2) {
3587 eeprom_93cx6_read(&eeprom, (u16) (i>>1), &eeprom_val);
3588 *((u16 *)(&hwinfo[i])) = eeprom_val;
3589 }
3590 } else if (!(priv->EepromOrEfuse)) { /* Read from EFUSE */
3591 /* Read EFUSE real map to shadow. */
3592 EFUSE_ShadowMapUpdate(dev);
3593 memcpy(hwinfo, &priv->EfuseMap[EFUSE_INIT_MAP][0], HWSET_MAX_SIZE_92S);
3594 } else {
3595 RT_TRACE(COMP_INIT, "%s(): Invalid boot type", __func__);
3596 }
3597
3598 /*
3599 * Even though CR9346 regiser can verify whether Autoload
3600 * is success or not, but we still double check ID codes for 92S here
3601 * (e.g., due to HW GPIO polling fail issue)
3602 */
3603 EEPROMId = *((u16 *)&hwinfo[0]);
3604 if (EEPROMId != RTL8190_EEPROM_ID) {
3605 RT_TRACE(COMP_INIT, "ID(%#x) is invalid!!\n", EEPROMId);
3606 priv->bTXPowerDataReadFromEEPORM = FALSE;
3607 priv->AutoloadFailFlag=TRUE;
3608 } else {
3609 priv->AutoloadFailFlag=FALSE;
3610 priv->bTXPowerDataReadFromEEPORM = TRUE;
3611 }
3612 /* Read IC Version && Channel Plan */
3613 if (!priv->AutoloadFailFlag) {
3614 /* VID, PID */
3615 priv->eeprom_vid = *(u16 *)&hwinfo[EEPROM_VID];
3616 priv->eeprom_pid = *(u16 *)&hwinfo[EEPROM_PID];
3617 priv->bIgnoreDiffRateTxPowerOffset = false; //cosa for test
3618
3619
3620 /* EEPROM Version ID, Channel plan */
3621 priv->EEPROMVersion = *(u8 *)&hwinfo[EEPROM_Version];
3622 priv->eeprom_ChannelPlan = *(u8 *)&hwinfo[EEPROM_ChannelPlan];
3623
3624 /* Customer ID, 0x00 and 0xff are reserved for Realtek. */
3625 priv->eeprom_CustomerID = *(u8 *)&hwinfo[EEPROM_CustomID];
3626 priv->eeprom_SubCustomerID = *(u8 *)&hwinfo[EEPROM_SubCustomID];
3627 } else {
3628 rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(dev);
3629 return;
3630 }
3631
3632 RT_TRACE(COMP_INIT, "EEPROM Id = 0x%4x\n", EEPROMId);
3633 RT_TRACE(COMP_INIT, "EEPROM VID = 0x%4x\n", priv->eeprom_vid);
3634 RT_TRACE(COMP_INIT, "EEPROM PID = 0x%4x\n", priv->eeprom_pid);
3635 RT_TRACE(COMP_INIT, "EEPROM Version ID: 0x%2x\n", priv->EEPROMVersion);
3636 RT_TRACE(COMP_INIT, "EEPROM Customer ID: 0x%2x\n", priv->eeprom_CustomerID);
3637 RT_TRACE(COMP_INIT, "EEPROM SubCustomer ID: 0x%2x\n", priv->eeprom_SubCustomerID);
3638 RT_TRACE(COMP_INIT, "EEPROM ChannelPlan = 0x%4x\n", priv->eeprom_ChannelPlan);
3639 RT_TRACE(COMP_INIT, "bIgnoreDiffRateTxPowerOffset = %d\n", priv->bIgnoreDiffRateTxPowerOffset);
3640
3641 /* Read USB optional function. */
3642 if (!priv->AutoloadFailFlag) {
3643 priv->EEPROMUsbOption = *(u8 *)&hwinfo[EEPROM_USB_OPTIONAL];
3644 } else {
3645 priv->EEPROMUsbOption = EEPROM_USB_Default_OPTIONAL_FUNC;
3646 }
3647
3648 priv->EEPROMUsbEndPointNumber = rtl8192SU_UsbOptionToEndPointNumber((priv->EEPROMUsbOption&EEPROM_EP_NUMBER)>>3);
3649
3650 RT_TRACE(COMP_INIT, "USB Option = %#x\n", priv->EEPROMUsbOption);
3651 RT_TRACE(COMP_INIT, "EndPoint Number = %#x\n", priv->EEPROMUsbEndPointNumber);
3652
3653 #ifdef TO_DO_LIST
3654 //
3655 // Decide CustomerID according to VID/DID or EEPROM
3656 //
3657 switch(pHalData->EEPROMCustomerID)
3658 {
3659 case EEPROM_CID_ALPHA:
3660 pMgntInfo->CustomerID = RT_CID_819x_ALPHA;
3661 break;
3662
3663 case EEPROM_CID_CAMEO:
3664 pMgntInfo->CustomerID = RT_CID_819x_CAMEO;
3665 break;
3666
3667 case EEPROM_CID_SITECOM:
3668 pMgntInfo->CustomerID = RT_CID_819x_Sitecom;
3669 RT_TRACE(COMP_INIT, DBG_LOUD, ("CustomerID = 0x%4x\n", pMgntInfo->CustomerID));
3670
3671 break;
3672
3673 case EEPROM_CID_WHQL:
3674 Adapter->bInHctTest = TRUE;
3675
3676 pMgntInfo->bSupportTurboMode = FALSE;
3677 pMgntInfo->bAutoTurboBy8186 = FALSE;
3678
3679 pMgntInfo->PowerSaveControl.bInactivePs = FALSE;
3680 pMgntInfo->PowerSaveControl.bIPSModeBackup = FALSE;
3681 pMgntInfo->PowerSaveControl.bLeisurePs = FALSE;
3682 pMgntInfo->keepAliveLevel = 0;
3683 break;
3684
3685 default:
3686 pMgntInfo->CustomerID = RT_CID_DEFAULT;
3687 break;
3688
3689 }
3690
3691 //
3692 // Led mode
3693 //
3694 switch(pMgntInfo->CustomerID)
3695 {
3696 case RT_CID_DEFAULT:
3697 case RT_CID_819x_ALPHA:
3698 pHalData->LedStrategy = SW_LED_MODE1;
3699 pHalData->bRegUseLed = TRUE;
3700 pHalData->SwLed1.bLedOn = TRUE;
3701 break;
3702 case RT_CID_819x_CAMEO:
3703 pHalData->LedStrategy = SW_LED_MODE1;
3704 pHalData->bRegUseLed = TRUE;
3705 break;
3706
3707 case RT_CID_819x_Sitecom:
3708 pHalData->LedStrategy = SW_LED_MODE2;
3709 pHalData->bRegUseLed = TRUE;
3710 break;
3711
3712 default:
3713 pHalData->LedStrategy = SW_LED_MODE0;
3714 break;
3715 }
3716 #endif
3717
3718 // Read USB PHY parameters.
3719 for(i=0; i<5; i++)
3720 priv->EEPROMUsbPhyParam[i] = *(u8 *)&hwinfo[EEPROM_USB_PHY_PARA1+i];
3721
3722 //RT_PRINT_DATA(COMP_EFUSE, DBG_LOUD, ("USB PHY Param: \n"), pHalData->EEPROMUsbPhyParam, 5);
3723
3724
3725 //Read Permanent MAC address
3726 for(i=0; i<6; i++)
3727 dev->dev_addr[i] = *(u8 *)&hwinfo[EEPROM_NODE_ADDRESS_BYTE_0+i];
3728
3729 //NicIFSetMacAddress(Adapter, Adapter->PermanentAddress);
3730 write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
3731 write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
3732
3733 RT_TRACE(COMP_INIT,
3734 "ReadAdapterInfo8192SEFuse(), Permanent Address = %pM\n",
3735 dev->dev_addr);
3736
3737 //
3738 // Get CustomerID(Boad Type)
3739 // i.e., 0x0: RTL8188SU, 0x1: RTL8191SU, 0x2: RTL8192SU, 0x3: RTL8191GU.
3740 // Others: Reserved. Default is 0x2: RTL8192SU.
3741 //
3742 //if(!priv->AutoloadFailFlag)
3743 //{
3744 priv->EEPROMBoardType = *(u8 *)&hwinfo[EEPROM_BoardType];
3745 priv->rf_type = rtl8192SU_BoardTypeToRFtype(dev, priv->EEPROMBoardType);
3746 //}
3747 //else
3748 //{
3749 // priv->EEPROMBoardType = EEPROM_Default_BoardType;
3750 // priv->rf_type = RF_1T2R;
3751 //}
3752
3753 priv->rf_chip = RF_6052;
3754
3755 priv->rf_chip = RF_6052;//lzm test
3756 RT_TRACE(COMP_INIT, "BoardType = 0x%2x\n", priv->EEPROMBoardType);
3757 RT_TRACE(COMP_INIT, "RF_Type = 0x%2x\n", priv->rf_type);
3758
3759 //
3760 // Read antenna tx power offset of B/C/D to A from EEPROM
3761 // and read ThermalMeter from EEPROM
3762 //
3763 //if(!priv->AutoloadFailFlag)
3764 {
3765 priv->EEPROMTxPowerDiff = *(u8 *)&hwinfo[EEPROM_PwDiff];
3766 priv->EEPROMThermalMeter = *(u8 *)&hwinfo[EEPROM_ThermalMeter];
3767 }
3768 //else
3769 //{
3770 // priv->EEPROMTxPowerDiff = EEPROM_Default_PwDiff;
3771 // priv->EEPROMThermalMeter = EEPROM_Default_ThermalMeter;
3772 //}
3773
3774 RT_TRACE(COMP_INIT, "PwDiff = %#x\n", priv->EEPROMTxPowerDiff);
3775 RT_TRACE(COMP_INIT, "ThermalMeter = %#x\n", priv->EEPROMThermalMeter);
3776
3777 //
3778 // Read Tx Power gain offset of legacy OFDM to HT rate.
3779 // Read CrystalCap from EEPROM
3780 //
3781 //if(!priv->AutoloadFailFlag)
3782 {
3783 priv->EEPROMCrystalCap = *(u8 *)&hwinfo[EEPROM_CrystalCap];
3784 }
3785 //else
3786 //{
3787 // priv->EEPROMCrystalCap = EEPROM_Default_CrystalCap;
3788 //}
3789
3790 RT_TRACE(COMP_INIT, "CrystalCap = %#x\n", priv->EEPROMCrystalCap);
3791
3792 //
3793 // Get Tx Power Base.
3794 //
3795 //if(!priv->AutoloadFailFlag)
3796 {
3797 priv->EEPROMTxPwrBase = *(u8 *)&hwinfo[EEPROM_TxPowerBase];
3798 }
3799 //else
3800 //{
3801 // priv->EEPROMTxPwrBase = EEPROM_Default_TxPowerBase;
3802 //}
3803
3804 RT_TRACE(COMP_INIT, "TxPwrBase = %#x\n", priv->EEPROMTxPwrBase);
3805
3806
3807 //
3808 // Get TSSI value for each path.
3809 //
3810 //if(!priv->AutoloadFailFlag)
3811 {
3812 priv->EEPROMTSSI_A = *(u8 *)&hwinfo[EEPROM_TSSI_A];
3813 priv->EEPROMTSSI_B = *(u8 *)&hwinfo[EEPROM_TSSI_B];
3814 }
3815 //else
3816 //{ // Default setting for Empty EEPROM
3817 // priv->EEPROMTSSI_A = EEPROM_Default_TSSI;
3818 // priv->EEPROMTSSI_B = EEPROM_Default_TSSI;
3819 //}
3820
3821 RT_TRACE(COMP_INIT, "TSSI_A = %#x, TSSI_B = %#x\n", priv->EEPROMTSSI_A, priv->EEPROMTSSI_B);
3822
3823 //
3824 // Get Tx Power tracking mode.
3825 //
3826 //if(!priv->AutoloadFailFlag)
3827 {
3828 priv->EEPROMTxPwrTkMode = *(u8 *)&hwinfo[EEPROM_TxPwTkMode];
3829 }
3830
3831 RT_TRACE(COMP_INIT, "TxPwrTkMod = %#x\n", priv->EEPROMTxPwrTkMode);
3832
3833
3834 {
3835 //
3836 // Buffer TxPwIdx(i.e., from offset 0x55~0x66, total 18Bytes)
3837 // Update CCK, OFDM (1T/2T)Tx Power Index from above buffer.
3838 //
3839
3840 //
3841 // Get Tx Power Level by Channel
3842 //
3843 //if(!priv->AutoloadFailFlag)
3844 {
3845 // Read Tx power of Channel 1 ~ 14 from EFUSE.
3846 // 92S suupport RF A & B
3847 for (rf_path = 0; rf_path < 2; rf_path++)
3848 {
3849 for (i = 0; i < 3; i++)
3850 {
3851 // Read CCK RF A & B Tx power
3852 priv->RfCckChnlAreaTxPwr[rf_path][i] =
3853 hwinfo[EEPROM_TxPwIndex+rf_path*3+i];
3854
3855 // Read OFDM RF A & B Tx power for 1T
3856 priv->RfOfdmChnlAreaTxPwr1T[rf_path][i] =
3857 hwinfo[EEPROM_TxPwIndex+6+rf_path*3+i];
3858
3859 // Read OFDM RF A & B Tx power for 2T
3860 priv->RfOfdmChnlAreaTxPwr2T[rf_path][i] =
3861 hwinfo[EEPROM_TxPwIndex+12+rf_path*3+i];
3862 }
3863 }
3864
3865 }
3866 update_hal_variables(priv);
3867 }
3868
3869 //
3870 // 2009/02/09 Cosa add for new EEPROM format
3871 //
3872 for(i=0; i<14; i++) // channel 1~3 use the same Tx Power Level.
3873 {
3874 // Read tx power difference between HT OFDM 20/40 MHZ
3875 if (i < 3) // Cjanel 1-3
3876 index = 0;
3877 else if (i < 9) // Channel 4-9
3878 index = 1;
3879 else // Channel 10-14
3880 index = 2;
3881
3882 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_HT20_DIFF+index])&0xff;
3883 priv->TxPwrHt20Diff[RF90_PATH_A][i] = (tempval&0xF);
3884 priv->TxPwrHt20Diff[RF90_PATH_B][i] = ((tempval>>4)&0xF);
3885
3886 // Read OFDM<->HT tx power diff
3887 if (i < 3) // Cjanel 1-3
3888 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_OFDM_DIFF])&0xff;
3889 else if (i < 9) // Channel 4-9
3890 tempval = (*(u8 *)&hwinfo[EEPROM_PwDiff])&0xff;
3891 else // Channel 10-14
3892 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_OFDM_DIFF+1])&0xff;
3893
3894 //cosa tempval = (*(u1Byte *)&hwinfo[EEPROM_TX_PWR_OFDM_DIFF+index])&0xff;
3895 priv->TxPwrLegacyHtDiff[RF90_PATH_A][i] = (tempval&0xF);
3896 priv->TxPwrLegacyHtDiff[RF90_PATH_B][i] = ((tempval>>4)&0xF);
3897
3898 //
3899 // Read Band Edge tx power offset and check if user enable the ability
3900 //
3901 // HT 40 band edge channel
3902 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE])&0xff;
3903 priv->TxPwrbandEdgeHt40[RF90_PATH_A][0] = (tempval&0xF); // Band edge low channel
3904 priv->TxPwrbandEdgeHt40[RF90_PATH_A][1] = ((tempval>>4)&0xF); // Band edge high channel
3905 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+1])&0xff;
3906 priv->TxPwrbandEdgeHt40[RF90_PATH_B][0] = (tempval&0xF); // Band edge low channel
3907 priv->TxPwrbandEdgeHt40[RF90_PATH_B][1] = ((tempval>>4)&0xF); // Band edge high channel
3908 // HT 20 band edge channel
3909 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+2])&0xff;
3910 priv->TxPwrbandEdgeHt20[RF90_PATH_A][0] = (tempval&0xF); // Band edge low channel
3911 priv->TxPwrbandEdgeHt20[RF90_PATH_A][1] = ((tempval>>4)&0xF); // Band edge high channel
3912 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+3])&0xff;
3913 priv->TxPwrbandEdgeHt20[RF90_PATH_B][0] = (tempval&0xF); // Band edge low channel
3914 priv->TxPwrbandEdgeHt20[RF90_PATH_B][1] = ((tempval>>4)&0xF); // Band edge high channel
3915 // OFDM band edge channel
3916 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+4])&0xff;
3917 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][0] = (tempval&0xF); // Band edge low channel
3918 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][1] = ((tempval>>4)&0xF); // Band edge high channel
3919 tempval = (*(u8 *)&hwinfo[EEPROM_TX_PWR_BAND_EDGE+5])&0xff;
3920 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][0] = (tempval&0xF); // Band edge low channel
3921 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][1] = ((tempval>>4)&0xF); // Band edge high channel
3922
3923 priv->TxPwrbandEdgeFlag = (*(u8 *)&hwinfo[TX_PWR_BAND_EDGE_CHK]);
3924 }
3925
3926 for(i=0; i<14; i++)
3927 RT_TRACE(COMP_INIT, "RF-A Ht20 to HT40 Diff[%d] = 0x%x\n", i, priv->TxPwrHt20Diff[RF90_PATH_A][i]);
3928 for(i=0; i<14; i++)
3929 RT_TRACE(COMP_INIT, "RF-A Legacy to Ht40 Diff[%d] = 0x%x\n", i, priv->TxPwrLegacyHtDiff[RF90_PATH_A][i]);
3930 for(i=0; i<14; i++)
3931 RT_TRACE(COMP_INIT, "RF-B Ht20 to HT40 Diff[%d] = 0x%x\n", i, priv->TxPwrHt20Diff[RF90_PATH_B][i]);
3932 for(i=0; i<14; i++)
3933 RT_TRACE(COMP_INIT, "RF-B Legacy to HT40 Diff[%d] = 0x%x\n", i, priv->TxPwrLegacyHtDiff[RF90_PATH_B][i]);
3934 RT_TRACE(COMP_INIT, "RF-A HT40 band-edge low/high power diff = 0x%x/0x%x\n",
3935 priv->TxPwrbandEdgeHt40[RF90_PATH_A][0],
3936 priv->TxPwrbandEdgeHt40[RF90_PATH_A][1]);
3937 RT_TRACE((COMP_INIT&COMP_DBG), "RF-B HT40 band-edge low/high power diff = 0x%x/0x%x\n",
3938 priv->TxPwrbandEdgeHt40[RF90_PATH_B][0],
3939 priv->TxPwrbandEdgeHt40[RF90_PATH_B][1]);
3940
3941 RT_TRACE((COMP_INIT&COMP_DBG), "RF-A HT20 band-edge low/high power diff = 0x%x/0x%x\n",
3942 priv->TxPwrbandEdgeHt20[RF90_PATH_A][0],
3943 priv->TxPwrbandEdgeHt20[RF90_PATH_A][1]);
3944 RT_TRACE((COMP_INIT&COMP_DBG), "RF-B HT20 band-edge low/high power diff = 0x%x/0x%x\n",
3945 priv->TxPwrbandEdgeHt20[RF90_PATH_B][0],
3946 priv->TxPwrbandEdgeHt20[RF90_PATH_B][1]);
3947
3948 RT_TRACE((COMP_INIT&COMP_DBG), "RF-A OFDM band-edge low/high power diff = 0x%x/0x%x\n",
3949 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][0],
3950 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_A][1]);
3951 RT_TRACE((COMP_INIT&COMP_DBG), "RF-B OFDM band-edge low/high power diff = 0x%x/0x%x\n",
3952 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][0],
3953 priv->TxPwrbandEdgeLegacyOfdm[RF90_PATH_B][1]);
3954 RT_TRACE((COMP_INIT&COMP_DBG), "Band-edge enable flag = %d\n", priv->TxPwrbandEdgeFlag);
3955
3956 //
3957 // Update remained HAL variables.
3958 //
3959 priv->TSSI_13dBm = priv->EEPROMThermalMeter *100;
3960 priv->LegacyHTTxPowerDiff = priv->EEPROMTxPowerDiff;
3961 priv->TxPowerDiff = priv->EEPROMTxPowerDiff;
3962 //priv->AntennaTxPwDiff[0] = (priv->EEPROMTxPowerDiff & 0xf);// Antenna B gain offset to antenna A, bit[3:0]
3963 //priv->AntennaTxPwDiff[1] = ((priv->EEPROMTxPowerDiff & 0xf0)>>4);// Antenna C gain offset to antenna A, bit[7:4]
3964 priv->CrystalCap = priv->EEPROMCrystalCap; // CrystalCap, bit[15:12]
3965 priv->ThermalMeter[0] = (priv->EEPROMThermalMeter&0x1f);// ThermalMeter, bit0~3 for RFIC1, bit4~7 for RFIC2
3966 priv->LedStrategy = SW_LED_MODE0;
3967
3968 init_rate_adaptive(dev);
3969
3970 RT_TRACE(COMP_INIT, "<==== ReadAdapterInfo8192SUsb\n");
3971
3972 //return RT_STATUS_SUCCESS;
3973 }
3974
3975
3976 //
3977 // Description:
3978 // Read HW adapter information by E-Fuse or EEPROM according CR9346 reported.
3979 //
3980 // Assumption:
3981 // 1. CR9346 regiser has verified.
3982 // 2. PASSIVE_LEVEL (USB interface)
3983 //
3984 // Created by Roger, 2008.10.21.
3985 //
3986 static void rtl8192SU_read_eeprom_info(struct net_device *dev)
3987 {
3988 struct r8192_priv *priv = ieee80211_priv(dev);
3989 u8 tmpU1b;
3990
3991 RT_TRACE(COMP_INIT, "====> ReadAdapterInfo8192SUsb\n");
3992
3993 // Retrieve Chip version.
3994 priv->card_8192_version = (VERSION_8192S)((read_nic_dword(dev, PMC_FSM)>>16)&0xF);
3995 RT_TRACE(COMP_INIT, "Chip Version ID: 0x%2x\n", priv->card_8192_version);
3996
3997 tmpU1b = read_nic_byte(dev, EPROM_CMD);//CR9346
3998
3999 // To check system boot selection.
4000 if (tmpU1b & CmdEERPOMSEL)
4001 {
4002 RT_TRACE(COMP_INIT, "Boot from EEPROM\n");
4003 priv->EepromOrEfuse = TRUE;
4004 }
4005 else
4006 {
4007 RT_TRACE(COMP_INIT, "Boot from EFUSE\n");
4008 priv->EepromOrEfuse = FALSE;
4009 }
4010
4011 // To check autoload success or not.
4012 if (tmpU1b & CmdEEPROM_En)
4013 {
4014 RT_TRACE(COMP_INIT, "Autoload OK!!\n");
4015 priv->AutoloadFailFlag=FALSE;
4016 rtl8192SU_ReadAdapterInfo8192SUsb(dev);//eeprom or e-fuse
4017 }
4018 else
4019 { // Auto load fail.
4020 RT_TRACE(COMP_INIT, "AutoLoad Fail reported from CR9346!!\n");
4021 priv->AutoloadFailFlag=TRUE;
4022 rtl8192SU_ConfigAdapterInfo8192SForAutoLoadFail(dev);
4023
4024 //if (IS_BOOT_FROM_EFUSE(Adapter))
4025 if(!priv->EepromOrEfuse)
4026 {
4027 RT_TRACE(COMP_INIT, "Update shadow map for EFuse future use!!\n");
4028 EFUSE_ShadowMapUpdate(dev);
4029 }
4030 }
4031 #ifdef TO_DO_LIST
4032 if((priv->RegChannelPlan >= RT_CHANNEL_DOMAIN_MAX) || (pHalData->EEPROMChannelPlan & EEPROM_CHANNEL_PLAN_BY_HW_MASK))
4033 {
4034 pMgntInfo->ChannelPlan = HalMapChannelPlan8192S(Adapter, (pHalData->EEPROMChannelPlan & (~(EEPROM_CHANNEL_PLAN_BY_HW_MASK))));
4035 pMgntInfo->bChnlPlanFromHW = (pHalData->EEPROMChannelPlan & EEPROM_CHANNEL_PLAN_BY_HW_MASK) ? TRUE : FALSE; // User cannot change channel plan.
4036 }
4037 else
4038 {
4039 pMgntInfo->ChannelPlan = (RT_CHANNEL_DOMAIN)pMgntInfo->RegChannelPlan;
4040 }
4041
4042 switch(pMgntInfo->ChannelPlan)
4043 {
4044 case RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN:
4045 {
4046 PRT_DOT11D_INFO pDot11dInfo = GET_DOT11D_INFO(pMgntInfo);
4047
4048 pDot11dInfo->bEnabled = TRUE;
4049 }
4050 RT_TRACE(COMP_INIT, DBG_LOUD, ("ReadAdapterInfo8187(): Enable dot11d when RT_CHANNEL_DOMAIN_GLOBAL_DOAMIN!\n"));
4051 break;
4052 }
4053
4054 RT_TRACE(COMP_INIT, DBG_LOUD, ("RegChannelPlan(%d) EEPROMChannelPlan(%d)", pMgntInfo->RegChannelPlan, pHalData->EEPROMChannelPlan));
4055 RT_TRACE(COMP_INIT, DBG_LOUD, ("ChannelPlan = %d\n" , pMgntInfo->ChannelPlan));
4056
4057 RT_TRACE(COMP_INIT, DBG_LOUD, ("<==== ReadAdapterInfo8192S\n"));
4058 #endif
4059
4060 RT_TRACE(COMP_INIT, "<==== ReadAdapterInfo8192SUsb\n");
4061
4062 //return RT_STATUS_SUCCESS;
4063 }
4064
4065 short rtl8192_get_channel_map(struct net_device * dev)
4066 {
4067 struct r8192_priv *priv = ieee80211_priv(dev);
4068 if(priv->ChannelPlan > COUNTRY_CODE_GLOBAL_DOMAIN){
4069 printk("rtl8180_init:Error channel plan! Set to default.\n");
4070 priv->ChannelPlan= 0;
4071 }
4072 RT_TRACE(COMP_INIT, "Channel plan is %d\n",priv->ChannelPlan);
4073
4074 rtl819x_set_channel_map(priv->ChannelPlan, priv);
4075 return 0;
4076 }
4077
4078 short rtl8192_init(struct net_device *dev)
4079 {
4080
4081 struct r8192_priv *priv = ieee80211_priv(dev);
4082
4083 rtl8192_init_priv_variable(dev);
4084 rtl8192_init_priv_lock(priv);
4085 rtl8192_init_priv_task(dev);
4086 priv->ops->rtl819x_read_eeprom_info(dev);
4087 rtl8192_get_channel_map(dev);
4088 init_hal_dm(dev);
4089 init_timer(&priv->watch_dog_timer);
4090 priv->watch_dog_timer.data = (unsigned long)dev;
4091 priv->watch_dog_timer.function = watch_dog_timer_callback;
4092 return 0;
4093 }
4094
4095 /******************************************************************************
4096 *function: This function actually only set RRSR, RATR and BW_OPMODE registers
4097 * not to do all the hw config as its name says
4098 * input: net_device dev
4099 * output: none
4100 * return: none
4101 * notice: This part need to modified according to the rate set we filtered
4102 * ****************************************************************************/
4103 void rtl8192_hwconfig(struct net_device* dev)
4104 {
4105 u32 regRATR = 0, regRRSR = 0;
4106 u8 regBwOpMode = 0, regTmp = 0;
4107 struct r8192_priv *priv = ieee80211_priv(dev);
4108
4109 // Set RRSR, RATR, and BW_OPMODE registers
4110 //
4111 switch(priv->ieee80211->mode)
4112 {
4113 case WIRELESS_MODE_B:
4114 regBwOpMode = BW_OPMODE_20MHZ;
4115 regRATR = RATE_ALL_CCK;
4116 regRRSR = RATE_ALL_CCK;
4117 break;
4118 case WIRELESS_MODE_A:
4119 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
4120 regRATR = RATE_ALL_OFDM_AG;
4121 regRRSR = RATE_ALL_OFDM_AG;
4122 break;
4123 case WIRELESS_MODE_G:
4124 regBwOpMode = BW_OPMODE_20MHZ;
4125 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4126 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4127 break;
4128 case WIRELESS_MODE_AUTO:
4129 #ifdef TO_DO_LIST
4130 if (Adapter->bInHctTest)
4131 {
4132 regBwOpMode = BW_OPMODE_20MHZ;
4133 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4134 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4135 }
4136 else
4137 #endif
4138 {
4139 regBwOpMode = BW_OPMODE_20MHZ;
4140 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4141 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4142 }
4143 break;
4144 case WIRELESS_MODE_N_24G:
4145 // It support CCK rate by default.
4146 // CCK rate will be filtered out only when associated AP does not support it.
4147 regBwOpMode = BW_OPMODE_20MHZ;
4148 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4149 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4150 break;
4151 case WIRELESS_MODE_N_5G:
4152 regBwOpMode = BW_OPMODE_5G;
4153 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4154 regRRSR = RATE_ALL_OFDM_AG;
4155 break;
4156 }
4157
4158 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
4159 {
4160 u32 ratr_value = 0;
4161 ratr_value = regRATR;
4162 if (priv->rf_type == RF_1T2R)
4163 {
4164 ratr_value &= ~(RATE_ALL_OFDM_2SS);
4165 }
4166 write_nic_dword(dev, RATR0, ratr_value);
4167 write_nic_byte(dev, UFWP, 1);
4168 }
4169 regTmp = read_nic_byte(dev, 0x313);
4170 regRRSR = ((regTmp) << 24) | (regRRSR & 0x00ffffff);
4171 write_nic_dword(dev, RRSR, regRRSR);
4172
4173 //
4174 // Set Retry Limit here
4175 //
4176 write_nic_word(dev, RETRY_LIMIT,
4177 priv->ShortRetryLimit << RETRY_LIMIT_SHORT_SHIFT | \
4178 priv->LongRetryLimit << RETRY_LIMIT_LONG_SHIFT);
4179 // Set Contention Window here
4180
4181 // Set Tx AGC
4182
4183 // Set Tx Antenna including Feedback control
4184
4185 // Set Auto Rate fallback control
4186
4187
4188 }
4189
4190
4191 //
4192 // Description:
4193 // Initial HW relted registers.
4194 //
4195 // Assumption:
4196 // Config RTL8192S USB MAC, we should config MAC before download FW.
4197 //
4198 // 2008.09.03, Added by Roger.
4199 //
4200 static void rtl8192SU_MacConfigBeforeFwDownloadASIC(struct net_device *dev)
4201 {
4202 u8 tmpU1b;// i;
4203 // u16 tmpU2b;
4204 // u32 tmpU4b;
4205 u8 PollingCnt = 20;
4206
4207 RT_TRACE(COMP_INIT, "--->MacConfigBeforeFwDownloadASIC()\n");
4208
4209 //2MAC Initialization for power on sequence, Revised by Roger. 2008.09.03.
4210
4211 //
4212 //<Roger_Notes> Set control path switch to HW control and reset Digital Core, CPU Core and
4213 // MAC I/O to solve FW download fail when system from resume sate.
4214 // 2008.11.04.
4215 //
4216 tmpU1b = read_nic_byte(dev, SYS_CLKR+1);
4217 if(tmpU1b & 0x80)
4218 {
4219 tmpU1b &= 0x3f;
4220 write_nic_byte(dev, SYS_CLKR+1, tmpU1b);
4221 }
4222 // Clear FW RPWM for FW control LPS. by tynli. 2009.02.23
4223 write_nic_byte(dev, RPWM, 0x0);
4224
4225 tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
4226 tmpU1b &= 0x73;
4227 write_nic_byte(dev, SYS_FUNC_EN+1, tmpU1b);
4228 udelay(1000);
4229
4230 //Revised POS, suggested by SD1 Alex, 2008.09.27.
4231 write_nic_byte(dev, SPS0_CTRL+1, 0x53);
4232 write_nic_byte(dev, SPS0_CTRL, 0x57);
4233
4234 //Enable AFE Macro Block's Bandgap adn Enable AFE Macro Block's Mbias
4235 tmpU1b = read_nic_byte(dev, AFE_MISC);
4236 write_nic_byte(dev, AFE_MISC, (tmpU1b|AFE_BGEN|AFE_MBEN));
4237
4238 //Enable PLL Power (LDOA15V)
4239 tmpU1b = read_nic_byte(dev, LDOA15_CTRL);
4240 write_nic_byte(dev, LDOA15_CTRL, (tmpU1b|LDA15_EN));
4241
4242 //Enable LDOV12D block
4243 tmpU1b = read_nic_byte(dev, LDOV12D_CTRL);
4244 write_nic_byte(dev, LDOV12D_CTRL, (tmpU1b|LDV12_EN));
4245
4246 //mpU1b = read_nic_byte(Adapter, SPS1_CTRL);
4247 //write_nic_byte(dev, SPS1_CTRL, (tmpU1b|SPS1_LDEN));
4248
4249 //PlatformSleepUs(2000);
4250
4251 //Enable Switch Regulator Block
4252 //tmpU1b = read_nic_byte(Adapter, SPS1_CTRL);
4253 //write_nic_byte(dev, SPS1_CTRL, (tmpU1b|SPS1_SWEN));
4254
4255 //write_nic_dword(Adapter, SPS1_CTRL, 0x00a7b267);
4256
4257 tmpU1b = read_nic_byte(dev, SYS_ISO_CTRL+1);
4258 write_nic_byte(dev, SYS_ISO_CTRL+1, (tmpU1b|0x08));
4259
4260 //Engineer Packet CP test Enable
4261 tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
4262 write_nic_byte(dev, SYS_FUNC_EN+1, (tmpU1b|0x20));
4263
4264 //Support 64k IMEM, suggested by SD1 Alex.
4265 tmpU1b = read_nic_byte(dev, SYS_ISO_CTRL+1);
4266 write_nic_byte(dev, SYS_ISO_CTRL+1, (tmpU1b& 0x68));
4267
4268 //Enable AFE clock
4269 tmpU1b = read_nic_byte(dev, AFE_XTAL_CTRL+1);
4270 write_nic_byte(dev, AFE_XTAL_CTRL+1, (tmpU1b& 0xfb));
4271
4272 //Enable AFE PLL Macro Block
4273 tmpU1b = read_nic_byte(dev, AFE_PLL_CTRL);
4274 write_nic_byte(dev, AFE_PLL_CTRL, (tmpU1b|0x11));
4275
4276 //Attatch AFE PLL to MACTOP/BB/PCIe Digital
4277 tmpU1b = read_nic_byte(dev, SYS_ISO_CTRL);
4278 write_nic_byte(dev, SYS_ISO_CTRL, (tmpU1b&0xEE));
4279
4280 // Switch to 40M clock
4281 write_nic_byte(dev, SYS_CLKR, 0x00);
4282
4283 //SSC Disable
4284 tmpU1b = read_nic_byte(dev, SYS_CLKR);
4285 //write_nic_byte(dev, SYS_CLKR, (tmpU1b&0x5f));
4286 write_nic_byte(dev, SYS_CLKR, (tmpU1b|0xa0));
4287
4288 //Enable MAC clock
4289 tmpU1b = read_nic_byte(dev, SYS_CLKR+1);
4290 write_nic_byte(dev, SYS_CLKR+1, (tmpU1b|0x18));
4291
4292 //Revised POS, suggested by SD1 Alex, 2008.09.27.
4293 write_nic_byte(dev, PMC_FSM, 0x02);
4294
4295 //Enable Core digital and enable IOREG R/W
4296 tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
4297 write_nic_byte(dev, SYS_FUNC_EN+1, (tmpU1b|0x08));
4298
4299 //Enable REG_EN
4300 tmpU1b = read_nic_byte(dev, SYS_FUNC_EN+1);
4301 write_nic_byte(dev, SYS_FUNC_EN+1, (tmpU1b|0x80));
4302
4303 //Switch the control path to FW
4304 tmpU1b = read_nic_byte(dev, SYS_CLKR+1);
4305 write_nic_byte(dev, SYS_CLKR+1, (tmpU1b|0x80)& 0xBF);
4306
4307 write_nic_byte(dev, CMDR, 0xFC);
4308 write_nic_byte(dev, CMDR+1, 0x37);
4309
4310 //Fix the RX FIFO issue(usb error), 970410
4311 tmpU1b = read_nic_byte_E(dev, 0x5c);
4312 write_nic_byte_E(dev, 0x5c, (tmpU1b|BIT7));
4313
4314 //For power save, used this in the bit file after 970621
4315 tmpU1b = read_nic_byte(dev, SYS_CLKR);
4316 write_nic_byte(dev, SYS_CLKR, tmpU1b&(~SYS_CPU_CLKSEL));
4317
4318 // Revised for 8051 ROM code wrong operation. Added by Roger. 2008.10.16.
4319 write_nic_byte_E(dev, 0x1c, 0x80);
4320
4321 //
4322 // <Roger_EXP> To make sure that TxDMA can ready to download FW.
4323 // We should reset TxDMA if IMEM RPT was not ready.
4324 // Suggested by SD1 Alex. 2008.10.23.
4325 //
4326 do
4327 {
4328 tmpU1b = read_nic_byte(dev, TCR);
4329 if((tmpU1b & TXDMA_INIT_VALUE) == TXDMA_INIT_VALUE)
4330 break;
4331 //PlatformStallExecution(5);
4332 udelay(5);
4333 }while(PollingCnt--); // Delay 1ms
4334
4335 if(PollingCnt <= 0 )
4336 {
4337 RT_TRACE(COMP_INIT, "MacConfigBeforeFwDownloadASIC(): Polling TXDMA_INIT_VALUE timeout!! Current TCR(%#x)\n", tmpU1b);
4338 tmpU1b = read_nic_byte(dev, CMDR);
4339 write_nic_byte(dev, CMDR, tmpU1b&(~TXDMA_EN));
4340 udelay(2);
4341 write_nic_byte(dev, CMDR, tmpU1b|TXDMA_EN);// Reset TxDMA
4342 }
4343
4344
4345 RT_TRACE(COMP_INIT, "<---MacConfigBeforeFwDownloadASIC()\n");
4346 }
4347
4348 //
4349 // Description:
4350 // Initial HW relted registers.
4351 //
4352 // Assumption:
4353 // 1. This function is only invoked at driver intialization once.
4354 // 2. PASSIVE LEVEL.
4355 //
4356 // 2008.06.10, Added by Roger.
4357 //
4358 static void rtl8192SU_MacConfigAfterFwDownload(struct net_device *dev)
4359 {
4360 struct r8192_priv *priv = ieee80211_priv((struct net_device *)dev);
4361 //PRT_HIGH_THROUGHPUT pHTInfo = priv->ieee80211->pHTInfo;
4362 //u8 tmpU1b, RxPageCfg, i;
4363 u16 tmpU2b;
4364 u8 tmpU1b;//, i;
4365
4366
4367 RT_TRACE(COMP_INIT, "--->MacConfigAfterFwDownload()\n");
4368
4369 // Enable Tx/Rx
4370 tmpU2b = (BBRSTn|BB_GLB_RSTn|SCHEDULE_EN|MACRXEN|MACTXEN|DDMA_EN|
4371 FW2HW_EN|RXDMA_EN|TXDMA_EN|HCI_RXDMA_EN|HCI_TXDMA_EN); //3
4372 //Adapter->HalFunc.SetHwRegHandler( Adapter, HW_VAR_COMMAND, &tmpU1b );
4373 write_nic_word(dev, CMDR, tmpU2b); //LZM REGISTER COM 090305
4374
4375 // Loopback mode or not
4376 priv->LoopbackMode = RTL8192SU_NO_LOOPBACK; // Set no loopback as default.
4377 if(priv->LoopbackMode == RTL8192SU_NO_LOOPBACK)
4378 tmpU1b = LBK_NORMAL;
4379 else if (priv->LoopbackMode == RTL8192SU_MAC_LOOPBACK )
4380 tmpU1b = LBK_MAC_DLB;
4381 else
4382 RT_TRACE(COMP_INIT, "Serious error: wrong loopback mode setting\n");
4383
4384 //Adapter->HalFunc.SetHwRegHandler( Adapter, HW_VAR_LBK_MODE, &tmpU1b);
4385 write_nic_byte(dev, LBKMD_SEL, tmpU1b);
4386
4387 // Set RCR
4388 write_nic_dword(dev, RCR, priv->ReceiveConfig);
4389 RT_TRACE(COMP_INIT, "MacConfigAfterFwDownload(): Current RCR settings(%#x)\n", priv->ReceiveConfig);
4390
4391
4392 // Set RQPN
4393 //
4394 // <Roger_Notes> 2008.08.18.
4395 // 6 endpoints:
4396 // (1) Page number on CMDQ is 0x03.
4397 // (2) Page number on BCNQ, HQ and MGTQ is 0.
4398 // (3) Page number on BKQ, BEQ, VIQ and VOQ are 0x07.
4399 // (4) Page number on PUBQ is 0xdd
4400 //
4401 // 11 endpoints:
4402 // (1) Page number on CMDQ is 0x00.
4403 // (2) Page number on BCNQ is 0x02, HQ and MGTQ are 0x03.
4404 // (3) Page number on BKQ, BEQ, VIQ and VOQ are 0x07.
4405 // (4) Page number on PUBQ is 0xd8
4406 //
4407 //write_nic_dword(Adapter, 0xa0, 0x07070707); //BKQ, BEQ, VIQ and VOQ
4408 //write_nic_byte(dev, 0xa4, 0x00); // HCCAQ
4409
4410 // Fix the RX FIFO issue(USB error), Rivesed by Roger, 2008-06-14
4411 tmpU1b = read_nic_byte_E(dev, 0x5C);
4412 write_nic_byte_E(dev, 0x5C, tmpU1b|BIT7);
4413
4414 // For EFUSE init configuration.
4415 //if (IS_BOOT_FROM_EFUSE(Adapter)) // We may R/W EFUSE in EFUSE mode
4416 if (priv->bBootFromEfuse)
4417 {
4418 u8 tempval;
4419
4420 tempval = read_nic_byte(dev, SYS_ISO_CTRL+1);
4421 tempval &= 0xFE;
4422 write_nic_byte(dev, SYS_ISO_CTRL+1, tempval);
4423
4424 // Enable LDO 2.5V for write action
4425 //tempval = read_nic_byte(Adapter, EFUSE_TEST+3);
4426 //write_nic_byte(Adapter, EFUSE_TEST+3, (tempval | 0x80));
4427
4428 // Change Efuse Clock for write action
4429 //write_nic_byte(Adapter, EFUSE_CLK, 0x03);
4430
4431 // Change Program timing
4432 write_nic_byte(dev, EFUSE_CTRL+3, 0x72);
4433 //printk("!!!!!!!!!!!!!!!!!!!!!%s: write 0x33 with 0x72\n",__FUNCTION__);
4434 RT_TRACE(COMP_INIT, "EFUSE CONFIG OK\n");
4435 }
4436
4437
4438 RT_TRACE(COMP_INIT, "<---MacConfigAfterFwDownload()\n");
4439 }
4440
4441 void rtl8192SU_HwConfigureRTL8192SUsb(struct net_device *dev)
4442 {
4443
4444 struct r8192_priv *priv = ieee80211_priv(dev);
4445 u8 regBwOpMode = 0;
4446 u32 regRATR = 0, regRRSR = 0;
4447 u8 regTmp = 0;
4448 u32 i = 0;
4449
4450 //1 This part need to modified according to the rate set we filtered!!
4451 //
4452 // Set RRSR, RATR, and BW_OPMODE registers
4453 //
4454 switch(priv->ieee80211->mode)
4455 {
4456 case WIRELESS_MODE_B:
4457 regBwOpMode = BW_OPMODE_20MHZ;
4458 regRATR = RATE_ALL_CCK;
4459 regRRSR = RATE_ALL_CCK;
4460 break;
4461 case WIRELESS_MODE_A:
4462 regBwOpMode = BW_OPMODE_5G |BW_OPMODE_20MHZ;
4463 regRATR = RATE_ALL_OFDM_AG;
4464 regRRSR = RATE_ALL_OFDM_AG;
4465 break;
4466 case WIRELESS_MODE_G:
4467 regBwOpMode = BW_OPMODE_20MHZ;
4468 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4469 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4470 break;
4471 case WIRELESS_MODE_AUTO:
4472 if (priv->bInHctTest)
4473 {
4474 regBwOpMode = BW_OPMODE_20MHZ;
4475 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4476 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4477 }
4478 else
4479 {
4480 regBwOpMode = BW_OPMODE_20MHZ;
4481 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4482 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4483 }
4484 break;
4485 case WIRELESS_MODE_N_24G:
4486 // It support CCK rate by default.
4487 // CCK rate will be filtered out only when associated AP does not support it.
4488 regBwOpMode = BW_OPMODE_20MHZ;
4489 regRATR = RATE_ALL_CCK | RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4490 regRRSR = RATE_ALL_CCK | RATE_ALL_OFDM_AG;
4491 break;
4492 case WIRELESS_MODE_N_5G:
4493 regBwOpMode = BW_OPMODE_5G;
4494 regRATR = RATE_ALL_OFDM_AG | RATE_ALL_OFDM_1SS | RATE_ALL_OFDM_2SS;
4495 regRRSR = RATE_ALL_OFDM_AG;
4496 break;
4497 }
4498
4499 //
4500 // <Roger_Notes> We disable CCK response rate until FIB CCK rate IC's back.
4501 // 2008.09.23.
4502 //
4503 regTmp = read_nic_byte(dev, INIRTSMCS_SEL);
4504 regRRSR = ((regRRSR & 0x000fffff)<<8) | regTmp;
4505
4506 //
4507 // Update SIFS timing.
4508 //
4509 //priv->SifsTime = 0x0e0e0a0a;
4510 //Adapter->HalFunc.SetHwRegHandler( Adapter, HW_VAR_SIFS, (pu1Byte)&pHalData->SifsTime);
4511 { u8 val[4] = {0x0e, 0x0e, 0x0a, 0x0a};
4512 // SIFS for CCK Data ACK
4513 write_nic_byte(dev, SIFS_CCK, val[0]);
4514 // SIFS for CCK consecutive tx like CTS data!
4515 write_nic_byte(dev, SIFS_CCK+1, val[1]);
4516
4517 // SIFS for OFDM Data ACK
4518 write_nic_byte(dev, SIFS_OFDM, val[2]);
4519 // SIFS for OFDM consecutive tx like CTS data!
4520 write_nic_byte(dev, SIFS_OFDM+1, val[3]);
4521 }
4522
4523 write_nic_dword(dev, INIRTSMCS_SEL, regRRSR);
4524 write_nic_byte(dev, BW_OPMODE, regBwOpMode);
4525
4526 //
4527 // Suggested by SD1 Alex, 2008-06-14.
4528 //
4529 //PlatformEFIOWrite1Byte(Adapter, TXOP_STALL_CTRL, 0x80);//NAV to protect all TXOP.
4530
4531 //
4532 // Set Data Auto Rate Fallback Retry Count register.
4533 //
4534 write_nic_dword(dev, DARFRC, 0x02010000);
4535 write_nic_dword(dev, DARFRC+4, 0x06050403);
4536 write_nic_dword(dev, RARFRC, 0x02010000);
4537 write_nic_dword(dev, RARFRC+4, 0x06050403);
4538
4539 // Set Data Auto Rate Fallback Reg. Added by Roger, 2008.09.22.
4540 for (i = 0; i < 8; i++)
4541 write_nic_dword(dev, ARFR0+i*4, 0x1f0ffff0);
4542
4543 //
4544 // Aggregation length limit. Revised by Roger. 2008.09.22.
4545 //
4546 write_nic_byte(dev, AGGLEN_LMT_H, 0x0f); // Set AMPDU length to 12Kbytes for ShortGI case.
4547 write_nic_dword(dev, AGGLEN_LMT_L, 0xddd77442); // Long GI
4548 write_nic_dword(dev, AGGLEN_LMT_L+4, 0xfffdd772);
4549
4550 // Set NAV protection length
4551 write_nic_word(dev, NAV_PROT_LEN, 0x0080);
4552
4553 // Set TXOP stall control for several queue/HI/BCN/MGT/
4554 write_nic_byte(dev, TXOP_STALL_CTRL, 0x00); // NAV Protect next packet.
4555
4556 // Set MSDU lifetime.
4557 write_nic_byte(dev, MLT, 0x8f);
4558
4559 // Set CCK/OFDM SIFS
4560 write_nic_word(dev, SIFS_CCK, 0x0a0a); // CCK SIFS shall always be 10us.
4561 write_nic_word(dev, SIFS_OFDM, 0x0e0e);
4562
4563 write_nic_byte(dev, ACK_TIMEOUT, 0x40);
4564
4565 // CF-END Threshold
4566 write_nic_byte(dev, CFEND_TH, 0xFF);
4567
4568 //
4569 // For Min Spacing configuration.
4570 //
4571 switch(priv->rf_type)
4572 {
4573 case RF_1T2R:
4574 case RF_1T1R:
4575 RT_TRACE(COMP_INIT, "Initializeadapter: RF_Type%s\n", (priv->rf_type==RF_1T1R? "(1T1R)":"(1T2R)"));
4576 priv->MinSpaceCfg = (MAX_MSS_DENSITY_1T<<3);
4577 break;
4578 case RF_2T2R:
4579 case RF_2T2R_GREEN:
4580 RT_TRACE(COMP_INIT, "Initializeadapter:RF_Type(2T2R)\n");
4581 priv->MinSpaceCfg = (MAX_MSS_DENSITY_2T<<3);
4582 break;
4583 }
4584 write_nic_byte(dev, AMPDU_MIN_SPACE, priv->MinSpaceCfg);
4585
4586 //LZM 090219
4587 //
4588 // For Min Spacing configuration.
4589 //
4590 //priv->MinSpaceCfg = 0x00;
4591 //rtl8192SU_SetHwRegAmpduMinSpace(dev, priv->MinSpaceCfg);
4592 }
4593
4594
4595 // Description: Initial HW relted registers.
4596 //
4597 // Assumption: This function is only invoked at driver intialization once.
4598 //
4599 // 2008.06.10, Added by Roger.
4600 bool rtl8192SU_adapter_start(struct net_device *dev)
4601 {
4602 struct r8192_priv *priv = ieee80211_priv(dev);
4603 //u32 dwRegRead = 0;
4604 //bool init_status = true;
4605 //u32 ulRegRead;
4606 bool rtStatus = true;
4607 //u8 PipeIndex;
4608 //u8 eRFPath, tmpU1b;
4609 u8 fw_download_times = 1;
4610
4611
4612 RT_TRACE(COMP_INIT, "--->InitializeAdapter8192SUsb()\n");
4613
4614 //pHalData->bGPIOChangeRF = FALSE;
4615
4616
4617 //
4618 // <Roger_Notes> 2008.06.15.
4619 //
4620 // Initialization Steps on RTL8192SU:
4621 // a. MAC initialization prior to sending down firmware code.
4622 // b. Download firmware code step by step(i.e., IMEM, EMEM, DMEM).
4623 // c. MAC configuration after firmware has been download successfully.
4624 // d. Initialize BB related configurations.
4625 // e. Initialize RF related configurations.
4626 // f. Start to BulkIn transfer.
4627 //
4628
4629 //
4630 //a. MAC initialization prior to send down firmware code.
4631 //
4632 start:
4633 rtl8192SU_MacConfigBeforeFwDownloadASIC(dev);
4634
4635 //
4636 //b. Download firmware code step by step(i.e., IMEM, EMEM, DMEM).
4637 //
4638 rtStatus = FirmwareDownload92S(dev);
4639 if(rtStatus != true)
4640 {
4641 if(fw_download_times == 1){
4642 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Download Firmware failed once, Download again!!\n");
4643 fw_download_times = fw_download_times + 1;
4644 goto start;
4645 }else{
4646 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Download Firmware failed twice, end!!\n");
4647 goto end;
4648 }
4649 }
4650 //
4651 //c. MAC configuration after firmware has been download successfully.
4652 //
4653 rtl8192SU_MacConfigAfterFwDownload(dev);
4654
4655 //priv->bLbusEnable = TRUE;
4656 //if(priv->RegRfOff == TRUE)
4657 // priv->eRFPowerState = eRfOff;
4658
4659 // Save target channel
4660 // <Roger_Notes> Current Channel will be updated again later.
4661 //priv->CurrentChannel = Channel;
4662 rtStatus = PHY_MACConfig8192S(dev);//===>ok
4663 if(rtStatus != true)
4664 {
4665 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Fail to configure MAC!!\n");
4666 goto end;
4667 }
4668 if (1){
4669 int i;
4670 for (i=0; i<4; i++)
4671 write_nic_dword(dev,WDCAPARA_ADD[i], 0x5e4322);
4672 write_nic_byte(dev,AcmHwCtrl, 0x01);
4673 }
4674
4675
4676 //
4677 //d. Initialize BB related configurations.
4678 //
4679
4680 rtStatus = PHY_BBConfig8192S(dev);//===>ok
4681 if(rtStatus != true)
4682 {
4683 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Fail to configure BB!!\n");
4684 goto end;
4685 }
4686
4687 rtl8192_setBBreg(dev, rFPGA0_AnalogParameter2, 0xff, 0x58);//===>ok
4688
4689 //
4690 // e. Initialize RF related configurations.
4691 //
4692 // 2007/11/02 MH Before initalizing RF. We can not use FW to do RF-R/W.
4693 priv->Rf_Mode = RF_OP_By_SW_3wire;
4694
4695 // For RF test only from Scott's suggestion
4696 //write_nic_byte(dev, 0x27, 0xDB);
4697 //write_nic_byte(dev, 0x1B, 0x07);
4698
4699
4700 write_nic_byte(dev, AFE_XTAL_CTRL+1, 0xDB);
4701
4702 // <Roger_Notes> The following IOs are configured for each RF modules.
4703 // Enable RF module and reset RF and SDM module. 2008.11.17.
4704 if(priv->card_8192_version == VERSION_8192S_ACUT)
4705 write_nic_byte(dev, SPS1_CTRL+3, (u8)(RF_EN|RF_RSTB|RF_SDMRSTB)); // Fix A-Cut bug.
4706 else
4707 write_nic_byte(dev, RF_CTRL, (u8)(RF_EN|RF_RSTB|RF_SDMRSTB));
4708
4709 rtStatus = PHY_RFConfig8192S(dev);//===>ok
4710 if(rtStatus != true)
4711 {
4712 RT_TRACE(COMP_INIT, "InitializeAdapter8192SUsb(): Fail to configure RF!!\n");
4713 goto end;
4714 }
4715
4716
4717 // Set CCK and OFDM Block "ON"
4718 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
4719 rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
4720
4721 //
4722 // Turn off Radio B while RF type is 1T1R by SD3 Wilsion's request.
4723 // Revised by Roger, 2008.12.18.
4724 //
4725 if(priv->rf_type == RF_1T1R)
4726 {
4727 // This is needed for PHY_REG after 20081219
4728 rtl8192_setBBreg(dev, rFPGA0_RFMOD, 0xff000000, 0x03);
4729 // This is needed for PHY_REG before 20081219
4730 //PHY_SetBBReg(Adapter, rOFDM0_TRxPathEnable, bMaskByte0, 0x11);
4731 }
4732
4733
4734 //LZM 090219
4735 // Set CCK and OFDM Block "ON"
4736 //rtl8192_setBBreg(dev, rFPGA0_RFMOD, bCCKEn, 0x1);
4737 //rtl8192_setBBreg(dev, rFPGA0_RFMOD, bOFDMEn, 0x1);
4738
4739
4740 //3//Get hardware version, do it in read eeprom?
4741 //GetHardwareVersion819xUsb(Adapter);
4742
4743 //3//
4744 //3 //Set Hardware
4745 //3//
4746 rtl8192SU_HwConfigureRTL8192SUsb(dev);//==>ok
4747
4748 //
4749 // <Roger_Notes> We set MAC address here if autoload was failed before,
4750 // otherwise IDR0 will NOT contain any value.
4751 //
4752 write_nic_dword(dev, IDR0, ((u32*)dev->dev_addr)[0]);
4753 write_nic_word(dev, IDR4, ((u16*)(dev->dev_addr + 4))[0]);
4754 if(!priv->bInHctTest)
4755 {
4756 if(priv->ResetProgress == RESET_TYPE_NORESET)
4757 {
4758 //RT_TRACE(COMP_MLME, DBG_LOUD, ("Initializeadapter8192SUsb():RegWirelessMode(%#x) \n", Adapter->RegWirelessMode));
4759 //Adapter->HalFunc.SetWirelessModeHandler(Adapter, Adapter->RegWirelessMode);
4760 rtl8192_SetWirelessMode(dev, priv->ieee80211->mode);//===>ok
4761 }
4762 }
4763 else
4764 {
4765 priv->ieee80211->mode = WIRELESS_MODE_G;
4766 rtl8192_SetWirelessMode(dev, WIRELESS_MODE_G);
4767 }
4768
4769 //Security related.
4770 //-----------------------------------------------------------------------------
4771 // Set up security related. 070106, by rcnjko:
4772 // 1. Clear all H/W keys.
4773 // 2. Enable H/W encryption/decryption.
4774 //-----------------------------------------------------------------------------
4775 //CamResetAllEntry(Adapter);
4776 //Adapter->HalFunc.EnableHWSecCfgHandler(Adapter);
4777
4778 //SecClearAllKeys(Adapter);
4779 CamResetAllEntry(dev);
4780 //SecInit(Adapter);
4781 {
4782 u8 SECR_value = 0x0;
4783 SECR_value |= SCR_TxEncEnable;
4784 SECR_value |= SCR_RxDecEnable;
4785 SECR_value |= SCR_NoSKMC;
4786 write_nic_byte(dev, SECR, SECR_value);
4787 }
4788
4789 #ifdef TO_DO_LIST
4790
4791 //PHY_UpdateInitialGain(dev);
4792
4793 if(priv->RegRfOff == true)
4794 { // User disable RF via registry.
4795 u8 eRFPath = 0;
4796
4797 RT_TRACE((COMP_INIT|COMP_RF), "InitializeAdapter8192SUsb(): Turn off RF for RegRfOff ----------\n");
4798 MgntActSet_RF_State(dev, eRfOff, RF_CHANGE_BY_SW);
4799 // Those action will be discard in MgntActSet_RF_State because off the same state
4800 for(eRFPath = 0; eRFPath <priv->NumTotalRFPath; eRFPath++)
4801 rtl8192_setBBreg(dev, (RF90_RADIO_PATH_E)eRFPath, 0x4, 0xC00, 0x0);
4802 }
4803 else if(priv->RfOffReason > RF_CHANGE_BY_PS)
4804 { // H/W or S/W RF OFF before sleep.
4805 RT_TRACE((COMP_INIT|COMP_RF), "InitializeAdapter8192SUsb(): Turn off RF for RfOffReason(%d) ----------\n", priv->RfOffReason);
4806 MgntActSet_RF_State(dev, eRfOff, priv->RfOffReason);
4807 }
4808 else
4809 {
4810 priv->eRFPowerState = eRfOn;
4811 priv->RfOffReason = 0;
4812 RT_TRACE((COMP_INIT|COMP_RF), "InitializeAdapter8192SUsb(): RF is on ----------\n");
4813 }
4814
4815 #endif
4816
4817
4818 //
4819 // f. Start to BulkIn transfer.
4820 //
4821 #ifdef TO_DO_LIST
4822
4823 #ifndef UNDER_VISTA
4824 {
4825 u8 i;
4826 PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
4827
4828 for(PipeIndex=0; PipeIndex < MAX_RX_QUEUE; PipeIndex++)
4829 {
4830 if (PipeIndex == 0)
4831 {
4832 for(i=0; i<32; i++)
4833 HalUsbInMpdu(Adapter, PipeIndex);
4834 }
4835 else
4836 {
4837 //HalUsbInMpdu(Adapter, PipeIndex);
4838 //HalUsbInMpdu(Adapter, PipeIndex);
4839 //HalUsbInMpdu(Adapter, PipeIndex);
4840 }
4841 }
4842 PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
4843 }
4844 #else
4845 // Joseph add to 819X code base for Vista USB platform.
4846 // This part may need to be add to Hal819xU code base. too.
4847 PlatformUsbEnableInPipes(Adapter);
4848 #endif
4849
4850 RT_TRACE(COMP_INIT, "HighestOperaRate = %x\n", Adapter->MgntInfo.HighestOperaRate);
4851
4852 PlatformStartWorkItem( &(pHalData->RtUsbCheckForHangWorkItem) );
4853
4854 //
4855 // <Roger_EXP> The following configurations are for ASIC verification temporally.
4856 // 2008.07.10.
4857 //
4858
4859 #endif
4860
4861 //
4862 // Read EEPROM TX power index and PHY_REG_PG.txt to capture correct
4863 // TX power index for different rate set.
4864 //
4865 //if(priv->card_8192_version >= VERSION_8192S_ACUT)
4866 {
4867 // Get original hw reg values
4868 PHY_GetHWRegOriginalValue(dev);
4869
4870 // Write correct tx power index//FIXLZM
4871 PHY_SetTxPowerLevel8192S(dev, priv->chan);
4872 }
4873
4874 {
4875 u8 tmpU1b = 0;
4876 // EEPROM R/W workaround
4877 tmpU1b = read_nic_byte(dev, MAC_PINMUX_CFG);
4878 write_nic_byte(dev, MAC_PINMUX_CFG, tmpU1b&(~GPIOMUX_EN));
4879 }
4880
4881 //
4882 //<Roger_Notes> 2008.08.19.
4883 // We return status here for temporal FPGA verification, 2008.08.19.
4884
4885 #ifdef RTL8192SU_FW_IQK
4886 write_nic_dword(dev, WFM5, FW_IQK_ENABLE);
4887 ChkFwCmdIoDone(dev);
4888 #endif
4889
4890 //
4891 // <Roger_Notes> We enable high power mechanism after NIC initialized.
4892 // 2008.11.27.
4893 //
4894 write_nic_dword(dev, WFM5, FW_RA_RESET);
4895 ChkFwCmdIoDone(dev);
4896 write_nic_dword(dev, WFM5, FW_RA_ACTIVE);
4897 ChkFwCmdIoDone(dev);
4898 write_nic_dword(dev, WFM5, FW_RA_REFRESH);
4899 ChkFwCmdIoDone(dev);
4900 write_nic_dword(dev, WFM5, FW_BB_RESET_ENABLE);
4901
4902 // <Roger_Notes> We return status here for temporal FPGA verification. 2008.05.12.
4903 //
4904
4905 end:
4906 return rtStatus;
4907 }
4908
4909 /***************************************************************************
4910 -------------------------------NET STUFF---------------------------
4911 ***************************************************************************/
4912
4913 static struct net_device_stats *rtl8192_stats(struct net_device *dev)
4914 {
4915 struct r8192_priv *priv = ieee80211_priv(dev);
4916
4917 return &priv->ieee80211->stats;
4918 }
4919
4920 bool
4921 HalTxCheckStuck819xUsb(
4922 struct net_device *dev
4923 )
4924 {
4925 struct r8192_priv *priv = ieee80211_priv(dev);
4926 u16 RegTxCounter = read_nic_word(dev, 0x128);
4927 bool bStuck = FALSE;
4928 RT_TRACE(COMP_RESET,"%s():RegTxCounter is %d,TxCounter is %d\n",__FUNCTION__,RegTxCounter,priv->TxCounter);
4929 if(priv->TxCounter==RegTxCounter)
4930 bStuck = TRUE;
4931
4932 priv->TxCounter = RegTxCounter;
4933
4934 return bStuck;
4935 }
4936
4937 /*
4938 * <Assumption: RT_TX_SPINLOCK is acquired.>
4939 * First added: 2006.11.19 by emily
4940 */
4941 RESET_TYPE
4942 TxCheckStuck(struct net_device *dev)
4943 {
4944 struct r8192_priv *priv = ieee80211_priv(dev);
4945 u8 QueueID;
4946 // PRT_TCB pTcb;
4947 // u8 ResetThreshold;
4948 bool bCheckFwTxCnt = false;
4949 //unsigned long flags;
4950
4951 //
4952 // Decide Stuch threshold according to current power save mode
4953 //
4954
4955 // RT_TRACE(COMP_RESET, " ==> TxCheckStuck()\n");
4956 // PlatformAcquireSpinLock(Adapter, RT_TX_SPINLOCK);
4957 // spin_lock_irqsave(&priv->ieee80211->lock,flags);
4958 for (QueueID = 0; QueueID<=BEACON_QUEUE;QueueID ++)
4959 {
4960 if(QueueID == TXCMD_QUEUE)
4961 continue;
4962 #if 1
4963 if((skb_queue_len(&priv->ieee80211->skb_waitQ[QueueID]) == 0) && (skb_queue_len(&priv->ieee80211->skb_aggQ[QueueID]) == 0))
4964 continue;
4965 #endif
4966
4967 bCheckFwTxCnt = true;
4968 }
4969 // PlatformReleaseSpinLock(Adapter, RT_TX_SPINLOCK);
4970 // spin_unlock_irqrestore(&priv->ieee80211->lock,flags);
4971 // RT_TRACE(COMP_RESET,"bCheckFwTxCnt is %d\n",bCheckFwTxCnt);
4972 #if 1
4973 if(bCheckFwTxCnt)
4974 {
4975 if(HalTxCheckStuck819xUsb(dev))
4976 {
4977 RT_TRACE(COMP_RESET, "TxCheckStuck(): Fw indicates no Tx condition! \n");
4978 return RESET_TYPE_SILENT;
4979 }
4980 }
4981 #endif
4982 return RESET_TYPE_NORESET;
4983 }
4984
4985 bool
4986 HalRxCheckStuck819xUsb(struct net_device *dev)
4987 {
4988 u16 RegRxCounter = read_nic_word(dev, 0x130);
4989 struct r8192_priv *priv = ieee80211_priv(dev);
4990 bool bStuck = FALSE;
4991 //#ifdef RTL8192SU
4992
4993 //#else
4994 static u8 rx_chk_cnt = 0;
4995 RT_TRACE(COMP_RESET,"%s(): RegRxCounter is %d,RxCounter is %d\n",__FUNCTION__,RegRxCounter,priv->RxCounter);
4996 // If rssi is small, we should check rx for long time because of bad rx.
4997 // or maybe it will continuous silent reset every 2 seconds.
4998 rx_chk_cnt++;
4999 if(priv->undecorated_smoothed_pwdb >= (RateAdaptiveTH_High+5))
5000 {
5001 rx_chk_cnt = 0; //high rssi, check rx stuck right now.
5002 }
5003 else if(priv->undecorated_smoothed_pwdb < (RateAdaptiveTH_High+5) &&
5004 ((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_40M) ||
5005 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb>=RateAdaptiveTH_Low_20M)) )
5006 {
5007 if(rx_chk_cnt < 2)
5008 {
5009 return bStuck;
5010 }
5011 else
5012 {
5013 rx_chk_cnt = 0;
5014 }
5015 }
5016 else if(((priv->CurrentChannelBW!=HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_40M) ||
5017 (priv->CurrentChannelBW==HT_CHANNEL_WIDTH_20&&priv->undecorated_smoothed_pwdb<RateAdaptiveTH_Low_20M)) &&
5018 priv->undecorated_smoothed_pwdb >= VeryLowRSSI)
5019 {
5020 if(rx_chk_cnt < 4)
5021 {
5022 //DbgPrint("RSSI < %d && RSSI >= %d, no check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
5023 return bStuck;
5024 }
5025 else
5026 {
5027 rx_chk_cnt = 0;
5028 //DbgPrint("RSSI < %d && RSSI >= %d, check this time \n", RateAdaptiveTH_Low, VeryLowRSSI);
5029 }
5030 }
5031 else
5032 {
5033 if(rx_chk_cnt < 8)
5034 {
5035 //DbgPrint("RSSI <= %d, no check this time \n", VeryLowRSSI);
5036 return bStuck;
5037 }
5038 else
5039 {
5040 rx_chk_cnt = 0;
5041 //DbgPrint("RSSI <= %d, check this time \n", VeryLowRSSI);
5042 }
5043 }
5044 //#endif
5045
5046 if(priv->RxCounter==RegRxCounter)
5047 bStuck = TRUE;
5048
5049 priv->RxCounter = RegRxCounter;
5050
5051 return bStuck;
5052 }
5053
5054 RESET_TYPE
5055 RxCheckStuck(struct net_device *dev)
5056 {
5057 struct r8192_priv *priv = ieee80211_priv(dev);
5058 //int i;
5059 bool bRxCheck = FALSE;
5060
5061 // RT_TRACE(COMP_RESET," ==> RxCheckStuck()\n");
5062 //PlatformAcquireSpinLock(Adapter, RT_RX_SPINLOCK);
5063
5064 if(priv->IrpPendingCount > 1)
5065 bRxCheck = TRUE;
5066 //PlatformReleaseSpinLock(Adapter, RT_RX_SPINLOCK);
5067
5068 // RT_TRACE(COMP_RESET,"bRxCheck is %d \n",bRxCheck);
5069 if(bRxCheck)
5070 {
5071 if(HalRxCheckStuck819xUsb(dev))
5072 {
5073 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
5074 return RESET_TYPE_SILENT;
5075 }
5076 }
5077 return RESET_TYPE_NORESET;
5078 }
5079
5080
5081 /**
5082 * This function is called by Checkforhang to check whether we should ask OS to reset driver
5083 *
5084 * \param pAdapter The adapter context for this miniport
5085 *
5086 * Note:NIC with USB interface sholud not call this function because we cannot scan descriptor
5087 * to judge whether there is tx stuck.
5088 * Note: This function may be required to be rewrite for Vista OS.
5089 * <<<Assumption: Tx spinlock has been acquired >>>
5090 *
5091 * 8185 and 8185b does not implement this function. This is added by Emily at 2006.11.24
5092 */
5093 RESET_TYPE
5094 rtl819x_ifcheck_resetornot(struct net_device *dev)
5095 {
5096 struct r8192_priv *priv = ieee80211_priv(dev);
5097 RESET_TYPE TxResetType = RESET_TYPE_NORESET;
5098 RESET_TYPE RxResetType = RESET_TYPE_NORESET;
5099 RT_RF_POWER_STATE rfState;
5100
5101 return RESET_TYPE_NORESET;
5102
5103 rfState = priv->ieee80211->eRFPowerState;
5104
5105 TxResetType = TxCheckStuck(dev);
5106 #if 1
5107 if( rfState != eRfOff ||
5108 /*ADAPTER_TEST_STATUS_FLAG(Adapter, ADAPTER_STATUS_FW_DOWNLOAD_FAILURE)) &&*/
5109 (priv->ieee80211->iw_mode != IW_MODE_ADHOC))
5110 {
5111 // If driver is in the status of firmware download failure , driver skips RF initialization and RF is
5112 // in turned off state. Driver should check whether Rx stuck and do silent reset. And
5113 // if driver is in firmware download failure status, driver should initialize RF in the following
5114 // silent reset procedure Emily, 2008.01.21
5115
5116 // Driver should not check RX stuck in IBSS mode because it is required to
5117 // set Check BSSID in order to send beacon, however, if check BSSID is
5118 // set, STA cannot hear any packet a all. Emily, 2008.04.12
5119 RxResetType = RxCheckStuck(dev);
5120 }
5121 #endif
5122 if(TxResetType==RESET_TYPE_NORMAL || RxResetType==RESET_TYPE_NORMAL)
5123 return RESET_TYPE_NORMAL;
5124 else if(TxResetType==RESET_TYPE_SILENT || RxResetType==RESET_TYPE_SILENT){
5125 RT_TRACE(COMP_RESET,"%s():silent reset\n",__FUNCTION__);
5126 return RESET_TYPE_SILENT;
5127 }
5128 else
5129 return RESET_TYPE_NORESET;
5130
5131 }
5132
5133 void rtl8192_cancel_deferred_work(struct r8192_priv* priv);
5134 int _rtl8192_up(struct net_device *dev);
5135 int rtl8192_close(struct net_device *dev);
5136
5137
5138
5139 void
5140 CamRestoreAllEntry( struct net_device *dev)
5141 {
5142 u8 EntryId = 0;
5143 struct r8192_priv *priv = ieee80211_priv(dev);
5144 u8* MacAddr = priv->ieee80211->current_network.bssid;
5145
5146 static u8 CAM_CONST_ADDR[4][6] = {
5147 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
5148 {0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
5149 {0x00, 0x00, 0x00, 0x00, 0x00, 0x02},
5150 {0x00, 0x00, 0x00, 0x00, 0x00, 0x03}};
5151 static u8 CAM_CONST_BROAD[] =
5152 {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
5153
5154 RT_TRACE(COMP_SEC, "CamRestoreAllEntry: \n");
5155
5156
5157 if ((priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP40)||
5158 (priv->ieee80211->pairwise_key_type == KEY_TYPE_WEP104))
5159 {
5160
5161 for(EntryId=0; EntryId<4; EntryId++)
5162 {
5163 {
5164 MacAddr = CAM_CONST_ADDR[EntryId];
5165 setKey(dev,
5166 EntryId ,
5167 EntryId,
5168 priv->ieee80211->pairwise_key_type,
5169 MacAddr,
5170 0,
5171 NULL);
5172 }
5173 }
5174
5175 }
5176 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_TKIP)
5177 {
5178
5179 {
5180 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
5181 setKey(dev,
5182 4,
5183 0,
5184 priv->ieee80211->pairwise_key_type,
5185 (u8*)dev->dev_addr,
5186 0,
5187 NULL);
5188 else
5189 setKey(dev,
5190 4,
5191 0,
5192 priv->ieee80211->pairwise_key_type,
5193 MacAddr,
5194 0,
5195 NULL);
5196 }
5197 }
5198 else if(priv->ieee80211->pairwise_key_type == KEY_TYPE_CCMP)
5199 {
5200
5201 {
5202 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
5203 setKey(dev,
5204 4,
5205 0,
5206 priv->ieee80211->pairwise_key_type,
5207 (u8*)dev->dev_addr,
5208 0,
5209 NULL);
5210 else
5211 setKey(dev,
5212 4,
5213 0,
5214 priv->ieee80211->pairwise_key_type,
5215 MacAddr,
5216 0,
5217 NULL);
5218 }
5219 }
5220
5221
5222
5223 if(priv->ieee80211->group_key_type == KEY_TYPE_TKIP)
5224 {
5225 MacAddr = CAM_CONST_BROAD;
5226 for(EntryId=1 ; EntryId<4 ; EntryId++)
5227 {
5228 {
5229 setKey(dev,
5230 EntryId,
5231 EntryId,
5232 priv->ieee80211->group_key_type,
5233 MacAddr,
5234 0,
5235 NULL);
5236 }
5237 }
5238 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
5239 setKey(dev,
5240 0,
5241 0,
5242 priv->ieee80211->group_key_type,
5243 CAM_CONST_ADDR[0],
5244 0,
5245 NULL);
5246 }
5247 else if(priv->ieee80211->group_key_type == KEY_TYPE_CCMP)
5248 {
5249 MacAddr = CAM_CONST_BROAD;
5250 for(EntryId=1; EntryId<4 ; EntryId++)
5251 {
5252 {
5253 setKey(dev,
5254 EntryId ,
5255 EntryId,
5256 priv->ieee80211->group_key_type,
5257 MacAddr,
5258 0,
5259 NULL);
5260 }
5261 }
5262
5263 if(priv->ieee80211->iw_mode == IW_MODE_ADHOC)
5264 setKey(dev,
5265 0 ,
5266 0,
5267 priv->ieee80211->group_key_type,
5268 CAM_CONST_ADDR[0],
5269 0,
5270 NULL);
5271 }
5272 }
5273 //////////////////////////////////////////////////////////////
5274 // This function is used to fix Tx/Rx stop bug temporarily.
5275 // This function will do "system reset" to NIC when Tx or Rx is stuck.
5276 // The method checking Tx/Rx stuck of this function is supported by FW,
5277 // which reports Tx and Rx counter to register 0x128 and 0x130.
5278 //////////////////////////////////////////////////////////////
5279 void
5280 rtl819x_ifsilentreset(struct net_device *dev)
5281 {
5282 //OCTET_STRING asocpdu;
5283 struct r8192_priv *priv = ieee80211_priv(dev);
5284 u8 reset_times = 0;
5285 int reset_status = 0;
5286 struct ieee80211_device *ieee = priv->ieee80211;
5287
5288
5289 // 2007.07.20. If we need to check CCK stop, please uncomment this line.
5290 //bStuck = Adapter->HalFunc.CheckHWStopHandler(Adapter);
5291
5292 if(priv->ResetProgress==RESET_TYPE_NORESET)
5293 {
5294 RESET_START:
5295
5296 RT_TRACE(COMP_RESET,"=========>Reset progress!! \n");
5297
5298 // Set the variable for reset.
5299 priv->ResetProgress = RESET_TYPE_SILENT;
5300 // rtl8192_close(dev);
5301 #if 1
5302 down(&priv->wx_sem);
5303 if(priv->up == 0)
5304 {
5305 RT_TRACE(COMP_ERR,"%s():the driver is not up! return\n",__FUNCTION__);
5306 up(&priv->wx_sem);
5307 return ;
5308 }
5309 priv->up = 0;
5310 RT_TRACE(COMP_RESET,"%s():======>start to down the driver\n",__FUNCTION__);
5311 // if(!netif_queue_stopped(dev))
5312 // netif_stop_queue(dev);
5313
5314 rtl8192_rtx_disable(dev);
5315 rtl8192_cancel_deferred_work(priv);
5316 deinit_hal_dm(dev);
5317 del_timer_sync(&priv->watch_dog_timer);
5318
5319 ieee->sync_scan_hurryup = 1;
5320 if(ieee->state == IEEE80211_LINKED)
5321 {
5322 down(&ieee->wx_sem);
5323 printk("ieee->state is IEEE80211_LINKED\n");
5324 ieee80211_stop_send_beacons(priv->ieee80211);
5325 del_timer_sync(&ieee->associate_timer);
5326 cancel_delayed_work(&ieee->associate_retry_wq);
5327 ieee80211_stop_scan(ieee);
5328 netif_carrier_off(dev);
5329 up(&ieee->wx_sem);
5330 }
5331 else{
5332 printk("ieee->state is NOT LINKED\n");
5333 ieee80211_softmac_stop_protocol(priv->ieee80211); }
5334 up(&priv->wx_sem);
5335 RT_TRACE(COMP_RESET,"%s():<==========down process is finished\n",__FUNCTION__);
5336 //rtl8192_irq_disable(dev);
5337 RT_TRACE(COMP_RESET,"%s():===========>start to up the driver\n",__FUNCTION__);
5338 reset_status = _rtl8192_up(dev);
5339
5340 RT_TRACE(COMP_RESET,"%s():<===========up process is finished\n",__FUNCTION__);
5341 if(reset_status == -EAGAIN)
5342 {
5343 if(reset_times < 3)
5344 {
5345 reset_times++;
5346 goto RESET_START;
5347 }
5348 else
5349 {
5350 RT_TRACE(COMP_ERR," ERR!!! %s(): Reset Failed!!\n", __FUNCTION__);
5351 }
5352 }
5353 #endif
5354 ieee->is_silent_reset = 1;
5355 #if 1
5356 EnableHWSecurityConfig8192(dev);
5357 #if 1
5358 if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_INFRA)
5359 {
5360 ieee->set_chan(ieee->dev, ieee->current_network.channel);
5361
5362 #if 1
5363 queue_work(ieee->wq, &ieee->associate_complete_wq);
5364 #endif
5365
5366 }
5367 else if(ieee->state == IEEE80211_LINKED && ieee->iw_mode == IW_MODE_ADHOC)
5368 {
5369 ieee->set_chan(ieee->dev, ieee->current_network.channel);
5370 ieee->link_change(ieee->dev);
5371
5372 // notify_wx_assoc_event(ieee);
5373
5374 ieee80211_start_send_beacons(ieee);
5375
5376 if (ieee->data_hard_resume)
5377 ieee->data_hard_resume(ieee->dev);
5378 netif_carrier_on(ieee->dev);
5379 }
5380 #endif
5381
5382 CamRestoreAllEntry(dev);
5383
5384 priv->ResetProgress = RESET_TYPE_NORESET;
5385 priv->reset_count++;
5386
5387 priv->bForcedSilentReset =false;
5388 priv->bResetInProgress = false;
5389
5390 // For test --> force write UFWP.
5391 write_nic_byte(dev, UFWP, 1);
5392 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n", priv->reset_count);
5393 #endif
5394 }
5395 }
5396
5397 void CAM_read_entry(
5398 struct net_device *dev,
5399 u32 iIndex
5400 )
5401 {
5402 u32 target_command=0;
5403 u32 target_content=0;
5404 u8 entry_i=0;
5405 u32 ulStatus;
5406 s32 i=100;
5407 // printk("=======>start read CAM\n");
5408 for(entry_i=0;entry_i<CAM_CONTENT_COUNT;entry_i++)
5409 {
5410 // polling bit, and No Write enable, and address
5411 target_command= entry_i+CAM_CONTENT_COUNT*iIndex;
5412 target_command= target_command | BIT31;
5413
5414 //Check polling bit is clear
5415 // mdelay(1);
5416 #if 1
5417 while((i--)>=0)
5418 {
5419 ulStatus = read_nic_dword(dev, RWCAM);
5420 if(ulStatus & BIT31){
5421 continue;
5422 }
5423 else{
5424 break;
5425 }
5426 }
5427 #endif
5428 write_nic_dword(dev, RWCAM, target_command);
5429 RT_TRACE(COMP_SEC,"CAM_read_entry(): WRITE A0: %x \n",target_command);
5430 // printk("CAM_read_entry(): WRITE A0: %lx \n",target_command);
5431 target_content = read_nic_dword(dev, RCAMO);
5432 RT_TRACE(COMP_SEC, "CAM_read_entry(): WRITE A8: %x \n",target_content);
5433 // printk("CAM_read_entry(): WRITE A8: %lx \n",target_content);
5434 }
5435 printk("\n");
5436 }
5437
5438 void rtl819x_update_rxcounts(
5439 struct r8192_priv *priv,
5440 u32* TotalRxBcnNum,
5441 u32* TotalRxDataNum
5442 )
5443 {
5444 u16 SlotIndex;
5445 u8 i;
5446
5447 *TotalRxBcnNum = 0;
5448 *TotalRxDataNum = 0;
5449
5450 SlotIndex = (priv->ieee80211->LinkDetectInfo.SlotIndex++)%(priv->ieee80211->LinkDetectInfo.SlotNum);
5451 priv->ieee80211->LinkDetectInfo.RxBcnNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod;
5452 priv->ieee80211->LinkDetectInfo.RxDataNum[SlotIndex] = priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod;
5453 for( i=0; i<priv->ieee80211->LinkDetectInfo.SlotNum; i++ ){
5454 *TotalRxBcnNum += priv->ieee80211->LinkDetectInfo.RxBcnNum[i];
5455 *TotalRxDataNum += priv->ieee80211->LinkDetectInfo.RxDataNum[i];
5456 }
5457 }
5458
5459 void rtl819x_watchdog_wqcallback(struct work_struct *work)
5460 {
5461 struct delayed_work *dwork = container_of(work,
5462 struct delayed_work,
5463 work);
5464 struct r8192_priv *priv = container_of(dwork,
5465 struct r8192_priv,
5466 watch_dog_wq);
5467 struct net_device *dev = priv->ieee80211->dev;
5468 struct ieee80211_device* ieee = priv->ieee80211;
5469 RESET_TYPE ResetType = RESET_TYPE_NORESET;
5470 static u8 check_reset_cnt;
5471 u32 TotalRxBcnNum = 0;
5472 u32 TotalRxDataNum = 0;
5473 bool bBusyTraffic = false;
5474
5475 if(!priv->up)
5476 return;
5477 hal_dm_watchdog(dev);
5478 /* to get busy traffic condition */
5479 if (ieee->state == IEEE80211_LINKED) {
5480 if (ieee->LinkDetectInfo.NumRxOkInPeriod > 666 ||
5481 ieee->LinkDetectInfo.NumTxOkInPeriod > 666)
5482 bBusyTraffic = true;
5483
5484 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
5485 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
5486 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
5487 }
5488
5489 if (priv->ieee80211->state == IEEE80211_LINKED &&
5490 priv->ieee80211->iw_mode == IW_MODE_INFRA) {
5491 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
5492 if ((TotalRxBcnNum + TotalRxDataNum) == 0) {
5493 RT_TRACE(COMP_ERR, "%s(): AP is powered off,"
5494 "connect another one\n", __func__);
5495 /* Dot11d_Reset(dev); */
5496 priv->ieee80211->state = IEEE80211_ASSOCIATING;
5497 notify_wx_assoc_event(priv->ieee80211);
5498 RemovePeerTS(priv->ieee80211,
5499 priv->ieee80211->current_network.bssid);
5500 ieee->is_roaming = true;
5501 priv->ieee80211->link_change(dev);
5502 if(ieee->LedControlHandler != NULL)
5503 ieee->LedControlHandler(ieee->dev,
5504 LED_CTL_START_TO_LINK);
5505 queue_work(priv->ieee80211->wq,
5506 &priv->ieee80211->associate_procedure_wq);
5507 }
5508 }
5509 priv->ieee80211->LinkDetectInfo.NumRecvBcnInPeriod = 0;
5510 priv->ieee80211->LinkDetectInfo.NumRecvDataInPeriod = 0;
5511
5512 /*
5513 * CAM_read_entry(dev,4);
5514 * check if reset the driver
5515 */
5516 if (check_reset_cnt++ >= 3 && !ieee->is_roaming) {
5517 ResetType = rtl819x_ifcheck_resetornot(dev);
5518 check_reset_cnt = 3;
5519 }
5520 if ((priv->force_reset) || (priv->ResetProgress == RESET_TYPE_NORESET &&
5521 (priv->bForcedSilentReset ||
5522 (!priv->bDisableNormalResetCheck &&
5523 /* This is control by OID set in Pomelo */
5524 ResetType == RESET_TYPE_SILENT)))) {
5525 RT_TRACE(COMP_RESET, "%s(): priv->force_reset is %d,"
5526 "priv->ResetProgress is %d, "
5527 "priv->bForcedSilentReset is %d, "
5528 "priv->bDisableNormalResetCheck is %d, "
5529 "ResetType is %d",
5530 __func__,
5531 priv->force_reset,
5532 priv->ResetProgress,
5533 priv->bForcedSilentReset,
5534 priv->bDisableNormalResetCheck,
5535 ResetType);
5536 rtl819x_ifsilentreset(dev);
5537 }
5538 priv->force_reset = false;
5539 priv->bForcedSilentReset = false;
5540 priv->bResetInProgress = false;
5541 }
5542
5543 void watch_dog_timer_callback(unsigned long data)
5544 {
5545 struct r8192_priv *priv = ieee80211_priv((struct net_device *) data);
5546 //printk("===============>watch_dog timer\n");
5547 queue_delayed_work(priv->priv_wq,&priv->watch_dog_wq, 0);
5548 mod_timer(&priv->watch_dog_timer, jiffies + MSECS(IEEE80211_WATCH_DOG_TIME));
5549 }
5550 int _rtl8192_up(struct net_device *dev)
5551 {
5552 struct r8192_priv *priv = ieee80211_priv(dev);
5553 //int i;
5554 int init_status = 0;
5555 priv->up=1;
5556 priv->ieee80211->ieee_up=1;
5557 RT_TRACE(COMP_INIT, "Bringing up iface");
5558 init_status = priv->ops->rtl819x_adapter_start(dev);
5559 if(!init_status)
5560 {
5561 RT_TRACE(COMP_ERR,"ERR!!! %s(): initialization is failed!\n", __FUNCTION__);
5562 priv->up=priv->ieee80211->ieee_up = 0;
5563 return -EAGAIN;
5564 }
5565 RT_TRACE(COMP_INIT, "start adapter finished\n");
5566 rtl8192_rx_enable(dev);
5567 // rtl8192_tx_enable(dev);
5568 if(priv->ieee80211->state != IEEE80211_LINKED)
5569 ieee80211_softmac_start_protocol(priv->ieee80211);
5570 ieee80211_reset_queue(priv->ieee80211);
5571 watch_dog_timer_callback((unsigned long) dev);
5572 if(!netif_queue_stopped(dev))
5573 netif_start_queue(dev);
5574 else
5575 netif_wake_queue(dev);
5576
5577 /*
5578 * Make sure that drop_unencrypted is initialized as "0"
5579 * No packets will be sent in non-security mode if we had set drop_unencrypted.
5580 * ex, After kill wpa_supplicant process, make the driver up again.
5581 * drop_unencrypted remains as "1", which is set by wpa_supplicant. 2008/12/04.john
5582 */
5583 priv->ieee80211->drop_unencrypted = 0;
5584
5585 return 0;
5586 }
5587
5588
5589 int rtl8192_open(struct net_device *dev)
5590 {
5591 struct r8192_priv *priv = ieee80211_priv(dev);
5592 int ret;
5593 down(&priv->wx_sem);
5594 ret = rtl8192_up(dev);
5595 up(&priv->wx_sem);
5596 return ret;
5597
5598 }
5599
5600
5601 int rtl8192_up(struct net_device *dev)
5602 {
5603 struct r8192_priv *priv = ieee80211_priv(dev);
5604
5605 if (priv->up == 1) return -1;
5606
5607 return _rtl8192_up(dev);
5608 }
5609
5610
5611 int rtl8192_close(struct net_device *dev)
5612 {
5613 struct r8192_priv *priv = ieee80211_priv(dev);
5614 int ret;
5615
5616 down(&priv->wx_sem);
5617
5618 ret = rtl8192_down(dev);
5619
5620 up(&priv->wx_sem);
5621
5622 return ret;
5623
5624 }
5625
5626 int rtl8192_down(struct net_device *dev)
5627 {
5628 struct r8192_priv *priv = ieee80211_priv(dev);
5629 int i;
5630
5631 if (priv->up == 0) return -1;
5632
5633 priv->up=0;
5634 priv->ieee80211->ieee_up = 0;
5635 RT_TRACE(COMP_DOWN, "==========>%s()\n", __FUNCTION__);
5636 /* FIXME */
5637 if (!netif_queue_stopped(dev))
5638 netif_stop_queue(dev);
5639
5640 rtl8192_rtx_disable(dev);
5641 //rtl8192_irq_disable(dev);
5642
5643 /* Tx related queue release */
5644 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
5645 skb_queue_purge(&priv->ieee80211->skb_waitQ [i]);
5646 }
5647 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
5648 skb_queue_purge(&priv->ieee80211->skb_aggQ [i]);
5649 }
5650
5651 for(i = 0; i < MAX_QUEUE_SIZE; i++) {
5652 skb_queue_purge(&priv->ieee80211->skb_drv_aggQ [i]);
5653 }
5654
5655 //as cancel_delayed_work will del work->timer, so if work is not definedas struct delayed_work, it will corrupt
5656 // flush_scheduled_work();
5657 rtl8192_cancel_deferred_work(priv);
5658 deinit_hal_dm(dev);
5659 del_timer_sync(&priv->watch_dog_timer);
5660
5661
5662 ieee80211_softmac_stop_protocol(priv->ieee80211);
5663 memset(&priv->ieee80211->current_network, 0 , offsetof(struct ieee80211_network, list));
5664 RT_TRACE(COMP_DOWN, "<==========%s()\n", __FUNCTION__);
5665
5666 return 0;
5667 }
5668
5669
5670 void rtl8192_commit(struct net_device *dev)
5671 {
5672 struct r8192_priv *priv = ieee80211_priv(dev);
5673 int reset_status = 0;
5674 //u8 reset_times = 0;
5675 if (priv->up == 0) return ;
5676 priv->up = 0;
5677
5678 rtl8192_cancel_deferred_work(priv);
5679 del_timer_sync(&priv->watch_dog_timer);
5680 //cancel_delayed_work(&priv->SwChnlWorkItem);
5681
5682 ieee80211_softmac_stop_protocol(priv->ieee80211);
5683
5684 //rtl8192_irq_disable(dev);
5685 rtl8192_rtx_disable(dev);
5686 reset_status = _rtl8192_up(dev);
5687
5688 }
5689
5690 /*
5691 void rtl8192_restart(struct net_device *dev)
5692 {
5693 struct r8192_priv *priv = ieee80211_priv(dev);
5694 */
5695 void rtl8192_restart(struct work_struct *work)
5696 {
5697 struct r8192_priv *priv = container_of(work, struct r8192_priv, reset_wq);
5698 struct net_device *dev = priv->ieee80211->dev;
5699
5700 down(&priv->wx_sem);
5701
5702 rtl8192_commit(dev);
5703
5704 up(&priv->wx_sem);
5705 }
5706
5707 static void r8192_set_multicast(struct net_device *dev)
5708 {
5709 struct r8192_priv *priv = ieee80211_priv(dev);
5710 short promisc;
5711
5712 //down(&priv->wx_sem);
5713
5714 /* FIXME FIXME */
5715
5716 promisc = (dev->flags & IFF_PROMISC) ? 1:0;
5717
5718 if (promisc != priv->promisc)
5719 // rtl8192_commit(dev);
5720
5721 priv->promisc = promisc;
5722
5723 //schedule_work(&priv->reset_wq);
5724 //up(&priv->wx_sem);
5725 }
5726
5727
5728 int r8192_set_mac_adr(struct net_device *dev, void *mac)
5729 {
5730 struct r8192_priv *priv = ieee80211_priv(dev);
5731 struct sockaddr *addr = mac;
5732
5733 down(&priv->wx_sem);
5734
5735 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
5736
5737 schedule_work(&priv->reset_wq);
5738
5739 up(&priv->wx_sem);
5740
5741 return 0;
5742 }
5743
5744 /* based on ipw2200 driver */
5745 int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
5746 {
5747 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
5748 struct iwreq *wrq = (struct iwreq *)rq;
5749 int ret=-1;
5750 struct ieee80211_device *ieee = priv->ieee80211;
5751 u32 key[4];
5752 u8 broadcast_addr[6] = {0xff,0xff,0xff,0xff,0xff,0xff};
5753 u8 zero_addr[6] = {0};
5754 struct iw_point *p = &wrq->u.data;
5755 struct ieee_param *ipw = NULL;//(struct ieee_param *)wrq->u.data.pointer;
5756
5757 down(&priv->wx_sem);
5758
5759
5760 if (p->length < sizeof(struct ieee_param) || !p->pointer){
5761 ret = -EINVAL;
5762 goto out;
5763 }
5764
5765 ipw = kmalloc(p->length, GFP_KERNEL);
5766 if (ipw == NULL){
5767 ret = -ENOMEM;
5768 goto out;
5769 }
5770 if (copy_from_user(ipw, p->pointer, p->length)) {
5771 kfree(ipw);
5772 ret = -EFAULT;
5773 goto out;
5774 }
5775
5776 switch (cmd) {
5777 case RTL_IOCTL_WPA_SUPPLICANT:
5778 //parse here for HW security
5779 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION)
5780 {
5781 if (ipw->u.crypt.set_tx)
5782 {
5783 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
5784 ieee->pairwise_key_type = KEY_TYPE_CCMP;
5785 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
5786 ieee->pairwise_key_type = KEY_TYPE_TKIP;
5787 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
5788 {
5789 if (ipw->u.crypt.key_len == 13)
5790 ieee->pairwise_key_type = KEY_TYPE_WEP104;
5791 else if (ipw->u.crypt.key_len == 5)
5792 ieee->pairwise_key_type = KEY_TYPE_WEP40;
5793 }
5794 else
5795 ieee->pairwise_key_type = KEY_TYPE_NA;
5796
5797 if (ieee->pairwise_key_type)
5798 {
5799 // FIXME:these two lines below just to fix ipw interface bug, that is, it will never set mode down to driver. So treat it as ADHOC mode, if no association procedure. WB. 2009.02.04
5800 if (memcmp(ieee->ap_mac_addr, zero_addr, 6) == 0)
5801 ieee->iw_mode = IW_MODE_ADHOC;
5802 memcpy((u8*)key, ipw->u.crypt.key, 16);
5803 EnableHWSecurityConfig8192(dev);
5804 //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!
5805 //added by WB.
5806 setKey(dev, 4, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
5807 if (ieee->iw_mode == IW_MODE_ADHOC)
5808 setKey(dev, ipw->u.crypt.idx, ipw->u.crypt.idx, ieee->pairwise_key_type, (u8*)ieee->ap_mac_addr, 0, key);
5809 }
5810 }
5811 else //if (ipw->u.crypt.idx) //group key use idx > 0
5812 {
5813 memcpy((u8*)key, ipw->u.crypt.key, 16);
5814 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
5815 ieee->group_key_type= KEY_TYPE_CCMP;
5816 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
5817 ieee->group_key_type = KEY_TYPE_TKIP;
5818 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0)
5819 {
5820 if (ipw->u.crypt.key_len == 13)
5821 ieee->group_key_type = KEY_TYPE_WEP104;
5822 else if (ipw->u.crypt.key_len == 5)
5823 ieee->group_key_type = KEY_TYPE_WEP40;
5824 }
5825 else
5826 ieee->group_key_type = KEY_TYPE_NA;
5827
5828 if (ieee->group_key_type)
5829 {
5830 setKey( dev,
5831 ipw->u.crypt.idx,
5832 ipw->u.crypt.idx, //KeyIndex
5833 ieee->group_key_type, //KeyType
5834 broadcast_addr, //MacAddr
5835 0, //DefaultKey
5836 key); //KeyContent
5837 }
5838 }
5839 }
5840 #ifdef JOHN_HWSEC_DEBUG
5841 //john's test 0711
5842 printk("@@ wrq->u pointer = ");
5843 for(i=0;i<wrq->u.data.length;i++){
5844 if(i%10==0) printk("\n");
5845 printk( "%8x|", ((u32*)wrq->u.data.pointer)[i] );
5846 }
5847 printk("\n");
5848 #endif /*JOHN_HWSEC_DEBUG*/
5849 ret = ieee80211_wpa_supplicant_ioctl(priv->ieee80211, &wrq->u.data);
5850 break;
5851
5852 default:
5853 ret = -EOPNOTSUPP;
5854 break;
5855 }
5856 kfree(ipw);
5857 ipw = NULL;
5858 out:
5859 up(&priv->wx_sem);
5860 return ret;
5861 }
5862
5863 u8 rtl8192SU_HwRateToMRate(bool bIsHT, u8 rate,bool bFirstAMPDU)
5864 {
5865
5866 u8 ret_rate = 0x02;
5867
5868 if( bFirstAMPDU )
5869 {
5870 if(!bIsHT)
5871 {
5872 switch(rate)
5873 {
5874
5875 case DESC92S_RATE1M: ret_rate = MGN_1M; break;
5876 case DESC92S_RATE2M: ret_rate = MGN_2M; break;
5877 case DESC92S_RATE5_5M: ret_rate = MGN_5_5M; break;
5878 case DESC92S_RATE11M: ret_rate = MGN_11M; break;
5879 case DESC92S_RATE6M: ret_rate = MGN_6M; break;
5880 case DESC92S_RATE9M: ret_rate = MGN_9M; break;
5881 case DESC92S_RATE12M: ret_rate = MGN_12M; break;
5882 case DESC92S_RATE18M: ret_rate = MGN_18M; break;
5883 case DESC92S_RATE24M: ret_rate = MGN_24M; break;
5884 case DESC92S_RATE36M: ret_rate = MGN_36M; break;
5885 case DESC92S_RATE48M: ret_rate = MGN_48M; break;
5886 case DESC92S_RATE54M: ret_rate = MGN_54M; break;
5887
5888 default:
5889 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
5890 break;
5891 }
5892 }
5893 else
5894 {
5895 switch(rate)
5896 {
5897
5898 case DESC92S_RATEMCS0: ret_rate = MGN_MCS0; break;
5899 case DESC92S_RATEMCS1: ret_rate = MGN_MCS1; break;
5900 case DESC92S_RATEMCS2: ret_rate = MGN_MCS2; break;
5901 case DESC92S_RATEMCS3: ret_rate = MGN_MCS3; break;
5902 case DESC92S_RATEMCS4: ret_rate = MGN_MCS4; break;
5903 case DESC92S_RATEMCS5: ret_rate = MGN_MCS5; break;
5904 case DESC92S_RATEMCS6: ret_rate = MGN_MCS6; break;
5905 case DESC92S_RATEMCS7: ret_rate = MGN_MCS7; break;
5906 case DESC92S_RATEMCS8: ret_rate = MGN_MCS8; break;
5907 case DESC92S_RATEMCS9: ret_rate = MGN_MCS9; break;
5908 case DESC92S_RATEMCS10: ret_rate = MGN_MCS10; break;
5909 case DESC92S_RATEMCS11: ret_rate = MGN_MCS11; break;
5910 case DESC92S_RATEMCS12: ret_rate = MGN_MCS12; break;
5911 case DESC92S_RATEMCS13: ret_rate = MGN_MCS13; break;
5912 case DESC92S_RATEMCS14: ret_rate = MGN_MCS14; break;
5913 case DESC92S_RATEMCS15: ret_rate = MGN_MCS15; break;
5914 case DESC92S_RATEMCS32: ret_rate = (0x80|0x20); break;
5915
5916 default:
5917 RT_TRACE(COMP_RECV, "HwRateToMRate92S(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT );
5918 break;
5919 }
5920
5921 }
5922 }
5923 else
5924 {
5925 switch(rate)
5926 {
5927
5928 case DESC92S_RATE1M: ret_rate = MGN_1M; break;
5929 case DESC92S_RATE2M: ret_rate = MGN_2M; break;
5930 case DESC92S_RATE5_5M: ret_rate = MGN_5_5M; break;
5931 case DESC92S_RATE11M: ret_rate = MGN_11M; break;
5932 case DESC92S_RATE6M: ret_rate = MGN_6M; break;
5933 case DESC92S_RATE9M: ret_rate = MGN_9M; break;
5934 case DESC92S_RATE12M: ret_rate = MGN_12M; break;
5935 case DESC92S_RATE18M: ret_rate = MGN_18M; break;
5936 case DESC92S_RATE24M: ret_rate = MGN_24M; break;
5937 case DESC92S_RATE36M: ret_rate = MGN_36M; break;
5938 case DESC92S_RATE48M: ret_rate = MGN_48M; break;
5939 case DESC92S_RATE54M: ret_rate = MGN_54M; break;
5940 case DESC92S_RATEMCS0: ret_rate = MGN_MCS0; break;
5941 case DESC92S_RATEMCS1: ret_rate = MGN_MCS1; break;
5942 case DESC92S_RATEMCS2: ret_rate = MGN_MCS2; break;
5943 case DESC92S_RATEMCS3: ret_rate = MGN_MCS3; break;
5944 case DESC92S_RATEMCS4: ret_rate = MGN_MCS4; break;
5945 case DESC92S_RATEMCS5: ret_rate = MGN_MCS5; break;
5946 case DESC92S_RATEMCS6: ret_rate = MGN_MCS6; break;
5947 case DESC92S_RATEMCS7: ret_rate = MGN_MCS7; break;
5948 case DESC92S_RATEMCS8: ret_rate = MGN_MCS8; break;
5949 case DESC92S_RATEMCS9: ret_rate = MGN_MCS9; break;
5950 case DESC92S_RATEMCS10: ret_rate = MGN_MCS10; break;
5951 case DESC92S_RATEMCS11: ret_rate = MGN_MCS11; break;
5952 case DESC92S_RATEMCS12: ret_rate = MGN_MCS12; break;
5953 case DESC92S_RATEMCS13: ret_rate = MGN_MCS13; break;
5954 case DESC92S_RATEMCS14: ret_rate = MGN_MCS14; break;
5955 case DESC92S_RATEMCS15: ret_rate = MGN_MCS15; break;
5956 case DESC92S_RATEMCS32: ret_rate = (0x80|0x20); break;
5957
5958 default:
5959 RT_TRACE(COMP_RECV, "HwRateToMRate92S(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT );
5960 break;
5961 }
5962 }
5963 return ret_rate;
5964 }
5965
5966 u8 HwRateToMRate90(bool bIsHT, u8 rate)
5967 {
5968 u8 ret_rate = 0xff;
5969
5970 if(!bIsHT) {
5971 switch(rate) {
5972 case DESC90_RATE1M: ret_rate = MGN_1M; break;
5973 case DESC90_RATE2M: ret_rate = MGN_2M; break;
5974 case DESC90_RATE5_5M: ret_rate = MGN_5_5M; break;
5975 case DESC90_RATE11M: ret_rate = MGN_11M; break;
5976 case DESC90_RATE6M: ret_rate = MGN_6M; break;
5977 case DESC90_RATE9M: ret_rate = MGN_9M; break;
5978 case DESC90_RATE12M: ret_rate = MGN_12M; break;
5979 case DESC90_RATE18M: ret_rate = MGN_18M; break;
5980 case DESC90_RATE24M: ret_rate = MGN_24M; break;
5981 case DESC90_RATE36M: ret_rate = MGN_36M; break;
5982 case DESC90_RATE48M: ret_rate = MGN_48M; break;
5983 case DESC90_RATE54M: ret_rate = MGN_54M; break;
5984
5985 default:
5986 ret_rate = 0xff;
5987 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n", rate, bIsHT);
5988 break;
5989 }
5990
5991 } else {
5992 switch(rate) {
5993 case DESC90_RATEMCS0: ret_rate = MGN_MCS0; break;
5994 case DESC90_RATEMCS1: ret_rate = MGN_MCS1; break;
5995 case DESC90_RATEMCS2: ret_rate = MGN_MCS2; break;
5996 case DESC90_RATEMCS3: ret_rate = MGN_MCS3; break;
5997 case DESC90_RATEMCS4: ret_rate = MGN_MCS4; break;
5998 case DESC90_RATEMCS5: ret_rate = MGN_MCS5; break;
5999 case DESC90_RATEMCS6: ret_rate = MGN_MCS6; break;
6000 case DESC90_RATEMCS7: ret_rate = MGN_MCS7; break;
6001 case DESC90_RATEMCS8: ret_rate = MGN_MCS8; break;
6002 case DESC90_RATEMCS9: ret_rate = MGN_MCS9; break;
6003 case DESC90_RATEMCS10: ret_rate = MGN_MCS10; break;
6004 case DESC90_RATEMCS11: ret_rate = MGN_MCS11; break;
6005 case DESC90_RATEMCS12: ret_rate = MGN_MCS12; break;
6006 case DESC90_RATEMCS13: ret_rate = MGN_MCS13; break;
6007 case DESC90_RATEMCS14: ret_rate = MGN_MCS14; break;
6008 case DESC90_RATEMCS15: ret_rate = MGN_MCS15; break;
6009 case DESC90_RATEMCS32: ret_rate = (0x80|0x20); break;
6010
6011 default:
6012 ret_rate = 0xff;
6013 RT_TRACE(COMP_RECV, "HwRateToMRate90(): Non supported Rate [%x], bIsHT = %d!!!\n",rate, bIsHT);
6014 break;
6015 }
6016 }
6017
6018 return ret_rate;
6019 }
6020
6021 /**
6022 * Function: UpdateRxPktTimeStamp
6023 * Overview: Recored down the TSF time stamp when receiving a packet
6024 *
6025 * Input:
6026 * PADAPTER Adapter
6027 * PRT_RFD pRfd,
6028 *
6029 * Output:
6030 * PRT_RFD pRfd
6031 * (pRfd->Status.TimeStampHigh is updated)
6032 * (pRfd->Status.TimeStampLow is updated)
6033 * Return:
6034 * None
6035 */
6036 void UpdateRxPktTimeStamp8190 (struct net_device *dev, struct ieee80211_rx_stats *stats)
6037 {
6038 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6039
6040 if(stats->bIsAMPDU && !stats->bFirstMPDU) {
6041 stats->mac_time[0] = priv->LastRxDescTSFLow;
6042 stats->mac_time[1] = priv->LastRxDescTSFHigh;
6043 } else {
6044 priv->LastRxDescTSFLow = stats->mac_time[0];
6045 priv->LastRxDescTSFHigh = stats->mac_time[1];
6046 }
6047 }
6048
6049 //by amy 080606
6050
6051 long rtl819x_translate_todbm(u8 signal_strength_index )// 0-100 index.
6052 {
6053 long signal_power; // in dBm.
6054
6055 // Translate to dBm (x=0.5y-95).
6056 signal_power = (long)((signal_strength_index + 1) >> 1);
6057 signal_power -= 95;
6058
6059 return signal_power;
6060 }
6061
6062
6063 /* 2008/01/22 MH We can not delcare RSSI/EVM total value of sliding window to
6064 be a local static. Otherwise, it may increase when we return from S3/S4. The
6065 value will be kept in memory or disk. We must delcare the value in adapter
6066 and it will be reinitialized when return from S3/S4. */
6067 void rtl8192_process_phyinfo(struct r8192_priv * priv,u8* buffer, struct ieee80211_rx_stats * pprevious_stats, struct ieee80211_rx_stats * pcurrent_stats)
6068 {
6069 bool bcheck = false;
6070 u8 rfpath;
6071 u32 nspatial_stream, tmp_val;
6072 //u8 i;
6073 static u32 slide_rssi_index=0, slide_rssi_statistics=0;
6074 static u32 slide_evm_index=0, slide_evm_statistics=0;
6075 static u32 last_rssi=0, last_evm=0;
6076
6077 static u32 slide_beacon_adc_pwdb_index=0, slide_beacon_adc_pwdb_statistics=0;
6078 static u32 last_beacon_adc_pwdb=0;
6079
6080 struct ieee80211_hdr_3addr *hdr;
6081 u16 sc ;
6082 unsigned int frag,seq;
6083 hdr = (struct ieee80211_hdr_3addr *)buffer;
6084 sc = le16_to_cpu(hdr->seq_ctrl);
6085 frag = WLAN_GET_SEQ_FRAG(sc);
6086 seq = WLAN_GET_SEQ_SEQ(sc);
6087 //cosa add 04292008 to record the sequence number
6088 pcurrent_stats->Seq_Num = seq;
6089 //
6090 // Check whether we should take the previous packet into accounting
6091 //
6092 if(!pprevious_stats->bIsAMPDU)
6093 {
6094 // if previous packet is not aggregated packet
6095 bcheck = true;
6096 }else
6097 {
6098 }
6099
6100
6101 if(slide_rssi_statistics++ >= PHY_RSSI_SLID_WIN_MAX)
6102 {
6103 slide_rssi_statistics = PHY_RSSI_SLID_WIN_MAX;
6104 last_rssi = priv->stats.slide_signal_strength[slide_rssi_index];
6105 priv->stats.slide_rssi_total -= last_rssi;
6106 }
6107 priv->stats.slide_rssi_total += pprevious_stats->SignalStrength;
6108
6109 priv->stats.slide_signal_strength[slide_rssi_index++] = pprevious_stats->SignalStrength;
6110 if(slide_rssi_index >= PHY_RSSI_SLID_WIN_MAX)
6111 slide_rssi_index = 0;
6112
6113 // <1> Showed on UI for user, in dbm
6114 tmp_val = priv->stats.slide_rssi_total/slide_rssi_statistics;
6115 priv->stats.signal_strength = rtl819x_translate_todbm((u8)tmp_val);
6116 pcurrent_stats->rssi = priv->stats.signal_strength;
6117 //
6118 // If the previous packet does not match the criteria, neglect it
6119 //
6120 if(!pprevious_stats->bPacketMatchBSSID)
6121 {
6122 if(!pprevious_stats->bToSelfBA)
6123 return;
6124 }
6125
6126 if(!bcheck)
6127 return;
6128
6129
6130 //rtl8190_process_cck_rxpathsel(priv,pprevious_stats);//only rtl8190 supported
6131
6132 //
6133 // Check RSSI
6134 //
6135 priv->stats.num_process_phyinfo++;
6136
6137 /* record the general signal strength to the sliding window. */
6138
6139
6140 // <2> Showed on UI for engineering
6141 // hardware does not provide rssi information for each rf path in CCK
6142 if(!pprevious_stats->bIsCCK && (pprevious_stats->bPacketToSelf || pprevious_stats->bToSelfBA))
6143 {
6144 for (rfpath = RF90_PATH_A; rfpath < priv->NumTotalRFPath; rfpath++)
6145 {
6146 if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, rfpath))
6147 continue;
6148
6149 //Fixed by Jacken 2008-03-20
6150 if(priv->stats.rx_rssi_percentage[rfpath] == 0)
6151 {
6152 priv->stats.rx_rssi_percentage[rfpath] = pprevious_stats->RxMIMOSignalStrength[rfpath];
6153 //DbgPrint("MIMO RSSI initialize \n");
6154 }
6155 if(pprevious_stats->RxMIMOSignalStrength[rfpath] > priv->stats.rx_rssi_percentage[rfpath])
6156 {
6157 priv->stats.rx_rssi_percentage[rfpath] =
6158 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
6159 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
6160 priv->stats.rx_rssi_percentage[rfpath] = priv->stats.rx_rssi_percentage[rfpath] + 1;
6161 }
6162 else
6163 {
6164 priv->stats.rx_rssi_percentage[rfpath] =
6165 ( (priv->stats.rx_rssi_percentage[rfpath]*(Rx_Smooth_Factor-1)) +
6166 (pprevious_stats->RxMIMOSignalStrength[rfpath])) /(Rx_Smooth_Factor);
6167 }
6168 RT_TRACE(COMP_DBG,"priv->stats.rx_rssi_percentage[rfPath] = %d \n" ,priv->stats.rx_rssi_percentage[rfpath] );
6169 }
6170 }
6171
6172
6173 //
6174 // Check PWDB.
6175 //
6176 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
6177 pprevious_stats->bIsCCK? "CCK": "OFDM",
6178 pprevious_stats->RxPWDBAll);
6179
6180 if(pprevious_stats->bPacketBeacon)
6181 {
6182 /* record the beacon pwdb to the sliding window. */
6183 if(slide_beacon_adc_pwdb_statistics++ >= PHY_Beacon_RSSI_SLID_WIN_MAX)
6184 {
6185 slide_beacon_adc_pwdb_statistics = PHY_Beacon_RSSI_SLID_WIN_MAX;
6186 last_beacon_adc_pwdb = priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index];
6187 priv->stats.Slide_Beacon_Total -= last_beacon_adc_pwdb;
6188 //DbgPrint("slide_beacon_adc_pwdb_index = %d, last_beacon_adc_pwdb = %d, Adapter->RxStats.Slide_Beacon_Total = %d\n",
6189 // slide_beacon_adc_pwdb_index, last_beacon_adc_pwdb, Adapter->RxStats.Slide_Beacon_Total);
6190 }
6191 priv->stats.Slide_Beacon_Total += pprevious_stats->RxPWDBAll;
6192 priv->stats.Slide_Beacon_pwdb[slide_beacon_adc_pwdb_index] = pprevious_stats->RxPWDBAll;
6193 //DbgPrint("slide_beacon_adc_pwdb_index = %d, pPreviousRfd->Status.RxPWDBAll = %d\n", slide_beacon_adc_pwdb_index, pPreviousRfd->Status.RxPWDBAll);
6194 slide_beacon_adc_pwdb_index++;
6195 if(slide_beacon_adc_pwdb_index >= PHY_Beacon_RSSI_SLID_WIN_MAX)
6196 slide_beacon_adc_pwdb_index = 0;
6197 pprevious_stats->RxPWDBAll = priv->stats.Slide_Beacon_Total/slide_beacon_adc_pwdb_statistics;
6198 if(pprevious_stats->RxPWDBAll >= 3)
6199 pprevious_stats->RxPWDBAll -= 3;
6200 }
6201
6202 RT_TRACE(COMP_RXDESC, "Smooth %s PWDB = %d\n",
6203 pprevious_stats->bIsCCK? "CCK": "OFDM",
6204 pprevious_stats->RxPWDBAll);
6205
6206
6207 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
6208 {
6209 if(priv->undecorated_smoothed_pwdb < 0) // initialize
6210 {
6211 priv->undecorated_smoothed_pwdb = pprevious_stats->RxPWDBAll;
6212 //DbgPrint("First pwdb initialize \n");
6213 }
6214 #if 1
6215 if(pprevious_stats->RxPWDBAll > (u32)priv->undecorated_smoothed_pwdb)
6216 {
6217 priv->undecorated_smoothed_pwdb =
6218 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
6219 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
6220 priv->undecorated_smoothed_pwdb = priv->undecorated_smoothed_pwdb + 1;
6221 }
6222 else
6223 {
6224 priv->undecorated_smoothed_pwdb =
6225 ( ((priv->undecorated_smoothed_pwdb)*(Rx_Smooth_Factor-1)) +
6226 (pprevious_stats->RxPWDBAll)) /(Rx_Smooth_Factor);
6227 }
6228 #else
6229 //Fixed by Jacken 2008-03-20
6230 if(pPreviousRfd->Status.RxPWDBAll > (u32)pHalData->UndecoratedSmoothedPWDB)
6231 {
6232 pHalData->UndecoratedSmoothedPWDB =
6233 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
6234 pHalData->UndecoratedSmoothedPWDB = pHalData->UndecoratedSmoothedPWDB + 1;
6235 }
6236 else
6237 {
6238 pHalData->UndecoratedSmoothedPWDB =
6239 ( ((pHalData->UndecoratedSmoothedPWDB)* 5) + (pPreviousRfd->Status.RxPWDBAll)) / 6;
6240 }
6241 #endif
6242
6243 }
6244
6245 //
6246 // Check EVM
6247 //
6248 /* record the general EVM to the sliding window. */
6249 if(pprevious_stats->SignalQuality == 0)
6250 {
6251 }
6252 else
6253 {
6254 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA){
6255 if(slide_evm_statistics++ >= PHY_RSSI_SLID_WIN_MAX){
6256 slide_evm_statistics = PHY_RSSI_SLID_WIN_MAX;
6257 last_evm = priv->stats.slide_evm[slide_evm_index];
6258 priv->stats.slide_evm_total -= last_evm;
6259 }
6260
6261 priv->stats.slide_evm_total += pprevious_stats->SignalQuality;
6262
6263 priv->stats.slide_evm[slide_evm_index++] = pprevious_stats->SignalQuality;
6264 if(slide_evm_index >= PHY_RSSI_SLID_WIN_MAX)
6265 slide_evm_index = 0;
6266
6267 // <1> Showed on UI for user, in percentage.
6268 tmp_val = priv->stats.slide_evm_total/slide_evm_statistics;
6269 priv->stats.signal_quality = tmp_val;
6270 //cosa add 10/11/2007, Showed on UI for user in Windows Vista, for Link quality.
6271 priv->stats.last_signal_strength_inpercent = tmp_val;
6272 }
6273
6274 // <2> Showed on UI for engineering
6275 if(pprevious_stats->bPacketToSelf || pprevious_stats->bPacketBeacon || pprevious_stats->bToSelfBA)
6276 {
6277 for(nspatial_stream = 0; nspatial_stream<2 ; nspatial_stream++) // 2 spatial stream
6278 {
6279 if(pprevious_stats->RxMIMOSignalQuality[nspatial_stream] != -1)
6280 {
6281 if(priv->stats.rx_evm_percentage[nspatial_stream] == 0) // initialize
6282 {
6283 priv->stats.rx_evm_percentage[nspatial_stream] = pprevious_stats->RxMIMOSignalQuality[nspatial_stream];
6284 }
6285 priv->stats.rx_evm_percentage[nspatial_stream] =
6286 ( (priv->stats.rx_evm_percentage[nspatial_stream]* (Rx_Smooth_Factor-1)) +
6287 (pprevious_stats->RxMIMOSignalQuality[nspatial_stream]* 1)) / (Rx_Smooth_Factor);
6288 }
6289 }
6290 }
6291 }
6292
6293
6294 }
6295
6296 /*-----------------------------------------------------------------------------
6297 * Function: rtl819x_query_rxpwrpercentage()
6298 *
6299 * Overview:
6300 *
6301 * Input: char antpower
6302 *
6303 * Output: NONE
6304 *
6305 * Return: 0-100 percentage
6306 *
6307 * Revised History:
6308 * When Who Remark
6309 * 05/26/2008 amy Create Version 0 porting from windows code.
6310 *
6311 *---------------------------------------------------------------------------*/
6312 static u8 rtl819x_query_rxpwrpercentage(
6313 char antpower
6314 )
6315 {
6316 if ((antpower <= -100) || (antpower >= 20))
6317 {
6318 return 0;
6319 }
6320 else if (antpower >= 0)
6321 {
6322 return 100;
6323 }
6324 else
6325 {
6326 return (100+antpower);
6327 }
6328
6329 } /* QueryRxPwrPercentage */
6330
6331 static u8
6332 rtl819x_evm_dbtopercentage(
6333 char value
6334 )
6335 {
6336 char ret_val;
6337
6338 ret_val = value;
6339
6340 if(ret_val >= 0)
6341 ret_val = 0;
6342 if(ret_val <= -33)
6343 ret_val = -33;
6344 ret_val = 0 - ret_val;
6345 ret_val*=3;
6346 if(ret_val == 99)
6347 ret_val = 100;
6348 return(ret_val);
6349 }
6350 //
6351 // Description:
6352 // We want good-looking for signal strength/quality
6353 // 2007/7/19 01:09, by cosa.
6354 //
6355 long
6356 rtl819x_signal_scale_mapping(
6357 long currsig
6358 )
6359 {
6360 long retsig;
6361
6362 // Step 1. Scale mapping.
6363 if(currsig >= 61 && currsig <= 100)
6364 {
6365 retsig = 90 + ((currsig - 60) / 4);
6366 }
6367 else if(currsig >= 41 && currsig <= 60)
6368 {
6369 retsig = 78 + ((currsig - 40) / 2);
6370 }
6371 else if(currsig >= 31 && currsig <= 40)
6372 {
6373 retsig = 66 + (currsig - 30);
6374 }
6375 else if(currsig >= 21 && currsig <= 30)
6376 {
6377 retsig = 54 + (currsig - 20);
6378 }
6379 else if(currsig >= 5 && currsig <= 20)
6380 {
6381 retsig = 42 + (((currsig - 5) * 2) / 3);
6382 }
6383 else if(currsig == 4)
6384 {
6385 retsig = 36;
6386 }
6387 else if(currsig == 3)
6388 {
6389 retsig = 27;
6390 }
6391 else if(currsig == 2)
6392 {
6393 retsig = 18;
6394 }
6395 else if(currsig == 1)
6396 {
6397 retsig = 9;
6398 }
6399 else
6400 {
6401 retsig = currsig;
6402 }
6403
6404 return retsig;
6405 }
6406
6407 /*-----------------------------------------------------------------------------
6408 * Function: QueryRxPhyStatus8192S()
6409 *
6410 * Overview:
6411 *
6412 * Input: NONE
6413 *
6414 * Output: NONE
6415 *
6416 * Return: NONE
6417 *
6418 * Revised History:
6419 * When Who Remark
6420 * 06/01/2007 MHC Create Version 0.
6421 * 06/05/2007 MHC Accordign to HW's new data sheet, we add CCK and OFDM
6422 * descriptor definition.
6423 * 07/04/2007 MHC According to Jerry and Bryant's document. We read
6424 * ir_isolation and ext_lna for RF's init value and use
6425 * to compensate RSSI after receiving packets.
6426 * 09/10/2008 MHC Modify name and PHY status field for 92SE.
6427 * 09/19/2008 MHC Add CCK/OFDM SS/SQ for 92S series.
6428 *
6429 *---------------------------------------------------------------------------*/
6430 static void rtl8192SU_query_rxphystatus(
6431 struct r8192_priv * priv,
6432 struct ieee80211_rx_stats * pstats,
6433 rx_desc_819x_usb *pDesc,
6434 rx_drvinfo_819x_usb * pdrvinfo,
6435 struct ieee80211_rx_stats * precord_stats,
6436 bool bpacket_match_bssid,
6437 bool bpacket_toself,
6438 bool bPacketBeacon,
6439 bool bToSelfBA
6440 )
6441 {
6442 //PRT_RFD_STATUS pRtRfdStatus = &(pRfd->Status);
6443 //PHY_STS_CCK_8192S_T *pCck_buf;
6444 phy_sts_cck_819xusb_t * pcck_buf;
6445 phy_ofdm_rx_status_rxsc_sgien_exintfflag* prxsc;
6446 //u8 *prxpkt;
6447 //u8 i, max_spatial_stream, tmp_rxsnr, tmp_rxevm, rxsc_sgien_exflg;
6448 u8 i, max_spatial_stream, rxsc_sgien_exflg;
6449 char rx_pwr[4], rx_pwr_all=0;
6450 //long rx_avg_pwr = 0;
6451 //char rx_snrX, rx_evmX;
6452 u8 evm, pwdb_all;
6453 u32 RSSI, total_rssi=0;//, total_evm=0;
6454 // long signal_strength_index = 0;
6455 u8 is_cck_rate=0;
6456 u8 rf_rx_num = 0;
6457
6458
6459
6460 priv->stats.numqry_phystatus++;
6461
6462 is_cck_rate = rx_hal_is_cck_rate(pDesc);
6463
6464 // Record it for next packet processing
6465 memset(precord_stats, 0, sizeof(struct ieee80211_rx_stats));
6466 pstats->bPacketMatchBSSID = precord_stats->bPacketMatchBSSID = bpacket_match_bssid;
6467 pstats->bPacketToSelf = precord_stats->bPacketToSelf = bpacket_toself;
6468 pstats->bIsCCK = precord_stats->bIsCCK = is_cck_rate;//RX_HAL_IS_CCK_RATE(pDrvInfo);
6469 pstats->bPacketBeacon = precord_stats->bPacketBeacon = bPacketBeacon;
6470 pstats->bToSelfBA = precord_stats->bToSelfBA = bToSelfBA;
6471
6472
6473 pstats->RxMIMOSignalQuality[0] = -1;
6474 pstats->RxMIMOSignalQuality[1] = -1;
6475 precord_stats->RxMIMOSignalQuality[0] = -1;
6476 precord_stats->RxMIMOSignalQuality[1] = -1;
6477
6478 if(is_cck_rate)
6479 {
6480 u8 report;//, tmp_pwdb;
6481 //char cck_adc_pwdb[4];
6482
6483 // CCK Driver info Structure is not the same as OFDM packet.
6484 pcck_buf = (phy_sts_cck_819xusb_t *)pdrvinfo;
6485
6486 //
6487 // (1)Hardware does not provide RSSI for CCK
6488 //
6489
6490 //
6491 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
6492 //
6493
6494 priv->stats.numqry_phystatusCCK++;
6495
6496 if(!priv->bCckHighPower)
6497 {
6498 report = pcck_buf->cck_agc_rpt & 0xc0;
6499 report = report>>6;
6500 switch(report)
6501 {
6502 //Fixed by Jacken from Bryant 2008-03-20
6503 //Original value is -38 , -26 , -14 , -2
6504 //Fixed value is -35 , -23 , -11 , 6
6505 case 0x3:
6506 rx_pwr_all = -35 - (pcck_buf->cck_agc_rpt & 0x3e);
6507 break;
6508 case 0x2:
6509 rx_pwr_all = -23 - (pcck_buf->cck_agc_rpt & 0x3e);
6510 break;
6511 case 0x1:
6512 rx_pwr_all = -11 - (pcck_buf->cck_agc_rpt & 0x3e);
6513 break;
6514 case 0x0:
6515 rx_pwr_all = 8 - (pcck_buf->cck_agc_rpt & 0x3e);//6->8
6516 break;
6517 }
6518 }
6519 else
6520 {
6521 report = pdrvinfo->cfosho[0] & 0x60;
6522 report = report>>5;
6523 switch(report)
6524 {
6525 case 0x3:
6526 rx_pwr_all = -35 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
6527 break;
6528 case 0x2:
6529 rx_pwr_all = -23 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1);
6530 break;
6531 case 0x1:
6532 rx_pwr_all = -11 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;
6533 break;
6534 case 0x0:
6535 rx_pwr_all = -8 - ((pcck_buf->cck_agc_rpt & 0x1f)<<1) ;//6->-8
6536 break;
6537 }
6538 }
6539
6540 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);//check it
6541 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
6542 //pstats->RecvSignalPower = pwdb_all;
6543 pstats->RecvSignalPower = rx_pwr_all;
6544
6545 //
6546 // (3) Get Signal Quality (EVM)
6547 //
6548 //if(bpacket_match_bssid)
6549 {
6550 u8 sq;
6551
6552 if(pstats->RxPWDBAll > 40)
6553 {
6554 sq = 100;
6555 }else
6556 {
6557 sq = pcck_buf->sq_rpt;
6558
6559 if(pcck_buf->sq_rpt > 64)
6560 sq = 0;
6561 else if (pcck_buf->sq_rpt < 20)
6562 sq = 100;
6563 else
6564 sq = ((64-sq) * 100) / 44;
6565 }
6566 pstats->SignalQuality = precord_stats->SignalQuality = sq;
6567 pstats->RxMIMOSignalQuality[0] = precord_stats->RxMIMOSignalQuality[0] = sq;
6568 pstats->RxMIMOSignalQuality[1] = precord_stats->RxMIMOSignalQuality[1] = -1;
6569 }
6570 }
6571 else
6572 {
6573 priv->stats.numqry_phystatusHT++;
6574
6575 // 2008/09/19 MH For 92S debug, RX RF path always enable!!
6576 priv->brfpath_rxenable[0] = priv->brfpath_rxenable[1] = TRUE;
6577
6578 //
6579 // (1)Get RSSI for HT rate
6580 //
6581 //for(i=RF90_PATH_A; i<priv->NumTotalRFPath; i++)
6582 for(i=RF90_PATH_A; i<RF90_PATH_MAX; i++)
6583 {
6584 // 2008/01/30 MH we will judge RF RX path now.
6585 if (priv->brfpath_rxenable[i])
6586 rf_rx_num++;
6587 //else
6588 // continue;
6589
6590 //if (!rtl8192_phy_CheckIsLegalRFPath(priv->ieee80211->dev, i))
6591 // continue;
6592
6593 //Fixed by Jacken from Bryant 2008-03-20
6594 //Original value is 106
6595 //rx_pwr[i] = ((pofdm_buf->trsw_gain_X[i]&0x3F)*2) - 106;
6596 rx_pwr[i] = ((pdrvinfo->gain_trsw[i]&0x3F)*2) - 110;
6597
6598 /* Translate DBM to percentage. */
6599 RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]); //check ok
6600 total_rssi += RSSI;
6601 RT_TRACE(COMP_RF, "RF-%d RXPWR=%x RSSI=%d\n", i, rx_pwr[i], RSSI);
6602
6603 //Get Rx snr value in DB
6604 //tmp_rxsnr = pofdm_buf->rxsnr_X[i];
6605 //rx_snrX = (char)(tmp_rxsnr);
6606 //rx_snrX /= 2;
6607 //priv->stats.rxSNRdB[i] = (long)rx_snrX;
6608 priv->stats.rxSNRdB[i] = (long)(pdrvinfo->rxsnr[i]/2);
6609
6610 /* Translate DBM to percentage. */
6611 //RSSI = rtl819x_query_rxpwrpercentage(rx_pwr[i]);
6612 //total_rssi += RSSI;
6613
6614 /* Record Signal Strength for next packet */
6615 //if(bpacket_match_bssid)
6616 {
6617 pstats->RxMIMOSignalStrength[i] =(u8) RSSI;
6618 precord_stats->RxMIMOSignalStrength[i] =(u8) RSSI;
6619 }
6620 }
6621
6622
6623 //
6624 // (2)PWDB, Average PWDB cacluated by hardware (for rate adaptive)
6625 //
6626 //Fixed by Jacken from Bryant 2008-03-20
6627 //Original value is 106
6628 //rx_pwr_all = (((pofdm_buf->pwdb_all ) >> 1 )& 0x7f) -106;
6629 rx_pwr_all = (((pdrvinfo->pwdb_all ) >> 1 )& 0x7f) -106;
6630 pwdb_all = rtl819x_query_rxpwrpercentage(rx_pwr_all);
6631
6632 pstats->RxPWDBAll = precord_stats->RxPWDBAll = pwdb_all;
6633 pstats->RxPower = precord_stats->RxPower = rx_pwr_all;
6634 pstats->RecvSignalPower = rx_pwr_all;
6635
6636 //
6637 // (3)EVM of HT rate
6638 //
6639 //if(pdrvinfo->RxHT && pdrvinfo->RxRate>=DESC90_RATEMCS8 &&
6640 // pdrvinfo->RxRate<=DESC90_RATEMCS15)
6641 if(pDesc->RxHT && pDesc->RxMCS>=DESC92S_RATEMCS8 &&
6642 pDesc->RxMCS<=DESC92S_RATEMCS15)
6643 max_spatial_stream = 2; //both spatial stream make sense
6644 else
6645 max_spatial_stream = 1; //only spatial stream 1 makes sense
6646
6647 for(i=0; i<max_spatial_stream; i++)
6648 {
6649 //tmp_rxevm = pofdm_buf->rxevm_X[i];
6650 //rx_evmX = (char)(tmp_rxevm);
6651
6652 // Do not use shift operation like "rx_evmX >>= 1" because the compilor of free build environment
6653 // fill most significant bit to "zero" when doing shifting operation which may change a negative
6654 // value to positive one, then the dbm value (which is supposed to be negative) is not correct anymore.
6655 //rx_evmX /= 2; //dbm
6656
6657 //evm = rtl819x_evm_dbtopercentage(rx_evmX);
6658 evm = rtl819x_evm_dbtopercentage( (pdrvinfo->rxevm[i] /*/ 2*/)); //dbm
6659 RT_TRACE(COMP_RF, "RXRATE=%x RXEVM=%x EVM=%s%d\n", pDesc->RxMCS, pdrvinfo->rxevm[i], "%", evm);
6660
6661 //if(bpacket_match_bssid)
6662 {
6663 if(i==0) // Fill value in RFD, Get the first spatial stream only
6664 pstats->SignalQuality = precord_stats->SignalQuality = (u8)(evm & 0xff);
6665 pstats->RxMIMOSignalQuality[i] = precord_stats->RxMIMOSignalQuality[i] = (u8)(evm & 0xff);
6666 }
6667 }
6668
6669
6670 /* record rx statistics for debug */
6671 //rxsc_sgien_exflg = pofdm_buf->rxsc_sgien_exflg;
6672 prxsc = (phy_ofdm_rx_status_rxsc_sgien_exintfflag *)&rxsc_sgien_exflg;
6673 //if(pdrvinfo->BW) //40M channel
6674 if(pDesc->BW) //40M channel
6675 priv->stats.received_bwtype[1+pdrvinfo->rxsc]++;
6676 else //20M channel
6677 priv->stats.received_bwtype[0]++;
6678 }
6679
6680 //UI BSS List signal strength(in percentage), make it good looking, from 0~100.
6681 //It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
6682 if(is_cck_rate)
6683 {
6684 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)pwdb_all));//PWDB_ALL;//check ok
6685
6686 }
6687 else
6688 {
6689 //pRfd->Status.SignalStrength = pRecordRfd->Status.SignalStrength = (u8)(SignalScaleMapping(total_rssi/=RF90_PATH_MAX));//(u8)(total_rssi/=RF90_PATH_MAX);
6690 // We can judge RX path number now.
6691 if (rf_rx_num != 0)
6692 pstats->SignalStrength = precord_stats->SignalStrength = (u8)(rtl819x_signal_scale_mapping((long)(total_rssi/=rf_rx_num)));
6693 }
6694 }/* QueryRxPhyStatus8192S */
6695
6696 void
6697 rtl8192_record_rxdesc_forlateruse(
6698 struct ieee80211_rx_stats * psrc_stats,
6699 struct ieee80211_rx_stats * ptarget_stats
6700 )
6701 {
6702 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
6703 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
6704 ptarget_stats->Seq_Num = psrc_stats->Seq_Num;
6705 }
6706
6707 static void rtl8192SU_query_rxphystatus(
6708 struct r8192_priv * priv,
6709 struct ieee80211_rx_stats * pstats,
6710 rx_desc_819x_usb *pDesc,
6711 rx_drvinfo_819x_usb * pdrvinfo,
6712 struct ieee80211_rx_stats * precord_stats,
6713 bool bpacket_match_bssid,
6714 bool bpacket_toself,
6715 bool bPacketBeacon,
6716 bool bToSelfBA
6717 );
6718 void rtl8192SU_TranslateRxSignalStuff(struct sk_buff *skb,
6719 struct ieee80211_rx_stats * pstats,
6720 rx_desc_819x_usb *pDesc,
6721 rx_drvinfo_819x_usb *pdrvinfo)
6722 {
6723 // TODO: We must only check packet for current MAC address. Not finish
6724 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
6725 struct net_device *dev=info->dev;
6726 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6727 bool bpacket_match_bssid, bpacket_toself;
6728 bool bPacketBeacon=FALSE, bToSelfBA=FALSE;
6729 static struct ieee80211_rx_stats previous_stats;
6730 struct ieee80211_hdr_3addr *hdr;//by amy
6731 u16 fc,type;
6732
6733 // Get Signal Quality for only RX data queue (but not command queue)
6734
6735 u8* tmp_buf;
6736 //u16 tmp_buf_len = 0;
6737 u8 *praddr;
6738
6739 /* Get MAC frame start address. */
6740 tmp_buf = (u8*)skb->data;// + get_rxpacket_shiftbytes_819xusb(pstats);
6741
6742 hdr = (struct ieee80211_hdr_3addr *)tmp_buf;
6743 fc = le16_to_cpu(hdr->frame_control);
6744 type = WLAN_FC_GET_TYPE(fc);
6745 praddr = hdr->addr1;
6746
6747 /* Check if the received packet is acceptabe. */
6748 bpacket_match_bssid = ((IEEE80211_FTYPE_CTL != type) &&
6749 (eqMacAddr(priv->ieee80211->current_network.bssid, (fc & IEEE80211_FCTL_TODS)? hdr->addr1 : (fc & IEEE80211_FCTL_FROMDS )? hdr->addr2 : hdr->addr3))
6750 && (!pstats->bHwError) && (!pstats->bCRC)&& (!pstats->bICV));
6751 bpacket_toself = bpacket_match_bssid & (eqMacAddr(praddr, priv->ieee80211->dev->dev_addr));
6752
6753 #if 1//cosa
6754 if(WLAN_FC_GET_FRAMETYPE(fc)== IEEE80211_STYPE_BEACON)
6755 {
6756 bPacketBeacon = true;
6757 //DbgPrint("Beacon 2, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
6758 }
6759 if(WLAN_FC_GET_FRAMETYPE(fc) == IEEE80211_STYPE_BLOCKACK)
6760 {
6761 if((eqMacAddr(praddr,dev->dev_addr)))
6762 bToSelfBA = true;
6763 //DbgPrint("BlockAck, MatchBSSID = %d, ToSelf = %d \n", bPacketMatchBSSID, bPacketToSelf);
6764 }
6765
6766 #endif
6767
6768
6769 if(bpacket_match_bssid)
6770 {
6771 priv->stats.numpacket_matchbssid++;
6772 }
6773 if(bpacket_toself){
6774 priv->stats.numpacket_toself++;
6775 }
6776 //
6777 // Process PHY information for previous packet (RSSI/PWDB/EVM)
6778 //
6779 // Because phy information is contained in the last packet of AMPDU only, so driver
6780 // should process phy information of previous packet
6781 rtl8192_process_phyinfo(priv, tmp_buf, &previous_stats, pstats);
6782 rtl8192SU_query_rxphystatus(priv, pstats, pDesc, pdrvinfo, &previous_stats, bpacket_match_bssid,bpacket_toself,bPacketBeacon,bToSelfBA);
6783 rtl8192_record_rxdesc_forlateruse(pstats, &previous_stats);
6784
6785 }
6786
6787 /**
6788 * Function: UpdateReceivedRateHistogramStatistics
6789 * Overview: Recored down the received data rate
6790 *
6791 * Input:
6792 * struct net_device *dev
6793 * struct ieee80211_rx_stats *stats
6794 *
6795 * Output:
6796 *
6797 * (priv->stats.ReceivedRateHistogram[] is updated)
6798 * Return:
6799 * None
6800 */
6801 void
6802 UpdateReceivedRateHistogramStatistics8190(
6803 struct net_device *dev,
6804 struct ieee80211_rx_stats *stats
6805 )
6806 {
6807 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6808 u32 rcvType=1; //0: Total, 1:OK, 2:CRC, 3:ICV
6809 u32 rateIndex;
6810 u32 preamble_guardinterval; //1: short preamble/GI, 0: long preamble/GI
6811
6812
6813 if(stats->bCRC)
6814 rcvType = 2;
6815 else if(stats->bICV)
6816 rcvType = 3;
6817
6818 if(stats->bShortPreamble)
6819 preamble_guardinterval = 1;// short
6820 else
6821 preamble_guardinterval = 0;// long
6822
6823 switch(stats->rate)
6824 {
6825 //
6826 // CCK rate
6827 //
6828 case MGN_1M: rateIndex = 0; break;
6829 case MGN_2M: rateIndex = 1; break;
6830 case MGN_5_5M: rateIndex = 2; break;
6831 case MGN_11M: rateIndex = 3; break;
6832 //
6833 // Legacy OFDM rate
6834 //
6835 case MGN_6M: rateIndex = 4; break;
6836 case MGN_9M: rateIndex = 5; break;
6837 case MGN_12M: rateIndex = 6; break;
6838 case MGN_18M: rateIndex = 7; break;
6839 case MGN_24M: rateIndex = 8; break;
6840 case MGN_36M: rateIndex = 9; break;
6841 case MGN_48M: rateIndex = 10; break;
6842 case MGN_54M: rateIndex = 11; break;
6843 //
6844 // 11n High throughput rate
6845 //
6846 case MGN_MCS0: rateIndex = 12; break;
6847 case MGN_MCS1: rateIndex = 13; break;
6848 case MGN_MCS2: rateIndex = 14; break;
6849 case MGN_MCS3: rateIndex = 15; break;
6850 case MGN_MCS4: rateIndex = 16; break;
6851 case MGN_MCS5: rateIndex = 17; break;
6852 case MGN_MCS6: rateIndex = 18; break;
6853 case MGN_MCS7: rateIndex = 19; break;
6854 case MGN_MCS8: rateIndex = 20; break;
6855 case MGN_MCS9: rateIndex = 21; break;
6856 case MGN_MCS10: rateIndex = 22; break;
6857 case MGN_MCS11: rateIndex = 23; break;
6858 case MGN_MCS12: rateIndex = 24; break;
6859 case MGN_MCS13: rateIndex = 25; break;
6860 case MGN_MCS14: rateIndex = 26; break;
6861 case MGN_MCS15: rateIndex = 27; break;
6862 default: rateIndex = 28; break;
6863 }
6864 priv->stats.received_preamble_GI[preamble_guardinterval][rateIndex]++;
6865 priv->stats.received_rate_histogram[0][rateIndex]++; //total
6866 priv->stats.received_rate_histogram[rcvType][rateIndex]++;
6867 }
6868
6869 void rtl8192SU_query_rxdesc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats, bool bIsRxAggrSubframe)
6870 {
6871 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
6872 struct net_device *dev=info->dev;
6873 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
6874 //rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
6875 rx_drvinfo_819x_usb *driver_info = NULL;
6876
6877 //PRT_RFD_STATUS pRtRfdStatus = &pRfd->Status;
6878 //PHAL_DATA_8192SUSB pHalData = GET_HAL_DATA(Adapter);
6879 //pu1Byte pDesc = (pu1Byte)pDescIn;
6880 //PRX_DRIVER_INFO_8192S pDrvInfo;
6881
6882 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
6883
6884 if(0)
6885 {
6886 int m = 0;
6887 printk("========================");
6888 for(m=0; m<skb->len; m++){
6889 if((m%32) == 0)
6890 printk("\n");
6891 printk("%2x ",((u8*)skb->data)[m]);
6892 }
6893 printk("\n========================\n");
6894
6895 }
6896
6897
6898 //
6899 //Get Rx Descriptor Raw Information
6900 //
6901 stats->Length = desc->Length ;
6902 stats->RxDrvInfoSize = desc->RxDrvInfoSize*RX_DRV_INFO_SIZE_UNIT;
6903 stats->RxBufShift = (desc->Shift)&0x03;
6904 stats->bICV = desc->ICV;
6905 stats->bCRC = desc->CRC32;
6906 stats->bHwError = stats->bCRC|stats->bICV;
6907 stats->Decrypted = !desc->SWDec;//RTL8190 set this bit to indicate that Hw does not decrypt packet
6908 stats->bIsAMPDU = (desc->AMSDU==1);
6909 stats->bFirstMPDU = (desc->PAGGR==1) && (desc->FAGGR==1);
6910 stats->bShortPreamble = desc->SPLCP;
6911 stats->RxIs40MHzPacket = (desc->BW==1);
6912 stats->TimeStampLow = desc->TSFL;
6913
6914 if((desc->FAGGR==1) || (desc->PAGGR==1))
6915 {// Rx A-MPDU
6916 RT_TRACE(COMP_RXDESC, "FirstAGGR = %d, PartAggr = %d\n", desc->FAGGR, desc->PAGGR);
6917 }
6918 //YJ,test,090310
6919 if(stats->bHwError)
6920 {
6921 if(stats->bICV)
6922 printk("%s: Receive ICV error!!!!!!!!!!!!!!!!!!!!!!\n", __FUNCTION__);
6923 if(stats->bCRC)
6924 printk("%s: Receive CRC error!!!!!!!!!!!!!!!!!!!!!!\n", __FUNCTION__);
6925 }
6926
6927 if(IS_UNDER_11N_AES_MODE(priv->ieee80211))
6928 {
6929 // Always received ICV error packets in AES mode.
6930 // This fixed HW later MIC write bug.
6931 if(stats->bICV && !stats->bCRC)
6932 {
6933 stats->bICV = FALSE;
6934 stats->bHwError = FALSE;
6935 }
6936 }
6937
6938 // Transform HwRate to MRate
6939 if(!stats->bHwError)
6940 //stats->DataRate = HwRateToMRate(
6941 // (BOOLEAN)GET_RX_DESC_RXHT(pDesc),
6942 // (u1Byte)GET_RX_DESC_RXMCS(pDesc),
6943 // (BOOLEAN)GET_RX_DESC_PAGGR(pDesc));
6944 stats->rate = rtl8192SU_HwRateToMRate(desc->RxHT, desc->RxMCS, desc->PAGGR);
6945 else
6946 stats->rate = MGN_1M;
6947
6948 //
6949 // Collect Rx rate/AMPDU/TSFL
6950 //
6951 //UpdateRxdRateHistogramStatistics8192S(Adapter, pRfd);
6952 //UpdateRxAMPDUHistogramStatistics8192S(Adapter, pRfd);
6953 //UpdateRxPktTimeStamp8192S(Adapter, pRfd);
6954 UpdateReceivedRateHistogramStatistics8190(dev, stats);
6955 //UpdateRxAMPDUHistogramStatistics8192S(dev, stats); //FIXLZM
6956 UpdateRxPktTimeStamp8190(dev, stats);
6957
6958 //
6959 // Get PHY Status and RSVD parts.
6960 // <Roger_Notes> It only appears on last aggregated packet.
6961 //
6962 if (desc->PHYStatus)
6963 {
6964 //driver_info = (rx_drvinfo_819x_usb *)(skb->data + RX_DESC_SIZE + stats->RxBufShift);
6965 driver_info = (rx_drvinfo_819x_usb *)(skb->data + sizeof(rx_desc_819x_usb) + \
6966 stats->RxBufShift);
6967 if(0)
6968 {
6969 int m = 0;
6970 printk("========================\n");
6971 printk("RX_DESC_SIZE:%d, RxBufShift:%d, RxDrvInfoSize:%d\n",
6972 RX_DESC_SIZE, stats->RxBufShift, stats->RxDrvInfoSize);
6973 for(m=0; m<32; m++){
6974 printk("%2x ",((u8*)driver_info)[m]);
6975 }
6976 printk("\n========================\n");
6977
6978 }
6979
6980 }
6981
6982 //YJ,add,090107
6983 skb_pull(skb, sizeof(rx_desc_819x_usb));
6984 //YJ,add,090107,end
6985
6986 //
6987 // Get Total offset of MPDU Frame Body
6988 //
6989 if((stats->RxBufShift + stats->RxDrvInfoSize) > 0)
6990 {
6991 stats->bShift = 1;
6992 //YJ,add,090107
6993 skb_pull(skb, stats->RxBufShift + stats->RxDrvInfoSize);
6994 //YJ,add,090107,end
6995 }
6996
6997 //
6998 // Get PHY Status and RSVD parts.
6999 // <Roger_Notes> It only appears on last aggregated packet.
7000 //
7001 if (desc->PHYStatus)
7002 {
7003 rtl8192SU_TranslateRxSignalStuff(skb, stats, desc, driver_info);
7004 }
7005 }
7006
7007 //
7008 // Description:
7009 // The strarting address of wireless lan header will shift 1 or 2 or 3 or "more" bytes for the following reason :
7010 // (1) QoS control : shift 2 bytes
7011 // (2) Mesh Network : shift 1 or 3 bytes
7012 // (3) RxDriverInfo occupies the front parts of Rx Packets buffer(shift units is in 8Bytes)
7013 //
7014 // It is because Lextra CPU used by 8186 or 865x series assert exception if the statrting address
7015 // of IP header is not double word alignment.
7016 // This features is supported in 818xb and 8190 only, but not 818x.
7017 //
7018 // parameter: PRT_RFD, Pointer of Reeceive frame descriptor which is initialized according to
7019 // Rx Descriptor
7020 // return value: unsigned int, number of total shifted bytes
7021 //
7022 // Notes: 2008/06/28, created by Roger
7023 //
7024 u32 GetRxPacketShiftBytes8192SU(struct ieee80211_rx_stats *Status, bool bIsRxAggrSubframe)
7025 {
7026 //PRT_RFD_STATUS pRtRfdStatus = &pRfd->Status;
7027
7028 return (sizeof(rx_desc_819x_usb) + Status->RxDrvInfoSize + Status->RxBufShift);
7029 }
7030
7031 void rtl8192SU_rx_nomal(struct sk_buff* skb)
7032 {
7033 rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
7034 struct net_device *dev=info->dev;
7035 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
7036 struct ieee80211_rx_stats stats = {
7037 .signal = 0,
7038 .noise = -98,
7039 .rate = 0,
7040 // .mac_time = jiffies,
7041 .freq = IEEE80211_24GHZ_BAND,
7042 };
7043 u32 rx_pkt_len = 0;
7044 struct ieee80211_hdr_1addr *ieee80211_hdr = NULL;
7045 bool unicast_packet = false;
7046
7047 //printk("**********skb->len = %d\n", skb->len);
7048 /* 20 is for ps-poll */
7049 if((skb->len >=(20 + sizeof(rx_desc_819x_usb))) && (skb->len < RX_URB_SIZE)) {
7050
7051 /* first packet should not contain Rx aggregation header */
7052 rtl8192SU_query_rxdesc_status(skb, &stats, false);
7053 /* TODO */
7054
7055 /* hardware related info */
7056 priv->stats.rxoktotal++; //YJ,test,090108
7057
7058 /* Process the MPDU recevied */
7059 skb_trim(skb, skb->len - 4/*sCrcLng*/);//FIXLZM
7060
7061 rx_pkt_len = skb->len;
7062 ieee80211_hdr = (struct ieee80211_hdr_1addr *)skb->data;
7063 unicast_packet = false;
7064 if(is_broadcast_ether_addr(ieee80211_hdr->addr1)) {
7065 //TODO
7066 }else if(is_multicast_ether_addr(ieee80211_hdr->addr1)){
7067 //TODO
7068 }else {
7069 /* unicast packet */
7070 unicast_packet = true;
7071 }
7072
7073 if(!ieee80211_rtl_rx(priv->ieee80211,skb, &stats)) {
7074 dev_kfree_skb_any(skb);
7075 } else {
7076 // priv->stats.rxoktotal++; //YJ,test,090108
7077 if(unicast_packet) {
7078 priv->stats.rxbytesunicast += rx_pkt_len;
7079 }
7080 }
7081
7082 //up is firs pkt, follow is next and next
7083 }
7084 else
7085 {
7086 priv->stats.rxurberr++;
7087 printk("actual_length:%d\n", skb->len);
7088 dev_kfree_skb_any(skb);
7089 }
7090
7091 }
7092
7093 void
7094 rtl819xusb_process_received_packet(
7095 struct net_device *dev,
7096 struct ieee80211_rx_stats *pstats
7097 )
7098 {
7099 // bool bfreerfd=false, bqueued=false;
7100 u8* frame;
7101 u16 frame_len=0;
7102 struct r8192_priv *priv = ieee80211_priv(dev);
7103 // u8 index = 0;
7104 // u8 TID = 0;
7105 //u16 seqnum = 0;
7106 //PRX_TS_RECORD pts = NULL;
7107
7108 // Get shifted bytes of Starting address of 802.11 header. 2006.09.28, by Emily
7109 //porting by amy 080508
7110 pstats->virtual_address += get_rxpacket_shiftbytes_819xusb(pstats);
7111 frame = pstats->virtual_address;
7112 frame_len = pstats->packetlength;
7113 #ifdef TODO // by amy about HCT
7114 if(!Adapter->bInHctTest)
7115 CountRxErrStatistics(Adapter, pRfd);
7116 #endif
7117 {
7118 #ifdef ENABLE_PS //by amy for adding ps function in future
7119 RT_RF_POWER_STATE rtState;
7120 // When RF is off, we should not count the packet for hw/sw synchronize
7121 // reason, ie. there may be a duration while sw switch is changed and hw
7122 // switch is being changed. 2006.12.04, by shien chang.
7123 Adapter->HalFunc.GetHwRegHandler(Adapter, HW_VAR_RF_STATE, (u8* )(&rtState));
7124 if (rtState == eRfOff)
7125 {
7126 return;
7127 }
7128 #endif
7129 priv->stats.rxframgment++;
7130
7131 }
7132 #ifdef TODO
7133 RmMonitorSignalStrength(Adapter, pRfd);
7134 #endif
7135 /* 2007/01/16 MH Add RX command packet handle here. */
7136 /* 2007/03/01 MH We have to release RFD and return if rx pkt is cmd pkt. */
7137 if (rtl819xusb_rx_command_packet(dev, pstats))
7138 {
7139 return;
7140 }
7141
7142 #ifdef SW_CRC_CHECK
7143 SwCrcCheck();
7144 #endif
7145
7146
7147 }
7148
7149 void query_rx_cmdpkt_desc_status(struct sk_buff *skb, struct ieee80211_rx_stats *stats)
7150 {
7151 // rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
7152 // struct net_device *dev=info->dev;
7153 // struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
7154 rx_desc_819x_usb *desc = (rx_desc_819x_usb *)skb->data;
7155 // rx_drvinfo_819x_usb *driver_info;
7156
7157 //
7158 //Get Rx Descriptor Information
7159 //
7160 stats->virtual_address = (u8*)skb->data;
7161 stats->Length = desc->Length;
7162 stats->RxDrvInfoSize = 0;
7163 stats->RxBufShift = 0;
7164 stats->packetlength = stats->Length-scrclng;
7165 stats->fraglength = stats->packetlength;
7166 stats->fragoffset = 0;
7167 stats->ntotalfrag = 1;
7168 }
7169
7170 void rtl8192SU_rx_cmd(struct sk_buff *skb)
7171 {
7172 struct rtl8192_rx_info *info = (struct rtl8192_rx_info *)skb->cb;
7173 struct net_device *dev = info->dev;
7174
7175 /* TODO */
7176 struct ieee80211_rx_stats stats = {
7177 .signal = 0,
7178 .noise = -98,
7179 .rate = 0,
7180 // .mac_time = jiffies,
7181 .freq = IEEE80211_24GHZ_BAND,
7182 };
7183
7184 //
7185 // Check buffer length to determine if this is a valid MPDU.
7186 //
7187 if( (skb->len >= sizeof(rx_desc_819x_usb)) && (skb->len <= RX_URB_SIZE) )//&&
7188 //(pHalData->SwChnlInProgress == FALSE))
7189 {
7190 //
7191 // Collection information in Rx descriptor.
7192 //
7193 query_rx_cmdpkt_desc_status(skb,&stats);
7194 // this is to be done by amy 080508 prfd->queue_id = 1;
7195
7196 //
7197 // Process the MPDU recevied.
7198 //
7199 rtl819xusb_process_received_packet(dev,&stats);
7200
7201 dev_kfree_skb_any(skb);
7202 }
7203 else
7204 {
7205 //RTInsertTailListWithCnt(&pAdapter->RfdIdleQueue, &pRfd->List, &pAdapter->NumIdleRfd);
7206 //RT_ASSERT(pAdapter->NumIdleRfd <= pAdapter->NumRfd, ("HalUsbInCommandComplete8192SUsb(): Adapter->NumIdleRfd(%d)\n", pAdapter->NumIdleRfd));
7207 //RT_TRACE(COMP_RECV, DBG_LOUD, ("HalUsbInCommandComplete8192SUsb(): NOT enough Resources!! BufLenUsed(%d), NumIdleRfd(%d)\n",
7208 //pContext->BufLenUsed, pAdapter->NumIdleRfd));
7209 }
7210
7211 //
7212 // Reuse USB_IN_CONTEXT since we had finished processing the
7213 // buffer in USB_IN_CONTEXT.
7214 //
7215 //HalUsbReturnInContext(pAdapter, pContext);
7216
7217 //
7218 // Issue another bulk IN transfer.
7219 //
7220 //HalUsbInMpdu(pAdapter, PipeIndex);
7221
7222 RT_TRACE(COMP_RECV, "<--- HalUsbInCommandComplete8192SUsb()\n");
7223
7224 }
7225
7226 void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
7227 {
7228 struct sk_buff *skb;
7229 struct rtl8192_rx_info *info;
7230
7231 while (NULL != (skb = skb_dequeue(&priv->skb_queue))) {
7232 info = (struct rtl8192_rx_info *)skb->cb;
7233 switch (info->out_pipe) {
7234 /* Nomal packet pipe */
7235 case 3:
7236 //RT_TRACE(COMP_RECV, "normal in-pipe index(%d)\n",info->out_pipe);
7237 priv->IrpPendingCount--;
7238 priv->ops->rtl819x_rx_nomal(skb);
7239 break;
7240
7241 /* Command packet pipe */
7242 case 9:
7243 RT_TRACE(COMP_RECV, "command in-pipe index(%d)\n",\
7244 info->out_pipe);
7245 priv->ops->rtl819x_rx_cmd(skb);
7246 break;
7247
7248 default: /* should never get here! */
7249 RT_TRACE(COMP_ERR, "Unknown in-pipe index(%d)\n",\
7250 info->out_pipe);
7251 dev_kfree_skb(skb);
7252 break;
7253
7254 }
7255 }
7256 }
7257
7258
7259
7260 /****************************************************************************
7261 ---------------------------- USB_STUFF---------------------------
7262 *****************************************************************************/
7263 //LZM Merge from windows HalUsbSetQueuePipeMapping8192SUsb 090319
7264 static void HalUsbSetQueuePipeMapping8192SUsb(struct usb_interface *intf, struct net_device *dev)
7265 {
7266 struct r8192_priv *priv = ieee80211_priv(dev);
7267 struct usb_host_interface *iface_desc;
7268 struct usb_endpoint_descriptor *endpoint;
7269 u8 i = 0;
7270
7271 priv->ep_in_num = 0;
7272 priv->ep_out_num = 0;
7273 memset(priv->RtOutPipes,0,16);
7274 memset(priv->RtInPipes,0,16);
7275
7276 iface_desc = intf->cur_altsetting;
7277 priv->ep_num = iface_desc->desc.bNumEndpoints;
7278
7279 for (i = 0; i < priv->ep_num; ++i) {
7280 endpoint = &iface_desc->endpoint[i].desc;
7281 if (usb_endpoint_is_bulk_in(endpoint)) {
7282 priv->RtInPipes[priv->ep_in_num] = usb_endpoint_num(endpoint);
7283 priv->ep_in_num ++;
7284 //printk("in_endpoint_idx = %d\n", usb_endpoint_num(endpoint));
7285 } else if (usb_endpoint_is_bulk_out(endpoint)) {
7286 priv->RtOutPipes[priv->ep_out_num] = usb_endpoint_num(endpoint);
7287 priv->ep_out_num ++;
7288 //printk("out_endpoint_idx = %d\n", usb_endpoint_num(endpoint));
7289 }
7290 }
7291 {
7292 memset(priv->txqueue_to_outpipemap,0,9);
7293 if (priv->ep_num == 6) {
7294 // BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON
7295 u8 queuetopipe[] = {3, 2, 1, 0, 4, 4, 4, 4, 4};
7296
7297 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
7298 } else if (priv->ep_num == 4) {
7299 // BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON
7300 u8 queuetopipe[] = {1, 1, 0, 0, 2, 2, 2, 2, 2};
7301
7302 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
7303 } else if (priv->ep_num > 9) {
7304 // BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON
7305 u8 queuetopipe[] = {3, 2, 1, 0, 4, 8, 7, 6, 5};
7306
7307 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
7308 } else {//use sigle pipe
7309 // BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON
7310 u8 queuetopipe[] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
7311 memcpy(priv->txqueue_to_outpipemap,queuetopipe,9);
7312 }
7313 }
7314 printk("==>ep_num:%d, in_ep_num:%d, out_ep_num:%d\n", priv->ep_num, priv->ep_in_num, priv->ep_out_num);
7315
7316 printk("==>RtInPipes:");
7317 for(i=0; i < priv->ep_in_num; i++)
7318 printk("%d ", priv->RtInPipes[i]);
7319 printk("\n");
7320
7321 printk("==>RtOutPipes:");
7322 for(i=0; i < priv->ep_out_num; i++)
7323 printk("%d ", priv->RtOutPipes[i]);
7324 printk("\n");
7325
7326 printk("==>txqueue_to_outpipemap for BK, BE, VI, VO, HCCA, TXCMD, MGNT, HIGH, BEACON:\n");
7327 for(i=0; i < 9; i++)
7328 printk("%d ", priv->txqueue_to_outpipemap[i]);
7329 printk("\n");
7330
7331 return;
7332 }
7333
7334 static const struct net_device_ops rtl8192_netdev_ops = {
7335 .ndo_open = rtl8192_open,
7336 .ndo_stop = rtl8192_close,
7337 .ndo_get_stats = rtl8192_stats,
7338 .ndo_tx_timeout = tx_timeout,
7339 .ndo_do_ioctl = rtl8192_ioctl,
7340 .ndo_set_multicast_list = r8192_set_multicast,
7341 .ndo_set_mac_address = r8192_set_mac_adr,
7342 .ndo_validate_addr = eth_validate_addr,
7343 .ndo_change_mtu = eth_change_mtu,
7344 .ndo_start_xmit = rtl8192_ieee80211_rtl_xmit,
7345 };
7346
7347 static int __devinit rtl8192_usb_probe(struct usb_interface *intf,
7348 const struct usb_device_id *id)
7349 {
7350 // unsigned long ioaddr = 0;
7351 struct net_device *dev = NULL;
7352 struct r8192_priv *priv= NULL;
7353 struct usb_device *udev = interface_to_usbdev(intf);
7354
7355 RT_TRACE(COMP_INIT, "Oops: i'm coming\n");
7356
7357 dev = alloc_ieee80211(sizeof(struct r8192_priv));
7358
7359 usb_set_intfdata(intf, dev);
7360 SET_NETDEV_DEV(dev, &intf->dev);
7361 priv = ieee80211_priv(dev);
7362 priv->ieee80211 = netdev_priv(dev);
7363 priv->udev=udev;
7364
7365 HalUsbSetQueuePipeMapping8192SUsb(intf, dev);
7366
7367 //printk("===============>NIC 8192SU\n");
7368 priv->ops = &rtl8192su_ops;
7369
7370 dev->netdev_ops = &rtl8192_netdev_ops;
7371
7372 //DMESG("Oops: i'm coming\n");
7373 dev->wireless_handlers = (struct iw_handler_def *) &r8192_wx_handlers_def;
7374
7375 dev->type=ARPHRD_ETHER;
7376
7377 dev->watchdog_timeo = HZ*3; //modified by john, 0805
7378
7379 if (dev_alloc_name(dev, ifname) < 0){
7380 RT_TRACE(COMP_INIT, "Oops: devname already taken! Trying wlan%%d...\n");
7381 ifname = "wlan%d";
7382 dev_alloc_name(dev, ifname);
7383 }
7384
7385 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
7386 #if 1
7387 if(rtl8192_init(dev)!=0){
7388 RT_TRACE(COMP_ERR, "Initialization failed");
7389 goto fail;
7390 }
7391 #endif
7392 netif_carrier_off(dev);
7393 netif_stop_queue(dev);
7394
7395 register_netdev(dev);
7396 RT_TRACE(COMP_INIT, "dev name=======> %s\n",dev->name);
7397 rtl8192_proc_init_one(dev);
7398
7399
7400 RT_TRACE(COMP_INIT, "Driver probe completed\n");
7401 return 0;
7402 fail:
7403 free_ieee80211(dev);
7404
7405 RT_TRACE(COMP_ERR, "wlan driver load failed\n");
7406 return -ENODEV;
7407 }
7408
7409 //detach all the work and timer structure declared or inititialize in r8192U_init function.
7410 void rtl8192_cancel_deferred_work(struct r8192_priv* priv)
7411 {
7412 cancel_work_sync(&priv->reset_wq);
7413 cancel_work_sync(&priv->qos_activate);
7414 cancel_delayed_work(&priv->watch_dog_wq);
7415 cancel_delayed_work(&priv->update_beacon_wq);
7416 cancel_delayed_work(&priv->ieee80211->hw_wakeup_wq);
7417 cancel_delayed_work(&priv->ieee80211->hw_sleep_wq);
7418 //cancel_work_sync(&priv->SetBWModeWorkItem);
7419 //cancel_work_sync(&priv->SwChnlWorkItem);
7420 }
7421
7422 static void __devexit rtl8192_usb_disconnect(struct usb_interface *intf)
7423 {
7424 struct net_device *dev = usb_get_intfdata(intf);
7425 struct r8192_priv *priv = ieee80211_priv(dev);
7426 if(dev){
7427
7428 unregister_netdev(dev);
7429
7430 RT_TRACE(COMP_DOWN, "=============>wlan driver to be removed\n");
7431 rtl8192_proc_remove_one(dev);
7432
7433 rtl8192_down(dev);
7434 if (priv->pFirmware)
7435 {
7436 vfree(priv->pFirmware);
7437 priv->pFirmware = NULL;
7438 }
7439 // priv->rf_close(dev);
7440 // rtl8192_SetRFPowerState(dev, eRfOff);
7441 destroy_workqueue(priv->priv_wq);
7442 //rtl8192_irq_disable(dev);
7443 //rtl8192_reset(dev);
7444 mdelay(10);
7445
7446 }
7447 free_ieee80211(dev);
7448 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
7449 }
7450
7451 /* fun with the built-in ieee80211 stack... */
7452 extern int ieee80211_debug_init(void);
7453 extern void ieee80211_debug_exit(void);
7454 extern int ieee80211_crypto_init(void);
7455 extern void ieee80211_crypto_deinit(void);
7456 extern int ieee80211_crypto_tkip_init(void);
7457 extern void ieee80211_crypto_tkip_exit(void);
7458 extern int ieee80211_crypto_ccmp_init(void);
7459 extern void ieee80211_crypto_ccmp_exit(void);
7460 extern int ieee80211_crypto_wep_init(void);
7461 extern void ieee80211_crypto_wep_exit(void);
7462
7463 static int __init rtl8192_usb_module_init(void)
7464 {
7465 int ret;
7466
7467 #ifdef CONFIG_IEEE80211_DEBUG
7468 ret = ieee80211_debug_init();
7469 if (ret) {
7470 printk(KERN_ERR "ieee80211_debug_init() failed %d\n", ret);
7471 return ret;
7472 }
7473 #endif
7474 ret = ieee80211_crypto_init();
7475 if (ret) {
7476 printk(KERN_ERR "ieee80211_crypto_init() failed %d\n", ret);
7477 return ret;
7478 }
7479
7480 ret = ieee80211_crypto_tkip_init();
7481 if (ret) {
7482 printk(KERN_ERR "ieee80211_crypto_tkip_init() failed %d\n",
7483 ret);
7484 return ret;
7485 }
7486
7487 ret = ieee80211_crypto_ccmp_init();
7488 if (ret) {
7489 printk(KERN_ERR "ieee80211_crypto_ccmp_init() failed %d\n",
7490 ret);
7491 return ret;
7492 }
7493
7494 ret = ieee80211_crypto_wep_init();
7495 if (ret) {
7496 printk(KERN_ERR "ieee80211_crypto_wep_init() failed %d\n", ret);
7497 return ret;
7498 }
7499
7500 printk(KERN_INFO "\nLinux kernel driver for RTL8192 based WLAN cards\n");
7501 printk(KERN_INFO "Copyright (c) 2007-2008, Realsil Wlan\n");
7502 RT_TRACE(COMP_INIT, "Initializing module");
7503 RT_TRACE(COMP_INIT, "Wireless extensions version %d", WIRELESS_EXT);
7504 rtl8192_proc_module_init();
7505 return usb_register(&rtl8192_usb_driver);
7506 }
7507
7508
7509 static void __exit rtl8192_usb_module_exit(void)
7510 {
7511 usb_deregister(&rtl8192_usb_driver);
7512
7513 RT_TRACE(COMP_DOWN, "Exiting");
7514 rtl8192_proc_module_remove();
7515
7516 ieee80211_crypto_tkip_exit();
7517 ieee80211_crypto_ccmp_exit();
7518 ieee80211_crypto_wep_exit();
7519 ieee80211_crypto_deinit();
7520 #ifdef CONFIG_IEEE80211_DEBUG
7521 ieee80211_debug_exit();
7522 #endif
7523 }
7524
7525
7526 void rtl8192_try_wake_queue(struct net_device *dev, int pri)
7527 {
7528 unsigned long flags;
7529 short enough_desc;
7530 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
7531
7532 spin_lock_irqsave(&priv->tx_lock,flags);
7533 enough_desc = check_nic_enough_desc(dev,pri);
7534 spin_unlock_irqrestore(&priv->tx_lock,flags);
7535
7536 if(enough_desc)
7537 ieee80211_rtl_wake_queue(priv->ieee80211);
7538 }
7539
7540 void EnableHWSecurityConfig8192(struct net_device *dev)
7541 {
7542 u8 SECR_value = 0x0;
7543 struct r8192_priv *priv = (struct r8192_priv *)ieee80211_priv(dev);
7544 struct ieee80211_device *ieee = priv->ieee80211;
7545
7546 SECR_value = SCR_TxEncEnable | SCR_RxDecEnable;
7547 switch (ieee->pairwise_key_type) {
7548 case KEY_TYPE_WEP40:
7549 case KEY_TYPE_WEP104:
7550 if (priv->ieee80211->auth_mode != 2) {
7551 SECR_value |= SCR_RxUseDK;
7552 SECR_value |= SCR_TxUseDK;
7553 }
7554 break;
7555 case KEY_TYPE_TKIP:
7556 case KEY_TYPE_CCMP:
7557 if (ieee->iw_mode == IW_MODE_ADHOC) {
7558 SECR_value |= SCR_RxUseDK;
7559 SECR_value |= SCR_TxUseDK;
7560 }
7561 break;
7562 default:
7563 break;
7564 }
7565
7566 /*
7567 * add HWSec active enable here.
7568 * default using hwsec.
7569 * when peer AP is in N mode only and pairwise_key_type is none_aes
7570 * (which HT_IOT_ACT_PURE_N_MODE indicates it),
7571 * use software security.
7572 * when peer AP is in b,g,n mode mixed and pairwise_key_type is none_aes
7573 * use g mode hw security.
7574 */
7575 ieee->hwsec_active = 1;
7576
7577 /* add hwsec_support flag to totol control hw_sec on/off */
7578 if ((ieee->pHTInfo->IOTAction&HT_IOT_ACT_PURE_N_MODE) || !hwwep) {
7579 ieee->hwsec_active = 0;
7580 SECR_value &= ~SCR_RxDecEnable;
7581 }
7582
7583 RT_TRACE(COMP_SEC, "%s(): hwsec: %d, pairwise_key: %d, "
7584 "SECR_value: %x",
7585 __func__, ieee->hwsec_active,
7586 ieee->pairwise_key_type, SECR_value);
7587
7588 write_nic_byte(dev, SECR, SECR_value); /* SECR_value | SCR_UseDK ); */
7589 }
7590
7591
7592 void setKey(struct net_device *dev,
7593 u8 EntryNo,
7594 u8 KeyIndex,
7595 u16 KeyType,
7596 u8 *MacAddr,
7597 u8 DefaultKey,
7598 u32 *KeyContent)
7599 {
7600 u32 TargetCommand = 0;
7601 u32 TargetContent = 0;
7602 u16 usConfig = 0;
7603 u8 i;
7604
7605 if (EntryNo >= TOTAL_CAM_ENTRY)
7606 RT_TRACE(COMP_ERR, "%s(): cam entry exceeds TOTAL_CAM_ENTRY",
7607 __func__);
7608
7609 RT_TRACE(COMP_SEC, "%s(): dev: %p, EntryNo: %d, "
7610 "KeyIndex: %d, KeyType: %d, MacAddr: %pM",
7611 __func__, dev, EntryNo,
7612 KeyIndex, KeyType, MacAddr);
7613
7614 if (DefaultKey)
7615 usConfig |= BIT15 | (KeyType << 2);
7616 else
7617 usConfig |= BIT15 | (KeyType << 2) | KeyIndex;
7618
7619 for (i = 0 ; i < CAM_CONTENT_COUNT; i++) {
7620 TargetCommand = i + CAM_CONTENT_COUNT * EntryNo;
7621 TargetCommand |= BIT31|BIT16;
7622 switch (i) {
7623 case 0: /* MAC|Config */
7624 TargetContent = (u32)(*(MacAddr + 0)) << 16|
7625 (u32)(*(MacAddr + 1)) << 24|
7626 (u32)usConfig;
7627
7628 write_nic_dword(dev, WCAMI, TargetContent);
7629 write_nic_dword(dev, RWCAM, TargetCommand);
7630 continue;
7631 case 1: /* MAC */
7632 TargetContent = (u32)(*(MacAddr + 2))|
7633 (u32)(*(MacAddr + 3)) << 8|
7634 (u32)(*(MacAddr + 4)) << 16|
7635 (u32)(*(MacAddr + 5)) << 24;
7636 write_nic_dword(dev, WCAMI, TargetContent);
7637 write_nic_dword(dev, RWCAM, TargetCommand);
7638 continue;
7639 default: /* Key Material */
7640 if (KeyContent != NULL) {
7641 write_nic_dword(dev, WCAMI,
7642 (u32)(*(KeyContent+i-2)));
7643 write_nic_dword(dev, RWCAM,
7644 TargetCommand);
7645 }
7646 continue;
7647 }
7648 }
7649 }
7650
7651 /***************************************************************************
7652 ------------------- module init / exit stubs ----------------
7653 ****************************************************************************/
7654 module_init(rtl8192_usb_module_init);
7655 module_exit(rtl8192_usb_module_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree