1 /******************************************************************************
3 * Copyright(c) 2003 - 2007 Intel Corporation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
18 * The full GNU General Public License is included in this distribution in the
19 * file called LICENSE.
21 * Contact Information:
22 * James P. Ketrenos <ipw2100-admin@linux.intel.com>
23 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
25 *****************************************************************************/
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/version.h>
30 #include <linux/init.h>
31 #include <linux/pci.h>
32 #include <linux/dma-mapping.h>
33 #include <linux/delay.h>
34 #include <linux/skbuff.h>
35 #include <linux/netdevice.h>
36 #include <linux/wireless.h>
37 #include <net/mac80211.h>
38 #include <linux/etherdevice.h>
39 #include <asm/unaligned.h>
42 #include "iwl-helpers.h"
44 static void iwl4965_hw_card_show_info(struct iwl4965_priv
*priv
);
46 #define IWL_DECLARE_RATE_INFO(r, s, ip, in, rp, rn, pp, np) \
47 [IWL_RATE_##r##M_INDEX] = { IWL_RATE_##r##M_PLCP, \
48 IWL_RATE_SISO_##s##M_PLCP, \
49 IWL_RATE_MIMO_##s##M_PLCP, \
50 IWL_RATE_##r##M_IEEE, \
51 IWL_RATE_##ip##M_INDEX, \
52 IWL_RATE_##in##M_INDEX, \
53 IWL_RATE_##rp##M_INDEX, \
54 IWL_RATE_##rn##M_INDEX, \
55 IWL_RATE_##pp##M_INDEX, \
56 IWL_RATE_##np##M_INDEX }
60 * rate, ht rate, prev rate, next rate, prev tgg rate, next tgg rate
62 * If there isn't a valid next or previous rate then INV is used which
63 * maps to IWL_RATE_INVALID
66 const struct iwl4965_rate_info iwl4965_rates
[IWL_RATE_COUNT
] = {
67 IWL_DECLARE_RATE_INFO(1, INV
, INV
, 2, INV
, 2, INV
, 2), /* 1mbps */
68 IWL_DECLARE_RATE_INFO(2, INV
, 1, 5, 1, 5, 1, 5), /* 2mbps */
69 IWL_DECLARE_RATE_INFO(5, INV
, 2, 6, 2, 11, 2, 11), /*5.5mbps */
70 IWL_DECLARE_RATE_INFO(11, INV
, 9, 12, 9, 12, 5, 18), /* 11mbps */
71 IWL_DECLARE_RATE_INFO(6, 6, 5, 9, 5, 11, 5, 11), /* 6mbps */
72 IWL_DECLARE_RATE_INFO(9, 6, 6, 11, 6, 11, 5, 11), /* 9mbps */
73 IWL_DECLARE_RATE_INFO(12, 12, 11, 18, 11, 18, 11, 18), /* 12mbps */
74 IWL_DECLARE_RATE_INFO(18, 18, 12, 24, 12, 24, 11, 24), /* 18mbps */
75 IWL_DECLARE_RATE_INFO(24, 24, 18, 36, 18, 36, 18, 36), /* 24mbps */
76 IWL_DECLARE_RATE_INFO(36, 36, 24, 48, 24, 48, 24, 48), /* 36mbps */
77 IWL_DECLARE_RATE_INFO(48, 48, 36, 54, 36, 54, 36, 54), /* 48mbps */
78 IWL_DECLARE_RATE_INFO(54, 54, 48, INV
, 48, INV
, 48, INV
),/* 54mbps */
79 IWL_DECLARE_RATE_INFO(60, 60, 48, INV
, 48, INV
, 48, INV
),/* 60mbps */
82 static int is_fat_channel(__le32 rxon_flags
)
84 return (rxon_flags
& RXON_FLG_CHANNEL_MODE_PURE_40_MSK
) ||
85 (rxon_flags
& RXON_FLG_CHANNEL_MODE_MIXED_MSK
);
88 static u8
is_single_stream(struct iwl4965_priv
*priv
)
90 #ifdef CONFIG_IWL4965_HT
91 if (!priv
->current_ht_config
.is_ht
||
92 (priv
->current_ht_config
.supp_mcs_set
[1] == 0) ||
93 (priv
->ps_mode
== IWL_MIMO_PS_STATIC
))
97 #endif /*CONFIG_IWL4965_HT */
102 * Determine how many receiver/antenna chains to use.
103 * More provides better reception via diversity. Fewer saves power.
104 * MIMO (dual stream) requires at least 2, but works better with 3.
105 * This does not determine *which* chains to use, just how many.
107 static int iwl4965_get_rx_chain_counter(struct iwl4965_priv
*priv
,
108 u8
*idle_state
, u8
*rx_state
)
110 u8 is_single
= is_single_stream(priv
);
111 u8 is_cam
= test_bit(STATUS_POWER_PMI
, &priv
->status
) ? 0 : 1;
113 /* # of Rx chains to use when expecting MIMO. */
114 if (is_single
|| (!is_cam
&& (priv
->ps_mode
== IWL_MIMO_PS_STATIC
)))
119 /* # Rx chains when idling and maybe trying to save power */
120 switch (priv
->ps_mode
) {
121 case IWL_MIMO_PS_STATIC
:
122 case IWL_MIMO_PS_DYNAMIC
:
123 *idle_state
= (is_cam
) ? 2 : 1;
125 case IWL_MIMO_PS_NONE
:
126 *idle_state
= (is_cam
) ? *rx_state
: 1;
136 int iwl4965_hw_rxq_stop(struct iwl4965_priv
*priv
)
141 spin_lock_irqsave(&priv
->lock
, flags
);
142 rc
= iwl4965_grab_nic_access(priv
);
144 spin_unlock_irqrestore(&priv
->lock
, flags
);
149 iwl4965_write_direct32(priv
, FH_MEM_RCSR_CHNL0_CONFIG_REG
, 0);
150 rc
= iwl4965_poll_direct_bit(priv
, FH_MEM_RSSR_RX_STATUS_REG
,
153 IWL_ERROR("Can't stop Rx DMA.\n");
155 iwl4965_release_nic_access(priv
);
156 spin_unlock_irqrestore(&priv
->lock
, flags
);
161 u8
iwl4965_hw_find_station(struct iwl4965_priv
*priv
, const u8
*addr
)
165 int ret
= IWL_INVALID_STATION
;
167 DECLARE_MAC_BUF(mac
);
169 if ((priv
->iw_mode
== IEEE80211_IF_TYPE_IBSS
) ||
170 (priv
->iw_mode
== IEEE80211_IF_TYPE_AP
))
173 if (is_broadcast_ether_addr(addr
))
174 return IWL4965_BROADCAST_ID
;
176 spin_lock_irqsave(&priv
->sta_lock
, flags
);
177 for (i
= start
; i
< priv
->hw_setting
.max_stations
; i
++)
178 if ((priv
->stations
[i
].used
) &&
180 (priv
->stations
[i
].sta
.sta
.addr
, addr
))) {
185 IWL_DEBUG_ASSOC_LIMIT("can not find STA %s total %d\n",
186 print_mac(mac
, addr
), priv
->num_stations
);
189 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
193 static int iwl4965_nic_set_pwr_src(struct iwl4965_priv
*priv
, int pwr_max
)
198 spin_lock_irqsave(&priv
->lock
, flags
);
199 ret
= iwl4965_grab_nic_access(priv
);
201 spin_unlock_irqrestore(&priv
->lock
, flags
);
208 ret
= pci_read_config_dword(priv
->pci_dev
, PCI_POWER_SOURCE
,
211 if (val
& PCI_CFG_PMC_PME_FROM_D3COLD_SUPPORT
)
212 iwl4965_set_bits_mask_prph(priv
, APMG_PS_CTRL_REG
,
213 APMG_PS_CTRL_VAL_PWR_SRC_VAUX
,
214 ~APMG_PS_CTRL_MSK_PWR_SRC
);
216 iwl4965_set_bits_mask_prph(priv
, APMG_PS_CTRL_REG
,
217 APMG_PS_CTRL_VAL_PWR_SRC_VMAIN
,
218 ~APMG_PS_CTRL_MSK_PWR_SRC
);
220 iwl4965_release_nic_access(priv
);
221 spin_unlock_irqrestore(&priv
->lock
, flags
);
226 static int iwl4965_rx_init(struct iwl4965_priv
*priv
, struct iwl4965_rx_queue
*rxq
)
230 unsigned int rb_size
;
232 spin_lock_irqsave(&priv
->lock
, flags
);
233 rc
= iwl4965_grab_nic_access(priv
);
235 spin_unlock_irqrestore(&priv
->lock
, flags
);
239 if (iwl4965_param_amsdu_size_8K
)
240 rb_size
= FH_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_8K
;
242 rb_size
= FH_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_4K
;
245 iwl4965_write_direct32(priv
, FH_MEM_RCSR_CHNL0_CONFIG_REG
, 0);
247 /* Reset driver's Rx queue write index */
248 iwl4965_write_direct32(priv
, FH_RSCSR_CHNL0_RBDCB_WPTR_REG
, 0);
250 /* Tell device where to find RBD circular buffer in DRAM */
251 iwl4965_write_direct32(priv
, FH_RSCSR_CHNL0_RBDCB_BASE_REG
,
254 /* Tell device where in DRAM to update its Rx status */
255 iwl4965_write_direct32(priv
, FH_RSCSR_CHNL0_STTS_WPTR_REG
,
256 (priv
->hw_setting
.shared_phys
+
257 offsetof(struct iwl4965_shared
, val0
)) >> 4);
259 /* Enable Rx DMA, enable host interrupt, Rx buffer size 4k, 256 RBDs */
260 iwl4965_write_direct32(priv
, FH_MEM_RCSR_CHNL0_CONFIG_REG
,
261 FH_RCSR_RX_CONFIG_CHNL_EN_ENABLE_VAL
|
262 FH_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_INT_HOST_VAL
|
265 (RX_QUEUE_SIZE_LOG
<<
266 FH_RCSR_RX_CONFIG_RBDCB_SIZE_BITSHIFT
));
269 * iwl4965_write32(priv,CSR_INT_COAL_REG,0);
272 iwl4965_release_nic_access(priv
);
273 spin_unlock_irqrestore(&priv
->lock
, flags
);
278 /* Tell 4965 where to find the "keep warm" buffer */
279 static int iwl4965_kw_init(struct iwl4965_priv
*priv
)
284 spin_lock_irqsave(&priv
->lock
, flags
);
285 rc
= iwl4965_grab_nic_access(priv
);
289 iwl4965_write_direct32(priv
, IWL_FH_KW_MEM_ADDR_REG
,
290 priv
->kw
.dma_addr
>> 4);
291 iwl4965_release_nic_access(priv
);
293 spin_unlock_irqrestore(&priv
->lock
, flags
);
297 static int iwl4965_kw_alloc(struct iwl4965_priv
*priv
)
299 struct pci_dev
*dev
= priv
->pci_dev
;
300 struct iwl4965_kw
*kw
= &priv
->kw
;
302 kw
->size
= IWL4965_KW_SIZE
; /* TBW need set somewhere else */
303 kw
->v_addr
= pci_alloc_consistent(dev
, kw
->size
, &kw
->dma_addr
);
310 #define CHECK_AND_PRINT(x) ((eeprom_ch->flags & EEPROM_CHANNEL_##x) \
314 * iwl4965_set_fat_chan_info - Copy fat channel info into driver's priv.
316 * Does not set up a command, or touch hardware.
318 int iwl4965_set_fat_chan_info(struct iwl4965_priv
*priv
, int phymode
, u16 channel
,
319 const struct iwl4965_eeprom_channel
*eeprom_ch
,
320 u8 fat_extension_channel
)
322 struct iwl4965_channel_info
*ch_info
;
324 ch_info
= (struct iwl4965_channel_info
*)
325 iwl4965_get_channel_info(priv
, phymode
, channel
);
327 if (!is_channel_valid(ch_info
))
330 IWL_DEBUG_INFO("FAT Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x"
331 " %ddBm): Ad-Hoc %ssupported\n",
333 is_channel_a_band(ch_info
) ?
335 CHECK_AND_PRINT(IBSS
),
336 CHECK_AND_PRINT(ACTIVE
),
337 CHECK_AND_PRINT(RADAR
),
338 CHECK_AND_PRINT(WIDE
),
339 CHECK_AND_PRINT(NARROW
),
340 CHECK_AND_PRINT(DFS
),
342 eeprom_ch
->max_power_avg
,
343 ((eeprom_ch
->flags
& EEPROM_CHANNEL_IBSS
)
344 && !(eeprom_ch
->flags
& EEPROM_CHANNEL_RADAR
)) ?
347 ch_info
->fat_eeprom
= *eeprom_ch
;
348 ch_info
->fat_max_power_avg
= eeprom_ch
->max_power_avg
;
349 ch_info
->fat_curr_txpow
= eeprom_ch
->max_power_avg
;
350 ch_info
->fat_min_power
= 0;
351 ch_info
->fat_scan_power
= eeprom_ch
->max_power_avg
;
352 ch_info
->fat_flags
= eeprom_ch
->flags
;
353 ch_info
->fat_extension_channel
= fat_extension_channel
;
359 * iwl4965_kw_free - Free the "keep warm" buffer
361 static void iwl4965_kw_free(struct iwl4965_priv
*priv
)
363 struct pci_dev
*dev
= priv
->pci_dev
;
364 struct iwl4965_kw
*kw
= &priv
->kw
;
367 pci_free_consistent(dev
, kw
->size
, kw
->v_addr
, kw
->dma_addr
);
368 memset(kw
, 0, sizeof(*kw
));
373 * iwl4965_txq_ctx_reset - Reset TX queue context
374 * Destroys all DMA structures and initialise them again
379 static int iwl4965_txq_ctx_reset(struct iwl4965_priv
*priv
)
382 int txq_id
, slots_num
;
385 iwl4965_kw_free(priv
);
387 /* Free all tx/cmd queues and keep-warm buffer */
388 iwl4965_hw_txq_ctx_free(priv
);
390 /* Alloc keep-warm buffer */
391 rc
= iwl4965_kw_alloc(priv
);
393 IWL_ERROR("Keep Warm allocation failed");
397 spin_lock_irqsave(&priv
->lock
, flags
);
399 rc
= iwl4965_grab_nic_access(priv
);
401 IWL_ERROR("TX reset failed");
402 spin_unlock_irqrestore(&priv
->lock
, flags
);
406 /* Turn off all Tx DMA channels */
407 iwl4965_write_prph(priv
, KDR_SCD_TXFACT
, 0);
408 iwl4965_release_nic_access(priv
);
409 spin_unlock_irqrestore(&priv
->lock
, flags
);
411 /* Tell 4965 where to find the keep-warm buffer */
412 rc
= iwl4965_kw_init(priv
);
414 IWL_ERROR("kw_init failed\n");
418 /* Alloc and init all (default 16) Tx queues,
419 * including the command queue (#4) */
420 for (txq_id
= 0; txq_id
< priv
->hw_setting
.max_txq_num
; txq_id
++) {
421 slots_num
= (txq_id
== IWL_CMD_QUEUE_NUM
) ?
422 TFD_CMD_SLOTS
: TFD_TX_CMD_SLOTS
;
423 rc
= iwl4965_tx_queue_init(priv
, &priv
->txq
[txq_id
], slots_num
,
426 IWL_ERROR("Tx %d queue init failed\n", txq_id
);
434 iwl4965_hw_txq_ctx_free(priv
);
436 iwl4965_kw_free(priv
);
441 int iwl4965_hw_nic_init(struct iwl4965_priv
*priv
)
445 struct iwl4965_rx_queue
*rxq
= &priv
->rxq
;
450 iwl4965_power_init_handle(priv
);
453 spin_lock_irqsave(&priv
->lock
, flags
);
455 iwl4965_set_bit(priv
, CSR_GIO_CHICKEN_BITS
,
456 CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER
);
458 iwl4965_set_bit(priv
, CSR_GP_CNTRL
, CSR_GP_CNTRL_REG_FLAG_INIT_DONE
);
459 rc
= iwl4965_poll_bit(priv
, CSR_GP_CNTRL
,
460 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY
,
461 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY
, 25000);
463 spin_unlock_irqrestore(&priv
->lock
, flags
);
464 IWL_DEBUG_INFO("Failed to init the card\n");
468 rc
= iwl4965_grab_nic_access(priv
);
470 spin_unlock_irqrestore(&priv
->lock
, flags
);
474 iwl4965_read_prph(priv
, APMG_CLK_CTRL_REG
);
476 iwl4965_write_prph(priv
, APMG_CLK_CTRL_REG
,
477 APMG_CLK_VAL_DMA_CLK_RQT
|
478 APMG_CLK_VAL_BSM_CLK_RQT
);
479 iwl4965_read_prph(priv
, APMG_CLK_CTRL_REG
);
483 iwl4965_set_bits_prph(priv
, APMG_PCIDEV_STT_REG
,
484 APMG_PCIDEV_STT_VAL_L1_ACT_DIS
);
486 iwl4965_release_nic_access(priv
);
487 iwl4965_write32(priv
, CSR_INT_COALESCING
, 512 / 32);
488 spin_unlock_irqrestore(&priv
->lock
, flags
);
490 /* Determine HW type */
491 rc
= pci_read_config_byte(priv
->pci_dev
, PCI_REVISION_ID
, &rev_id
);
495 IWL_DEBUG_INFO("HW Revision ID = 0x%X\n", rev_id
);
497 iwl4965_nic_set_pwr_src(priv
, 1);
498 spin_lock_irqsave(&priv
->lock
, flags
);
500 if ((rev_id
& 0x80) == 0x80 && (rev_id
& 0x7f) < 8) {
501 pci_read_config_dword(priv
->pci_dev
, PCI_REG_WUM8
, &val
);
502 /* Enable No Snoop field */
503 pci_write_config_dword(priv
->pci_dev
, PCI_REG_WUM8
,
507 spin_unlock_irqrestore(&priv
->lock
, flags
);
509 /* Read the EEPROM */
510 rc
= iwl4965_eeprom_init(priv
);
514 if (priv
->eeprom
.calib_version
< EEPROM_TX_POWER_VERSION_NEW
) {
515 IWL_ERROR("Older EEPROM detected! Aborting.\n");
519 pci_read_config_byte(priv
->pci_dev
, PCI_LINK_CTRL
, &val_link
);
521 /* disable L1 entry -- workaround for pre-B1 */
522 pci_write_config_byte(priv
->pci_dev
, PCI_LINK_CTRL
, val_link
& ~0x02);
524 spin_lock_irqsave(&priv
->lock
, flags
);
526 /* set CSR_HW_CONFIG_REG for uCode use */
528 iwl4965_set_bit(priv
, CSR_SW_VER
, CSR_HW_IF_CONFIG_REG_BIT_KEDRON_R
|
529 CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI
|
530 CSR_HW_IF_CONFIG_REG_BIT_MAC_SI
);
532 rc
= iwl4965_grab_nic_access(priv
);
534 spin_unlock_irqrestore(&priv
->lock
, flags
);
535 IWL_DEBUG_INFO("Failed to init the card\n");
539 iwl4965_read_prph(priv
, APMG_PS_CTRL_REG
);
540 iwl4965_set_bits_prph(priv
, APMG_PS_CTRL_REG
,
541 APMG_PS_CTRL_VAL_RESET_REQ
);
543 iwl4965_clear_bits_prph(priv
, APMG_PS_CTRL_REG
,
544 APMG_PS_CTRL_VAL_RESET_REQ
);
546 iwl4965_release_nic_access(priv
);
547 spin_unlock_irqrestore(&priv
->lock
, flags
);
549 iwl4965_hw_card_show_info(priv
);
553 /* Allocate the RX queue, or reset if it is already allocated */
555 rc
= iwl4965_rx_queue_alloc(priv
);
557 IWL_ERROR("Unable to initialize Rx queue\n");
561 iwl4965_rx_queue_reset(priv
, rxq
);
563 iwl4965_rx_replenish(priv
);
565 iwl4965_rx_init(priv
, rxq
);
567 spin_lock_irqsave(&priv
->lock
, flags
);
569 rxq
->need_update
= 1;
570 iwl4965_rx_queue_update_write_ptr(priv
, rxq
);
572 spin_unlock_irqrestore(&priv
->lock
, flags
);
574 /* Allocate and init all Tx and Command queues */
575 rc
= iwl4965_txq_ctx_reset(priv
);
579 if (priv
->eeprom
.sku_cap
& EEPROM_SKU_CAP_SW_RF_KILL_ENABLE
)
580 IWL_DEBUG_RF_KILL("SW RF KILL supported in EEPROM.\n");
582 if (priv
->eeprom
.sku_cap
& EEPROM_SKU_CAP_HW_RF_KILL_ENABLE
)
583 IWL_DEBUG_RF_KILL("HW RF KILL supported in EEPROM.\n");
585 set_bit(STATUS_INIT
, &priv
->status
);
590 int iwl4965_hw_nic_stop_master(struct iwl4965_priv
*priv
)
596 spin_lock_irqsave(&priv
->lock
, flags
);
598 /* set stop master bit */
599 iwl4965_set_bit(priv
, CSR_RESET
, CSR_RESET_REG_FLAG_STOP_MASTER
);
601 reg_val
= iwl4965_read32(priv
, CSR_GP_CNTRL
);
603 if (CSR_GP_CNTRL_REG_FLAG_MAC_POWER_SAVE
==
604 (reg_val
& CSR_GP_CNTRL_REG_MSK_POWER_SAVE_TYPE
))
605 IWL_DEBUG_INFO("Card in power save, master is already "
608 rc
= iwl4965_poll_bit(priv
, CSR_RESET
,
609 CSR_RESET_REG_FLAG_MASTER_DISABLED
,
610 CSR_RESET_REG_FLAG_MASTER_DISABLED
, 100);
612 spin_unlock_irqrestore(&priv
->lock
, flags
);
617 spin_unlock_irqrestore(&priv
->lock
, flags
);
618 IWL_DEBUG_INFO("stop master\n");
624 * iwl4965_hw_txq_ctx_stop - Stop all Tx DMA channels, free Tx queue memory
626 void iwl4965_hw_txq_ctx_stop(struct iwl4965_priv
*priv
)
632 /* Stop each Tx DMA channel, and wait for it to be idle */
633 for (txq_id
= 0; txq_id
< priv
->hw_setting
.max_txq_num
; txq_id
++) {
634 spin_lock_irqsave(&priv
->lock
, flags
);
635 if (iwl4965_grab_nic_access(priv
)) {
636 spin_unlock_irqrestore(&priv
->lock
, flags
);
640 iwl4965_write_direct32(priv
,
641 IWL_FH_TCSR_CHNL_TX_CONFIG_REG(txq_id
),
643 iwl4965_poll_direct_bit(priv
, IWL_FH_TSSR_TX_STATUS_REG
,
644 IWL_FH_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE
646 iwl4965_release_nic_access(priv
);
647 spin_unlock_irqrestore(&priv
->lock
, flags
);
650 /* Deallocate memory for all Tx queues */
651 iwl4965_hw_txq_ctx_free(priv
);
654 int iwl4965_hw_nic_reset(struct iwl4965_priv
*priv
)
659 iwl4965_hw_nic_stop_master(priv
);
661 spin_lock_irqsave(&priv
->lock
, flags
);
663 iwl4965_set_bit(priv
, CSR_RESET
, CSR_RESET_REG_FLAG_SW_RESET
);
667 iwl4965_set_bit(priv
, CSR_GP_CNTRL
, CSR_GP_CNTRL_REG_FLAG_INIT_DONE
);
668 rc
= iwl4965_poll_bit(priv
, CSR_RESET
,
669 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY
,
670 CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY
, 25);
674 rc
= iwl4965_grab_nic_access(priv
);
676 iwl4965_write_prph(priv
, APMG_CLK_EN_REG
,
677 APMG_CLK_VAL_DMA_CLK_RQT
|
678 APMG_CLK_VAL_BSM_CLK_RQT
);
682 iwl4965_set_bits_prph(priv
, APMG_PCIDEV_STT_REG
,
683 APMG_PCIDEV_STT_VAL_L1_ACT_DIS
);
685 iwl4965_release_nic_access(priv
);
688 clear_bit(STATUS_HCMD_ACTIVE
, &priv
->status
);
689 wake_up_interruptible(&priv
->wait_command_queue
);
691 spin_unlock_irqrestore(&priv
->lock
, flags
);
697 #define REG_RECALIB_PERIOD (60)
700 * iwl4965_bg_statistics_periodic - Timer callback to queue statistics
702 * This callback is provided in order to queue the statistics_work
703 * in work_queue context (v. softirq)
705 * This timer function is continually reset to execute within
706 * REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
707 * was received. We need to ensure we receive the statistics in order
708 * to update the temperature used for calibrating the TXPOWER. However,
709 * we can't send the statistics command from softirq context (which
710 * is the context which timers run at) so we have to queue off the
711 * statistics_work to actually send the command to the hardware.
713 static void iwl4965_bg_statistics_periodic(unsigned long data
)
715 struct iwl4965_priv
*priv
= (struct iwl4965_priv
*)data
;
717 queue_work(priv
->workqueue
, &priv
->statistics_work
);
721 * iwl4965_bg_statistics_work - Send the statistics request to the hardware.
723 * This is queued by iwl4965_bg_statistics_periodic.
725 static void iwl4965_bg_statistics_work(struct work_struct
*work
)
727 struct iwl4965_priv
*priv
= container_of(work
, struct iwl4965_priv
,
730 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
))
733 mutex_lock(&priv
->mutex
);
734 iwl4965_send_statistics_request(priv
);
735 mutex_unlock(&priv
->mutex
);
738 #define CT_LIMIT_CONST 259
739 #define TM_CT_KILL_THRESHOLD 110
741 void iwl4965_rf_kill_ct_config(struct iwl4965_priv
*priv
)
743 struct iwl4965_ct_kill_config cmd
;
746 u32 crit_temperature
;
750 spin_lock_irqsave(&priv
->lock
, flags
);
751 iwl4965_write32(priv
, CSR_UCODE_DRV_GP1_CLR
,
752 CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT
);
753 spin_unlock_irqrestore(&priv
->lock
, flags
);
755 if (priv
->statistics
.flag
& STATISTICS_REPLY_FLG_FAT_MODE_MSK
) {
756 R1
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r1
[1]);
757 R2
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r2
[1]);
758 R3
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r3
[1]);
760 R1
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r1
[0]);
761 R2
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r2
[0]);
762 R3
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r3
[0]);
765 temp_th
= CELSIUS_TO_KELVIN(TM_CT_KILL_THRESHOLD
);
767 crit_temperature
= ((temp_th
* (R3
-R1
))/CT_LIMIT_CONST
) + R2
;
768 cmd
.critical_temperature_R
= cpu_to_le32(crit_temperature
);
769 rc
= iwl4965_send_cmd_pdu(priv
,
770 REPLY_CT_KILL_CONFIG_CMD
, sizeof(cmd
), &cmd
);
772 IWL_ERROR("REPLY_CT_KILL_CONFIG_CMD failed\n");
774 IWL_DEBUG_INFO("REPLY_CT_KILL_CONFIG_CMD succeeded\n");
777 #ifdef CONFIG_IWL4965_SENSITIVITY
779 /* "false alarms" are signals that our DSP tries to lock onto,
780 * but then determines that they are either noise, or transmissions
781 * from a distant wireless network (also "noise", really) that get
782 * "stepped on" by stronger transmissions within our own network.
783 * This algorithm attempts to set a sensitivity level that is high
784 * enough to receive all of our own network traffic, but not so
785 * high that our DSP gets too busy trying to lock onto non-network
787 static int iwl4965_sens_energy_cck(struct iwl4965_priv
*priv
,
790 struct statistics_general_data
*rx_info
)
794 u8 max_silence_rssi
= 0;
796 u8 silence_rssi_a
= 0;
797 u8 silence_rssi_b
= 0;
798 u8 silence_rssi_c
= 0;
801 /* "false_alarms" values below are cross-multiplications to assess the
802 * numbers of false alarms within the measured period of actual Rx
803 * (Rx is off when we're txing), vs the min/max expected false alarms
804 * (some should be expected if rx is sensitive enough) in a
805 * hypothetical listening period of 200 time units (TU), 204.8 msec:
807 * MIN_FA/fixed-time < false_alarms/actual-rx-time < MAX_FA/beacon-time
810 u32 false_alarms
= norm_fa
* 200 * 1024;
811 u32 max_false_alarms
= MAX_FA_CCK
* rx_enable_time
;
812 u32 min_false_alarms
= MIN_FA_CCK
* rx_enable_time
;
813 struct iwl4965_sensitivity_data
*data
= NULL
;
815 data
= &(priv
->sensitivity_data
);
817 data
->nrg_auto_corr_silence_diff
= 0;
819 /* Find max silence rssi among all 3 receivers.
820 * This is background noise, which may include transmissions from other
821 * networks, measured during silence before our network's beacon */
822 silence_rssi_a
= (u8
)((rx_info
->beacon_silence_rssi_a
&
823 ALL_BAND_FILTER
)>>8);
824 silence_rssi_b
= (u8
)((rx_info
->beacon_silence_rssi_b
&
825 ALL_BAND_FILTER
)>>8);
826 silence_rssi_c
= (u8
)((rx_info
->beacon_silence_rssi_c
&
827 ALL_BAND_FILTER
)>>8);
829 val
= max(silence_rssi_b
, silence_rssi_c
);
830 max_silence_rssi
= max(silence_rssi_a
, (u8
) val
);
832 /* Store silence rssi in 20-beacon history table */
833 data
->nrg_silence_rssi
[data
->nrg_silence_idx
] = max_silence_rssi
;
834 data
->nrg_silence_idx
++;
835 if (data
->nrg_silence_idx
>= NRG_NUM_PREV_STAT_L
)
836 data
->nrg_silence_idx
= 0;
838 /* Find max silence rssi across 20 beacon history */
839 for (i
= 0; i
< NRG_NUM_PREV_STAT_L
; i
++) {
840 val
= data
->nrg_silence_rssi
[i
];
841 silence_ref
= max(silence_ref
, val
);
843 IWL_DEBUG_CALIB("silence a %u, b %u, c %u, 20-bcn max %u\n",
844 silence_rssi_a
, silence_rssi_b
, silence_rssi_c
,
847 /* Find max rx energy (min value!) among all 3 receivers,
848 * measured during beacon frame.
849 * Save it in 10-beacon history table. */
850 i
= data
->nrg_energy_idx
;
851 val
= min(rx_info
->beacon_energy_b
, rx_info
->beacon_energy_c
);
852 data
->nrg_value
[i
] = min(rx_info
->beacon_energy_a
, val
);
854 data
->nrg_energy_idx
++;
855 if (data
->nrg_energy_idx
>= 10)
856 data
->nrg_energy_idx
= 0;
858 /* Find min rx energy (max value) across 10 beacon history.
859 * This is the minimum signal level that we want to receive well.
860 * Add backoff (margin so we don't miss slightly lower energy frames).
861 * This establishes an upper bound (min value) for energy threshold. */
862 max_nrg_cck
= data
->nrg_value
[0];
863 for (i
= 1; i
< 10; i
++)
864 max_nrg_cck
= (u32
) max(max_nrg_cck
, (data
->nrg_value
[i
]));
867 IWL_DEBUG_CALIB("rx energy a %u, b %u, c %u, 10-bcn max/min %u\n",
868 rx_info
->beacon_energy_a
, rx_info
->beacon_energy_b
,
869 rx_info
->beacon_energy_c
, max_nrg_cck
- 6);
871 /* Count number of consecutive beacons with fewer-than-desired
873 if (false_alarms
< min_false_alarms
)
874 data
->num_in_cck_no_fa
++;
876 data
->num_in_cck_no_fa
= 0;
877 IWL_DEBUG_CALIB("consecutive bcns with few false alarms = %u\n",
878 data
->num_in_cck_no_fa
);
880 /* If we got too many false alarms this time, reduce sensitivity */
881 if (false_alarms
> max_false_alarms
) {
882 IWL_DEBUG_CALIB("norm FA %u > max FA %u\n",
883 false_alarms
, max_false_alarms
);
884 IWL_DEBUG_CALIB("... reducing sensitivity\n");
885 data
->nrg_curr_state
= IWL_FA_TOO_MANY
;
887 if (data
->auto_corr_cck
> AUTO_CORR_MAX_TH_CCK
) {
888 /* Store for "fewer than desired" on later beacon */
889 data
->nrg_silence_ref
= silence_ref
;
891 /* increase energy threshold (reduce nrg value)
892 * to decrease sensitivity */
893 if (data
->nrg_th_cck
> (NRG_MAX_CCK
+ NRG_STEP_CCK
))
894 data
->nrg_th_cck
= data
->nrg_th_cck
898 /* increase auto_corr values to decrease sensitivity */
899 if (data
->auto_corr_cck
< AUTO_CORR_MAX_TH_CCK
)
900 data
->auto_corr_cck
= AUTO_CORR_MAX_TH_CCK
+ 1;
902 val
= data
->auto_corr_cck
+ AUTO_CORR_STEP_CCK
;
903 data
->auto_corr_cck
= min((u32
)AUTO_CORR_MAX_CCK
, val
);
905 val
= data
->auto_corr_cck_mrc
+ AUTO_CORR_STEP_CCK
;
906 data
->auto_corr_cck_mrc
= min((u32
)AUTO_CORR_MAX_CCK_MRC
, val
);
908 /* Else if we got fewer than desired, increase sensitivity */
909 } else if (false_alarms
< min_false_alarms
) {
910 data
->nrg_curr_state
= IWL_FA_TOO_FEW
;
912 /* Compare silence level with silence level for most recent
913 * healthy number or too many false alarms */
914 data
->nrg_auto_corr_silence_diff
= (s32
)data
->nrg_silence_ref
-
917 IWL_DEBUG_CALIB("norm FA %u < min FA %u, silence diff %d\n",
918 false_alarms
, min_false_alarms
,
919 data
->nrg_auto_corr_silence_diff
);
921 /* Increase value to increase sensitivity, but only if:
922 * 1a) previous beacon did *not* have *too many* false alarms
923 * 1b) AND there's a significant difference in Rx levels
924 * from a previous beacon with too many, or healthy # FAs
925 * OR 2) We've seen a lot of beacons (100) with too few
927 if ((data
->nrg_prev_state
!= IWL_FA_TOO_MANY
) &&
928 ((data
->nrg_auto_corr_silence_diff
> NRG_DIFF
) ||
929 (data
->num_in_cck_no_fa
> MAX_NUMBER_CCK_NO_FA
))) {
931 IWL_DEBUG_CALIB("... increasing sensitivity\n");
932 /* Increase nrg value to increase sensitivity */
933 val
= data
->nrg_th_cck
+ NRG_STEP_CCK
;
934 data
->nrg_th_cck
= min((u32
)NRG_MIN_CCK
, val
);
936 /* Decrease auto_corr values to increase sensitivity */
937 val
= data
->auto_corr_cck
- AUTO_CORR_STEP_CCK
;
938 data
->auto_corr_cck
= max((u32
)AUTO_CORR_MIN_CCK
, val
);
940 val
= data
->auto_corr_cck_mrc
- AUTO_CORR_STEP_CCK
;
941 data
->auto_corr_cck_mrc
=
942 max((u32
)AUTO_CORR_MIN_CCK_MRC
, val
);
945 IWL_DEBUG_CALIB("... but not changing sensitivity\n");
947 /* Else we got a healthy number of false alarms, keep status quo */
949 IWL_DEBUG_CALIB(" FA in safe zone\n");
950 data
->nrg_curr_state
= IWL_FA_GOOD_RANGE
;
952 /* Store for use in "fewer than desired" with later beacon */
953 data
->nrg_silence_ref
= silence_ref
;
955 /* If previous beacon had too many false alarms,
956 * give it some extra margin by reducing sensitivity again
957 * (but don't go below measured energy of desired Rx) */
958 if (IWL_FA_TOO_MANY
== data
->nrg_prev_state
) {
959 IWL_DEBUG_CALIB("... increasing margin\n");
960 data
->nrg_th_cck
-= NRG_MARGIN
;
964 /* Make sure the energy threshold does not go above the measured
965 * energy of the desired Rx signals (reduced by backoff margin),
966 * or else we might start missing Rx frames.
967 * Lower value is higher energy, so we use max()!
969 data
->nrg_th_cck
= max(max_nrg_cck
, data
->nrg_th_cck
);
970 IWL_DEBUG_CALIB("new nrg_th_cck %u\n", data
->nrg_th_cck
);
972 data
->nrg_prev_state
= data
->nrg_curr_state
;
978 static int iwl4965_sens_auto_corr_ofdm(struct iwl4965_priv
*priv
,
983 u32 false_alarms
= norm_fa
* 200 * 1024;
984 u32 max_false_alarms
= MAX_FA_OFDM
* rx_enable_time
;
985 u32 min_false_alarms
= MIN_FA_OFDM
* rx_enable_time
;
986 struct iwl4965_sensitivity_data
*data
= NULL
;
988 data
= &(priv
->sensitivity_data
);
990 /* If we got too many false alarms this time, reduce sensitivity */
991 if (false_alarms
> max_false_alarms
) {
993 IWL_DEBUG_CALIB("norm FA %u > max FA %u)\n",
994 false_alarms
, max_false_alarms
);
996 val
= data
->auto_corr_ofdm
+ AUTO_CORR_STEP_OFDM
;
997 data
->auto_corr_ofdm
=
998 min((u32
)AUTO_CORR_MAX_OFDM
, val
);
1000 val
= data
->auto_corr_ofdm_mrc
+ AUTO_CORR_STEP_OFDM
;
1001 data
->auto_corr_ofdm_mrc
=
1002 min((u32
)AUTO_CORR_MAX_OFDM_MRC
, val
);
1004 val
= data
->auto_corr_ofdm_x1
+ AUTO_CORR_STEP_OFDM
;
1005 data
->auto_corr_ofdm_x1
=
1006 min((u32
)AUTO_CORR_MAX_OFDM_X1
, val
);
1008 val
= data
->auto_corr_ofdm_mrc_x1
+ AUTO_CORR_STEP_OFDM
;
1009 data
->auto_corr_ofdm_mrc_x1
=
1010 min((u32
)AUTO_CORR_MAX_OFDM_MRC_X1
, val
);
1013 /* Else if we got fewer than desired, increase sensitivity */
1014 else if (false_alarms
< min_false_alarms
) {
1016 IWL_DEBUG_CALIB("norm FA %u < min FA %u\n",
1017 false_alarms
, min_false_alarms
);
1019 val
= data
->auto_corr_ofdm
- AUTO_CORR_STEP_OFDM
;
1020 data
->auto_corr_ofdm
=
1021 max((u32
)AUTO_CORR_MIN_OFDM
, val
);
1023 val
= data
->auto_corr_ofdm_mrc
- AUTO_CORR_STEP_OFDM
;
1024 data
->auto_corr_ofdm_mrc
=
1025 max((u32
)AUTO_CORR_MIN_OFDM_MRC
, val
);
1027 val
= data
->auto_corr_ofdm_x1
- AUTO_CORR_STEP_OFDM
;
1028 data
->auto_corr_ofdm_x1
=
1029 max((u32
)AUTO_CORR_MIN_OFDM_X1
, val
);
1031 val
= data
->auto_corr_ofdm_mrc_x1
- AUTO_CORR_STEP_OFDM
;
1032 data
->auto_corr_ofdm_mrc_x1
=
1033 max((u32
)AUTO_CORR_MIN_OFDM_MRC_X1
, val
);
1037 IWL_DEBUG_CALIB("min FA %u < norm FA %u < max FA %u OK\n",
1038 min_false_alarms
, false_alarms
, max_false_alarms
);
1043 static int iwl4965_sensitivity_callback(struct iwl4965_priv
*priv
,
1044 struct iwl4965_cmd
*cmd
, struct sk_buff
*skb
)
1046 /* We didn't cache the SKB; let the caller free it */
1050 /* Prepare a SENSITIVITY_CMD, send to uCode if values have changed */
1051 static int iwl4965_sensitivity_write(struct iwl4965_priv
*priv
, u8 flags
)
1054 struct iwl4965_sensitivity_cmd cmd
;
1055 struct iwl4965_sensitivity_data
*data
= NULL
;
1056 struct iwl4965_host_cmd cmd_out
= {
1057 .id
= SENSITIVITY_CMD
,
1058 .len
= sizeof(struct iwl4965_sensitivity_cmd
),
1059 .meta
.flags
= flags
,
1063 data
= &(priv
->sensitivity_data
);
1065 memset(&cmd
, 0, sizeof(cmd
));
1067 cmd
.table
[HD_AUTO_CORR32_X4_TH_ADD_MIN_INDEX
] =
1068 cpu_to_le16((u16
)data
->auto_corr_ofdm
);
1069 cmd
.table
[HD_AUTO_CORR32_X4_TH_ADD_MIN_MRC_INDEX
] =
1070 cpu_to_le16((u16
)data
->auto_corr_ofdm_mrc
);
1071 cmd
.table
[HD_AUTO_CORR32_X1_TH_ADD_MIN_INDEX
] =
1072 cpu_to_le16((u16
)data
->auto_corr_ofdm_x1
);
1073 cmd
.table
[HD_AUTO_CORR32_X1_TH_ADD_MIN_MRC_INDEX
] =
1074 cpu_to_le16((u16
)data
->auto_corr_ofdm_mrc_x1
);
1076 cmd
.table
[HD_AUTO_CORR40_X4_TH_ADD_MIN_INDEX
] =
1077 cpu_to_le16((u16
)data
->auto_corr_cck
);
1078 cmd
.table
[HD_AUTO_CORR40_X4_TH_ADD_MIN_MRC_INDEX
] =
1079 cpu_to_le16((u16
)data
->auto_corr_cck_mrc
);
1081 cmd
.table
[HD_MIN_ENERGY_CCK_DET_INDEX
] =
1082 cpu_to_le16((u16
)data
->nrg_th_cck
);
1083 cmd
.table
[HD_MIN_ENERGY_OFDM_DET_INDEX
] =
1084 cpu_to_le16((u16
)data
->nrg_th_ofdm
);
1086 cmd
.table
[HD_BARKER_CORR_TH_ADD_MIN_INDEX
] =
1087 __constant_cpu_to_le16(190);
1088 cmd
.table
[HD_BARKER_CORR_TH_ADD_MIN_MRC_INDEX
] =
1089 __constant_cpu_to_le16(390);
1090 cmd
.table
[HD_OFDM_ENERGY_TH_IN_INDEX
] =
1091 __constant_cpu_to_le16(62);
1093 IWL_DEBUG_CALIB("ofdm: ac %u mrc %u x1 %u mrc_x1 %u thresh %u\n",
1094 data
->auto_corr_ofdm
, data
->auto_corr_ofdm_mrc
,
1095 data
->auto_corr_ofdm_x1
, data
->auto_corr_ofdm_mrc_x1
,
1098 IWL_DEBUG_CALIB("cck: ac %u mrc %u thresh %u\n",
1099 data
->auto_corr_cck
, data
->auto_corr_cck_mrc
,
1102 /* Update uCode's "work" table, and copy it to DSP */
1103 cmd
.control
= SENSITIVITY_CMD_CONTROL_WORK_TABLE
;
1105 if (flags
& CMD_ASYNC
)
1106 cmd_out
.meta
.u
.callback
= iwl4965_sensitivity_callback
;
1108 /* Don't send command to uCode if nothing has changed */
1109 if (!memcmp(&cmd
.table
[0], &(priv
->sensitivity_tbl
[0]),
1110 sizeof(u16
)*HD_TABLE_SIZE
)) {
1111 IWL_DEBUG_CALIB("No change in SENSITIVITY_CMD\n");
1115 /* Copy table for comparison next time */
1116 memcpy(&(priv
->sensitivity_tbl
[0]), &(cmd
.table
[0]),
1117 sizeof(u16
)*HD_TABLE_SIZE
);
1119 rc
= iwl4965_send_cmd(priv
, &cmd_out
);
1121 IWL_DEBUG_CALIB("SENSITIVITY_CMD succeeded\n");
1128 void iwl4965_init_sensitivity(struct iwl4965_priv
*priv
, u8 flags
, u8 force
)
1132 struct iwl4965_sensitivity_data
*data
= NULL
;
1134 IWL_DEBUG_CALIB("Start iwl4965_init_sensitivity\n");
1137 memset(&(priv
->sensitivity_tbl
[0]), 0,
1138 sizeof(u16
)*HD_TABLE_SIZE
);
1140 /* Clear driver's sensitivity algo data */
1141 data
= &(priv
->sensitivity_data
);
1142 memset(data
, 0, sizeof(struct iwl4965_sensitivity_data
));
1144 data
->num_in_cck_no_fa
= 0;
1145 data
->nrg_curr_state
= IWL_FA_TOO_MANY
;
1146 data
->nrg_prev_state
= IWL_FA_TOO_MANY
;
1147 data
->nrg_silence_ref
= 0;
1148 data
->nrg_silence_idx
= 0;
1149 data
->nrg_energy_idx
= 0;
1151 for (i
= 0; i
< 10; i
++)
1152 data
->nrg_value
[i
] = 0;
1154 for (i
= 0; i
< NRG_NUM_PREV_STAT_L
; i
++)
1155 data
->nrg_silence_rssi
[i
] = 0;
1157 data
->auto_corr_ofdm
= 90;
1158 data
->auto_corr_ofdm_mrc
= 170;
1159 data
->auto_corr_ofdm_x1
= 105;
1160 data
->auto_corr_ofdm_mrc_x1
= 220;
1161 data
->auto_corr_cck
= AUTO_CORR_CCK_MIN_VAL_DEF
;
1162 data
->auto_corr_cck_mrc
= 200;
1163 data
->nrg_th_cck
= 100;
1164 data
->nrg_th_ofdm
= 100;
1166 data
->last_bad_plcp_cnt_ofdm
= 0;
1167 data
->last_fa_cnt_ofdm
= 0;
1168 data
->last_bad_plcp_cnt_cck
= 0;
1169 data
->last_fa_cnt_cck
= 0;
1171 /* Clear prior Sensitivity command data to force send to uCode */
1173 memset(&(priv
->sensitivity_tbl
[0]), 0,
1174 sizeof(u16
)*HD_TABLE_SIZE
);
1176 rc
|= iwl4965_sensitivity_write(priv
, flags
);
1177 IWL_DEBUG_CALIB("<<return 0x%X\n", rc
);
1183 /* Reset differential Rx gains in NIC to prepare for chain noise calibration.
1184 * Called after every association, but this runs only once!
1185 * ... once chain noise is calibrated the first time, it's good forever. */
1186 void iwl4965_chain_noise_reset(struct iwl4965_priv
*priv
)
1188 struct iwl4965_chain_noise_data
*data
= NULL
;
1191 data
= &(priv
->chain_noise_data
);
1192 if ((data
->state
== IWL_CHAIN_NOISE_ALIVE
) && iwl4965_is_associated(priv
)) {
1193 struct iwl4965_calibration_cmd cmd
;
1195 memset(&cmd
, 0, sizeof(cmd
));
1196 cmd
.opCode
= PHY_CALIBRATE_DIFF_GAIN_CMD
;
1197 cmd
.diff_gain_a
= 0;
1198 cmd
.diff_gain_b
= 0;
1199 cmd
.diff_gain_c
= 0;
1200 rc
= iwl4965_send_cmd_pdu(priv
, REPLY_PHY_CALIBRATION_CMD
,
1203 data
->state
= IWL_CHAIN_NOISE_ACCUMULATE
;
1204 IWL_DEBUG_CALIB("Run chain_noise_calibrate\n");
1210 * Accumulate 20 beacons of signal and noise statistics for each of
1211 * 3 receivers/antennas/rx-chains, then figure out:
1212 * 1) Which antennas are connected.
1213 * 2) Differential rx gain settings to balance the 3 receivers.
1215 static void iwl4965_noise_calibration(struct iwl4965_priv
*priv
,
1216 struct iwl4965_notif_statistics
*stat_resp
)
1218 struct iwl4965_chain_noise_data
*data
= NULL
;
1227 u32 average_sig
[NUM_RX_CHAINS
] = {INITIALIZATION_VALUE
};
1228 u32 average_noise
[NUM_RX_CHAINS
] = {INITIALIZATION_VALUE
};
1229 u32 max_average_sig
;
1230 u16 max_average_sig_antenna_i
;
1231 u32 min_average_noise
= MIN_AVERAGE_NOISE_MAX_VALUE
;
1232 u16 min_average_noise_antenna_i
= INITIALIZATION_VALUE
;
1234 u16 chan_num
= INITIALIZATION_VALUE
;
1235 u32 band
= INITIALIZATION_VALUE
;
1236 u32 active_chains
= 0;
1237 unsigned long flags
;
1238 struct statistics_rx_non_phy
*rx_info
= &(stat_resp
->rx
.general
);
1240 data
= &(priv
->chain_noise_data
);
1242 /* Accumulate just the first 20 beacons after the first association,
1243 * then we're done forever. */
1244 if (data
->state
!= IWL_CHAIN_NOISE_ACCUMULATE
) {
1245 if (data
->state
== IWL_CHAIN_NOISE_ALIVE
)
1246 IWL_DEBUG_CALIB("Wait for noise calib reset\n");
1250 spin_lock_irqsave(&priv
->lock
, flags
);
1251 if (rx_info
->interference_data_flag
!= INTERFERENCE_DATA_AVAILABLE
) {
1252 IWL_DEBUG_CALIB(" << Interference data unavailable\n");
1253 spin_unlock_irqrestore(&priv
->lock
, flags
);
1257 band
= (priv
->staging_rxon
.flags
& RXON_FLG_BAND_24G_MSK
) ? 0 : 1;
1258 chan_num
= le16_to_cpu(priv
->staging_rxon
.channel
);
1260 /* Make sure we accumulate data for just the associated channel
1261 * (even if scanning). */
1262 if ((chan_num
!= (le32_to_cpu(stat_resp
->flag
) >> 16)) ||
1263 ((STATISTICS_REPLY_FLG_BAND_24G_MSK
==
1264 (stat_resp
->flag
& STATISTICS_REPLY_FLG_BAND_24G_MSK
)) && band
)) {
1265 IWL_DEBUG_CALIB("Stats not from chan=%d, band=%d\n",
1267 spin_unlock_irqrestore(&priv
->lock
, flags
);
1271 /* Accumulate beacon statistics values across 20 beacons */
1272 chain_noise_a
= le32_to_cpu(rx_info
->beacon_silence_rssi_a
) &
1274 chain_noise_b
= le32_to_cpu(rx_info
->beacon_silence_rssi_b
) &
1276 chain_noise_c
= le32_to_cpu(rx_info
->beacon_silence_rssi_c
) &
1279 chain_sig_a
= le32_to_cpu(rx_info
->beacon_rssi_a
) & IN_BAND_FILTER
;
1280 chain_sig_b
= le32_to_cpu(rx_info
->beacon_rssi_b
) & IN_BAND_FILTER
;
1281 chain_sig_c
= le32_to_cpu(rx_info
->beacon_rssi_c
) & IN_BAND_FILTER
;
1283 spin_unlock_irqrestore(&priv
->lock
, flags
);
1285 data
->beacon_count
++;
1287 data
->chain_noise_a
= (chain_noise_a
+ data
->chain_noise_a
);
1288 data
->chain_noise_b
= (chain_noise_b
+ data
->chain_noise_b
);
1289 data
->chain_noise_c
= (chain_noise_c
+ data
->chain_noise_c
);
1291 data
->chain_signal_a
= (chain_sig_a
+ data
->chain_signal_a
);
1292 data
->chain_signal_b
= (chain_sig_b
+ data
->chain_signal_b
);
1293 data
->chain_signal_c
= (chain_sig_c
+ data
->chain_signal_c
);
1295 IWL_DEBUG_CALIB("chan=%d, band=%d, beacon=%d\n", chan_num
, band
,
1296 data
->beacon_count
);
1297 IWL_DEBUG_CALIB("chain_sig: a %d b %d c %d\n",
1298 chain_sig_a
, chain_sig_b
, chain_sig_c
);
1299 IWL_DEBUG_CALIB("chain_noise: a %d b %d c %d\n",
1300 chain_noise_a
, chain_noise_b
, chain_noise_c
);
1302 /* If this is the 20th beacon, determine:
1303 * 1) Disconnected antennas (using signal strengths)
1304 * 2) Differential gain (using silence noise) to balance receivers */
1305 if (data
->beacon_count
== CAL_NUM_OF_BEACONS
) {
1307 /* Analyze signal for disconnected antenna */
1308 average_sig
[0] = (data
->chain_signal_a
) / CAL_NUM_OF_BEACONS
;
1309 average_sig
[1] = (data
->chain_signal_b
) / CAL_NUM_OF_BEACONS
;
1310 average_sig
[2] = (data
->chain_signal_c
) / CAL_NUM_OF_BEACONS
;
1312 if (average_sig
[0] >= average_sig
[1]) {
1313 max_average_sig
= average_sig
[0];
1314 max_average_sig_antenna_i
= 0;
1315 active_chains
= (1 << max_average_sig_antenna_i
);
1317 max_average_sig
= average_sig
[1];
1318 max_average_sig_antenna_i
= 1;
1319 active_chains
= (1 << max_average_sig_antenna_i
);
1322 if (average_sig
[2] >= max_average_sig
) {
1323 max_average_sig
= average_sig
[2];
1324 max_average_sig_antenna_i
= 2;
1325 active_chains
= (1 << max_average_sig_antenna_i
);
1328 IWL_DEBUG_CALIB("average_sig: a %d b %d c %d\n",
1329 average_sig
[0], average_sig
[1], average_sig
[2]);
1330 IWL_DEBUG_CALIB("max_average_sig = %d, antenna %d\n",
1331 max_average_sig
, max_average_sig_antenna_i
);
1333 /* Compare signal strengths for all 3 receivers. */
1334 for (i
= 0; i
< NUM_RX_CHAINS
; i
++) {
1335 if (i
!= max_average_sig_antenna_i
) {
1336 s32 rssi_delta
= (max_average_sig
-
1339 /* If signal is very weak, compared with
1340 * strongest, mark it as disconnected. */
1341 if (rssi_delta
> MAXIMUM_ALLOWED_PATHLOSS
)
1342 data
->disconn_array
[i
] = 1;
1344 active_chains
|= (1 << i
);
1345 IWL_DEBUG_CALIB("i = %d rssiDelta = %d "
1346 "disconn_array[i] = %d\n",
1347 i
, rssi_delta
, data
->disconn_array
[i
]);
1351 /*If both chains A & B are disconnected -
1352 * connect B and leave A as is */
1353 if (data
->disconn_array
[CHAIN_A
] &&
1354 data
->disconn_array
[CHAIN_B
]) {
1355 data
->disconn_array
[CHAIN_B
] = 0;
1356 active_chains
|= (1 << CHAIN_B
);
1357 IWL_DEBUG_CALIB("both A & B chains are disconnected! "
1358 "W/A - declare B as connected\n");
1361 IWL_DEBUG_CALIB("active_chains (bitwise) = 0x%x\n",
1364 /* Save for use within RXON, TX, SCAN commands, etc. */
1365 priv
->valid_antenna
= active_chains
;
1367 /* Analyze noise for rx balance */
1368 average_noise
[0] = ((data
->chain_noise_a
)/CAL_NUM_OF_BEACONS
);
1369 average_noise
[1] = ((data
->chain_noise_b
)/CAL_NUM_OF_BEACONS
);
1370 average_noise
[2] = ((data
->chain_noise_c
)/CAL_NUM_OF_BEACONS
);
1372 for (i
= 0; i
< NUM_RX_CHAINS
; i
++) {
1373 if (!(data
->disconn_array
[i
]) &&
1374 (average_noise
[i
] <= min_average_noise
)) {
1375 /* This means that chain i is active and has
1376 * lower noise values so far: */
1377 min_average_noise
= average_noise
[i
];
1378 min_average_noise_antenna_i
= i
;
1382 data
->delta_gain_code
[min_average_noise_antenna_i
] = 0;
1384 IWL_DEBUG_CALIB("average_noise: a %d b %d c %d\n",
1385 average_noise
[0], average_noise
[1],
1388 IWL_DEBUG_CALIB("min_average_noise = %d, antenna %d\n",
1389 min_average_noise
, min_average_noise_antenna_i
);
1391 for (i
= 0; i
< NUM_RX_CHAINS
; i
++) {
1394 if (!(data
->disconn_array
[i
]) &&
1395 (data
->delta_gain_code
[i
] ==
1396 CHAIN_NOISE_DELTA_GAIN_INIT_VAL
)) {
1397 delta_g
= average_noise
[i
] - min_average_noise
;
1398 data
->delta_gain_code
[i
] = (u8
)((delta_g
*
1400 if (CHAIN_NOISE_MAX_DELTA_GAIN_CODE
<
1401 data
->delta_gain_code
[i
])
1402 data
->delta_gain_code
[i
] =
1403 CHAIN_NOISE_MAX_DELTA_GAIN_CODE
;
1405 data
->delta_gain_code
[i
] =
1406 (data
->delta_gain_code
[i
] | (1 << 2));
1408 data
->delta_gain_code
[i
] = 0;
1410 IWL_DEBUG_CALIB("delta_gain_codes: a %d b %d c %d\n",
1411 data
->delta_gain_code
[0],
1412 data
->delta_gain_code
[1],
1413 data
->delta_gain_code
[2]);
1415 /* Differential gain gets sent to uCode only once */
1416 if (!data
->radio_write
) {
1417 struct iwl4965_calibration_cmd cmd
;
1418 data
->radio_write
= 1;
1420 memset(&cmd
, 0, sizeof(cmd
));
1421 cmd
.opCode
= PHY_CALIBRATE_DIFF_GAIN_CMD
;
1422 cmd
.diff_gain_a
= data
->delta_gain_code
[0];
1423 cmd
.diff_gain_b
= data
->delta_gain_code
[1];
1424 cmd
.diff_gain_c
= data
->delta_gain_code
[2];
1425 rc
= iwl4965_send_cmd_pdu(priv
, REPLY_PHY_CALIBRATION_CMD
,
1428 IWL_DEBUG_CALIB("fail sending cmd "
1429 "REPLY_PHY_CALIBRATION_CMD \n");
1431 /* TODO we might want recalculate
1432 * rx_chain in rxon cmd */
1434 /* Mark so we run this algo only once! */
1435 data
->state
= IWL_CHAIN_NOISE_CALIBRATED
;
1437 data
->chain_noise_a
= 0;
1438 data
->chain_noise_b
= 0;
1439 data
->chain_noise_c
= 0;
1440 data
->chain_signal_a
= 0;
1441 data
->chain_signal_b
= 0;
1442 data
->chain_signal_c
= 0;
1443 data
->beacon_count
= 0;
1448 static void iwl4965_sensitivity_calibration(struct iwl4965_priv
*priv
,
1449 struct iwl4965_notif_statistics
*resp
)
1459 struct iwl4965_sensitivity_data
*data
= NULL
;
1460 struct statistics_rx_non_phy
*rx_info
= &(resp
->rx
.general
);
1461 struct statistics_rx
*statistics
= &(resp
->rx
);
1462 unsigned long flags
;
1463 struct statistics_general_data statis
;
1465 data
= &(priv
->sensitivity_data
);
1467 if (!iwl4965_is_associated(priv
)) {
1468 IWL_DEBUG_CALIB("<< - not associated\n");
1472 spin_lock_irqsave(&priv
->lock
, flags
);
1473 if (rx_info
->interference_data_flag
!= INTERFERENCE_DATA_AVAILABLE
) {
1474 IWL_DEBUG_CALIB("<< invalid data.\n");
1475 spin_unlock_irqrestore(&priv
->lock
, flags
);
1479 /* Extract Statistics: */
1480 rx_enable_time
= le32_to_cpu(rx_info
->channel_load
);
1481 fa_cck
= le32_to_cpu(statistics
->cck
.false_alarm_cnt
);
1482 fa_ofdm
= le32_to_cpu(statistics
->ofdm
.false_alarm_cnt
);
1483 bad_plcp_cck
= le32_to_cpu(statistics
->cck
.plcp_err
);
1484 bad_plcp_ofdm
= le32_to_cpu(statistics
->ofdm
.plcp_err
);
1486 statis
.beacon_silence_rssi_a
=
1487 le32_to_cpu(statistics
->general
.beacon_silence_rssi_a
);
1488 statis
.beacon_silence_rssi_b
=
1489 le32_to_cpu(statistics
->general
.beacon_silence_rssi_b
);
1490 statis
.beacon_silence_rssi_c
=
1491 le32_to_cpu(statistics
->general
.beacon_silence_rssi_c
);
1492 statis
.beacon_energy_a
=
1493 le32_to_cpu(statistics
->general
.beacon_energy_a
);
1494 statis
.beacon_energy_b
=
1495 le32_to_cpu(statistics
->general
.beacon_energy_b
);
1496 statis
.beacon_energy_c
=
1497 le32_to_cpu(statistics
->general
.beacon_energy_c
);
1499 spin_unlock_irqrestore(&priv
->lock
, flags
);
1501 IWL_DEBUG_CALIB("rx_enable_time = %u usecs\n", rx_enable_time
);
1503 if (!rx_enable_time
) {
1504 IWL_DEBUG_CALIB("<< RX Enable Time == 0! \n");
1508 /* These statistics increase monotonically, and do not reset
1509 * at each beacon. Calculate difference from last value, or just
1510 * use the new statistics value if it has reset or wrapped around. */
1511 if (data
->last_bad_plcp_cnt_cck
> bad_plcp_cck
)
1512 data
->last_bad_plcp_cnt_cck
= bad_plcp_cck
;
1514 bad_plcp_cck
-= data
->last_bad_plcp_cnt_cck
;
1515 data
->last_bad_plcp_cnt_cck
+= bad_plcp_cck
;
1518 if (data
->last_bad_plcp_cnt_ofdm
> bad_plcp_ofdm
)
1519 data
->last_bad_plcp_cnt_ofdm
= bad_plcp_ofdm
;
1521 bad_plcp_ofdm
-= data
->last_bad_plcp_cnt_ofdm
;
1522 data
->last_bad_plcp_cnt_ofdm
+= bad_plcp_ofdm
;
1525 if (data
->last_fa_cnt_ofdm
> fa_ofdm
)
1526 data
->last_fa_cnt_ofdm
= fa_ofdm
;
1528 fa_ofdm
-= data
->last_fa_cnt_ofdm
;
1529 data
->last_fa_cnt_ofdm
+= fa_ofdm
;
1532 if (data
->last_fa_cnt_cck
> fa_cck
)
1533 data
->last_fa_cnt_cck
= fa_cck
;
1535 fa_cck
-= data
->last_fa_cnt_cck
;
1536 data
->last_fa_cnt_cck
+= fa_cck
;
1539 /* Total aborted signal locks */
1540 norm_fa_ofdm
= fa_ofdm
+ bad_plcp_ofdm
;
1541 norm_fa_cck
= fa_cck
+ bad_plcp_cck
;
1543 IWL_DEBUG_CALIB("cck: fa %u badp %u ofdm: fa %u badp %u\n", fa_cck
,
1544 bad_plcp_cck
, fa_ofdm
, bad_plcp_ofdm
);
1546 iwl4965_sens_auto_corr_ofdm(priv
, norm_fa_ofdm
, rx_enable_time
);
1547 iwl4965_sens_energy_cck(priv
, norm_fa_cck
, rx_enable_time
, &statis
);
1548 rc
|= iwl4965_sensitivity_write(priv
, CMD_ASYNC
);
1553 static void iwl4965_bg_sensitivity_work(struct work_struct
*work
)
1555 struct iwl4965_priv
*priv
= container_of(work
, struct iwl4965_priv
,
1558 mutex_lock(&priv
->mutex
);
1560 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
) ||
1561 test_bit(STATUS_SCANNING
, &priv
->status
)) {
1562 mutex_unlock(&priv
->mutex
);
1566 if (priv
->start_calib
) {
1567 iwl4965_noise_calibration(priv
, &priv
->statistics
);
1569 if (priv
->sensitivity_data
.state
==
1570 IWL_SENS_CALIB_NEED_REINIT
) {
1571 iwl4965_init_sensitivity(priv
, CMD_ASYNC
, 0);
1572 priv
->sensitivity_data
.state
= IWL_SENS_CALIB_ALLOWED
;
1574 iwl4965_sensitivity_calibration(priv
,
1578 mutex_unlock(&priv
->mutex
);
1581 #endif /*CONFIG_IWL4965_SENSITIVITY*/
1583 static void iwl4965_bg_txpower_work(struct work_struct
*work
)
1585 struct iwl4965_priv
*priv
= container_of(work
, struct iwl4965_priv
,
1588 /* If a scan happened to start before we got here
1589 * then just return; the statistics notification will
1590 * kick off another scheduled work to compensate for
1591 * any temperature delta we missed here. */
1592 if (test_bit(STATUS_EXIT_PENDING
, &priv
->status
) ||
1593 test_bit(STATUS_SCANNING
, &priv
->status
))
1596 mutex_lock(&priv
->mutex
);
1598 /* Regardless of if we are assocaited, we must reconfigure the
1599 * TX power since frames can be sent on non-radar channels while
1601 iwl4965_hw_reg_send_txpower(priv
);
1603 /* Update last_temperature to keep is_calib_needed from running
1604 * when it isn't needed... */
1605 priv
->last_temperature
= priv
->temperature
;
1607 mutex_unlock(&priv
->mutex
);
1611 * Acquire priv->lock before calling this function !
1613 static void iwl4965_set_wr_ptrs(struct iwl4965_priv
*priv
, int txq_id
, u32 index
)
1615 iwl4965_write_direct32(priv
, HBUS_TARG_WRPTR
,
1616 (index
& 0xff) | (txq_id
<< 8));
1617 iwl4965_write_prph(priv
, KDR_SCD_QUEUE_RDPTR(txq_id
), index
);
1621 * iwl4965_tx_queue_set_status - (optionally) start Tx/Cmd queue
1622 * @tx_fifo_id: Tx DMA/FIFO channel (range 0-7) that the queue will feed
1623 * @scd_retry: (1) Indicates queue will be used in aggregation mode
1625 * NOTE: Acquire priv->lock before calling this function !
1627 static void iwl4965_tx_queue_set_status(struct iwl4965_priv
*priv
,
1628 struct iwl4965_tx_queue
*txq
,
1629 int tx_fifo_id
, int scd_retry
)
1631 int txq_id
= txq
->q
.id
;
1633 /* Find out whether to activate Tx queue */
1634 int active
= test_bit(txq_id
, &priv
->txq_ctx_active_msk
)?1:0;
1636 /* Set up and activate */
1637 iwl4965_write_prph(priv
, KDR_SCD_QUEUE_STATUS_BITS(txq_id
),
1638 (active
<< SCD_QUEUE_STTS_REG_POS_ACTIVE
) |
1639 (tx_fifo_id
<< SCD_QUEUE_STTS_REG_POS_TXF
) |
1640 (scd_retry
<< SCD_QUEUE_STTS_REG_POS_WSL
) |
1641 (scd_retry
<< SCD_QUEUE_STTS_REG_POS_SCD_ACK
) |
1642 SCD_QUEUE_STTS_REG_MSK
);
1644 txq
->sched_retry
= scd_retry
;
1646 IWL_DEBUG_INFO("%s %s Queue %d on AC %d\n",
1647 active
? "Activate" : "Deactivate",
1648 scd_retry
? "BA" : "AC", txq_id
, tx_fifo_id
);
1651 static const u16 default_queue_to_tx_fifo
[] = {
1661 static inline void iwl4965_txq_ctx_activate(struct iwl4965_priv
*priv
, int txq_id
)
1663 set_bit(txq_id
, &priv
->txq_ctx_active_msk
);
1666 static inline void iwl4965_txq_ctx_deactivate(struct iwl4965_priv
*priv
, int txq_id
)
1668 clear_bit(txq_id
, &priv
->txq_ctx_active_msk
);
1671 int iwl4965_alive_notify(struct iwl4965_priv
*priv
)
1675 unsigned long flags
;
1678 spin_lock_irqsave(&priv
->lock
, flags
);
1680 #ifdef CONFIG_IWL4965_SENSITIVITY
1681 memset(&(priv
->sensitivity_data
), 0,
1682 sizeof(struct iwl4965_sensitivity_data
));
1683 memset(&(priv
->chain_noise_data
), 0,
1684 sizeof(struct iwl4965_chain_noise_data
));
1685 for (i
= 0; i
< NUM_RX_CHAINS
; i
++)
1686 priv
->chain_noise_data
.delta_gain_code
[i
] =
1687 CHAIN_NOISE_DELTA_GAIN_INIT_VAL
;
1688 #endif /* CONFIG_IWL4965_SENSITIVITY*/
1689 rc
= iwl4965_grab_nic_access(priv
);
1691 spin_unlock_irqrestore(&priv
->lock
, flags
);
1695 /* Clear 4965's internal Tx Scheduler data base */
1696 priv
->scd_base_addr
= iwl4965_read_prph(priv
, KDR_SCD_SRAM_BASE_ADDR
);
1697 a
= priv
->scd_base_addr
+ SCD_CONTEXT_DATA_OFFSET
;
1698 for (; a
< priv
->scd_base_addr
+ SCD_TX_STTS_BITMAP_OFFSET
; a
+= 4)
1699 iwl4965_write_targ_mem(priv
, a
, 0);
1700 for (; a
< priv
->scd_base_addr
+ SCD_TRANSLATE_TBL_OFFSET
; a
+= 4)
1701 iwl4965_write_targ_mem(priv
, a
, 0);
1702 for (; a
< sizeof(u16
) * priv
->hw_setting
.max_txq_num
; a
+= 4)
1703 iwl4965_write_targ_mem(priv
, a
, 0);
1705 /* Tel 4965 where to find Tx byte count tables */
1706 iwl4965_write_prph(priv
, KDR_SCD_DRAM_BASE_ADDR
,
1707 (priv
->hw_setting
.shared_phys
+
1708 offsetof(struct iwl4965_shared
, queues_byte_cnt_tbls
)) >> 10);
1710 /* Disable chain mode for all queues */
1711 iwl4965_write_prph(priv
, KDR_SCD_QUEUECHAIN_SEL
, 0);
1713 /* Initialize each Tx queue (including the command queue) */
1714 for (i
= 0; i
< priv
->hw_setting
.max_txq_num
; i
++) {
1716 /* TFD circular buffer read/write indexes */
1717 iwl4965_write_prph(priv
, KDR_SCD_QUEUE_RDPTR(i
), 0);
1718 iwl4965_write_direct32(priv
, HBUS_TARG_WRPTR
, 0 | (i
<< 8));
1720 /* Max Tx Window size for Scheduler-ACK mode */
1721 iwl4965_write_targ_mem(priv
, priv
->scd_base_addr
+
1722 SCD_CONTEXT_QUEUE_OFFSET(i
),
1724 SCD_QUEUE_CTX_REG1_WIN_SIZE_POS
) &
1725 SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK
);
1728 iwl4965_write_targ_mem(priv
, priv
->scd_base_addr
+
1729 SCD_CONTEXT_QUEUE_OFFSET(i
) +
1732 SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS
) &
1733 SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK
);
1736 iwl4965_write_prph(priv
, KDR_SCD_INTERRUPT_MASK
,
1737 (1 << priv
->hw_setting
.max_txq_num
) - 1);
1739 /* Activate all Tx DMA/FIFO channels */
1740 iwl4965_write_prph(priv
, KDR_SCD_TXFACT
,
1741 SCD_TXFACT_REG_TXFIFO_MASK(0, 7));
1743 iwl4965_set_wr_ptrs(priv
, IWL_CMD_QUEUE_NUM
, 0);
1745 /* Map each Tx/cmd queue to its corresponding fifo */
1746 for (i
= 0; i
< ARRAY_SIZE(default_queue_to_tx_fifo
); i
++) {
1747 int ac
= default_queue_to_tx_fifo
[i
];
1748 iwl4965_txq_ctx_activate(priv
, i
);
1749 iwl4965_tx_queue_set_status(priv
, &priv
->txq
[i
], ac
, 0);
1752 iwl4965_release_nic_access(priv
);
1753 spin_unlock_irqrestore(&priv
->lock
, flags
);
1759 * iwl4965_hw_set_hw_setting
1761 * Called when initializing driver
1763 int iwl4965_hw_set_hw_setting(struct iwl4965_priv
*priv
)
1765 /* Allocate area for Tx byte count tables and Rx queue status */
1766 priv
->hw_setting
.shared_virt
=
1767 pci_alloc_consistent(priv
->pci_dev
,
1768 sizeof(struct iwl4965_shared
),
1769 &priv
->hw_setting
.shared_phys
);
1771 if (!priv
->hw_setting
.shared_virt
)
1774 memset(priv
->hw_setting
.shared_virt
, 0, sizeof(struct iwl4965_shared
));
1776 priv
->hw_setting
.max_txq_num
= iwl4965_param_queues_num
;
1777 priv
->hw_setting
.ac_queue_count
= AC_NUM
;
1778 priv
->hw_setting
.tx_cmd_len
= sizeof(struct iwl4965_tx_cmd
);
1779 priv
->hw_setting
.max_rxq_size
= RX_QUEUE_SIZE
;
1780 priv
->hw_setting
.max_rxq_log
= RX_QUEUE_SIZE_LOG
;
1781 if (iwl4965_param_amsdu_size_8K
)
1782 priv
->hw_setting
.rx_buf_size
= IWL_RX_BUF_SIZE_8K
;
1784 priv
->hw_setting
.rx_buf_size
= IWL_RX_BUF_SIZE_4K
;
1785 priv
->hw_setting
.max_pkt_size
= priv
->hw_setting
.rx_buf_size
- 256;
1786 priv
->hw_setting
.max_stations
= IWL4965_STATION_COUNT
;
1787 priv
->hw_setting
.bcast_sta_id
= IWL4965_BROADCAST_ID
;
1792 * iwl4965_hw_txq_ctx_free - Free TXQ Context
1794 * Destroy all TX DMA queues and structures
1796 void iwl4965_hw_txq_ctx_free(struct iwl4965_priv
*priv
)
1801 for (txq_id
= 0; txq_id
< priv
->hw_setting
.max_txq_num
; txq_id
++)
1802 iwl4965_tx_queue_free(priv
, &priv
->txq
[txq_id
]);
1804 /* Keep-warm buffer */
1805 iwl4965_kw_free(priv
);
1809 * iwl4965_hw_txq_free_tfd - Free all chunks referenced by TFD [txq->q.read_ptr]
1811 * Does NOT advance any TFD circular buffer read/write indexes
1812 * Does NOT free the TFD itself (which is within circular buffer)
1814 int iwl4965_hw_txq_free_tfd(struct iwl4965_priv
*priv
, struct iwl4965_tx_queue
*txq
)
1816 struct iwl4965_tfd_frame
*bd_tmp
= (struct iwl4965_tfd_frame
*)&txq
->bd
[0];
1817 struct iwl4965_tfd_frame
*bd
= &bd_tmp
[txq
->q
.read_ptr
];
1818 struct pci_dev
*dev
= priv
->pci_dev
;
1823 /* Host command buffers stay mapped in memory, nothing to clean */
1824 if (txq
->q
.id
== IWL_CMD_QUEUE_NUM
)
1827 /* Sanity check on number of chunks */
1828 counter
= IWL_GET_BITS(*bd
, num_tbs
);
1829 if (counter
> MAX_NUM_OF_TBS
) {
1830 IWL_ERROR("Too many chunks: %i\n", counter
);
1831 /* @todo issue fatal error, it is quite serious situation */
1835 /* Unmap chunks, if any.
1836 * TFD info for odd chunks is different format than for even chunks. */
1837 for (i
= 0; i
< counter
; i
++) {
1844 IWL_GET_BITS(bd
->pa
[index
], tb2_addr_lo16
) |
1845 (IWL_GET_BITS(bd
->pa
[index
],
1846 tb2_addr_hi20
) << 16),
1847 IWL_GET_BITS(bd
->pa
[index
], tb2_len
),
1851 pci_unmap_single(dev
,
1852 le32_to_cpu(bd
->pa
[index
].tb1_addr
),
1853 IWL_GET_BITS(bd
->pa
[index
], tb1_len
),
1856 /* Free SKB, if any, for this chunk */
1857 if (txq
->txb
[txq
->q
.read_ptr
].skb
[i
]) {
1858 struct sk_buff
*skb
= txq
->txb
[txq
->q
.read_ptr
].skb
[i
];
1861 txq
->txb
[txq
->q
.read_ptr
].skb
[i
] = NULL
;
1867 int iwl4965_hw_reg_set_txpower(struct iwl4965_priv
*priv
, s8 power
)
1869 IWL_ERROR("TODO: Implement iwl4965_hw_reg_set_txpower!\n");
1873 static s32
iwl4965_math_div_round(s32 num
, s32 denom
, s32
*res
)
1886 *res
= ((num
* 2 + denom
) / (denom
* 2)) * sign
;
1892 * iwl4965_get_voltage_compensation - Power supply voltage comp for txpower
1894 * Determines power supply voltage compensation for txpower calculations.
1895 * Returns number of 1/2-dB steps to subtract from gain table index,
1896 * to compensate for difference between power supply voltage during
1897 * factory measurements, vs. current power supply voltage.
1899 * Voltage indication is higher for lower voltage.
1900 * Lower voltage requires more gain (lower gain table index).
1902 static s32
iwl4965_get_voltage_compensation(s32 eeprom_voltage
,
1903 s32 current_voltage
)
1907 if ((TX_POWER_IWL_ILLEGAL_VOLTAGE
== eeprom_voltage
) ||
1908 (TX_POWER_IWL_ILLEGAL_VOLTAGE
== current_voltage
))
1911 iwl4965_math_div_round(current_voltage
- eeprom_voltage
,
1912 TX_POWER_IWL_VOLTAGE_CODES_PER_03V
, &comp
);
1914 if (current_voltage
> eeprom_voltage
)
1916 if ((comp
< -2) || (comp
> 2))
1922 static const struct iwl4965_channel_info
*
1923 iwl4965_get_channel_txpower_info(struct iwl4965_priv
*priv
, u8 phymode
, u16 channel
)
1925 const struct iwl4965_channel_info
*ch_info
;
1927 ch_info
= iwl4965_get_channel_info(priv
, phymode
, channel
);
1929 if (!is_channel_valid(ch_info
))
1935 static s32
iwl4965_get_tx_atten_grp(u16 channel
)
1937 if (channel
>= CALIB_IWL_TX_ATTEN_GR5_FCH
&&
1938 channel
<= CALIB_IWL_TX_ATTEN_GR5_LCH
)
1939 return CALIB_CH_GROUP_5
;
1941 if (channel
>= CALIB_IWL_TX_ATTEN_GR1_FCH
&&
1942 channel
<= CALIB_IWL_TX_ATTEN_GR1_LCH
)
1943 return CALIB_CH_GROUP_1
;
1945 if (channel
>= CALIB_IWL_TX_ATTEN_GR2_FCH
&&
1946 channel
<= CALIB_IWL_TX_ATTEN_GR2_LCH
)
1947 return CALIB_CH_GROUP_2
;
1949 if (channel
>= CALIB_IWL_TX_ATTEN_GR3_FCH
&&
1950 channel
<= CALIB_IWL_TX_ATTEN_GR3_LCH
)
1951 return CALIB_CH_GROUP_3
;
1953 if (channel
>= CALIB_IWL_TX_ATTEN_GR4_FCH
&&
1954 channel
<= CALIB_IWL_TX_ATTEN_GR4_LCH
)
1955 return CALIB_CH_GROUP_4
;
1957 IWL_ERROR("Can't find txatten group for channel %d.\n", channel
);
1961 static u32
iwl4965_get_sub_band(const struct iwl4965_priv
*priv
, u32 channel
)
1965 for (b
= 0; b
< EEPROM_TX_POWER_BANDS
; b
++) {
1966 if (priv
->eeprom
.calib_info
.band_info
[b
].ch_from
== 0)
1969 if ((channel
>= priv
->eeprom
.calib_info
.band_info
[b
].ch_from
)
1970 && (channel
<= priv
->eeprom
.calib_info
.band_info
[b
].ch_to
))
1977 static s32
iwl4965_interpolate_value(s32 x
, s32 x1
, s32 y1
, s32 x2
, s32 y2
)
1984 iwl4965_math_div_round((x2
- x
) * (y1
- y2
), (x2
- x1
), &val
);
1990 * iwl4965_interpolate_chan - Interpolate factory measurements for one channel
1992 * Interpolates factory measurements from the two sample channels within a
1993 * sub-band, to apply to channel of interest. Interpolation is proportional to
1994 * differences in channel frequencies, which is proportional to differences
1995 * in channel number.
1997 static int iwl4965_interpolate_chan(struct iwl4965_priv
*priv
, u32 channel
,
1998 struct iwl4965_eeprom_calib_ch_info
*chan_info
)
2003 const struct iwl4965_eeprom_calib_measure
*m1
;
2004 const struct iwl4965_eeprom_calib_measure
*m2
;
2005 struct iwl4965_eeprom_calib_measure
*omeas
;
2009 s
= iwl4965_get_sub_band(priv
, channel
);
2010 if (s
>= EEPROM_TX_POWER_BANDS
) {
2011 IWL_ERROR("Tx Power can not find channel %d ", channel
);
2015 ch_i1
= priv
->eeprom
.calib_info
.band_info
[s
].ch1
.ch_num
;
2016 ch_i2
= priv
->eeprom
.calib_info
.band_info
[s
].ch2
.ch_num
;
2017 chan_info
->ch_num
= (u8
) channel
;
2019 IWL_DEBUG_TXPOWER("channel %d subband %d factory cal ch %d & %d\n",
2020 channel
, s
, ch_i1
, ch_i2
);
2022 for (c
= 0; c
< EEPROM_TX_POWER_TX_CHAINS
; c
++) {
2023 for (m
= 0; m
< EEPROM_TX_POWER_MEASUREMENTS
; m
++) {
2024 m1
= &(priv
->eeprom
.calib_info
.band_info
[s
].ch1
.
2025 measurements
[c
][m
]);
2026 m2
= &(priv
->eeprom
.calib_info
.band_info
[s
].ch2
.
2027 measurements
[c
][m
]);
2028 omeas
= &(chan_info
->measurements
[c
][m
]);
2031 (u8
) iwl4965_interpolate_value(channel
, ch_i1
,
2036 (u8
) iwl4965_interpolate_value(channel
, ch_i1
,
2037 m1
->gain_idx
, ch_i2
,
2039 omeas
->temperature
=
2040 (u8
) iwl4965_interpolate_value(channel
, ch_i1
,
2045 (s8
) iwl4965_interpolate_value(channel
, ch_i1
,
2050 ("chain %d meas %d AP1=%d AP2=%d AP=%d\n", c
, m
,
2051 m1
->actual_pow
, m2
->actual_pow
, omeas
->actual_pow
);
2053 ("chain %d meas %d NI1=%d NI2=%d NI=%d\n", c
, m
,
2054 m1
->gain_idx
, m2
->gain_idx
, omeas
->gain_idx
);
2056 ("chain %d meas %d PA1=%d PA2=%d PA=%d\n", c
, m
,
2057 m1
->pa_det
, m2
->pa_det
, omeas
->pa_det
);
2059 ("chain %d meas %d T1=%d T2=%d T=%d\n", c
, m
,
2060 m1
->temperature
, m2
->temperature
,
2061 omeas
->temperature
);
2068 /* bit-rate-dependent table to prevent Tx distortion, in half-dB units,
2069 * for OFDM 6, 12, 18, 24, 36, 48, 54, 60 MBit, and CCK all rates. */
2070 static s32 back_off_table
[] = {
2071 10, 10, 10, 10, 10, 15, 17, 20, /* OFDM SISO 20 MHz */
2072 10, 10, 10, 10, 10, 15, 17, 20, /* OFDM MIMO 20 MHz */
2073 10, 10, 10, 10, 10, 15, 17, 20, /* OFDM SISO 40 MHz */
2074 10, 10, 10, 10, 10, 15, 17, 20, /* OFDM MIMO 40 MHz */
2078 /* Thermal compensation values for txpower for various frequency ranges ...
2079 * ratios from 3:1 to 4.5:1 of degrees (Celsius) per half-dB gain adjust */
2080 static struct iwl4965_txpower_comp_entry
{
2081 s32 degrees_per_05db_a
;
2082 s32 degrees_per_05db_a_denom
;
2083 } tx_power_cmp_tble
[CALIB_CH_GROUP_MAX
] = {
2084 {9, 2}, /* group 0 5.2, ch 34-43 */
2085 {4, 1}, /* group 1 5.2, ch 44-70 */
2086 {4, 1}, /* group 2 5.2, ch 71-124 */
2087 {4, 1}, /* group 3 5.2, ch 125-200 */
2088 {3, 1} /* group 4 2.4, ch all */
2091 static s32
get_min_power_index(s32 rate_power_index
, u32 band
)
2094 if ((rate_power_index
& 7) <= 4)
2095 return MIN_TX_GAIN_INDEX_52GHZ_EXT
;
2097 return MIN_TX_GAIN_INDEX
;
2105 static const struct gain_entry gain_table
[2][108] = {
2106 /* 5.2GHz power gain index table */
2108 {123, 0x3F}, /* highest txpower */
2217 /* 2.4GHz power gain index table */
2219 {110, 0x3f}, /* highest txpower */
2330 static int iwl4965_fill_txpower_tbl(struct iwl4965_priv
*priv
, u8 band
, u16 channel
,
2331 u8 is_fat
, u8 ctrl_chan_high
,
2332 struct iwl4965_tx_power_db
*tx_power_tbl
)
2334 u8 saturation_power
;
2336 s32 user_target_power
;
2340 s32 current_regulatory
;
2341 s32 txatten_grp
= CALIB_CH_GROUP_MAX
;
2344 const struct iwl4965_channel_info
*ch_info
= NULL
;
2345 struct iwl4965_eeprom_calib_ch_info ch_eeprom_info
;
2346 const struct iwl4965_eeprom_calib_measure
*measurement
;
2349 s32 voltage_compensation
;
2350 s32 degrees_per_05db_num
;
2351 s32 degrees_per_05db_denom
;
2353 s32 temperature_comp
[2];
2354 s32 factory_gain_index
[2];
2355 s32 factory_actual_pwr
[2];
2358 /* Sanity check requested level (dBm) */
2359 if (priv
->user_txpower_limit
< IWL_TX_POWER_TARGET_POWER_MIN
) {
2360 IWL_WARNING("Requested user TXPOWER %d below limit.\n",
2361 priv
->user_txpower_limit
);
2364 if (priv
->user_txpower_limit
> IWL_TX_POWER_TARGET_POWER_MAX
) {
2365 IWL_WARNING("Requested user TXPOWER %d above limit.\n",
2366 priv
->user_txpower_limit
);
2370 /* user_txpower_limit is in dBm, convert to half-dBm (half-dB units
2371 * are used for indexing into txpower table) */
2372 user_target_power
= 2 * priv
->user_txpower_limit
;
2374 /* Get current (RXON) channel, band, width */
2376 iwl4965_get_channel_txpower_info(priv
, priv
->phymode
, channel
);
2378 IWL_DEBUG_TXPOWER("chan %d band %d is_fat %d\n", channel
, band
,
2384 /* get txatten group, used to select 1) thermal txpower adjustment
2385 * and 2) mimo txpower balance between Tx chains. */
2386 txatten_grp
= iwl4965_get_tx_atten_grp(channel
);
2387 if (txatten_grp
< 0)
2390 IWL_DEBUG_TXPOWER("channel %d belongs to txatten group %d\n",
2391 channel
, txatten_grp
);
2400 /* hardware txpower limits ...
2401 * saturation (clipping distortion) txpowers are in half-dBm */
2403 saturation_power
= priv
->eeprom
.calib_info
.saturation_power24
;
2405 saturation_power
= priv
->eeprom
.calib_info
.saturation_power52
;
2407 if (saturation_power
< IWL_TX_POWER_SATURATION_MIN
||
2408 saturation_power
> IWL_TX_POWER_SATURATION_MAX
) {
2410 saturation_power
= IWL_TX_POWER_DEFAULT_SATURATION_24
;
2412 saturation_power
= IWL_TX_POWER_DEFAULT_SATURATION_52
;
2415 /* regulatory txpower limits ... reg_limit values are in half-dBm,
2416 * max_power_avg values are in dBm, convert * 2 */
2418 reg_limit
= ch_info
->fat_max_power_avg
* 2;
2420 reg_limit
= ch_info
->max_power_avg
* 2;
2422 if ((reg_limit
< IWL_TX_POWER_REGULATORY_MIN
) ||
2423 (reg_limit
> IWL_TX_POWER_REGULATORY_MAX
)) {
2425 reg_limit
= IWL_TX_POWER_DEFAULT_REGULATORY_24
;
2427 reg_limit
= IWL_TX_POWER_DEFAULT_REGULATORY_52
;
2430 /* Interpolate txpower calibration values for this channel,
2431 * based on factory calibration tests on spaced channels. */
2432 iwl4965_interpolate_chan(priv
, channel
, &ch_eeprom_info
);
2434 /* calculate tx gain adjustment based on power supply voltage */
2435 voltage
= priv
->eeprom
.calib_info
.voltage
;
2436 init_voltage
= (s32
)le32_to_cpu(priv
->card_alive_init
.voltage
);
2437 voltage_compensation
=
2438 iwl4965_get_voltage_compensation(voltage
, init_voltage
);
2440 IWL_DEBUG_TXPOWER("curr volt %d eeprom volt %d volt comp %d\n",
2442 voltage
, voltage_compensation
);
2444 /* get current temperature (Celsius) */
2445 current_temp
= max(priv
->temperature
, IWL_TX_POWER_TEMPERATURE_MIN
);
2446 current_temp
= min(priv
->temperature
, IWL_TX_POWER_TEMPERATURE_MAX
);
2447 current_temp
= KELVIN_TO_CELSIUS(current_temp
);
2449 /* select thermal txpower adjustment params, based on channel group
2450 * (same frequency group used for mimo txatten adjustment) */
2451 degrees_per_05db_num
=
2452 tx_power_cmp_tble
[txatten_grp
].degrees_per_05db_a
;
2453 degrees_per_05db_denom
=
2454 tx_power_cmp_tble
[txatten_grp
].degrees_per_05db_a_denom
;
2456 /* get per-chain txpower values from factory measurements */
2457 for (c
= 0; c
< 2; c
++) {
2458 measurement
= &ch_eeprom_info
.measurements
[c
][1];
2460 /* txgain adjustment (in half-dB steps) based on difference
2461 * between factory and current temperature */
2462 factory_temp
= measurement
->temperature
;
2463 iwl4965_math_div_round((current_temp
- factory_temp
) *
2464 degrees_per_05db_denom
,
2465 degrees_per_05db_num
,
2466 &temperature_comp
[c
]);
2468 factory_gain_index
[c
] = measurement
->gain_idx
;
2469 factory_actual_pwr
[c
] = measurement
->actual_pow
;
2471 IWL_DEBUG_TXPOWER("chain = %d\n", c
);
2472 IWL_DEBUG_TXPOWER("fctry tmp %d, "
2473 "curr tmp %d, comp %d steps\n",
2474 factory_temp
, current_temp
,
2475 temperature_comp
[c
]);
2477 IWL_DEBUG_TXPOWER("fctry idx %d, fctry pwr %d\n",
2478 factory_gain_index
[c
],
2479 factory_actual_pwr
[c
]);
2482 /* for each of 33 bit-rates (including 1 for CCK) */
2483 for (i
= 0; i
< POWER_TABLE_NUM_ENTRIES
; i
++) {
2485 union iwl4965_tx_power_dual_stream tx_power
;
2487 /* for mimo, reduce each chain's txpower by half
2488 * (3dB, 6 steps), so total output power is regulatory
2491 current_regulatory
= reg_limit
-
2492 IWL_TX_POWER_MIMO_REGULATORY_COMPENSATION
;
2495 current_regulatory
= reg_limit
;
2499 /* find txpower limit, either hardware or regulatory */
2500 power_limit
= saturation_power
- back_off_table
[i
];
2501 if (power_limit
> current_regulatory
)
2502 power_limit
= current_regulatory
;
2504 /* reduce user's txpower request if necessary
2505 * for this rate on this channel */
2506 target_power
= user_target_power
;
2507 if (target_power
> power_limit
)
2508 target_power
= power_limit
;
2510 IWL_DEBUG_TXPOWER("rate %d sat %d reg %d usr %d tgt %d\n",
2511 i
, saturation_power
- back_off_table
[i
],
2512 current_regulatory
, user_target_power
,
2515 /* for each of 2 Tx chains (radio transmitters) */
2516 for (c
= 0; c
< 2; c
++) {
2521 (s32
)le32_to_cpu(priv
->card_alive_init
.
2522 tx_atten
[txatten_grp
][c
]);
2526 /* calculate index; higher index means lower txpower */
2527 power_index
= (u8
) (factory_gain_index
[c
] -
2529 factory_actual_pwr
[c
]) -
2530 temperature_comp
[c
] -
2531 voltage_compensation
+
2534 /* IWL_DEBUG_TXPOWER("calculated txpower index %d\n",
2537 if (power_index
< get_min_power_index(i
, band
))
2538 power_index
= get_min_power_index(i
, band
);
2540 /* adjust 5 GHz index to support negative indexes */
2544 /* CCK, rate 32, reduce txpower for CCK */
2545 if (i
== POWER_TABLE_CCK_ENTRY
)
2547 IWL_TX_POWER_CCK_COMPENSATION_C_STEP
;
2549 /* stay within the table! */
2550 if (power_index
> 107) {
2551 IWL_WARNING("txpower index %d > 107\n",
2555 if (power_index
< 0) {
2556 IWL_WARNING("txpower index %d < 0\n",
2561 /* fill txpower command for this rate/chain */
2562 tx_power
.s
.radio_tx_gain
[c
] =
2563 gain_table
[band
][power_index
].radio
;
2564 tx_power
.s
.dsp_predis_atten
[c
] =
2565 gain_table
[band
][power_index
].dsp
;
2567 IWL_DEBUG_TXPOWER("chain %d mimo %d index %d "
2568 "gain 0x%02x dsp %d\n",
2569 c
, atten_value
, power_index
,
2570 tx_power
.s
.radio_tx_gain
[c
],
2571 tx_power
.s
.dsp_predis_atten
[c
]);
2572 }/* for each chain */
2574 tx_power_tbl
->power_tbl
[i
].dw
= cpu_to_le32(tx_power
.dw
);
2576 }/* for each rate */
2582 * iwl4965_hw_reg_send_txpower - Configure the TXPOWER level user limit
2584 * Uses the active RXON for channel, band, and characteristics (fat, high)
2585 * The power limit is taken from priv->user_txpower_limit.
2587 int iwl4965_hw_reg_send_txpower(struct iwl4965_priv
*priv
)
2589 struct iwl4965_txpowertable_cmd cmd
= { 0 };
2593 u8 ctrl_chan_high
= 0;
2595 if (test_bit(STATUS_SCANNING
, &priv
->status
)) {
2596 /* If this gets hit a lot, switch it to a BUG() and catch
2597 * the stack trace to find out who is calling this during
2599 IWL_WARNING("TX Power requested while scanning!\n");
2603 band
= ((priv
->phymode
== MODE_IEEE80211B
) ||
2604 (priv
->phymode
== MODE_IEEE80211G
));
2606 is_fat
= is_fat_channel(priv
->active_rxon
.flags
);
2609 (priv
->active_rxon
.flags
& RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
))
2613 cmd
.channel
= priv
->active_rxon
.channel
;
2615 rc
= iwl4965_fill_txpower_tbl(priv
, band
,
2616 le16_to_cpu(priv
->active_rxon
.channel
),
2617 is_fat
, ctrl_chan_high
, &cmd
.tx_power
);
2621 rc
= iwl4965_send_cmd_pdu(priv
, REPLY_TX_PWR_TABLE_CMD
, sizeof(cmd
), &cmd
);
2625 int iwl4965_hw_channel_switch(struct iwl4965_priv
*priv
, u16 channel
)
2630 u8 ctrl_chan_high
= 0;
2631 struct iwl4965_channel_switch_cmd cmd
= { 0 };
2632 const struct iwl4965_channel_info
*ch_info
;
2634 band
= ((priv
->phymode
== MODE_IEEE80211B
) ||
2635 (priv
->phymode
== MODE_IEEE80211G
));
2637 ch_info
= iwl4965_get_channel_info(priv
, priv
->phymode
, channel
);
2639 is_fat
= is_fat_channel(priv
->staging_rxon
.flags
);
2642 (priv
->active_rxon
.flags
& RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
))
2646 cmd
.expect_beacon
= 0;
2647 cmd
.channel
= cpu_to_le16(channel
);
2648 cmd
.rxon_flags
= priv
->active_rxon
.flags
;
2649 cmd
.rxon_filter_flags
= priv
->active_rxon
.filter_flags
;
2650 cmd
.switch_time
= cpu_to_le32(priv
->ucode_beacon_time
);
2652 cmd
.expect_beacon
= is_channel_radar(ch_info
);
2654 cmd
.expect_beacon
= 1;
2656 rc
= iwl4965_fill_txpower_tbl(priv
, band
, channel
, is_fat
,
2657 ctrl_chan_high
, &cmd
.tx_power
);
2659 IWL_DEBUG_11H("error:%d fill txpower_tbl\n", rc
);
2663 rc
= iwl4965_send_cmd_pdu(priv
, REPLY_CHANNEL_SWITCH
, sizeof(cmd
), &cmd
);
2667 #define RTS_HCCA_RETRY_LIMIT 3
2668 #define RTS_DFAULT_RETRY_LIMIT 60
2670 void iwl4965_hw_build_tx_cmd_rate(struct iwl4965_priv
*priv
,
2671 struct iwl4965_cmd
*cmd
,
2672 struct ieee80211_tx_control
*ctrl
,
2673 struct ieee80211_hdr
*hdr
, int sta_id
,
2677 u8 rts_retry_limit
= 0;
2678 u8 data_retry_limit
= 0;
2680 u16 fc
= le16_to_cpu(hdr
->frame_control
);
2682 tx_flags
= cmd
->cmd
.tx
.tx_flags
;
2684 rate
= iwl4965_rates
[ctrl
->tx_rate
].plcp
;
2686 rts_retry_limit
= (is_hcca
) ?
2687 RTS_HCCA_RETRY_LIMIT
: RTS_DFAULT_RETRY_LIMIT
;
2689 if (ieee80211_is_probe_response(fc
)) {
2690 data_retry_limit
= 3;
2691 if (data_retry_limit
< rts_retry_limit
)
2692 rts_retry_limit
= data_retry_limit
;
2694 data_retry_limit
= IWL_DEFAULT_TX_RETRY
;
2696 if (priv
->data_retry_limit
!= -1)
2697 data_retry_limit
= priv
->data_retry_limit
;
2699 if ((fc
& IEEE80211_FCTL_FTYPE
) == IEEE80211_FTYPE_MGMT
) {
2700 switch (fc
& IEEE80211_FCTL_STYPE
) {
2701 case IEEE80211_STYPE_AUTH
:
2702 case IEEE80211_STYPE_DEAUTH
:
2703 case IEEE80211_STYPE_ASSOC_REQ
:
2704 case IEEE80211_STYPE_REASSOC_REQ
:
2705 if (tx_flags
& TX_CMD_FLG_RTS_MSK
) {
2706 tx_flags
&= ~TX_CMD_FLG_RTS_MSK
;
2707 tx_flags
|= TX_CMD_FLG_CTS_MSK
;
2715 cmd
->cmd
.tx
.rts_retry_limit
= rts_retry_limit
;
2716 cmd
->cmd
.tx
.data_retry_limit
= data_retry_limit
;
2717 cmd
->cmd
.tx
.rate_n_flags
= iwl4965_hw_set_rate_n_flags(rate
, 0);
2718 cmd
->cmd
.tx
.tx_flags
= tx_flags
;
2721 int iwl4965_hw_get_rx_read(struct iwl4965_priv
*priv
)
2723 struct iwl4965_shared
*shared_data
= priv
->hw_setting
.shared_virt
;
2725 return IWL_GET_BITS(*shared_data
, rb_closed_stts_rb_num
);
2728 int iwl4965_hw_get_temperature(struct iwl4965_priv
*priv
)
2730 return priv
->temperature
;
2733 unsigned int iwl4965_hw_get_beacon_cmd(struct iwl4965_priv
*priv
,
2734 struct iwl4965_frame
*frame
, u8 rate
)
2736 struct iwl4965_tx_beacon_cmd
*tx_beacon_cmd
;
2737 unsigned int frame_size
;
2739 tx_beacon_cmd
= &frame
->u
.beacon
;
2740 memset(tx_beacon_cmd
, 0, sizeof(*tx_beacon_cmd
));
2742 tx_beacon_cmd
->tx
.sta_id
= IWL4965_BROADCAST_ID
;
2743 tx_beacon_cmd
->tx
.stop_time
.life_time
= TX_CMD_LIFE_TIME_INFINITE
;
2745 frame_size
= iwl4965_fill_beacon_frame(priv
,
2746 tx_beacon_cmd
->frame
,
2747 iwl4965_broadcast_addr
,
2748 sizeof(frame
->u
) - sizeof(*tx_beacon_cmd
));
2750 BUG_ON(frame_size
> MAX_MPDU_SIZE
);
2751 tx_beacon_cmd
->tx
.len
= cpu_to_le16((u16
)frame_size
);
2753 if ((rate
== IWL_RATE_1M_PLCP
) || (rate
>= IWL_RATE_2M_PLCP
))
2754 tx_beacon_cmd
->tx
.rate_n_flags
=
2755 iwl4965_hw_set_rate_n_flags(rate
, RATE_MCS_CCK_MSK
);
2757 tx_beacon_cmd
->tx
.rate_n_flags
=
2758 iwl4965_hw_set_rate_n_flags(rate
, 0);
2760 tx_beacon_cmd
->tx
.tx_flags
= (TX_CMD_FLG_SEQ_CTL_MSK
|
2761 TX_CMD_FLG_TSF_MSK
| TX_CMD_FLG_STA_RATE_MSK
);
2762 return (sizeof(*tx_beacon_cmd
) + frame_size
);
2766 * Tell 4965 where to find circular buffer of Tx Frame Descriptors for
2767 * given Tx queue, and enable the DMA channel used for that queue.
2769 * 4965 supports up to 16 Tx queues in DRAM, mapped to up to 8 Tx DMA
2770 * channels supported in hardware.
2772 int iwl4965_hw_tx_queue_init(struct iwl4965_priv
*priv
, struct iwl4965_tx_queue
*txq
)
2775 unsigned long flags
;
2776 int txq_id
= txq
->q
.id
;
2778 spin_lock_irqsave(&priv
->lock
, flags
);
2779 rc
= iwl4965_grab_nic_access(priv
);
2781 spin_unlock_irqrestore(&priv
->lock
, flags
);
2785 /* Circular buffer (TFD queue in DRAM) physical base address */
2786 iwl4965_write_direct32(priv
, FH_MEM_CBBC_QUEUE(txq_id
),
2787 txq
->q
.dma_addr
>> 8);
2789 /* Enable DMA channel, using same id as for TFD queue */
2790 iwl4965_write_direct32(
2791 priv
, IWL_FH_TCSR_CHNL_TX_CONFIG_REG(txq_id
),
2792 IWL_FH_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE
|
2793 IWL_FH_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE_VAL
);
2794 iwl4965_release_nic_access(priv
);
2795 spin_unlock_irqrestore(&priv
->lock
, flags
);
2800 static inline u8
iwl4965_get_dma_hi_address(dma_addr_t addr
)
2802 return sizeof(addr
) > sizeof(u32
) ? (addr
>> 16) >> 16 : 0;
2805 int iwl4965_hw_txq_attach_buf_to_tfd(struct iwl4965_priv
*priv
, void *ptr
,
2806 dma_addr_t addr
, u16 len
)
2809 struct iwl4965_tfd_frame
*tfd
= ptr
;
2810 u32 num_tbs
= IWL_GET_BITS(*tfd
, num_tbs
);
2812 /* Each TFD can point to a maximum 20 Tx buffers */
2813 if ((num_tbs
>= MAX_NUM_OF_TBS
) || (num_tbs
< 0)) {
2814 IWL_ERROR("Error can not send more than %d chunks\n",
2819 index
= num_tbs
/ 2;
2820 is_odd
= num_tbs
& 0x1;
2823 tfd
->pa
[index
].tb1_addr
= cpu_to_le32(addr
);
2824 IWL_SET_BITS(tfd
->pa
[index
], tb1_addr_hi
,
2825 iwl4965_get_dma_hi_address(addr
));
2826 IWL_SET_BITS(tfd
->pa
[index
], tb1_len
, len
);
2828 IWL_SET_BITS(tfd
->pa
[index
], tb2_addr_lo16
,
2829 (u32
) (addr
& 0xffff));
2830 IWL_SET_BITS(tfd
->pa
[index
], tb2_addr_hi20
, addr
>> 16);
2831 IWL_SET_BITS(tfd
->pa
[index
], tb2_len
, len
);
2834 IWL_SET_BITS(*tfd
, num_tbs
, num_tbs
+ 1);
2839 static void iwl4965_hw_card_show_info(struct iwl4965_priv
*priv
)
2841 u16 hw_version
= priv
->eeprom
.board_revision_4965
;
2843 IWL_DEBUG_INFO("4965ABGN HW Version %u.%u.%u\n",
2844 ((hw_version
>> 8) & 0x0F),
2845 ((hw_version
>> 8) >> 4), (hw_version
& 0x00FF));
2847 IWL_DEBUG_INFO("4965ABGN PBA Number %.16s\n",
2848 priv
->eeprom
.board_pba_number_4965
);
2851 #define IWL_TX_CRC_SIZE 4
2852 #define IWL_TX_DELIMITER_SIZE 4
2855 * iwl4965_tx_queue_update_wr_ptr - Set up entry in Tx byte-count array
2857 int iwl4965_tx_queue_update_wr_ptr(struct iwl4965_priv
*priv
,
2858 struct iwl4965_tx_queue
*txq
, u16 byte_cnt
)
2861 int txq_id
= txq
->q
.id
;
2862 struct iwl4965_shared
*shared_data
= priv
->hw_setting
.shared_virt
;
2864 if (txq
->need_update
== 0)
2867 len
= byte_cnt
+ IWL_TX_CRC_SIZE
+ IWL_TX_DELIMITER_SIZE
;
2869 /* Set up byte count within first 256 entries */
2870 IWL_SET_BITS16(shared_data
->queues_byte_cnt_tbls
[txq_id
].
2871 tfd_offset
[txq
->q
.write_ptr
], byte_cnt
, len
);
2873 /* If within first 64 entries, duplicate at end */
2874 if (txq
->q
.write_ptr
< IWL4965_MAX_WIN_SIZE
)
2875 IWL_SET_BITS16(shared_data
->queues_byte_cnt_tbls
[txq_id
].
2876 tfd_offset
[IWL4965_QUEUE_SIZE
+ txq
->q
.write_ptr
],
2883 * iwl4965_set_rxon_chain - Set up Rx chain usage in "staging" RXON image
2885 * Selects how many and which Rx receivers/antennas/chains to use.
2886 * This should not be used for scan command ... it puts data in wrong place.
2888 void iwl4965_set_rxon_chain(struct iwl4965_priv
*priv
)
2890 u8 is_single
= is_single_stream(priv
);
2891 u8 idle_state
, rx_state
;
2893 priv
->staging_rxon
.rx_chain
= 0;
2894 rx_state
= idle_state
= 3;
2896 /* Tell uCode which antennas are actually connected.
2897 * Before first association, we assume all antennas are connected.
2898 * Just after first association, iwl4965_noise_calibration()
2899 * checks which antennas actually *are* connected. */
2900 priv
->staging_rxon
.rx_chain
|=
2901 cpu_to_le16(priv
->valid_antenna
<< RXON_RX_CHAIN_VALID_POS
);
2903 /* How many receivers should we use? */
2904 iwl4965_get_rx_chain_counter(priv
, &idle_state
, &rx_state
);
2905 priv
->staging_rxon
.rx_chain
|=
2906 cpu_to_le16(rx_state
<< RXON_RX_CHAIN_MIMO_CNT_POS
);
2907 priv
->staging_rxon
.rx_chain
|=
2908 cpu_to_le16(idle_state
<< RXON_RX_CHAIN_CNT_POS
);
2910 if (!is_single
&& (rx_state
>= 2) &&
2911 !test_bit(STATUS_POWER_PMI
, &priv
->status
))
2912 priv
->staging_rxon
.rx_chain
|= RXON_RX_CHAIN_MIMO_FORCE_MSK
;
2914 priv
->staging_rxon
.rx_chain
&= ~RXON_RX_CHAIN_MIMO_FORCE_MSK
;
2916 IWL_DEBUG_ASSOC("rx chain %X\n", priv
->staging_rxon
.rx_chain
);
2919 #ifdef CONFIG_IWL4965_HT
2920 #ifdef CONFIG_IWL4965_HT_AGG
2922 get the traffic load value for tid
2924 static u32
iwl4965_tl_get_load(struct iwl4965_priv
*priv
, u8 tid
)
2927 u32 current_time
= jiffies_to_msecs(jiffies
);
2930 unsigned long flags
;
2931 struct iwl4965_traffic_load
*tid_ptr
= NULL
;
2933 if (tid
>= TID_MAX_LOAD_COUNT
)
2936 tid_ptr
= &(priv
->lq_mngr
.agg_ctrl
.traffic_load
[tid
]);
2938 current_time
-= current_time
% TID_ROUND_VALUE
;
2940 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
2941 if (!(tid_ptr
->queue_count
))
2944 time_diff
= TIME_WRAP_AROUND(tid_ptr
->time_stamp
, current_time
);
2945 index
= time_diff
/ TID_QUEUE_CELL_SPACING
;
2947 if (index
>= TID_QUEUE_MAX_SIZE
) {
2948 u32 oldest_time
= current_time
- TID_MAX_TIME_DIFF
;
2950 while (tid_ptr
->queue_count
&&
2951 (tid_ptr
->time_stamp
< oldest_time
)) {
2952 tid_ptr
->total
-= tid_ptr
->packet_count
[tid_ptr
->head
];
2953 tid_ptr
->packet_count
[tid_ptr
->head
] = 0;
2954 tid_ptr
->time_stamp
+= TID_QUEUE_CELL_SPACING
;
2955 tid_ptr
->queue_count
--;
2957 if (tid_ptr
->head
>= TID_QUEUE_MAX_SIZE
)
2961 load
= tid_ptr
->total
;
2964 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
2969 increment traffic load value for tid and also remove
2970 any old values if passed the certian time period
2972 static void iwl4965_tl_add_packet(struct iwl4965_priv
*priv
, u8 tid
)
2974 u32 current_time
= jiffies_to_msecs(jiffies
);
2977 unsigned long flags
;
2978 struct iwl4965_traffic_load
*tid_ptr
= NULL
;
2980 if (tid
>= TID_MAX_LOAD_COUNT
)
2983 tid_ptr
= &(priv
->lq_mngr
.agg_ctrl
.traffic_load
[tid
]);
2985 current_time
-= current_time
% TID_ROUND_VALUE
;
2987 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
2988 if (!(tid_ptr
->queue_count
)) {
2990 tid_ptr
->time_stamp
= current_time
;
2991 tid_ptr
->queue_count
= 1;
2993 tid_ptr
->packet_count
[0] = 1;
2997 time_diff
= TIME_WRAP_AROUND(tid_ptr
->time_stamp
, current_time
);
2998 index
= time_diff
/ TID_QUEUE_CELL_SPACING
;
3000 if (index
>= TID_QUEUE_MAX_SIZE
) {
3001 u32 oldest_time
= current_time
- TID_MAX_TIME_DIFF
;
3003 while (tid_ptr
->queue_count
&&
3004 (tid_ptr
->time_stamp
< oldest_time
)) {
3005 tid_ptr
->total
-= tid_ptr
->packet_count
[tid_ptr
->head
];
3006 tid_ptr
->packet_count
[tid_ptr
->head
] = 0;
3007 tid_ptr
->time_stamp
+= TID_QUEUE_CELL_SPACING
;
3008 tid_ptr
->queue_count
--;
3010 if (tid_ptr
->head
>= TID_QUEUE_MAX_SIZE
)
3015 index
= (tid_ptr
->head
+ index
) % TID_QUEUE_MAX_SIZE
;
3016 tid_ptr
->packet_count
[index
] = tid_ptr
->packet_count
[index
] + 1;
3017 tid_ptr
->total
= tid_ptr
->total
+ 1;
3019 if ((index
+ 1) > tid_ptr
->queue_count
)
3020 tid_ptr
->queue_count
= index
+ 1;
3022 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3026 #define MMAC_SCHED_MAX_NUMBER_OF_HT_BACK_FLOWS 7
3028 BA_STATUS_FAILURE
= 0,
3029 BA_STATUS_INITIATOR_DELBA
,
3030 BA_STATUS_RECIPIENT_DELBA
,
3031 BA_STATUS_RENEW_ADDBA_REQUEST
,
3036 * iwl4964_tl_ba_avail - Find out if an unused aggregation queue is available
3038 static u8
iwl4964_tl_ba_avail(struct iwl4965_priv
*priv
)
3041 struct iwl4965_lq_mngr
*lq
;
3045 lq
= (struct iwl4965_lq_mngr
*)&(priv
->lq_mngr
);
3047 /* Find out how many agg queues are in use */
3048 for (i
= 0; i
< TID_MAX_LOAD_COUNT
; i
++) {
3050 if ((lq
->agg_ctrl
.granted_ba
& msk
) ||
3051 (lq
->agg_ctrl
.wait_for_agg_status
& msk
))
3055 if (count
< MMAC_SCHED_MAX_NUMBER_OF_HT_BACK_FLOWS
)
3061 static void iwl4965_ba_status(struct iwl4965_priv
*priv
,
3062 u8 tid
, enum HT_STATUS status
);
3064 static int iwl4965_perform_addba(struct iwl4965_priv
*priv
, u8 tid
, u32 length
,
3069 rc
= ieee80211_start_BA_session(priv
->hw
, priv
->bssid
, tid
);
3071 iwl4965_ba_status(priv
, tid
, BA_STATUS_FAILURE
);
3076 static int iwl4965_perform_delba(struct iwl4965_priv
*priv
, u8 tid
)
3080 rc
= ieee80211_stop_BA_session(priv
->hw
, priv
->bssid
, tid
);
3082 iwl4965_ba_status(priv
, tid
, BA_STATUS_FAILURE
);
3087 static void iwl4965_turn_on_agg_for_tid(struct iwl4965_priv
*priv
,
3088 struct iwl4965_lq_mngr
*lq
,
3089 u8 auto_agg
, u8 tid
)
3091 u32 tid_msk
= (1 << tid
);
3092 unsigned long flags
;
3094 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3096 if ((auto_agg) && (!lq->enable_counter)){
3097 lq->agg_ctrl.next_retry = 0;
3098 lq->agg_ctrl.tid_retry = 0;
3099 spin_unlock_irqrestore(&priv->lq_mngr.lock, flags);
3103 if (!(lq
->agg_ctrl
.granted_ba
& tid_msk
) &&
3104 (lq
->agg_ctrl
.requested_ba
& tid_msk
)) {
3105 u8 available_queues
;
3108 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3109 available_queues
= iwl4964_tl_ba_avail(priv
);
3110 load
= iwl4965_tl_get_load(priv
, tid
);
3112 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3113 if (!available_queues
) {
3115 lq
->agg_ctrl
.tid_retry
|= tid_msk
;
3117 lq
->agg_ctrl
.requested_ba
&= ~tid_msk
;
3118 lq
->agg_ctrl
.wait_for_agg_status
&= ~tid_msk
;
3120 } else if ((auto_agg
) &&
3121 ((load
<= lq
->agg_ctrl
.tid_traffic_load_threshold
) ||
3122 ((lq
->agg_ctrl
.wait_for_agg_status
& tid_msk
))))
3123 lq
->agg_ctrl
.tid_retry
|= tid_msk
;
3125 lq
->agg_ctrl
.wait_for_agg_status
|= tid_msk
;
3126 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3127 iwl4965_perform_addba(priv
, tid
, 0x40,
3128 lq
->agg_ctrl
.ba_timeout
);
3129 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3132 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3135 static void iwl4965_turn_on_agg(struct iwl4965_priv
*priv
, u8 tid
)
3137 struct iwl4965_lq_mngr
*lq
;
3138 unsigned long flags
;
3140 lq
= (struct iwl4965_lq_mngr
*)&(priv
->lq_mngr
);
3142 if ((tid
< TID_MAX_LOAD_COUNT
))
3143 iwl4965_turn_on_agg_for_tid(priv
, lq
, lq
->agg_ctrl
.auto_agg
,
3145 else if (tid
== TID_ALL_SPECIFIED
) {
3146 if (lq
->agg_ctrl
.requested_ba
) {
3147 for (tid
= 0; tid
< TID_MAX_LOAD_COUNT
; tid
++)
3148 iwl4965_turn_on_agg_for_tid(priv
, lq
,
3149 lq
->agg_ctrl
.auto_agg
, tid
);
3151 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3152 lq
->agg_ctrl
.tid_retry
= 0;
3153 lq
->agg_ctrl
.next_retry
= 0;
3154 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3160 void iwl4965_turn_off_agg(struct iwl4965_priv
*priv
, u8 tid
)
3163 struct iwl4965_lq_mngr
*lq
;
3164 unsigned long flags
;
3166 lq
= (struct iwl4965_lq_mngr
*)&(priv
->lq_mngr
);
3168 if ((tid
< TID_MAX_LOAD_COUNT
)) {
3170 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3171 lq
->agg_ctrl
.wait_for_agg_status
|= tid_msk
;
3172 lq
->agg_ctrl
.requested_ba
&= ~tid_msk
;
3173 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3174 iwl4965_perform_delba(priv
, tid
);
3175 } else if (tid
== TID_ALL_SPECIFIED
) {
3176 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3177 for (tid
= 0; tid
< TID_MAX_LOAD_COUNT
; tid
++) {
3179 lq
->agg_ctrl
.wait_for_agg_status
|= tid_msk
;
3180 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3181 iwl4965_perform_delba(priv
, tid
);
3182 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3184 lq
->agg_ctrl
.requested_ba
= 0;
3185 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3190 * iwl4965_ba_status - Update driver's link quality mgr with tid's HT status
3192 static void iwl4965_ba_status(struct iwl4965_priv
*priv
,
3193 u8 tid
, enum HT_STATUS status
)
3195 struct iwl4965_lq_mngr
*lq
;
3196 u32 tid_msk
= (1 << tid
);
3197 unsigned long flags
;
3199 lq
= (struct iwl4965_lq_mngr
*)&(priv
->lq_mngr
);
3201 if ((tid
>= TID_MAX_LOAD_COUNT
))
3204 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3206 case BA_STATUS_ACTIVE
:
3207 if (!(lq
->agg_ctrl
.granted_ba
& tid_msk
))
3208 lq
->agg_ctrl
.granted_ba
|= tid_msk
;
3211 if ((lq
->agg_ctrl
.granted_ba
& tid_msk
))
3212 lq
->agg_ctrl
.granted_ba
&= ~tid_msk
;
3216 lq
->agg_ctrl
.wait_for_agg_status
&= ~tid_msk
;
3217 if (status
!= BA_STATUS_ACTIVE
) {
3218 if (lq
->agg_ctrl
.auto_agg
) {
3219 lq
->agg_ctrl
.tid_retry
|= tid_msk
;
3220 lq
->agg_ctrl
.next_retry
=
3221 jiffies
+ msecs_to_jiffies(500);
3223 lq
->agg_ctrl
.requested_ba
&= ~tid_msk
;
3225 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3230 static void iwl4965_bg_agg_work(struct work_struct
*work
)
3232 struct iwl4965_priv
*priv
= container_of(work
, struct iwl4965_priv
,
3238 unsigned long flags
;
3239 struct iwl4965_lq_mngr
*lq
= (struct iwl4965_lq_mngr
*)&(priv
->lq_mngr
);
3241 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3242 retry_tid
= lq
->agg_ctrl
.tid_retry
;
3243 lq
->agg_ctrl
.tid_retry
= 0;
3244 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3246 if (retry_tid
== TID_ALL_SPECIFIED
)
3247 iwl4965_turn_on_agg(priv
, TID_ALL_SPECIFIED
);
3249 for (tid
= 0; tid
< TID_MAX_LOAD_COUNT
; tid
++) {
3250 tid_msk
= (1 << tid
);
3251 if (retry_tid
& tid_msk
)
3252 iwl4965_turn_on_agg(priv
, tid
);
3256 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3257 if (lq
->agg_ctrl
.tid_retry
)
3258 lq
->agg_ctrl
.next_retry
= jiffies
+ msecs_to_jiffies(500);
3259 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3262 #endif /*CONFIG_IWL4965_HT_AGG */
3263 #endif /* CONFIG_IWL4965_HT */
3265 int iwl4965_tx_cmd(struct iwl4965_priv
*priv
, struct iwl4965_cmd
*out_cmd
,
3266 u8 sta_id
, dma_addr_t txcmd_phys
,
3267 struct ieee80211_hdr
*hdr
, u8 hdr_len
,
3268 struct ieee80211_tx_control
*ctrl
, void *sta_in
)
3270 struct iwl4965_tx_cmd cmd
;
3271 struct iwl4965_tx_cmd
*tx
= (struct iwl4965_tx_cmd
*)&out_cmd
->cmd
.payload
[0];
3272 dma_addr_t scratch_phys
;
3277 int rate_index
= min(ctrl
->tx_rate
& 0xffff, IWL_RATE_COUNT
- 1);
3278 #ifdef CONFIG_IWL4965_HT
3279 #ifdef CONFIG_IWL4965_HT_AGG
3281 #endif /*CONFIG_IWL4965_HT_AGG */
3282 #endif /* CONFIG_IWL4965_HT */
3284 unicast
= !is_multicast_ether_addr(hdr
->addr1
);
3286 fc
= le16_to_cpu(hdr
->frame_control
);
3287 if ((fc
& IEEE80211_FCTL_FTYPE
) != IEEE80211_FTYPE_DATA
)
3290 memcpy(&cmd
, &(out_cmd
->cmd
.tx
), sizeof(struct iwl4965_tx_cmd
));
3291 memset(tx
, 0, sizeof(struct iwl4965_tx_cmd
));
3292 memcpy(tx
->hdr
, hdr
, hdr_len
);
3295 tx
->driver_txop
= cmd
.driver_txop
;
3296 tx
->stop_time
.life_time
= cmd
.stop_time
.life_time
;
3297 tx
->tx_flags
= cmd
.tx_flags
;
3298 tx
->sta_id
= cmd
.sta_id
;
3299 tx
->tid_tspec
= cmd
.tid_tspec
;
3300 tx
->timeout
.pm_frame_timeout
= cmd
.timeout
.pm_frame_timeout
;
3301 tx
->next_frame_len
= cmd
.next_frame_len
;
3303 tx
->sec_ctl
= cmd
.sec_ctl
;
3304 memcpy(&(tx
->key
[0]), &(cmd
.key
[0]), 16);
3305 tx
->tx_flags
= cmd
.tx_flags
;
3307 tx
->rts_retry_limit
= cmd
.rts_retry_limit
;
3308 tx
->data_retry_limit
= cmd
.data_retry_limit
;
3310 scratch_phys
= txcmd_phys
+ sizeof(struct iwl4965_cmd_header
) +
3311 offsetof(struct iwl4965_tx_cmd
, scratch
);
3312 tx
->dram_lsb_ptr
= cpu_to_le32(scratch_phys
);
3313 tx
->dram_msb_ptr
= iwl4965_get_dma_hi_address(scratch_phys
);
3315 /* Hard coded to start at the highest retry fallback position
3316 * until the 4965 specific rate control algorithm is tied in */
3317 tx
->initial_rate_index
= LINK_QUAL_MAX_RETRY_NUM
- 1;
3319 /* Alternate between antenna A and B for successive frames */
3320 if (priv
->use_ant_b_for_management_frame
) {
3321 priv
->use_ant_b_for_management_frame
= 0;
3322 rate_flags
= RATE_MCS_ANT_B_MSK
;
3324 priv
->use_ant_b_for_management_frame
= 1;
3325 rate_flags
= RATE_MCS_ANT_A_MSK
;
3328 if (!unicast
|| !is_data
) {
3329 if ((rate_index
>= IWL_FIRST_CCK_RATE
) &&
3330 (rate_index
<= IWL_LAST_CCK_RATE
))
3331 rate_flags
|= RATE_MCS_CCK_MSK
;
3333 tx
->initial_rate_index
= 0;
3334 tx
->tx_flags
|= TX_CMD_FLG_STA_RATE_MSK
;
3337 tx
->rate_n_flags
= iwl4965_hw_set_rate_n_flags(iwl4965_rates
[rate_index
].plcp
,
3340 if (ieee80211_is_back_request(fc
))
3341 tx
->tx_flags
|= TX_CMD_FLG_ACK_MSK
|
3342 TX_CMD_FLG_IMM_BA_RSP_MASK
;
3343 #ifdef CONFIG_IWL4965_HT
3344 #ifdef CONFIG_IWL4965_HT_AGG
3345 qc
= ieee80211_get_qos_ctrl(hdr
);
3347 (priv
->iw_mode
!= IEEE80211_IF_TYPE_IBSS
)) {
3349 tid
= (u8
) (le16_to_cpu(*qc
) & 0xF);
3350 if (tid
< TID_MAX_LOAD_COUNT
)
3351 iwl4965_tl_add_packet(priv
, tid
);
3354 if (priv
->lq_mngr
.agg_ctrl
.next_retry
&&
3355 (time_after(priv
->lq_mngr
.agg_ctrl
.next_retry
, jiffies
))) {
3356 unsigned long flags
;
3358 spin_lock_irqsave(&priv
->lq_mngr
.lock
, flags
);
3359 priv
->lq_mngr
.agg_ctrl
.next_retry
= 0;
3360 spin_unlock_irqrestore(&priv
->lq_mngr
.lock
, flags
);
3361 schedule_work(&priv
->agg_work
);
3369 * sign_extend - Sign extend a value using specified bit as sign-bit
3371 * Example: sign_extend(9, 3) would return -7 as bit3 of 1001b is 1
3372 * and bit0..2 is 001b which when sign extended to 1111111111111001b is -7.
3374 * @param oper value to sign extend
3375 * @param index 0 based bit index (0<=index<32) to sign bit
3377 static s32
sign_extend(u32 oper
, int index
)
3379 u8 shift
= 31 - index
;
3381 return (s32
)(oper
<< shift
) >> shift
;
3385 * iwl4965_get_temperature - return the calibrated temperature (in Kelvin)
3386 * @statistics: Provides the temperature reading from the uCode
3388 * A return of <0 indicates bogus data in the statistics
3390 int iwl4965_get_temperature(const struct iwl4965_priv
*priv
)
3397 if (test_bit(STATUS_TEMPERATURE
, &priv
->status
) &&
3398 (priv
->statistics
.flag
& STATISTICS_REPLY_FLG_FAT_MODE_MSK
)) {
3399 IWL_DEBUG_TEMP("Running FAT temperature calibration\n");
3400 R1
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r1
[1]);
3401 R2
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r2
[1]);
3402 R3
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r3
[1]);
3403 R4
= le32_to_cpu(priv
->card_alive_init
.therm_r4
[1]);
3405 IWL_DEBUG_TEMP("Running temperature calibration\n");
3406 R1
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r1
[0]);
3407 R2
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r2
[0]);
3408 R3
= (s32
)le32_to_cpu(priv
->card_alive_init
.therm_r3
[0]);
3409 R4
= le32_to_cpu(priv
->card_alive_init
.therm_r4
[0]);
3413 * Temperature is only 23 bits, so sign extend out to 32.
3415 * NOTE If we haven't received a statistics notification yet
3416 * with an updated temperature, use R4 provided to us in the
3417 * "initialize" ALIVE response.
3419 if (!test_bit(STATUS_TEMPERATURE
, &priv
->status
))
3420 vt
= sign_extend(R4
, 23);
3423 le32_to_cpu(priv
->statistics
.general
.temperature
), 23);
3425 IWL_DEBUG_TEMP("Calib values R[1-3]: %d %d %d R4: %d\n",
3429 IWL_ERROR("Calibration conflict R1 == R3\n");
3433 /* Calculate temperature in degrees Kelvin, adjust by 97%.
3434 * Add offset to center the adjustment around 0 degrees Centigrade. */
3435 temperature
= TEMPERATURE_CALIB_A_VAL
* (vt
- R2
);
3436 temperature
/= (R3
- R1
);
3437 temperature
= (temperature
* 97) / 100 +
3438 TEMPERATURE_CALIB_KELVIN_OFFSET
;
3440 IWL_DEBUG_TEMP("Calibrated temperature: %dK, %dC\n", temperature
,
3441 KELVIN_TO_CELSIUS(temperature
));
3446 /* Adjust Txpower only if temperature variance is greater than threshold. */
3447 #define IWL_TEMPERATURE_THRESHOLD 3
3450 * iwl4965_is_temp_calib_needed - determines if new calibration is needed
3452 * If the temperature changed has changed sufficiently, then a recalibration
3455 * Assumes caller will replace priv->last_temperature once calibration
3458 static int iwl4965_is_temp_calib_needed(struct iwl4965_priv
*priv
)
3462 if (!test_bit(STATUS_STATISTICS
, &priv
->status
)) {
3463 IWL_DEBUG_TEMP("Temperature not updated -- no statistics.\n");
3467 temp_diff
= priv
->temperature
- priv
->last_temperature
;
3469 /* get absolute value */
3470 if (temp_diff
< 0) {
3471 IWL_DEBUG_POWER("Getting cooler, delta %d, \n", temp_diff
);
3472 temp_diff
= -temp_diff
;
3473 } else if (temp_diff
== 0)
3474 IWL_DEBUG_POWER("Same temp, \n");
3476 IWL_DEBUG_POWER("Getting warmer, delta %d, \n", temp_diff
);
3478 if (temp_diff
< IWL_TEMPERATURE_THRESHOLD
) {
3479 IWL_DEBUG_POWER("Thermal txpower calib not needed\n");
3483 IWL_DEBUG_POWER("Thermal txpower calib needed\n");
3488 /* Calculate noise level, based on measurements during network silence just
3489 * before arriving beacon. This measurement can be done only if we know
3490 * exactly when to expect beacons, therefore only when we're associated. */
3491 static void iwl4965_rx_calc_noise(struct iwl4965_priv
*priv
)
3493 struct statistics_rx_non_phy
*rx_info
3494 = &(priv
->statistics
.rx
.general
);
3495 int num_active_rx
= 0;
3496 int total_silence
= 0;
3498 le32_to_cpu(rx_info
->beacon_silence_rssi_a
) & IN_BAND_FILTER
;
3500 le32_to_cpu(rx_info
->beacon_silence_rssi_b
) & IN_BAND_FILTER
;
3502 le32_to_cpu(rx_info
->beacon_silence_rssi_c
) & IN_BAND_FILTER
;
3504 if (bcn_silence_a
) {
3505 total_silence
+= bcn_silence_a
;
3508 if (bcn_silence_b
) {
3509 total_silence
+= bcn_silence_b
;
3512 if (bcn_silence_c
) {
3513 total_silence
+= bcn_silence_c
;
3517 /* Average among active antennas */
3519 priv
->last_rx_noise
= (total_silence
/ num_active_rx
) - 107;
3521 priv
->last_rx_noise
= IWL_NOISE_MEAS_NOT_AVAILABLE
;
3523 IWL_DEBUG_CALIB("inband silence a %u, b %u, c %u, dBm %d\n",
3524 bcn_silence_a
, bcn_silence_b
, bcn_silence_c
,
3525 priv
->last_rx_noise
);
3528 void iwl4965_hw_rx_statistics(struct iwl4965_priv
*priv
, struct iwl4965_rx_mem_buffer
*rxb
)
3530 struct iwl4965_rx_packet
*pkt
= (void *)rxb
->skb
->data
;
3534 IWL_DEBUG_RX("Statistics notification received (%d vs %d).\n",
3535 (int)sizeof(priv
->statistics
), pkt
->len
);
3537 change
= ((priv
->statistics
.general
.temperature
!=
3538 pkt
->u
.stats
.general
.temperature
) ||
3539 ((priv
->statistics
.flag
&
3540 STATISTICS_REPLY_FLG_FAT_MODE_MSK
) !=
3541 (pkt
->u
.stats
.flag
& STATISTICS_REPLY_FLG_FAT_MODE_MSK
)));
3543 memcpy(&priv
->statistics
, &pkt
->u
.stats
, sizeof(priv
->statistics
));
3545 set_bit(STATUS_STATISTICS
, &priv
->status
);
3547 /* Reschedule the statistics timer to occur in
3548 * REG_RECALIB_PERIOD seconds to ensure we get a
3549 * thermal update even if the uCode doesn't give
3551 mod_timer(&priv
->statistics_periodic
, jiffies
+
3552 msecs_to_jiffies(REG_RECALIB_PERIOD
* 1000));
3554 if (unlikely(!test_bit(STATUS_SCANNING
, &priv
->status
)) &&
3555 (pkt
->hdr
.cmd
== STATISTICS_NOTIFICATION
)) {
3556 iwl4965_rx_calc_noise(priv
);
3557 #ifdef CONFIG_IWL4965_SENSITIVITY
3558 queue_work(priv
->workqueue
, &priv
->sensitivity_work
);
3562 /* If the hardware hasn't reported a change in
3563 * temperature then don't bother computing a
3564 * calibrated temperature value */
3568 temp
= iwl4965_get_temperature(priv
);
3572 if (priv
->temperature
!= temp
) {
3573 if (priv
->temperature
)
3574 IWL_DEBUG_TEMP("Temperature changed "
3575 "from %dC to %dC\n",
3576 KELVIN_TO_CELSIUS(priv
->temperature
),
3577 KELVIN_TO_CELSIUS(temp
));
3579 IWL_DEBUG_TEMP("Temperature "
3580 "initialized to %dC\n",
3581 KELVIN_TO_CELSIUS(temp
));
3584 priv
->temperature
= temp
;
3585 set_bit(STATUS_TEMPERATURE
, &priv
->status
);
3587 if (unlikely(!test_bit(STATUS_SCANNING
, &priv
->status
)) &&
3588 iwl4965_is_temp_calib_needed(priv
))
3589 queue_work(priv
->workqueue
, &priv
->txpower_work
);
3592 static void iwl4965_add_radiotap(struct iwl4965_priv
*priv
,
3593 struct sk_buff
*skb
,
3594 struct iwl4965_rx_phy_res
*rx_start
,
3595 struct ieee80211_rx_status
*stats
,
3598 s8 signal
= stats
->ssi
;
3600 int rate
= stats
->rate
;
3601 u64 tsf
= stats
->mactime
;
3602 __le16 phy_flags_hw
= rx_start
->phy_flags
;
3603 struct iwl4965_rt_rx_hdr
{
3604 struct ieee80211_radiotap_header rt_hdr
;
3605 __le64 rt_tsf
; /* TSF */
3606 u8 rt_flags
; /* radiotap packet flags */
3607 u8 rt_rate
; /* rate in 500kb/s */
3608 __le16 rt_channelMHz
; /* channel in MHz */
3609 __le16 rt_chbitmask
; /* channel bitfield */
3610 s8 rt_dbmsignal
; /* signal in dBm, kluged to signed */
3612 u8 rt_antenna
; /* antenna number */
3613 } __attribute__ ((packed
)) *iwl4965_rt
;
3615 /* TODO: We won't have enough headroom for HT frames. Fix it later. */
3616 if (skb_headroom(skb
) < sizeof(*iwl4965_rt
)) {
3617 if (net_ratelimit())
3618 printk(KERN_ERR
"not enough headroom [%d] for "
3619 "radiotap head [%zd]\n",
3620 skb_headroom(skb
), sizeof(*iwl4965_rt
));
3624 /* put radiotap header in front of 802.11 header and data */
3625 iwl4965_rt
= (void *)skb_push(skb
, sizeof(*iwl4965_rt
));
3627 /* initialise radiotap header */
3628 iwl4965_rt
->rt_hdr
.it_version
= PKTHDR_RADIOTAP_VERSION
;
3629 iwl4965_rt
->rt_hdr
.it_pad
= 0;
3631 /* total header + data */
3632 put_unaligned(cpu_to_le16(sizeof(*iwl4965_rt
)),
3633 &iwl4965_rt
->rt_hdr
.it_len
);
3635 /* Indicate all the fields we add to the radiotap header */
3636 put_unaligned(cpu_to_le32((1 << IEEE80211_RADIOTAP_TSFT
) |
3637 (1 << IEEE80211_RADIOTAP_FLAGS
) |
3638 (1 << IEEE80211_RADIOTAP_RATE
) |
3639 (1 << IEEE80211_RADIOTAP_CHANNEL
) |
3640 (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL
) |
3641 (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE
) |
3642 (1 << IEEE80211_RADIOTAP_ANTENNA
)),
3643 &iwl4965_rt
->rt_hdr
.it_present
);
3645 /* Zero the flags, we'll add to them as we go */
3646 iwl4965_rt
->rt_flags
= 0;
3648 put_unaligned(cpu_to_le64(tsf
), &iwl4965_rt
->rt_tsf
);
3650 iwl4965_rt
->rt_dbmsignal
= signal
;
3651 iwl4965_rt
->rt_dbmnoise
= noise
;
3653 /* Convert the channel frequency and set the flags */
3654 put_unaligned(cpu_to_le16(stats
->freq
), &iwl4965_rt
->rt_channelMHz
);
3655 if (!(phy_flags_hw
& RX_RES_PHY_FLAGS_BAND_24_MSK
))
3656 put_unaligned(cpu_to_le16(IEEE80211_CHAN_OFDM
|
3657 IEEE80211_CHAN_5GHZ
),
3658 &iwl4965_rt
->rt_chbitmask
);
3659 else if (phy_flags_hw
& RX_RES_PHY_FLAGS_MOD_CCK_MSK
)
3660 put_unaligned(cpu_to_le16(IEEE80211_CHAN_CCK
|
3661 IEEE80211_CHAN_2GHZ
),
3662 &iwl4965_rt
->rt_chbitmask
);
3664 put_unaligned(cpu_to_le16(IEEE80211_CHAN_OFDM
|
3665 IEEE80211_CHAN_2GHZ
),
3666 &iwl4965_rt
->rt_chbitmask
);
3668 rate
= iwl4965_rate_index_from_plcp(rate
);
3670 iwl4965_rt
->rt_rate
= 0;
3672 iwl4965_rt
->rt_rate
= iwl4965_rates
[rate
].ieee
;
3677 * It seems that the antenna field in the phy flags value
3678 * is actually a bitfield. This is undefined by radiotap,
3679 * it wants an actual antenna number but I always get "7"
3680 * for most legacy frames I receive indicating that the
3681 * same frame was received on all three RX chains.
3683 * I think this field should be removed in favour of a
3684 * new 802.11n radiotap field "RX chains" that is defined
3687 iwl4965_rt
->rt_antenna
=
3688 le16_to_cpu(phy_flags_hw
& RX_RES_PHY_FLAGS_ANTENNA_MSK
) >> 4;
3690 /* set the preamble flag if appropriate */
3691 if (phy_flags_hw
& RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK
)
3692 iwl4965_rt
->rt_flags
|= IEEE80211_RADIOTAP_F_SHORTPRE
;
3694 stats
->flag
|= RX_FLAG_RADIOTAP
;
3697 static void iwl4965_handle_data_packet(struct iwl4965_priv
*priv
, int is_data
,
3699 struct iwl4965_rx_mem_buffer
*rxb
,
3700 struct ieee80211_rx_status
*stats
)
3702 struct iwl4965_rx_packet
*pkt
= (struct iwl4965_rx_packet
*)rxb
->skb
->data
;
3703 struct iwl4965_rx_phy_res
*rx_start
= (include_phy
) ?
3704 (struct iwl4965_rx_phy_res
*)&(pkt
->u
.raw
[0]) : NULL
;
3705 struct ieee80211_hdr
*hdr
;
3708 unsigned int skblen
;
3711 if (!include_phy
&& priv
->last_phy_res
[0])
3712 rx_start
= (struct iwl4965_rx_phy_res
*)&priv
->last_phy_res
[1];
3715 IWL_ERROR("MPDU frame without a PHY data\n");
3719 hdr
= (struct ieee80211_hdr
*)((u8
*) & rx_start
[1] +
3720 rx_start
->cfg_phy_cnt
);
3722 len
= le16_to_cpu(rx_start
->byte_count
);
3724 rx_end
= (__le32
*) ((u8
*) & pkt
->u
.raw
[0] +
3725 sizeof(struct iwl4965_rx_phy_res
) +
3726 rx_start
->cfg_phy_cnt
+ len
);
3729 struct iwl4965_rx_mpdu_res_start
*amsdu
=
3730 (struct iwl4965_rx_mpdu_res_start
*)pkt
->u
.raw
;
3732 hdr
= (struct ieee80211_hdr
*)(pkt
->u
.raw
+
3733 sizeof(struct iwl4965_rx_mpdu_res_start
));
3734 len
= le16_to_cpu(amsdu
->byte_count
);
3735 rx_start
->byte_count
= amsdu
->byte_count
;
3736 rx_end
= (__le32
*) (((u8
*) hdr
) + len
);
3738 if (len
> priv
->hw_setting
.max_pkt_size
|| len
< 16) {
3739 IWL_WARNING("byte count out of range [16,4K] : %d\n", len
);
3743 ampdu_status
= le32_to_cpu(*rx_end
);
3744 skblen
= ((u8
*) rx_end
- (u8
*) & pkt
->u
.raw
[0]) + sizeof(u32
);
3746 /* start from MAC */
3747 skb_reserve(rxb
->skb
, (void *)hdr
- (void *)pkt
);
3748 skb_put(rxb
->skb
, len
); /* end where data ends */
3750 /* We only process data packets if the interface is open */
3751 if (unlikely(!priv
->is_open
)) {
3752 IWL_DEBUG_DROP_LIMIT
3753 ("Dropping packet while interface is not open.\n");
3758 hdr
= (struct ieee80211_hdr
*)rxb
->skb
->data
;
3760 if (iwl4965_param_hwcrypto
)
3761 iwl4965_set_decrypted_flag(priv
, rxb
->skb
, ampdu_status
, stats
);
3763 if (priv
->add_radiotap
)
3764 iwl4965_add_radiotap(priv
, rxb
->skb
, rx_start
, stats
, ampdu_status
);
3766 ieee80211_rx_irqsafe(priv
->hw
, rxb
->skb
, stats
);
3767 priv
->alloc_rxb_skb
--;
3770 priv
->led_packets
+= len
;
3771 iwl4965_setup_activity_timer(priv
);
3775 /* Calc max signal level (dBm) among 3 possible receivers */
3776 static int iwl4965_calc_rssi(struct iwl4965_rx_phy_res
*rx_resp
)
3778 /* data from PHY/DSP regarding signal strength, etc.,
3779 * contents are always there, not configurable by host. */
3780 struct iwl4965_rx_non_cfg_phy
*ncphy
=
3781 (struct iwl4965_rx_non_cfg_phy
*)rx_resp
->non_cfg_phy
;
3782 u32 agc
= (le16_to_cpu(ncphy
->agc_info
) & IWL_AGC_DB_MASK
)
3785 u32 valid_antennae
=
3786 (le16_to_cpu(rx_resp
->phy_flags
) & RX_PHY_FLAGS_ANTENNAE_MASK
)
3787 >> RX_PHY_FLAGS_ANTENNAE_OFFSET
;
3791 /* Find max rssi among 3 possible receivers.
3792 * These values are measured by the digital signal processor (DSP).
3793 * They should stay fairly constant even as the signal strength varies,
3794 * if the radio's automatic gain control (AGC) is working right.
3795 * AGC value (see below) will provide the "interesting" info. */
3796 for (i
= 0; i
< 3; i
++)
3797 if (valid_antennae
& (1 << i
))
3798 max_rssi
= max(ncphy
->rssi_info
[i
<< 1], max_rssi
);
3800 IWL_DEBUG_STATS("Rssi In A %d B %d C %d Max %d AGC dB %d\n",
3801 ncphy
->rssi_info
[0], ncphy
->rssi_info
[2], ncphy
->rssi_info
[4],
3804 /* dBm = max_rssi dB - agc dB - constant.
3805 * Higher AGC (higher radio gain) means lower signal. */
3806 return (max_rssi
- agc
- IWL_RSSI_OFFSET
);
3809 #ifdef CONFIG_IWL4965_HT
3811 /* Parsed Information Elements */
3812 struct ieee802_11_elems
{
3822 u8 ht_cap_param_len
;
3824 u8 ht_extra_param_len
;
3827 static int parse_elems(u8
*start
, size_t len
, struct ieee802_11_elems
*elems
)
3833 memset(elems
, 0, sizeof(*elems
));
3846 case WLAN_EID_DS_PARAMS
:
3847 elems
->ds_params
= pos
;
3848 elems
->ds_params_len
= elen
;
3852 elems
->tim_len
= elen
;
3854 case WLAN_EID_IBSS_PARAMS
:
3855 elems
->ibss_params
= pos
;
3856 elems
->ibss_params_len
= elen
;
3858 case WLAN_EID_ERP_INFO
:
3859 elems
->erp_info
= pos
;
3860 elems
->erp_info_len
= elen
;
3862 case WLAN_EID_HT_CAPABILITY
:
3863 elems
->ht_cap_param
= pos
;
3864 elems
->ht_cap_param_len
= elen
;
3866 case WLAN_EID_HT_EXTRA_INFO
:
3867 elems
->ht_extra_param
= pos
;
3868 elems
->ht_extra_param_len
= elen
;
3882 void iwl4965_init_ht_hw_capab(struct ieee80211_ht_info
*ht_info
, int mode
)
3885 memset(ht_info
->supp_mcs_set
, 0, 16);
3887 ht_info
->ht_supported
= 1;
3889 if (mode
== MODE_IEEE80211A
) {
3890 ht_info
->cap
|= (u16
)IEEE80211_HT_CAP_SUP_WIDTH
;
3891 ht_info
->cap
|= (u16
)IEEE80211_HT_CAP_SGI_40
;
3892 ht_info
->supp_mcs_set
[4] = 0x01;
3894 ht_info
->cap
|= (u16
)IEEE80211_HT_CAP_GRN_FLD
;
3895 ht_info
->cap
|= (u16
)IEEE80211_HT_CAP_SGI_20
;
3896 ht_info
->cap
|= (u16
)(IEEE80211_HT_CAP_MIMO_PS
&
3897 (IWL_MIMO_PS_NONE
<< 2));
3898 if (iwl4965_param_amsdu_size_8K
) {
3899 printk(KERN_DEBUG
"iwl4965 in A-MSDU 8K support mode\n");
3900 ht_info
->cap
|= (u16
)IEEE80211_HT_CAP_MAX_AMSDU
;
3903 ht_info
->ampdu_factor
= CFG_HT_RX_AMPDU_FACTOR_DEF
;
3904 ht_info
->ampdu_density
= CFG_HT_MPDU_DENSITY_DEF
;
3906 ht_info
->supp_mcs_set
[0] = 0xFF;
3907 ht_info
->supp_mcs_set
[1] = 0xFF;
3909 #endif /* CONFIG_IWL4965_HT */
3911 static void iwl4965_sta_modify_ps_wake(struct iwl4965_priv
*priv
, int sta_id
)
3913 unsigned long flags
;
3915 spin_lock_irqsave(&priv
->sta_lock
, flags
);
3916 priv
->stations
[sta_id
].sta
.station_flags
&= ~STA_FLG_PWR_SAVE_MSK
;
3917 priv
->stations
[sta_id
].sta
.station_flags_msk
= STA_FLG_PWR_SAVE_MSK
;
3918 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= 0;
3919 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
3920 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
3922 iwl4965_send_add_station(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
3925 static void iwl4965_update_ps_mode(struct iwl4965_priv
*priv
, u16 ps_bit
, u8
*addr
)
3927 /* FIXME: need locking over ps_status ??? */
3928 u8 sta_id
= iwl4965_hw_find_station(priv
, addr
);
3930 if (sta_id
!= IWL_INVALID_STATION
) {
3931 u8 sta_awake
= priv
->stations
[sta_id
].
3932 ps_status
== STA_PS_STATUS_WAKE
;
3934 if (sta_awake
&& ps_bit
)
3935 priv
->stations
[sta_id
].ps_status
= STA_PS_STATUS_SLEEP
;
3936 else if (!sta_awake
&& !ps_bit
) {
3937 iwl4965_sta_modify_ps_wake(priv
, sta_id
);
3938 priv
->stations
[sta_id
].ps_status
= STA_PS_STATUS_WAKE
;
3943 #define IWL_DELAY_NEXT_SCAN_AFTER_ASSOC (HZ*6)
3945 /* Called for REPLY_4965_RX (legacy ABG frames), or
3946 * REPLY_RX_MPDU_CMD (HT high-throughput N frames). */
3947 static void iwl4965_rx_reply_rx(struct iwl4965_priv
*priv
,
3948 struct iwl4965_rx_mem_buffer
*rxb
)
3950 struct iwl4965_rx_packet
*pkt
= (void *)rxb
->skb
->data
;
3951 /* Use phy data (Rx signal strength, etc.) contained within
3952 * this rx packet for legacy frames,
3953 * or phy data cached from REPLY_RX_PHY_CMD for HT frames. */
3954 int include_phy
= (pkt
->hdr
.cmd
== REPLY_4965_RX
);
3955 struct iwl4965_rx_phy_res
*rx_start
= (include_phy
) ?
3956 (struct iwl4965_rx_phy_res
*)&(pkt
->u
.raw
[0]) :
3957 (struct iwl4965_rx_phy_res
*)&priv
->last_phy_res
[1];
3959 unsigned int len
= 0;
3960 struct ieee80211_hdr
*header
;
3962 struct ieee80211_rx_status stats
= {
3963 .mactime
= le64_to_cpu(rx_start
->timestamp
),
3964 .channel
= le16_to_cpu(rx_start
->channel
),
3966 (rx_start
->phy_flags
& RX_RES_PHY_FLAGS_BAND_24_MSK
) ?
3967 MODE_IEEE80211G
: MODE_IEEE80211A
,
3969 .rate
= iwl4965_hw_get_rate(rx_start
->rate_n_flags
),
3974 if ((unlikely(rx_start
->cfg_phy_cnt
> 20))) {
3976 ("dsp size out of range [0,20]: "
3977 "%d/n", rx_start
->cfg_phy_cnt
);
3981 if (priv
->last_phy_res
[0])
3982 rx_start
= (struct iwl4965_rx_phy_res
*)
3983 &priv
->last_phy_res
[1];
3989 IWL_ERROR("MPDU frame without a PHY data\n");
3994 header
= (struct ieee80211_hdr
*)((u8
*) & rx_start
[1]
3995 + rx_start
->cfg_phy_cnt
);
3997 len
= le16_to_cpu(rx_start
->byte_count
);
3998 rx_end
= (__le32
*) (pkt
->u
.raw
+ rx_start
->cfg_phy_cnt
+
3999 sizeof(struct iwl4965_rx_phy_res
) + len
);
4001 struct iwl4965_rx_mpdu_res_start
*amsdu
=
4002 (struct iwl4965_rx_mpdu_res_start
*)pkt
->u
.raw
;
4004 header
= (void *)(pkt
->u
.raw
+
4005 sizeof(struct iwl4965_rx_mpdu_res_start
));
4006 len
= le16_to_cpu(amsdu
->byte_count
);
4007 rx_end
= (__le32
*) (pkt
->u
.raw
+
4008 sizeof(struct iwl4965_rx_mpdu_res_start
) + len
);
4011 if (!(*rx_end
& RX_RES_STATUS_NO_CRC32_ERROR
) ||
4012 !(*rx_end
& RX_RES_STATUS_NO_RXE_OVERFLOW
)) {
4013 IWL_DEBUG_RX("Bad CRC or FIFO: 0x%08X.\n",
4014 le32_to_cpu(*rx_end
));
4018 priv
->ucode_beacon_time
= le32_to_cpu(rx_start
->beacon_time_stamp
);
4020 stats
.freq
= ieee80211chan2mhz(stats
.channel
);
4022 /* Find max signal strength (dBm) among 3 antenna/receiver chains */
4023 stats
.ssi
= iwl4965_calc_rssi(rx_start
);
4025 /* Meaningful noise values are available only from beacon statistics,
4026 * which are gathered only when associated, and indicate noise
4027 * only for the associated network channel ...
4028 * Ignore these noise values while scanning (other channels) */
4029 if (iwl4965_is_associated(priv
) &&
4030 !test_bit(STATUS_SCANNING
, &priv
->status
)) {
4031 stats
.noise
= priv
->last_rx_noise
;
4032 stats
.signal
= iwl4965_calc_sig_qual(stats
.ssi
, stats
.noise
);
4034 stats
.noise
= IWL_NOISE_MEAS_NOT_AVAILABLE
;
4035 stats
.signal
= iwl4965_calc_sig_qual(stats
.ssi
, 0);
4038 /* Reset beacon noise level if not associated. */
4039 if (!iwl4965_is_associated(priv
))
4040 priv
->last_rx_noise
= IWL_NOISE_MEAS_NOT_AVAILABLE
;
4042 #ifdef CONFIG_IWL4965_DEBUG
4043 /* TODO: Parts of iwl4965_report_frame are broken for 4965 */
4044 if (iwl4965_debug_level
& (IWL_DL_RX
))
4045 /* Set "1" to report good data frames in groups of 100 */
4046 iwl4965_report_frame(priv
, pkt
, header
, 1);
4048 if (iwl4965_debug_level
& (IWL_DL_RX
| IWL_DL_STATS
))
4049 IWL_DEBUG_RX("Rssi %d, noise %d, qual %d, TSF %lu\n",
4050 stats
.ssi
, stats
.noise
, stats
.signal
,
4051 (long unsigned int)le64_to_cpu(rx_start
->timestamp
));
4054 network_packet
= iwl4965_is_network_packet(priv
, header
);
4055 if (network_packet
) {
4056 priv
->last_rx_rssi
= stats
.ssi
;
4057 priv
->last_beacon_time
= priv
->ucode_beacon_time
;
4058 priv
->last_tsf
= le64_to_cpu(rx_start
->timestamp
);
4061 fc
= le16_to_cpu(header
->frame_control
);
4062 switch (fc
& IEEE80211_FCTL_FTYPE
) {
4063 case IEEE80211_FTYPE_MGMT
:
4065 if (priv
->iw_mode
== IEEE80211_IF_TYPE_AP
)
4066 iwl4965_update_ps_mode(priv
, fc
& IEEE80211_FCTL_PM
,
4068 switch (fc
& IEEE80211_FCTL_STYPE
) {
4069 case IEEE80211_STYPE_PROBE_RESP
:
4070 case IEEE80211_STYPE_BEACON
:
4071 if ((priv
->iw_mode
== IEEE80211_IF_TYPE_STA
&&
4072 !compare_ether_addr(header
->addr2
, priv
->bssid
)) ||
4073 (priv
->iw_mode
== IEEE80211_IF_TYPE_IBSS
&&
4074 !compare_ether_addr(header
->addr3
, priv
->bssid
))) {
4075 struct ieee80211_mgmt
*mgmt
=
4076 (struct ieee80211_mgmt
*)header
;
4078 le64_to_cpu(mgmt
->u
.beacon
.timestamp
);
4080 priv
->timestamp0
= timestamp
& 0xFFFFFFFF;
4082 (timestamp
>> 32) & 0xFFFFFFFF;
4083 priv
->beacon_int
= le16_to_cpu(
4084 mgmt
->u
.beacon
.beacon_int
);
4085 if (priv
->call_post_assoc_from_beacon
&&
4086 (priv
->iw_mode
== IEEE80211_IF_TYPE_STA
)) {
4087 priv
->call_post_assoc_from_beacon
= 0;
4088 queue_work(priv
->workqueue
,
4089 &priv
->post_associate
.work
);
4094 case IEEE80211_STYPE_ACTION
:
4098 * TODO: There is no callback function from upper
4099 * stack to inform us when associated status. this
4100 * work around to sniff assoc_resp management frame
4101 * and finish the association process.
4103 case IEEE80211_STYPE_ASSOC_RESP
:
4104 case IEEE80211_STYPE_REASSOC_RESP
:
4105 if (network_packet
) {
4106 #ifdef CONFIG_IWL4965_HT
4108 struct ieee802_11_elems elems
;
4109 #endif /*CONFIG_IWL4965_HT */
4110 struct ieee80211_mgmt
*mgnt
=
4111 (struct ieee80211_mgmt
*)header
;
4113 /* We have just associated, give some
4114 * time for the 4-way handshake if
4115 * any. Don't start scan too early. */
4116 priv
->next_scan_jiffies
= jiffies
+
4117 IWL_DELAY_NEXT_SCAN_AFTER_ASSOC
;
4119 priv
->assoc_id
= (~((1 << 15) | (1 << 14))
4120 & le16_to_cpu(mgnt
->u
.assoc_resp
.aid
));
4121 priv
->assoc_capability
=
4123 mgnt
->u
.assoc_resp
.capab_info
);
4124 #ifdef CONFIG_IWL4965_HT
4125 pos
= mgnt
->u
.assoc_resp
.variable
;
4126 if (!parse_elems(pos
,
4127 len
- (pos
- (u8
*) mgnt
),
4129 if (elems
.ht_extra_param
&&
4133 #endif /*CONFIG_IWL4965_HT */
4134 /* assoc_id is 0 no association */
4135 if (!priv
->assoc_id
)
4137 if (priv
->beacon_int
)
4138 queue_work(priv
->workqueue
,
4139 &priv
->post_associate
.work
);
4141 priv
->call_post_assoc_from_beacon
= 1;
4146 case IEEE80211_STYPE_PROBE_REQ
:
4147 if ((priv
->iw_mode
== IEEE80211_IF_TYPE_IBSS
) &&
4148 !iwl4965_is_associated(priv
)) {
4149 DECLARE_MAC_BUF(mac1
);
4150 DECLARE_MAC_BUF(mac2
);
4151 DECLARE_MAC_BUF(mac3
);
4153 IWL_DEBUG_DROP("Dropping (non network): "
4155 print_mac(mac1
, header
->addr1
),
4156 print_mac(mac2
, header
->addr2
),
4157 print_mac(mac3
, header
->addr3
));
4161 iwl4965_handle_data_packet(priv
, 0, include_phy
, rxb
, &stats
);
4164 case IEEE80211_FTYPE_CTL
:
4165 #ifdef CONFIG_IWL4965_HT
4166 switch (fc
& IEEE80211_FCTL_STYPE
) {
4167 case IEEE80211_STYPE_BACK_REQ
:
4168 IWL_DEBUG_HT("IEEE80211_STYPE_BACK_REQ arrived\n");
4169 iwl4965_handle_data_packet(priv
, 0, include_phy
,
4178 case IEEE80211_FTYPE_DATA
: {
4179 DECLARE_MAC_BUF(mac1
);
4180 DECLARE_MAC_BUF(mac2
);
4181 DECLARE_MAC_BUF(mac3
);
4183 if (priv
->iw_mode
== IEEE80211_IF_TYPE_AP
)
4184 iwl4965_update_ps_mode(priv
, fc
& IEEE80211_FCTL_PM
,
4187 if (unlikely(!network_packet
))
4188 IWL_DEBUG_DROP("Dropping (non network): "
4190 print_mac(mac1
, header
->addr1
),
4191 print_mac(mac2
, header
->addr2
),
4192 print_mac(mac3
, header
->addr3
));
4193 else if (unlikely(iwl4965_is_duplicate_packet(priv
, header
)))
4194 IWL_DEBUG_DROP("Dropping (dup): %s, %s, %s\n",
4195 print_mac(mac1
, header
->addr1
),
4196 print_mac(mac2
, header
->addr2
),
4197 print_mac(mac3
, header
->addr3
));
4199 iwl4965_handle_data_packet(priv
, 1, include_phy
, rxb
,
4209 /* Cache phy data (Rx signal strength, etc) for HT frame (REPLY_RX_PHY_CMD).
4210 * This will be used later in iwl4965_rx_reply_rx() for REPLY_RX_MPDU_CMD. */
4211 static void iwl4965_rx_reply_rx_phy(struct iwl4965_priv
*priv
,
4212 struct iwl4965_rx_mem_buffer
*rxb
)
4214 struct iwl4965_rx_packet
*pkt
= (void *)rxb
->skb
->data
;
4215 priv
->last_phy_res
[0] = 1;
4216 memcpy(&priv
->last_phy_res
[1], &(pkt
->u
.raw
[0]),
4217 sizeof(struct iwl4965_rx_phy_res
));
4220 static void iwl4965_rx_missed_beacon_notif(struct iwl4965_priv
*priv
,
4221 struct iwl4965_rx_mem_buffer
*rxb
)
4224 #ifdef CONFIG_IWL4965_SENSITIVITY
4225 struct iwl4965_rx_packet
*pkt
= (void *)rxb
->skb
->data
;
4226 struct iwl4965_missed_beacon_notif
*missed_beacon
;
4228 missed_beacon
= &pkt
->u
.missed_beacon
;
4229 if (le32_to_cpu(missed_beacon
->consequtive_missed_beacons
) > 5) {
4230 IWL_DEBUG_CALIB("missed bcn cnsq %d totl %d rcd %d expctd %d\n",
4231 le32_to_cpu(missed_beacon
->consequtive_missed_beacons
),
4232 le32_to_cpu(missed_beacon
->total_missed_becons
),
4233 le32_to_cpu(missed_beacon
->num_recvd_beacons
),
4234 le32_to_cpu(missed_beacon
->num_expected_beacons
));
4235 priv
->sensitivity_data
.state
= IWL_SENS_CALIB_NEED_REINIT
;
4236 if (unlikely(!test_bit(STATUS_SCANNING
, &priv
->status
)))
4237 queue_work(priv
->workqueue
, &priv
->sensitivity_work
);
4239 #endif /*CONFIG_IWL4965_SENSITIVITY*/
4242 #ifdef CONFIG_IWL4965_HT
4243 #ifdef CONFIG_IWL4965_HT_AGG
4246 * iwl4965_set_tx_status - Update driver's record of one Tx frame's status
4248 * This will get sent to mac80211.
4250 static void iwl4965_set_tx_status(struct iwl4965_priv
*priv
, int txq_id
, int idx
,
4251 u32 status
, u32 retry_count
, u32 rate
)
4253 struct ieee80211_tx_status
*tx_status
=
4254 &(priv
->txq
[txq_id
].txb
[idx
].status
);
4256 tx_status
->flags
= status
? IEEE80211_TX_STATUS_ACK
: 0;
4257 tx_status
->retry_count
+= retry_count
;
4258 tx_status
->control
.tx_rate
= rate
;
4263 * iwl4965_sta_modify_enable_tid_tx - Enable Tx for this TID in station table
4265 static void iwl4965_sta_modify_enable_tid_tx(struct iwl4965_priv
*priv
,
4266 int sta_id
, int tid
)
4268 unsigned long flags
;
4270 /* Remove "disable" flag, to enable Tx for this TID */
4271 spin_lock_irqsave(&priv
->sta_lock
, flags
);
4272 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_TID_DISABLE_TX
;
4273 priv
->stations
[sta_id
].sta
.tid_disable_tx
&= cpu_to_le16(~(1 << tid
));
4274 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
4275 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
4277 iwl4965_send_add_station(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
4282 * iwl4965_tx_status_reply_compressed_ba - Update tx status from block-ack
4284 * Go through block-ack's bitmap of ACK'd frames, update driver's record of
4285 * ACK vs. not. This gets sent to mac80211, then to rate scaling algo.
4287 static int iwl4965_tx_status_reply_compressed_ba(struct iwl4965_priv
*priv
,
4288 struct iwl4965_ht_agg
*agg
,
4289 struct iwl4965_compressed_ba_resp
*
4294 u16 ba_seq_ctl
= le16_to_cpu(ba_resp
->ba_seq_ctl
);
4295 u32 bitmap0
, bitmap1
;
4296 u32 resp_bitmap0
= le32_to_cpu(ba_resp
->ba_bitmap0
);
4297 u32 resp_bitmap1
= le32_to_cpu(ba_resp
->ba_bitmap1
);
4299 if (unlikely(!agg
->wait_for_ba
)) {
4300 IWL_ERROR("Received BA when not expected\n");
4304 /* Mark that the expected block-ack response arrived */
4305 agg
->wait_for_ba
= 0;
4306 IWL_DEBUG_TX_REPLY("BA %d %d\n", agg
->start_idx
, ba_resp
->ba_seq_ctl
);
4308 /* Calculate shift to align block-ack bits with our Tx window bits */
4309 sh
= agg
->start_idx
- SEQ_TO_INDEX(ba_seq_ctl
>>4);
4310 if (sh
< 0) /* tbw something is wrong with indices */
4313 /* don't use 64-bit values for now */
4314 bitmap0
= resp_bitmap0
>> sh
;
4315 bitmap1
= resp_bitmap1
>> sh
;
4316 bitmap0
|= (resp_bitmap1
& ((1<<sh
)|((1<<sh
)-1))) << (32 - sh
);
4318 if (agg
->frame_count
> (64 - sh
)) {
4319 IWL_DEBUG_TX_REPLY("more frames than bitmap size");
4323 /* check for success or failure according to the
4324 * transmitted bitmap and block-ack bitmap */
4325 bitmap0
&= agg
->bitmap0
;
4326 bitmap1
&= agg
->bitmap1
;
4328 /* For each frame attempted in aggregation,
4329 * update driver's record of tx frame's status. */
4330 for (i
= 0; i
< agg
->frame_count
; i
++) {
4331 int idx
= (agg
->start_idx
+ i
) & 0xff;
4332 ack
= bitmap0
& (1 << i
);
4333 IWL_DEBUG_TX_REPLY("%s ON i=%d idx=%d raw=%d\n",
4334 ack
? "ACK":"NACK", i
, idx
, agg
->start_idx
+ i
);
4335 iwl4965_set_tx_status(priv
, agg
->txq_id
, idx
, ack
, 0,
4340 IWL_DEBUG_TX_REPLY("Bitmap %x%x\n", bitmap0
, bitmap1
);
4346 * iwl4965_queue_dec_wrap - Decrement queue index, wrap back to end if needed
4347 * @index -- current index
4348 * @n_bd -- total number of entries in queue (s/b power of 2)
4350 static inline int iwl4965_queue_dec_wrap(int index
, int n_bd
)
4352 return (index
== 0) ? n_bd
- 1 : index
- 1;
4356 * iwl4965_rx_reply_compressed_ba - Handler for REPLY_COMPRESSED_BA
4358 * Handles block-acknowledge notification from device, which reports success
4359 * of frames sent via aggregation.
4361 static void iwl4965_rx_reply_compressed_ba(struct iwl4965_priv
*priv
,
4362 struct iwl4965_rx_mem_buffer
*rxb
)
4364 struct iwl4965_rx_packet
*pkt
= (void *)rxb
->skb
->data
;
4365 struct iwl4965_compressed_ba_resp
*ba_resp
= &pkt
->u
.compressed_ba
;
4367 struct iwl4965_tx_queue
*txq
= NULL
;
4368 struct iwl4965_ht_agg
*agg
;
4370 /* "flow" corresponds to Tx queue */
4371 u16 ba_resp_scd_flow
= le16_to_cpu(ba_resp
->scd_flow
);
4373 /* "ssn" is start of block-ack Tx window, corresponds to index
4374 * (in Tx queue's circular buffer) of first TFD/frame in window */
4375 u16 ba_resp_scd_ssn
= le16_to_cpu(ba_resp
->scd_ssn
);
4377 if (ba_resp_scd_flow
>= ARRAY_SIZE(priv
->txq
)) {
4378 IWL_ERROR("BUG_ON scd_flow is bigger than number of queues");
4382 txq
= &priv
->txq
[ba_resp_scd_flow
];
4383 agg
= &priv
->stations
[ba_resp
->sta_id
].tid
[ba_resp
->tid
].agg
;
4385 /* Find index just before block-ack window */
4386 index
= iwl4965_queue_dec_wrap(ba_resp_scd_ssn
& 0xff, txq
->q
.n_bd
);
4388 /* TODO: Need to get this copy more safely - now good for debug */
4391 DECLARE_MAC_BUF(mac);
4392 IWL_DEBUG_TX_REPLY("REPLY_COMPRESSED_BA [%d]Received from %s, "
4395 print_mac(mac, (u8*) &ba_resp->sta_addr_lo32),
4397 IWL_DEBUG_TX_REPLY("TID = %d, SeqCtl = %d, bitmap = 0x%X%X, scd_flow = "
4398 "%d, scd_ssn = %d\n",
4400 ba_resp->ba_seq_ctl,
4401 ba_resp->ba_bitmap1,
4402 ba_resp->ba_bitmap0,
4405 IWL_DEBUG_TX_REPLY("DAT start_idx = %d, bitmap = 0x%X%X \n",
4412 /* Update driver's record of ACK vs. not for each frame in window */
4413 iwl4965_tx_status_reply_compressed_ba(priv
, agg
, ba_resp
);
4415 /* Release all TFDs before the SSN, i.e. all TFDs in front of
4416 * block-ack window (we assume that they've been successfully
4417 * transmitted ... if not, it's too late anyway). */
4418 if (txq
->q
.read_ptr
!= (ba_resp_scd_ssn
& 0xff))
4419 iwl4965_tx_queue_reclaim(priv
, ba_resp_scd_flow
, index
);
4425 * iwl4965_tx_queue_stop_scheduler - Stop queue, but keep configuration
4427 static void iwl4965_tx_queue_stop_scheduler(struct iwl4965_priv
*priv
, u16 txq_id
)
4429 /* Simply stop the queue, but don't change any configuration;
4430 * the SCD_ACT_EN bit is the write-enable mask for the ACTIVE bit. */
4431 iwl4965_write_prph(priv
,
4432 KDR_SCD_QUEUE_STATUS_BITS(txq_id
),
4433 (0 << SCD_QUEUE_STTS_REG_POS_ACTIVE
)|
4434 (1 << SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN
));
4438 * iwl4965_tx_queue_set_q2ratid - Map unique receiver/tid combination to a queue
4440 static int iwl4965_tx_queue_set_q2ratid(struct iwl4965_priv
*priv
, u16 ra_tid
,
4447 scd_q2ratid
= ra_tid
& SCD_QUEUE_RA_TID_MAP_RATID_MSK
;
4449 tbl_dw_addr
= priv
->scd_base_addr
+
4450 SCD_TRANSLATE_TBL_OFFSET_QUEUE(txq_id
);
4452 tbl_dw
= iwl4965_read_targ_mem(priv
, tbl_dw_addr
);
4455 tbl_dw
= (scd_q2ratid
<< 16) | (tbl_dw
& 0x0000FFFF);
4457 tbl_dw
= scd_q2ratid
| (tbl_dw
& 0xFFFF0000);
4459 iwl4965_write_targ_mem(priv
, tbl_dw_addr
, tbl_dw
);
4465 * iwl4965_tx_queue_agg_enable - Set up & enable aggregation for selected queue
4467 * NOTE: txq_id must be greater than IWL_BACK_QUEUE_FIRST_ID,
4468 * i.e. it must be one of the higher queues used for aggregation
4470 static int iwl4965_tx_queue_agg_enable(struct iwl4965_priv
*priv
, int txq_id
,
4471 int tx_fifo
, int sta_id
, int tid
,
4474 unsigned long flags
;
4478 if (IWL_BACK_QUEUE_FIRST_ID
> txq_id
)
4479 IWL_WARNING("queue number too small: %d, must be > %d\n",
4480 txq_id
, IWL_BACK_QUEUE_FIRST_ID
);
4482 ra_tid
= BUILD_RAxTID(sta_id
, tid
);
4484 /* Modify device's station table to Tx this TID */
4485 iwl4965_sta_modify_enable_tid_tx(priv
, sta_id
, tid
);
4487 spin_lock_irqsave(&priv
->lock
, flags
);
4488 rc
= iwl4965_grab_nic_access(priv
);
4490 spin_unlock_irqrestore(&priv
->lock
, flags
);
4494 /* Stop this Tx queue before configuring it */
4495 iwl4965_tx_queue_stop_scheduler(priv
, txq_id
);
4497 /* Map receiver-address / traffic-ID to this queue */
4498 iwl4965_tx_queue_set_q2ratid(priv
, ra_tid
, txq_id
);
4500 /* Set this queue as a chain-building queue */
4501 iwl4965_set_bits_prph(priv
, KDR_SCD_QUEUECHAIN_SEL
, (1<<txq_id
));
4503 /* Place first TFD at index corresponding to start sequence number.
4504 * Assumes that ssn_idx is valid (!= 0xFFF) */
4505 priv
->txq
[txq_id
].q
.read_ptr
= (ssn_idx
& 0xff);
4506 priv
->txq
[txq_id
].q
.write_ptr
= (ssn_idx
& 0xff);
4507 iwl4965_set_wr_ptrs(priv
, txq_id
, ssn_idx
);
4509 /* Set up Tx window size and frame limit for this queue */
4510 iwl4965_write_targ_mem(priv
,
4511 priv
->scd_base_addr
+ SCD_CONTEXT_QUEUE_OFFSET(txq_id
),
4512 (SCD_WIN_SIZE
<< SCD_QUEUE_CTX_REG1_WIN_SIZE_POS
) &
4513 SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK
);
4515 iwl4965_write_targ_mem(priv
, priv
->scd_base_addr
+
4516 SCD_CONTEXT_QUEUE_OFFSET(txq_id
) + sizeof(u32
),
4517 (SCD_FRAME_LIMIT
<< SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS
)
4518 & SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK
);
4520 iwl4965_set_bits_prph(priv
, KDR_SCD_INTERRUPT_MASK
, (1 << txq_id
));
4522 /* Set up Status area in SRAM, map to Tx DMA/FIFO, activate the queue */
4523 iwl4965_tx_queue_set_status(priv
, &priv
->txq
[txq_id
], tx_fifo
, 1);
4525 iwl4965_release_nic_access(priv
);
4526 spin_unlock_irqrestore(&priv
->lock
, flags
);
4532 * txq_id must be greater than IWL_BACK_QUEUE_FIRST_ID
4534 static int iwl4965_tx_queue_agg_disable(struct iwl4965_priv
*priv
, u16 txq_id
,
4535 u16 ssn_idx
, u8 tx_fifo
)
4537 unsigned long flags
;
4540 if (IWL_BACK_QUEUE_FIRST_ID
> txq_id
) {
4541 IWL_WARNING("queue number too small: %d, must be > %d\n",
4542 txq_id
, IWL_BACK_QUEUE_FIRST_ID
);
4546 spin_lock_irqsave(&priv
->lock
, flags
);
4547 rc
= iwl4965_grab_nic_access(priv
);
4549 spin_unlock_irqrestore(&priv
->lock
, flags
);
4553 iwl4965_tx_queue_stop_scheduler(priv
, txq_id
);
4555 iwl4965_clear_bits_prph(priv
, KDR_SCD_QUEUECHAIN_SEL
, (1 << txq_id
));
4557 priv
->txq
[txq_id
].q
.read_ptr
= (ssn_idx
& 0xff);
4558 priv
->txq
[txq_id
].q
.write_ptr
= (ssn_idx
& 0xff);
4559 /* supposes that ssn_idx is valid (!= 0xFFF) */
4560 iwl4965_set_wr_ptrs(priv
, txq_id
, ssn_idx
);
4562 iwl4965_clear_bits_prph(priv
, KDR_SCD_INTERRUPT_MASK
, (1 << txq_id
));
4563 iwl4965_txq_ctx_deactivate(priv
, txq_id
);
4564 iwl4965_tx_queue_set_status(priv
, &priv
->txq
[txq_id
], tx_fifo
, 0);
4566 iwl4965_release_nic_access(priv
);
4567 spin_unlock_irqrestore(&priv
->lock
, flags
);
4572 #endif/* CONFIG_IWL4965_HT_AGG */
4573 #endif /* CONFIG_IWL4965_HT */
4576 * iwl4965_add_station - Initialize a station's hardware rate table
4578 * The uCode's station table contains a table of fallback rates
4579 * for automatic fallback during transmission.
4581 * NOTE: This sets up a default set of values. These will be replaced later
4582 * if the driver's iwl-4965-rs rate scaling algorithm is used, instead of
4585 * NOTE: Run REPLY_ADD_STA command to set up station table entry, before
4586 * calling this function (which runs REPLY_TX_LINK_QUALITY_CMD,
4587 * which requires station table entry to exist).
4589 void iwl4965_add_station(struct iwl4965_priv
*priv
, const u8
*addr
, int is_ap
)
4592 struct iwl4965_link_quality_cmd link_cmd
= {
4597 /* Set up the rate scaling to start at selected rate, fall back
4598 * all the way down to 1M in IEEE order, and then spin on 1M */
4600 r
= IWL_RATE_54M_INDEX
;
4601 else if (priv
->phymode
== MODE_IEEE80211A
)
4602 r
= IWL_RATE_6M_INDEX
;
4604 r
= IWL_RATE_1M_INDEX
;
4606 for (i
= 0; i
< LINK_QUAL_MAX_RETRY_NUM
; i
++) {
4608 if (r
>= IWL_FIRST_CCK_RATE
&& r
<= IWL_LAST_CCK_RATE
)
4609 rate_flags
|= RATE_MCS_CCK_MSK
;
4611 /* Use Tx antenna B only */
4612 rate_flags
|= RATE_MCS_ANT_B_MSK
;
4613 rate_flags
&= ~RATE_MCS_ANT_A_MSK
;
4615 link_cmd
.rs_table
[i
].rate_n_flags
=
4616 iwl4965_hw_set_rate_n_flags(iwl4965_rates
[r
].plcp
, rate_flags
);
4617 r
= iwl4965_get_prev_ieee_rate(r
);
4620 link_cmd
.general_params
.single_stream_ant_msk
= 2;
4621 link_cmd
.general_params
.dual_stream_ant_msk
= 3;
4622 link_cmd
.agg_params
.agg_dis_start_th
= 3;
4623 link_cmd
.agg_params
.agg_time_limit
= cpu_to_le16(4000);
4625 /* Update the rate scaling for control frame Tx to AP */
4626 link_cmd
.sta_id
= is_ap
? IWL_AP_ID
: IWL4965_BROADCAST_ID
;
4628 iwl4965_send_cmd_pdu(priv
, REPLY_TX_LINK_QUALITY_CMD
, sizeof(link_cmd
),
4632 #ifdef CONFIG_IWL4965_HT
4634 static u8
iwl4965_is_channel_extension(struct iwl4965_priv
*priv
, int phymode
,
4635 u16 channel
, u8 extension_chan_offset
)
4637 const struct iwl4965_channel_info
*ch_info
;
4639 ch_info
= iwl4965_get_channel_info(priv
, phymode
, channel
);
4640 if (!is_channel_valid(ch_info
))
4643 if (extension_chan_offset
== IWL_EXT_CHANNEL_OFFSET_AUTO
)
4646 if ((ch_info
->fat_extension_channel
== extension_chan_offset
) ||
4647 (ch_info
->fat_extension_channel
== HT_IE_EXT_CHANNEL_MAX
))
4653 static u8
iwl4965_is_fat_tx_allowed(struct iwl4965_priv
*priv
,
4654 struct ieee80211_ht_info
*sta_ht_inf
)
4656 struct iwl_ht_info
*iwl_ht_conf
= &priv
->current_ht_config
;
4658 if ((!iwl_ht_conf
->is_ht
) ||
4659 (iwl_ht_conf
->supported_chan_width
!= IWL_CHANNEL_WIDTH_40MHZ
) ||
4660 (iwl_ht_conf
->extension_chan_offset
== IWL_EXT_CHANNEL_OFFSET_AUTO
))
4664 if ((!sta_ht_inf
->ht_supported
) ||
4665 (!sta_ht_inf
->cap
& IEEE80211_HT_CAP_SUP_WIDTH
))
4669 return (iwl4965_is_channel_extension(priv
, priv
->phymode
,
4670 iwl_ht_conf
->control_channel
,
4671 iwl_ht_conf
->extension_chan_offset
));
4674 void iwl4965_set_rxon_ht(struct iwl4965_priv
*priv
, struct iwl_ht_info
*ht_info
)
4676 struct iwl4965_rxon_cmd
*rxon
= &priv
->staging_rxon
;
4679 if (!ht_info
->is_ht
)
4682 /* Set up channel bandwidth: 20 MHz only, or 20/40 mixed if fat ok */
4683 if (iwl4965_is_fat_tx_allowed(priv
, NULL
))
4684 rxon
->flags
|= RXON_FLG_CHANNEL_MODE_MIXED_MSK
;
4686 rxon
->flags
&= ~(RXON_FLG_CHANNEL_MODE_MIXED_MSK
|
4687 RXON_FLG_CHANNEL_MODE_PURE_40_MSK
);
4689 if (le16_to_cpu(rxon
->channel
) != ht_info
->control_channel
) {
4690 IWL_DEBUG_ASSOC("control diff than current %d %d\n",
4691 le16_to_cpu(rxon
->channel
),
4692 ht_info
->control_channel
);
4693 rxon
->channel
= cpu_to_le16(ht_info
->control_channel
);
4697 /* Note: control channel is opposite of extension channel */
4698 switch (ht_info
->extension_chan_offset
) {
4699 case IWL_EXT_CHANNEL_OFFSET_ABOVE
:
4700 rxon
->flags
&= ~(RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
);
4702 case IWL_EXT_CHANNEL_OFFSET_BELOW
:
4703 rxon
->flags
|= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK
;
4705 case IWL_EXT_CHANNEL_OFFSET_AUTO
:
4706 rxon
->flags
&= ~RXON_FLG_CHANNEL_MODE_MIXED_MSK
;
4709 rxon
->flags
&= ~RXON_FLG_CHANNEL_MODE_MIXED_MSK
;
4713 val
= ht_info
->ht_protection
;
4715 rxon
->flags
|= cpu_to_le32(val
<< RXON_FLG_HT_OPERATING_MODE_POS
);
4717 iwl4965_set_rxon_chain(priv
);
4719 IWL_DEBUG_ASSOC("supported HT rate 0x%X %X "
4720 "rxon flags 0x%X operation mode :0x%X "
4721 "extension channel offset 0x%x "
4722 "control chan %d\n",
4723 ht_info
->supp_mcs_set
[0], ht_info
->supp_mcs_set
[1],
4724 le32_to_cpu(rxon
->flags
), ht_info
->ht_protection
,
4725 ht_info
->extension_chan_offset
,
4726 ht_info
->control_channel
);
4730 void iwl4965_set_ht_add_station(struct iwl4965_priv
*priv
, u8 index
,
4731 struct ieee80211_ht_info
*sta_ht_inf
)
4735 if (!sta_ht_inf
|| !sta_ht_inf
->ht_supported
)
4738 sta_flags
= priv
->stations
[index
].sta
.station_flags
;
4740 if (((sta_ht_inf
->cap
& IEEE80211_HT_CAP_MIMO_PS
>> 2))
4741 == IWL_MIMO_PS_DYNAMIC
)
4742 sta_flags
|= STA_FLG_RTS_MIMO_PROT_MSK
;
4744 sta_flags
&= ~STA_FLG_RTS_MIMO_PROT_MSK
;
4746 sta_flags
|= cpu_to_le32(
4747 (u32
)sta_ht_inf
->ampdu_factor
<< STA_FLG_MAX_AGG_SIZE_POS
);
4749 sta_flags
|= cpu_to_le32(
4750 (u32
)sta_ht_inf
->ampdu_density
<< STA_FLG_AGG_MPDU_DENSITY_POS
);
4752 if (iwl4965_is_fat_tx_allowed(priv
, sta_ht_inf
))
4753 sta_flags
|= STA_FLG_FAT_EN_MSK
;
4755 sta_flags
&= (~STA_FLG_FAT_EN_MSK
);
4757 priv
->stations
[index
].sta
.station_flags
= sta_flags
;
4762 static void iwl4965_sta_modify_add_ba_tid(struct iwl4965_priv
*priv
,
4763 int sta_id
, int tid
, u16 ssn
)
4765 unsigned long flags
;
4767 spin_lock_irqsave(&priv
->sta_lock
, flags
);
4768 priv
->stations
[sta_id
].sta
.station_flags_msk
= 0;
4769 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_ADDBA_TID_MSK
;
4770 priv
->stations
[sta_id
].sta
.add_immediate_ba_tid
= (u8
)tid
;
4771 priv
->stations
[sta_id
].sta
.add_immediate_ba_ssn
= cpu_to_le16(ssn
);
4772 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
4773 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
4775 iwl4965_send_add_station(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
4778 static void iwl4965_sta_modify_del_ba_tid(struct iwl4965_priv
*priv
,
4779 int sta_id
, int tid
)
4781 unsigned long flags
;
4783 spin_lock_irqsave(&priv
->sta_lock
, flags
);
4784 priv
->stations
[sta_id
].sta
.station_flags_msk
= 0;
4785 priv
->stations
[sta_id
].sta
.sta
.modify_mask
= STA_MODIFY_DELBA_TID_MSK
;
4786 priv
->stations
[sta_id
].sta
.remove_immediate_ba_tid
= (u8
)tid
;
4787 priv
->stations
[sta_id
].sta
.mode
= STA_CONTROL_MODIFY_MSK
;
4788 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
4790 iwl4965_send_add_station(priv
, &priv
->stations
[sta_id
].sta
, CMD_ASYNC
);
4793 int iwl4965_mac_ampdu_action(struct ieee80211_hw
*hw
,
4794 enum ieee80211_ampdu_mlme_action action
,
4795 const u8
*addr
, u16 tid
, u16 ssn
)
4797 struct iwl4965_priv
*priv
= hw
->priv
;
4799 DECLARE_MAC_BUF(mac
);
4801 IWL_DEBUG_HT("A-MPDU action on da=%s tid=%d ",
4802 print_mac(mac
, addr
), tid
);
4803 sta_id
= iwl4965_hw_find_station(priv
, addr
);
4805 case IEEE80211_AMPDU_RX_START
:
4806 IWL_DEBUG_HT("start Rx\n");
4807 iwl4965_sta_modify_add_ba_tid(priv
, sta_id
, tid
, ssn
);
4809 case IEEE80211_AMPDU_RX_STOP
:
4810 IWL_DEBUG_HT("stop Rx\n");
4811 iwl4965_sta_modify_del_ba_tid(priv
, sta_id
, tid
);
4814 IWL_DEBUG_HT("unknown\n");
4821 #ifdef CONFIG_IWL4965_HT_AGG
4823 static const u16 default_tid_to_tx_fifo
[] = {
4844 * Find first available (lowest unused) Tx Queue, mark it "active".
4845 * Called only when finding queue for aggregation.
4846 * Should never return anything < 7, because they should already
4847 * be in use as EDCA AC (0-3), Command (4), HCCA (5, 6).
4849 static int iwl4965_txq_ctx_activate_free(struct iwl4965_priv
*priv
)
4853 for (txq_id
= 0; txq_id
< priv
->hw_setting
.max_txq_num
; txq_id
++)
4854 if (!test_and_set_bit(txq_id
, &priv
->txq_ctx_active_msk
))
4859 int iwl4965_mac_ht_tx_agg_start(struct ieee80211_hw
*hw
, u8
*da
, u16 tid
,
4863 struct iwl4965_priv
*priv
= hw
->priv
;
4868 unsigned long flags
;
4869 struct iwl4965_tid_data
*tid_data
;
4870 DECLARE_MAC_BUF(mac
);
4872 /* Determine Tx DMA/FIFO channel for this Traffic ID */
4873 if (likely(tid
< ARRAY_SIZE(default_tid_to_tx_fifo
)))
4874 tx_fifo
= default_tid_to_tx_fifo
[tid
];
4878 IWL_WARNING("iwl-AGG iwl4965_mac_ht_tx_agg_start on da=%s"
4879 " tid=%d\n", print_mac(mac
, da
), tid
);
4881 /* Get index into station table */
4882 sta_id
= iwl4965_hw_find_station(priv
, da
);
4883 if (sta_id
== IWL_INVALID_STATION
)
4886 /* Find available Tx queue for aggregation */
4887 txq_id
= iwl4965_txq_ctx_activate_free(priv
);
4891 spin_lock_irqsave(&priv
->sta_lock
, flags
);
4892 tid_data
= &priv
->stations
[sta_id
].tid
[tid
];
4894 /* Get starting sequence number for 1st frame in block ack window.
4895 * We'll use least signif byte as 1st frame's index into Tx queue. */
4896 ssn
= SEQ_TO_SN(tid_data
->seq_number
);
4897 tid_data
->agg
.txq_id
= txq_id
;
4898 spin_unlock_irqrestore(&priv
->sta_lock
, flags
);
4900 *start_seq_num
= ssn
;
4902 /* Update driver's link quality manager */
4903 iwl4965_ba_status(priv
, tid
, BA_STATUS_ACTIVE
);
4905 /* Set up and enable aggregation for selected Tx queue and FIFO */
4906 return iwl4965_tx_queue_agg_enable(priv
, txq_id
, tx_fifo
,
4911 int iwl4965_mac_ht_tx_agg_stop(struct ieee80211_hw
*hw
, u8
*da
, u16 tid
,
4915 struct iwl4965_priv
*priv
= hw
->priv
;
4916 int tx_fifo_id
, txq_id
, sta_id
, ssn
= -1;
4917 struct iwl4965_tid_data
*tid_data
;
4919 DECLARE_MAC_BUF(mac
);
4922 IWL_ERROR("%s: da = NULL\n", __func__
);
4926 if (likely(tid
< ARRAY_SIZE(default_tid_to_tx_fifo
)))
4927 tx_fifo_id
= default_tid_to_tx_fifo
[tid
];
4931 sta_id
= iwl4965_hw_find_station(priv
, da
);
4933 if (sta_id
== IWL_INVALID_STATION
)
4936 tid_data
= &priv
->stations
[sta_id
].tid
[tid
];
4937 ssn
= (tid_data
->seq_number
& IEEE80211_SCTL_SEQ
) >> 4;
4938 txq_id
= tid_data
->agg
.txq_id
;
4940 rc
= iwl4965_tx_queue_agg_disable(priv
, txq_id
, ssn
, tx_fifo_id
);
4941 /* FIXME: need more safe way to handle error condition */
4945 iwl4965_ba_status(priv
, tid
, BA_STATUS_INITIATOR_DELBA
);
4946 IWL_DEBUG_INFO("iwl4965_mac_ht_tx_agg_stop on da=%s tid=%d\n",
4947 print_mac(mac
, da
), tid
);
4953 #endif /* CONFIG_IWL4965_HT_AGG */
4954 #endif /* CONFIG_IWL4965_HT */
4956 /* Set up 4965-specific Rx frame reply handlers */
4957 void iwl4965_hw_rx_handler_setup(struct iwl4965_priv
*priv
)
4959 /* Legacy Rx frames */
4960 priv
->rx_handlers
[REPLY_4965_RX
] = iwl4965_rx_reply_rx
;
4962 /* High-throughput (HT) Rx frames */
4963 priv
->rx_handlers
[REPLY_RX_PHY_CMD
] = iwl4965_rx_reply_rx_phy
;
4964 priv
->rx_handlers
[REPLY_RX_MPDU_CMD
] = iwl4965_rx_reply_rx
;
4966 priv
->rx_handlers
[MISSED_BEACONS_NOTIFICATION
] =
4967 iwl4965_rx_missed_beacon_notif
;
4969 #ifdef CONFIG_IWL4965_HT
4970 #ifdef CONFIG_IWL4965_HT_AGG
4971 priv
->rx_handlers
[REPLY_COMPRESSED_BA
] = iwl4965_rx_reply_compressed_ba
;
4972 #endif /* CONFIG_IWL4965_HT_AGG */
4973 #endif /* CONFIG_IWL4965_HT */
4976 void iwl4965_hw_setup_deferred_work(struct iwl4965_priv
*priv
)
4978 INIT_WORK(&priv
->txpower_work
, iwl4965_bg_txpower_work
);
4979 INIT_WORK(&priv
->statistics_work
, iwl4965_bg_statistics_work
);
4980 #ifdef CONFIG_IWL4965_SENSITIVITY
4981 INIT_WORK(&priv
->sensitivity_work
, iwl4965_bg_sensitivity_work
);
4983 #ifdef CONFIG_IWL4965_HT
4984 #ifdef CONFIG_IWL4965_HT_AGG
4985 INIT_WORK(&priv
->agg_work
, iwl4965_bg_agg_work
);
4986 #endif /* CONFIG_IWL4965_HT_AGG */
4987 #endif /* CONFIG_IWL4965_HT */
4988 init_timer(&priv
->statistics_periodic
);
4989 priv
->statistics_periodic
.data
= (unsigned long)priv
;
4990 priv
->statistics_periodic
.function
= iwl4965_bg_statistics_periodic
;
4993 void iwl4965_hw_cancel_deferred_work(struct iwl4965_priv
*priv
)
4995 del_timer_sync(&priv
->statistics_periodic
);
4997 cancel_delayed_work(&priv
->init_alive_start
);
5000 struct pci_device_id iwl4965_hw_card_ids
[] = {
5001 {PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x4229)},
5002 {PCI_DEVICE(PCI_VENDOR_ID_INTEL
, 0x4230)},
5007 * The device's EEPROM semaphore prevents conflicts between driver and uCode
5008 * when accessing the EEPROM; each access is a series of pulses to/from the
5009 * EEPROM chip, not a single event, so even reads could conflict if they
5010 * weren't arbitrated by the semaphore.
5012 int iwl4965_eeprom_acquire_semaphore(struct iwl4965_priv
*priv
)
5017 for (count
= 0; count
< EEPROM_SEM_RETRY_LIMIT
; count
++) {
5018 /* Request semaphore */
5019 iwl4965_set_bit(priv
, CSR_HW_IF_CONFIG_REG
,
5020 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM
);
5022 /* See if we got it */
5023 rc
= iwl4965_poll_bit(priv
, CSR_HW_IF_CONFIG_REG
,
5024 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM
,
5025 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM
,
5026 EEPROM_SEM_TIMEOUT
);
5028 IWL_DEBUG_IO("Acquired semaphore after %d tries.\n",
5037 inline void iwl4965_eeprom_release_semaphore(struct iwl4965_priv
*priv
)
5039 iwl4965_clear_bit(priv
, CSR_HW_IF_CONFIG_REG
,
5040 CSR_HW_IF_CONFIG_REG_BIT_EEPROM_OWN_SEM
);
5044 MODULE_DEVICE_TABLE(pci
, iwl4965_hw_card_ids
);