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
;
603 mutex_lock(&priv
->mutex
);
604 if (priv
->rtllib
->state
!= RTLLIB_LINKED
)
606 RT_TRACE(COMP_QOS
, "qos active process with associate response "
609 for (i
= 0; i
< QOS_QUEUE_NUM
; i
++) {
610 priv
->rtllib
->SetHwRegHandler(dev
, HW_VAR_AC_PARAM
, (u8
*)(&i
));
614 mutex_unlock(&priv
->mutex
);
617 static int rtl8192_qos_handle_probe_response(struct r8192_priv
*priv
,
619 struct rtllib_network
*network
)
622 u32 size
= sizeof(struct rtllib_qos_parameters
);
624 if (priv
->rtllib
->state
!= RTLLIB_LINKED
)
627 if ((priv
->rtllib
->iw_mode
!= IW_MODE_INFRA
))
630 if (network
->flags
& NETWORK_HAS_QOS_MASK
) {
631 if (active_network
&&
632 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
))
633 network
->qos_data
.active
= network
->qos_data
.supported
;
635 if ((network
->qos_data
.active
== 1) && (active_network
== 1) &&
636 (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) &&
637 (network
->qos_data
.old_param_count
!=
638 network
->qos_data
.param_count
)) {
639 network
->qos_data
.old_param_count
=
640 network
->qos_data
.param_count
;
641 priv
->rtllib
->wmm_acm
= network
->qos_data
.wmm_acm
;
642 queue_work_rsl(priv
->priv_wq
, &priv
->qos_activate
);
643 RT_TRACE(COMP_QOS
, "QoS parameters change call "
647 memcpy(&priv
->rtllib
->current_network
.qos_data
.parameters
,
648 &def_qos_parameters
, size
);
650 if ((network
->qos_data
.active
== 1) && (active_network
== 1)) {
651 queue_work_rsl(priv
->priv_wq
, &priv
->qos_activate
);
652 RT_TRACE(COMP_QOS
, "QoS was disabled call qos_"
655 network
->qos_data
.active
= 0;
656 network
->qos_data
.supported
= 0;
662 static int rtl8192_handle_beacon(struct net_device
*dev
,
663 struct rtllib_beacon
*beacon
,
664 struct rtllib_network
*network
)
666 struct r8192_priv
*priv
= rtllib_priv(dev
);
668 rtl8192_qos_handle_probe_response(priv
, 1, network
);
670 queue_delayed_work_rsl(priv
->priv_wq
, &priv
->update_beacon_wq
, 0);
675 static int rtl8192_qos_association_resp(struct r8192_priv
*priv
,
676 struct rtllib_network
*network
)
680 u32 size
= sizeof(struct rtllib_qos_parameters
);
681 int set_qos_param
= 0;
683 if ((priv
== NULL
) || (network
== NULL
))
686 if (priv
->rtllib
->state
!= RTLLIB_LINKED
)
689 if ((priv
->rtllib
->iw_mode
!= IW_MODE_INFRA
))
692 spin_lock_irqsave(&priv
->rtllib
->lock
, flags
);
693 if (network
->flags
& NETWORK_HAS_QOS_PARAMETERS
) {
694 memcpy(&priv
->rtllib
->current_network
.qos_data
.parameters
,
695 &network
->qos_data
.parameters
,
696 sizeof(struct rtllib_qos_parameters
));
697 priv
->rtllib
->current_network
.qos_data
.active
= 1;
698 priv
->rtllib
->wmm_acm
= network
->qos_data
.wmm_acm
;
700 priv
->rtllib
->current_network
.qos_data
.old_param_count
=
701 priv
->rtllib
->current_network
.qos_data
.param_count
;
702 priv
->rtllib
->current_network
.qos_data
.param_count
=
703 network
->qos_data
.param_count
;
705 memcpy(&priv
->rtllib
->current_network
.qos_data
.parameters
,
706 &def_qos_parameters
, size
);
707 priv
->rtllib
->current_network
.qos_data
.active
= 0;
708 priv
->rtllib
->current_network
.qos_data
.supported
= 0;
712 spin_unlock_irqrestore(&priv
->rtllib
->lock
, flags
);
714 RT_TRACE(COMP_QOS
, "%s: network->flags = %d,%d\n", __func__
,
715 network
->flags
, priv
->rtllib
->current_network
.qos_data
.active
);
716 if (set_qos_param
== 1) {
717 dm_init_edca_turbo(priv
->rtllib
->dev
);
718 queue_work_rsl(priv
->priv_wq
, &priv
->qos_activate
);
723 static int rtl8192_handle_assoc_response(struct net_device
*dev
,
724 struct rtllib_assoc_response_frame
*resp
,
725 struct rtllib_network
*network
)
727 struct r8192_priv
*priv
= rtllib_priv(dev
);
728 rtl8192_qos_association_resp(priv
, network
);
732 static void rtl8192_prepare_beacon(struct r8192_priv
*priv
)
734 struct net_device
*dev
= priv
->rtllib
->dev
;
735 struct sk_buff
*pskb
= NULL
, *pnewskb
= NULL
;
736 struct cb_desc
*tcb_desc
= NULL
;
737 struct rtl8192_tx_ring
*ring
= NULL
;
738 struct tx_desc
*pdesc
= NULL
;
740 ring
= &priv
->tx_ring
[BEACON_QUEUE
];
741 pskb
= __skb_dequeue(&ring
->queue
);
745 pnewskb
= rtllib_get_beacon(priv
->rtllib
);
749 tcb_desc
= (struct cb_desc
*)(pnewskb
->cb
+ 8);
750 tcb_desc
->queue_index
= BEACON_QUEUE
;
751 tcb_desc
->data_rate
= 2;
752 tcb_desc
->RATRIndex
= 7;
753 tcb_desc
->bTxDisableRateFallBack
= 1;
754 tcb_desc
->bTxUseDriverAssingedRate
= 1;
755 skb_push(pnewskb
, priv
->rtllib
->tx_headroom
);
757 pdesc
= &ring
->desc
[0];
758 priv
->ops
->tx_fill_descriptor(dev
, pdesc
, tcb_desc
, pnewskb
);
759 __skb_queue_tail(&ring
->queue
, pnewskb
);
765 static void rtl8192_stop_beacon(struct net_device
*dev
)
769 void rtl8192_config_rate(struct net_device
*dev
, u16
*rate_config
)
771 struct r8192_priv
*priv
= rtllib_priv(dev
);
772 struct rtllib_network
*net
;
773 u8 i
= 0, basic_rate
= 0;
774 net
= &priv
->rtllib
->current_network
;
776 for (i
= 0; i
< net
->rates_len
; i
++) {
777 basic_rate
= net
->rates
[i
] & 0x7f;
778 switch (basic_rate
) {
780 *rate_config
|= RRSR_1M
;
783 *rate_config
|= RRSR_2M
;
786 *rate_config
|= RRSR_5_5M
;
789 *rate_config
|= RRSR_11M
;
792 *rate_config
|= RRSR_6M
;
795 *rate_config
|= RRSR_9M
;
798 *rate_config
|= RRSR_12M
;
801 *rate_config
|= RRSR_18M
;
804 *rate_config
|= RRSR_24M
;
807 *rate_config
|= RRSR_36M
;
810 *rate_config
|= RRSR_48M
;
813 *rate_config
|= RRSR_54M
;
818 for (i
= 0; i
< net
->rates_ex_len
; i
++) {
819 basic_rate
= net
->rates_ex
[i
] & 0x7f;
820 switch (basic_rate
) {
822 *rate_config
|= RRSR_1M
;
825 *rate_config
|= RRSR_2M
;
828 *rate_config
|= RRSR_5_5M
;
831 *rate_config
|= RRSR_11M
;
834 *rate_config
|= RRSR_6M
;
837 *rate_config
|= RRSR_9M
;
840 *rate_config
|= RRSR_12M
;
843 *rate_config
|= RRSR_18M
;
846 *rate_config
|= RRSR_24M
;
849 *rate_config
|= RRSR_36M
;
852 *rate_config
|= RRSR_48M
;
855 *rate_config
|= RRSR_54M
;
861 static void rtl8192_refresh_supportrate(struct r8192_priv
*priv
)
863 struct rtllib_device
*ieee
= priv
->rtllib
;
864 if (ieee
->mode
== WIRELESS_MODE_N_24G
||
865 ieee
->mode
== WIRELESS_MODE_N_5G
) {
866 memcpy(ieee
->Regdot11HTOperationalRateSet
,
867 ieee
->RegHTSuppRateSet
, 16);
868 memcpy(ieee
->Regdot11TxHTOperationalRateSet
,
869 ieee
->RegHTSuppRateSet
, 16);
872 memset(ieee
->Regdot11HTOperationalRateSet
, 0, 16);
877 static u8
rtl8192_getSupportedWireleeMode(struct net_device
*dev
)
879 struct r8192_priv
*priv
= rtllib_priv(dev
);
882 switch (priv
->rf_chip
) {
887 ret
= (WIRELESS_MODE_N_24G
|WIRELESS_MODE_G
| WIRELESS_MODE_B
);
890 ret
= (WIRELESS_MODE_A
| WIRELESS_MODE_N_5G
);
893 ret
= WIRELESS_MODE_B
;
899 void rtl8192_SetWirelessMode(struct net_device
*dev
, u8 wireless_mode
)
901 struct r8192_priv
*priv
= rtllib_priv(dev
);
902 u8 bSupportMode
= rtl8192_getSupportedWireleeMode(dev
);
904 if ((wireless_mode
== WIRELESS_MODE_AUTO
) ||
905 ((wireless_mode
& bSupportMode
) == 0)) {
906 if (bSupportMode
& WIRELESS_MODE_N_24G
) {
907 wireless_mode
= WIRELESS_MODE_N_24G
;
908 } else if (bSupportMode
& WIRELESS_MODE_N_5G
) {
909 wireless_mode
= WIRELESS_MODE_N_5G
;
910 } else if ((bSupportMode
& WIRELESS_MODE_A
)) {
911 wireless_mode
= WIRELESS_MODE_A
;
912 } else if ((bSupportMode
& WIRELESS_MODE_G
)) {
913 wireless_mode
= WIRELESS_MODE_G
;
914 } else if ((bSupportMode
& WIRELESS_MODE_B
)) {
915 wireless_mode
= WIRELESS_MODE_B
;
917 RT_TRACE(COMP_ERR
, "%s(), No valid wireless mode "
918 "supported (%x)!!!\n", __func__
, bSupportMode
);
919 wireless_mode
= WIRELESS_MODE_B
;
923 if ((wireless_mode
& (WIRELESS_MODE_B
| WIRELESS_MODE_G
)) ==
924 (WIRELESS_MODE_G
| WIRELESS_MODE_B
))
925 wireless_mode
= WIRELESS_MODE_G
;
927 priv
->rtllib
->mode
= wireless_mode
;
929 ActUpdateChannelAccessSetting(dev
, wireless_mode
,
930 &priv
->ChannelAccessSetting
);
932 if ((wireless_mode
== WIRELESS_MODE_N_24G
) ||
933 (wireless_mode
== WIRELESS_MODE_N_5G
)) {
934 priv
->rtllib
->pHTInfo
->bEnableHT
= 1;
935 RT_TRACE(COMP_DBG
, "%s(), wireless_mode:%x, bEnableHT = 1\n",
936 __func__
, wireless_mode
);
938 priv
->rtllib
->pHTInfo
->bEnableHT
= 0;
939 RT_TRACE(COMP_DBG
, "%s(), wireless_mode:%x, bEnableHT = 0\n",
940 __func__
, wireless_mode
);
943 RT_TRACE(COMP_INIT
, "Current Wireless Mode is %x\n", wireless_mode
);
944 rtl8192_refresh_supportrate(priv
);
947 static int _rtl8192_sta_up(struct net_device
*dev
, bool is_silent_reset
)
949 struct r8192_priv
*priv
= rtllib_priv(dev
);
950 struct rt_pwr_save_ctrl
*pPSC
= (struct rt_pwr_save_ctrl
*)
951 (&(priv
->rtllib
->PowerSaveControl
));
952 bool init_status
= true;
953 priv
->bDriverIsGoingToUnload
= false;
954 priv
->bdisable_nic
= false;
957 priv
->rtllib
->ieee_up
= 1;
959 priv
->up_first_time
= 0;
960 RT_TRACE(COMP_INIT
, "Bringing up iface");
961 priv
->bfirst_init
= true;
962 init_status
= priv
->ops
->initialize_adapter(dev
);
963 if (init_status
!= true) {
964 RT_TRACE(COMP_ERR
, "ERR!!! %s(): initialization is failed!\n",
966 priv
->bfirst_init
= false;
970 RT_TRACE(COMP_INIT
, "start adapter finished\n");
971 RT_CLEAR_PS_LEVEL(pPSC
, RT_RF_OFF_LEVL_HALT_NIC
);
972 priv
->bfirst_init
= false;
974 if (priv
->polling_timer_on
== 0)
975 check_rfctrl_gpio_timer((unsigned long)dev
);
977 if (priv
->rtllib
->state
!= RTLLIB_LINKED
)
978 rtllib_softmac_start_protocol(priv
->rtllib
, 0);
979 rtllib_reset_queue(priv
->rtllib
);
980 watch_dog_timer_callback((unsigned long) dev
);
982 if (!netif_queue_stopped(dev
))
983 netif_start_queue(dev
);
985 netif_wake_queue(dev
);
990 static int rtl8192_sta_down(struct net_device
*dev
, bool shutdownrf
)
992 struct r8192_priv
*priv
= rtllib_priv(dev
);
993 unsigned long flags
= 0;
994 u8 RFInProgressTimeOut
= 0;
999 if (priv
->rtllib
->rtllib_ips_leave
!= NULL
)
1000 priv
->rtllib
->rtllib_ips_leave(dev
);
1002 if (priv
->rtllib
->state
== RTLLIB_LINKED
)
1003 LeisurePSLeave(dev
);
1005 priv
->bDriverIsGoingToUnload
= true;
1007 priv
->rtllib
->ieee_up
= 0;
1008 priv
->bfirst_after_down
= 1;
1009 RT_TRACE(COMP_DOWN
, "==========>%s()\n", __func__
);
1010 if (!netif_queue_stopped(dev
))
1011 netif_stop_queue(dev
);
1013 priv
->rtllib
->wpa_ie_len
= 0;
1014 kfree(priv
->rtllib
->wpa_ie
);
1015 priv
->rtllib
->wpa_ie
= NULL
;
1016 CamResetAllEntry(dev
);
1017 memset(priv
->rtllib
->swcamtable
, 0, sizeof(struct sw_cam_table
) * 32);
1018 rtl8192_irq_disable(dev
);
1020 del_timer_sync(&priv
->watch_dog_timer
);
1021 rtl8192_cancel_deferred_work(priv
);
1022 cancel_delayed_work(&priv
->rtllib
->hw_wakeup_wq
);
1024 rtllib_softmac_stop_protocol(priv
->rtllib
, 0, true);
1025 spin_lock_irqsave(&priv
->rf_ps_lock
, flags
);
1026 while (priv
->RFChangeInProgress
) {
1027 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flags
);
1028 if (RFInProgressTimeOut
> 100) {
1029 spin_lock_irqsave(&priv
->rf_ps_lock
, flags
);
1032 RT_TRACE(COMP_DBG
, "===>%s():RF is in progress, need to wait "
1033 "until rf chang is done.\n", __func__
);
1035 RFInProgressTimeOut
++;
1036 spin_lock_irqsave(&priv
->rf_ps_lock
, flags
);
1038 priv
->RFChangeInProgress
= true;
1039 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flags
);
1040 priv
->ops
->stop_adapter(dev
, false);
1041 spin_lock_irqsave(&priv
->rf_ps_lock
, flags
);
1042 priv
->RFChangeInProgress
= false;
1043 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flags
);
1045 memset(&priv
->rtllib
->current_network
, 0,
1046 offsetof(struct rtllib_network
, list
));
1047 RT_TRACE(COMP_DOWN
, "<==========%s()\n", __func__
);
1052 static void rtl8192_init_priv_handler(struct net_device
*dev
)
1054 struct r8192_priv
*priv
= rtllib_priv(dev
);
1056 priv
->rtllib
->softmac_hard_start_xmit
= rtl8192_hard_start_xmit
;
1057 priv
->rtllib
->set_chan
= rtl8192_set_chan
;
1058 priv
->rtllib
->link_change
= priv
->ops
->link_change
;
1059 priv
->rtllib
->softmac_data_hard_start_xmit
= rtl8192_hard_data_xmit
;
1060 priv
->rtllib
->data_hard_stop
= rtl8192_data_hard_stop
;
1061 priv
->rtllib
->data_hard_resume
= rtl8192_data_hard_resume
;
1062 priv
->rtllib
->check_nic_enough_desc
= rtl8192_check_nic_enough_desc
;
1063 priv
->rtllib
->get_nic_desc_num
= rtl8192_get_nic_desc_num
;
1064 priv
->rtllib
->handle_assoc_response
= rtl8192_handle_assoc_response
;
1065 priv
->rtllib
->handle_beacon
= rtl8192_handle_beacon
;
1066 priv
->rtllib
->SetWirelessMode
= rtl8192_SetWirelessMode
;
1067 priv
->rtllib
->LeisurePSLeave
= LeisurePSLeave
;
1068 priv
->rtllib
->SetBWModeHandler
= rtl8192_SetBWMode
;
1069 priv
->rf_set_chan
= rtl8192_phy_SwChnl
;
1071 priv
->rtllib
->start_send_beacons
= rtl8192e_start_beacon
;
1072 priv
->rtllib
->stop_send_beacons
= rtl8192_stop_beacon
;
1074 priv
->rtllib
->sta_wake_up
= rtl8192_hw_wakeup
;
1075 priv
->rtllib
->enter_sleep_state
= rtl8192_hw_to_sleep
;
1076 priv
->rtllib
->ps_is_queue_empty
= rtl8192_is_tx_queue_empty
;
1078 priv
->rtllib
->GetNmodeSupportBySecCfg
= rtl8192_GetNmodeSupportBySecCfg
;
1079 priv
->rtllib
->GetHalfNmodeSupportByAPsHandler
=
1080 rtl8192_GetHalfNmodeSupportByAPs
;
1082 priv
->rtllib
->SetHwRegHandler
= rtl8192e_SetHwReg
;
1083 priv
->rtllib
->AllowAllDestAddrHandler
= rtl8192_AllowAllDestAddr
;
1084 priv
->rtllib
->SetFwCmdHandler
= NULL
;
1085 priv
->rtllib
->InitialGainHandler
= InitialGain819xPci
;
1086 priv
->rtllib
->rtllib_ips_leave_wq
= rtllib_ips_leave_wq
;
1087 priv
->rtllib
->rtllib_ips_leave
= rtllib_ips_leave
;
1089 priv
->rtllib
->LedControlHandler
= NULL
;
1090 priv
->rtllib
->UpdateBeaconInterruptHandler
= NULL
;
1092 priv
->rtllib
->ScanOperationBackupHandler
= PHY_ScanOperationBackup8192
;
1094 priv
->rtllib
->rtllib_rfkill_poll
= NULL
;
1097 static void rtl8192_init_priv_constant(struct net_device
*dev
)
1099 struct r8192_priv
*priv
= rtllib_priv(dev
);
1100 struct rt_pwr_save_ctrl
*pPSC
= (struct rt_pwr_save_ctrl
*)
1101 &(priv
->rtllib
->PowerSaveControl
);
1103 pPSC
->RegMaxLPSAwakeIntvl
= 5;
1105 priv
->RegPciASPM
= 2;
1107 priv
->RegDevicePciASPMSetting
= 0x03;
1109 priv
->RegHostPciASPMSetting
= 0x02;
1111 priv
->RegHwSwRfOffD3
= 2;
1113 priv
->RegSupportPciASPM
= 2;
1117 static void rtl8192_init_priv_variable(struct net_device
*dev
)
1119 struct r8192_priv
*priv
= rtllib_priv(dev
);
1122 priv
->AcmMethod
= eAcmWay2_SW
;
1123 priv
->dot11CurrentPreambleMode
= PREAMBLE_AUTO
;
1124 priv
->rtllib
->hwscan_sem_up
= 1;
1125 priv
->rtllib
->status
= 0;
1126 priv
->H2CTxCmdSeq
= 0;
1127 priv
->bDisableFrameBursting
= 0;
1128 priv
->bDMInitialGainEnable
= 1;
1129 priv
->polling_timer_on
= 0;
1130 priv
->up_first_time
= 1;
1131 priv
->blinked_ingpio
= false;
1132 priv
->bDriverIsGoingToUnload
= false;
1133 priv
->being_init_adapter
= false;
1134 priv
->initialized_at_probe
= false;
1135 priv
->sw_radio_on
= true;
1136 priv
->bdisable_nic
= false;
1137 priv
->bfirst_init
= false;
1138 priv
->txringcount
= 64;
1139 priv
->rxbuffersize
= 9100;
1140 priv
->rxringcount
= MAX_RX_COUNT
;
1141 priv
->irq_enabled
= 0;
1143 priv
->RegWirelessMode
= WIRELESS_MODE_AUTO
;
1144 priv
->RegChannelPlan
= 0xf;
1145 priv
->nrxAMPDU_size
= 0;
1146 priv
->nrxAMPDU_aggr_num
= 0;
1147 priv
->last_rxdesc_tsf_high
= 0;
1148 priv
->last_rxdesc_tsf_low
= 0;
1149 priv
->rtllib
->mode
= WIRELESS_MODE_AUTO
;
1150 priv
->rtllib
->iw_mode
= IW_MODE_INFRA
;
1151 priv
->rtllib
->bNetPromiscuousMode
= false;
1152 priv
->rtllib
->IntelPromiscuousModeInfo
.bPromiscuousOn
= false;
1153 priv
->rtllib
->IntelPromiscuousModeInfo
.bFilterSourceStationFrame
=
1155 priv
->rtllib
->ieee_up
= 0;
1156 priv
->retry_rts
= DEFAULT_RETRY_RTS
;
1157 priv
->retry_data
= DEFAULT_RETRY_DATA
;
1158 priv
->rtllib
->rts
= DEFAULT_RTS_THRESHOLD
;
1159 priv
->rtllib
->rate
= 110;
1160 priv
->rtllib
->short_slot
= 1;
1161 priv
->promisc
= (dev
->flags
& IFF_PROMISC
) ? 1 : 0;
1162 priv
->bcck_in_ch14
= false;
1163 priv
->bfsync_processing
= false;
1164 priv
->CCKPresentAttentuation
= 0;
1165 priv
->rfa_txpowertrackingindex
= 0;
1166 priv
->rfc_txpowertrackingindex
= 0;
1168 priv
->ScanDelay
= 50;
1169 priv
->ResetProgress
= RESET_TYPE_NORESET
;
1170 priv
->bForcedSilentReset
= 0;
1171 priv
->bDisableNormalResetCheck
= false;
1172 priv
->force_reset
= false;
1173 memset(priv
->rtllib
->swcamtable
, 0, sizeof(struct sw_cam_table
) * 32);
1175 memset(&priv
->InterruptLog
, 0, sizeof(struct log_int_8190
));
1176 priv
->RxCounter
= 0;
1177 priv
->rtllib
->wx_set_enc
= 0;
1178 priv
->bHwRadioOff
= false;
1180 priv
->isRFOff
= false;
1181 priv
->bInPowerSaveMode
= false;
1182 priv
->rtllib
->RfOffReason
= 0;
1183 priv
->RFChangeInProgress
= false;
1184 priv
->bHwRfOffAction
= 0;
1185 priv
->SetRFPowerStateInProgress
= false;
1186 priv
->rtllib
->PowerSaveControl
.bInactivePs
= true;
1187 priv
->rtllib
->PowerSaveControl
.bIPSModeBackup
= false;
1188 priv
->rtllib
->PowerSaveControl
.bLeisurePs
= true;
1189 priv
->rtllib
->PowerSaveControl
.bFwCtrlLPS
= false;
1190 priv
->rtllib
->LPSDelayCnt
= 0;
1191 priv
->rtllib
->sta_sleep
= LPS_IS_WAKE
;
1192 priv
->rtllib
->eRFPowerState
= eRfOn
;
1194 priv
->txpower_checkcnt
= 0;
1195 priv
->thermal_readback_index
= 0;
1196 priv
->txpower_tracking_callback_cnt
= 0;
1197 priv
->ccktxpower_adjustcnt_ch14
= 0;
1198 priv
->ccktxpower_adjustcnt_not_ch14
= 0;
1200 priv
->rtllib
->current_network
.beacon_interval
= DEFAULT_BEACONINTERVAL
;
1201 priv
->rtllib
->iw_mode
= IW_MODE_INFRA
;
1202 priv
->rtllib
->active_scan
= 1;
1203 priv
->rtllib
->be_scan_inprogress
= false;
1204 priv
->rtllib
->modulation
= RTLLIB_CCK_MODULATION
|
1205 RTLLIB_OFDM_MODULATION
;
1206 priv
->rtllib
->host_encrypt
= 1;
1207 priv
->rtllib
->host_decrypt
= 1;
1209 priv
->rtllib
->dot11PowerSaveMode
= eActive
;
1210 priv
->rtllib
->fts
= DEFAULT_FRAG_THRESHOLD
;
1211 priv
->rtllib
->MaxMssDensity
= 0;
1212 priv
->rtllib
->MinSpaceCfg
= 0;
1214 priv
->card_type
= PCI
;
1216 priv
->AcmControl
= 0;
1217 priv
->pFirmware
= vzalloc(sizeof(struct rt_firmware
));
1218 if (!priv
->pFirmware
)
1219 printk(KERN_ERR
"rtl8193e: Unable to allocate space "
1222 skb_queue_head_init(&priv
->rx_queue
);
1223 skb_queue_head_init(&priv
->skb_queue
);
1225 for (i
= 0; i
< MAX_QUEUE_SIZE
; i
++)
1226 skb_queue_head_init(&priv
->rtllib
->skb_waitQ
[i
]);
1227 for (i
= 0; i
< MAX_QUEUE_SIZE
; i
++)
1228 skb_queue_head_init(&priv
->rtllib
->skb_aggQ
[i
]);
1231 static void rtl8192_init_priv_lock(struct r8192_priv
*priv
)
1233 spin_lock_init(&priv
->fw_scan_lock
);
1234 spin_lock_init(&priv
->tx_lock
);
1235 spin_lock_init(&priv
->irq_lock
);
1236 spin_lock_init(&priv
->irq_th_lock
);
1237 spin_lock_init(&priv
->rf_ps_lock
);
1238 spin_lock_init(&priv
->ps_lock
);
1239 spin_lock_init(&priv
->rf_lock
);
1240 spin_lock_init(&priv
->rt_h2c_lock
);
1241 sema_init(&priv
->wx_sem
, 1);
1242 sema_init(&priv
->rf_sem
, 1);
1243 mutex_init(&priv
->mutex
);
1246 static void rtl8192_init_priv_task(struct net_device
*dev
)
1248 struct r8192_priv
*priv
= rtllib_priv(dev
);
1250 priv
->priv_wq
= create_workqueue(DRV_NAME
);
1251 INIT_WORK_RSL(&priv
->reset_wq
, (void *)rtl8192_restart
, dev
);
1252 INIT_WORK_RSL(&priv
->rtllib
->ips_leave_wq
, (void *)IPSLeave_wq
, dev
);
1253 INIT_DELAYED_WORK_RSL(&priv
->watch_dog_wq
,
1254 (void *)rtl819x_watchdog_wqcallback
, dev
);
1255 INIT_DELAYED_WORK_RSL(&priv
->txpower_tracking_wq
,
1256 (void *)dm_txpower_trackingcallback
, dev
);
1257 INIT_DELAYED_WORK_RSL(&priv
->rfpath_check_wq
,
1258 (void *)dm_rf_pathcheck_workitemcallback
, dev
);
1259 INIT_DELAYED_WORK_RSL(&priv
->update_beacon_wq
,
1260 (void *)rtl8192_update_beacon
, dev
);
1261 INIT_WORK_RSL(&priv
->qos_activate
, (void *)rtl8192_qos_activate
, dev
);
1262 INIT_DELAYED_WORK_RSL(&priv
->rtllib
->hw_wakeup_wq
,
1263 (void *) rtl8192_hw_wakeup_wq
, dev
);
1264 INIT_DELAYED_WORK_RSL(&priv
->rtllib
->hw_sleep_wq
,
1265 (void *) rtl8192_hw_sleep_wq
, dev
);
1266 tasklet_init(&priv
->irq_rx_tasklet
,
1267 (void(*)(unsigned long))rtl8192_irq_rx_tasklet
,
1268 (unsigned long)priv
);
1269 tasklet_init(&priv
->irq_tx_tasklet
,
1270 (void(*)(unsigned long))rtl8192_irq_tx_tasklet
,
1271 (unsigned long)priv
);
1272 tasklet_init(&priv
->irq_prepare_beacon_tasklet
,
1273 (void(*)(unsigned long))rtl8192_prepare_beacon
,
1274 (unsigned long)priv
);
1277 static short rtl8192_get_channel_map(struct net_device
*dev
)
1281 struct r8192_priv
*priv
= rtllib_priv(dev
);
1282 if ((priv
->rf_chip
!= RF_8225
) && (priv
->rf_chip
!= RF_8256
)
1283 && (priv
->rf_chip
!= RF_6052
)) {
1284 RT_TRACE(COMP_ERR
, "%s: unknown rf chip, can't set channel "
1289 if (priv
->ChannelPlan
> COUNTRY_CODE_MAX
) {
1290 printk(KERN_INFO
"rtl819x_init:Error channel plan! Set to "
1292 priv
->ChannelPlan
= COUNTRY_CODE_FCC
;
1294 RT_TRACE(COMP_INIT
, "Channel plan is %d\n", priv
->ChannelPlan
);
1295 Dot11d_Init(priv
->rtllib
);
1296 Dot11d_Channelmap(priv
->ChannelPlan
, priv
->rtllib
);
1297 for (i
= 1; i
<= 11; i
++)
1298 (priv
->rtllib
->active_channel_map
)[i
] = 1;
1299 (priv
->rtllib
->active_channel_map
)[12] = 2;
1300 (priv
->rtllib
->active_channel_map
)[13] = 2;
1305 static short rtl8192_init(struct net_device
*dev
)
1307 struct r8192_priv
*priv
= rtllib_priv(dev
);
1309 memset(&(priv
->stats
), 0, sizeof(struct rt_stats
));
1311 rtl8192_dbgp_flag_init(dev
);
1312 rtl8192_init_priv_handler(dev
);
1313 rtl8192_init_priv_constant(dev
);
1314 rtl8192_init_priv_variable(dev
);
1315 rtl8192_init_priv_lock(priv
);
1316 rtl8192_init_priv_task(dev
);
1317 priv
->ops
->get_eeprom_size(dev
);
1318 priv
->ops
->init_adapter_variable(dev
);
1319 rtl8192_get_channel_map(dev
);
1323 init_timer(&priv
->watch_dog_timer
);
1324 setup_timer(&priv
->watch_dog_timer
,
1325 watch_dog_timer_callback
,
1326 (unsigned long) dev
);
1328 init_timer(&priv
->gpio_polling_timer
);
1329 setup_timer(&priv
->gpio_polling_timer
,
1330 check_rfctrl_gpio_timer
,
1331 (unsigned long)dev
);
1333 rtl8192_irq_disable(dev
);
1334 if (request_irq(dev
->irq
, (void *)rtl8192_interrupt_rsl
, IRQF_SHARED
,
1336 printk(KERN_ERR
"Error allocating IRQ %d", dev
->irq
);
1339 priv
->irq
= dev
->irq
;
1340 RT_TRACE(COMP_INIT
, "IRQ %d\n", dev
->irq
);
1343 if (rtl8192_pci_initdescring(dev
) != 0) {
1344 printk(KERN_ERR
"Endopoints initialization failed");
1351 /***************************************************************************
1352 -------------------------------WATCHDOG STUFF---------------------------
1353 ***************************************************************************/
1354 short rtl8192_is_tx_queue_empty(struct net_device
*dev
)
1357 struct r8192_priv
*priv
= rtllib_priv(dev
);
1358 for (i
= 0; i
<= MGNT_QUEUE
; i
++) {
1359 if ((i
== TXCMD_QUEUE
) || (i
== HCCA_QUEUE
))
1361 if (skb_queue_len(&(&priv
->tx_ring
[i
])->queue
) > 0) {
1362 printk(KERN_INFO
"===>tx queue is not empty:%d, %d\n",
1363 i
, skb_queue_len(&(&priv
->tx_ring
[i
])->queue
));
1370 static enum reset_type
rtl819x_TxCheckStuck(struct net_device
*dev
)
1372 struct r8192_priv
*priv
= rtllib_priv(dev
);
1374 u8 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
1375 bool bCheckFwTxCnt
= false;
1376 struct rtl8192_tx_ring
*ring
= NULL
;
1377 struct sk_buff
*skb
= NULL
;
1378 struct cb_desc
*tcb_desc
= NULL
;
1379 unsigned long flags
= 0;
1381 switch (priv
->rtllib
->ps
) {
1382 case RTLLIB_PS_DISABLED
:
1383 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_NORMAL
;
1385 case (RTLLIB_PS_MBCAST
|RTLLIB_PS_UNICAST
):
1386 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
1389 ResetThreshold
= NIC_SEND_HANG_THRESHOLD_POWERSAVE
;
1392 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
1393 for (QueueID
= 0; QueueID
< MAX_TX_QUEUE
; QueueID
++) {
1394 if (QueueID
== TXCMD_QUEUE
)
1397 if (QueueID
== BEACON_QUEUE
)
1400 ring
= &priv
->tx_ring
[QueueID
];
1402 if (skb_queue_len(&ring
->queue
) == 0) {
1405 skb
= (&ring
->queue
)->next
;
1406 tcb_desc
= (struct cb_desc
*)(skb
->cb
+
1408 tcb_desc
->nStuckCount
++;
1409 bCheckFwTxCnt
= true;
1410 if (tcb_desc
->nStuckCount
> 1)
1411 printk(KERN_INFO
"%s: QueueID=%d tcb_desc->n"
1412 "StuckCount=%d\n", __func__
, QueueID
,
1413 tcb_desc
->nStuckCount
);
1416 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
1418 if (bCheckFwTxCnt
) {
1419 if (priv
->ops
->TxCheckStuckHandler(dev
)) {
1420 RT_TRACE(COMP_RESET
, "TxCheckStuck(): Fw indicates no"
1421 " Tx condition!\n");
1422 return RESET_TYPE_SILENT
;
1426 return RESET_TYPE_NORESET
;
1429 static enum reset_type
rtl819x_RxCheckStuck(struct net_device
*dev
)
1431 struct r8192_priv
*priv
= rtllib_priv(dev
);
1433 if (priv
->ops
->RxCheckStuckHandler(dev
)) {
1434 RT_TRACE(COMP_RESET
, "RxStuck Condition\n");
1435 return RESET_TYPE_SILENT
;
1438 return RESET_TYPE_NORESET
;
1441 static enum reset_type
rtl819x_ifcheck_resetornot(struct net_device
*dev
)
1443 struct r8192_priv
*priv
= rtllib_priv(dev
);
1444 enum reset_type TxResetType
= RESET_TYPE_NORESET
;
1445 enum reset_type RxResetType
= RESET_TYPE_NORESET
;
1446 enum rt_rf_power_state rfState
;
1448 rfState
= priv
->rtllib
->eRFPowerState
;
1450 if (rfState
== eRfOn
)
1451 TxResetType
= rtl819x_TxCheckStuck(dev
);
1453 if (rfState
== eRfOn
&&
1454 (priv
->rtllib
->iw_mode
== IW_MODE_INFRA
) &&
1455 (priv
->rtllib
->state
== RTLLIB_LINKED
))
1456 RxResetType
= rtl819x_RxCheckStuck(dev
);
1458 if (TxResetType
== RESET_TYPE_NORMAL
||
1459 RxResetType
== RESET_TYPE_NORMAL
) {
1460 printk(KERN_INFO
"%s(): TxResetType is %d, RxResetType is %d\n",
1461 __func__
, TxResetType
, RxResetType
);
1462 return RESET_TYPE_NORMAL
;
1463 } else if (TxResetType
== RESET_TYPE_SILENT
||
1464 RxResetType
== RESET_TYPE_SILENT
) {
1465 printk(KERN_INFO
"%s(): TxResetType is %d, RxResetType is %d\n",
1466 __func__
, TxResetType
, RxResetType
);
1467 return RESET_TYPE_SILENT
;
1469 return RESET_TYPE_NORESET
;
1474 static void rtl819x_silentreset_mesh_bk(struct net_device
*dev
, u8 IsPortal
)
1478 static void rtl819x_ifsilentreset(struct net_device
*dev
)
1480 struct r8192_priv
*priv
= rtllib_priv(dev
);
1482 int reset_status
= 0;
1483 struct rtllib_device
*ieee
= priv
->rtllib
;
1489 if (priv
->ResetProgress
== RESET_TYPE_NORESET
) {
1491 RT_TRACE(COMP_RESET
, "=========>Reset progress!!\n");
1493 priv
->ResetProgress
= RESET_TYPE_SILENT
;
1495 spin_lock_irqsave(&priv
->rf_ps_lock
, flag
);
1496 if (priv
->RFChangeInProgress
) {
1497 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flag
);
1500 priv
->RFChangeInProgress
= true;
1501 priv
->bResetInProgress
= true;
1502 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flag
);
1506 down(&priv
->wx_sem
);
1508 if (priv
->rtllib
->state
== RTLLIB_LINKED
)
1509 LeisurePSLeave(dev
);
1511 if (IS_NIC_DOWN(priv
)) {
1512 RT_TRACE(COMP_ERR
, "%s():the driver is not up! "
1513 "return\n", __func__
);
1519 RT_TRACE(COMP_RESET
, "%s():======>start to down the driver\n",
1522 RT_TRACE(COMP_RESET
, "%s():111111111111111111111111======>start"
1523 " to down the driver\n", __func__
);
1525 if (!netif_queue_stopped(dev
))
1526 netif_stop_queue(dev
);
1528 rtl8192_irq_disable(dev
);
1529 del_timer_sync(&priv
->watch_dog_timer
);
1530 rtl8192_cancel_deferred_work(priv
);
1532 rtllib_stop_scan_syncro(ieee
);
1534 if (ieee
->state
== RTLLIB_LINKED
) {
1535 SEM_DOWN_IEEE_WX(&ieee
->wx_sem
);
1536 printk(KERN_INFO
"ieee->state is RTLLIB_LINKED\n");
1537 rtllib_stop_send_beacons(priv
->rtllib
);
1538 del_timer_sync(&ieee
->associate_timer
);
1539 cancel_delayed_work(&ieee
->associate_retry_wq
);
1540 rtllib_stop_scan(ieee
);
1541 netif_carrier_off(dev
);
1542 SEM_UP_IEEE_WX(&ieee
->wx_sem
);
1544 printk(KERN_INFO
"ieee->state is NOT LINKED\n");
1545 rtllib_softmac_stop_protocol(priv
->rtllib
, 0 , true);
1548 dm_backup_dynamic_mechanism_state(dev
);
1551 RT_TRACE(COMP_RESET
, "%s():<==========down process is "
1552 "finished\n", __func__
);
1554 RT_TRACE(COMP_RESET
, "%s():<===========up process start\n",
1556 reset_status
= _rtl8192_up(dev
, true);
1558 RT_TRACE(COMP_RESET
, "%s():<===========up process is "
1559 "finished\n", __func__
);
1560 if (reset_status
== -1) {
1561 if (reset_times
< 3) {
1565 RT_TRACE(COMP_ERR
, " ERR!!! %s(): Reset "
1566 "Failed!!\n", __func__
);
1570 ieee
->is_silent_reset
= 1;
1572 spin_lock_irqsave(&priv
->rf_ps_lock
, flag
);
1573 priv
->RFChangeInProgress
= false;
1574 spin_unlock_irqrestore(&priv
->rf_ps_lock
, flag
);
1576 EnableHWSecurityConfig8192(dev
);
1578 if (ieee
->state
== RTLLIB_LINKED
&& ieee
->iw_mode
==
1580 ieee
->set_chan(ieee
->dev
,
1581 ieee
->current_network
.channel
);
1583 queue_work_rsl(ieee
->wq
, &ieee
->associate_complete_wq
);
1585 } else if (ieee
->state
== RTLLIB_LINKED
&& ieee
->iw_mode
==
1587 ieee
->set_chan(ieee
->dev
,
1588 ieee
->current_network
.channel
);
1589 ieee
->link_change(ieee
->dev
);
1591 notify_wx_assoc_event(ieee
);
1593 rtllib_start_send_beacons(ieee
);
1595 if (ieee
->data_hard_resume
)
1596 ieee
->data_hard_resume(ieee
->dev
);
1597 netif_carrier_on(ieee
->dev
);
1598 } else if (ieee
->iw_mode
== IW_MODE_MESH
) {
1599 rtl819x_silentreset_mesh_bk(dev
, IsPortal
);
1602 CamRestoreAllEntry(dev
);
1603 dm_restore_dynamic_mechanism_state(dev
);
1605 priv
->ResetProgress
= RESET_TYPE_NORESET
;
1606 priv
->reset_count
++;
1608 priv
->bForcedSilentReset
= false;
1609 priv
->bResetInProgress
= false;
1611 write_nic_byte(dev
, UFWP
, 1);
1612 RT_TRACE(COMP_RESET
, "Reset finished!! ====>[%d]\n",
1617 static void rtl819x_update_rxcounts(struct r8192_priv
*priv
, u32
*TotalRxBcnNum
,
1618 u32
*TotalRxDataNum
)
1624 *TotalRxDataNum
= 0;
1626 SlotIndex
= (priv
->rtllib
->LinkDetectInfo
.SlotIndex
++) %
1627 (priv
->rtllib
->LinkDetectInfo
.SlotNum
);
1628 priv
->rtllib
->LinkDetectInfo
.RxBcnNum
[SlotIndex
] =
1629 priv
->rtllib
->LinkDetectInfo
.NumRecvBcnInPeriod
;
1630 priv
->rtllib
->LinkDetectInfo
.RxDataNum
[SlotIndex
] =
1631 priv
->rtllib
->LinkDetectInfo
.NumRecvDataInPeriod
;
1632 for (i
= 0; i
< priv
->rtllib
->LinkDetectInfo
.SlotNum
; i
++) {
1633 *TotalRxBcnNum
+= priv
->rtllib
->LinkDetectInfo
.RxBcnNum
[i
];
1634 *TotalRxDataNum
+= priv
->rtllib
->LinkDetectInfo
.RxDataNum
[i
];
1639 void rtl819x_watchdog_wqcallback(void *data
)
1641 struct r8192_priv
*priv
= container_of_dwork_rsl(data
,
1642 struct r8192_priv
, watch_dog_wq
);
1643 struct net_device
*dev
= priv
->rtllib
->dev
;
1644 struct rtllib_device
*ieee
= priv
->rtllib
;
1645 enum reset_type ResetType
= RESET_TYPE_NORESET
;
1646 static u8 check_reset_cnt
;
1647 unsigned long flags
;
1648 struct rt_pwr_save_ctrl
*pPSC
= (struct rt_pwr_save_ctrl
*)
1649 (&(priv
->rtllib
->PowerSaveControl
));
1650 bool bBusyTraffic
= false;
1651 bool bHigherBusyTraffic
= false;
1652 bool bHigherBusyRxTraffic
= false;
1653 bool bEnterPS
= false;
1655 if (IS_NIC_DOWN(priv
) || (priv
->bHwRadioOff
== true))
1658 if (priv
->rtllib
->state
>= RTLLIB_LINKED
) {
1659 if (priv
->rtllib
->CntAfterLink
< 2)
1660 priv
->rtllib
->CntAfterLink
++;
1662 priv
->rtllib
->CntAfterLink
= 0;
1665 hal_dm_watchdog(dev
);
1667 if (rtllib_act_scanning(priv
->rtllib
, false) == false) {
1668 if ((ieee
->iw_mode
== IW_MODE_INFRA
) && (ieee
->state
==
1670 (ieee
->eRFPowerState
== eRfOn
) && !ieee
->is_set_key
&&
1671 (!ieee
->proto_stoppping
) && !ieee
->wx_set_enc
) {
1672 if ((ieee
->PowerSaveControl
.ReturnPoint
==
1673 IPS_CALLBACK_NONE
) &&
1674 (!ieee
->bNetPromiscuousMode
)) {
1675 RT_TRACE(COMP_PS
, "====================>haha: "
1681 if ((ieee
->state
== RTLLIB_LINKED
) && (ieee
->iw_mode
==
1682 IW_MODE_INFRA
) && (!ieee
->bNetPromiscuousMode
)) {
1683 if (ieee
->LinkDetectInfo
.NumRxOkInPeriod
> 100 ||
1684 ieee
->LinkDetectInfo
.NumTxOkInPeriod
> 100)
1685 bBusyTraffic
= true;
1688 if (ieee
->LinkDetectInfo
.NumRxOkInPeriod
> 4000 ||
1689 ieee
->LinkDetectInfo
.NumTxOkInPeriod
> 4000) {
1690 bHigherBusyTraffic
= true;
1691 if (ieee
->LinkDetectInfo
.NumRxOkInPeriod
> 5000)
1692 bHigherBusyRxTraffic
= true;
1694 bHigherBusyRxTraffic
= false;
1697 if (((ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
+
1698 ieee
->LinkDetectInfo
.NumTxOkInPeriod
) > 8) ||
1699 (ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
> 2))
1704 if (ieee
->current_network
.beacon_interval
< 95)
1708 LeisurePSEnter(dev
);
1710 LeisurePSLeave(dev
);
1713 RT_TRACE(COMP_LPS
, "====>no link LPS leave\n");
1714 LeisurePSLeave(dev
);
1717 ieee
->LinkDetectInfo
.NumRxOkInPeriod
= 0;
1718 ieee
->LinkDetectInfo
.NumTxOkInPeriod
= 0;
1719 ieee
->LinkDetectInfo
.NumRxUnicastOkInPeriod
= 0;
1720 ieee
->LinkDetectInfo
.bBusyTraffic
= bBusyTraffic
;
1722 ieee
->LinkDetectInfo
.bHigherBusyTraffic
= bHigherBusyTraffic
;
1723 ieee
->LinkDetectInfo
.bHigherBusyRxTraffic
= bHigherBusyRxTraffic
;
1725 if (ieee
->state
== RTLLIB_LINKED
&& ieee
->iw_mode
== IW_MODE_INFRA
) {
1726 u32 TotalRxBcnNum
= 0;
1727 u32 TotalRxDataNum
= 0;
1729 rtl819x_update_rxcounts(priv
, &TotalRxBcnNum
, &TotalRxDataNum
);
1731 if ((TotalRxBcnNum
+TotalRxDataNum
) == 0)
1732 priv
->check_roaming_cnt
++;
1734 priv
->check_roaming_cnt
= 0;
1737 if (priv
->check_roaming_cnt
> 0) {
1738 if (ieee
->eRFPowerState
== eRfOff
)
1739 RT_TRACE(COMP_ERR
, "========>%s()\n", __func__
);
1741 printk(KERN_INFO
"===>%s(): AP is power off, chan:%d,"
1742 " connect another one\n", __func__
, priv
->chan
);
1744 ieee
->state
= RTLLIB_ASSOCIATING
;
1746 RemovePeerTS(priv
->rtllib
,
1747 priv
->rtllib
->current_network
.bssid
);
1748 ieee
->is_roaming
= true;
1749 ieee
->is_set_key
= false;
1750 ieee
->link_change(dev
);
1751 if (ieee
->LedControlHandler
)
1752 ieee
->LedControlHandler(ieee
->dev
,
1753 LED_CTL_START_TO_LINK
);
1755 notify_wx_assoc_event(ieee
);
1757 if (!(ieee
->rtllib_ap_sec_type(ieee
) &
1758 (SEC_ALG_CCMP
|SEC_ALG_TKIP
)))
1759 queue_delayed_work_rsl(ieee
->wq
,
1760 &ieee
->associate_procedure_wq
, 0);
1762 priv
->check_roaming_cnt
= 0;
1764 ieee
->LinkDetectInfo
.NumRecvBcnInPeriod
= 0;
1765 ieee
->LinkDetectInfo
.NumRecvDataInPeriod
= 0;
1769 spin_lock_irqsave(&priv
->tx_lock
, flags
);
1770 if ((check_reset_cnt
++ >= 3) && (!ieee
->is_roaming
) &&
1771 (!priv
->RFChangeInProgress
) && (!pPSC
->bSwRfProcessing
)) {
1772 ResetType
= rtl819x_ifcheck_resetornot(dev
);
1773 check_reset_cnt
= 3;
1775 spin_unlock_irqrestore(&priv
->tx_lock
, flags
);
1777 if (!priv
->bDisableNormalResetCheck
&& ResetType
== RESET_TYPE_NORMAL
) {
1778 priv
->ResetProgress
= RESET_TYPE_NORMAL
;
1779 RT_TRACE(COMP_RESET
, "%s(): NOMAL RESET\n", __func__
);
1783 if (((priv
->force_reset
) || (!priv
->bDisableNormalResetCheck
&&
1784 ResetType
== RESET_TYPE_SILENT
)))
1785 rtl819x_ifsilentreset(dev
);
1786 priv
->force_reset
= false;
1787 priv
->bForcedSilentReset
= false;
1788 priv
->bResetInProgress
= false;
1789 RT_TRACE(COMP_TRACE
, " <==RtUsbCheckForHangWorkItemCallback()\n");
1792 void watch_dog_timer_callback(unsigned long data
)
1794 struct r8192_priv
*priv
= rtllib_priv((struct net_device
*)data
);
1795 queue_delayed_work_rsl(priv
->priv_wq
, &priv
->watch_dog_wq
, 0);
1796 mod_timer(&priv
->watch_dog_timer
, jiffies
+
1797 MSECS(RTLLIB_WATCH_DOG_TIME
));
1800 /****************************************************************************
1801 ---------------------------- NIC TX/RX STUFF---------------------------
1802 *****************************************************************************/
1803 void rtl8192_rx_enable(struct net_device
*dev
)
1805 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1806 priv
->ops
->rx_enable(dev
);
1809 void rtl8192_tx_enable(struct net_device
*dev
)
1811 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1813 priv
->ops
->tx_enable(dev
);
1815 rtllib_reset_queue(priv
->rtllib
);
1819 static void rtl8192_free_rx_ring(struct net_device
*dev
)
1821 struct r8192_priv
*priv
= rtllib_priv(dev
);
1822 int i
, rx_queue_idx
;
1824 for (rx_queue_idx
= 0; rx_queue_idx
< MAX_RX_QUEUE
;
1826 for (i
= 0; i
< priv
->rxringcount
; i
++) {
1827 struct sk_buff
*skb
= priv
->rx_buf
[rx_queue_idx
][i
];
1831 pci_unmap_single(priv
->pdev
,
1832 *((dma_addr_t
*)skb
->cb
),
1833 priv
->rxbuffersize
, PCI_DMA_FROMDEVICE
);
1837 pci_free_consistent(priv
->pdev
,
1838 sizeof(*priv
->rx_ring
[rx_queue_idx
]) *
1840 priv
->rx_ring
[rx_queue_idx
],
1841 priv
->rx_ring_dma
[rx_queue_idx
]);
1842 priv
->rx_ring
[rx_queue_idx
] = NULL
;
1846 static void rtl8192_free_tx_ring(struct net_device
*dev
, unsigned int prio
)
1848 struct r8192_priv
*priv
= rtllib_priv(dev
);
1849 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
1851 while (skb_queue_len(&ring
->queue
)) {
1852 struct tx_desc
*entry
= &ring
->desc
[ring
->idx
];
1853 struct sk_buff
*skb
= __skb_dequeue(&ring
->queue
);
1855 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
1856 skb
->len
, PCI_DMA_TODEVICE
);
1858 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
1861 pci_free_consistent(priv
->pdev
, sizeof(*ring
->desc
)*ring
->entries
,
1862 ring
->desc
, ring
->dma
);
1866 void rtl8192_data_hard_stop(struct net_device
*dev
)
1871 void rtl8192_data_hard_resume(struct net_device
*dev
)
1875 void rtl8192_hard_data_xmit(struct sk_buff
*skb
, struct net_device
*dev
,
1878 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1880 struct cb_desc
*tcb_desc
= (struct cb_desc
*)(skb
->cb
+
1882 u8 queue_index
= tcb_desc
->queue_index
;
1884 if ((priv
->rtllib
->eRFPowerState
== eRfOff
) || IS_NIC_DOWN(priv
) ||
1885 priv
->bResetInProgress
) {
1890 assert(queue_index
!= TXCMD_QUEUE
);
1893 memcpy((unsigned char *)(skb
->cb
), &dev
, sizeof(dev
));
1894 skb_push(skb
, priv
->rtllib
->tx_headroom
);
1895 ret
= rtl8192_tx(dev
, skb
);
1900 if (queue_index
!= MGNT_QUEUE
) {
1901 priv
->rtllib
->stats
.tx_bytes
+= (skb
->len
-
1902 priv
->rtllib
->tx_headroom
);
1903 priv
->rtllib
->stats
.tx_packets
++;
1910 int rtl8192_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1912 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1914 struct cb_desc
*tcb_desc
= (struct cb_desc
*)(skb
->cb
+
1916 u8 queue_index
= tcb_desc
->queue_index
;
1918 if (queue_index
!= TXCMD_QUEUE
) {
1919 if ((priv
->rtllib
->eRFPowerState
== eRfOff
) ||
1920 IS_NIC_DOWN(priv
) || priv
->bResetInProgress
) {
1926 memcpy((unsigned char *)(skb
->cb
), &dev
, sizeof(dev
));
1927 if (queue_index
== TXCMD_QUEUE
) {
1928 rtl8192_tx_cmd(dev
, skb
);
1932 tcb_desc
->RATRIndex
= 7;
1933 tcb_desc
->bTxDisableRateFallBack
= 1;
1934 tcb_desc
->bTxUseDriverAssingedRate
= 1;
1935 tcb_desc
->bTxEnableFwCalcDur
= 1;
1936 skb_push(skb
, priv
->rtllib
->tx_headroom
);
1937 ret
= rtl8192_tx(dev
, skb
);
1949 static void rtl8192_tx_isr(struct net_device
*dev
, int prio
)
1951 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
1953 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[prio
];
1955 while (skb_queue_len(&ring
->queue
)) {
1956 struct tx_desc
*entry
= &ring
->desc
[ring
->idx
];
1957 struct sk_buff
*skb
;
1959 if (prio
!= BEACON_QUEUE
) {
1962 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
1965 skb
= __skb_dequeue(&ring
->queue
);
1966 pci_unmap_single(priv
->pdev
, le32_to_cpu(entry
->TxBuffAddr
),
1967 skb
->len
, PCI_DMA_TODEVICE
);
1971 if (prio
!= BEACON_QUEUE
)
1972 tasklet_schedule(&priv
->irq_tx_tasklet
);
1975 void rtl8192_tx_cmd(struct net_device
*dev
, struct sk_buff
*skb
)
1977 struct r8192_priv
*priv
= rtllib_priv(dev
);
1978 struct rtl8192_tx_ring
*ring
;
1979 struct tx_desc_cmd
*entry
;
1981 struct cb_desc
*tcb_desc
;
1982 unsigned long flags
;
1984 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
1985 ring
= &priv
->tx_ring
[TXCMD_QUEUE
];
1987 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
1988 entry
= (struct tx_desc_cmd
*) &ring
->desc
[idx
];
1990 tcb_desc
= (struct cb_desc
*)(skb
->cb
+ MAX_DEV_ADDR_SIZE
);
1992 priv
->ops
->tx_fill_cmd_descriptor(dev
, entry
, tcb_desc
, skb
);
1994 __skb_queue_tail(&ring
->queue
, skb
);
1995 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2000 short rtl8192_tx(struct net_device
*dev
, struct sk_buff
*skb
)
2002 struct r8192_priv
*priv
= rtllib_priv(dev
);
2003 struct rtl8192_tx_ring
*ring
;
2004 unsigned long flags
;
2005 struct cb_desc
*tcb_desc
= (struct cb_desc
*)(skb
->cb
+
2007 struct tx_desc
*pdesc
= NULL
;
2008 struct rtllib_hdr_1addr
*header
= NULL
;
2009 u16 fc
= 0, type
= 0, stype
= 0;
2010 bool multi_addr
= false, broad_addr
= false, uni_addr
= false;
2011 u8
*pda_addr
= NULL
;
2013 u32 fwinfo_size
= 0;
2015 if (priv
->bdisable_nic
) {
2016 RT_TRACE(COMP_ERR
, "%s: ERR!! Nic is disabled! Can't tx packet"
2017 " len=%d qidx=%d!!!\n", __func__
, skb
->len
,
2018 tcb_desc
->queue_index
);
2022 priv
->rtllib
->bAwakePktSent
= true;
2024 fwinfo_size
= sizeof(struct tx_fwinfo_8190pci
);
2026 header
= (struct rtllib_hdr_1addr
*)(((u8
*)skb
->data
) + fwinfo_size
);
2027 fc
= header
->frame_ctl
;
2028 type
= WLAN_FC_GET_TYPE(fc
);
2029 stype
= WLAN_FC_GET_STYPE(fc
);
2030 pda_addr
= header
->addr1
;
2032 if (is_multicast_ether_addr(pda_addr
))
2034 else if (is_broadcast_ether_addr(pda_addr
))
2040 priv
->stats
.txbytesunicast
+= skb
->len
- fwinfo_size
;
2041 else if (multi_addr
)
2042 priv
->stats
.txbytesmulticast
+= skb
->len
- fwinfo_size
;
2044 priv
->stats
.txbytesbroadcast
+= skb
->len
- fwinfo_size
;
2046 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
2047 ring
= &priv
->tx_ring
[tcb_desc
->queue_index
];
2048 if (tcb_desc
->queue_index
!= BEACON_QUEUE
)
2049 idx
= (ring
->idx
+ skb_queue_len(&ring
->queue
)) % ring
->entries
;
2053 pdesc
= &ring
->desc
[idx
];
2054 if ((pdesc
->OWN
== 1) && (tcb_desc
->queue_index
!= BEACON_QUEUE
)) {
2055 RT_TRACE(COMP_ERR
, "No more TX desc@%d, ring->idx = %d, idx = "
2056 "%d, skblen = 0x%x queuelen=%d",
2057 tcb_desc
->queue_index
, ring
->idx
, idx
, skb
->len
,
2058 skb_queue_len(&ring
->queue
));
2059 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2063 if (type
== RTLLIB_FTYPE_DATA
) {
2064 if (priv
->rtllib
->LedControlHandler
)
2065 priv
->rtllib
->LedControlHandler(dev
, LED_CTL_TX
);
2067 priv
->ops
->tx_fill_descriptor(dev
, pdesc
, tcb_desc
, skb
);
2068 __skb_queue_tail(&ring
->queue
, skb
);
2070 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2071 dev
->trans_start
= jiffies
;
2073 write_nic_word(dev
, TPPoll
, 0x01 << tcb_desc
->queue_index
);
2077 static short rtl8192_alloc_rx_desc_ring(struct net_device
*dev
)
2079 struct r8192_priv
*priv
= rtllib_priv(dev
);
2080 struct rx_desc
*entry
= NULL
;
2081 int i
, rx_queue_idx
;
2083 for (rx_queue_idx
= 0; rx_queue_idx
< MAX_RX_QUEUE
; rx_queue_idx
++) {
2084 priv
->rx_ring
[rx_queue_idx
] = pci_alloc_consistent(priv
->pdev
,
2085 sizeof(*priv
->rx_ring
[rx_queue_idx
]) *
2087 &priv
->rx_ring_dma
[rx_queue_idx
]);
2089 if (!priv
->rx_ring
[rx_queue_idx
] ||
2090 (unsigned long)priv
->rx_ring
[rx_queue_idx
] & 0xFF) {
2091 RT_TRACE(COMP_ERR
, "Cannot allocate RX ring\n");
2095 memset(priv
->rx_ring
[rx_queue_idx
], 0,
2096 sizeof(*priv
->rx_ring
[rx_queue_idx
]) *
2098 priv
->rx_idx
[rx_queue_idx
] = 0;
2100 for (i
= 0; i
< priv
->rxringcount
; i
++) {
2101 struct sk_buff
*skb
= dev_alloc_skb(priv
->rxbuffersize
);
2102 dma_addr_t
*mapping
;
2103 entry
= &priv
->rx_ring
[rx_queue_idx
][i
];
2107 priv
->rx_buf
[rx_queue_idx
][i
] = skb
;
2108 mapping
= (dma_addr_t
*)skb
->cb
;
2109 *mapping
= pci_map_single(priv
->pdev
,
2110 skb_tail_pointer_rsl(skb
),
2112 PCI_DMA_FROMDEVICE
);
2114 entry
->BufferAddress
= cpu_to_le32(*mapping
);
2116 entry
->Length
= priv
->rxbuffersize
;
2125 static int rtl8192_alloc_tx_desc_ring(struct net_device
*dev
,
2126 unsigned int prio
, unsigned int entries
)
2128 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2129 struct tx_desc
*ring
;
2133 ring
= pci_alloc_consistent(priv
->pdev
, sizeof(*ring
) * entries
, &dma
);
2134 if (!ring
|| (unsigned long)ring
& 0xFF) {
2135 RT_TRACE(COMP_ERR
, "Cannot allocate TX ring (prio = %d)\n",
2140 memset(ring
, 0, sizeof(*ring
)*entries
);
2141 priv
->tx_ring
[prio
].desc
= ring
;
2142 priv
->tx_ring
[prio
].dma
= dma
;
2143 priv
->tx_ring
[prio
].idx
= 0;
2144 priv
->tx_ring
[prio
].entries
= entries
;
2145 skb_queue_head_init(&priv
->tx_ring
[prio
].queue
);
2147 for (i
= 0; i
< entries
; i
++)
2148 ring
[i
].NextDescAddress
=
2149 cpu_to_le32((u32
)dma
+ ((i
+ 1) % entries
) *
2156 short rtl8192_pci_initdescring(struct net_device
*dev
)
2160 struct r8192_priv
*priv
= rtllib_priv(dev
);
2162 ret
= rtl8192_alloc_rx_desc_ring(dev
);
2166 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
2167 ret
= rtl8192_alloc_tx_desc_ring(dev
, i
, priv
->txringcount
);
2169 goto err_free_rings
;
2175 rtl8192_free_rx_ring(dev
);
2176 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
2177 if (priv
->tx_ring
[i
].desc
)
2178 rtl8192_free_tx_ring(dev
, i
);
2182 void rtl8192_pci_resetdescring(struct net_device
*dev
)
2184 struct r8192_priv
*priv
= rtllib_priv(dev
);
2185 int i
, rx_queue_idx
;
2186 unsigned long flags
= 0;
2188 for (rx_queue_idx
= 0; rx_queue_idx
< MAX_RX_QUEUE
; rx_queue_idx
++) {
2189 if (priv
->rx_ring
[rx_queue_idx
]) {
2190 struct rx_desc
*entry
= NULL
;
2191 for (i
= 0; i
< priv
->rxringcount
; i
++) {
2192 entry
= &priv
->rx_ring
[rx_queue_idx
][i
];
2195 priv
->rx_idx
[rx_queue_idx
] = 0;
2199 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
2200 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++) {
2201 if (priv
->tx_ring
[i
].desc
) {
2202 struct rtl8192_tx_ring
*ring
= &priv
->tx_ring
[i
];
2204 while (skb_queue_len(&ring
->queue
)) {
2205 struct tx_desc
*entry
= &ring
->desc
[ring
->idx
];
2206 struct sk_buff
*skb
=
2207 __skb_dequeue(&ring
->queue
);
2209 pci_unmap_single(priv
->pdev
,
2210 le32_to_cpu(entry
->TxBuffAddr
),
2211 skb
->len
, PCI_DMA_TODEVICE
);
2213 ring
->idx
= (ring
->idx
+ 1) % ring
->entries
;
2218 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2221 void rtl819x_UpdateRxPktTimeStamp(struct net_device
*dev
,
2222 struct rtllib_rx_stats
*stats
)
2224 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2226 if (stats
->bIsAMPDU
&& !stats
->bFirstMPDU
)
2227 stats
->mac_time
= priv
->LastRxDescTSF
;
2229 priv
->LastRxDescTSF
= stats
->mac_time
;
2232 long rtl819x_translate_todbm(struct r8192_priv
*priv
, u8 signal_strength_index
)
2236 signal_power
= (long)((signal_strength_index
+ 1) >> 1);
2239 return signal_power
;
2244 rtl819x_update_rxsignalstatistics8190pci(
2245 struct r8192_priv
*priv
,
2246 struct rtllib_rx_stats
*pprevious_stats
2252 if (priv
->stats
.recv_signal_power
== 0)
2253 priv
->stats
.recv_signal_power
=
2254 pprevious_stats
->RecvSignalPower
;
2256 if (pprevious_stats
->RecvSignalPower
> priv
->stats
.recv_signal_power
)
2258 else if (pprevious_stats
->RecvSignalPower
<
2259 priv
->stats
.recv_signal_power
)
2261 priv
->stats
.recv_signal_power
= (priv
->stats
.recv_signal_power
* 5 +
2262 pprevious_stats
->RecvSignalPower
+
2266 void rtl819x_process_cck_rxpathsel(struct r8192_priv
*priv
,
2267 struct rtllib_rx_stats
*pprevious_stats
)
2272 u8
rtl819x_query_rxpwrpercentage(char antpower
)
2274 if ((antpower
<= -100) || (antpower
>= 20))
2276 else if (antpower
>= 0)
2279 return 100 + antpower
;
2281 } /* QueryRxPwrPercentage */
2284 rtl819x_evm_dbtopercentage(
2296 ret_val
= 0 - ret_val
;
2304 rtl8192_record_rxdesc_forlateruse(
2305 struct rtllib_rx_stats
*psrc_stats
,
2306 struct rtllib_rx_stats
*ptarget_stats
2309 ptarget_stats
->bIsAMPDU
= psrc_stats
->bIsAMPDU
;
2310 ptarget_stats
->bFirstMPDU
= psrc_stats
->bFirstMPDU
;
2315 static void rtl8192_rx_normal(struct net_device
*dev
)
2317 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2318 struct rtllib_hdr_1addr
*rtllib_hdr
= NULL
;
2319 bool unicast_packet
= false;
2320 bool bLedBlinking
= true;
2321 u16 fc
= 0, type
= 0;
2323 int rx_queue_idx
= RX_MPDU_QUEUE
;
2325 struct rtllib_rx_stats stats
= {
2329 .freq
= RTLLIB_24GHZ_BAND
,
2331 unsigned int count
= priv
->rxringcount
;
2333 stats
.nic_type
= NIC_8192E
;
2336 struct rx_desc
*pdesc
= &priv
->rx_ring
[rx_queue_idx
]
2337 [priv
->rx_idx
[rx_queue_idx
]];
2338 struct sk_buff
*skb
= priv
->rx_buf
[rx_queue_idx
]
2339 [priv
->rx_idx
[rx_queue_idx
]];
2344 struct sk_buff
*new_skb
;
2346 if (!priv
->ops
->rx_query_status_descriptor(dev
, &stats
,
2349 new_skb
= dev_alloc_skb(priv
->rxbuffersize
);
2350 /* if allocation of new skb failed - drop current packet
2352 if (unlikely(!new_skb
))
2355 pci_unmap_single(priv
->pdev
,
2356 *((dma_addr_t
*)skb
->cb
),
2358 PCI_DMA_FROMDEVICE
);
2360 skb_put(skb
, pdesc
->Length
);
2361 skb_reserve(skb
, stats
.RxDrvInfoSize
+
2363 skb_trim(skb
, skb
->len
- 4/*sCrcLng*/);
2364 rtllib_hdr
= (struct rtllib_hdr_1addr
*)skb
->data
;
2365 if (!is_broadcast_ether_addr(rtllib_hdr
->addr1
) &&
2366 !is_multicast_ether_addr(rtllib_hdr
->addr1
)) {
2367 /* unicast packet */
2368 unicast_packet
= true;
2370 fc
= le16_to_cpu(rtllib_hdr
->frame_ctl
);
2371 type
= WLAN_FC_GET_TYPE(fc
);
2372 if (type
== RTLLIB_FTYPE_MGMT
)
2373 bLedBlinking
= false;
2376 if (priv
->rtllib
->LedControlHandler
)
2377 priv
->rtllib
->LedControlHandler(dev
,
2381 if (type
!= RTLLIB_FTYPE_MGMT
)
2382 priv
->stats
.rxdatacrcerr
++;
2384 priv
->stats
.rxmgmtcrcerr
++;
2389 if (!rtllib_rx(priv
->rtllib
, skb
, &stats
)) {
2390 dev_kfree_skb_any(skb
);
2394 priv
->stats
.rxbytesunicast
+= skb_len
;
2400 priv
->rx_buf
[rx_queue_idx
][priv
->rx_idx
[rx_queue_idx
]] =
2402 *((dma_addr_t
*) skb
->cb
) = pci_map_single(priv
->pdev
,
2403 skb_tail_pointer_rsl(skb
),
2405 PCI_DMA_FROMDEVICE
);
2409 pdesc
->BufferAddress
= cpu_to_le32(*((dma_addr_t
*)skb
->cb
));
2411 pdesc
->Length
= priv
->rxbuffersize
;
2412 if (priv
->rx_idx
[rx_queue_idx
] == priv
->rxringcount
-1)
2414 priv
->rx_idx
[rx_queue_idx
] = (priv
->rx_idx
[rx_queue_idx
] + 1) %
2420 static void rtl8192_rx_cmd(struct net_device
*dev
)
2425 static void rtl8192_tx_resume(struct net_device
*dev
)
2427 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2428 struct rtllib_device
*ieee
= priv
->rtllib
;
2429 struct sk_buff
*skb
;
2432 for (queue_index
= BK_QUEUE
;
2433 queue_index
< MAX_QUEUE_SIZE
; queue_index
++) {
2434 while ((!skb_queue_empty(&ieee
->skb_waitQ
[queue_index
])) &&
2435 (priv
->rtllib
->check_nic_enough_desc(dev
, queue_index
) > 0)) {
2436 skb
= skb_dequeue(&ieee
->skb_waitQ
[queue_index
]);
2437 ieee
->softmac_data_hard_start_xmit(skb
, dev
, 0);
2442 void rtl8192_irq_tx_tasklet(struct r8192_priv
*priv
)
2444 rtl8192_tx_resume(priv
->rtllib
->dev
);
2447 void rtl8192_irq_rx_tasklet(struct r8192_priv
*priv
)
2449 rtl8192_rx_normal(priv
->rtllib
->dev
);
2451 if (MAX_RX_QUEUE
> 1)
2452 rtl8192_rx_cmd(priv
->rtllib
->dev
);
2454 write_nic_dword(priv
->rtllib
->dev
, INTA_MASK
,
2455 read_nic_dword(priv
->rtllib
->dev
, INTA_MASK
) | IMR_RDU
);
2458 /****************************************************************************
2459 ---------------------------- NIC START/CLOSE STUFF---------------------------
2460 *****************************************************************************/
2461 void rtl8192_cancel_deferred_work(struct r8192_priv
*priv
)
2463 cancel_delayed_work(&priv
->watch_dog_wq
);
2464 cancel_delayed_work(&priv
->update_beacon_wq
);
2465 cancel_delayed_work(&priv
->rtllib
->hw_sleep_wq
);
2466 cancel_work_sync(&priv
->reset_wq
);
2467 cancel_work_sync(&priv
->qos_activate
);
2470 int _rtl8192_up(struct net_device
*dev
, bool is_silent_reset
)
2472 if (_rtl8192_sta_up(dev
, is_silent_reset
) == -1)
2478 static int rtl8192_open(struct net_device
*dev
)
2480 struct r8192_priv
*priv
= rtllib_priv(dev
);
2483 down(&priv
->wx_sem
);
2484 ret
= rtl8192_up(dev
);
2491 int rtl8192_up(struct net_device
*dev
)
2493 struct r8192_priv
*priv
= rtllib_priv(dev
);
2497 return _rtl8192_up(dev
, false);
2501 static int rtl8192_close(struct net_device
*dev
)
2503 struct r8192_priv
*priv
= rtllib_priv(dev
);
2506 if ((rtllib_act_scanning(priv
->rtllib
, false)) &&
2507 !(priv
->rtllib
->softmac_features
& IEEE_SOFTMAC_SCAN
)) {
2508 rtllib_stop_scan(priv
->rtllib
);
2511 down(&priv
->wx_sem
);
2513 ret
= rtl8192_down(dev
, true);
2521 int rtl8192_down(struct net_device
*dev
, bool shutdownrf
)
2523 if (rtl8192_sta_down(dev
, shutdownrf
) == -1)
2529 void rtl8192_commit(struct net_device
*dev
)
2531 struct r8192_priv
*priv
= rtllib_priv(dev
);
2535 rtllib_softmac_stop_protocol(priv
->rtllib
, 0 , true);
2536 rtl8192_irq_disable(dev
);
2537 priv
->ops
->stop_adapter(dev
, true);
2538 _rtl8192_up(dev
, false);
2541 void rtl8192_restart(void *data
)
2543 struct r8192_priv
*priv
= container_of_work_rsl(data
, struct r8192_priv
,
2545 struct net_device
*dev
= priv
->rtllib
->dev
;
2547 down(&priv
->wx_sem
);
2549 rtl8192_commit(dev
);
2554 static void r8192_set_multicast(struct net_device
*dev
)
2556 struct r8192_priv
*priv
= rtllib_priv(dev
);
2559 promisc
= (dev
->flags
& IFF_PROMISC
) ? 1 : 0;
2560 priv
->promisc
= promisc
;
2565 static int r8192_set_mac_adr(struct net_device
*dev
, void *mac
)
2567 struct r8192_priv
*priv
= rtllib_priv(dev
);
2568 struct sockaddr
*addr
= mac
;
2570 down(&priv
->wx_sem
);
2572 memcpy(dev
->dev_addr
, addr
->sa_data
, ETH_ALEN
);
2574 schedule_work(&priv
->reset_wq
);
2580 /* based on ipw2200 driver */
2581 static int rtl8192_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
2583 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2584 struct iwreq
*wrq
= (struct iwreq
*)rq
;
2586 struct rtllib_device
*ieee
= priv
->rtllib
;
2588 u8 broadcast_addr
[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
2589 u8 zero_addr
[6] = {0};
2590 struct iw_point
*p
= &wrq
->u
.data
;
2591 struct ieee_param
*ipw
= NULL
;
2593 down(&priv
->wx_sem
);
2596 case RTL_IOCTL_WPA_SUPPLICANT
:
2597 if (p
->length
< sizeof(struct ieee_param
) || !p
->pointer
) {
2602 ipw
= kmalloc(p
->length
, GFP_KERNEL
);
2607 if (copy_from_user(ipw
, p
->pointer
, p
->length
)) {
2613 if (ipw
->cmd
== IEEE_CMD_SET_ENCRYPTION
) {
2614 if (ipw
->u
.crypt
.set_tx
) {
2615 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
2616 ieee
->pairwise_key_type
= KEY_TYPE_CCMP
;
2617 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
2618 ieee
->pairwise_key_type
= KEY_TYPE_TKIP
;
2619 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0) {
2620 if (ipw
->u
.crypt
.key_len
== 13)
2621 ieee
->pairwise_key_type
=
2623 else if (ipw
->u
.crypt
.key_len
== 5)
2624 ieee
->pairwise_key_type
=
2627 ieee
->pairwise_key_type
= KEY_TYPE_NA
;
2630 if (ieee
->pairwise_key_type
) {
2631 if (memcmp(ieee
->ap_mac_addr
, zero_addr
,
2633 ieee
->iw_mode
= IW_MODE_ADHOC
;
2634 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
2635 EnableHWSecurityConfig8192(dev
);
2636 set_swcam(dev
, 4, ipw
->u
.crypt
.idx
,
2637 ieee
->pairwise_key_type
,
2638 (u8
*)ieee
->ap_mac_addr
,
2640 setKey(dev
, 4, ipw
->u
.crypt
.idx
,
2641 ieee
->pairwise_key_type
,
2642 (u8
*)ieee
->ap_mac_addr
, 0, key
);
2643 if (ieee
->iw_mode
== IW_MODE_ADHOC
) {
2644 set_swcam(dev
, ipw
->u
.crypt
.idx
,
2646 ieee
->pairwise_key_type
,
2647 (u8
*)ieee
->ap_mac_addr
,
2649 setKey(dev
, ipw
->u
.crypt
.idx
,
2651 ieee
->pairwise_key_type
,
2652 (u8
*)ieee
->ap_mac_addr
,
2656 if ((ieee
->pairwise_key_type
== KEY_TYPE_CCMP
)
2657 && ieee
->pHTInfo
->bCurrentHTSupport
) {
2658 write_nic_byte(dev
, 0x173, 1);
2662 memcpy((u8
*)key
, ipw
->u
.crypt
.key
, 16);
2663 if (strcmp(ipw
->u
.crypt
.alg
, "CCMP") == 0)
2664 ieee
->group_key_type
= KEY_TYPE_CCMP
;
2665 else if (strcmp(ipw
->u
.crypt
.alg
, "TKIP") == 0)
2666 ieee
->group_key_type
= KEY_TYPE_TKIP
;
2667 else if (strcmp(ipw
->u
.crypt
.alg
, "WEP") == 0) {
2668 if (ipw
->u
.crypt
.key_len
== 13)
2669 ieee
->group_key_type
=
2671 else if (ipw
->u
.crypt
.key_len
== 5)
2672 ieee
->group_key_type
=
2675 ieee
->group_key_type
= KEY_TYPE_NA
;
2677 if (ieee
->group_key_type
) {
2678 set_swcam(dev
, ipw
->u
.crypt
.idx
,
2680 ieee
->group_key_type
,
2681 broadcast_addr
, 0, key
, 0);
2682 setKey(dev
, ipw
->u
.crypt
.idx
,
2684 ieee
->group_key_type
,
2685 broadcast_addr
, 0, key
);
2690 ret
= rtllib_wpa_supplicant_ioctl(priv
->rtllib
, &wrq
->u
.data
,
2706 irqreturn_type
rtl8192_interrupt(int irq
, void *netdev
, struct pt_regs
*regs
)
2708 struct net_device
*dev
= (struct net_device
*) netdev
;
2709 struct r8192_priv
*priv
= (struct r8192_priv
*)rtllib_priv(dev
);
2710 unsigned long flags
;
2715 if (priv
->irq_enabled
== 0)
2718 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
2720 priv
->ops
->interrupt_recognized(dev
, &inta
, &intb
);
2721 priv
->stats
.shints
++;
2724 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2728 if (inta
== 0xffff) {
2729 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2735 if (!netif_running(dev
)) {
2736 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2740 if (inta
& IMR_TBDOK
) {
2741 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
2742 priv
->stats
.txbeaconokint
++;
2745 if (inta
& IMR_TBDER
) {
2746 RT_TRACE(COMP_INTR
, "beacon ok interrupt!\n");
2747 priv
->stats
.txbeaconerr
++;
2750 if (inta
& IMR_BDOK
)
2751 RT_TRACE(COMP_INTR
, "beacon interrupt!\n");
2753 if (inta
& IMR_MGNTDOK
) {
2754 RT_TRACE(COMP_INTR
, "Manage ok interrupt!\n");
2755 priv
->stats
.txmanageokint
++;
2756 rtl8192_tx_isr(dev
, MGNT_QUEUE
);
2757 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2758 if (priv
->rtllib
->ack_tx_to_ieee
) {
2759 if (rtl8192_is_tx_queue_empty(dev
)) {
2760 priv
->rtllib
->ack_tx_to_ieee
= 0;
2761 rtllib_ps_tx_ack(priv
->rtllib
, 1);
2764 spin_lock_irqsave(&priv
->irq_th_lock
, flags
);
2767 if (inta
& IMR_COMDOK
) {
2768 priv
->stats
.txcmdpktokint
++;
2769 rtl8192_tx_isr(dev
, TXCMD_QUEUE
);
2772 if (inta
& IMR_HIGHDOK
)
2773 rtl8192_tx_isr(dev
, HIGH_QUEUE
);
2775 if (inta
& IMR_ROK
) {
2776 priv
->stats
.rxint
++;
2777 priv
->InterruptLog
.nIMR_ROK
++;
2778 tasklet_schedule(&priv
->irq_rx_tasklet
);
2781 if (inta
& IMR_BcnInt
) {
2782 RT_TRACE(COMP_INTR
, "prepare beacon for interrupt!\n");
2783 tasklet_schedule(&priv
->irq_prepare_beacon_tasklet
);
2786 if (inta
& IMR_RDU
) {
2787 RT_TRACE(COMP_INTR
, "rx descriptor unavailable!\n");
2788 priv
->stats
.rxrdu
++;
2789 write_nic_dword(dev
, INTA_MASK
,
2790 read_nic_dword(dev
, INTA_MASK
) & ~IMR_RDU
);
2791 tasklet_schedule(&priv
->irq_rx_tasklet
);
2794 if (inta
& IMR_RXFOVW
) {
2795 RT_TRACE(COMP_INTR
, "rx overflow !\n");
2796 priv
->stats
.rxoverflow
++;
2797 tasklet_schedule(&priv
->irq_rx_tasklet
);
2800 if (inta
& IMR_TXFOVW
)
2801 priv
->stats
.txoverflow
++;
2803 if (inta
& IMR_BKDOK
) {
2804 RT_TRACE(COMP_INTR
, "BK Tx OK interrupt!\n");
2805 priv
->stats
.txbkokint
++;
2806 priv
->rtllib
->LinkDetectInfo
.NumTxOkInPeriod
++;
2807 rtl8192_tx_isr(dev
, BK_QUEUE
);
2810 if (inta
& IMR_BEDOK
) {
2811 RT_TRACE(COMP_INTR
, "BE TX OK interrupt!\n");
2812 priv
->stats
.txbeokint
++;
2813 priv
->rtllib
->LinkDetectInfo
.NumTxOkInPeriod
++;
2814 rtl8192_tx_isr(dev
, BE_QUEUE
);
2817 if (inta
& IMR_VIDOK
) {
2818 RT_TRACE(COMP_INTR
, "VI TX OK interrupt!\n");
2819 priv
->stats
.txviokint
++;
2820 priv
->rtllib
->LinkDetectInfo
.NumTxOkInPeriod
++;
2821 rtl8192_tx_isr(dev
, VI_QUEUE
);
2824 if (inta
& IMR_VODOK
) {
2825 priv
->stats
.txvookint
++;
2826 RT_TRACE(COMP_INTR
, "Vo TX OK interrupt!\n");
2827 priv
->rtllib
->LinkDetectInfo
.NumTxOkInPeriod
++;
2828 rtl8192_tx_isr(dev
, VO_QUEUE
);
2831 spin_unlock_irqrestore(&priv
->irq_th_lock
, flags
);
2840 /****************************************************************************
2841 ---------------------------- PCI_STUFF---------------------------
2842 *****************************************************************************/
2843 #ifdef HAVE_NET_DEVICE_OPS
2844 static const struct net_device_ops rtl8192_netdev_ops
= {
2845 .ndo_open
= rtl8192_open
,
2846 .ndo_stop
= rtl8192_close
,
2847 .ndo_tx_timeout
= rtl8192_tx_timeout
,
2848 .ndo_do_ioctl
= rtl8192_ioctl
,
2849 .ndo_set_rx_mode
= r8192_set_multicast
,
2850 .ndo_set_mac_address
= r8192_set_mac_adr
,
2851 .ndo_validate_addr
= eth_validate_addr
,
2852 .ndo_change_mtu
= eth_change_mtu
,
2853 .ndo_start_xmit
= rtllib_xmit
,
2857 static int __devinit
rtl8192_pci_probe(struct pci_dev
*pdev
,
2858 const struct pci_device_id
*id
)
2860 unsigned long ioaddr
= 0;
2861 struct net_device
*dev
= NULL
;
2862 struct r8192_priv
*priv
= NULL
;
2863 struct rtl819x_ops
*ops
= (struct rtl819x_ops
*)(id
->driver_data
);
2864 unsigned long pmem_start
, pmem_len
, pmem_flags
;
2866 bool bdma64
= false;
2869 RT_TRACE(COMP_INIT
, "Configuring chip resources");
2871 if (pci_enable_device(pdev
)) {
2872 RT_TRACE(COMP_ERR
, "Failed to enable PCI device");
2876 pci_set_master(pdev
);
2878 if (!pci_set_dma_mask(pdev
, DMA_BIT_MASK(32))) {
2879 if (pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32))) {
2880 printk(KERN_INFO
"Unable to obtain 32bit DMA for consistent allocations\n");
2881 pci_disable_device(pdev
);
2885 dev
= alloc_rtllib(sizeof(struct r8192_priv
));
2890 dev
->features
|= NETIF_F_HIGHDMA
;
2892 pci_set_drvdata(pdev
, dev
);
2893 SET_NETDEV_DEV(dev
, &pdev
->dev
);
2894 priv
= rtllib_priv(dev
);
2895 priv
->rtllib
= (struct rtllib_device
*)netdev_priv_rsl(dev
);
2897 priv
->rtllib
->pdev
= pdev
;
2898 if ((pdev
->subsystem_vendor
== PCI_VENDOR_ID_DLINK
) &&
2899 (pdev
->subsystem_device
== 0x3304))
2900 priv
->rtllib
->bSupportRemoteWakeUp
= 1;
2902 priv
->rtllib
->bSupportRemoteWakeUp
= 0;
2904 pmem_start
= pci_resource_start(pdev
, 1);
2905 pmem_len
= pci_resource_len(pdev
, 1);
2906 pmem_flags
= pci_resource_flags(pdev
, 1);
2908 if (!(pmem_flags
& IORESOURCE_MEM
)) {
2909 RT_TRACE(COMP_ERR
, "region #1 not a MMIO resource, aborting");
2913 printk(KERN_INFO
"Memory mapped space start: 0x%08lx\n", pmem_start
);
2914 if (!request_mem_region(pmem_start
, pmem_len
, DRV_NAME
)) {
2915 RT_TRACE(COMP_ERR
, "request_mem_region failed!");
2920 ioaddr
= (unsigned long)ioremap_nocache(pmem_start
, pmem_len
);
2921 if (ioaddr
== (unsigned long)NULL
) {
2922 RT_TRACE(COMP_ERR
, "ioremap failed!");
2926 dev
->mem_start
= ioaddr
;
2927 dev
->mem_end
= ioaddr
+ pci_resource_len(pdev
, 0);
2929 pci_read_config_byte(pdev
, 0x08, &revision_id
);
2930 /* If the revisionid is 0x10, the device uses rtl8192se. */
2931 if (pdev
->device
== 0x8192 && revision_id
== 0x10)
2936 if (rtl8192_pci_findadapter(pdev
, dev
) == false)
2939 dev
->irq
= pdev
->irq
;
2942 #ifdef HAVE_NET_DEVICE_OPS
2943 dev
->netdev_ops
= &rtl8192_netdev_ops
;
2945 dev
->open
= rtl8192_open
;
2946 dev
->stop
= rtl8192_close
;
2947 dev
->tx_timeout
= rtl8192_tx_timeout
;
2948 dev
->do_ioctl
= rtl8192_ioctl
;
2949 dev
->set_multicast_list
= r8192_set_multicast
;
2950 dev
->set_mac_address
= r8192_set_mac_adr
;
2951 dev
->hard_start_xmit
= rtllib_xmit
;
2954 dev
->wireless_handlers
= (struct iw_handler_def
*)
2955 &r8192_wx_handlers_def
;
2956 dev
->ethtool_ops
= &rtl819x_ethtool_ops
;
2958 dev
->type
= ARPHRD_ETHER
;
2959 dev
->watchdog_timeo
= HZ
* 3;
2961 if (dev_alloc_name(dev
, ifname
) < 0) {
2962 RT_TRACE(COMP_INIT
, "Oops: devname already taken! Trying "
2964 dev_alloc_name(dev
, ifname
);
2967 RT_TRACE(COMP_INIT
, "Driver probe completed1\n");
2968 if (rtl8192_init(dev
) != 0) {
2969 RT_TRACE(COMP_ERR
, "Initialization failed");
2973 netif_carrier_off(dev
);
2974 netif_stop_queue(dev
);
2976 register_netdev(dev
);
2977 RT_TRACE(COMP_INIT
, "dev name: %s\n", dev
->name
);
2978 err
= rtl_debug_module_init(priv
, dev
->name
);
2980 RT_TRACE(COMP_DBG
, "failed to create debugfs files. Ignoring "
2981 "error: %d\n", err
);
2982 rtl8192_proc_init_one(dev
);
2984 if (priv
->polling_timer_on
== 0)
2985 check_rfctrl_gpio_timer((unsigned long)dev
);
2987 RT_TRACE(COMP_INIT
, "Driver probe completed\n");
2991 if (dev
->mem_start
!= (unsigned long)NULL
) {
2992 iounmap((void *)dev
->mem_start
);
2993 release_mem_region(pci_resource_start(pdev
, 1),
2994 pci_resource_len(pdev
, 1));
3000 free_irq(dev
->irq
, dev
);
3006 pci_disable_device(pdev
);
3008 DMESG("wlan driver load failed\n");
3009 pci_set_drvdata(pdev
, NULL
);
3014 static void __devexit
rtl8192_pci_disconnect(struct pci_dev
*pdev
)
3016 struct net_device
*dev
= pci_get_drvdata(pdev
);
3017 struct r8192_priv
*priv
;
3021 unregister_netdev(dev
);
3023 priv
= rtllib_priv(dev
);
3025 del_timer_sync(&priv
->gpio_polling_timer
);
3026 cancel_delayed_work(&priv
->gpio_change_rf_wq
);
3027 priv
->polling_timer_on
= 0;
3028 rtl_debug_module_remove(priv
);
3029 rtl8192_proc_remove_one(dev
);
3030 rtl8192_down(dev
, true);
3032 if (priv
->pFirmware
) {
3033 vfree(priv
->pFirmware
);
3034 priv
->pFirmware
= NULL
;
3036 destroy_workqueue(priv
->priv_wq
);
3037 rtl8192_free_rx_ring(dev
);
3038 for (i
= 0; i
< MAX_TX_QUEUE_COUNT
; i
++)
3039 rtl8192_free_tx_ring(dev
, i
);
3042 printk(KERN_INFO
"Freeing irq %d\n", dev
->irq
);
3043 free_irq(dev
->irq
, dev
);
3048 kfree(priv
->scan_cmd
);
3050 if (dev
->mem_start
!= 0) {
3051 iounmap((void __iomem
*)dev
->mem_start
);
3052 release_mem_region(pci_resource_start(pdev
, 1),
3053 pci_resource_len(pdev
, 1));
3056 priv
= rtllib_priv(dev
);
3059 pci_disable_device(pdev
);
3060 RT_TRACE(COMP_DOWN
, "wlan driver removed\n");
3063 bool NicIFEnableNIC(struct net_device
*dev
)
3065 bool init_status
= true;
3066 struct r8192_priv
*priv
= rtllib_priv(dev
);
3067 struct rt_pwr_save_ctrl
*pPSC
= (struct rt_pwr_save_ctrl
*)
3068 (&(priv
->rtllib
->PowerSaveControl
));
3070 if (IS_NIC_DOWN(priv
)) {
3071 RT_TRACE(COMP_ERR
, "ERR!!! %s(): Driver is already down!\n",
3073 priv
->bdisable_nic
= false;
3074 return RT_STATUS_FAILURE
;
3077 RT_TRACE(COMP_PS
, "===========>%s()\n", __func__
);
3078 priv
->bfirst_init
= true;
3079 init_status
= priv
->ops
->initialize_adapter(dev
);
3080 if (init_status
!= true) {
3081 RT_TRACE(COMP_ERR
, "ERR!!! %s(): initialization is failed!\n",
3083 priv
->bdisable_nic
= false;
3086 RT_TRACE(COMP_INIT
, "start adapter finished\n");
3087 RT_CLEAR_PS_LEVEL(pPSC
, RT_RF_OFF_LEVL_HALT_NIC
);
3088 priv
->bfirst_init
= false;
3090 rtl8192_irq_enable(dev
);
3091 priv
->bdisable_nic
= false;
3092 RT_TRACE(COMP_PS
, "<===========%s()\n", __func__
);
3095 bool NicIFDisableNIC(struct net_device
*dev
)
3098 struct r8192_priv
*priv
= rtllib_priv(dev
);
3100 RT_TRACE(COMP_PS
, "=========>%s()\n", __func__
);
3101 priv
->bdisable_nic
= true;
3102 tmp_state
= priv
->rtllib
->state
;
3103 rtllib_softmac_stop_protocol(priv
->rtllib
, 0, false);
3104 priv
->rtllib
->state
= tmp_state
;
3105 rtl8192_cancel_deferred_work(priv
);
3106 rtl8192_irq_disable(dev
);
3108 priv
->ops
->stop_adapter(dev
, false);
3109 RT_TRACE(COMP_PS
, "<=========%s()\n", __func__
);
3114 static int __init
rtl8192_pci_module_init(void)
3119 ret
= rtllib_init();
3121 printk(KERN_ERR
"rtllib_init() failed %d\n", ret
);
3124 ret
= rtllib_crypto_init();
3126 printk(KERN_ERR
"rtllib_crypto_init() failed %d\n", ret
);
3129 ret
= rtllib_crypto_tkip_init();
3131 printk(KERN_ERR
"rtllib_crypto_tkip_init() failed %d\n", ret
);
3134 ret
= rtllib_crypto_ccmp_init();
3136 printk(KERN_ERR
"rtllib_crypto_ccmp_init() failed %d\n", ret
);
3139 ret
= rtllib_crypto_wep_init();
3141 printk(KERN_ERR
"rtllib_crypto_wep_init() failed %d\n", ret
);
3144 printk(KERN_INFO
"\nLinux kernel driver for RTL8192E WLAN cards\n");
3145 printk(KERN_INFO
"Copyright (c) 2007-2008, Realsil Wlan Driver\n");
3147 error
= rtl_create_debugfs_root();
3149 RT_TRACE(COMP_DBG
, "Create debugfs root fail: %d\n", error
);
3153 rtl8192_proc_module_init();
3154 if (0 != pci_register_driver(&rtl8192_pci_driver
)) {
3155 DMESG("No device found");
3156 /*pci_unregister_driver (&rtl8192_pci_driver);*/
3165 static void __exit
rtl8192_pci_module_exit(void)
3167 pci_unregister_driver(&rtl8192_pci_driver
);
3169 RT_TRACE(COMP_DOWN
, "Exiting");
3170 rtl8192_proc_module_remove();
3171 rtl_remove_debugfs_root();
3172 rtllib_crypto_tkip_exit();
3173 rtllib_crypto_ccmp_exit();
3174 rtllib_crypto_wep_exit();
3175 rtllib_crypto_deinit();
3179 void check_rfctrl_gpio_timer(unsigned long data
)
3181 struct r8192_priv
*priv
= rtllib_priv((struct net_device
*)data
);
3183 priv
->polling_timer_on
= 1;
3185 queue_delayed_work_rsl(priv
->priv_wq
, &priv
->gpio_change_rf_wq
, 0);
3187 mod_timer(&priv
->gpio_polling_timer
, jiffies
+
3188 MSECS(RTLLIB_WATCH_DOG_TIME
));
3191 /***************************************************************************
3192 ------------------- module init / exit stubs ----------------
3193 ****************************************************************************/
3194 module_init(rtl8192_pci_module_init
);
3195 module_exit(rtl8192_pci_module_exit
);
3197 MODULE_DESCRIPTION("Linux driver for Realtek RTL819x WiFi cards");
3198 MODULE_AUTHOR(DRV_COPYRIGHT
" " DRV_AUTHOR
);
3199 MODULE_VERSION(DRV_VERSION
);
3200 MODULE_LICENSE("GPL");
3202 module_param(ifname
, charp
, S_IRUGO
|S_IWUSR
);
3203 module_param(hwwep
, int, S_IRUGO
|S_IWUSR
);
3204 module_param(channels
, int, S_IRUGO
|S_IWUSR
);
3206 MODULE_PARM_DESC(ifname
, " Net interface name, wlan%d=default");
3207 MODULE_PARM_DESC(hwwep
, " Try to use hardware WEP support(default use hw. set 0 to use software security)");
3208 MODULE_PARM_DESC(channels
, " Channel bitmask for specific locales. NYI");