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