1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
4 * Based on the r8180 driver, which is:
5 * Copyright 2004-2005 Andrea Merello <andreamrl@tiscali.it>, et al.
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.
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
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
19 * The full GNU General Public License is included in this distribution in the
20 * file called LICENSE.
22 * Contact Information:
23 * wlanfae <wlanfae@realtek.com>
24 ******************************************************************************/
25 #undef RX_DONT_PASS_UL
27 #undef DEBUG_RX_VERBOSE
33 #undef DEBUG_TX_FILLDESC
38 #undef DEBUG_REGISTERS
40 #undef DEBUG_IRQ_TASKLET
44 #include <linux/uaccess.h>
45 #include <linux/pci.h>
46 #include <linux/vmalloc.h>
48 #include "r8192E_phy.h"
49 #include "r8192E_phyreg.h"
50 #include "r8190P_rtl8256.h"
51 #include "r8192E_cmdpkt.h"
61 static int channels
= 0x3fff;
62 static char *ifname
= "wlan%d";
65 static struct rtl819x_ops rtl819xp_ops
= {
66 .nic_type
= NIC_8192E
,
67 .get_eeprom_size
= rtl8192_get_eeprom_size
,
68 .init_adapter_variable
= rtl8192_InitializeVariables
,
69 .initialize_adapter
= rtl8192_adapter_start
,
70 .link_change
= rtl8192_link_change
,
71 .tx_fill_descriptor
= rtl8192_tx_fill_desc
,
72 .tx_fill_cmd_descriptor
= rtl8192_tx_fill_cmd_desc
,
73 .rx_query_status_descriptor
= rtl8192_rx_query_status_desc
,
74 .rx_command_packet_handler
= NULL
,
75 .stop_adapter
= rtl8192_halt_adapter
,
76 .update_ratr_table
= rtl8192_update_ratr_table
,
77 .irq_enable
= rtl8192_EnableInterrupt
,
78 .irq_disable
= rtl8192_DisableInterrupt
,
79 .irq_clear
= rtl8192_ClearInterrupt
,
80 .rx_enable
= rtl8192_enable_rx
,
81 .tx_enable
= rtl8192_enable_tx
,
82 .interrupt_recognized
= rtl8192_interrupt_recognized
,
83 .TxCheckStuckHandler
= rtl8192_HalTxCheckStuck
,
84 .RxCheckStuckHandler
= rtl8192_HalRxCheckStuck
,
87 static struct pci_device_id rtl8192_pci_id_tbl
[] __devinitdata
= {
88 {RTL_PCI_DEVICE(0x10ec, 0x8192, rtl819xp_ops
)},
89 {RTL_PCI_DEVICE(0x07aa, 0x0044, rtl819xp_ops
)},
90 {RTL_PCI_DEVICE(0x07aa, 0x0047, rtl819xp_ops
)},
94 MODULE_DEVICE_TABLE(pci
, rtl8192_pci_id_tbl
);
96 static int __devinit
rtl8192_pci_probe(struct pci_dev
*pdev
,
97 const struct pci_device_id
*id
);
98 static void __devexit
rtl8192_pci_disconnect(struct pci_dev
*pdev
);
100 static struct pci_driver rtl8192_pci_driver
= {
101 .name
= DRV_NAME
, /* Driver name */
102 .id_table
= rtl8192_pci_id_tbl
, /* PCI_ID table */
103 .probe
= rtl8192_pci_probe
, /* probe fn */
104 .remove
= __devexit_p(rtl8192_pci_disconnect
), /* remove fn */
105 .suspend
= rtl8192E_suspend
, /* PM suspend fn */
106 .resume
= rtl8192E_resume
, /* PM resume fn */
109 /****************************************************************************
110 -----------------------------IO STUFF-------------------------
111 *****************************************************************************/
112 static bool PlatformIOCheckPageLegalAndGetRegMask(u32 u4bPage
, u8
*pu1bPageMask
)
114 bool bReturn
= false;
116 *pu1bPageMask
= 0xfe;
119 case 1: case 2: case 3: case 4:
120 case 8: case 9: case 10: case 12: case 13:
122 *pu1bPageMask
= 0xf0;
133 void write_nic_io_byte(struct net_device
*dev
, int x
, u8 y
)
135 u32 u4bPage
= (x
>> 8);
137 bool bIsLegalPage
= false;
140 outb(y
&0xff, dev
->base_addr
+ x
);
143 bIsLegalPage
= PlatformIOCheckPageLegalAndGetRegMask(u4bPage
,
146 u8 u1bPsr
= read_nic_io_byte(dev
, PSR
);
148 write_nic_io_byte(dev
, PSR
, ((u1bPsr
& u1PageMask
) |
150 write_nic_io_byte(dev
, (x
& 0xff), y
);
151 write_nic_io_byte(dev
, PSR
, (u1bPsr
& u1PageMask
));
156 void write_nic_io_word(struct net_device
*dev
, int x
, u16 y
)
158 u32 u4bPage
= (x
>> 8);
160 bool bIsLegalPage
= false;
163 outw(y
, dev
->base_addr
+ x
);
165 bIsLegalPage
= PlatformIOCheckPageLegalAndGetRegMask(u4bPage
,
168 u8 u1bPsr
= read_nic_io_byte(dev
, PSR
);
170 write_nic_io_byte(dev
, PSR
, ((u1bPsr
& u1PageMask
) |
172 write_nic_io_word(dev
, (x
& 0xff), y
);
173 write_nic_io_byte(dev
, PSR
, (u1bPsr
& u1PageMask
));
179 void write_nic_io_dword(struct net_device
*dev
, int x
, u32 y
)
181 u32 u4bPage
= (x
>> 8);
183 bool bIsLegalPage
= false;
186 outl(y
, dev
->base_addr
+ x
);
188 bIsLegalPage
= PlatformIOCheckPageLegalAndGetRegMask(u4bPage
,
191 u8 u1bPsr
= read_nic_io_byte(dev
, PSR
);
193 write_nic_io_byte(dev
, PSR
, ((u1bPsr
& u1PageMask
) |
195 write_nic_io_dword(dev
, (x
& 0xff), y
);
196 write_nic_io_byte(dev
, PSR
, (u1bPsr
& u1PageMask
));
201 u8
read_nic_io_byte(struct net_device
*dev
, int x
)
203 u32 u4bPage
= (x
>> 8);
205 bool bIsLegalPage
= false;
209 return 0xff&inb(dev
->base_addr
+ x
);
211 bIsLegalPage
= PlatformIOCheckPageLegalAndGetRegMask(u4bPage
,
214 u8 u1bPsr
= read_nic_io_byte(dev
, PSR
);
216 write_nic_io_byte(dev
, PSR
, ((u1bPsr
& u1PageMask
) |
218 Data
= read_nic_io_byte(dev
, (x
& 0xff));
219 write_nic_io_byte(dev
, PSR
, (u1bPsr
& u1PageMask
));
226 u16
read_nic_io_word(struct net_device
*dev
, int x
)
228 u32 u4bPage
= (x
>> 8);
230 bool bIsLegalPage
= false;
234 return inw(dev
->base_addr
+ x
);
236 bIsLegalPage
= PlatformIOCheckPageLegalAndGetRegMask(u4bPage
,
239 u8 u1bPsr
= read_nic_io_byte(dev
, PSR
);
241 write_nic_io_byte(dev
, PSR
, ((u1bPsr
& u1PageMask
) |
243 Data
= read_nic_io_word(dev
, (x
& 0xff));
244 write_nic_io_byte(dev
, PSR
, (u1bPsr
& u1PageMask
));
252 u32
read_nic_io_dword(struct net_device
*dev
, int x
)
254 u32 u4bPage
= (x
>> 8);
256 bool bIsLegalPage
= false;
260 return inl(dev
->base_addr
+ x
);
262 bIsLegalPage
= PlatformIOCheckPageLegalAndGetRegMask(u4bPage
,
265 u8 u1bPsr
= read_nic_io_byte(dev
, PSR
);
267 write_nic_io_byte(dev
, PSR
, ((u1bPsr
& u1PageMask
) |
269 Data
= read_nic_io_dword(dev
, (x
& 0xff));
270 write_nic_io_byte(dev
, PSR
, (u1bPsr
& u1PageMask
));
278 u8
read_nic_byte(struct net_device
*dev
, int x
)
280 return 0xff & readb((u8 __iomem
*)dev
->mem_start
+ x
);
283 u32
read_nic_dword(struct net_device
*dev
, int x
)
285 return readl((u8 __iomem
*)dev
->mem_start
+ x
);
288 u16
read_nic_word(struct net_device
*dev
, int x
)
290 return readw((u8 __iomem
*)dev
->mem_start
+ x
);
293 void write_nic_byte(struct net_device
*dev
, int x
, u8 y
)
295 writeb(y
, (u8 __iomem
*)dev
->mem_start
+ x
);
300 void write_nic_dword(struct net_device
*dev
, int x
, u32 y
)
302 writel(y
, (u8 __iomem
*)dev
->mem_start
+ x
);
307 void write_nic_word(struct net_device
*dev
, int x
, u16 y
)
309 writew(y
, (u8 __iomem
*)dev
->mem_start
+ x
);
314 /****************************************************************************
315 -----------------------------GENERAL FUNCTION-------------------------
316 *****************************************************************************/
317 bool MgntActSet_RF_State(struct net_device
*dev
,
318 enum rt_rf_power_state StateToSet
,
319 RT_RF_CHANGE_SOURCE ChangeSource
,
322 struct r8192_priv
*priv
= rtllib_priv(dev
);
323 struct rtllib_device
*ieee
= priv
->rtllib
;
324 bool bActionAllowed
= false;
325 bool bConnectBySSID
= false;
326 enum rt_rf_power_state rtState
;
327 u16 RFWaitCounter
= 0;
329 RT_TRACE((COMP_PS
| COMP_RF
), "===>MgntActSet_RF_State(): "
330 "StateToSet(%d)\n", StateToSet
);
332 ProtectOrNot
= false;
337 spin_lock_irqsave(&priv
->rf_ps_lock
, flag
);
338 if (priv
->RFChangeInProgress
) {
339 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flag
);
340 RT_TRACE((COMP_PS
| COMP_RF
),
341 "MgntActSet_RF_State(): RF Change in "
342 "progress! Wait to set..StateToSet"
343 "(%d).\n", StateToSet
);
345 while (priv
->RFChangeInProgress
) {
347 RT_TRACE((COMP_PS
| COMP_RF
),
348 "MgntActSet_RF_State(): Wait 1"
349 " ms (%d times)...\n",
353 if (RFWaitCounter
> 100) {
354 RT_TRACE(COMP_ERR
, "MgntActSet_"
355 "RF_State(): Wait too "
361 priv
->RFChangeInProgress
= true;
362 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flag
);
368 rtState
= priv
->rtllib
->eRFPowerState
;
370 switch (StateToSet
) {
372 priv
->rtllib
->RfOffReason
&= (~ChangeSource
);
374 if ((ChangeSource
== RF_CHANGE_BY_HW
) &&
375 (priv
->bHwRadioOff
== true))
376 priv
->bHwRadioOff
= false;
378 if (!priv
->rtllib
->RfOffReason
) {
379 priv
->rtllib
->RfOffReason
= 0;
380 bActionAllowed
= true;
383 if (rtState
== eRfOff
&&
384 ChangeSource
>= RF_CHANGE_BY_HW
)
385 bConnectBySSID
= true;
387 RT_TRACE((COMP_PS
| COMP_RF
), "MgntActSet_RF_State - "
388 "eRfon reject pMgntInfo->RfOffReason= 0x%x,"
389 " ChangeSource=0x%X\n",
390 priv
->rtllib
->RfOffReason
, ChangeSource
);
397 if ((priv
->rtllib
->iw_mode
== IW_MODE_INFRA
) ||
398 (priv
->rtllib
->iw_mode
== IW_MODE_ADHOC
)) {
399 if ((priv
->rtllib
->RfOffReason
> RF_CHANGE_BY_IPS
) ||
400 (ChangeSource
> RF_CHANGE_BY_IPS
)) {
401 if (ieee
->state
== RTLLIB_LINKED
)
402 priv
->blinked_ingpio
= true;
404 priv
->blinked_ingpio
= false;
405 rtllib_MgntDisconnect(priv
->rtllib
,
409 if ((ChangeSource
== RF_CHANGE_BY_HW
) &&
410 (priv
->bHwRadioOff
== false))
411 priv
->bHwRadioOff
= true;
412 priv
->rtllib
->RfOffReason
|= ChangeSource
;
413 bActionAllowed
= true;
417 priv
->rtllib
->RfOffReason
|= ChangeSource
;
418 bActionAllowed
= true;
425 if (bActionAllowed
) {
426 RT_TRACE((COMP_PS
| COMP_RF
), "MgntActSet_RF_State(): Action is"
427 " allowed.... StateToSet(%d), RfOffReason(%#X)\n",
428 StateToSet
, priv
->rtllib
->RfOffReason
);
429 PHY_SetRFPowerState(dev
, StateToSet
);
430 if (StateToSet
== eRfOn
) {
432 if (bConnectBySSID
&& (priv
->blinked_ingpio
== true)) {
433 queue_delayed_work_rsl(ieee
->wq
,
434 &ieee
->associate_procedure_wq
, 0);
435 priv
->blinked_ingpio
= false;
439 RT_TRACE((COMP_PS
| COMP_RF
), "MgntActSet_RF_State(): "
440 "Action is rejected.... StateToSet(%d), ChangeSource"
441 "(%#X), RfOffReason(%#X)\n", StateToSet
, ChangeSource
,
442 priv
->rtllib
->RfOffReason
);
446 spin_lock_irqsave(&priv
->rf_ps_lock
, flag
);
447 priv
->RFChangeInProgress
= false;
448 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flag
);
451 RT_TRACE((COMP_PS
| COMP_RF
), "<===MgntActSet_RF_State()\n");
452 return bActionAllowed
;
456 static short rtl8192_get_nic_desc_num(struct net_device
*dev
, int prio
)
458 struct r8192_priv
*priv
= rtllib_priv(dev
);
459 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
461 /* For now, we reserved two free descriptor as a safety boundary
462 * between the tail and the head
464 if ((prio
== MGNT_QUEUE
) && (skb_queue_len(&ring
->queue
) > 10))
465 RT_TRACE(COMP_DBG
, "-----[%d]---------ring->idx=%d "
466 "queue_len=%d---------\n", prio
, ring
->idx
,
467 skb_queue_len(&ring
->queue
));
468 return skb_queue_len(&ring
->queue
);
471 static short rtl8192_check_nic_enough_desc(struct net_device
*dev
, int prio
)
473 struct r8192_priv
*priv
= rtllib_priv(dev
);
474 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
476 if (ring
->entries
- skb_queue_len(&ring
->queue
) >= 2)
481 void rtl8192_tx_timeout(struct net_device
*dev
)
483 struct r8192_priv
*priv
= rtllib_priv(dev
);
485 schedule_work(&priv
->reset_wq
);
486 printk(KERN_INFO
"TXTIMEOUT");
489 void rtl8192_irq_enable(struct net_device
*dev
)
491 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
492 priv
->irq_enabled
= 1;
494 priv
->ops
->irq_enable(dev
);
497 void rtl8192_irq_disable(struct net_device
*dev
)
499 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
501 priv
->ops
->irq_disable(dev
);
503 priv
->irq_enabled
= 0;
506 void rtl8192_set_chan(struct net_device
*dev
, short ch
)
508 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
510 RT_TRACE(COMP_CH
, "=====>%s()====ch:%d\n", __func__
, ch
);
511 if (priv
->chan_forced
)
516 if (priv
->rf_set_chan
)
517 priv
->rf_set_chan(dev
, priv
->chan
);
520 void rtl8192_update_cap(struct net_device
*dev
, u16 cap
)
522 struct r8192_priv
*priv
= rtllib_priv(dev
);
523 struct rtllib_network
*net
= &priv
->rtllib
->current_network
;
526 if (cap
& WLAN_CAPABILITY_SHORT_PREAMBLE
) {
527 if (priv
->dot11CurrentPreambleMode
!= PREAMBLE_SHORT
) {
528 ShortPreamble
= true;
529 priv
->dot11CurrentPreambleMode
= PREAMBLE_SHORT
;
530 RT_TRACE(COMP_DBG
, "%s(): WLAN_CAPABILITY_SHORT_"
531 "PREAMBLE\n", __func__
);
532 priv
->rtllib
->SetHwRegHandler(dev
, HW_VAR_ACK_PREAMBLE
,
533 (unsigned char *)&ShortPreamble
);
536 if (priv
->dot11CurrentPreambleMode
!= PREAMBLE_LONG
) {
537 ShortPreamble
= false;
538 priv
->dot11CurrentPreambleMode
= PREAMBLE_LONG
;
539 RT_TRACE(COMP_DBG
, "%s(): WLAN_CAPABILITY_LONG_"
540 "PREAMBLE\n", __func__
);
541 priv
->rtllib
->SetHwRegHandler(dev
, HW_VAR_ACK_PREAMBLE
,
542 (unsigned char *)&ShortPreamble
);
546 if (net
->mode
& (IEEE_G
|IEEE_N_24G
)) {
548 u8 CurSlotTime
= priv
->slot_time
;
550 if ((cap
& WLAN_CAPABILITY_SHORT_SLOT_TIME
) &&
551 (!priv
->rtllib
->pHTInfo
->bCurrentRT2RTLongSlotTime
)) {
552 if (CurSlotTime
!= SHORT_SLOT_TIME
) {
553 slot_time_val
= SHORT_SLOT_TIME
;
554 priv
->rtllib
->SetHwRegHandler(dev
,
555 HW_VAR_SLOT_TIME
, &slot_time_val
);
558 if (CurSlotTime
!= NON_SHORT_SLOT_TIME
) {
559 slot_time_val
= NON_SHORT_SLOT_TIME
;
560 priv
->rtllib
->SetHwRegHandler(dev
,
561 HW_VAR_SLOT_TIME
, &slot_time_val
);
567 static struct rtllib_qos_parameters def_qos_parameters
= {
575 static void rtl8192_update_beacon(void *data
)
577 struct r8192_priv
*priv
= container_of_work_rsl(data
, struct r8192_priv
,
578 update_beacon_wq
.work
);
579 struct net_device
*dev
= priv
->rtllib
->dev
;
580 struct rtllib_device
*ieee
= priv
->rtllib
;
581 struct rtllib_network
*net
= &ieee
->current_network
;
583 if (ieee
->pHTInfo
->bCurrentHTSupport
)
584 HTUpdateSelfAndPeerSetting(ieee
, net
);
585 ieee
->pHTInfo
->bCurrentRT2RTLongSlotTime
=
586 net
->bssht
.bdRT2RTLongSlotTime
;
587 ieee
->pHTInfo
->RT2RT_HT_Mode
= net
->bssht
.RT2RT_HT_Mode
;
588 rtl8192_update_cap(dev
, net
->capability
);
591 int WDCAPARA_ADD
[] = {EDCAPARA_BE
, EDCAPARA_BK
, EDCAPARA_VI
, EDCAPARA_VO
};
593 static void rtl8192_qos_activate(void *data
)
595 struct r8192_priv
*priv
= container_of_work_rsl(data
, struct r8192_priv
,
597 struct net_device
*dev
= priv
->rtllib
->dev
;
600 mutex_lock(&priv
->mutex
);
601 if (priv
->rtllib
->state
!= RTLLIB_LINKED
)
603 RT_TRACE(COMP_QOS
, "qos active process with associate response "
606 for (i
= 0; i
< QOS_QUEUE_NUM
; i
++) {
607 priv
->rtllib
->SetHwRegHandler(dev
, HW_VAR_AC_PARAM
, (u8
*)(&i
));
611 mutex_unlock(&priv
->mutex
);
614 static int rtl8192_qos_handle_probe_response(struct r8192_priv
*priv
,
616 struct rtllib_network
*network
)
619 u32 size
= sizeof(struct rtllib_qos_parameters
);
621 if (priv
->rtllib
->state
!= RTLLIB_LINKED
)
624 if ((priv
->rtllib
->iw_mode
!= IW_MODE_INFRA
))
627 if (network
->flags
& NETWORK_HAS_QOS_MASK
) {
628 if (active_network
&&
629 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
))
630 network
->qos_data
.active
= network
->qos_data
.supported
;
632 if ((network
->qos_data
.active
== 1) && (active_network
== 1) &&
633 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) &&
634 (network
->qos_data
.old_param_count
!=
635 network
->qos_data
.param_count
)) {
636 network
->qos_data
.old_param_count
=
637 network
->qos_data
.param_count
;
638 priv
->rtllib
->wmm_acm
= network
->qos_data
.wmm_acm
;
639 queue_work_rsl(priv
->priv_wq
, &priv
->qos_activate
);
640 RT_TRACE(COMP_QOS
, "QoS parameters change call "
644 memcpy(&priv
->rtllib
->current_network
.qos_data
.parameters
,
645 &def_qos_parameters
, size
);
647 if ((network
->qos_data
.active
== 1) && (active_network
== 1)) {
648 queue_work_rsl(priv
->priv_wq
, &priv
->qos_activate
);
649 RT_TRACE(COMP_QOS
, "QoS was disabled call qos_"
652 network
->qos_data
.active
= 0;
653 network
->qos_data
.supported
= 0;
659 static int rtl8192_handle_beacon(struct net_device
*dev
,
660 struct rtllib_beacon
*beacon
,
661 struct rtllib_network
*network
)
663 struct r8192_priv
*priv
= rtllib_priv(dev
);
665 rtl8192_qos_handle_probe_response(priv
, 1, network
);
667 queue_delayed_work_rsl(priv
->priv_wq
, &priv
->update_beacon_wq
, 0);
672 static int rtl8192_qos_association_resp(struct r8192_priv
*priv
,
673 struct rtllib_network
*network
)
677 u32 size
= sizeof(struct rtllib_qos_parameters
);
678 int set_qos_param
= 0;
680 if ((priv
== NULL
) || (network
== NULL
))
683 if (priv
->rtllib
->state
!= RTLLIB_LINKED
)
686 if ((priv
->rtllib
->iw_mode
!= IW_MODE_INFRA
))
689 spin_lock_irqsave(&priv
->rtllib
->lock
, flags
);
690 if (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) {
691 memcpy(&priv
->rtllib
->current_network
.qos_data
.parameters
,
692 &network
->qos_data
.parameters
,
693 sizeof(struct rtllib_qos_parameters
));
694 priv
->rtllib
->current_network
.qos_data
.active
= 1;
695 priv
->rtllib
->wmm_acm
= network
->qos_data
.wmm_acm
;
697 priv
->rtllib
->current_network
.qos_data
.old_param_count
=
698 priv
->rtllib
->current_network
.qos_data
.param_count
;
699 priv
->rtllib
->current_network
.qos_data
.param_count
=
700 network
->qos_data
.param_count
;
702 memcpy(&priv
->rtllib
->current_network
.qos_data
.parameters
,
703 &def_qos_parameters
, size
);
704 priv
->rtllib
->current_network
.qos_data
.active
= 0;
705 priv
->rtllib
->current_network
.qos_data
.supported
= 0;
709 spin_unlock_irqrestore(&priv
->rtllib
->lock
, flags
);
711 RT_TRACE(COMP_QOS
, "%s: network->flags = %d,%d\n", __func__
,
712 network
->flags
, priv
->rtllib
->current_network
.qos_data
.active
);
713 if (set_qos_param
== 1) {
714 dm_init_edca_turbo(priv
->rtllib
->dev
);
715 queue_work_rsl(priv
->priv_wq
, &priv
->qos_activate
);
720 static int rtl8192_handle_assoc_response(struct net_device
*dev
,
721 struct rtllib_assoc_response_frame
*resp
,
722 struct rtllib_network
*network
)
724 struct r8192_priv
*priv
= rtllib_priv(dev
);
725 rtl8192_qos_association_resp(priv
, network
);
729 static void rtl8192_prepare_beacon(struct r8192_priv
*priv
)
731 struct net_device
*dev
= priv
->rtllib
->dev
;
732 struct sk_buff
*pskb
= NULL
, *pnewskb
= NULL
;
733 struct cb_desc
*tcb_desc
= NULL
;
734 struct rtl8192_tx_ring
*ring
= NULL
;
735 struct tx_desc
*pdesc
= NULL
;
737 ring
= &priv
->tx_ring
[BEACON_QUEUE
];
738 pskb
= __skb_dequeue(&ring
->queue
);
742 pnewskb
= rtllib_get_beacon(priv
->rtllib
);
746 tcb_desc
= (struct cb_desc
*)(pnewskb
->cb
+ 8);
747 tcb_desc
->queue_index
= BEACON_QUEUE
;
748 tcb_desc
->data_rate
= 2;
749 tcb_desc
->RATRIndex
= 7;
750 tcb_desc
->bTxDisableRateFallBack
= 1;
751 tcb_desc
->bTxUseDriverAssingedRate
= 1;
752 skb_push(pnewskb
, priv
->rtllib
->tx_headroom
);
754 pdesc
= &ring
->desc
[0];
755 priv
->ops
->tx_fill_descriptor(dev
, pdesc
, tcb_desc
, pnewskb
);
756 __skb_queue_tail(&ring
->queue
, pnewskb
);
762 static void rtl8192_stop_beacon(struct net_device
*dev
)
766 void rtl8192_config_rate(struct net_device
*dev
, u16
*rate_config
)
768 struct r8192_priv
*priv
= rtllib_priv(dev
);
769 struct rtllib_network
*net
;
770 u8 i
= 0, basic_rate
= 0;
771 net
= &priv
->rtllib
->current_network
;
773 for (i
= 0; i
< net
->rates_len
; i
++) {
774 basic_rate
= net
->rates
[i
] & 0x7f;
775 switch (basic_rate
) {
777 *rate_config
|= RRSR_1M
;
780 *rate_config
|= RRSR_2M
;
783 *rate_config
|= RRSR_5_5M
;
786 *rate_config
|= RRSR_11M
;
789 *rate_config
|= RRSR_6M
;
792 *rate_config
|= RRSR_9M
;
795 *rate_config
|= RRSR_12M
;
798 *rate_config
|= RRSR_18M
;
801 *rate_config
|= RRSR_24M
;
804 *rate_config
|= RRSR_36M
;
807 *rate_config
|= RRSR_48M
;
810 *rate_config
|= RRSR_54M
;
815 for (i
= 0; i
< net
->rates_ex_len
; i
++) {
816 basic_rate
= net
->rates_ex
[i
] & 0x7f;
817 switch (basic_rate
) {
819 *rate_config
|= RRSR_1M
;
822 *rate_config
|= RRSR_2M
;
825 *rate_config
|= RRSR_5_5M
;
828 *rate_config
|= RRSR_11M
;
831 *rate_config
|= RRSR_6M
;
834 *rate_config
|= RRSR_9M
;
837 *rate_config
|= RRSR_12M
;
840 *rate_config
|= RRSR_18M
;
843 *rate_config
|= RRSR_24M
;
846 *rate_config
|= RRSR_36M
;
849 *rate_config
|= RRSR_48M
;
852 *rate_config
|= RRSR_54M
;
858 static void rtl8192_refresh_supportrate(struct r8192_priv
*priv
)
860 struct rtllib_device
*ieee
= priv
->rtllib
;
861 if (ieee
->mode
== WIRELESS_MODE_N_24G
||
862 ieee
->mode
== WIRELESS_MODE_N_5G
) {
863 memcpy(ieee
->Regdot11HTOperationalRateSet
,
864 ieee
->RegHTSuppRateSet
, 16);
865 memcpy(ieee
->Regdot11TxHTOperationalRateSet
,
866 ieee
->RegHTSuppRateSet
, 16);
869 memset(ieee
->Regdot11HTOperationalRateSet
, 0, 16);
874 static u8
rtl8192_getSupportedWireleeMode(struct net_device
*dev
)
876 struct r8192_priv
*priv
= rtllib_priv(dev
);
879 switch (priv
->rf_chip
) {
884 ret
= (WIRELESS_MODE_N_24G
|WIRELESS_MODE_G
| WIRELESS_MODE_B
);
887 ret
= (WIRELESS_MODE_A
| WIRELESS_MODE_N_5G
);
890 ret
= WIRELESS_MODE_B
;
896 void rtl8192_SetWirelessMode(struct net_device
*dev
, u8 wireless_mode
)
898 struct r8192_priv
*priv
= rtllib_priv(dev
);
899 u8 bSupportMode
= rtl8192_getSupportedWireleeMode(dev
);
901 if ((wireless_mode
== WIRELESS_MODE_AUTO
) ||
902 ((wireless_mode
& bSupportMode
) == 0)) {
903 if (bSupportMode
& WIRELESS_MODE_N_24G
) {
904 wireless_mode
= WIRELESS_MODE_N_24G
;
905 } else if (bSupportMode
& WIRELESS_MODE_N_5G
) {
906 wireless_mode
= WIRELESS_MODE_N_5G
;
907 } else if ((bSupportMode
& WIRELESS_MODE_A
)) {
908 wireless_mode
= WIRELESS_MODE_A
;
909 } else if ((bSupportMode
& WIRELESS_MODE_G
)) {
910 wireless_mode
= WIRELESS_MODE_G
;
911 } else if ((bSupportMode
& WIRELESS_MODE_B
)) {
912 wireless_mode
= WIRELESS_MODE_B
;
914 RT_TRACE(COMP_ERR
, "%s(), No valid wireless mode "
915 "supported (%x)!!!\n", __func__
, bSupportMode
);
916 wireless_mode
= WIRELESS_MODE_B
;
920 if ((wireless_mode
& (WIRELESS_MODE_B
| WIRELESS_MODE_G
)) ==
921 (WIRELESS_MODE_G
| WIRELESS_MODE_B
))
922 wireless_mode
= WIRELESS_MODE_G
;
924 priv
->rtllib
->mode
= wireless_mode
;
926 ActUpdateChannelAccessSetting(dev
, wireless_mode
,
927 &priv
->ChannelAccessSetting
);
929 if ((wireless_mode
== WIRELESS_MODE_N_24G
) ||
930 (wireless_mode
== WIRELESS_MODE_N_5G
)) {
931 priv
->rtllib
->pHTInfo
->bEnableHT
= 1;
932 RT_TRACE(COMP_DBG
, "%s(), wireless_mode:%x, bEnableHT = 1\n",
933 __func__
, wireless_mode
);
935 priv
->rtllib
->pHTInfo
->bEnableHT
= 0;
936 RT_TRACE(COMP_DBG
, "%s(), wireless_mode:%x, bEnableHT = 0\n",
937 __func__
, wireless_mode
);
940 RT_TRACE(COMP_INIT
, "Current Wireless Mode is %x\n", wireless_mode
);
941 rtl8192_refresh_supportrate(priv
);
944 static int _rtl8192_sta_up(struct net_device
*dev
, bool is_silent_reset
)
946 struct r8192_priv
*priv
= rtllib_priv(dev
);
947 struct rt_pwr_save_ctrl
*pPSC
= (struct rt_pwr_save_ctrl
*)
948 (&(priv
->rtllib
->PowerSaveControl
));
949 bool init_status
= true;
950 priv
->bDriverIsGoingToUnload
= false;
951 priv
->bdisable_nic
= false;
954 priv
->rtllib
->ieee_up
= 1;
956 priv
->up_first_time
= 0;
957 RT_TRACE(COMP_INIT
, "Bringing up iface");
958 priv
->bfirst_init
= true;
959 init_status
= priv
->ops
->initialize_adapter(dev
);
960 if (init_status
!= true) {
961 RT_TRACE(COMP_ERR
, "ERR!!! %s(): initialization is failed!\n",
963 priv
->bfirst_init
= false;
967 RT_TRACE(COMP_INIT
, "start adapter finished\n");
968 RT_CLEAR_PS_LEVEL(pPSC
, RT_RF_OFF_LEVL_HALT_NIC
);
969 priv
->bfirst_init
= false;
971 if (priv
->polling_timer_on
== 0)
972 check_rfctrl_gpio_timer((unsigned long)dev
);
974 if (priv
->rtllib
->state
!= RTLLIB_LINKED
)
975 rtllib_softmac_start_protocol(priv
->rtllib
, 0);
976 rtllib_reset_queue(priv
->rtllib
);
977 watch_dog_timer_callback((unsigned long) dev
);
979 if (!netif_queue_stopped(dev
))
980 netif_start_queue(dev
);
982 netif_wake_queue(dev
);
987 static int rtl8192_sta_down(struct net_device
*dev
, bool shutdownrf
)
989 struct r8192_priv
*priv
= rtllib_priv(dev
);
990 unsigned long flags
= 0;
991 u8 RFInProgressTimeOut
= 0;
996 if (priv
->rtllib
->rtllib_ips_leave
!= NULL
)
997 priv
->rtllib
->rtllib_ips_leave(dev
);
999 if (priv
->rtllib
->state
== RTLLIB_LINKED
)
1000 LeisurePSLeave(dev
);
1002 priv
->bDriverIsGoingToUnload
= true;
1004 priv
->rtllib
->ieee_up
= 0;
1005 priv
->bfirst_after_down
= 1;
1006 RT_TRACE(COMP_DOWN
, "==========>%s()\n", __func__
);
1007 if (!netif_queue_stopped(dev
))
1008 netif_stop_queue(dev
);
1010 priv
->rtllib
->wpa_ie_len
= 0;
1011 kfree(priv
->rtllib
->wpa_ie
);
1012 priv
->rtllib
->wpa_ie
= NULL
;
1013 CamResetAllEntry(dev
);
1014 memset(priv
->rtllib
->swcamtable
, 0, sizeof(struct sw_cam_table
) * 32);
1015 rtl8192_irq_disable(dev
);
1017 del_timer_sync(&priv
->watch_dog_timer
);
1018 rtl8192_cancel_deferred_work(priv
);
1019 cancel_delayed_work(&priv
->rtllib
->hw_wakeup_wq
);
1021 rtllib_softmac_stop_protocol(priv
->rtllib
, 0, true);
1022 spin_lock_irqsave(&priv
->rf_ps_lock
, flags
);
1023 while (priv
->RFChangeInProgress
) {
1024 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flags
);
1025 if (RFInProgressTimeOut
> 100) {
1026 spin_lock_irqsave(&priv
->rf_ps_lock
, flags
);
1029 RT_TRACE(COMP_DBG
, "===>%s():RF is in progress, need to wait "
1030 "until rf chang is done.\n", __func__
);
1032 RFInProgressTimeOut
++;
1033 spin_lock_irqsave(&priv
->rf_ps_lock
, flags
);
1035 priv
->RFChangeInProgress
= true;
1036 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flags
);
1037 priv
->ops
->stop_adapter(dev
, false);
1038 spin_lock_irqsave(&priv
->rf_ps_lock
, flags
);
1039 priv
->RFChangeInProgress
= false;
1040 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flags
);
1042 memset(&priv
->rtllib
->current_network
, 0,
1043 offsetof(struct rtllib_network
, list
));
1044 RT_TRACE(COMP_DOWN
, "<==========%s()\n", __func__
);
1049 static void rtl8192_init_priv_handler(struct net_device
*dev
)
1051 struct r8192_priv
*priv
= rtllib_priv(dev
);
1053 priv
->rtllib
->softmac_hard_start_xmit
= rtl8192_hard_start_xmit
;
1054 priv
->rtllib
->set_chan
= rtl8192_set_chan
;
1055 priv
->rtllib
->link_change
= priv
->ops
->link_change
;
1056 priv
->rtllib
->softmac_data_hard_start_xmit
= rtl8192_hard_data_xmit
;
1057 priv
->rtllib
->data_hard_stop
= rtl8192_data_hard_stop
;
1058 priv
->rtllib
->data_hard_resume
= rtl8192_data_hard_resume
;
1059 priv
->rtllib
->check_nic_enough_desc
= rtl8192_check_nic_enough_desc
;
1060 priv
->rtllib
->get_nic_desc_num
= rtl8192_get_nic_desc_num
;
1061 priv
->rtllib
->handle_assoc_response
= rtl8192_handle_assoc_response
;
1062 priv
->rtllib
->handle_beacon
= rtl8192_handle_beacon
;
1063 priv
->rtllib
->SetWirelessMode
= rtl8192_SetWirelessMode
;
1064 priv
->rtllib
->LeisurePSLeave
= LeisurePSLeave
;
1065 priv
->rtllib
->SetBWModeHandler
= rtl8192_SetBWMode
;
1066 priv
->rf_set_chan
= rtl8192_phy_SwChnl
;
1068 priv
->rtllib
->start_send_beacons
= rtl8192e_start_beacon
;
1069 priv
->rtllib
->stop_send_beacons
= rtl8192_stop_beacon
;
1071 priv
->rtllib
->sta_wake_up
= rtl8192_hw_wakeup
;
1072 priv
->rtllib
->enter_sleep_state
= rtl8192_hw_to_sleep
;
1073 priv
->rtllib
->ps_is_queue_empty
= rtl8192_is_tx_queue_empty
;
1075 priv
->rtllib
->GetNmodeSupportBySecCfg
= rtl8192_GetNmodeSupportBySecCfg
;
1076 priv
->rtllib
->GetHalfNmodeSupportByAPsHandler
=
1077 rtl8192_GetHalfNmodeSupportByAPs
;
1079 priv
->rtllib
->SetHwRegHandler
= rtl8192e_SetHwReg
;
1080 priv
->rtllib
->AllowAllDestAddrHandler
= rtl8192_AllowAllDestAddr
;
1081 priv
->rtllib
->SetFwCmdHandler
= NULL
;
1082 priv
->rtllib
->InitialGainHandler
= InitialGain819xPci
;
1083 priv
->rtllib
->rtllib_ips_leave_wq
= rtllib_ips_leave_wq
;
1084 priv
->rtllib
->rtllib_ips_leave
= rtllib_ips_leave
;
1086 priv
->rtllib
->LedControlHandler
= NULL
;
1087 priv
->rtllib
->UpdateBeaconInterruptHandler
= NULL
;
1089 priv
->rtllib
->ScanOperationBackupHandler
= PHY_ScanOperationBackup8192
;
1091 priv
->rtllib
->rtllib_rfkill_poll
= NULL
;
1094 static void rtl8192_init_priv_constant(struct net_device
*dev
)
1096 struct r8192_priv
*priv
= rtllib_priv(dev
);
1097 struct rt_pwr_save_ctrl
*pPSC
= (struct rt_pwr_save_ctrl
*)
1098 &(priv
->rtllib
->PowerSaveControl
);
1100 pPSC
->RegMaxLPSAwakeIntvl
= 5;
1102 priv
->RegPciASPM
= 2;
1104 priv
->RegDevicePciASPMSetting
= 0x03;
1106 priv
->RegHostPciASPMSetting
= 0x02;
1108 priv
->RegHwSwRfOffD3
= 2;
1110 priv
->RegSupportPciASPM
= 2;
1114 static void rtl8192_init_priv_variable(struct net_device
*dev
)
1116 struct r8192_priv
*priv
= rtllib_priv(dev
);
1119 priv
->AcmMethod
= eAcmWay2_SW
;
1120 priv
->dot11CurrentPreambleMode
= PREAMBLE_AUTO
;
1121 priv
->rtllib
->hwscan_sem_up
= 1;
1122 priv
->rtllib
->status
= 0;
1123 priv
->H2CTxCmdSeq
= 0;
1124 priv
->bDisableFrameBursting
= 0;
1125 priv
->bDMInitialGainEnable
= 1;
1126 priv
->polling_timer_on
= 0;
1127 priv
->up_first_time
= 1;
1128 priv
->blinked_ingpio
= false;
1129 priv
->bDriverIsGoingToUnload
= false;
1130 priv
->being_init_adapter
= false;
1131 priv
->initialized_at_probe
= false;
1132 priv
->sw_radio_on
= true;
1133 priv
->bdisable_nic
= false;
1134 priv
->bfirst_init
= false;
1135 priv
->txringcount
= 64;
1136 priv
->rxbuffersize
= 9100;
1137 priv
->rxringcount
= MAX_RX_COUNT
;
1138 priv
->irq_enabled
= 0;
1140 priv
->RegWirelessMode
= WIRELESS_MODE_AUTO
;
1141 priv
->RegChannelPlan
= 0xf;
1142 priv
->nrxAMPDU_size
= 0;
1143 priv
->nrxAMPDU_aggr_num
= 0;
1144 priv
->last_rxdesc_tsf_high
= 0;
1145 priv
->last_rxdesc_tsf_low
= 0;
1146 priv
->rtllib
->mode
= WIRELESS_MODE_AUTO
;
1147 priv
->rtllib
->iw_mode
= IW_MODE_INFRA
;
1148 priv
->rtllib
->bNetPromiscuousMode
= false;
1149 priv
->rtllib
->IntelPromiscuousModeInfo
.bPromiscuousOn
= false;
1150 priv
->rtllib
->IntelPromiscuousModeInfo
.bFilterSourceStationFrame
=
1152 priv
->rtllib
->ieee_up
= 0;
1153 priv
->retry_rts
= DEFAULT_RETRY_RTS
;
1154 priv
->retry_data
= DEFAULT_RETRY_DATA
;
1155 priv
->rtllib
->rts
= DEFAULT_RTS_THRESHOLD
;
1156 priv
->rtllib
->rate
= 110;
1157 priv
->rtllib
->short_slot
= 1;
1158 priv
->promisc
= (dev
->flags
& IFF_PROMISC
) ? 1 : 0;
1159 priv
->bcck_in_ch14
= false;
1160 priv
->bfsync_processing
= false;
1161 priv
->CCKPresentAttentuation
= 0;
1162 priv
->rfa_txpowertrackingindex
= 0;
1163 priv
->rfc_txpowertrackingindex
= 0;
1165 priv
->ScanDelay
= 50;
1166 priv
->ResetProgress
= RESET_TYPE_NORESET
;
1167 priv
->bForcedSilentReset
= 0;
1168 priv
->bDisableNormalResetCheck
= false;
1169 priv
->force_reset
= false;
1170 memset(priv
->rtllib
->swcamtable
, 0, sizeof(struct sw_cam_table
) * 32);
1172 memset(&priv
->InterruptLog
, 0, sizeof(struct log_int_8190
));
1173 priv
->RxCounter
= 0;
1174 priv
->rtllib
->wx_set_enc
= 0;
1175 priv
->bHwRadioOff
= false;
1177 priv
->isRFOff
= false;
1178 priv
->bInPowerSaveMode
= false;
1179 priv
->rtllib
->RfOffReason
= 0;
1180 priv
->RFChangeInProgress
= false;
1181 priv
->bHwRfOffAction
= 0;
1182 priv
->SetRFPowerStateInProgress
= false;
1183 priv
->rtllib
->PowerSaveControl
.bInactivePs
= true;
1184 priv
->rtllib
->PowerSaveControl
.bIPSModeBackup
= false;
1185 priv
->rtllib
->PowerSaveControl
.bLeisurePs
= true;
1186 priv
->rtllib
->PowerSaveControl
.bFwCtrlLPS
= false;
1187 priv
->rtllib
->LPSDelayCnt
= 0;
1188 priv
->rtllib
->sta_sleep
= LPS_IS_WAKE
;
1189 priv
->rtllib
->eRFPowerState
= eRfOn
;
1191 priv
->txpower_checkcnt
= 0;
1192 priv
->thermal_readback_index
= 0;
1193 priv
->txpower_tracking_callback_cnt
= 0;
1194 priv
->ccktxpower_adjustcnt_ch14
= 0;
1195 priv
->ccktxpower_adjustcnt_not_ch14
= 0;
1197 priv
->rtllib
->current_network
.beacon_interval
= DEFAULT_BEACONINTERVAL
;
1198 priv
->rtllib
->iw_mode
= IW_MODE_INFRA
;
1199 priv
->rtllib
->active_scan
= 1;
1200 priv
->rtllib
->be_scan_inprogress
= false;
1201 priv
->rtllib
->modulation
= RTLLIB_CCK_MODULATION
|
1202 RTLLIB_OFDM_MODULATION
;
1203 priv
->rtllib
->host_encrypt
= 1;
1204 priv
->rtllib
->host_decrypt
= 1;
1206 priv
->rtllib
->dot11PowerSaveMode
= eActive
;
1207 priv
->rtllib
->fts
= DEFAULT_FRAG_THRESHOLD
;
1208 priv
->rtllib
->MaxMssDensity
= 0;
1209 priv
->rtllib
->MinSpaceCfg
= 0;
1211 priv
->card_type
= PCI
;
1213 priv
->AcmControl
= 0;
1214 priv
->pFirmware
= vzalloc(sizeof(struct rt_firmware
));
1215 if (!priv
->pFirmware
)
1216 printk(KERN_ERR
"rtl8193e: Unable to allocate space "
1219 skb_queue_head_init(&priv
->rx_queue
);
1220 skb_queue_head_init(&priv
->skb_queue
);
1222 for (i
= 0; i
< MAX_QUEUE_SIZE
; i
++)
1223 skb_queue_head_init(&priv
->rtllib
->skb_waitQ
[i
]);
1224 for (i
= 0; i
< MAX_QUEUE_SIZE
; i
++)
1225 skb_queue_head_init(&priv
->rtllib
->skb_aggQ
[i
]);
1228 static void rtl8192_init_priv_lock(struct r8192_priv
*priv
)
1230 spin_lock_init(&priv
->fw_scan_lock
);
1231 spin_lock_init(&priv
->tx_lock
);
1232 spin_lock_init(&priv
->irq_lock
);
1233 spin_lock_init(&priv
->irq_th_lock
);
1234 spin_lock_init(&priv
->rf_ps_lock
);
1235 spin_lock_init(&priv
->ps_lock
);
1236 spin_lock_init(&priv
->rf_lock
);
1237 spin_lock_init(&priv
->rt_h2c_lock
);
1238 sema_init(&priv
->wx_sem
, 1);
1239 sema_init(&priv
->rf_sem
, 1);
1240 mutex_init(&priv
->mutex
);
1243 static void rtl8192_init_priv_task(struct net_device
*dev
)
1245 struct r8192_priv
*priv
= rtllib_priv(dev
);
1247 priv
->priv_wq
= create_workqueue(DRV_NAME
);
1248 INIT_WORK_RSL(&priv
->reset_wq
, (void *)rtl8192_restart
, dev
);
1249 INIT_WORK_RSL(&priv
->rtllib
->ips_leave_wq
, (void *)IPSLeave_wq
, dev
);
1250 INIT_DELAYED_WORK_RSL(&priv
->watch_dog_wq
,
1251 (void *)rtl819x_watchdog_wqcallback
, dev
);
1252 INIT_DELAYED_WORK_RSL(&priv
->txpower_tracking_wq
,
1253 (void *)dm_txpower_trackingcallback
, dev
);
1254 INIT_DELAYED_WORK_RSL(&priv
->rfpath_check_wq
,
1255 (void *)dm_rf_pathcheck_workitemcallback
, dev
);
1256 INIT_DELAYED_WORK_RSL(&priv
->update_beacon_wq
,
1257 (void *)rtl8192_update_beacon
, dev
);
1258 INIT_WORK_RSL(&priv
->qos_activate
, (void *)rtl8192_qos_activate
, dev
);
1259 INIT_DELAYED_WORK_RSL(&priv
->rtllib
->hw_wakeup_wq
,
1260 (void *) rtl8192_hw_wakeup_wq
, dev
);
1261 INIT_DELAYED_WORK_RSL(&priv
->rtllib
->hw_sleep_wq
,
1262 (void *) rtl8192_hw_sleep_wq
, dev
);
1263 tasklet_init(&priv
->irq_rx_tasklet
,
1264 (void(*)(unsigned long))rtl8192_irq_rx_tasklet
,
1265 (unsigned long)priv
);
1266 tasklet_init(&priv
->irq_tx_tasklet
,
1267 (void(*)(unsigned long))rtl8192_irq_tx_tasklet
,
1268 (unsigned long)priv
);
1269 tasklet_init(&priv
->irq_prepare_beacon_tasklet
,
1270 (void(*)(unsigned long))rtl8192_prepare_beacon
,
1271 (unsigned long)priv
);
1274 static short rtl8192_get_channel_map(struct net_device
*dev
)
1278 struct r8192_priv
*priv
= rtllib_priv(dev
);
1279 if ((priv
->rf_chip
!= RF_8225
) && (priv
->rf_chip
!= RF_8256
)
1280 && (priv
->rf_chip
!= RF_6052
)) {
1281 RT_TRACE(COMP_ERR
, "%s: unknown rf chip, can't set channel "
1286 if (priv
->ChannelPlan
> COUNTRY_CODE_MAX
) {
1287 printk(KERN_INFO
"rtl819x_init:Error channel plan! Set to "
1289 priv
->ChannelPlan
= COUNTRY_CODE_FCC
;
1291 RT_TRACE(COMP_INIT
, "Channel plan is %d\n", priv
->ChannelPlan
);
1292 Dot11d_Init(priv
->rtllib
);
1293 Dot11d_Channelmap(priv
->ChannelPlan
, priv
->rtllib
);
1294 for (i
= 1; i
<= 11; i
++)
1295 (priv
->rtllib
->active_channel_map
)[i
] = 1;
1296 (priv
->rtllib
->active_channel_map
)[12] = 2;
1297 (priv
->rtllib
->active_channel_map
)[13] = 2;
1302 static short rtl8192_init(struct net_device
*dev
)
1304 struct r8192_priv
*priv
= rtllib_priv(dev
);
1306 memset(&(priv
->stats
), 0, sizeof(struct rt_stats
));
1308 rtl8192_dbgp_flag_init(dev
);
1309 rtl8192_init_priv_handler(dev
);
1310 rtl8192_init_priv_constant(dev
);
1311 rtl8192_init_priv_variable(dev
);
1312 rtl8192_init_priv_lock(priv
);
1313 rtl8192_init_priv_task(dev
);
1314 priv
->ops
->get_eeprom_size(dev
);
1315 priv
->ops
->init_adapter_variable(dev
);
1316 rtl8192_get_channel_map(dev
);
1320 init_timer(&priv
->watch_dog_timer
);
1321 setup_timer(&priv
->watch_dog_timer
,
1322 watch_dog_timer_callback
,
1323 (unsigned long) dev
);
1325 init_timer(&priv
->gpio_polling_timer
);
1326 setup_timer(&priv
->gpio_polling_timer
,
1327 check_rfctrl_gpio_timer
,
1328 (unsigned long)dev
);
1330 rtl8192_irq_disable(dev
);
1331 if (request_irq(dev
->irq
, (void *)rtl8192_interrupt_rsl
, IRQF_SHARED
,
1333 printk(KERN_ERR
"Error allocating IRQ %d", dev
->irq
);
1336 priv
->irq
= dev
->irq
;
1337 RT_TRACE(COMP_INIT
, "IRQ %d\n", dev
->irq
);
1340 if (rtl8192_pci_initdescring(dev
) != 0) {
1341 printk(KERN_ERR
"Endopoints initialization failed");
1342 free_irq(dev
->irq
, dev
);
1349 /***************************************************************************
1350 -------------------------------WATCHDOG STUFF---------------------------
1351 ***************************************************************************/
1352 short rtl8192_is_tx_queue_empty(struct net_device
*dev
)
1355 struct r8192_priv
*priv
= rtllib_priv(dev
);
1356 for (i
= 0; i
<= MGNT_QUEUE
; i
++) {
1357 if ((i
== TXCMD_QUEUE
) || (i
== HCCA_QUEUE
))
1359 if (skb_queue_len(&(&priv
->tx_ring
[i
])->queue
) > 0) {
1360 printk(KERN_INFO
"===>tx queue is not empty:%d, %d\n",
1361 i
, skb_queue_len(&(&priv
->tx_ring
[i
])->queue
));
1368 static enum reset_type
rtl819x_TxCheckStuck(struct net_device
*dev
)
1370 struct r8192_priv
*priv
= rtllib_priv(dev
);
1372 u8 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
1373 bool bCheckFwTxCnt
= false;
1374 struct rtl8192_tx_ring
*ring
= NULL
;
1375 struct sk_buff
*skb
= NULL
;
1376 struct cb_desc
*tcb_desc
= NULL
;
1377 unsigned long flags
= 0;
1379 switch (priv
->rtllib
->ps
) {
1380 case RTLLIB_PS_DISABLED
:
1381 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_NORMAL
;
1383 case (RTLLIB_PS_MBCAST
|RTLLIB_PS_UNICAST
):
1384 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
1387 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
1390 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
1391 for (QueueID
= 0; QueueID
< MAX_TX_QUEUE
; QueueID
++) {
1392 if (QueueID
== TXCMD_QUEUE
)
1395 if (QueueID
== BEACON_QUEUE
)
1398 ring
= &priv
->tx_ring
[QueueID
];
1400 if (skb_queue_len(&ring
->queue
) == 0) {
1403 skb
= (&ring
->queue
)->next
;
1404 tcb_desc
= (struct cb_desc
*)(skb
->cb
+
1406 tcb_desc
->nStuckCount
++;
1407 bCheckFwTxCnt
= true;
1408 if (tcb_desc
->nStuckCount
> 1)
1409 printk(KERN_INFO
"%s: QueueID=%d tcb_desc->n"
1410 "StuckCount=%d\n", __func__
, QueueID
,
1411 tcb_desc
->nStuckCount
);
1414 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
1416 if (bCheckFwTxCnt
) {
1417 if (priv
->ops
->TxCheckStuckHandler(dev
)) {
1418 RT_TRACE(COMP_RESET
, "TxCheckStuck(): Fw indicates no"
1419 " Tx condition!\n");
1420 return RESET_TYPE_SILENT
;
1424 return RESET_TYPE_NORESET
;
1427 static enum reset_type
rtl819x_RxCheckStuck(struct net_device
*dev
)
1429 struct r8192_priv
*priv
= rtllib_priv(dev
);
1431 if (priv
->ops
->RxCheckStuckHandler(dev
)) {
1432 RT_TRACE(COMP_RESET
, "RxStuck Condition\n");
1433 return RESET_TYPE_SILENT
;
1436 return RESET_TYPE_NORESET
;
1439 static enum reset_type
rtl819x_ifcheck_resetornot(struct net_device
*dev
)
1441 struct r8192_priv
*priv
= rtllib_priv(dev
);
1442 enum reset_type TxResetType
= RESET_TYPE_NORESET
;
1443 enum reset_type RxResetType
= RESET_TYPE_NORESET
;
1444 enum rt_rf_power_state rfState
;
1446 rfState
= priv
->rtllib
->eRFPowerState
;
1448 if (rfState
== eRfOn
)
1449 TxResetType
= rtl819x_TxCheckStuck(dev
);
1451 if (rfState
== eRfOn
&&
1452 (priv
->rtllib
->iw_mode
== IW_MODE_INFRA
) &&
1453 (priv
->rtllib
->state
== RTLLIB_LINKED
))
1454 RxResetType
= rtl819x_RxCheckStuck(dev
);
1456 if (TxResetType
== RESET_TYPE_NORMAL
||
1457 RxResetType
== RESET_TYPE_NORMAL
) {
1458 printk(KERN_INFO
"%s(): TxResetType is %d, RxResetType is %d\n",
1459 __func__
, TxResetType
, RxResetType
);
1460 return RESET_TYPE_NORMAL
;
1461 } else if (TxResetType
== RESET_TYPE_SILENT
||
1462 RxResetType
== RESET_TYPE_SILENT
) {
1463 printk(KERN_INFO
"%s(): TxResetType is %d, RxResetType is %d\n",
1464 __func__
, TxResetType
, RxResetType
);
1465 return RESET_TYPE_SILENT
;
1467 return RESET_TYPE_NORESET
;
1472 static void rtl819x_silentreset_mesh_bk(struct net_device
*dev
, u8 IsPortal
)
1476 static void rtl819x_ifsilentreset(struct net_device
*dev
)
1478 struct r8192_priv
*priv
= rtllib_priv(dev
);
1480 int reset_status
= 0;
1481 struct rtllib_device
*ieee
= priv
->rtllib
;
1487 if (priv
->ResetProgress
== RESET_TYPE_NORESET
) {
1489 RT_TRACE(COMP_RESET
, "=========>Reset progress!!\n");
1491 priv
->ResetProgress
= RESET_TYPE_SILENT
;
1493 spin_lock_irqsave(&priv
->rf_ps_lock
, flag
);
1494 if (priv
->RFChangeInProgress
) {
1495 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flag
);
1498 priv
->RFChangeInProgress
= true;
1499 priv
->bResetInProgress
= true;
1500 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flag
);
1504 down(&priv
->wx_sem
);
1506 if (priv
->rtllib
->state
== RTLLIB_LINKED
)
1507 LeisurePSLeave(dev
);
1509 if (IS_NIC_DOWN(priv
)) {
1510 RT_TRACE(COMP_ERR
, "%s():the driver is not up! "
1511 "return\n", __func__
);
1517 RT_TRACE(COMP_RESET
, "%s():======>start to down the driver\n",
1520 RT_TRACE(COMP_RESET
, "%s():111111111111111111111111======>start"
1521 " to down the driver\n", __func__
);
1523 if (!netif_queue_stopped(dev
))
1524 netif_stop_queue(dev
);
1526 rtl8192_irq_disable(dev
);
1527 del_timer_sync(&priv
->watch_dog_timer
);
1528 rtl8192_cancel_deferred_work(priv
);
1530 rtllib_stop_scan_syncro(ieee
);
1532 if (ieee
->state
== RTLLIB_LINKED
) {
1533 SEM_DOWN_IEEE_WX(&ieee
->wx_sem
);
1534 printk(KERN_INFO
"ieee->state is RTLLIB_LINKED\n");
1535 rtllib_stop_send_beacons(priv
->rtllib
);
1536 del_timer_sync(&ieee
->associate_timer
);
1537 cancel_delayed_work(&ieee
->associate_retry_wq
);
1538 rtllib_stop_scan(ieee
);
1539 netif_carrier_off(dev
);
1540 SEM_UP_IEEE_WX(&ieee
->wx_sem
);
1542 printk(KERN_INFO
"ieee->state is NOT LINKED\n");
1543 rtllib_softmac_stop_protocol(priv
->rtllib
, 0 , true);
1546 dm_backup_dynamic_mechanism_state(dev
);
1549 RT_TRACE(COMP_RESET
, "%s():<==========down process is "
1550 "finished\n", __func__
);
1552 RT_TRACE(COMP_RESET
, "%s():<===========up process start\n",
1554 reset_status
= _rtl8192_up(dev
, true);
1556 RT_TRACE(COMP_RESET
, "%s():<===========up process is "
1557 "finished\n", __func__
);
1558 if (reset_status
== -1) {
1559 if (reset_times
< 3) {
1563 RT_TRACE(COMP_ERR
, " ERR!!! %s(): Reset "
1564 "Failed!!\n", __func__
);
1568 ieee
->is_silent_reset
= 1;
1570 spin_lock_irqsave(&priv
->rf_ps_lock
, flag
);
1571 priv
->RFChangeInProgress
= false;
1572 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flag
);
1574 EnableHWSecurityConfig8192(dev
);
1576 if (ieee
->state
== RTLLIB_LINKED
&& ieee
->iw_mode
==
1578 ieee
->set_chan(ieee
->dev
,
1579 ieee
->current_network
.channel
);
1581 queue_work_rsl(ieee
->wq
, &ieee
->associate_complete_wq
);
1583 } else if (ieee
->state
== RTLLIB_LINKED
&& ieee
->iw_mode
==
1585 ieee
->set_chan(ieee
->dev
,
1586 ieee
->current_network
.channel
);
1587 ieee
->link_change(ieee
->dev
);
1589 notify_wx_assoc_event(ieee
);
1591 rtllib_start_send_beacons(ieee
);
1593 if (ieee
->data_hard_resume
)
1594 ieee
->data_hard_resume(ieee
->dev
);
1595 netif_carrier_on(ieee
->dev
);
1596 } else if (ieee
->iw_mode
== IW_MODE_MESH
) {
1597 rtl819x_silentreset_mesh_bk(dev
, IsPortal
);
1600 CamRestoreAllEntry(dev
);
1601 dm_restore_dynamic_mechanism_state(dev
);
1603 priv
->ResetProgress
= RESET_TYPE_NORESET
;
1604 priv
->reset_count
++;
1606 priv
->bForcedSilentReset
= false;
1607 priv
->bResetInProgress
= false;
1609 write_nic_byte(dev
, UFWP
, 1);
1610 RT_TRACE(COMP_RESET
, "Reset finished!! ====>[%d]\n",
1615 static void rtl819x_update_rxcounts(struct r8192_priv
*priv
, u32
*TotalRxBcnNum
,
1616 u32
*TotalRxDataNum
)
1622 *TotalRxDataNum
= 0;
1624 SlotIndex
= (priv
->rtllib
->LinkDetectInfo
.SlotIndex
++) %
1625 (priv
->rtllib
->LinkDetectInfo
.SlotNum
);
1626 priv
->rtllib
->LinkDetectInfo
.RxBcnNum
[SlotIndex
] =
1627 priv
->rtllib
->LinkDetectInfo
.NumRecvBcnInPeriod
;
1628 priv
->rtllib
->LinkDetectInfo
.RxDataNum
[SlotIndex
] =
1629 priv
->rtllib
->LinkDetectInfo
.NumRecvDataInPeriod
;
1630 for (i
= 0; i
< priv
->rtllib
->LinkDetectInfo
.SlotNum
; i
++) {
1631 *TotalRxBcnNum
+= priv
->rtllib
->LinkDetectInfo
.RxBcnNum
[i
];
1632 *TotalRxDataNum
+= priv
->rtllib
->LinkDetectInfo
.RxDataNum
[i
];
1637 void rtl819x_watchdog_wqcallback(void *data
)
1639 struct r8192_priv
*priv
= container_of_dwork_rsl(data
,
1640 struct r8192_priv
, watch_dog_wq
);
1641 struct net_device
*dev
= priv
->rtllib
->dev
;
1642 struct rtllib_device
*ieee
= priv
->rtllib
;
1643 enum reset_type ResetType
= RESET_TYPE_NORESET
;
1644 static u8 check_reset_cnt
;
1645 unsigned long flags
;
1646 struct rt_pwr_save_ctrl
*pPSC
= (struct rt_pwr_save_ctrl
*)
1647 (&(priv
->rtllib
->PowerSaveControl
));
1648 bool bBusyTraffic
= false;
1649 bool bHigherBusyTraffic
= false;
1650 bool bHigherBusyRxTraffic
= false;
1651 bool bEnterPS
= false;
1653 if (IS_NIC_DOWN(priv
) || (priv
->bHwRadioOff
== true))
1656 if (priv
->rtllib
->state
>= RTLLIB_LINKED
) {
1657 if (priv
->rtllib
->CntAfterLink
< 2)
1658 priv
->rtllib
->CntAfterLink
++;
1660 priv
->rtllib
->CntAfterLink
= 0;
1663 hal_dm_watchdog(dev
);
1665 if (rtllib_act_scanning(priv
->rtllib
, false) == false) {
1666 if ((ieee
->iw_mode
== IW_MODE_INFRA
) && (ieee
->state
==
1668 (ieee
->eRFPowerState
== eRfOn
) && !ieee
->is_set_key
&&
1669 (!ieee
->proto_stoppping
) && !ieee
->wx_set_enc
) {
1670 if ((ieee
->PowerSaveControl
.ReturnPoint
==
1671 IPS_CALLBACK_NONE
) &&
1672 (!ieee
->bNetPromiscuousMode
)) {
1673 RT_TRACE(COMP_PS
, "====================>haha: "
1679 if ((ieee
->state
== RTLLIB_LINKED
) && (ieee
->iw_mode
==
1680 IW_MODE_INFRA
) && (!ieee
->bNetPromiscuousMode
)) {
1681 if (ieee
->LinkDetectInfo
.NumRxOkInPeriod
> 100 ||
1682 ieee
->LinkDetectInfo
.NumTxOkInPeriod
> 100)
1683 bBusyTraffic
= true;
1686 if (ieee
->LinkDetectInfo
.NumRxOkInPeriod
> 4000 ||
1687 ieee
->LinkDetectInfo
.NumTxOkInPeriod
> 4000) {
1688 bHigherBusyTraffic
= true;
1689 if (ieee
->LinkDetectInfo
.NumRxOkInPeriod
> 5000)
1690 bHigherBusyRxTraffic
= true;
1692 bHigherBusyRxTraffic
= false;
1695 if (((ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
+
1696 ieee
->LinkDetectInfo
.NumTxOkInPeriod
) > 8) ||
1697 (ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
> 2))
1702 if (ieee
->current_network
.beacon_interval
< 95)
1706 LeisurePSEnter(dev
);
1708 LeisurePSLeave(dev
);
1711 RT_TRACE(COMP_LPS
, "====>no link LPS leave\n");
1712 LeisurePSLeave(dev
);
1715 ieee
->LinkDetectInfo
.NumRxOkInPeriod
= 0;
1716 ieee
->LinkDetectInfo
.NumTxOkInPeriod
= 0;
1717 ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
= 0;
1718 ieee
->LinkDetectInfo
.bBusyTraffic
= bBusyTraffic
;
1720 ieee
->LinkDetectInfo
.bHigherBusyTraffic
= bHigherBusyTraffic
;
1721 ieee
->LinkDetectInfo
.bHigherBusyRxTraffic
= bHigherBusyRxTraffic
;
1723 if (ieee
->state
== RTLLIB_LINKED
&& ieee
->iw_mode
== IW_MODE_INFRA
) {
1724 u32 TotalRxBcnNum
= 0;
1725 u32 TotalRxDataNum
= 0;
1727 rtl819x_update_rxcounts(priv
, &TotalRxBcnNum
, &TotalRxDataNum
);
1729 if ((TotalRxBcnNum
+TotalRxDataNum
) == 0)
1730 priv
->check_roaming_cnt
++;
1732 priv
->check_roaming_cnt
= 0;
1735 if (priv
->check_roaming_cnt
> 0) {
1736 if (ieee
->eRFPowerState
== eRfOff
)
1737 RT_TRACE(COMP_ERR
, "========>%s()\n", __func__
);
1739 printk(KERN_INFO
"===>%s(): AP is power off, chan:%d,"
1740 " connect another one\n", __func__
, priv
->chan
);
1742 ieee
->state
= RTLLIB_ASSOCIATING
;
1744 RemovePeerTS(priv
->rtllib
,
1745 priv
->rtllib
->current_network
.bssid
);
1746 ieee
->is_roaming
= true;
1747 ieee
->is_set_key
= false;
1748 ieee
->link_change(dev
);
1749 if (ieee
->LedControlHandler
)
1750 ieee
->LedControlHandler(ieee
->dev
,
1751 LED_CTL_START_TO_LINK
);
1753 notify_wx_assoc_event(ieee
);
1755 if (!(ieee
->rtllib_ap_sec_type(ieee
) &
1756 (SEC_ALG_CCMP
|SEC_ALG_TKIP
)))
1757 queue_delayed_work_rsl(ieee
->wq
,
1758 &ieee
->associate_procedure_wq
, 0);
1760 priv
->check_roaming_cnt
= 0;
1762 ieee
->LinkDetectInfo
.NumRecvBcnInPeriod
= 0;
1763 ieee
->LinkDetectInfo
.NumRecvDataInPeriod
= 0;
1767 spin_lock_irqsave(&priv
->tx_lock
, flags
);
1768 if ((check_reset_cnt
++ >= 3) && (!ieee
->is_roaming
) &&
1769 (!priv
->RFChangeInProgress
) && (!pPSC
->bSwRfProcessing
)) {
1770 ResetType
= rtl819x_ifcheck_resetornot(dev
);
1771 check_reset_cnt
= 3;
1773 spin_unlock_irqrestore(&priv
->tx_lock
, flags
);
1775 if (!priv
->bDisableNormalResetCheck
&& ResetType
== RESET_TYPE_NORMAL
) {
1776 priv
->ResetProgress
= RESET_TYPE_NORMAL
;
1777 RT_TRACE(COMP_RESET
, "%s(): NOMAL RESET\n", __func__
);
1781 if (((priv
->force_reset
) || (!priv
->bDisableNormalResetCheck
&&
1782 ResetType
== RESET_TYPE_SILENT
)))
1783 rtl819x_ifsilentreset(dev
);
1784 priv
->force_reset
= false;
1785 priv
->bForcedSilentReset
= false;
1786 priv
->bResetInProgress
= false;
1787 RT_TRACE(COMP_TRACE
, " <==RtUsbCheckForHangWorkItemCallback()\n");
1790 void watch_dog_timer_callback(unsigned long data
)
1792 struct r8192_priv
*priv
= rtllib_priv((struct net_device
*)data
);
1793 queue_delayed_work_rsl(priv
->priv_wq
, &priv
->watch_dog_wq
, 0);
1794 mod_timer(&priv
->watch_dog_timer
, jiffies
+
1795 MSECS(RTLLIB_WATCH_DOG_TIME
));
1798 /****************************************************************************
1799 ---------------------------- NIC TX/RX STUFF---------------------------
1800 *****************************************************************************/
1801 void rtl8192_rx_enable(struct net_device
*dev
)
1803 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1804 priv
->ops
->rx_enable(dev
);
1807 void rtl8192_tx_enable(struct net_device
*dev
)
1809 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1811 priv
->ops
->tx_enable(dev
);
1813 rtllib_reset_queue(priv
->rtllib
);
1817 static void rtl8192_free_rx_ring(struct net_device
*dev
)
1819 struct r8192_priv
*priv
= rtllib_priv(dev
);
1820 int i
, rx_queue_idx
;
1822 for (rx_queue_idx
= 0; rx_queue_idx
< MAX_RX_QUEUE
;
1824 for (i
= 0; i
< priv
->rxringcount
; i
++) {
1825 struct sk_buff
*skb
= priv
->rx_buf
[rx_queue_idx
][i
];
1829 pci_unmap_single(priv
->pdev
,
1830 *((dma_addr_t
*)skb
->cb
),
1831 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
1835 pci_free_consistent(priv
->pdev
,
1836 sizeof(*priv
->rx_ring
[rx_queue_idx
]) *
1838 priv
->rx_ring
[rx_queue_idx
],
1839 priv
->rx_ring_dma
[rx_queue_idx
]);
1840 priv
->rx_ring
[rx_queue_idx
] = NULL
;
1844 static void rtl8192_free_tx_ring(struct net_device
*dev
, unsigned int prio
)
1846 struct r8192_priv
*priv
= rtllib_priv(dev
);
1847 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
1849 while (skb_queue_len(&ring
->queue
)) {
1850 struct tx_desc
*entry
= &ring
->desc
[ring
->idx
];
1851 struct sk_buff
*skb
= __skb_dequeue(&ring
->queue
);
1853 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
1854 skb
->len
, PCI_DMA_TODEVICE
);
1856 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
1859 pci_free_consistent(priv
->pdev
, sizeof(*ring
->desc
)*ring
->entries
,
1860 ring
->desc
, ring
->dma
);
1864 void rtl8192_data_hard_stop(struct net_device
*dev
)
1869 void rtl8192_data_hard_resume(struct net_device
*dev
)
1873 void rtl8192_hard_data_xmit(struct sk_buff
*skb
, struct net_device
*dev
,
1876 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1878 struct cb_desc
*tcb_desc
= (struct cb_desc
*)(skb
->cb
+
1880 u8 queue_index
= tcb_desc
->queue_index
;
1882 if ((priv
->rtllib
->eRFPowerState
== eRfOff
) || IS_NIC_DOWN(priv
) ||
1883 priv
->bResetInProgress
) {
1888 assert(queue_index
!= TXCMD_QUEUE
);
1891 memcpy((unsigned char *)(skb
->cb
), &dev
, sizeof(dev
));
1892 skb_push(skb
, priv
->rtllib
->tx_headroom
);
1893 ret
= rtl8192_tx(dev
, skb
);
1898 if (queue_index
!= MGNT_QUEUE
) {
1899 priv
->rtllib
->stats
.tx_bytes
+= (skb
->len
-
1900 priv
->rtllib
->tx_headroom
);
1901 priv
->rtllib
->stats
.tx_packets
++;
1908 int rtl8192_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1910 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1912 struct cb_desc
*tcb_desc
= (struct cb_desc
*)(skb
->cb
+
1914 u8 queue_index
= tcb_desc
->queue_index
;
1916 if (queue_index
!= TXCMD_QUEUE
) {
1917 if ((priv
->rtllib
->eRFPowerState
== eRfOff
) ||
1918 IS_NIC_DOWN(priv
) || priv
->bResetInProgress
) {
1924 memcpy((unsigned char *)(skb
->cb
), &dev
, sizeof(dev
));
1925 if (queue_index
== TXCMD_QUEUE
) {
1926 rtl8192_tx_cmd(dev
, skb
);
1930 tcb_desc
->RATRIndex
= 7;
1931 tcb_desc
->bTxDisableRateFallBack
= 1;
1932 tcb_desc
->bTxUseDriverAssingedRate
= 1;
1933 tcb_desc
->bTxEnableFwCalcDur
= 1;
1934 skb_push(skb
, priv
->rtllib
->tx_headroom
);
1935 ret
= rtl8192_tx(dev
, skb
);
1947 static void rtl8192_tx_isr(struct net_device
*dev
, int prio
)
1949 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1951 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
1953 while (skb_queue_len(&ring
->queue
)) {
1954 struct tx_desc
*entry
= &ring
->desc
[ring
->idx
];
1955 struct sk_buff
*skb
;
1957 if (prio
!= BEACON_QUEUE
) {
1960 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
1963 skb
= __skb_dequeue(&ring
->queue
);
1964 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
1965 skb
->len
, PCI_DMA_TODEVICE
);
1969 if (prio
!= BEACON_QUEUE
)
1970 tasklet_schedule(&priv
->irq_tx_tasklet
);
1973 void rtl8192_tx_cmd(struct net_device
*dev
, struct sk_buff
*skb
)
1975 struct r8192_priv
*priv
= rtllib_priv(dev
);
1976 struct rtl8192_tx_ring
*ring
;
1977 struct tx_desc_cmd
*entry
;
1979 struct cb_desc
*tcb_desc
;
1980 unsigned long flags
;
1982 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
1983 ring
= &priv
->tx_ring
[TXCMD_QUEUE
];
1985 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
1986 entry
= (struct tx_desc_cmd
*) &ring
->desc
[idx
];
1988 tcb_desc
= (struct cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
1990 priv
->ops
->tx_fill_cmd_descriptor(dev
, entry
, tcb_desc
, skb
);
1992 __skb_queue_tail(&ring
->queue
, skb
);
1993 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
1998 short rtl8192_tx(struct net_device
*dev
, struct sk_buff
*skb
)
2000 struct r8192_priv
*priv
= rtllib_priv(dev
);
2001 struct rtl8192_tx_ring
*ring
;
2002 unsigned long flags
;
2003 struct cb_desc
*tcb_desc
= (struct cb_desc
*)(skb
->cb
+
2005 struct tx_desc
*pdesc
= NULL
;
2006 struct rtllib_hdr_1addr
*header
= NULL
;
2007 u16 fc
= 0, type
= 0, stype
= 0;
2008 bool multi_addr
= false, broad_addr
= false, uni_addr
= false;
2009 u8
*pda_addr
= NULL
;
2011 u32 fwinfo_size
= 0;
2013 if (priv
->bdisable_nic
) {
2014 RT_TRACE(COMP_ERR
, "%s: ERR!! Nic is disabled! Can't tx packet"
2015 " len=%d qidx=%d!!!\n", __func__
, skb
->len
,
2016 tcb_desc
->queue_index
);
2020 priv
->rtllib
->bAwakePktSent
= true;
2022 fwinfo_size
= sizeof(struct tx_fwinfo_8190pci
);
2024 header
= (struct rtllib_hdr_1addr
*)(((u8
*)skb
->data
) + fwinfo_size
);
2025 fc
= header
->frame_ctl
;
2026 type
= WLAN_FC_GET_TYPE(fc
);
2027 stype
= WLAN_FC_GET_STYPE(fc
);
2028 pda_addr
= header
->addr1
;
2030 if (is_multicast_ether_addr(pda_addr
))
2032 else if (is_broadcast_ether_addr(pda_addr
))
2038 priv
->stats
.txbytesunicast
+= skb
->len
- fwinfo_size
;
2039 else if (multi_addr
)
2040 priv
->stats
.txbytesmulticast
+= skb
->len
- fwinfo_size
;
2042 priv
->stats
.txbytesbroadcast
+= skb
->len
- fwinfo_size
;
2044 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
2045 ring
= &priv
->tx_ring
[tcb_desc
->queue_index
];
2046 if (tcb_desc
->queue_index
!= BEACON_QUEUE
)
2047 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
2051 pdesc
= &ring
->desc
[idx
];
2052 if ((pdesc
->OWN
== 1) && (tcb_desc
->queue_index
!= BEACON_QUEUE
)) {
2053 RT_TRACE(COMP_ERR
, "No more TX desc@%d, ring->idx = %d, idx = "
2054 "%d, skblen = 0x%x queuelen=%d",
2055 tcb_desc
->queue_index
, ring
->idx
, idx
, skb
->len
,
2056 skb_queue_len(&ring
->queue
));
2057 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2061 if (type
== RTLLIB_FTYPE_DATA
) {
2062 if (priv
->rtllib
->LedControlHandler
)
2063 priv
->rtllib
->LedControlHandler(dev
, LED_CTL_TX
);
2065 priv
->ops
->tx_fill_descriptor(dev
, pdesc
, tcb_desc
, skb
);
2066 __skb_queue_tail(&ring
->queue
, skb
);
2068 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2069 dev
->trans_start
= jiffies
;
2071 write_nic_word(dev
, TPPoll
, 0x01 << tcb_desc
->queue_index
);
2075 static short rtl8192_alloc_rx_desc_ring(struct net_device
*dev
)
2077 struct r8192_priv
*priv
= rtllib_priv(dev
);
2078 struct rx_desc
*entry
= NULL
;
2079 int i
, rx_queue_idx
;
2081 for (rx_queue_idx
= 0; rx_queue_idx
< MAX_RX_QUEUE
; rx_queue_idx
++) {
2082 priv
->rx_ring
[rx_queue_idx
] = pci_alloc_consistent(priv
->pdev
,
2083 sizeof(*priv
->rx_ring
[rx_queue_idx
]) *
2085 &priv
->rx_ring_dma
[rx_queue_idx
]);
2087 if (!priv
->rx_ring
[rx_queue_idx
] ||
2088 (unsigned long)priv
->rx_ring
[rx_queue_idx
] & 0xFF) {
2089 RT_TRACE(COMP_ERR
, "Cannot allocate RX ring\n");
2093 memset(priv
->rx_ring
[rx_queue_idx
], 0,
2094 sizeof(*priv
->rx_ring
[rx_queue_idx
]) *
2096 priv
->rx_idx
[rx_queue_idx
] = 0;
2098 for (i
= 0; i
< priv
->rxringcount
; i
++) {
2099 struct sk_buff
*skb
= dev_alloc_skb(priv
->rxbuffersize
);
2100 dma_addr_t
*mapping
;
2101 entry
= &priv
->rx_ring
[rx_queue_idx
][i
];
2105 priv
->rx_buf
[rx_queue_idx
][i
] = skb
;
2106 mapping
= (dma_addr_t
*)skb
->cb
;
2107 *mapping
= pci_map_single(priv
->pdev
,
2108 skb_tail_pointer_rsl(skb
),
2110 PCI_DMA_FROMDEVICE
);
2112 entry
->BufferAddress
= cpu_to_le32(*mapping
);
2114 entry
->Length
= priv
->rxbuffersize
;
2124 static int rtl8192_alloc_tx_desc_ring(struct net_device
*dev
,
2125 unsigned int prio
, unsigned int entries
)
2127 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2128 struct tx_desc
*ring
;
2132 ring
= pci_alloc_consistent(priv
->pdev
, sizeof(*ring
) * entries
, &dma
);
2133 if (!ring
|| (unsigned long)ring
& 0xFF) {
2134 RT_TRACE(COMP_ERR
, "Cannot allocate TX ring (prio = %d)\n",
2139 memset(ring
, 0, sizeof(*ring
)*entries
);
2140 priv
->tx_ring
[prio
].desc
= ring
;
2141 priv
->tx_ring
[prio
].dma
= dma
;
2142 priv
->tx_ring
[prio
].idx
= 0;
2143 priv
->tx_ring
[prio
].entries
= entries
;
2144 skb_queue_head_init(&priv
->tx_ring
[prio
].queue
);
2146 for (i
= 0; i
< entries
; i
++)
2147 ring
[i
].NextDescAddress
=
2148 cpu_to_le32((u32
)dma
+ ((i
+ 1) % entries
) *
2155 short rtl8192_pci_initdescring(struct net_device
*dev
)
2159 struct r8192_priv
*priv
= rtllib_priv(dev
);
2161 ret
= rtl8192_alloc_rx_desc_ring(dev
);
2165 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
2166 ret
= rtl8192_alloc_tx_desc_ring(dev
, i
, priv
->txringcount
);
2168 goto err_free_rings
;
2174 rtl8192_free_rx_ring(dev
);
2175 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
2176 if (priv
->tx_ring
[i
].desc
)
2177 rtl8192_free_tx_ring(dev
, i
);
2181 void rtl8192_pci_resetdescring(struct net_device
*dev
)
2183 struct r8192_priv
*priv
= rtllib_priv(dev
);
2184 int i
, rx_queue_idx
;
2185 unsigned long flags
= 0;
2187 for (rx_queue_idx
= 0; rx_queue_idx
< MAX_RX_QUEUE
; rx_queue_idx
++) {
2188 if (priv
->rx_ring
[rx_queue_idx
]) {
2189 struct rx_desc
*entry
= NULL
;
2190 for (i
= 0; i
< priv
->rxringcount
; i
++) {
2191 entry
= &priv
->rx_ring
[rx_queue_idx
][i
];
2194 priv
->rx_idx
[rx_queue_idx
] = 0;
2198 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
2199 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
2200 if (priv
->tx_ring
[i
].desc
) {
2201 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[i
];
2203 while (skb_queue_len(&ring
->queue
)) {
2204 struct tx_desc
*entry
= &ring
->desc
[ring
->idx
];
2205 struct sk_buff
*skb
=
2206 __skb_dequeue(&ring
->queue
);
2208 pci_unmap_single(priv
->pdev
,
2209 le32_to_cpu(entry
->TxBuffAddr
),
2210 skb
->len
, PCI_DMA_TODEVICE
);
2212 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
2217 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2220 void rtl819x_UpdateRxPktTimeStamp(struct net_device
*dev
,
2221 struct rtllib_rx_stats
*stats
)
2223 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2225 if (stats
->bIsAMPDU
&& !stats
->bFirstMPDU
)
2226 stats
->mac_time
= priv
->LastRxDescTSF
;
2228 priv
->LastRxDescTSF
= stats
->mac_time
;
2231 long rtl819x_translate_todbm(struct r8192_priv
*priv
, u8 signal_strength_index
)
2235 signal_power
= (long)((signal_strength_index
+ 1) >> 1);
2238 return signal_power
;
2243 rtl819x_update_rxsignalstatistics8190pci(
2244 struct r8192_priv
*priv
,
2245 struct rtllib_rx_stats
*pprevious_stats
2251 if (priv
->stats
.recv_signal_power
== 0)
2252 priv
->stats
.recv_signal_power
=
2253 pprevious_stats
->RecvSignalPower
;
2255 if (pprevious_stats
->RecvSignalPower
> priv
->stats
.recv_signal_power
)
2257 else if (pprevious_stats
->RecvSignalPower
<
2258 priv
->stats
.recv_signal_power
)
2260 priv
->stats
.recv_signal_power
= (priv
->stats
.recv_signal_power
* 5 +
2261 pprevious_stats
->RecvSignalPower
+
2265 void rtl819x_process_cck_rxpathsel(struct r8192_priv
*priv
,
2266 struct rtllib_rx_stats
*pprevious_stats
)
2271 u8
rtl819x_query_rxpwrpercentage(char antpower
)
2273 if ((antpower
<= -100) || (antpower
>= 20))
2275 else if (antpower
>= 0)
2278 return 100 + antpower
;
2280 } /* QueryRxPwrPercentage */
2283 rtl819x_evm_dbtopercentage(
2295 ret_val
= 0 - ret_val
;
2303 rtl8192_record_rxdesc_forlateruse(
2304 struct rtllib_rx_stats
*psrc_stats
,
2305 struct rtllib_rx_stats
*ptarget_stats
2308 ptarget_stats
->bIsAMPDU
= psrc_stats
->bIsAMPDU
;
2309 ptarget_stats
->bFirstMPDU
= psrc_stats
->bFirstMPDU
;
2314 static void rtl8192_rx_normal(struct net_device
*dev
)
2316 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2317 struct rtllib_hdr_1addr
*rtllib_hdr
= NULL
;
2318 bool unicast_packet
= false;
2319 bool bLedBlinking
= true;
2320 u16 fc
= 0, type
= 0;
2322 int rx_queue_idx
= RX_MPDU_QUEUE
;
2324 struct rtllib_rx_stats stats
= {
2328 .freq
= RTLLIB_24GHZ_BAND
,
2330 unsigned int count
= priv
->rxringcount
;
2332 stats
.nic_type
= NIC_8192E
;
2335 struct rx_desc
*pdesc
= &priv
->rx_ring
[rx_queue_idx
]
2336 [priv
->rx_idx
[rx_queue_idx
]];
2337 struct sk_buff
*skb
= priv
->rx_buf
[rx_queue_idx
]
2338 [priv
->rx_idx
[rx_queue_idx
]];
2343 struct sk_buff
*new_skb
;
2345 if (!priv
->ops
->rx_query_status_descriptor(dev
, &stats
,
2348 new_skb
= dev_alloc_skb(priv
->rxbuffersize
);
2349 /* if allocation of new skb failed - drop current packet
2351 if (unlikely(!new_skb
))
2354 pci_unmap_single(priv
->pdev
,
2355 *((dma_addr_t
*)skb
->cb
),
2357 PCI_DMA_FROMDEVICE
);
2359 skb_put(skb
, pdesc
->Length
);
2360 skb_reserve(skb
, stats
.RxDrvInfoSize
+
2362 skb_trim(skb
, skb
->len
- 4/*sCrcLng*/);
2363 rtllib_hdr
= (struct rtllib_hdr_1addr
*)skb
->data
;
2364 if (!is_broadcast_ether_addr(rtllib_hdr
->addr1
) &&
2365 !is_multicast_ether_addr(rtllib_hdr
->addr1
)) {
2366 /* unicast packet */
2367 unicast_packet
= true;
2369 fc
= le16_to_cpu(rtllib_hdr
->frame_ctl
);
2370 type
= WLAN_FC_GET_TYPE(fc
);
2371 if (type
== RTLLIB_FTYPE_MGMT
)
2372 bLedBlinking
= false;
2375 if (priv
->rtllib
->LedControlHandler
)
2376 priv
->rtllib
->LedControlHandler(dev
,
2380 if (type
!= RTLLIB_FTYPE_MGMT
)
2381 priv
->stats
.rxdatacrcerr
++;
2383 priv
->stats
.rxmgmtcrcerr
++;
2388 if (!rtllib_rx(priv
->rtllib
, skb
, &stats
)) {
2389 dev_kfree_skb_any(skb
);
2393 priv
->stats
.rxbytesunicast
+= skb_len
;
2399 priv
->rx_buf
[rx_queue_idx
][priv
->rx_idx
[rx_queue_idx
]] =
2401 *((dma_addr_t
*) skb
->cb
) = pci_map_single(priv
->pdev
,
2402 skb_tail_pointer_rsl(skb
),
2404 PCI_DMA_FROMDEVICE
);
2408 pdesc
->BufferAddress
= cpu_to_le32(*((dma_addr_t
*)skb
->cb
));
2410 pdesc
->Length
= priv
->rxbuffersize
;
2411 if (priv
->rx_idx
[rx_queue_idx
] == priv
->rxringcount
-1)
2413 priv
->rx_idx
[rx_queue_idx
] = (priv
->rx_idx
[rx_queue_idx
] + 1) %
2419 static void rtl8192_rx_cmd(struct net_device
*dev
)
2424 static void rtl8192_tx_resume(struct net_device
*dev
)
2426 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2427 struct rtllib_device
*ieee
= priv
->rtllib
;
2428 struct sk_buff
*skb
;
2431 for (queue_index
= BK_QUEUE
;
2432 queue_index
< MAX_QUEUE_SIZE
; queue_index
++) {
2433 while ((!skb_queue_empty(&ieee
->skb_waitQ
[queue_index
])) &&
2434 (priv
->rtllib
->check_nic_enough_desc(dev
, queue_index
) > 0)) {
2435 skb
= skb_dequeue(&ieee
->skb_waitQ
[queue_index
]);
2436 ieee
->softmac_data_hard_start_xmit(skb
, dev
, 0);
2441 void rtl8192_irq_tx_tasklet(struct r8192_priv
*priv
)
2443 rtl8192_tx_resume(priv
->rtllib
->dev
);
2446 void rtl8192_irq_rx_tasklet(struct r8192_priv
*priv
)
2448 rtl8192_rx_normal(priv
->rtllib
->dev
);
2450 if (MAX_RX_QUEUE
> 1)
2451 rtl8192_rx_cmd(priv
->rtllib
->dev
);
2453 write_nic_dword(priv
->rtllib
->dev
, INTA_MASK
,
2454 read_nic_dword(priv
->rtllib
->dev
, INTA_MASK
) | IMR_RDU
);
2457 /****************************************************************************
2458 ---------------------------- NIC START/CLOSE STUFF---------------------------
2459 *****************************************************************************/
2460 void rtl8192_cancel_deferred_work(struct r8192_priv
*priv
)
2462 cancel_delayed_work(&priv
->watch_dog_wq
);
2463 cancel_delayed_work(&priv
->update_beacon_wq
);
2464 cancel_delayed_work(&priv
->rtllib
->hw_sleep_wq
);
2465 cancel_work_sync(&priv
->reset_wq
);
2466 cancel_work_sync(&priv
->qos_activate
);
2469 int _rtl8192_up(struct net_device
*dev
, bool is_silent_reset
)
2471 if (_rtl8192_sta_up(dev
, is_silent_reset
) == -1)
2477 static int rtl8192_open(struct net_device
*dev
)
2479 struct r8192_priv
*priv
= rtllib_priv(dev
);
2482 down(&priv
->wx_sem
);
2483 ret
= rtl8192_up(dev
);
2490 int rtl8192_up(struct net_device
*dev
)
2492 struct r8192_priv
*priv
= rtllib_priv(dev
);
2496 return _rtl8192_up(dev
, false);
2500 static int rtl8192_close(struct net_device
*dev
)
2502 struct r8192_priv
*priv
= rtllib_priv(dev
);
2505 if ((rtllib_act_scanning(priv
->rtllib
, false)) &&
2506 !(priv
->rtllib
->softmac_features
& IEEE_SOFTMAC_SCAN
)) {
2507 rtllib_stop_scan(priv
->rtllib
);
2510 down(&priv
->wx_sem
);
2512 ret
= rtl8192_down(dev
, true);
2520 int rtl8192_down(struct net_device
*dev
, bool shutdownrf
)
2522 if (rtl8192_sta_down(dev
, shutdownrf
) == -1)
2528 void rtl8192_commit(struct net_device
*dev
)
2530 struct r8192_priv
*priv
= rtllib_priv(dev
);
2534 rtllib_softmac_stop_protocol(priv
->rtllib
, 0 , true);
2535 rtl8192_irq_disable(dev
);
2536 priv
->ops
->stop_adapter(dev
, true);
2537 _rtl8192_up(dev
, false);
2540 void rtl8192_restart(void *data
)
2542 struct r8192_priv
*priv
= container_of_work_rsl(data
, struct r8192_priv
,
2544 struct net_device
*dev
= priv
->rtllib
->dev
;
2546 down(&priv
->wx_sem
);
2548 rtl8192_commit(dev
);
2553 static void r8192_set_multicast(struct net_device
*dev
)
2555 struct r8192_priv
*priv
= rtllib_priv(dev
);
2558 promisc
= (dev
->flags
& IFF_PROMISC
) ? 1 : 0;
2559 priv
->promisc
= promisc
;
2564 static int r8192_set_mac_adr(struct net_device
*dev
, void *mac
)
2566 struct r8192_priv
*priv
= rtllib_priv(dev
);
2567 struct sockaddr
*addr
= mac
;
2569 down(&priv
->wx_sem
);
2571 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
2573 schedule_work(&priv
->reset_wq
);
2579 /* based on ipw2200 driver */
2580 static int rtl8192_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
2582 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2583 struct iwreq
*wrq
= (struct iwreq
*)rq
;
2585 struct rtllib_device
*ieee
= priv
->rtllib
;
2587 u8 broadcast_addr
[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
2588 u8 zero_addr
[6] = {0};
2589 struct iw_point
*p
= &wrq
->u
.data
;
2590 struct ieee_param
*ipw
= NULL
;
2592 down(&priv
->wx_sem
);
2595 case RTL_IOCTL_WPA_SUPPLICANT
:
2596 if (p
->length
< sizeof(struct ieee_param
) || !p
->pointer
) {
2601 ipw
= kmalloc(p
->length
, GFP_KERNEL
);
2606 if (copy_from_user(ipw
, p
->pointer
, p
->length
)) {
2612 if (ipw
->cmd
== IEEE_CMD_SET_ENCRYPTION
) {
2613 if (ipw
->u
.crypt
.set_tx
) {
2614 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
2615 ieee
->pairwise_key_type
= KEY_TYPE_CCMP
;
2616 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
2617 ieee
->pairwise_key_type
= KEY_TYPE_TKIP
;
2618 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0) {
2619 if (ipw
->u
.crypt
.key_len
== 13)
2620 ieee
->pairwise_key_type
=
2622 else if (ipw
->u
.crypt
.key_len
== 5)
2623 ieee
->pairwise_key_type
=
2626 ieee
->pairwise_key_type
= KEY_TYPE_NA
;
2629 if (ieee
->pairwise_key_type
) {
2630 if (memcmp(ieee
->ap_mac_addr
, zero_addr
,
2632 ieee
->iw_mode
= IW_MODE_ADHOC
;
2633 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
2634 EnableHWSecurityConfig8192(dev
);
2635 set_swcam(dev
, 4, ipw
->u
.crypt
.idx
,
2636 ieee
->pairwise_key_type
,
2637 (u8
*)ieee
->ap_mac_addr
,
2639 setKey(dev
, 4, ipw
->u
.crypt
.idx
,
2640 ieee
->pairwise_key_type
,
2641 (u8
*)ieee
->ap_mac_addr
, 0, key
);
2642 if (ieee
->iw_mode
== IW_MODE_ADHOC
) {
2643 set_swcam(dev
, ipw
->u
.crypt
.idx
,
2645 ieee
->pairwise_key_type
,
2646 (u8
*)ieee
->ap_mac_addr
,
2648 setKey(dev
, ipw
->u
.crypt
.idx
,
2650 ieee
->pairwise_key_type
,
2651 (u8
*)ieee
->ap_mac_addr
,
2655 if ((ieee
->pairwise_key_type
== KEY_TYPE_CCMP
)
2656 && ieee
->pHTInfo
->bCurrentHTSupport
) {
2657 write_nic_byte(dev
, 0x173, 1);
2661 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
2662 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
2663 ieee
->group_key_type
= KEY_TYPE_CCMP
;
2664 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
2665 ieee
->group_key_type
= KEY_TYPE_TKIP
;
2666 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0) {
2667 if (ipw
->u
.crypt
.key_len
== 13)
2668 ieee
->group_key_type
=
2670 else if (ipw
->u
.crypt
.key_len
== 5)
2671 ieee
->group_key_type
=
2674 ieee
->group_key_type
= KEY_TYPE_NA
;
2676 if (ieee
->group_key_type
) {
2677 set_swcam(dev
, ipw
->u
.crypt
.idx
,
2679 ieee
->group_key_type
,
2680 broadcast_addr
, 0, key
, 0);
2681 setKey(dev
, ipw
->u
.crypt
.idx
,
2683 ieee
->group_key_type
,
2684 broadcast_addr
, 0, key
);
2689 ret
= rtllib_wpa_supplicant_ioctl(priv
->rtllib
, &wrq
->u
.data
,
2705 irqreturn_type
rtl8192_interrupt(int irq
, void *netdev
, struct pt_regs
*regs
)
2707 struct net_device
*dev
= (struct net_device
*) netdev
;
2708 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2709 unsigned long flags
;
2714 if (priv
->irq_enabled
== 0)
2717 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
2719 priv
->ops
->interrupt_recognized(dev
, &inta
, &intb
);
2720 priv
->stats
.shints
++;
2723 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2727 if (inta
== 0xffff) {
2728 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2734 if (!netif_running(dev
)) {
2735 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2739 if (inta
& IMR_TBDOK
) {
2740 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
2741 priv
->stats
.txbeaconokint
++;
2744 if (inta
& IMR_TBDER
) {
2745 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
2746 priv
->stats
.txbeaconerr
++;
2749 if (inta
& IMR_BDOK
)
2750 RT_TRACE(COMP_INTR
, "beacon interrupt!\n");
2752 if (inta
& IMR_MGNTDOK
) {
2753 RT_TRACE(COMP_INTR
, "Manage ok interrupt!\n");
2754 priv
->stats
.txmanageokint
++;
2755 rtl8192_tx_isr(dev
, MGNT_QUEUE
);
2756 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2757 if (priv
->rtllib
->ack_tx_to_ieee
) {
2758 if (rtl8192_is_tx_queue_empty(dev
)) {
2759 priv
->rtllib
->ack_tx_to_ieee
= 0;
2760 rtllib_ps_tx_ack(priv
->rtllib
, 1);
2763 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
2766 if (inta
& IMR_COMDOK
) {
2767 priv
->stats
.txcmdpktokint
++;
2768 rtl8192_tx_isr(dev
, TXCMD_QUEUE
);
2771 if (inta
& IMR_HIGHDOK
)
2772 rtl8192_tx_isr(dev
, HIGH_QUEUE
);
2774 if (inta
& IMR_ROK
) {
2775 priv
->stats
.rxint
++;
2776 priv
->InterruptLog
.nIMR_ROK
++;
2777 tasklet_schedule(&priv
->irq_rx_tasklet
);
2780 if (inta
& IMR_BcnInt
) {
2781 RT_TRACE(COMP_INTR
, "prepare beacon for interrupt!\n");
2782 tasklet_schedule(&priv
->irq_prepare_beacon_tasklet
);
2785 if (inta
& IMR_RDU
) {
2786 RT_TRACE(COMP_INTR
, "rx descriptor unavailable!\n");
2787 priv
->stats
.rxrdu
++;
2788 write_nic_dword(dev
, INTA_MASK
,
2789 read_nic_dword(dev
, INTA_MASK
) & ~IMR_RDU
);
2790 tasklet_schedule(&priv
->irq_rx_tasklet
);
2793 if (inta
& IMR_RXFOVW
) {
2794 RT_TRACE(COMP_INTR
, "rx overflow !\n");
2795 priv
->stats
.rxoverflow
++;
2796 tasklet_schedule(&priv
->irq_rx_tasklet
);
2799 if (inta
& IMR_TXFOVW
)
2800 priv
->stats
.txoverflow
++;
2802 if (inta
& IMR_BKDOK
) {
2803 RT_TRACE(COMP_INTR
, "BK Tx OK interrupt!\n");
2804 priv
->stats
.txbkokint
++;
2805 priv
->rtllib
->LinkDetectInfo
.NumTxOkInPeriod
++;
2806 rtl8192_tx_isr(dev
, BK_QUEUE
);
2809 if (inta
& IMR_BEDOK
) {
2810 RT_TRACE(COMP_INTR
, "BE TX OK interrupt!\n");
2811 priv
->stats
.txbeokint
++;
2812 priv
->rtllib
->LinkDetectInfo
.NumTxOkInPeriod
++;
2813 rtl8192_tx_isr(dev
, BE_QUEUE
);
2816 if (inta
& IMR_VIDOK
) {
2817 RT_TRACE(COMP_INTR
, "VI TX OK interrupt!\n");
2818 priv
->stats
.txviokint
++;
2819 priv
->rtllib
->LinkDetectInfo
.NumTxOkInPeriod
++;
2820 rtl8192_tx_isr(dev
, VI_QUEUE
);
2823 if (inta
& IMR_VODOK
) {
2824 priv
->stats
.txvookint
++;
2825 RT_TRACE(COMP_INTR
, "Vo TX OK interrupt!\n");
2826 priv
->rtllib
->LinkDetectInfo
.NumTxOkInPeriod
++;
2827 rtl8192_tx_isr(dev
, VO_QUEUE
);
2830 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2839 /****************************************************************************
2840 ---------------------------- PCI_STUFF---------------------------
2841 *****************************************************************************/
2842 #ifdef HAVE_NET_DEVICE_OPS
2843 static const struct net_device_ops rtl8192_netdev_ops
= {
2844 .ndo_open
= rtl8192_open
,
2845 .ndo_stop
= rtl8192_close
,
2846 .ndo_tx_timeout
= rtl8192_tx_timeout
,
2847 .ndo_do_ioctl
= rtl8192_ioctl
,
2848 .ndo_set_rx_mode
= r8192_set_multicast
,
2849 .ndo_set_mac_address
= r8192_set_mac_adr
,
2850 .ndo_validate_addr
= eth_validate_addr
,
2851 .ndo_change_mtu
= eth_change_mtu
,
2852 .ndo_start_xmit
= rtllib_xmit
,
2856 static int __devinit
rtl8192_pci_probe(struct pci_dev
*pdev
,
2857 const struct pci_device_id
*id
)
2859 unsigned long ioaddr
= 0;
2860 struct net_device
*dev
= NULL
;
2861 struct r8192_priv
*priv
= NULL
;
2862 struct rtl819x_ops
*ops
= (struct rtl819x_ops
*)(id
->driver_data
);
2863 unsigned long pmem_start
, pmem_len
, pmem_flags
;
2865 bool bdma64
= false;
2868 RT_TRACE(COMP_INIT
, "Configuring chip resources");
2870 if (pci_enable_device(pdev
)) {
2871 RT_TRACE(COMP_ERR
, "Failed to enable PCI device");
2875 pci_set_master(pdev
);
2877 if (!pci_set_dma_mask(pdev
, DMA_BIT_MASK(32))) {
2878 if (pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32))) {
2879 printk(KERN_INFO
"Unable to obtain 32bit DMA for consistent allocations\n");
2880 goto err_pci_disable
;
2883 dev
= alloc_rtllib(sizeof(struct r8192_priv
));
2885 goto err_pci_disable
;
2889 dev
->features
|= NETIF_F_HIGHDMA
;
2891 pci_set_drvdata(pdev
, dev
);
2892 SET_NETDEV_DEV(dev
, &pdev
->dev
);
2893 priv
= rtllib_priv(dev
);
2894 priv
->rtllib
= (struct rtllib_device
*)netdev_priv_rsl(dev
);
2896 priv
->rtllib
->pdev
= pdev
;
2897 if ((pdev
->subsystem_vendor
== PCI_VENDOR_ID_DLINK
) &&
2898 (pdev
->subsystem_device
== 0x3304))
2899 priv
->rtllib
->bSupportRemoteWakeUp
= 1;
2901 priv
->rtllib
->bSupportRemoteWakeUp
= 0;
2903 pmem_start
= pci_resource_start(pdev
, 1);
2904 pmem_len
= pci_resource_len(pdev
, 1);
2905 pmem_flags
= pci_resource_flags(pdev
, 1);
2907 if (!(pmem_flags
& IORESOURCE_MEM
)) {
2908 RT_TRACE(COMP_ERR
, "region #1 not a MMIO resource, aborting");
2909 goto err_rel_rtllib
;
2912 printk(KERN_INFO
"Memory mapped space start: 0x%08lx\n", pmem_start
);
2913 if (!request_mem_region(pmem_start
, pmem_len
, DRV_NAME
)) {
2914 RT_TRACE(COMP_ERR
, "request_mem_region failed!");
2915 goto err_rel_rtllib
;
2919 ioaddr
= (unsigned long)ioremap_nocache(pmem_start
, pmem_len
);
2920 if (ioaddr
== (unsigned long)NULL
) {
2921 RT_TRACE(COMP_ERR
, "ioremap failed!");
2925 dev
->mem_start
= ioaddr
;
2926 dev
->mem_end
= ioaddr
+ pci_resource_len(pdev
, 0);
2928 pci_read_config_byte(pdev
, 0x08, &revision_id
);
2929 /* If the revisionid is 0x10, the device uses rtl8192se. */
2930 if (pdev
->device
== 0x8192 && revision_id
== 0x10)
2935 if (rtl8192_pci_findadapter(pdev
, dev
) == false)
2938 dev
->irq
= pdev
->irq
;
2941 #ifdef HAVE_NET_DEVICE_OPS
2942 dev
->netdev_ops
= &rtl8192_netdev_ops
;
2944 dev
->open
= rtl8192_open
;
2945 dev
->stop
= rtl8192_close
;
2946 dev
->tx_timeout
= rtl8192_tx_timeout
;
2947 dev
->do_ioctl
= rtl8192_ioctl
;
2948 dev
->set_multicast_list
= r8192_set_multicast
;
2949 dev
->set_mac_address
= r8192_set_mac_adr
;
2950 dev
->hard_start_xmit
= rtllib_xmit
;
2953 dev
->wireless_handlers
= (struct iw_handler_def
*)
2954 &r8192_wx_handlers_def
;
2955 dev
->ethtool_ops
= &rtl819x_ethtool_ops
;
2957 dev
->type
= ARPHRD_ETHER
;
2958 dev
->watchdog_timeo
= HZ
* 3;
2960 if (dev_alloc_name(dev
, ifname
) < 0) {
2961 RT_TRACE(COMP_INIT
, "Oops: devname already taken! Trying "
2963 dev_alloc_name(dev
, ifname
);
2966 RT_TRACE(COMP_INIT
, "Driver probe completed1\n");
2967 if (rtl8192_init(dev
) != 0) {
2968 RT_TRACE(COMP_ERR
, "Initialization failed");
2972 netif_carrier_off(dev
);
2973 netif_stop_queue(dev
);
2975 register_netdev(dev
);
2976 RT_TRACE(COMP_INIT
, "dev name: %s\n", dev
->name
);
2977 err
= rtl_debug_module_init(priv
, dev
->name
);
2979 RT_TRACE(COMP_DBG
, "failed to create debugfs files. Ignoring "
2980 "error: %d\n", err
);
2981 rtl8192_proc_init_one(dev
);
2983 if (priv
->polling_timer_on
== 0)
2984 check_rfctrl_gpio_timer((unsigned long)dev
);
2986 RT_TRACE(COMP_INIT
, "Driver probe completed\n");
2990 free_irq(dev
->irq
, dev
);
2993 release_mem_region(pmem_start
, pmem_len
);
2997 DMESG("wlan driver load failed\n");
2998 pci_set_drvdata(pdev
, NULL
);
3000 pci_disable_device(pdev
);
3004 static void __devexit
rtl8192_pci_disconnect(struct pci_dev
*pdev
)
3006 struct net_device
*dev
= pci_get_drvdata(pdev
);
3007 struct r8192_priv
*priv
;
3011 unregister_netdev(dev
);
3013 priv
= rtllib_priv(dev
);
3015 del_timer_sync(&priv
->gpio_polling_timer
);
3016 cancel_delayed_work(&priv
->gpio_change_rf_wq
);
3017 priv
->polling_timer_on
= 0;
3018 rtl_debug_module_remove(priv
);
3019 rtl8192_proc_remove_one(dev
);
3020 rtl8192_down(dev
, true);
3022 if (priv
->pFirmware
) {
3023 vfree(priv
->pFirmware
);
3024 priv
->pFirmware
= NULL
;
3026 destroy_workqueue(priv
->priv_wq
);
3027 rtl8192_free_rx_ring(dev
);
3028 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
3029 rtl8192_free_tx_ring(dev
, i
);
3032 printk(KERN_INFO
"Freeing irq %d\n", dev
->irq
);
3033 free_irq(dev
->irq
, dev
);
3038 kfree(priv
->scan_cmd
);
3040 if (dev
->mem_start
!= 0) {
3041 iounmap((void __iomem
*)dev
->mem_start
);
3042 release_mem_region(pci_resource_start(pdev
, 1),
3043 pci_resource_len(pdev
, 1));
3046 priv
= rtllib_priv(dev
);
3049 pci_disable_device(pdev
);
3050 RT_TRACE(COMP_DOWN
, "wlan driver removed\n");
3053 bool NicIFEnableNIC(struct net_device
*dev
)
3055 bool init_status
= true;
3056 struct r8192_priv
*priv
= rtllib_priv(dev
);
3057 struct rt_pwr_save_ctrl
*pPSC
= (struct rt_pwr_save_ctrl
*)
3058 (&(priv
->rtllib
->PowerSaveControl
));
3060 if (IS_NIC_DOWN(priv
)) {
3061 RT_TRACE(COMP_ERR
, "ERR!!! %s(): Driver is already down!\n",
3063 priv
->bdisable_nic
= false;
3064 return RT_STATUS_FAILURE
;
3067 RT_TRACE(COMP_PS
, "===========>%s()\n", __func__
);
3068 priv
->bfirst_init
= true;
3069 init_status
= priv
->ops
->initialize_adapter(dev
);
3070 if (init_status
!= true) {
3071 RT_TRACE(COMP_ERR
, "ERR!!! %s(): initialization is failed!\n",
3073 priv
->bdisable_nic
= false;
3076 RT_TRACE(COMP_INIT
, "start adapter finished\n");
3077 RT_CLEAR_PS_LEVEL(pPSC
, RT_RF_OFF_LEVL_HALT_NIC
);
3078 priv
->bfirst_init
= false;
3080 rtl8192_irq_enable(dev
);
3081 priv
->bdisable_nic
= false;
3082 RT_TRACE(COMP_PS
, "<===========%s()\n", __func__
);
3085 bool NicIFDisableNIC(struct net_device
*dev
)
3088 struct r8192_priv
*priv
= rtllib_priv(dev
);
3090 RT_TRACE(COMP_PS
, "=========>%s()\n", __func__
);
3091 priv
->bdisable_nic
= true;
3092 tmp_state
= priv
->rtllib
->state
;
3093 rtllib_softmac_stop_protocol(priv
->rtllib
, 0, false);
3094 priv
->rtllib
->state
= tmp_state
;
3095 rtl8192_cancel_deferred_work(priv
);
3096 rtl8192_irq_disable(dev
);
3098 priv
->ops
->stop_adapter(dev
, false);
3099 RT_TRACE(COMP_PS
, "<=========%s()\n", __func__
);
3104 static int __init
rtl8192_pci_module_init(void)
3109 ret
= rtllib_init();
3111 printk(KERN_ERR
"rtllib_init() failed %d\n", ret
);
3114 ret
= rtllib_crypto_init();
3116 printk(KERN_ERR
"rtllib_crypto_init() failed %d\n", ret
);
3119 ret
= rtllib_crypto_tkip_init();
3121 printk(KERN_ERR
"rtllib_crypto_tkip_init() failed %d\n", ret
);
3124 ret
= rtllib_crypto_ccmp_init();
3126 printk(KERN_ERR
"rtllib_crypto_ccmp_init() failed %d\n", ret
);
3129 ret
= rtllib_crypto_wep_init();
3131 printk(KERN_ERR
"rtllib_crypto_wep_init() failed %d\n", ret
);
3134 printk(KERN_INFO
"\nLinux kernel driver for RTL8192E WLAN cards\n");
3135 printk(KERN_INFO
"Copyright (c) 2007-2008, Realsil Wlan Driver\n");
3137 error
= rtl_create_debugfs_root();
3139 RT_TRACE(COMP_DBG
, "Create debugfs root fail: %d\n", error
);
3143 rtl8192_proc_module_init();
3144 if (0 != pci_register_driver(&rtl8192_pci_driver
)) {
3145 DMESG("No device found");
3146 /*pci_unregister_driver (&rtl8192_pci_driver);*/
3155 static void __exit
rtl8192_pci_module_exit(void)
3157 pci_unregister_driver(&rtl8192_pci_driver
);
3159 RT_TRACE(COMP_DOWN
, "Exiting");
3160 rtl8192_proc_module_remove();
3161 rtl_remove_debugfs_root();
3162 rtllib_crypto_tkip_exit();
3163 rtllib_crypto_ccmp_exit();
3164 rtllib_crypto_wep_exit();
3165 rtllib_crypto_deinit();
3169 void check_rfctrl_gpio_timer(unsigned long data
)
3171 struct r8192_priv
*priv
= rtllib_priv((struct net_device
*)data
);
3173 priv
->polling_timer_on
= 1;
3175 queue_delayed_work_rsl(priv
->priv_wq
, &priv
->gpio_change_rf_wq
, 0);
3177 mod_timer(&priv
->gpio_polling_timer
, jiffies
+
3178 MSECS(RTLLIB_WATCH_DOG_TIME
));
3181 /***************************************************************************
3182 ------------------- module init / exit stubs ----------------
3183 ****************************************************************************/
3184 module_init(rtl8192_pci_module_init
);
3185 module_exit(rtl8192_pci_module_exit
);
3187 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
3188 MODULE_AUTHOR(DRV_COPYRIGHT
" " DRV_AUTHOR
);
3189 MODULE_VERSION(DRV_VERSION
);
3190 MODULE_LICENSE("GPL");
3192 module_param(ifname
, charp
, S_IRUGO
|S_IWUSR
);
3193 module_param(hwwep
, int, S_IRUGO
|S_IWUSR
);
3194 module_param(channels
, int, S_IRUGO
|S_IWUSR
);
3196 MODULE_PARM_DESC(ifname
, " Net interface name, wlan%d=default");
3197 MODULE_PARM_DESC(hwwep
, " Try to use hardware WEP support(default use hw. set 0 to use software security)");
3198 MODULE_PARM_DESC(channels
, " Channel bitmask for specific locales. NYI");