projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
staging: rtl8192e: Remove unused rtllib_device members
[linux-2.6-block.git] / drivers / staging / rtl8192e / rtl8192e / rtl_core.c
CommitLineData
94a79942
LF		 1/******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 *
4 * Based on the r8180 driver, which is:
559a4c31 5 * Copyright 2004-2005 Andrea Merello <andrea.merello@gmail.com>, et al.
94a79942
LF		 6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of version 2 of the GNU General Public License as
8 * published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * more details.
14 *
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
18 *
19 * The full GNU General Public License is included in this distribution in the
20 * file called LICENSE.
21 *
22 * Contact Information:
23 * wlanfae <wlanfae@realtek.com>
24******************************************************************************/
94a79942
LF		 25#undef RX_DONT_PASS_UL
26#undef DEBUG_EPROM
27#undef DEBUG_RX_VERBOSE
28#undef DUMMY_RX
29#undef DEBUG_ZERO_RX
30#undef DEBUG_RX_SKB
31#undef DEBUG_TX_FRAG
32#undef DEBUG_RX_FRAG
33#undef DEBUG_TX_FILLDESC
34#undef DEBUG_TX
35#undef DEBUG_IRQ
36#undef DEBUG_RX
37#undef DEBUG_RXALLOC
38#undef DEBUG_REGISTERS
39#undef DEBUG_RING
40#undef DEBUG_IRQ_TASKLET
41#undef DEBUG_TX_ALLOC
42#undef DEBUG_TX_DESC
43
1344ee25 44#include <linux/uaccess.h>
94a79942 45#include <linux/pci.h>
09ebd6f2 46#include <linux/vmalloc.h>
acd442db 47#include <linux/ieee80211.h>
94a79942
LF		 48#include "rtl_core.h"
49#include "r8192E_phy.h"
50#include "r8192E_phyreg.h"
51#include "r8190P_rtl8256.h"
52#include "r8192E_cmdpkt.h"
53
54#include "rtl_wx.h"
94a79942 55#include "rtl_dm.h"
94a79942 56
94a79942 57#include "rtl_pm.h"
94a79942
LF		 58
59int hwwep = 1;
60static int channels = 0x3fff;
49aab5fd 61static char *ifname = "wlan%d";
94a79942
LF		 62
63
49aab5fd 64static struct rtl819x_ops rtl819xp_ops = {
1344ee25
LF		 65 .nic_type = NIC_8192E,
66 .get_eeprom_size = rtl8192_get_eeprom_size,
94a79942 67 .init_adapter_variable = rtl8192_InitializeVariables,
1344ee25
LF		 68 .initialize_adapter = rtl8192_adapter_start,
69 .link_change = rtl8192_link_change,
70 .tx_fill_descriptor = rtl8192_tx_fill_desc,
71 .tx_fill_cmd_descriptor = rtl8192_tx_fill_cmd_desc,
94a79942
LF		 72 .rx_query_status_descriptor = rtl8192_rx_query_status_desc,
73 .rx_command_packet_handler = NULL,
1344ee25
LF		 74 .stop_adapter = rtl8192_halt_adapter,
75 .update_ratr_table = rtl8192_update_ratr_table,
76 .irq_enable = rtl8192_EnableInterrupt,
77 .irq_disable = rtl8192_DisableInterrupt,
78 .irq_clear = rtl8192_ClearInterrupt,
79 .rx_enable = rtl8192_enable_rx,
80 .tx_enable = rtl8192_enable_tx,
94a79942
LF		 81 .interrupt_recognized = rtl8192_interrupt_recognized,
82 .TxCheckStuckHandler = rtl8192_HalTxCheckStuck,
83 .RxCheckStuckHandler = rtl8192_HalRxCheckStuck,
84};
85
83f5789c 86static struct pci_device_id rtl8192_pci_id_tbl[] = {
94a79942
LF		 87 {RTL_PCI_DEVICE(0x10ec, 0x8192, rtl819xp_ops)},
88 {RTL_PCI_DEVICE(0x07aa, 0x0044, rtl819xp_ops)},
89 {RTL_PCI_DEVICE(0x07aa, 0x0047, rtl819xp_ops)},
90 {}
91};
92
93MODULE_DEVICE_TABLE(pci, rtl8192_pci_id_tbl);
94
c506fff1 95static int rtl8192_pci_probe(struct pci_dev *pdev,
1344ee25 96 const struct pci_device_id *id);
1387b461 97static void rtl8192_pci_disconnect(struct pci_dev *pdev);
30224b5e 98static irqreturn_t rtl8192_interrupt(int irq, void *netdev);
94a79942
LF		 99
100static struct pci_driver rtl8192_pci_driver = {
1344ee25
LF		 101 .name = DRV_NAME, /* Driver name */
102 .id_table = rtl8192_pci_id_tbl, /* PCI_ID table */
103 .probe = rtl8192_pci_probe, /* probe fn */
c08561c5 104 .remove = rtl8192_pci_disconnect, /* remove fn */
1344ee25
LF		 105 .suspend = rtl8192E_suspend, /* PM suspend fn */
106 .resume = rtl8192E_resume, /* PM resume fn */
94a79942
LF		 107};
108
109/****************************************************************************
110 -----------------------------IO STUFF-------------------------
111*****************************************************************************/
49aab5fd 112static bool PlatformIOCheckPageLegalAndGetRegMask(u32 u4bPage, u8 *pu1bPageMask)
94a79942
LF		 113{
114 bool bReturn = false;
1344ee25 115
94a79942
LF		 116 *pu1bPageMask = 0xfe;
117
1344ee25
LF		 118 switch (u4bPage) {
119 case 1: case 2: case 3: case 4:
120 case 8: case 9: case 10: case 12: case 13:
121 bReturn = true;
122 *pu1bPageMask = 0xf0;
123 break;
94a79942 124
1344ee25
LF		 125 default:
126 bReturn = false;
127 break;
94a79942
LF		 128 }
129
130 return bReturn;
131}
132
1344ee25 133void write_nic_io_byte(struct net_device *dev, int x, u8 y)
94a79942 134{
9f491da9 135 u32 u4bPage = x >> 8;
94a79942
LF		 136 u8 u1PageMask = 0;
137 bool bIsLegalPage = false;
138
1344ee25
LF		 139 if (u4bPage == 0) {
140 outb(y&0xff, dev->base_addr + x);
141
142 } else {
143 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
144 &u1PageMask);
145 if (bIsLegalPage) {
94a79942
LF		 146 u8 u1bPsr = read_nic_io_byte(dev, PSR);
147
1344ee25
LF		 148 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
149 (u8)u4bPage));
94a79942
LF		 150 write_nic_io_byte(dev, (x & 0xff), y);
151 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
94a79942
LF		 152 }
153 }
94a79942
LF		 154}
155
1344ee25 156void write_nic_io_word(struct net_device *dev, int x, u16 y)
94a79942 157{
9f491da9 158 u32 u4bPage = x >> 8;
94a79942
LF		 159 u8 u1PageMask = 0;
160 bool bIsLegalPage = false;
161
1344ee25
LF		 162 if (u4bPage == 0) {
163 outw(y, dev->base_addr + x);
164 } else {
165 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
166 &u1PageMask);
167 if (bIsLegalPage) {
94a79942
LF		 168 u8 u1bPsr = read_nic_io_byte(dev, PSR);
169
1344ee25
LF		 170 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
171 (u8)u4bPage));
94a79942
LF		 172 write_nic_io_word(dev, (x & 0xff), y);
173 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
174
94a79942
LF		 175 }
176 }
94a79942
LF		 177}
178
1344ee25 179void write_nic_io_dword(struct net_device *dev, int x, u32 y)
94a79942 180{
9f491da9 181 u32 u4bPage = x >> 8;
94a79942
LF		 182 u8 u1PageMask = 0;
183 bool bIsLegalPage = false;
184
1344ee25
LF		 185 if (u4bPage == 0) {
186 outl(y, dev->base_addr + x);
187 } else {
188 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
189 &u1PageMask);
190 if (bIsLegalPage) {
94a79942
LF		 191 u8 u1bPsr = read_nic_io_byte(dev, PSR);
192
1344ee25
LF		 193 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
194 (u8)u4bPage));
94a79942
LF		 195 write_nic_io_dword(dev, (x & 0xff), y);
196 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
94a79942
LF		 197 }
198 }
94a79942 199}
1344ee25 200
94a79942
LF		 201u8 read_nic_io_byte(struct net_device *dev, int x)
202{
9f491da9 203 u32 u4bPage = x >> 8;
94a79942
LF		 204 u8 u1PageMask = 0;
205 bool bIsLegalPage = false;
206 u8 Data = 0;
207
285b7c00 208 if (u4bPage == 0)
1344ee25 209 return 0xff&inb(dev->base_addr + x);
94a79942 210
285b7c00
MK		 211 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
212 &u1PageMask);
213 if (bIsLegalPage) {
214 u8 u1bPsr = read_nic_io_byte(dev, PSR);
215
216 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
217 (u8)u4bPage));
218 Data = read_nic_io_byte(dev, (x & 0xff));
219 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
94a79942
LF		 220 }
221
222 return Data;
223}
224
225u16 read_nic_io_word(struct net_device *dev, int x)
226{
9f491da9 227 u32 u4bPage = x >> 8;
94a79942
LF		 228 u8 u1PageMask = 0;
229 bool bIsLegalPage = false;
230 u16 Data = 0;
231
285b7c00 232 if (u4bPage == 0)
1344ee25 233 return inw(dev->base_addr + x);
285b7c00
MK		 234 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
235 &u1PageMask);
236 if (bIsLegalPage) {
237 u8 u1bPsr = read_nic_io_byte(dev, PSR);
238
239 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
240 (u8)u4bPage));
241 Data = read_nic_io_word(dev, (x & 0xff));
242 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
94a79942
LF		 243 }
244
245 return Data;
246}
247
248u32 read_nic_io_dword(struct net_device *dev, int x)
249{
9f491da9 250 u32 u4bPage = x >> 8;
94a79942
LF		 251 u8 u1PageMask = 0;
252 bool bIsLegalPage = false;
253 u32 Data = 0;
254
285b7c00 255 if (u4bPage == 0)
1344ee25 256 return inl(dev->base_addr + x);
285b7c00
MK		 257 bIsLegalPage = PlatformIOCheckPageLegalAndGetRegMask(u4bPage,
258 &u1PageMask);
259 if (bIsLegalPage) {
260 u8 u1bPsr = read_nic_io_byte(dev, PSR);
261
262 write_nic_io_byte(dev, PSR, ((u1bPsr & u1PageMask) |
263 (u8)u4bPage));
264 Data = read_nic_io_dword(dev, (x & 0xff));
265 write_nic_io_byte(dev, PSR, (u1bPsr & u1PageMask));
94a79942
LF		 266 }
267
268 return Data;
269}
270
271u8 read_nic_byte(struct net_device *dev, int x)
272{
49aab5fd 273 return 0xff & readb((u8 __iomem *)dev->mem_start + x);
94a79942
LF		 274}
275
276u32 read_nic_dword(struct net_device *dev, int x)
277{
49aab5fd 278 return readl((u8 __iomem *)dev->mem_start + x);
94a79942
LF		 279}
280
281u16 read_nic_word(struct net_device *dev, int x)
282{
49aab5fd 283 return readw((u8 __iomem *)dev->mem_start + x);
94a79942
LF		 284}
285
1344ee25 286void write_nic_byte(struct net_device *dev, int x, u8 y)
94a79942 287{
49aab5fd 288 writeb(y, (u8 __iomem *)dev->mem_start + x);
94a79942 289
94a79942 290 udelay(20);
94a79942
LF		 291}
292
1344ee25 293void write_nic_dword(struct net_device *dev, int x, u32 y)
94a79942 294{
49aab5fd 295 writel(y, (u8 __iomem *)dev->mem_start + x);
94a79942 296
94a79942 297 udelay(20);
94a79942
LF		 298}
299
1344ee25 300void write_nic_word(struct net_device *dev, int x, u16 y)
94a79942 301{
49aab5fd 302 writew(y, (u8 __iomem *)dev->mem_start + x);
94a79942 303
94a79942 304 udelay(20);
94a79942
LF		 305}
306
307/****************************************************************************
308 -----------------------------GENERAL FUNCTION-------------------------
309*****************************************************************************/
1344ee25
LF		 310bool MgntActSet_RF_State(struct net_device *dev,
311 enum rt_rf_power_state StateToSet,
312 RT_RF_CHANGE_SOURCE ChangeSource,
313 bool ProtectOrNot)
94a79942
LF		 314{
315 struct r8192_priv *priv = rtllib_priv(dev);
1344ee25 316 struct rtllib_device *ieee = priv->rtllib;
94a79942
LF		 317 bool bActionAllowed = false;
318 bool bConnectBySSID = false;
de7c885a 319 enum rt_rf_power_state rtState;
94a79942
LF		 320 u16 RFWaitCounter = 0;
321 unsigned long flag;
3a6b70c3 322
0822339b
MK		 323 RT_TRACE((COMP_PS | COMP_RF),
324 "===>MgntActSet_RF_State(): StateToSet(%d)\n", StateToSet);
94a79942 325
94a79942 326 ProtectOrNot = false;
94a79942
LF		 327
328
1344ee25
LF		 329 if (!ProtectOrNot) {
330 while (true) {
331 spin_lock_irqsave(&priv->rf_ps_lock, flag);
332 if (priv->RFChangeInProgress) {
333 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
334 RT_TRACE((COMP_PS | COMP_RF),
0822339b
MK		 335 "MgntActSet_RF_State(): RF Change in progress! Wait to set..StateToSet(%d).\n",
336 StateToSet);
1344ee25
LF		 337
338 while (priv->RFChangeInProgress) {
339 RFWaitCounter++;
340 RT_TRACE((COMP_PS | COMP_RF),
0822339b 341 "MgntActSet_RF_State(): Wait 1 ms (%d times)...\n",
1344ee25
LF		 342 RFWaitCounter);
343 mdelay(1);
344
345 if (RFWaitCounter > 100) {
3b4140af
MK		 346 netdev_warn(dev,
347 "%s(): Timeout waiting for RF change.\n",
348 __func__);
1344ee25
LF		 349 return false;
350 }
94a79942 351 }
1344ee25
LF		 352 } else {
353 priv->RFChangeInProgress = true;
354 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
355 break;
94a79942 356 }
94a79942 357 }
94a79942
LF		 358 }
359
360 rtState = priv->rtllib->eRFPowerState;
361
1344ee25 362 switch (StateToSet) {
94a79942 363 case eRfOn:
94a79942
LF		 364 priv->rtllib->RfOffReason &= (~ChangeSource);
365
4bb01423 366 if ((ChangeSource == RF_CHANGE_BY_HW) && priv->bHwRadioOff)
94a79942 367 priv->bHwRadioOff = false;
94a79942 368
1344ee25 369 if (!priv->rtllib->RfOffReason) {
94a79942
LF		 370 priv->rtllib->RfOffReason = 0;
371 bActionAllowed = true;
372
373
1344ee25
LF		 374 if (rtState == eRfOff &&
375 ChangeSource >= RF_CHANGE_BY_HW)
94a79942 376 bConnectBySSID = true;
1344ee25 377 } else {
0822339b
MK		 378 RT_TRACE((COMP_PS | COMP_RF),
379 "MgntActSet_RF_State - eRfon reject pMgntInfo->RfOffReason= 0x%x, ChangeSource=0x%X\n",
1344ee25
LF		 380 priv->rtllib->RfOffReason, ChangeSource);
381 }
94a79942
LF		 382
383 break;
384
385 case eRfOff:
386
1344ee25
LF		 387 if ((priv->rtllib->iw_mode == IW_MODE_INFRA) ||
388 (priv->rtllib->iw_mode == IW_MODE_ADHOC)) {
389 if ((priv->rtllib->RfOffReason > RF_CHANGE_BY_IPS) ||
390 (ChangeSource > RF_CHANGE_BY_IPS)) {
94a79942
LF		 391 if (ieee->state == RTLLIB_LINKED)
392 priv->blinked_ingpio = true;
393 else
394 priv->blinked_ingpio = false;
1344ee25 395 rtllib_MgntDisconnect(priv->rtllib,
acd442db 396 WLAN_REASON_DISASSOC_STA_HAS_LEFT);
94a79942
LF		 397 }
398 }
4bb01423 399 if ((ChangeSource == RF_CHANGE_BY_HW) && !priv->bHwRadioOff)
94a79942 400 priv->bHwRadioOff = true;
94a79942
LF		 401 priv->rtllib->RfOffReason |= ChangeSource;
402 bActionAllowed = true;
403 break;
404
405 case eRfSleep:
406 priv->rtllib->RfOffReason |= ChangeSource;
407 bActionAllowed = true;
408 break;
409
410 default:
411 break;
412 }
413
1344ee25 414 if (bActionAllowed) {
0822339b
MK		 415 RT_TRACE((COMP_PS | COMP_RF),
416 "MgntActSet_RF_State(): Action is allowed.... StateToSet(%d), RfOffReason(%#X)\n",
1344ee25 417 StateToSet, priv->rtllib->RfOffReason);
94a79942 418 PHY_SetRFPowerState(dev, StateToSet);
1344ee25 419 if (StateToSet == eRfOn) {
94a79942 420
4bb01423 421 if (bConnectBySSID && priv->blinked_ingpio) {
1344ee25
LF		 422 queue_delayed_work_rsl(ieee->wq,
423 &ieee->associate_procedure_wq, 0);
94a79942 424 priv->blinked_ingpio = false;
94a79942
LF		 425 }
426 }
427 } else {
0822339b
MK		 428 RT_TRACE((COMP_PS | COMP_RF),
429 "MgntActSet_RF_State(): Action is rejected.... StateToSet(%d), ChangeSource(%#X), RfOffReason(%#X)\n",
430 StateToSet, ChangeSource, priv->rtllib->RfOffReason);
94a79942
LF		 431 }
432
1344ee25
LF		 433 if (!ProtectOrNot) {
434 spin_lock_irqsave(&priv->rf_ps_lock, flag);
435 priv->RFChangeInProgress = false;
436 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
94a79942
LF		 437 }
438
35f8673d 439 RT_TRACE((COMP_PS | COMP_RF), "<===MgntActSet_RF_State()\n");
94a79942
LF		 440 return bActionAllowed;
441}
442
49aab5fd 443static short rtl8192_check_nic_enough_desc(struct net_device *dev, int prio)
94a79942 444{
1344ee25
LF		 445 struct r8192_priv *priv = rtllib_priv(dev);
446 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
94a79942 447
1344ee25
LF		 448 if (ring->entries - skb_queue_len(&ring->queue) >= 2)
449 return 1;
450 return 0;
94a79942
LF		 451}
452
453void rtl8192_tx_timeout(struct net_device *dev)
454{
1344ee25 455 struct r8192_priv *priv = rtllib_priv(dev);
94a79942 456
1344ee25 457 schedule_work(&priv->reset_wq);
d69d2054 458 netdev_info(dev, "TXTIMEOUT");
94a79942
LF		 459}
460
461void rtl8192_irq_enable(struct net_device *dev)
462{
463 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
3a6b70c3 464
94a79942
LF		 465 priv->irq_enabled = 1;
466
467 priv->ops->irq_enable(dev);
468}
469
470void rtl8192_irq_disable(struct net_device *dev)
471{
472 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
473
474 priv->ops->irq_disable(dev);
475
476 priv->irq_enabled = 0;
477}
478
1344ee25 479void rtl8192_set_chan(struct net_device *dev, short ch)
94a79942 480{
1344ee25 481 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
94a79942 482
1344ee25
LF		 483 RT_TRACE(COMP_CH, "=====>%s()====ch:%d\n", __func__, ch);
484 if (priv->chan_forced)
485 return;
94a79942 486
1344ee25 487 priv->chan = ch;
94a79942 488
1344ee25
LF		 489 if (priv->rf_set_chan)
490 priv->rf_set_chan(dev, priv->chan);
94a79942
LF		 491}
492
1344ee25 493void rtl8192_update_cap(struct net_device *dev, u16 cap)
94a79942
LF		 494{
495 struct r8192_priv *priv = rtllib_priv(dev);
496 struct rtllib_network *net = &priv->rtllib->current_network;
1344ee25
LF		 497 bool ShortPreamble;
498
499 if (cap & WLAN_CAPABILITY_SHORT_PREAMBLE) {
500 if (priv->dot11CurrentPreambleMode != PREAMBLE_SHORT) {
501 ShortPreamble = true;
502 priv->dot11CurrentPreambleMode = PREAMBLE_SHORT;
0822339b
MK		 503 RT_TRACE(COMP_DBG,
504 "%s(): WLAN_CAPABILITY_SHORT_PREAMBLE\n",
505 __func__);
1344ee25
LF		 506 priv->rtllib->SetHwRegHandler(dev, HW_VAR_ACK_PREAMBLE,
507 (unsigned char *)&ShortPreamble);
94a79942 508 }
1344ee25
LF		 509 } else {
510 if (priv->dot11CurrentPreambleMode != PREAMBLE_LONG) {
511 ShortPreamble = false;
512 priv->dot11CurrentPreambleMode = PREAMBLE_LONG;
0822339b
MK		 513 RT_TRACE(COMP_DBG,
514 "%s(): WLAN_CAPABILITY_LONG_PREAMBLE\n",
515 __func__);
1344ee25
LF		 516 priv->rtllib->SetHwRegHandler(dev, HW_VAR_ACK_PREAMBLE,
517 (unsigned char *)&ShortPreamble);
94a79942
LF		 518 }
519 }
520
1344ee25 521 if (net->mode & (IEEE_G|IEEE_N_24G)) {
94a79942
LF		 522 u8 slot_time_val;
523 u8 CurSlotTime = priv->slot_time;
524
1344ee25
LF		 525 if ((cap & WLAN_CAPABILITY_SHORT_SLOT_TIME) &&
526 (!priv->rtllib->pHTInfo->bCurrentRT2RTLongSlotTime)) {
527 if (CurSlotTime != SHORT_SLOT_TIME) {
94a79942 528 slot_time_val = SHORT_SLOT_TIME;
1344ee25
LF		 529 priv->rtllib->SetHwRegHandler(dev,
530 HW_VAR_SLOT_TIME, &slot_time_val);
94a79942 531 }
1344ee25
LF		 532 } else {
533 if (CurSlotTime != NON_SHORT_SLOT_TIME) {
94a79942 534 slot_time_val = NON_SHORT_SLOT_TIME;
1344ee25
LF		 535 priv->rtllib->SetHwRegHandler(dev,
536 HW_VAR_SLOT_TIME, &slot_time_val);
94a79942
LF		 537 }
538 }
539 }
540}
541
542static struct rtllib_qos_parameters def_qos_parameters = {
34e987e6
RK		 543 {cpu_to_le16(3), cpu_to_le16(3), cpu_to_le16(3), cpu_to_le16(3)},
544 {cpu_to_le16(7), cpu_to_le16(7), cpu_to_le16(7), cpu_to_le16(7)},
1344ee25
LF		 545 {2, 2, 2, 2},
546 {0, 0, 0, 0},
547 {0, 0, 0, 0}
94a79942
LF		 548};
549
49aab5fd 550static void rtl8192_update_beacon(void *data)
94a79942 551{
1344ee25
LF		 552 struct r8192_priv *priv = container_of_work_rsl(data, struct r8192_priv,
553 update_beacon_wq.work);
94a79942 554 struct net_device *dev = priv->rtllib->dev;
1344ee25
LF		 555 struct rtllib_device *ieee = priv->rtllib;
556 struct rtllib_network *net = &ieee->current_network;
94a79942
LF		 557
558 if (ieee->pHTInfo->bCurrentHTSupport)
976d5341 559 HT_update_self_and_peer_setting(ieee, net);
1344ee25
LF		 560 ieee->pHTInfo->bCurrentRT2RTLongSlotTime =
561 net->bssht.bdRT2RTLongSlotTime;
94a79942
LF		 562 ieee->pHTInfo->RT2RT_HT_Mode = net->bssht.RT2RT_HT_Mode;
563 rtl8192_update_cap(dev, net->capability);
564}
565
49aab5fd 566static void rtl8192_qos_activate(void *data)
94a79942 567{
1344ee25
LF		 568 struct r8192_priv *priv = container_of_work_rsl(data, struct r8192_priv,
569 qos_activate);
94a79942 570 struct net_device *dev = priv->rtllib->dev;
1344ee25 571 int i;
94a79942 572
1344ee25
LF		 573 mutex_lock(&priv->mutex);
574 if (priv->rtllib->state != RTLLIB_LINKED)
94a79942 575 goto success;
0822339b
MK		 576 RT_TRACE(COMP_QOS,
577 "qos active process with associate response received\n");
94a79942 578
fe40a0b3 579 for (i = 0; i < QOS_QUEUE_NUM; i++)
1344ee25 580 priv->rtllib->SetHwRegHandler(dev, HW_VAR_AC_PARAM, (u8 *)(&i));
fe40a0b3 581
94a79942
LF		 582
583success:
1344ee25 584 mutex_unlock(&priv->mutex);
94a79942
LF		 585}
586
587static int rtl8192_qos_handle_probe_response(struct r8192_priv *priv,
588 int active_network,
589 struct rtllib_network *network)
590{
591 int ret = 0;
592 u32 size = sizeof(struct rtllib_qos_parameters);
593
1344ee25
LF		 594 if (priv->rtllib->state != RTLLIB_LINKED)
595 return ret;
94a79942 596
025b8bbe 597 if (priv->rtllib->iw_mode != IW_MODE_INFRA)
94a79942
LF		 598 return ret;
599
600 if (network->flags & NETWORK_HAS_QOS_MASK) {
601 if (active_network &&
602 (network->flags & NETWORK_HAS_QOS_PARAMETERS))
603 network->qos_data.active = network->qos_data.supported;
604
605 if ((network->qos_data.active == 1) && (active_network == 1) &&
606 (network->flags & NETWORK_HAS_QOS_PARAMETERS) &&
607 (network->qos_data.old_param_count !=
1344ee25 608 network->qos_data.param_count)) {
94a79942
LF		 609 network->qos_data.old_param_count =
610 network->qos_data.param_count;
1344ee25 611 priv->rtllib->wmm_acm = network->qos_data.wmm_acm;
94a79942 612 queue_work_rsl(priv->priv_wq, &priv->qos_activate);
0822339b
MK		 613 RT_TRACE(COMP_QOS,
614 "QoS parameters change call qos_activate\n");
94a79942
LF		 615 }
616 } else {
1344ee25 617 memcpy(&priv->rtllib->current_network.qos_data.parameters,
94a79942
LF		 618 &def_qos_parameters, size);
619
620 if ((network->qos_data.active == 1) && (active_network == 1)) {
621 queue_work_rsl(priv->priv_wq, &priv->qos_activate);
0822339b
MK		 622 RT_TRACE(COMP_QOS,
623 "QoS was disabled call qos_activate\n");
94a79942
LF		 624 }
625 network->qos_data.active = 0;
626 network->qos_data.supported = 0;
627 }
628
629 return 0;
630}
631
1344ee25
LF		 632static int rtl8192_handle_beacon(struct net_device *dev,
633 struct rtllib_beacon *beacon,
634 struct rtllib_network *network)
94a79942
LF		 635{
636 struct r8192_priv *priv = rtllib_priv(dev);
637
1344ee25 638 rtl8192_qos_handle_probe_response(priv, 1, network);
94a79942
LF		 639
640 queue_delayed_work_rsl(priv->priv_wq, &priv->update_beacon_wq, 0);
641 return 0;
642
643}
644
645static int rtl8192_qos_association_resp(struct r8192_priv *priv,
1344ee25 646 struct rtllib_network *network)
94a79942 647{
1344ee25
LF		 648 unsigned long flags;
649 u32 size = sizeof(struct rtllib_qos_parameters);
650 int set_qos_param = 0;
94a79942 651
1344ee25 652 if ((priv == NULL) || (network == NULL))
5c8b3961 653 return 0;
94a79942 654
1344ee25 655 if (priv->rtllib->state != RTLLIB_LINKED)
5c8b3961 656 return 0;
94a79942 657
025b8bbe 658 if (priv->rtllib->iw_mode != IW_MODE_INFRA)
5c8b3961 659 return 0;
94a79942 660
1344ee25 661 spin_lock_irqsave(&priv->rtllib->lock, flags);
94a79942 662 if (network->flags & NETWORK_HAS_QOS_PARAMETERS) {
1344ee25
LF		 663 memcpy(&priv->rtllib->current_network.qos_data.parameters,
664 &network->qos_data.parameters,
665 sizeof(struct rtllib_qos_parameters));
94a79942 666 priv->rtllib->current_network.qos_data.active = 1;
1344ee25 667 priv->rtllib->wmm_acm = network->qos_data.wmm_acm;
94a79942
LF		 668 set_qos_param = 1;
669 priv->rtllib->current_network.qos_data.old_param_count =
1344ee25 670 priv->rtllib->current_network.qos_data.param_count;
94a79942 671 priv->rtllib->current_network.qos_data.param_count =
1344ee25
LF		 672 network->qos_data.param_count;
673 } else {
94a79942 674 memcpy(&priv->rtllib->current_network.qos_data.parameters,
1344ee25 675 &def_qos_parameters, size);
94a79942
LF		 676 priv->rtllib->current_network.qos_data.active = 0;
677 priv->rtllib->current_network.qos_data.supported = 0;
1344ee25
LF		 678 set_qos_param = 1;
679 }
94a79942 680
1344ee25 681 spin_unlock_irqrestore(&priv->rtllib->lock, flags);
94a79942
LF		 682
683 RT_TRACE(COMP_QOS, "%s: network->flags = %d,%d\n", __func__,
1344ee25 684 network->flags, priv->rtllib->current_network.qos_data.active);
94a79942
LF		 685 if (set_qos_param == 1) {
686 dm_init_edca_turbo(priv->rtllib->dev);
687 queue_work_rsl(priv->priv_wq, &priv->qos_activate);
688 }
5c8b3961 689 return 0;
94a79942
LF		 690}
691
692static int rtl8192_handle_assoc_response(struct net_device *dev,
1344ee25
LF		 693 struct rtllib_assoc_response_frame *resp,
694 struct rtllib_network *network)
94a79942 695{
1344ee25 696 struct r8192_priv *priv = rtllib_priv(dev);
3a6b70c3 697
1344ee25
LF		 698 rtl8192_qos_association_resp(priv, network);
699 return 0;
94a79942
LF		 700}
701
49aab5fd 702static void rtl8192_prepare_beacon(struct r8192_priv *priv)
94a79942
LF		 703{
704 struct net_device *dev = priv->rtllib->dev;
705 struct sk_buff *pskb = NULL, *pnewskb = NULL;
3b83db43 706 struct cb_desc *tcb_desc = NULL;
94a79942 707 struct rtl8192_tx_ring *ring = NULL;
bc27e89b 708 struct tx_desc *pdesc = NULL;
94a79942
LF		 709
710 ring = &priv->tx_ring[BEACON_QUEUE];
711 pskb = __skb_dequeue(&ring->queue);
085b5018 712 kfree_skb(pskb);
94a79942
LF		 713
714 pnewskb = rtllib_get_beacon(priv->rtllib);
715 if (!pnewskb)
716 return;
717
3b83db43 718 tcb_desc = (struct cb_desc *)(pnewskb->cb + 8);
94a79942
LF		 719 tcb_desc->queue_index = BEACON_QUEUE;
720 tcb_desc->data_rate = 2;
721 tcb_desc->RATRIndex = 7;
722 tcb_desc->bTxDisableRateFallBack = 1;
723 tcb_desc->bTxUseDriverAssingedRate = 1;
724 skb_push(pnewskb, priv->rtllib->tx_headroom);
725
726 pdesc = &ring->desc[0];
727 priv->ops->tx_fill_descriptor(dev, pdesc, tcb_desc, pnewskb);
728 __skb_queue_tail(&ring->queue, pnewskb);
729 pdesc->OWN = 1;
94a79942
LF		 730}
731
49aab5fd 732static void rtl8192_stop_beacon(struct net_device *dev)
94a79942
LF		 733{
734}
735
1344ee25
LF		 736void rtl8192_config_rate(struct net_device *dev, u16 *rate_config)
737{
738 struct r8192_priv *priv = rtllib_priv(dev);
739 struct rtllib_network *net;
740 u8 i = 0, basic_rate = 0;
3a6b70c3 741
1344ee25
LF		 742 net = &priv->rtllib->current_network;
743
744 for (i = 0; i < net->rates_len; i++) {
745 basic_rate = net->rates[i] & 0x7f;
746 switch (basic_rate) {
747 case MGN_1M:
748 *rate_config |= RRSR_1M;
749 break;
750 case MGN_2M:
751 *rate_config |= RRSR_2M;
752 break;
753 case MGN_5_5M:
754 *rate_config |= RRSR_5_5M;
755 break;
756 case MGN_11M:
757 *rate_config |= RRSR_11M;
758 break;
759 case MGN_6M:
760 *rate_config |= RRSR_6M;
761 break;
762 case MGN_9M:
763 *rate_config |= RRSR_9M;
764 break;
765 case MGN_12M:
766 *rate_config |= RRSR_12M;
767 break;
768 case MGN_18M:
769 *rate_config |= RRSR_18M;
770 break;
771 case MGN_24M:
772 *rate_config |= RRSR_24M;
773 break;
774 case MGN_36M:
775 *rate_config |= RRSR_36M;
776 break;
777 case MGN_48M:
778 *rate_config |= RRSR_48M;
779 break;
780 case MGN_54M:
781 *rate_config |= RRSR_54M;
782 break;
783 }
784 }
785
786 for (i = 0; i < net->rates_ex_len; i++) {
787 basic_rate = net->rates_ex[i] & 0x7f;
788 switch (basic_rate) {
789 case MGN_1M:
790 *rate_config |= RRSR_1M;
791 break;
792 case MGN_2M:
793 *rate_config |= RRSR_2M;
794 break;
795 case MGN_5_5M:
796 *rate_config |= RRSR_5_5M;
797 break;
798 case MGN_11M:
799 *rate_config |= RRSR_11M;
800 break;
801 case MGN_6M:
802 *rate_config |= RRSR_6M;
803 break;
804 case MGN_9M:
805 *rate_config |= RRSR_9M;
806 break;
807 case MGN_12M:
808 *rate_config |= RRSR_12M;
809 break;
810 case MGN_18M:
811 *rate_config |= RRSR_18M;
812 break;
813 case MGN_24M:
814 *rate_config |= RRSR_24M;
815 break;
816 case MGN_36M:
817 *rate_config |= RRSR_36M;
818 break;
819 case MGN_48M:
820 *rate_config |= RRSR_48M;
821 break;
822 case MGN_54M:
823 *rate_config |= RRSR_54M;
824 break;
825 }
826 }
827}
828
49aab5fd 829static void rtl8192_refresh_supportrate(struct r8192_priv *priv)
1344ee25
LF		 830{
831 struct rtllib_device *ieee = priv->rtllib;
3a6b70c3 832
1344ee25
LF		 833 if (ieee->mode == WIRELESS_MODE_N_24G ||
834 ieee->mode == WIRELESS_MODE_N_5G) {
835 memcpy(ieee->Regdot11HTOperationalRateSet,
836 ieee->RegHTSuppRateSet, 16);
837 memcpy(ieee->Regdot11TxHTOperationalRateSet,
838 ieee->RegHTSuppRateSet, 16);
94a79942 839
94a79942
LF		 840 } else {
841 memset(ieee->Regdot11HTOperationalRateSet, 0, 16);
842 }
94a79942
LF		 843}
844
49aab5fd 845static u8 rtl8192_getSupportedWireleeMode(struct net_device *dev)
94a79942
LF		 846{
847 struct r8192_priv *priv = rtllib_priv(dev);
848 u8 ret = 0;
849
850 switch (priv->rf_chip) {
851 case RF_8225:
852 case RF_8256:
853 case RF_6052:
854 case RF_PSEUDO_11N:
855 ret = (WIRELESS_MODE_N_24G|WIRELESS_MODE_G | WIRELESS_MODE_B);
856 break;
857 case RF_8258:
858 ret = (WIRELESS_MODE_A | WIRELESS_MODE_N_5G);
859 break;
860 default:
861 ret = WIRELESS_MODE_B;
862 break;
863 }
864 return ret;
865}
866
1344ee25 867void rtl8192_SetWirelessMode(struct net_device *dev, u8 wireless_mode)
94a79942
LF		 868{
869 struct r8192_priv *priv = rtllib_priv(dev);
870 u8 bSupportMode = rtl8192_getSupportedWireleeMode(dev);
871
1344ee25
LF		 872 if ((wireless_mode == WIRELESS_MODE_AUTO) ||
873 ((wireless_mode & bSupportMode) == 0)) {
94a79942
LF		 874 if (bSupportMode & WIRELESS_MODE_N_24G) {
875 wireless_mode = WIRELESS_MODE_N_24G;
876 } else if (bSupportMode & WIRELESS_MODE_N_5G) {
877 wireless_mode = WIRELESS_MODE_N_5G;
878 } else if ((bSupportMode & WIRELESS_MODE_A)) {
879 wireless_mode = WIRELESS_MODE_A;
880 } else if ((bSupportMode & WIRELESS_MODE_G)) {
881 wireless_mode = WIRELESS_MODE_G;
882 } else if ((bSupportMode & WIRELESS_MODE_B)) {
883 wireless_mode = WIRELESS_MODE_B;
884 } else {
3b4140af
MK		 885 netdev_info(dev,
886 "%s(): Unsupported mode requested. Fallback to 802.11b\n",
887 __func__);
94a79942
LF		 888 wireless_mode = WIRELESS_MODE_B;
889 }
890 }
891
1344ee25
LF		 892 if ((wireless_mode & (WIRELESS_MODE_B | WIRELESS_MODE_G)) ==
893 (WIRELESS_MODE_G | WIRELESS_MODE_B))
94a79942
LF		 894 wireless_mode = WIRELESS_MODE_G;
895
896 priv->rtllib->mode = wireless_mode;
897
1344ee25
LF		 898 ActUpdateChannelAccessSetting(dev, wireless_mode,
899 &priv->ChannelAccessSetting);
94a79942 900
1344ee25
LF		 901 if ((wireless_mode == WIRELESS_MODE_N_24G) ||
902 (wireless_mode == WIRELESS_MODE_N_5G)) {
94a79942 903 priv->rtllib->pHTInfo->bEnableHT = 1;
1344ee25
LF		 904 RT_TRACE(COMP_DBG, "%s(), wireless_mode:%x, bEnableHT = 1\n",
905 __func__, wireless_mode);
906 } else {
94a79942 907 priv->rtllib->pHTInfo->bEnableHT = 0;
1344ee25
LF		 908 RT_TRACE(COMP_DBG, "%s(), wireless_mode:%x, bEnableHT = 0\n",
909 __func__, wireless_mode);
910 }
94a79942
LF		 911
912 RT_TRACE(COMP_INIT, "Current Wireless Mode is %x\n", wireless_mode);
913 rtl8192_refresh_supportrate(priv);
914}
915
49aab5fd 916static int _rtl8192_sta_up(struct net_device *dev, bool is_silent_reset)
94a79942
LF		 917{
918 struct r8192_priv *priv = rtllib_priv(dev);
1344ee25
LF		 919 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
920 (&(priv->rtllib->PowerSaveControl));
94a79942 921 bool init_status = true;
3a6b70c3 922
94a79942
LF		 923 priv->bDriverIsGoingToUnload = false;
924 priv->bdisable_nic = false;
925
1344ee25
LF		 926 priv->up = 1;
927 priv->rtllib->ieee_up = 1;
94a79942
LF		 928
929 priv->up_first_time = 0;
930 RT_TRACE(COMP_INIT, "Bringing up iface");
931 priv->bfirst_init = true;
932 init_status = priv->ops->initialize_adapter(dev);
4bb01423 933 if (!init_status) {
3b4140af 934 netdev_err(dev, "%s(): Initialization failed!\n", __func__);
94a79942
LF		 935 priv->bfirst_init = false;
936 return -1;
937 }
938
939 RT_TRACE(COMP_INIT, "start adapter finished\n");
940 RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
941 priv->bfirst_init = false;
94a79942 942
1344ee25 943 if (priv->polling_timer_on == 0)
94a79942 944 check_rfctrl_gpio_timer((unsigned long)dev);
94a79942
LF		 945
946 if (priv->rtllib->state != RTLLIB_LINKED)
1344ee25 947 rtllib_softmac_start_protocol(priv->rtllib, 0);
94a79942 948 rtllib_reset_queue(priv->rtllib);
94a79942 949 watch_dog_timer_callback((unsigned long) dev);
94a79942 950
94a79942
LF		 951 if (!netif_queue_stopped(dev))
952 netif_start_queue(dev);
953 else
954 netif_wake_queue(dev);
955
956 return 0;
957}
958
49aab5fd 959static int rtl8192_sta_down(struct net_device *dev, bool shutdownrf)
94a79942
LF		 960{
961 struct r8192_priv *priv = rtllib_priv(dev);
962 unsigned long flags = 0;
963 u8 RFInProgressTimeOut = 0;
964
1344ee25
LF		 965 if (priv->up == 0)
966 return -1;
94a79942
LF		 967
968 if (priv->rtllib->rtllib_ips_leave != NULL)
969 priv->rtllib->rtllib_ips_leave(dev);
970
971 if (priv->rtllib->state == RTLLIB_LINKED)
972 LeisurePSLeave(dev);
973
974 priv->bDriverIsGoingToUnload = true;
1344ee25 975 priv->up = 0;
94a79942 976 priv->rtllib->ieee_up = 0;
014e4c27 977 priv->bfirst_after_down = true;
94a79942
LF		 978 RT_TRACE(COMP_DOWN, "==========>%s()\n", __func__);
979 if (!netif_queue_stopped(dev))
980 netif_stop_queue(dev);
981
982 priv->rtllib->wpa_ie_len = 0;
1344ee25 983 kfree(priv->rtllib->wpa_ie);
94a79942
LF		 984 priv->rtllib->wpa_ie = NULL;
985 CamResetAllEntry(dev);
1344ee25 986 memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32);
94a79942
LF		 987 rtl8192_irq_disable(dev);
988
989 del_timer_sync(&priv->watch_dog_timer);
990 rtl8192_cancel_deferred_work(priv);
94a79942 991 cancel_delayed_work(&priv->rtllib->hw_wakeup_wq);
94a79942
LF		 992
993 rtllib_softmac_stop_protocol(priv->rtllib, 0, true);
1344ee25
LF		 994 spin_lock_irqsave(&priv->rf_ps_lock, flags);
995 while (priv->RFChangeInProgress) {
996 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
997 if (RFInProgressTimeOut > 100) {
998 spin_lock_irqsave(&priv->rf_ps_lock, flags);
94a79942
LF		 999 break;
1000 }
0822339b
MK		 1001 RT_TRACE(COMP_DBG,
1002 "===>%s():RF is in progress, need to wait until rf change is done.\n",
1003 __func__);
94a79942 1004 mdelay(1);
1344ee25
LF		 1005 RFInProgressTimeOut++;
1006 spin_lock_irqsave(&priv->rf_ps_lock, flags);
94a79942
LF		 1007 }
1008 priv->RFChangeInProgress = true;
1344ee25 1009 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
94a79942 1010 priv->ops->stop_adapter(dev, false);
1344ee25 1011 spin_lock_irqsave(&priv->rf_ps_lock, flags);
94a79942 1012 priv->RFChangeInProgress = false;
1344ee25 1013 spin_unlock_irqrestore(&priv->rf_ps_lock, flags);
94a79942 1014 udelay(100);
1344ee25
LF		 1015 memset(&priv->rtllib->current_network, 0,
1016 offsetof(struct rtllib_network, list));
94a79942
LF		 1017 RT_TRACE(COMP_DOWN, "<==========%s()\n", __func__);
1018
1019 return 0;
1020}
1021
1344ee25 1022static void rtl8192_init_priv_handler(struct net_device *dev)
94a79942
LF		 1023{
1024 struct r8192_priv *priv = rtllib_priv(dev);
1025
1026 priv->rtllib->softmac_hard_start_xmit = rtl8192_hard_start_xmit;
1344ee25
LF		 1027 priv->rtllib->set_chan = rtl8192_set_chan;
1028 priv->rtllib->link_change = priv->ops->link_change;
94a79942
LF		 1029 priv->rtllib->softmac_data_hard_start_xmit = rtl8192_hard_data_xmit;
1030 priv->rtllib->data_hard_stop = rtl8192_data_hard_stop;
1031 priv->rtllib->data_hard_resume = rtl8192_data_hard_resume;
1032 priv->rtllib->check_nic_enough_desc = rtl8192_check_nic_enough_desc;
94a79942
LF		 1033 priv->rtllib->handle_assoc_response = rtl8192_handle_assoc_response;
1034 priv->rtllib->handle_beacon = rtl8192_handle_beacon;
1035 priv->rtllib->SetWirelessMode = rtl8192_SetWirelessMode;
1036 priv->rtllib->LeisurePSLeave = LeisurePSLeave;
1037 priv->rtllib->SetBWModeHandler = rtl8192_SetBWMode;
1038 priv->rf_set_chan = rtl8192_phy_SwChnl;
1039
94a79942
LF		 1040 priv->rtllib->start_send_beacons = rtl8192e_start_beacon;
1041 priv->rtllib->stop_send_beacons = rtl8192_stop_beacon;
94a79942
LF		 1042
1043 priv->rtllib->sta_wake_up = rtl8192_hw_wakeup;
1044 priv->rtllib->enter_sleep_state = rtl8192_hw_to_sleep;
1045 priv->rtllib->ps_is_queue_empty = rtl8192_is_tx_queue_empty;
1046
1047 priv->rtllib->GetNmodeSupportBySecCfg = rtl8192_GetNmodeSupportBySecCfg;
1344ee25
LF		 1048 priv->rtllib->GetHalfNmodeSupportByAPsHandler =
1049 rtl8192_GetHalfNmodeSupportByAPs;
94a79942
LF		 1050
1051 priv->rtllib->SetHwRegHandler = rtl8192e_SetHwReg;
1052 priv->rtllib->AllowAllDestAddrHandler = rtl8192_AllowAllDestAddr;
1053 priv->rtllib->SetFwCmdHandler = NULL;
1054 priv->rtllib->InitialGainHandler = InitialGain819xPci;
1055 priv->rtllib->rtllib_ips_leave_wq = rtllib_ips_leave_wq;
1056 priv->rtllib->rtllib_ips_leave = rtllib_ips_leave;
1057
1058 priv->rtllib->LedControlHandler = NULL;
1059 priv->rtllib->UpdateBeaconInterruptHandler = NULL;
1060
1061 priv->rtllib->ScanOperationBackupHandler = PHY_ScanOperationBackup8192;
94a79942
LF		 1062}
1063
1344ee25 1064static void rtl8192_init_priv_constant(struct net_device *dev)
94a79942 1065{
94a79942 1066 struct r8192_priv *priv = rtllib_priv(dev);
1344ee25
LF		 1067 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
1068 &(priv->rtllib->PowerSaveControl);
94a79942 1069
94a79942 1070 pPSC->RegMaxLPSAwakeIntvl = 5;
94a79942
LF		 1071}
1072
1073
1344ee25 1074static void rtl8192_init_priv_variable(struct net_device *dev)
94a79942
LF		 1075{
1076 struct r8192_priv *priv = rtllib_priv(dev);
1077 u8 i;
1078
1079 priv->AcmMethod = eAcmWay2_SW;
1080 priv->dot11CurrentPreambleMode = PREAMBLE_AUTO;
94a79942 1081 priv->rtllib->status = 0;
94a79942
LF		 1082 priv->polling_timer_on = 0;
1083 priv->up_first_time = 1;
1084 priv->blinked_ingpio = false;
1085 priv->bDriverIsGoingToUnload = false;
1086 priv->being_init_adapter = false;
1087 priv->initialized_at_probe = false;
94a79942
LF		 1088 priv->bdisable_nic = false;
1089 priv->bfirst_init = false;
1090 priv->txringcount = 64;
1091 priv->rxbuffersize = 9100;
1092 priv->rxringcount = MAX_RX_COUNT;
1344ee25 1093 priv->irq_enabled = 0;
94a79942 1094 priv->chan = 1;
94a79942 1095 priv->RegChannelPlan = 0xf;
94a79942
LF		 1096 priv->rtllib->mode = WIRELESS_MODE_AUTO;
1097 priv->rtllib->iw_mode = IW_MODE_INFRA;
1098 priv->rtllib->bNetPromiscuousMode = false;
1099 priv->rtllib->IntelPromiscuousModeInfo.bPromiscuousOn = false;
1344ee25
LF		 1100 priv->rtllib->IntelPromiscuousModeInfo.bFilterSourceStationFrame =
1101 false;
1102 priv->rtllib->ieee_up = 0;
94a79942
LF		 1103 priv->retry_rts = DEFAULT_RETRY_RTS;
1104 priv->retry_data = DEFAULT_RETRY_DATA;
1105 priv->rtllib->rts = DEFAULT_RTS_THRESHOLD;
1106 priv->rtllib->rate = 110;
1107 priv->rtllib->short_slot = 1;
1344ee25 1108 priv->promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
94a79942
LF		 1109 priv->bcck_in_ch14 = false;
1110 priv->bfsync_processing = false;
1111 priv->CCKPresentAttentuation = 0;
1112 priv->rfa_txpowertrackingindex = 0;
1113 priv->rfc_txpowertrackingindex = 0;
1114 priv->CckPwEnl = 6;
1115 priv->ScanDelay = 50;
1116 priv->ResetProgress = RESET_TYPE_NORESET;
014e4c27 1117 priv->bForcedSilentReset = false;
94a79942
LF		 1118 priv->bDisableNormalResetCheck = false;
1119 priv->force_reset = false;
1344ee25 1120 memset(priv->rtllib->swcamtable, 0, sizeof(struct sw_cam_table) * 32);
94a79942 1121
1344ee25 1122 memset(&priv->InterruptLog, 0, sizeof(struct log_int_8190));
94a79942 1123 priv->RxCounter = 0;
1344ee25 1124 priv->rtllib->wx_set_enc = 0;
94a79942 1125 priv->bHwRadioOff = false;
014e4c27 1126 priv->RegRfOff = false;
94a79942
LF		 1127 priv->isRFOff = false;
1128 priv->bInPowerSaveMode = false;
1129 priv->rtllib->RfOffReason = 0;
1130 priv->RFChangeInProgress = false;
1131 priv->bHwRfOffAction = 0;
1132 priv->SetRFPowerStateInProgress = false;
1133 priv->rtllib->PowerSaveControl.bInactivePs = true;
1134 priv->rtllib->PowerSaveControl.bIPSModeBackup = false;
1135 priv->rtllib->PowerSaveControl.bLeisurePs = true;
1136 priv->rtllib->PowerSaveControl.bFwCtrlLPS = false;
1137 priv->rtllib->LPSDelayCnt = 0;
1138 priv->rtllib->sta_sleep = LPS_IS_WAKE;
1139 priv->rtllib->eRFPowerState = eRfOn;
1140
94a79942
LF		 1141 priv->rtllib->current_network.beacon_interval = DEFAULT_BEACONINTERVAL;
1142 priv->rtllib->iw_mode = IW_MODE_INFRA;
1143 priv->rtllib->active_scan = 1;
1144 priv->rtllib->be_scan_inprogress = false;
1344ee25
LF		 1145 priv->rtllib->modulation = RTLLIB_CCK_MODULATION |
1146 RTLLIB_OFDM_MODULATION;
94a79942
LF		 1147 priv->rtllib->host_encrypt = 1;
1148 priv->rtllib->host_decrypt = 1;
1149
94a79942 1150 priv->rtllib->fts = DEFAULT_FRAG_THRESHOLD;
94a79942
LF		 1151
1152 priv->card_type = PCI;
1153
49aab5fd
LF		 1154 priv->pFirmware = vzalloc(sizeof(struct rt_firmware));
1155 if (!priv->pFirmware)
d69d2054
MK		 1156 netdev_err(dev,
1157 "rtl8192e: Unable to allocate space for firmware\n");
94a79942 1158
94a79942
LF		 1159 skb_queue_head_init(&priv->skb_queue);
1160
1344ee25
LF		 1161 for (i = 0; i < MAX_QUEUE_SIZE; i++)
1162 skb_queue_head_init(&priv->rtllib->skb_waitQ[i]);
1163 for (i = 0; i < MAX_QUEUE_SIZE; i++)
1164 skb_queue_head_init(&priv->rtllib->skb_aggQ[i]);
94a79942
LF		 1165}
1166
1344ee25 1167static void rtl8192_init_priv_lock(struct r8192_priv *priv)
94a79942 1168{
94a79942 1169 spin_lock_init(&priv->tx_lock);
94a79942
LF		 1170 spin_lock_init(&priv->irq_th_lock);
1171 spin_lock_init(&priv->rf_ps_lock);
1172 spin_lock_init(&priv->ps_lock);
1344ee25
LF		 1173 sema_init(&priv->wx_sem, 1);
1174 sema_init(&priv->rf_sem, 1);
94a79942 1175 mutex_init(&priv->mutex);
94a79942
LF		 1176}
1177
1344ee25 1178static void rtl8192_init_priv_task(struct net_device *dev)
94a79942
LF		 1179{
1180 struct r8192_priv *priv = rtllib_priv(dev);
1181
94a79942 1182 priv->priv_wq = create_workqueue(DRV_NAME);
1344ee25
LF		 1183 INIT_WORK_RSL(&priv->reset_wq, (void *)rtl8192_restart, dev);
1184 INIT_WORK_RSL(&priv->rtllib->ips_leave_wq, (void *)IPSLeave_wq, dev);
1185 INIT_DELAYED_WORK_RSL(&priv->watch_dog_wq,
1186 (void *)rtl819x_watchdog_wqcallback, dev);
1187 INIT_DELAYED_WORK_RSL(&priv->txpower_tracking_wq,
1188 (void *)dm_txpower_trackingcallback, dev);
1189 INIT_DELAYED_WORK_RSL(&priv->rfpath_check_wq,
1190 (void *)dm_rf_pathcheck_workitemcallback, dev);
1191 INIT_DELAYED_WORK_RSL(&priv->update_beacon_wq,
1192 (void *)rtl8192_update_beacon, dev);
1193 INIT_WORK_RSL(&priv->qos_activate, (void *)rtl8192_qos_activate, dev);
1194 INIT_DELAYED_WORK_RSL(&priv->rtllib->hw_wakeup_wq,
1195 (void *) rtl8192_hw_wakeup_wq, dev);
1196 INIT_DELAYED_WORK_RSL(&priv->rtllib->hw_sleep_wq,
1197 (void *) rtl8192_hw_sleep_wq, dev);
94a79942 1198 tasklet_init(&priv->irq_rx_tasklet,
1344ee25
LF		 1199 (void(*)(unsigned long))rtl8192_irq_rx_tasklet,
1200 (unsigned long)priv);
94a79942 1201 tasklet_init(&priv->irq_tx_tasklet,
1344ee25
LF		 1202 (void(*)(unsigned long))rtl8192_irq_tx_tasklet,
1203 (unsigned long)priv);
1204 tasklet_init(&priv->irq_prepare_beacon_tasklet,
1205 (void(*)(unsigned long))rtl8192_prepare_beacon,
1206 (unsigned long)priv);
94a79942
LF		 1207}
1208
49aab5fd 1209static short rtl8192_get_channel_map(struct net_device *dev)
94a79942
LF		 1210{
1211 int i;
1212
94a79942 1213 struct r8192_priv *priv = rtllib_priv(dev);
3a6b70c3 1214
94a79942
LF		 1215 if ((priv->rf_chip != RF_8225) && (priv->rf_chip != RF_8256)
1216 && (priv->rf_chip != RF_6052)) {
3b4140af
MK		 1217 netdev_err(dev, "%s: unknown rf chip, can't set channel map\n",
1218 __func__);
94a79942
LF		 1219 return -1;
1220 }
1221
8f019bfe 1222 if (priv->ChannelPlan >= COUNTRY_CODE_MAX) {
d69d2054
MK		 1223 netdev_info(dev,
1224 "rtl819x_init:Error channel plan! Set to default.\n");
1344ee25 1225 priv->ChannelPlan = COUNTRY_CODE_FCC;
94a79942 1226 }
1344ee25 1227 RT_TRACE(COMP_INIT, "Channel plan is %d\n", priv->ChannelPlan);
976d5341 1228 dot11d_init(priv->rtllib);
94a79942 1229 Dot11d_Channelmap(priv->ChannelPlan, priv->rtllib);
1344ee25 1230 for (i = 1; i <= 11; i++)
94a79942 1231 (priv->rtllib->active_channel_map)[i] = 1;
94a79942
LF		 1232 (priv->rtllib->active_channel_map)[12] = 2;
1233 (priv->rtllib->active_channel_map)[13] = 2;
1234
1235 return 0;
1236}
1237
49aab5fd 1238static short rtl8192_init(struct net_device *dev)
94a79942
LF		 1239{
1240 struct r8192_priv *priv = rtllib_priv(dev);
1241
1344ee25 1242 memset(&(priv->stats), 0, sizeof(struct rt_stats));
94a79942 1243
94a79942
LF		 1244 rtl8192_init_priv_handler(dev);
1245 rtl8192_init_priv_constant(dev);
1246 rtl8192_init_priv_variable(dev);
1247 rtl8192_init_priv_lock(priv);
1248 rtl8192_init_priv_task(dev);
1249 priv->ops->get_eeprom_size(dev);
1250 priv->ops->init_adapter_variable(dev);
1251 rtl8192_get_channel_map(dev);
1252
94a79942
LF		 1253 init_hal_dm(dev);
1254
94a79942
LF		 1255 init_timer(&priv->watch_dog_timer);
1256 setup_timer(&priv->watch_dog_timer,
1257 watch_dog_timer_callback,
1258 (unsigned long) dev);
1259
1260 init_timer(&priv->gpio_polling_timer);
1261 setup_timer(&priv->gpio_polling_timer,
1262 check_rfctrl_gpio_timer,
1263 (unsigned long)dev);
1264
1265 rtl8192_irq_disable(dev);
30224b5e 1266 if (request_irq(dev->irq, rtl8192_interrupt, IRQF_SHARED,
1344ee25 1267 dev->name, dev)) {
d69d2054 1268 netdev_err(dev, "Error allocating IRQ %d", dev->irq);
94a79942 1269 return -1;
94a79942
LF		 1270 }
1271
285b7c00
MK		 1272 priv->irq = dev->irq;
1273 RT_TRACE(COMP_INIT, "IRQ %d\n", dev->irq);
1274
94a79942 1275 if (rtl8192_pci_initdescring(dev) != 0) {
d69d2054 1276 netdev_err(dev, "Endopoints initialization failed");
35f8673d 1277 free_irq(dev->irq, dev);
94a79942
LF		 1278 return -1;
1279 }
1280
1281 return 0;
1282}
1283
94a79942 1284/***************************************************************************
1344ee25 1285 -------------------------------WATCHDOG STUFF---------------------------
94a79942
LF		 1286***************************************************************************/
1287short rtl8192_is_tx_queue_empty(struct net_device *dev)
1288{
1344ee25 1289 int i = 0;
94a79942 1290 struct r8192_priv *priv = rtllib_priv(dev);
3a6b70c3 1291
1344ee25
LF		 1292 for (i = 0; i <= MGNT_QUEUE; i++) {
1293 if ((i == TXCMD_QUEUE) || (i == HCCA_QUEUE))
94a79942 1294 continue;
1344ee25 1295 if (skb_queue_len(&(&priv->tx_ring[i])->queue) > 0) {
d69d2054 1296 netdev_info(dev, "===>tx queue is not empty:%d, %d\n",
1344ee25 1297 i, skb_queue_len(&(&priv->tx_ring[i])->queue));
94a79942
LF		 1298 return 0;
1299 }
1300 }
1301 return 1;
1302}
1303
49aab5fd 1304static enum reset_type rtl819x_TxCheckStuck(struct net_device *dev)
94a79942
LF		 1305{
1306 struct r8192_priv *priv = rtllib_priv(dev);
1344ee25
LF		 1307 u8 QueueID;
1308 u8 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
1309 bool bCheckFwTxCnt = false;
94a79942 1310 struct rtl8192_tx_ring *ring = NULL;
1344ee25
LF		 1311 struct sk_buff *skb = NULL;
1312 struct cb_desc *tcb_desc = NULL;
94a79942
LF		 1313 unsigned long flags = 0;
1314
1344ee25
LF		 1315 switch (priv->rtllib->ps) {
1316 case RTLLIB_PS_DISABLED:
1317 ResetThreshold = NIC_SEND_HANG_THRESHOLD_NORMAL;
1318 break;
1319 case (RTLLIB_PS_MBCAST|RTLLIB_PS_UNICAST):
1320 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
1321 break;
1322 default:
1323 ResetThreshold = NIC_SEND_HANG_THRESHOLD_POWERSAVE;
1324 break;
94a79942 1325 }
1344ee25
LF		 1326 spin_lock_irqsave(&priv->irq_th_lock, flags);
1327 for (QueueID = 0; QueueID < MAX_TX_QUEUE; QueueID++) {
94a79942
LF		 1328 if (QueueID == TXCMD_QUEUE)
1329 continue;
1330
1331 if (QueueID == BEACON_QUEUE)
1332 continue;
1333
1334 ring = &priv->tx_ring[QueueID];
1335
1344ee25 1336 if (skb_queue_len(&ring->queue) == 0) {
94a79942 1337 continue;
1344ee25 1338 } else {
94a79942 1339 skb = (&ring->queue)->next;
1344ee25
LF		 1340 tcb_desc = (struct cb_desc *)(skb->cb +
1341 MAX_DEV_ADDR_SIZE);
94a79942
LF		 1342 tcb_desc->nStuckCount++;
1343 bCheckFwTxCnt = true;
1344 if (tcb_desc->nStuckCount > 1)
d69d2054
MK		 1345 netdev_info(dev,
1346 "%s: QueueID=%d tcb_desc->nStuckCount=%d\n",
1347 __func__, QueueID,
1348 tcb_desc->nStuckCount);
94a79942
LF		 1349 }
1350 }
1344ee25 1351 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
94a79942
LF		 1352
1353 if (bCheckFwTxCnt) {
1344ee25 1354 if (priv->ops->TxCheckStuckHandler(dev)) {
0822339b
MK		 1355 RT_TRACE(COMP_RESET,
1356 "TxCheckStuck(): Fw indicates no Tx condition!\n");
94a79942
LF		 1357 return RESET_TYPE_SILENT;
1358 }
1359 }
1360
1361 return RESET_TYPE_NORESET;
1362}
1363
49aab5fd 1364static enum reset_type rtl819x_RxCheckStuck(struct net_device *dev)
94a79942
LF		 1365{
1366 struct r8192_priv *priv = rtllib_priv(dev);
1367
1344ee25 1368 if (priv->ops->RxCheckStuckHandler(dev)) {
94a79942
LF		 1369 RT_TRACE(COMP_RESET, "RxStuck Condition\n");
1370 return RESET_TYPE_SILENT;
1371 }
1372
1373 return RESET_TYPE_NORESET;
1374}
1375
49aab5fd 1376static enum reset_type rtl819x_ifcheck_resetornot(struct net_device *dev)
94a79942
LF		 1377{
1378 struct r8192_priv *priv = rtllib_priv(dev);
ab0d7cca
LF		 1379 enum reset_type TxResetType = RESET_TYPE_NORESET;
1380 enum reset_type RxResetType = RESET_TYPE_NORESET;
de7c885a 1381 enum rt_rf_power_state rfState;
94a79942
LF		 1382
1383 rfState = priv->rtllib->eRFPowerState;
1384
1385 if (rfState == eRfOn)
1386 TxResetType = rtl819x_TxCheckStuck(dev);
1387
1344ee25 1388 if (rfState == eRfOn &&
94a79942 1389 (priv->rtllib->iw_mode == IW_MODE_INFRA) &&
1344ee25 1390 (priv->rtllib->state == RTLLIB_LINKED))
94a79942 1391 RxResetType = rtl819x_RxCheckStuck(dev);
94a79942 1392
1344ee25
LF		 1393 if (TxResetType == RESET_TYPE_NORMAL ||
1394 RxResetType == RESET_TYPE_NORMAL) {
d69d2054
MK		 1395 netdev_info(dev, "%s(): TxResetType is %d, RxResetType is %d\n",
1396 __func__, TxResetType, RxResetType);
94a79942 1397 return RESET_TYPE_NORMAL;
1344ee25
LF		 1398 } else if (TxResetType == RESET_TYPE_SILENT ||
1399 RxResetType == RESET_TYPE_SILENT) {
d69d2054
MK		 1400 netdev_info(dev, "%s(): TxResetType is %d, RxResetType is %d\n",
1401 __func__, TxResetType, RxResetType);
94a79942
LF		 1402 return RESET_TYPE_SILENT;
1403 } else {
1404 return RESET_TYPE_NORESET;
1405 }
1406
1407}
1408
49aab5fd 1409static void rtl819x_silentreset_mesh_bk(struct net_device *dev, u8 IsPortal)
94a79942
LF		 1410{
1411}
1412
49aab5fd 1413static void rtl819x_ifsilentreset(struct net_device *dev)
94a79942
LF		 1414{
1415 struct r8192_priv *priv = rtllib_priv(dev);
1416 u8 reset_times = 0;
1417 int reset_status = 0;
1418 struct rtllib_device *ieee = priv->rtllib;
1419 unsigned long flag;
1420
1421 u8 IsPortal = 0;
1422
1423
1344ee25 1424 if (priv->ResetProgress == RESET_TYPE_NORESET) {
94a79942 1425
1344ee25 1426 RT_TRACE(COMP_RESET, "=========>Reset progress!!\n");
94a79942
LF		 1427
1428 priv->ResetProgress = RESET_TYPE_SILENT;
1429
1344ee25
LF		 1430 spin_lock_irqsave(&priv->rf_ps_lock, flag);
1431 if (priv->RFChangeInProgress) {
1432 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
94a79942
LF		 1433 goto END;
1434 }
1435 priv->RFChangeInProgress = true;
1436 priv->bResetInProgress = true;
1344ee25 1437 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
94a79942
LF		 1438
1439RESET_START:
1440
1441 down(&priv->wx_sem);
1442
1443 if (priv->rtllib->state == RTLLIB_LINKED)
1444 LeisurePSLeave(dev);
1445
5dc42962 1446 if (priv->up) {
3b4140af
MK		 1447 netdev_info(dev, "%s():the driver is not up.\n",
1448 __func__);
94a79942 1449 up(&priv->wx_sem);
fe40a0b3 1450 return;
94a79942
LF		 1451 }
1452 priv->up = 0;
1453
1344ee25
LF		 1454 RT_TRACE(COMP_RESET, "%s():======>start to down the driver\n",
1455 __func__);
94a79942 1456 mdelay(1000);
0822339b
MK		 1457 RT_TRACE(COMP_RESET,
1458 "%s():111111111111111111111111======>start to down the driver\n",
1459 __func__);
94a79942
LF		 1460
1461 if (!netif_queue_stopped(dev))
1462 netif_stop_queue(dev);
1463
1464 rtl8192_irq_disable(dev);
1465 del_timer_sync(&priv->watch_dog_timer);
1466 rtl8192_cancel_deferred_work(priv);
1467 deinit_hal_dm(dev);
1468 rtllib_stop_scan_syncro(ieee);
1469
1470 if (ieee->state == RTLLIB_LINKED) {
1471 SEM_DOWN_IEEE_WX(&ieee->wx_sem);
d69d2054 1472 netdev_info(dev, "ieee->state is RTLLIB_LINKED\n");
94a79942
LF		 1473 rtllib_stop_send_beacons(priv->rtllib);
1474 del_timer_sync(&ieee->associate_timer);
1475 cancel_delayed_work(&ieee->associate_retry_wq);
1476 rtllib_stop_scan(ieee);
1477 netif_carrier_off(dev);
1478 SEM_UP_IEEE_WX(&ieee->wx_sem);
1479 } else {
d69d2054 1480 netdev_info(dev, "ieee->state is NOT LINKED\n");
f6692285 1481 rtllib_softmac_stop_protocol(priv->rtllib, 0, true);
94a79942
LF		 1482 }
1483
94a79942 1484 dm_backup_dynamic_mechanism_state(dev);
94a79942
LF		 1485
1486 up(&priv->wx_sem);
0822339b
MK		 1487 RT_TRACE(COMP_RESET,
1488 "%s():<==========down process is finished\n",
1489 __func__);
94a79942 1490
1344ee25
LF		 1491 RT_TRACE(COMP_RESET, "%s():<===========up process start\n",
1492 __func__);
1493 reset_status = _rtl8192_up(dev, true);
94a79942 1494
0822339b
MK		 1495 RT_TRACE(COMP_RESET,
1496 "%s():<===========up process is finished\n", __func__);
94a79942
LF		 1497 if (reset_status == -1) {
1498 if (reset_times < 3) {
1499 reset_times++;
1500 goto RESET_START;
1501 } else {
3b4140af
MK		 1502 netdev_warn(dev, "%s(): Reset Failed\n",
1503 __func__);
94a79942
LF		 1504 }
1505 }
1506
1507 ieee->is_silent_reset = 1;
1508
1344ee25 1509 spin_lock_irqsave(&priv->rf_ps_lock, flag);
94a79942 1510 priv->RFChangeInProgress = false;
1344ee25 1511 spin_unlock_irqrestore(&priv->rf_ps_lock, flag);
94a79942
LF		 1512
1513 EnableHWSecurityConfig8192(dev);
1514
1344ee25
LF		 1515 if (ieee->state == RTLLIB_LINKED && ieee->iw_mode ==
1516 IW_MODE_INFRA) {
1517 ieee->set_chan(ieee->dev,
1518 ieee->current_network.channel);
94a79942
LF		 1519
1520 queue_work_rsl(ieee->wq, &ieee->associate_complete_wq);
1521
1344ee25
LF		 1522 } else if (ieee->state == RTLLIB_LINKED && ieee->iw_mode ==
1523 IW_MODE_ADHOC) {
1524 ieee->set_chan(ieee->dev,
1525 ieee->current_network.channel);
94a79942
LF		 1526 ieee->link_change(ieee->dev);
1527
1528 notify_wx_assoc_event(ieee);
1529
1530 rtllib_start_send_beacons(ieee);
1531
1532 if (ieee->data_hard_resume)
1533 ieee->data_hard_resume(ieee->dev);
1534 netif_carrier_on(ieee->dev);
1535 } else if (ieee->iw_mode == IW_MODE_MESH) {
1536 rtl819x_silentreset_mesh_bk(dev, IsPortal);
1537 }
1538
1539 CamRestoreAllEntry(dev);
94a79942 1540 dm_restore_dynamic_mechanism_state(dev);
94a79942
LF		 1541END:
1542 priv->ResetProgress = RESET_TYPE_NORESET;
1543 priv->reset_count++;
1544
1344ee25 1545 priv->bForcedSilentReset = false;
94a79942
LF		 1546 priv->bResetInProgress = false;
1547
94a79942 1548 write_nic_byte(dev, UFWP, 1);
1344ee25
LF		 1549 RT_TRACE(COMP_RESET, "Reset finished!! ====>[%d]\n",
1550 priv->reset_count);
94a79942
LF		 1551 }
1552}
1553
49aab5fd
LF		 1554static void rtl819x_update_rxcounts(struct r8192_priv *priv, u32 *TotalRxBcnNum,
1555 u32 *TotalRxDataNum)
94a79942 1556{
1344ee25
LF		 1557 u16 SlotIndex;
1558 u8 i;
94a79942
LF		 1559
1560 *TotalRxBcnNum = 0;
1561 *TotalRxDataNum = 0;
1562
1344ee25
LF		 1563 SlotIndex = (priv->rtllib->LinkDetectInfo.SlotIndex++) %
1564 (priv->rtllib->LinkDetectInfo.SlotNum);
1565 priv->rtllib->LinkDetectInfo.RxBcnNum[SlotIndex] =
1566 priv->rtllib->LinkDetectInfo.NumRecvBcnInPeriod;
1567 priv->rtllib->LinkDetectInfo.RxDataNum[SlotIndex] =
1568 priv->rtllib->LinkDetectInfo.NumRecvDataInPeriod;
94a79942
LF		 1569 for (i = 0; i < priv->rtllib->LinkDetectInfo.SlotNum; i++) {
1570 *TotalRxBcnNum += priv->rtllib->LinkDetectInfo.RxBcnNum[i];
1571 *TotalRxDataNum += priv->rtllib->LinkDetectInfo.RxDataNum[i];
1572 }
1573}
1574
1575
1576void rtl819x_watchdog_wqcallback(void *data)
1577{
1344ee25
LF		 1578 struct r8192_priv *priv = container_of_dwork_rsl(data,
1579 struct r8192_priv, watch_dog_wq);
94a79942 1580 struct net_device *dev = priv->rtllib->dev;
1344ee25 1581 struct rtllib_device *ieee = priv->rtllib;
ab0d7cca 1582 enum reset_type ResetType = RESET_TYPE_NORESET;
1344ee25 1583 static u8 check_reset_cnt;
94a79942 1584 unsigned long flags;
1344ee25
LF		 1585 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
1586 (&(priv->rtllib->PowerSaveControl));
94a79942
LF		 1587 bool bBusyTraffic = false;
1588 bool bHigherBusyTraffic = false;
1589 bool bHigherBusyRxTraffic = false;
1590 bool bEnterPS = false;
1591
5dc42962 1592 if (!priv->up || priv->bHwRadioOff)
94a79942
LF		 1593 return;
1594
1595 if (priv->rtllib->state >= RTLLIB_LINKED) {
1344ee25 1596 if (priv->rtllib->CntAfterLink < 2)
94a79942
LF		 1597 priv->rtllib->CntAfterLink++;
1598 } else {
1599 priv->rtllib->CntAfterLink = 0;
1600 }
1601
1602 hal_dm_watchdog(dev);
1603
1344ee25
LF		 1604 if (rtllib_act_scanning(priv->rtllib, false) == false) {
1605 if ((ieee->iw_mode == IW_MODE_INFRA) && (ieee->state ==
1606 RTLLIB_NOLINK) &&
1607 (ieee->eRFPowerState == eRfOn) && !ieee->is_set_key &&
1608 (!ieee->proto_stoppping) && !ieee->wx_set_enc) {
1609 if ((ieee->PowerSaveControl.ReturnPoint ==
1610 IPS_CALLBACK_NONE) &&
1611 (!ieee->bNetPromiscuousMode)) {
0822339b
MK		 1612 RT_TRACE(COMP_PS,
1613 "====================>haha: IPSEnter()\n");
94a79942
LF		 1614 IPSEnter(dev);
1615 }
1616 }
1617 }
1344ee25
LF		 1618 if ((ieee->state == RTLLIB_LINKED) && (ieee->iw_mode ==
1619 IW_MODE_INFRA) && (!ieee->bNetPromiscuousMode)) {
1620 if (ieee->LinkDetectInfo.NumRxOkInPeriod > 100 ||
1621 ieee->LinkDetectInfo.NumTxOkInPeriod > 100)
1622 bBusyTraffic = true;
94a79942
LF		 1623
1624
1344ee25
LF		 1625 if (ieee->LinkDetectInfo.NumRxOkInPeriod > 4000 ||
1626 ieee->LinkDetectInfo.NumTxOkInPeriod > 4000) {
1627 bHigherBusyTraffic = true;
1628 if (ieee->LinkDetectInfo.NumRxOkInPeriod > 5000)
1629 bHigherBusyRxTraffic = true;
94a79942 1630 else
1344ee25
LF		 1631 bHigherBusyRxTraffic = false;
1632 }
94a79942 1633
1344ee25
LF		 1634 if (((ieee->LinkDetectInfo.NumRxUnicastOkInPeriod +
1635 ieee->LinkDetectInfo.NumTxOkInPeriod) > 8) ||
1636 (ieee->LinkDetectInfo.NumRxUnicastOkInPeriod > 2))
1637 bEnterPS = false;
1638 else
1639 bEnterPS = true;
94a79942 1640
1344ee25
LF		 1641 if (ieee->current_network.beacon_interval < 95)
1642 bEnterPS = false;
94a79942 1643
1344ee25
LF		 1644 if (bEnterPS)
1645 LeisurePSEnter(dev);
1646 else
94a79942 1647 LeisurePSLeave(dev);
94a79942 1648
1344ee25
LF		 1649 } else {
1650 RT_TRACE(COMP_LPS, "====>no link LPS leave\n");
1651 LeisurePSLeave(dev);
1652 }
94a79942 1653
1344ee25
LF		 1654 ieee->LinkDetectInfo.NumRxOkInPeriod = 0;
1655 ieee->LinkDetectInfo.NumTxOkInPeriod = 0;
1656 ieee->LinkDetectInfo.NumRxUnicastOkInPeriod = 0;
1657 ieee->LinkDetectInfo.bBusyTraffic = bBusyTraffic;
94a79942 1658
1344ee25
LF		 1659 ieee->LinkDetectInfo.bHigherBusyTraffic = bHigherBusyTraffic;
1660 ieee->LinkDetectInfo.bHigherBusyRxTraffic = bHigherBusyRxTraffic;
94a79942 1661
1344ee25
LF		 1662 if (ieee->state == RTLLIB_LINKED && ieee->iw_mode == IW_MODE_INFRA) {
1663 u32 TotalRxBcnNum = 0;
1664 u32 TotalRxDataNum = 0;
94a79942 1665
1344ee25 1666 rtl819x_update_rxcounts(priv, &TotalRxBcnNum, &TotalRxDataNum);
94a79942 1667
1344ee25
LF		 1668 if ((TotalRxBcnNum+TotalRxDataNum) == 0)
1669 priv->check_roaming_cnt++;
1670 else
1671 priv->check_roaming_cnt = 0;
94a79942
LF		 1672
1673
1344ee25
LF		 1674 if (priv->check_roaming_cnt > 0) {
1675 if (ieee->eRFPowerState == eRfOff)
3b4140af 1676 netdev_info(dev, "%s(): RF is off\n", __func__);
94a79942 1677
d69d2054
MK		 1678 netdev_info(dev,
1679 "===>%s(): AP is power off, chan:%d, connect another one\n",
1680 __func__, priv->chan);
94a79942 1681
1344ee25 1682 ieee->state = RTLLIB_ASSOCIATING;
94a79942 1683
1344ee25
LF		 1684 RemovePeerTS(priv->rtllib,
1685 priv->rtllib->current_network.bssid);
1686 ieee->is_roaming = true;
1687 ieee->is_set_key = false;
1688 ieee->link_change(dev);
1689 if (ieee->LedControlHandler)
1690 ieee->LedControlHandler(ieee->dev,
1691 LED_CTL_START_TO_LINK);
94a79942 1692
1344ee25 1693 notify_wx_assoc_event(ieee);
94a79942 1694
1344ee25
LF		 1695 if (!(ieee->rtllib_ap_sec_type(ieee) &
1696 (SEC_ALG_CCMP|SEC_ALG_TKIP)))
1697 queue_delayed_work_rsl(ieee->wq,
1698 &ieee->associate_procedure_wq, 0);
94a79942 1699
1344ee25 1700 priv->check_roaming_cnt = 0;
94a79942 1701 }
1344ee25
LF		 1702 ieee->LinkDetectInfo.NumRecvBcnInPeriod = 0;
1703 ieee->LinkDetectInfo.NumRecvDataInPeriod = 0;
94a79942
LF		 1704
1705 }
1706
1344ee25 1707 spin_lock_irqsave(&priv->tx_lock, flags);
94a79942 1708 if ((check_reset_cnt++ >= 3) && (!ieee->is_roaming) &&
1344ee25 1709 (!priv->RFChangeInProgress) && (!pPSC->bSwRfProcessing)) {
94a79942
LF		 1710 ResetType = rtl819x_ifcheck_resetornot(dev);
1711 check_reset_cnt = 3;
1712 }
1344ee25 1713 spin_unlock_irqrestore(&priv->tx_lock, flags);
94a79942 1714
1344ee25 1715 if (!priv->bDisableNormalResetCheck && ResetType == RESET_TYPE_NORMAL) {
94a79942 1716 priv->ResetProgress = RESET_TYPE_NORMAL;
1344ee25 1717 RT_TRACE(COMP_RESET, "%s(): NOMAL RESET\n", __func__);
94a79942
LF		 1718 return;
1719 }
1720
1344ee25
LF		 1721 if (((priv->force_reset) || (!priv->bDisableNormalResetCheck &&
1722 ResetType == RESET_TYPE_SILENT)))
94a79942 1723 rtl819x_ifsilentreset(dev);
94a79942
LF		 1724 priv->force_reset = false;
1725 priv->bForcedSilentReset = false;
1726 priv->bResetInProgress = false;
1727 RT_TRACE(COMP_TRACE, " <==RtUsbCheckForHangWorkItemCallback()\n");
1728}
1729
1730void watch_dog_timer_callback(unsigned long data)
1731{
1344ee25 1732 struct r8192_priv *priv = rtllib_priv((struct net_device *)data);
3a6b70c3 1733
1344ee25
LF		 1734 queue_delayed_work_rsl(priv->priv_wq, &priv->watch_dog_wq, 0);
1735 mod_timer(&priv->watch_dog_timer, jiffies +
8b9733c1 1736 msecs_to_jiffies(RTLLIB_WATCH_DOG_TIME));
94a79942
LF		 1737}
1738
1739/****************************************************************************
1740 ---------------------------- NIC TX/RX STUFF---------------------------
1741*****************************************************************************/
1742void rtl8192_rx_enable(struct net_device *dev)
1743{
1344ee25 1744 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
3a6b70c3 1745
94a79942
LF		 1746 priv->ops->rx_enable(dev);
1747}
1748
1749void rtl8192_tx_enable(struct net_device *dev)
1750{
1344ee25 1751 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
94a79942
LF		 1752
1753 priv->ops->tx_enable(dev);
1754
1344ee25 1755 rtllib_reset_queue(priv->rtllib);
94a79942
LF		 1756}
1757
1758
1759static void rtl8192_free_rx_ring(struct net_device *dev)
1760{
1344ee25
LF		 1761 struct r8192_priv *priv = rtllib_priv(dev);
1762 int i, rx_queue_idx;
94a79942 1763
1344ee25
LF		 1764 for (rx_queue_idx = 0; rx_queue_idx < MAX_RX_QUEUE;
1765 rx_queue_idx++) {
1766 for (i = 0; i < priv->rxringcount; i++) {
94a79942 1767 struct sk_buff *skb = priv->rx_buf[rx_queue_idx][i];
3a6b70c3 1768
1344ee25
LF		 1769 if (!skb)
1770 continue;
94a79942 1771
1344ee25
LF		 1772 pci_unmap_single(priv->pdev,
1773 *((dma_addr_t *)skb->cb),
1774 priv->rxbuffersize, PCI_DMA_FROMDEVICE);
1775 kfree_skb(skb);
1776 }
94a79942 1777
1344ee25
LF		 1778 pci_free_consistent(priv->pdev,
1779 sizeof(*priv->rx_ring[rx_queue_idx]) *
1780 priv->rxringcount,
1781 priv->rx_ring[rx_queue_idx],
1782 priv->rx_ring_dma[rx_queue_idx]);
94a79942
LF		 1783 priv->rx_ring[rx_queue_idx] = NULL;
1784 }
1785}
1786
1787static void rtl8192_free_tx_ring(struct net_device *dev, unsigned int prio)
1788{
1344ee25
LF		 1789 struct r8192_priv *priv = rtllib_priv(dev);
1790 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
94a79942 1791
1344ee25
LF		 1792 while (skb_queue_len(&ring->queue)) {
1793 struct tx_desc *entry = &ring->desc[ring->idx];
1794 struct sk_buff *skb = __skb_dequeue(&ring->queue);
94a79942 1795
466bc7f2 1796 pci_unmap_single(priv->pdev, entry->TxBuffAddr,
1344ee25
LF		 1797 skb->len, PCI_DMA_TODEVICE);
1798 kfree_skb(skb);
1799 ring->idx = (ring->idx + 1) % ring->entries;
1800 }
94a79942 1801
1344ee25
LF		 1802 pci_free_consistent(priv->pdev, sizeof(*ring->desc)*ring->entries,
1803 ring->desc, ring->dma);
1804 ring->desc = NULL;
94a79942
LF		 1805}
1806
1807void rtl8192_data_hard_stop(struct net_device *dev)
1808{
1809}
1810
1811
1812void rtl8192_data_hard_resume(struct net_device *dev)
1813{
1814}
1815
1344ee25
LF		 1816void rtl8192_hard_data_xmit(struct sk_buff *skb, struct net_device *dev,
1817 int rate)
94a79942
LF		 1818{
1819 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1820 int ret;
1344ee25
LF		 1821 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
1822 MAX_DEV_ADDR_SIZE);
94a79942
LF		 1823 u8 queue_index = tcb_desc->queue_index;
1824
5dc42962 1825 if ((priv->rtllib->eRFPowerState == eRfOff) || !priv->up ||
1344ee25 1826 priv->bResetInProgress) {
94a79942
LF		 1827 kfree_skb(skb);
1828 return;
1829 }
1830
ca93dcba
MK		 1831 if (queue_index != TXCMD_QUEUE)
1832 netdev_warn(dev, "%s(): queue index != TXCMD_QUEUE\n",
1833 __func__);
94a79942 1834
1344ee25 1835 memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
94a79942
LF		 1836 skb_push(skb, priv->rtllib->tx_headroom);
1837 ret = rtl8192_tx(dev, skb);
a22526e4 1838 if (ret != 0)
94a79942 1839 kfree_skb(skb);
94a79942 1840
1344ee25
LF		 1841 if (queue_index != MGNT_QUEUE) {
1842 priv->rtllib->stats.tx_bytes += (skb->len -
1843 priv->rtllib->tx_headroom);
94a79942
LF		 1844 priv->rtllib->stats.tx_packets++;
1845 }
94a79942
LF		 1846}
1847
1344ee25 1848int rtl8192_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
94a79942
LF		 1849{
1850 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
1851 int ret;
1344ee25
LF		 1852 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
1853 MAX_DEV_ADDR_SIZE);
94a79942
LF		 1854 u8 queue_index = tcb_desc->queue_index;
1855
1344ee25
LF		 1856 if (queue_index != TXCMD_QUEUE) {
1857 if ((priv->rtllib->eRFPowerState == eRfOff) ||
5dc42962 1858 !priv->up || priv->bResetInProgress) {
94a79942
LF		 1859 kfree_skb(skb);
1860 return 0;
1861 }
1862 }
1863
1344ee25 1864 memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
94a79942
LF		 1865 if (queue_index == TXCMD_QUEUE) {
1866 rtl8192_tx_cmd(dev, skb);
26e2fa76 1867 return 0;
94a79942
LF		 1868 }
1869
285b7c00
MK		 1870 tcb_desc->RATRIndex = 7;
1871 tcb_desc->bTxDisableRateFallBack = 1;
1872 tcb_desc->bTxUseDriverAssingedRate = 1;
1873 tcb_desc->bTxEnableFwCalcDur = 1;
1874 skb_push(skb, priv->rtllib->tx_headroom);
1875 ret = rtl8192_tx(dev, skb);
1876 if (ret != 0)
1877 kfree_skb(skb);
94a79942 1878 return ret;
94a79942
LF		 1879}
1880
49aab5fd 1881static void rtl8192_tx_isr(struct net_device *dev, int prio)
94a79942 1882{
1344ee25 1883 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
94a79942 1884
1344ee25 1885 struct rtl8192_tx_ring *ring = &priv->tx_ring[prio];
94a79942 1886
1344ee25
LF		 1887 while (skb_queue_len(&ring->queue)) {
1888 struct tx_desc *entry = &ring->desc[ring->idx];
1889 struct sk_buff *skb;
94a79942 1890
1344ee25
LF		 1891 if (prio != BEACON_QUEUE) {
1892 if (entry->OWN)
1893 return;
1894 ring->idx = (ring->idx + 1) % ring->entries;
1895 }
94a79942 1896
1344ee25 1897 skb = __skb_dequeue(&ring->queue);
466bc7f2 1898 pci_unmap_single(priv->pdev, entry->TxBuffAddr,
1344ee25 1899 skb->len, PCI_DMA_TODEVICE);
94a79942 1900
1344ee25
LF		 1901 kfree_skb(skb);
1902 }
1903 if (prio != BEACON_QUEUE)
1904 tasklet_schedule(&priv->irq_tx_tasklet);
94a79942
LF		 1905}
1906
1907void rtl8192_tx_cmd(struct net_device *dev, struct sk_buff *skb)
1908{
1344ee25
LF		 1909 struct r8192_priv *priv = rtllib_priv(dev);
1910 struct rtl8192_tx_ring *ring;
1911 struct tx_desc_cmd *entry;
1912 unsigned int idx;
1913 struct cb_desc *tcb_desc;
1914 unsigned long flags;
94a79942 1915
1344ee25
LF		 1916 spin_lock_irqsave(&priv->irq_th_lock, flags);
1917 ring = &priv->tx_ring[TXCMD_QUEUE];
94a79942 1918
1344ee25
LF		 1919 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1920 entry = (struct tx_desc_cmd *) &ring->desc[idx];
94a79942 1921
1344ee25 1922 tcb_desc = (struct cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
94a79942 1923
1344ee25 1924 priv->ops->tx_fill_cmd_descriptor(dev, entry, tcb_desc, skb);
94a79942 1925
1344ee25
LF		 1926 __skb_queue_tail(&ring->queue, skb);
1927 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
94a79942
LF		 1928}
1929
1344ee25 1930short rtl8192_tx(struct net_device *dev, struct sk_buff *skb)
94a79942
LF		 1931{
1932 struct r8192_priv *priv = rtllib_priv(dev);
1933 struct rtl8192_tx_ring *ring;
1934 unsigned long flags;
1344ee25
LF		 1935 struct cb_desc *tcb_desc = (struct cb_desc *)(skb->cb +
1936 MAX_DEV_ADDR_SIZE);
bc27e89b 1937 struct tx_desc *pdesc = NULL;
1344ee25
LF		 1938 struct rtllib_hdr_1addr *header = NULL;
1939 u16 fc = 0, type = 0, stype = 0;
1940 bool multi_addr = false, broad_addr = false, uni_addr = false;
1941 u8 *pda_addr = NULL;
94a79942
LF		 1942 int idx;
1943 u32 fwinfo_size = 0;
1944
1344ee25 1945 if (priv->bdisable_nic) {
3b4140af
MK		 1946 netdev_warn(dev, "%s: Nic is disabled! Can't tx packet.\n",
1947 __func__);
1344ee25 1948 return skb->len;
94a79942
LF		 1949 }
1950
1951 priv->rtllib->bAwakePktSent = true;
1952
a07dc3d1 1953 fwinfo_size = sizeof(struct tx_fwinfo_8190pci);
94a79942 1954
1344ee25 1955 header = (struct rtllib_hdr_1addr *)(((u8 *)skb->data) + fwinfo_size);
34e987e6 1956 fc = le16_to_cpu(header->frame_ctl);
94a79942
LF		 1957 type = WLAN_FC_GET_TYPE(fc);
1958 stype = WLAN_FC_GET_STYPE(fc);
1959 pda_addr = header->addr1;
1960
14fc4235 1961 if (is_broadcast_ether_addr(pda_addr))
94a79942 1962 broad_addr = true;
14fc4235
JP		 1963 else if (is_multicast_ether_addr(pda_addr))
1964 multi_addr = true;
1344ee25 1965 else
94a79942 1966 uni_addr = true;
94a79942
LF		 1967
1968 if (uni_addr)
1969 priv->stats.txbytesunicast += skb->len - fwinfo_size;
1970 else if (multi_addr)
1971 priv->stats.txbytesmulticast += skb->len - fwinfo_size;
1972 else
1973 priv->stats.txbytesbroadcast += skb->len - fwinfo_size;
1974
1344ee25 1975 spin_lock_irqsave(&priv->irq_th_lock, flags);
94a79942 1976 ring = &priv->tx_ring[tcb_desc->queue_index];
1344ee25 1977 if (tcb_desc->queue_index != BEACON_QUEUE)
94a79942 1978 idx = (ring->idx + skb_queue_len(&ring->queue)) % ring->entries;
1344ee25 1979 else
94a79942 1980 idx = 0;
94a79942
LF		 1981
1982 pdesc = &ring->desc[idx];
1983 if ((pdesc->OWN == 1) && (tcb_desc->queue_index != BEACON_QUEUE)) {
3b4140af
MK		 1984 netdev_warn(dev,
1985 "No more TX desc@%d, ring->idx = %d, idx = %d, skblen = 0x%x queuelen=%d",
1986 tcb_desc->queue_index, ring->idx, idx, skb->len,
1987 skb_queue_len(&ring->queue));
1344ee25 1988 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
94a79942
LF		 1989 return skb->len;
1990 }
1991
1344ee25 1992 if (type == RTLLIB_FTYPE_DATA) {
94a79942
LF		 1993 if (priv->rtllib->LedControlHandler)
1994 priv->rtllib->LedControlHandler(dev, LED_CTL_TX);
1995 }
1996 priv->ops->tx_fill_descriptor(dev, pdesc, tcb_desc, skb);
1997 __skb_queue_tail(&ring->queue, skb);
1998 pdesc->OWN = 1;
1344ee25 1999 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
94a79942
LF		 2000 dev->trans_start = jiffies;
2001
1344ee25 2002 write_nic_word(dev, TPPoll, 0x01 << tcb_desc->queue_index);
94a79942
LF		 2003 return 0;
2004}
2005
49aab5fd 2006static short rtl8192_alloc_rx_desc_ring(struct net_device *dev)
94a79942
LF		 2007{
2008 struct r8192_priv *priv = rtllib_priv(dev);
4f534b36 2009 struct rx_desc *entry = NULL;
94a79942
LF		 2010 int i, rx_queue_idx;
2011
1344ee25 2012 for (rx_queue_idx = 0; rx_queue_idx < MAX_RX_QUEUE; rx_queue_idx++) {
35e33b04 2013 priv->rx_ring[rx_queue_idx] = pci_zalloc_consistent(priv->pdev,
8b983be5
JP		 2014 sizeof(*priv->rx_ring[rx_queue_idx]) * priv->rxringcount,
2015 &priv->rx_ring_dma[rx_queue_idx]);
1344ee25
LF		 2016 if (!priv->rx_ring[rx_queue_idx] ||
2017 (unsigned long)priv->rx_ring[rx_queue_idx] & 0xFF) {
3b4140af 2018 netdev_warn(dev, "Cannot allocate RX ring\n");
94a79942
LF		 2019 return -ENOMEM;
2020 }
2021
94a79942
LF		 2022 priv->rx_idx[rx_queue_idx] = 0;
2023
2024 for (i = 0; i < priv->rxringcount; i++) {
2025 struct sk_buff *skb = dev_alloc_skb(priv->rxbuffersize);
2026 dma_addr_t *mapping;
3a6b70c3 2027
94a79942
LF		 2028 entry = &priv->rx_ring[rx_queue_idx][i];
2029 if (!skb)
2030 return 0;
2031 skb->dev = dev;
2032 priv->rx_buf[rx_queue_idx][i] = skb;
2033 mapping = (dma_addr_t *)skb->cb;
1344ee25
LF		 2034 *mapping = pci_map_single(priv->pdev,
2035 skb_tail_pointer_rsl(skb),
2036 priv->rxbuffersize,
2037 PCI_DMA_FROMDEVICE);
2dcb4a29
LF		 2038 if (pci_dma_mapping_error(priv->pdev, *mapping)) {
2039 dev_kfree_skb_any(skb);
2040 return -1;
2041 }
34e987e6 2042 entry->BufferAddress = *mapping;
94a79942
LF		 2043
2044 entry->Length = priv->rxbuffersize;
2045 entry->OWN = 1;
2046 }
2047
f6692285 2048 if (entry)
35f8673d 2049 entry->EOR = 1;
94a79942
LF		 2050 }
2051 return 0;
2052}
2053
2054static int rtl8192_alloc_tx_desc_ring(struct net_device *dev,
1344ee25 2055 unsigned int prio, unsigned int entries)
94a79942 2056{
1344ee25
LF		 2057 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2058 struct tx_desc *ring;
2059 dma_addr_t dma;
2060 int i;
94a79942 2061
8b983be5 2062 ring = pci_zalloc_consistent(priv->pdev, sizeof(*ring) * entries, &dma);
1344ee25 2063 if (!ring || (unsigned long)ring & 0xFF) {
3b4140af 2064 netdev_warn(dev, "Cannot allocate TX ring (prio = %d)\n", prio);
1344ee25
LF		 2065 return -ENOMEM;
2066 }
94a79942 2067
1344ee25
LF		 2068 priv->tx_ring[prio].desc = ring;
2069 priv->tx_ring[prio].dma = dma;
2070 priv->tx_ring[prio].idx = 0;
2071 priv->tx_ring[prio].entries = entries;
2072 skb_queue_head_init(&priv->tx_ring[prio].queue);
94a79942 2073
1344ee25
LF		 2074 for (i = 0; i < entries; i++)
2075 ring[i].NextDescAddress =
34e987e6
RK		 2076 (u32)dma + ((i + 1) % entries) *
2077 sizeof(*ring);
94a79942 2078
1344ee25 2079 return 0;
94a79942
LF		 2080}
2081
2082
2083short rtl8192_pci_initdescring(struct net_device *dev)
2084{
1344ee25
LF		 2085 u32 ret;
2086 int i;
2087 struct r8192_priv *priv = rtllib_priv(dev);
94a79942 2088
1344ee25
LF		 2089 ret = rtl8192_alloc_rx_desc_ring(dev);
2090 if (ret)
2091 return ret;
94a79942 2092
1344ee25
LF		 2093 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
2094 ret = rtl8192_alloc_tx_desc_ring(dev, i, priv->txringcount);
2095 if (ret)
2096 goto err_free_rings;
2097 }
94a79942 2098
1344ee25 2099 return 0;
94a79942
LF		 2100
2101err_free_rings:
1344ee25
LF		 2102 rtl8192_free_rx_ring(dev);
2103 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
2104 if (priv->tx_ring[i].desc)
2105 rtl8192_free_tx_ring(dev, i);
2106 return 1;
94a79942
LF		 2107}
2108
2109void rtl8192_pci_resetdescring(struct net_device *dev)
2110{
1344ee25
LF		 2111 struct r8192_priv *priv = rtllib_priv(dev);
2112 int i, rx_queue_idx;
2113 unsigned long flags = 0;
94a79942 2114
1344ee25 2115 for (rx_queue_idx = 0; rx_queue_idx < MAX_RX_QUEUE; rx_queue_idx++) {
94a79942 2116 if (priv->rx_ring[rx_queue_idx]) {
4f534b36 2117 struct rx_desc *entry = NULL;
3a6b70c3 2118
94a79942
LF		 2119 for (i = 0; i < priv->rxringcount; i++) {
2120 entry = &priv->rx_ring[rx_queue_idx][i];
2121 entry->OWN = 1;
2122 }
2123 priv->rx_idx[rx_queue_idx] = 0;
2124 }
2125 }
2126
1344ee25
LF		 2127 spin_lock_irqsave(&priv->irq_th_lock, flags);
2128 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++) {
2129 if (priv->tx_ring[i].desc) {
2130 struct rtl8192_tx_ring *ring = &priv->tx_ring[i];
94a79942 2131
1344ee25
LF		 2132 while (skb_queue_len(&ring->queue)) {
2133 struct tx_desc *entry = &ring->desc[ring->idx];
2134 struct sk_buff *skb =
2135 __skb_dequeue(&ring->queue);
94a79942 2136
1344ee25 2137 pci_unmap_single(priv->pdev,
466bc7f2 2138 entry->TxBuffAddr,
1344ee25
LF		 2139 skb->len, PCI_DMA_TODEVICE);
2140 kfree_skb(skb);
2141 ring->idx = (ring->idx + 1) % ring->entries;
2142 }
2143 ring->idx = 0;
2144 }
2145 }
2146 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
94a79942
LF		 2147}
2148
1344ee25
LF		 2149void rtl819x_UpdateRxPktTimeStamp(struct net_device *dev,
2150 struct rtllib_rx_stats *stats)
94a79942
LF		 2151{
2152 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2153
0dd56506
LF		 2154 if (stats->bIsAMPDU && !stats->bFirstMPDU)
2155 stats->mac_time = priv->LastRxDescTSF;
2156 else
2157 priv->LastRxDescTSF = stats->mac_time;
94a79942
LF		 2158}
2159
1344ee25 2160long rtl819x_translate_todbm(struct r8192_priv *priv, u8 signal_strength_index)
94a79942
LF		 2161{
2162 long signal_power;
2163
2164 signal_power = (long)((signal_strength_index + 1) >> 1);
2165 signal_power -= 95;
2166
2167 return signal_power;
2168}
2169
2170
2171void
2172rtl819x_update_rxsignalstatistics8190pci(
1344ee25
LF		 2173 struct r8192_priv *priv,
2174 struct rtllib_rx_stats *pprevious_stats
94a79942
LF		 2175 )
2176{
2177 int weighting = 0;
2178
2179
2180 if (priv->stats.recv_signal_power == 0)
1344ee25
LF		 2181 priv->stats.recv_signal_power =
2182 pprevious_stats->RecvSignalPower;
94a79942
LF		 2183
2184 if (pprevious_stats->RecvSignalPower > priv->stats.recv_signal_power)
2185 weighting = 5;
1344ee25
LF		 2186 else if (pprevious_stats->RecvSignalPower <
2187 priv->stats.recv_signal_power)
94a79942 2188 weighting = (-5);
1344ee25
LF		 2189 priv->stats.recv_signal_power = (priv->stats.recv_signal_power * 5 +
2190 pprevious_stats->RecvSignalPower +
2191 weighting) / 6;
94a79942
LF		 2192}
2193
1344ee25
LF		 2194void rtl819x_process_cck_rxpathsel(struct r8192_priv *priv,
2195 struct rtllib_rx_stats *pprevious_stats)
94a79942 2196{
94a79942
LF		 2197}
2198
2199
1344ee25 2200u8 rtl819x_query_rxpwrpercentage(char antpower)
94a79942
LF		 2201{
2202 if ((antpower <= -100) || (antpower >= 20))
94a79942 2203 return 0;
94a79942 2204 else if (antpower >= 0)
94a79942 2205 return 100;
94a79942 2206 else
1344ee25 2207 return 100 + antpower;
94a79942
LF		 2208
2209} /* QueryRxPwrPercentage */
2210
2211u8
2212rtl819x_evm_dbtopercentage(
2213 char value
2214 )
2215{
2216 char ret_val;
2217
2218 ret_val = value;
2219
2220 if (ret_val >= 0)
2221 ret_val = 0;
2222 if (ret_val <= -33)
2223 ret_val = -33;
2224 ret_val = 0 - ret_val;
1344ee25 2225 ret_val *= 3;
94a79942
LF		 2226 if (ret_val == 99)
2227 ret_val = 100;
1344ee25 2228 return ret_val;
94a79942
LF		 2229}
2230
2231void
2232rtl8192_record_rxdesc_forlateruse(
1344ee25
LF		 2233 struct rtllib_rx_stats *psrc_stats,
2234 struct rtllib_rx_stats *ptarget_stats
94a79942
LF		 2235)
2236{
2237 ptarget_stats->bIsAMPDU = psrc_stats->bIsAMPDU;
2238 ptarget_stats->bFirstMPDU = psrc_stats->bFirstMPDU;
2239}
2240
2241
2242
49aab5fd 2243static void rtl8192_rx_normal(struct net_device *dev)
94a79942
LF		 2244{
2245 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2246 struct rtllib_hdr_1addr *rtllib_hdr = NULL;
2247 bool unicast_packet = false;
1344ee25
LF		 2248 bool bLedBlinking = true;
2249 u16 fc = 0, type = 0;
94a79942
LF		 2250 u32 skb_len = 0;
2251 int rx_queue_idx = RX_MPDU_QUEUE;
2252
2253 struct rtllib_rx_stats stats = {
2254 .signal = 0,
94e057d7 2255 .noise = (u8) -98,
94a79942
LF		 2256 .rate = 0,
2257 .freq = RTLLIB_24GHZ_BAND,
2258 };
2259 unsigned int count = priv->rxringcount;
2260
2261 stats.nic_type = NIC_8192E;
2262
2263 while (count--) {
1344ee25
LF		 2264 struct rx_desc *pdesc = &priv->rx_ring[rx_queue_idx]
2265 [priv->rx_idx[rx_queue_idx]];
2266 struct sk_buff *skb = priv->rx_buf[rx_queue_idx]
2267 [priv->rx_idx[rx_queue_idx]];
285b7c00 2268 struct sk_buff *new_skb;
94a79942 2269
285b7c00 2270 if (pdesc->OWN)
94a79942 2271 return;
285b7c00
MK		 2272 if (!priv->ops->rx_query_status_descriptor(dev, &stats,
2273 pdesc, skb))
2274 goto done;
2275 new_skb = dev_alloc_skb(priv->rxbuffersize);
2276 /* if allocation of new skb failed - drop current packet
14b40d92
MK		 2277 * and reuse skb
2278 */
285b7c00
MK		 2279 if (unlikely(!new_skb))
2280 goto done;
2281
2282 pci_unmap_single(priv->pdev,
2283 *((dma_addr_t *)skb->cb),
2284 priv->rxbuffersize,
2285 PCI_DMA_FROMDEVICE);
2286
2287 skb_put(skb, pdesc->Length);
2288 skb_reserve(skb, stats.RxDrvInfoSize +
2289 stats.RxBufShift);
2290 skb_trim(skb, skb->len - 4/*sCrcLng*/);
2291 rtllib_hdr = (struct rtllib_hdr_1addr *)skb->data;
2292 if (!is_multicast_ether_addr(rtllib_hdr->addr1)) {
2293 /* unicast packet */
2294 unicast_packet = true;
2295 }
2296 fc = le16_to_cpu(rtllib_hdr->frame_ctl);
2297 type = WLAN_FC_GET_TYPE(fc);
2298 if (type == RTLLIB_FTYPE_MGMT)
2299 bLedBlinking = false;
2300
2301 if (bLedBlinking)
2302 if (priv->rtllib->LedControlHandler)
2303 priv->rtllib->LedControlHandler(dev,
2304 LED_CTL_RX);
2305
2306 if (stats.bCRC) {
2307 if (type != RTLLIB_FTYPE_MGMT)
2308 priv->stats.rxdatacrcerr++;
2309 else
2310 priv->stats.rxmgmtcrcerr++;
2311 }
94a79942 2312
285b7c00 2313 skb_len = skb->len;
4f6807e8 2314
285b7c00
MK		 2315 if (!rtllib_rx(priv->rtllib, skb, &stats)) {
2316 dev_kfree_skb_any(skb);
2317 } else {
2318 priv->stats.rxok++;
2319 if (unicast_packet)
2320 priv->stats.rxbytesunicast += skb_len;
2321 }
4f6807e8 2322
285b7c00
MK		 2323 skb = new_skb;
2324 skb->dev = dev;
2325
2326 priv->rx_buf[rx_queue_idx][priv->rx_idx[rx_queue_idx]] =
2327 skb;
2328 *((dma_addr_t *) skb->cb) = pci_map_single(priv->pdev,
2329 skb_tail_pointer_rsl(skb),
2330 priv->rxbuffersize,
2331 PCI_DMA_FROMDEVICE);
2332 if (pci_dma_mapping_error(priv->pdev,
2333 *((dma_addr_t *)skb->cb))) {
2334 dev_kfree_skb_any(skb);
2335 return;
94a79942
LF		 2336 }
2337done:
34e987e6 2338 pdesc->BufferAddress = *((dma_addr_t *)skb->cb);
94a79942
LF		 2339 pdesc->OWN = 1;
2340 pdesc->Length = priv->rxbuffersize;
2341 if (priv->rx_idx[rx_queue_idx] == priv->rxringcount-1)
2342 pdesc->EOR = 1;
1344ee25
LF		 2343 priv->rx_idx[rx_queue_idx] = (priv->rx_idx[rx_queue_idx] + 1) %
2344 priv->rxringcount;
94a79942
LF		 2345 }
2346
2347}
2348
49aab5fd 2349static void rtl8192_rx_cmd(struct net_device *dev)
94a79942 2350{
94a79942
LF		 2351}
2352
2353
49aab5fd 2354static void rtl8192_tx_resume(struct net_device *dev)
94a79942
LF		 2355{
2356 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2357 struct rtllib_device *ieee = priv->rtllib;
2358 struct sk_buff *skb;
2359 int queue_index;
2360
1344ee25
LF		 2361 for (queue_index = BK_QUEUE;
2362 queue_index < MAX_QUEUE_SIZE; queue_index++) {
2363 while ((!skb_queue_empty(&ieee->skb_waitQ[queue_index])) &&
2364 (priv->rtllib->check_nic_enough_desc(dev, queue_index) > 0)) {
94a79942 2365 skb = skb_dequeue(&ieee->skb_waitQ[queue_index]);
1344ee25 2366 ieee->softmac_data_hard_start_xmit(skb, dev, 0);
94a79942
LF		 2367 }
2368 }
2369}
2370
2371void rtl8192_irq_tx_tasklet(struct r8192_priv *priv)
2372{
1344ee25 2373 rtl8192_tx_resume(priv->rtllib->dev);
94a79942
LF		 2374}
2375
2376void rtl8192_irq_rx_tasklet(struct r8192_priv *priv)
2377{
2378 rtl8192_rx_normal(priv->rtllib->dev);
2379
2380 if (MAX_RX_QUEUE > 1)
2381 rtl8192_rx_cmd(priv->rtllib->dev);
2382
1344ee25
LF		 2383 write_nic_dword(priv->rtllib->dev, INTA_MASK,
2384 read_nic_dword(priv->rtllib->dev, INTA_MASK) | IMR_RDU);
94a79942
LF		 2385}
2386
2387/****************************************************************************
2388 ---------------------------- NIC START/CLOSE STUFF---------------------------
2389*****************************************************************************/
1344ee25 2390void rtl8192_cancel_deferred_work(struct r8192_priv *priv)
94a79942 2391{
94a79942
LF		 2392 cancel_delayed_work(&priv->watch_dog_wq);
2393 cancel_delayed_work(&priv->update_beacon_wq);
94a79942 2394 cancel_delayed_work(&priv->rtllib->hw_sleep_wq);
94a79942
LF		 2395 cancel_work_sync(&priv->reset_wq);
2396 cancel_work_sync(&priv->qos_activate);
94a79942
LF		 2397}
2398
1344ee25 2399int _rtl8192_up(struct net_device *dev, bool is_silent_reset)
94a79942
LF		 2400{
2401 if (_rtl8192_sta_up(dev, is_silent_reset) == -1)
2402 return -1;
2403 return 0;
2404}
2405
2406
49aab5fd 2407static int rtl8192_open(struct net_device *dev)
94a79942
LF		 2408{
2409 struct r8192_priv *priv = rtllib_priv(dev);
2410 int ret;
2411
2412 down(&priv->wx_sem);
2413 ret = rtl8192_up(dev);
2414 up(&priv->wx_sem);
2415 return ret;
2416
2417}
2418
2419
2420int rtl8192_up(struct net_device *dev)
2421{
2422 struct r8192_priv *priv = rtllib_priv(dev);
2423
1344ee25
LF		 2424 if (priv->up == 1)
2425 return -1;
2426 return _rtl8192_up(dev, false);
94a79942
LF		 2427}
2428
2429
49aab5fd 2430static int rtl8192_close(struct net_device *dev)
94a79942
LF		 2431{
2432 struct r8192_priv *priv = rtllib_priv(dev);
2433 int ret;
2434
2435 if ((rtllib_act_scanning(priv->rtllib, false)) &&
1344ee25 2436 !(priv->rtllib->softmac_features & IEEE_SOFTMAC_SCAN)) {
94a79942
LF		 2437 rtllib_stop_scan(priv->rtllib);
2438 }
2439
2440 down(&priv->wx_sem);
2441
1344ee25 2442 ret = rtl8192_down(dev, true);
94a79942
LF		 2443
2444 up(&priv->wx_sem);
2445
2446 return ret;
2447
2448}
2449
2450int rtl8192_down(struct net_device *dev, bool shutdownrf)
2451{
94a79942
LF		 2452 if (rtl8192_sta_down(dev, shutdownrf) == -1)
2453 return -1;
2454
94a79942
LF		 2455 return 0;
2456}
2457
2458void rtl8192_commit(struct net_device *dev)
2459{
2460 struct r8192_priv *priv = rtllib_priv(dev);
2461
1344ee25
LF		 2462 if (priv->up == 0)
2463 return;
f6692285 2464 rtllib_softmac_stop_protocol(priv->rtllib, 0, true);
94a79942
LF		 2465 rtl8192_irq_disable(dev);
2466 priv->ops->stop_adapter(dev, true);
1344ee25 2467 _rtl8192_up(dev, false);
94a79942
LF		 2468}
2469
2470void rtl8192_restart(void *data)
2471{
1344ee25
LF		 2472 struct r8192_priv *priv = container_of_work_rsl(data, struct r8192_priv,
2473 reset_wq);
94a79942 2474 struct net_device *dev = priv->rtllib->dev;
94a79942
LF		 2475
2476 down(&priv->wx_sem);
2477
2478 rtl8192_commit(dev);
2479
2480 up(&priv->wx_sem);
2481}
2482
2483static void r8192_set_multicast(struct net_device *dev)
2484{
2485 struct r8192_priv *priv = rtllib_priv(dev);
2486 short promisc;
2487
1344ee25 2488 promisc = (dev->flags & IFF_PROMISC) ? 1 : 0;
94a79942
LF		 2489 priv->promisc = promisc;
2490
2491}
2492
2493
49aab5fd 2494static int r8192_set_mac_adr(struct net_device *dev, void *mac)
94a79942
LF		 2495{
2496 struct r8192_priv *priv = rtllib_priv(dev);
2497 struct sockaddr *addr = mac;
2498
2499 down(&priv->wx_sem);
2500
1f3aefb5 2501 ether_addr_copy(dev->dev_addr, addr->sa_data);
94a79942 2502
94a79942 2503 schedule_work(&priv->reset_wq);
94a79942
LF		 2504 up(&priv->wx_sem);
2505
2506 return 0;
2507}
2508
2509/* based on ipw2200 driver */
49aab5fd 2510static int rtl8192_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
94a79942
LF		 2511{
2512 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2513 struct iwreq *wrq = (struct iwreq *)rq;
1344ee25 2514 int ret = -1;
94a79942
LF		 2515 struct rtllib_device *ieee = priv->rtllib;
2516 u32 key[4];
06c11107 2517 const u8 broadcast_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
94a79942 2518 struct iw_point *p = &wrq->u.data;
1344ee25 2519 struct ieee_param *ipw = NULL;
94a79942
LF		 2520
2521 down(&priv->wx_sem);
2522
2523 switch (cmd) {
1344ee25
LF		 2524 case RTL_IOCTL_WPA_SUPPLICANT:
2525 if (p->length < sizeof(struct ieee_param) || !p->pointer) {
2526 ret = -EINVAL;
2527 goto out;
2528 }
94a79942 2529
21624981
TB		 2530 ipw = memdup_user(p->pointer, p->length);
2531 if (IS_ERR(ipw)) {
2532 ret = PTR_ERR(ipw);
1344ee25
LF		 2533 goto out;
2534 }
94a79942 2535
1344ee25
LF		 2536 if (ipw->cmd == IEEE_CMD_SET_ENCRYPTION) {
2537 if (ipw->u.crypt.set_tx) {
2538 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
2539 ieee->pairwise_key_type = KEY_TYPE_CCMP;
2540 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
2541 ieee->pairwise_key_type = KEY_TYPE_TKIP;
2542 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
2543 if (ipw->u.crypt.key_len == 13)
2544 ieee->pairwise_key_type =
2545 KEY_TYPE_WEP104;
2546 else if (ipw->u.crypt.key_len == 5)
2547 ieee->pairwise_key_type =
2548 KEY_TYPE_WEP40;
2549 } else {
2550 ieee->pairwise_key_type = KEY_TYPE_NA;
94a79942 2551 }
1344ee25
LF		 2552
2553 if (ieee->pairwise_key_type) {
06c11107 2554 if (is_zero_ether_addr(ieee->ap_mac_addr))
1344ee25
LF		 2555 ieee->iw_mode = IW_MODE_ADHOC;
2556 memcpy((u8 *)key, ipw->u.crypt.key, 16);
2557 EnableHWSecurityConfig8192(dev);
2558 set_swcam(dev, 4, ipw->u.crypt.idx,
2559 ieee->pairwise_key_type,
2560 (u8 *)ieee->ap_mac_addr,
2561 0, key, 0);
2562 setKey(dev, 4, ipw->u.crypt.idx,
2563 ieee->pairwise_key_type,
2564 (u8 *)ieee->ap_mac_addr, 0, key);
2565 if (ieee->iw_mode == IW_MODE_ADHOC) {
2566 set_swcam(dev, ipw->u.crypt.idx,
2567 ipw->u.crypt.idx,
2568 ieee->pairwise_key_type,
2569 (u8 *)ieee->ap_mac_addr,
2570 0, key, 0);
2571 setKey(dev, ipw->u.crypt.idx,
2572 ipw->u.crypt.idx,
2573 ieee->pairwise_key_type,
2574 (u8 *)ieee->ap_mac_addr,
2575 0, key);
94a79942
LF		 2576 }
2577 }
1344ee25
LF		 2578 if ((ieee->pairwise_key_type == KEY_TYPE_CCMP)
2579 && ieee->pHTInfo->bCurrentHTSupport) {
2580 write_nic_byte(dev, 0x173, 1);
2581 }
22466983 2582
1344ee25
LF		 2583 } else {
2584 memcpy((u8 *)key, ipw->u.crypt.key, 16);
2585 if (strcmp(ipw->u.crypt.alg, "CCMP") == 0)
2586 ieee->group_key_type = KEY_TYPE_CCMP;
2587 else if (strcmp(ipw->u.crypt.alg, "TKIP") == 0)
2588 ieee->group_key_type = KEY_TYPE_TKIP;
2589 else if (strcmp(ipw->u.crypt.alg, "WEP") == 0) {
2590 if (ipw->u.crypt.key_len == 13)
2591 ieee->group_key_type =
2592 KEY_TYPE_WEP104;
2593 else if (ipw->u.crypt.key_len == 5)
2594 ieee->group_key_type =
2595 KEY_TYPE_WEP40;
2596 } else
2597 ieee->group_key_type = KEY_TYPE_NA;
2598
2599 if (ieee->group_key_type) {
2600 set_swcam(dev, ipw->u.crypt.idx,
2601 ipw->u.crypt.idx,
2602 ieee->group_key_type,
2603 broadcast_addr, 0, key, 0);
2604 setKey(dev, ipw->u.crypt.idx,
2605 ipw->u.crypt.idx,
2606 ieee->group_key_type,
2607 broadcast_addr, 0, key);
2608 }
2609 }
94a79942 2610 }
1344ee25
LF		 2611
2612 ret = rtllib_wpa_supplicant_ioctl(priv->rtllib, &wrq->u.data,
2613 0);
2614 kfree(ipw);
2615 break;
2616 default:
2617 ret = -EOPNOTSUPP;
2618 break;
94a79942
LF		 2619 }
2620
2621out:
2622 up(&priv->wx_sem);
2623
2624 return ret;
2625}
2626
94a79942 2627
fa63c9ce 2628static irqreturn_t rtl8192_interrupt(int irq, void *netdev)
94a79942
LF		 2629{
2630 struct net_device *dev = (struct net_device *) netdev;
2631 struct r8192_priv *priv = (struct r8192_priv *)rtllib_priv(dev);
2632 unsigned long flags;
2633 u32 inta;
2634 u32 intb;
3a6b70c3 2635
94a79942
LF		 2636 intb = 0;
2637
1344ee25 2638 if (priv->irq_enabled == 0)
94a79942 2639 goto done;
94a79942 2640
1344ee25 2641 spin_lock_irqsave(&priv->irq_th_lock, flags);
94a79942
LF		 2642
2643 priv->ops->interrupt_recognized(dev, &inta, &intb);
2644 priv->stats.shints++;
2645
2646 if (!inta) {
1344ee25 2647 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
94a79942
LF		 2648 goto done;
2649 }
2650
2651 if (inta == 0xffff) {
1344ee25 2652 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
94a79942
LF		 2653 goto done;
2654 }
2655
2656 priv->stats.ints++;
2657
2658 if (!netif_running(dev)) {
1344ee25 2659 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
94a79942
LF		 2660 goto done;
2661 }
2662
1344ee25 2663 if (inta & IMR_TBDOK) {
94a79942
LF		 2664 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
2665 priv->stats.txbeaconokint++;
2666 }
2667
1344ee25 2668 if (inta & IMR_TBDER) {
94a79942
LF		 2669 RT_TRACE(COMP_INTR, "beacon ok interrupt!\n");
2670 priv->stats.txbeaconerr++;
2671 }
94a79942 2672
1344ee25 2673 if (inta & IMR_BDOK)
94a79942 2674 RT_TRACE(COMP_INTR, "beacon interrupt!\n");
94a79942 2675
1344ee25 2676 if (inta & IMR_MGNTDOK) {
94a79942
LF		 2677 RT_TRACE(COMP_INTR, "Manage ok interrupt!\n");
2678 priv->stats.txmanageokint++;
1344ee25
LF		 2679 rtl8192_tx_isr(dev, MGNT_QUEUE);
2680 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
2681 if (priv->rtllib->ack_tx_to_ieee) {
2682 if (rtl8192_is_tx_queue_empty(dev)) {
94a79942
LF		 2683 priv->rtllib->ack_tx_to_ieee = 0;
2684 rtllib_ps_tx_ack(priv->rtllib, 1);
2685 }
2686 }
1344ee25 2687 spin_lock_irqsave(&priv->irq_th_lock, flags);
94a79942
LF		 2688 }
2689
94a79942
LF		 2690 if (inta & IMR_COMDOK) {
2691 priv->stats.txcmdpktokint++;
1344ee25 2692 rtl8192_tx_isr(dev, TXCMD_QUEUE);
94a79942 2693 }
94a79942 2694
1344ee25
LF		 2695 if (inta & IMR_HIGHDOK)
2696 rtl8192_tx_isr(dev, HIGH_QUEUE);
94a79942 2697
1344ee25 2698 if (inta & IMR_ROK) {
94a79942
LF		 2699 priv->stats.rxint++;
2700 priv->InterruptLog.nIMR_ROK++;
2701 tasklet_schedule(&priv->irq_rx_tasklet);
2702 }
2703
2704 if (inta & IMR_BcnInt) {
2705 RT_TRACE(COMP_INTR, "prepare beacon for interrupt!\n");
94a79942 2706 tasklet_schedule(&priv->irq_prepare_beacon_tasklet);
94a79942
LF		 2707 }
2708
2709 if (inta & IMR_RDU) {
2710 RT_TRACE(COMP_INTR, "rx descriptor unavailable!\n");
2711 priv->stats.rxrdu++;
1344ee25
LF		 2712 write_nic_dword(dev, INTA_MASK,
2713 read_nic_dword(dev, INTA_MASK) & ~IMR_RDU);
94a79942
LF		 2714 tasklet_schedule(&priv->irq_rx_tasklet);
2715 }
2716
2717 if (inta & IMR_RXFOVW) {
2718 RT_TRACE(COMP_INTR, "rx overflow !\n");
2719 priv->stats.rxoverflow++;
2720 tasklet_schedule(&priv->irq_rx_tasklet);
2721 }
2722
1344ee25
LF		 2723 if (inta & IMR_TXFOVW)
2724 priv->stats.txoverflow++;
94a79942
LF		 2725
2726 if (inta & IMR_BKDOK) {
2727 RT_TRACE(COMP_INTR, "BK Tx OK interrupt!\n");
2728 priv->stats.txbkokint++;
2729 priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;
1344ee25 2730 rtl8192_tx_isr(dev, BK_QUEUE);
94a79942
LF		 2731 }
2732
2733 if (inta & IMR_BEDOK) {
2734 RT_TRACE(COMP_INTR, "BE TX OK interrupt!\n");
2735 priv->stats.txbeokint++;
2736 priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;
1344ee25 2737 rtl8192_tx_isr(dev, BE_QUEUE);
94a79942
LF		 2738 }
2739
2740 if (inta & IMR_VIDOK) {
2741 RT_TRACE(COMP_INTR, "VI TX OK interrupt!\n");
2742 priv->stats.txviokint++;
2743 priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;
1344ee25 2744 rtl8192_tx_isr(dev, VI_QUEUE);
94a79942
LF		 2745 }
2746
2747 if (inta & IMR_VODOK) {
2748 priv->stats.txvookint++;
2749 RT_TRACE(COMP_INTR, "Vo TX OK interrupt!\n");
2750 priv->rtllib->LinkDetectInfo.NumTxOkInPeriod++;
1344ee25 2751 rtl8192_tx_isr(dev, VO_QUEUE);
94a79942
LF		 2752 }
2753
1344ee25 2754 spin_unlock_irqrestore(&priv->irq_th_lock, flags);
94a79942
LF		 2755
2756done:
2757
94a79942 2758 return IRQ_HANDLED;
94a79942
LF		 2759}
2760
2761
2762
2763/****************************************************************************
1344ee25 2764 ---------------------------- PCI_STUFF---------------------------
94a79942 2765*****************************************************************************/
94a79942
LF		 2766static const struct net_device_ops rtl8192_netdev_ops = {
2767 .ndo_open = rtl8192_open,
2768 .ndo_stop = rtl8192_close,
2769 .ndo_tx_timeout = rtl8192_tx_timeout,
2770 .ndo_do_ioctl = rtl8192_ioctl,
faae60d2 2771 .ndo_set_rx_mode = r8192_set_multicast,
94a79942
LF		 2772 .ndo_set_mac_address = r8192_set_mac_adr,
2773 .ndo_validate_addr = eth_validate_addr,
2774 .ndo_change_mtu = eth_change_mtu,
2775 .ndo_start_xmit = rtllib_xmit,
2776};
94a79942 2777
c506fff1 2778static int rtl8192_pci_probe(struct pci_dev *pdev,
1344ee25 2779 const struct pci_device_id *id)
94a79942
LF		 2780{
2781 unsigned long ioaddr = 0;
2782 struct net_device *dev = NULL;
1344ee25 2783 struct r8192_priv *priv = NULL;
94a79942 2784 struct rtl819x_ops *ops = (struct rtl819x_ops *)(id->driver_data);
94a79942 2785 unsigned long pmem_start, pmem_len, pmem_flags;
35f8673d 2786 int err = -ENOMEM;
94a79942 2787 bool bdma64 = false;
1ec3e2f2 2788 u8 revision_id;
94a79942 2789
1344ee25 2790 RT_TRACE(COMP_INIT, "Configuring chip resources");
94a79942 2791
1344ee25 2792 if (pci_enable_device(pdev)) {
3b4140af 2793 dev_err(&pdev->dev, "Failed to enable PCI device");
94a79942
LF		 2794 return -EIO;
2795 }
2796
2797 pci_set_master(pdev);
2798
1344ee25
LF		 2799 if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) {
2800 if (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
d69d2054
MK		 2801 dev_info(&pdev->dev,
2802 "Unable to obtain 32bit DMA for consistent allocations\n");
35f8673d 2803 goto err_pci_disable;
94a79942
LF		 2804 }
2805 }
2806 dev = alloc_rtllib(sizeof(struct r8192_priv));
2807 if (!dev)
35f8673d 2808 goto err_pci_disable;
94a79942 2809
35f8673d 2810 err = -ENODEV;
1344ee25 2811 if (bdma64)
94a79942 2812 dev->features |= NETIF_F_HIGHDMA;
94a79942 2813
94a79942 2814 pci_set_drvdata(pdev, dev);
94a79942 2815 SET_NETDEV_DEV(dev, &pdev->dev);
94a79942
LF		 2816 priv = rtllib_priv(dev);
2817 priv->rtllib = (struct rtllib_device *)netdev_priv_rsl(dev);
1344ee25
LF		 2818 priv->pdev = pdev;
2819 priv->rtllib->pdev = pdev;
2820 if ((pdev->subsystem_vendor == PCI_VENDOR_ID_DLINK) &&
2821 (pdev->subsystem_device == 0x3304))
94a79942 2822 priv->rtllib->bSupportRemoteWakeUp = 1;
cb762154 2823 else
94a79942 2824 priv->rtllib->bSupportRemoteWakeUp = 0;
94a79942 2825
94a79942
LF		 2826 pmem_start = pci_resource_start(pdev, 1);
2827 pmem_len = pci_resource_len(pdev, 1);
1344ee25 2828 pmem_flags = pci_resource_flags(pdev, 1);
94a79942
LF		 2829
2830 if (!(pmem_flags & IORESOURCE_MEM)) {
3b4140af 2831 netdev_err(dev, "region #1 not a MMIO resource, aborting");
35f8673d 2832 goto err_rel_rtllib;
94a79942
LF		 2833 }
2834
d69d2054
MK		 2835 dev_info(&pdev->dev, "Memory mapped space start: 0x%08lx\n",
2836 pmem_start);
94a79942 2837 if (!request_mem_region(pmem_start, pmem_len, DRV_NAME)) {
3b4140af 2838 netdev_err(dev, "request_mem_region failed!");
35f8673d 2839 goto err_rel_rtllib;
94a79942
LF		 2840 }
2841
2842
1344ee25
LF		 2843 ioaddr = (unsigned long)ioremap_nocache(pmem_start, pmem_len);
2844 if (ioaddr == (unsigned long)NULL) {
3b4140af 2845 netdev_err(dev, "ioremap failed!");
35f8673d 2846 goto err_rel_mem;
94a79942
LF		 2847 }
2848
2849 dev->mem_start = ioaddr;
2850 dev->mem_end = ioaddr + pci_resource_len(pdev, 0);
2851
1ec3e2f2
MM		 2852 pci_read_config_byte(pdev, 0x08, &revision_id);
2853 /* If the revisionid is 0x10, the device uses rtl8192se. */
2854 if (pdev->device == 0x8192 && revision_id == 0x10)
35f8673d 2855 goto err_rel_mem;
1ec3e2f2 2856
94a79942 2857 priv->ops = ops;
94a79942
LF		 2858
2859 if (rtl8192_pci_findadapter(pdev, dev) == false)
35f8673d 2860 goto err_rel_mem;
94a79942
LF		 2861
2862 dev->irq = pdev->irq;
2863 priv->irq = 0;
2864
94a79942 2865 dev->netdev_ops = &rtl8192_netdev_ops;
94a79942 2866
5169af23 2867 dev->wireless_handlers = &r8192_wx_handlers_def;
94a79942 2868 dev->ethtool_ops = &rtl819x_ethtool_ops;
94a79942
LF		 2869
2870 dev->type = ARPHRD_ETHER;
1344ee25 2871 dev->watchdog_timeo = HZ * 3;
94a79942 2872
1344ee25 2873 if (dev_alloc_name(dev, ifname) < 0) {
0822339b
MK		 2874 RT_TRACE(COMP_INIT,
2875 "Oops: devname already taken! Trying wlan%%d...\n");
1344ee25
LF		 2876 dev_alloc_name(dev, ifname);
2877 }
94a79942
LF		 2878
2879 RT_TRACE(COMP_INIT, "Driver probe completed1\n");
1344ee25 2880 if (rtl8192_init(dev) != 0) {
3b4140af 2881 netdev_warn(dev, "Initialization failed");
35f8673d 2882 goto err_free_irq;
94a79942
LF		 2883 }
2884
94a79942
LF		 2885 netif_carrier_off(dev);
2886 netif_stop_queue(dev);
2887
4087641b
KAM		 2888 if (register_netdev(dev))
2889 goto err_free_irq;
1344ee25 2890 RT_TRACE(COMP_INIT, "dev name: %s\n", dev->name);
80c0d83a 2891
1344ee25 2892 if (priv->polling_timer_on == 0)
94a79942 2893 check_rfctrl_gpio_timer((unsigned long)dev);
94a79942 2894
94a79942
LF		 2895 RT_TRACE(COMP_INIT, "Driver probe completed\n");
2896 return 0;
2897
35f8673d
LF		 2898err_free_irq:
2899 free_irq(dev->irq, dev);
2900 priv->irq = 0;
2901err_rel_mem:
2902 release_mem_region(pmem_start, pmem_len);
2903err_rel_rtllib:
2904 free_rtllib(dev);
94a79942
LF		 2905
2906 DMESG("wlan driver load failed\n");
35f8673d
LF		 2907err_pci_disable:
2908 pci_disable_device(pdev);
2909 return err;
94a79942
LF		 2910}
2911
1387b461 2912static void rtl8192_pci_disconnect(struct pci_dev *pdev)
94a79942
LF		 2913{
2914 struct net_device *dev = pci_get_drvdata(pdev);
dc986e3e 2915 struct r8192_priv *priv;
1344ee25
LF		 2916 u32 i;
2917
2918 if (dev) {
94a79942
LF		 2919 unregister_netdev(dev);
2920
2921 priv = rtllib_priv(dev);
2922
94a79942 2923 del_timer_sync(&priv->gpio_polling_timer);
94a79942 2924 cancel_delayed_work(&priv->gpio_change_rf_wq);
94a79942 2925 priv->polling_timer_on = 0;
1344ee25 2926 rtl8192_down(dev, true);
94a79942 2927 deinit_hal_dm(dev);
cb762154 2928 if (priv->pFirmware) {
94a79942
LF		 2929 vfree(priv->pFirmware);
2930 priv->pFirmware = NULL;
2931 }
94a79942 2932 destroy_workqueue(priv->priv_wq);
1344ee25
LF		 2933 rtl8192_free_rx_ring(dev);
2934 for (i = 0; i < MAX_TX_QUEUE_COUNT; i++)
2935 rtl8192_free_tx_ring(dev, i);
94a79942 2936
1344ee25 2937 if (priv->irq) {
d69d2054 2938 dev_info(&pdev->dev, "Freeing irq %d\n", dev->irq);
94a79942 2939 free_irq(dev->irq, dev);
1344ee25 2940 priv->irq = 0;
94a79942 2941 }
94a79942
LF		 2942 free_rtllib(dev);
2943
66898177 2944 if (dev->mem_start != 0) {
49aab5fd 2945 iounmap((void __iomem *)dev->mem_start);
66898177 2946 release_mem_region(pci_resource_start(pdev, 1),
1344ee25 2947 pci_resource_len(pdev, 1));
66898177 2948 }
1344ee25
LF		 2949 } else {
2950 priv = rtllib_priv(dev);
2951 }
94a79942
LF		 2952
2953 pci_disable_device(pdev);
94a79942
LF		 2954 RT_TRACE(COMP_DOWN, "wlan driver removed\n");
2955}
2956
1344ee25 2957bool NicIFEnableNIC(struct net_device *dev)
94a79942
LF		 2958{
2959 bool init_status = true;
1344ee25
LF		 2960 struct r8192_priv *priv = rtllib_priv(dev);
2961 struct rt_pwr_save_ctrl *pPSC = (struct rt_pwr_save_ctrl *)
2962 (&(priv->rtllib->PowerSaveControl));
94a79942 2963
5dc42962 2964 if (!priv->up) {
3b4140af 2965 netdev_warn(dev, "%s(): Driver is already down!\n", __func__);
94a79942 2966 priv->bdisable_nic = false;
7626e3d0 2967 return false;
94a79942
LF		 2968 }
2969
1344ee25 2970 RT_TRACE(COMP_PS, "===========>%s()\n", __func__);
94a79942
LF		 2971 priv->bfirst_init = true;
2972 init_status = priv->ops->initialize_adapter(dev);
4bb01423 2973 if (!init_status) {
3b4140af 2974 netdev_warn(dev, "%s(): Initialization failed!\n", __func__);
94a79942 2975 priv->bdisable_nic = false;
7626e3d0 2976 return false;
94a79942
LF		 2977 }
2978 RT_TRACE(COMP_INIT, "start adapter finished\n");
2979 RT_CLEAR_PS_LEVEL(pPSC, RT_RF_OFF_LEVL_HALT_NIC);
2980 priv->bfirst_init = false;
2981
2982 rtl8192_irq_enable(dev);
2983 priv->bdisable_nic = false;
1344ee25 2984 RT_TRACE(COMP_PS, "<===========%s()\n", __func__);
94a79942
LF		 2985 return init_status;
2986}
1344ee25 2987bool NicIFDisableNIC(struct net_device *dev)
94a79942 2988{
1344ee25 2989 struct r8192_priv *priv = rtllib_priv(dev);
94a79942 2990 u8 tmp_state = 0;
3a6b70c3 2991
1344ee25 2992 RT_TRACE(COMP_PS, "=========>%s()\n", __func__);
94a79942
LF		 2993 priv->bdisable_nic = true;
2994 tmp_state = priv->rtllib->state;
2995 rtllib_softmac_stop_protocol(priv->rtllib, 0, false);
2996 priv->rtllib->state = tmp_state;
2997 rtl8192_cancel_deferred_work(priv);
2998 rtl8192_irq_disable(dev);
2999
3000 priv->ops->stop_adapter(dev, false);
1344ee25 3001 RT_TRACE(COMP_PS, "<=========%s()\n", __func__);
94a79942 3002
e623d0f3 3003 return true;
94a79942
LF		 3004}
3005
3006static int __init rtl8192_pci_module_init(void)
3007{
d69d2054
MK		 3008 pr_info("\nLinux kernel driver for RTL8192E WLAN cards\n");
3009 pr_info("Copyright (c) 2007-2008, Realsil Wlan Driver\n");
94a79942 3010
1344ee25 3011 if (0 != pci_register_driver(&rtl8192_pci_driver)) {
94a79942
LF		 3012 DMESG("No device found");
3013 /*pci_unregister_driver (&rtl8192_pci_driver);*/
3014 return -ENODEV;
3015 }
3016 return 0;
94a79942
LF		 3017}
3018
3019static void __exit rtl8192_pci_module_exit(void)
3020{
3021 pci_unregister_driver(&rtl8192_pci_driver);
3022
3023 RT_TRACE(COMP_DOWN, "Exiting");
94a79942
LF		 3024}
3025
3026void check_rfctrl_gpio_timer(unsigned long data)
3027{
1344ee25 3028 struct r8192_priv *priv = rtllib_priv((struct net_device *)data);
94a79942
LF		 3029
3030 priv->polling_timer_on = 1;
3031
1344ee25 3032 queue_delayed_work_rsl(priv->priv_wq, &priv->gpio_change_rf_wq, 0);
94a79942 3033
1344ee25 3034 mod_timer(&priv->gpio_polling_timer, jiffies +
8b9733c1 3035 msecs_to_jiffies(RTLLIB_WATCH_DOG_TIME));
94a79942
LF		 3036}
3037
3038/***************************************************************************
1344ee25 3039 ------------------- module init / exit stubs ----------------
94a79942
LF		 3040****************************************************************************/
3041module_init(rtl8192_pci_module_init);
3042module_exit(rtl8192_pci_module_exit);
3043
3044MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
3045MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
94a79942 3046MODULE_VERSION(DRV_VERSION);
94a79942 3047MODULE_LICENSE("GPL");
7f34f412
TG		 3048MODULE_FIRMWARE(RTL8192E_BOOT_IMG_FW);
3049MODULE_FIRMWARE(RTL8192E_MAIN_IMG_FW);
3050MODULE_FIRMWARE(RTL8192E_DATA_IMG_FW);
94a79942 3051
1344ee25
LF		 3052module_param(ifname, charp, S_IRUGO|S_IWUSR);
3053module_param(hwwep, int, S_IRUGO|S_IWUSR);
3054module_param(channels, int, S_IRUGO|S_IWUSR);
94a79942 3055
1344ee25
LF		 3056MODULE_PARM_DESC(ifname, " Net interface name, wlan%d=default");
3057MODULE_PARM_DESC(hwwep, " Try to use hardware WEP support(default use hw. set 0 to use software security)");
3058MODULE_PARM_DESC(channels, " Channel bitmask for specific locales. NYI");
Linux 6.x block layer and io_uring tree(s)