2008-05-05 10:22:43 +08:00
|
|
|
/******************************************************************************
|
|
|
|
*
|
2009-01-09 02:20:02 +08:00
|
|
|
* Copyright(c) 2003 - 2009 Intel Corporation. All rights reserved.
|
2008-05-05 10:22:43 +08:00
|
|
|
*
|
|
|
|
* Portions of this file are derived from the ipw3945 project, as well
|
|
|
|
* as portions of the ieee80211 subsystem header files.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of version 2 of the GNU General Public License as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along with
|
|
|
|
* this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
|
|
|
|
*
|
|
|
|
* The full GNU General Public License is included in this distribution in the
|
|
|
|
* file called LICENSE.
|
|
|
|
*
|
|
|
|
* Contact Information:
|
2008-12-10 03:28:58 +08:00
|
|
|
* Intel Linux Wireless <ilw@linux.intel.com>
|
2008-05-05 10:22:43 +08:00
|
|
|
* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
|
|
|
|
*
|
|
|
|
*****************************************************************************/
|
|
|
|
|
2008-05-15 13:54:07 +08:00
|
|
|
#include <linux/etherdevice.h>
|
2009-10-07 21:09:06 +08:00
|
|
|
#include <linux/sched.h>
|
2008-05-05 10:22:43 +08:00
|
|
|
#include <net/mac80211.h>
|
|
|
|
#include "iwl-eeprom.h"
|
|
|
|
#include "iwl-dev.h"
|
|
|
|
#include "iwl-core.h"
|
|
|
|
#include "iwl-sta.h"
|
|
|
|
#include "iwl-io.h"
|
|
|
|
#include "iwl-helpers.h"
|
|
|
|
|
2008-05-29 16:35:16 +08:00
|
|
|
static const u16 default_tid_to_tx_fifo[] = {
|
|
|
|
IWL_TX_FIFO_AC1,
|
|
|
|
IWL_TX_FIFO_AC0,
|
|
|
|
IWL_TX_FIFO_AC0,
|
|
|
|
IWL_TX_FIFO_AC1,
|
|
|
|
IWL_TX_FIFO_AC2,
|
|
|
|
IWL_TX_FIFO_AC2,
|
|
|
|
IWL_TX_FIFO_AC3,
|
|
|
|
IWL_TX_FIFO_AC3,
|
|
|
|
IWL_TX_FIFO_NONE,
|
|
|
|
IWL_TX_FIFO_NONE,
|
|
|
|
IWL_TX_FIFO_NONE,
|
|
|
|
IWL_TX_FIFO_NONE,
|
|
|
|
IWL_TX_FIFO_NONE,
|
|
|
|
IWL_TX_FIFO_NONE,
|
|
|
|
IWL_TX_FIFO_NONE,
|
|
|
|
IWL_TX_FIFO_NONE,
|
|
|
|
IWL_TX_FIFO_AC3
|
|
|
|
};
|
|
|
|
|
2008-11-08 01:58:40 +08:00
|
|
|
static inline int iwl_alloc_dma_ptr(struct iwl_priv *priv,
|
|
|
|
struct iwl_dma_ptr *ptr, size_t size)
|
|
|
|
{
|
|
|
|
ptr->addr = pci_alloc_consistent(priv->pci_dev, size, &ptr->dma);
|
|
|
|
if (!ptr->addr)
|
|
|
|
return -ENOMEM;
|
|
|
|
ptr->size = size;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void iwl_free_dma_ptr(struct iwl_priv *priv,
|
|
|
|
struct iwl_dma_ptr *ptr)
|
|
|
|
{
|
|
|
|
if (unlikely(!ptr->addr))
|
|
|
|
return;
|
|
|
|
|
|
|
|
pci_free_consistent(priv->pci_dev, ptr->size, ptr->addr, ptr->dma);
|
|
|
|
memset(ptr, 0, sizeof(*ptr));
|
|
|
|
}
|
|
|
|
|
2008-05-15 13:54:07 +08:00
|
|
|
/**
|
|
|
|
* iwl_txq_update_write_ptr - Send new write index to hardware
|
|
|
|
*/
|
|
|
|
int iwl_txq_update_write_ptr(struct iwl_priv *priv, struct iwl_tx_queue *txq)
|
|
|
|
{
|
|
|
|
u32 reg = 0;
|
|
|
|
int ret = 0;
|
|
|
|
int txq_id = txq->q.id;
|
|
|
|
|
|
|
|
if (txq->need_update == 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
/* if we're trying to save power */
|
|
|
|
if (test_bit(STATUS_POWER_PMI, &priv->status)) {
|
|
|
|
/* wake up nic if it's powered down ...
|
|
|
|
* uCode will wake up, and interrupt us again, so next
|
|
|
|
* time we'll skip this part. */
|
|
|
|
reg = iwl_read32(priv, CSR_UCODE_DRV_GP1);
|
|
|
|
|
|
|
|
if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
|
2009-11-07 06:53:03 +08:00
|
|
|
IWL_DEBUG_INFO(priv, "Tx queue %d requesting wakeup, GP1 = 0x%x\n",
|
|
|
|
txq_id, reg);
|
2008-05-15 13:54:07 +08:00
|
|
|
iwl_set_bit(priv, CSR_GP_CNTRL,
|
|
|
|
CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
iwl_write_direct32(priv, HBUS_TARG_WRPTR,
|
|
|
|
txq->q.write_ptr | (txq_id << 8));
|
|
|
|
|
|
|
|
/* else not in power-save mode, uCode will never sleep when we're
|
|
|
|
* trying to tx (during RFKILL, we're not trying to tx). */
|
|
|
|
} else
|
|
|
|
iwl_write32(priv, HBUS_TARG_WRPTR,
|
|
|
|
txq->q.write_ptr | (txq_id << 8));
|
|
|
|
|
|
|
|
txq->need_update = 0;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_txq_update_write_ptr);
|
|
|
|
|
|
|
|
|
2008-05-05 10:22:43 +08:00
|
|
|
/**
|
|
|
|
* iwl_tx_queue_free - Deallocate DMA queue.
|
|
|
|
* @txq: Transmit queue to deallocate.
|
|
|
|
*
|
|
|
|
* Empty queue by removing and destroying all BD's.
|
|
|
|
* Free all buffers.
|
|
|
|
* 0-fill, but do not free "txq" descriptor structure.
|
|
|
|
*/
|
2009-01-24 05:45:14 +08:00
|
|
|
void iwl_tx_queue_free(struct iwl_priv *priv, int txq_id)
|
2008-05-05 10:22:43 +08:00
|
|
|
{
|
2008-08-04 16:00:40 +08:00
|
|
|
struct iwl_tx_queue *txq = &priv->txq[txq_id];
|
2008-05-15 13:53:57 +08:00
|
|
|
struct iwl_queue *q = &txq->q;
|
2008-05-05 10:22:43 +08:00
|
|
|
struct pci_dev *dev = priv->pci_dev;
|
2009-10-24 04:42:31 +08:00
|
|
|
int i;
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
if (q->n_bd == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* first, empty all BD's */
|
|
|
|
for (; q->write_ptr != q->read_ptr;
|
|
|
|
q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd))
|
2009-01-20 07:30:26 +08:00
|
|
|
priv->cfg->ops->lib->txq_free_tfd(priv, txq);
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
/* De-alloc array of command/tx buffers */
|
2008-10-15 03:32:44 +08:00
|
|
|
for (i = 0; i < TFD_TX_CMD_SLOTS; i++)
|
2008-08-04 16:00:40 +08:00
|
|
|
kfree(txq->cmd[i]);
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
/* De-alloc circular buffer of TFDs */
|
|
|
|
if (txq->q.n_bd)
|
2009-01-24 05:45:14 +08:00
|
|
|
pci_free_consistent(dev, priv->hw_params.tfd_size *
|
2008-10-15 03:32:48 +08:00
|
|
|
txq->q.n_bd, txq->tfds, txq->q.dma_addr);
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
/* De-alloc array of per-TFD driver data */
|
|
|
|
kfree(txq->txb);
|
|
|
|
txq->txb = NULL;
|
|
|
|
|
2009-07-25 02:13:05 +08:00
|
|
|
/* deallocate arrays */
|
|
|
|
kfree(txq->cmd);
|
|
|
|
kfree(txq->meta);
|
|
|
|
txq->cmd = NULL;
|
|
|
|
txq->meta = NULL;
|
|
|
|
|
2008-05-05 10:22:43 +08:00
|
|
|
/* 0-fill queue descriptor structure */
|
|
|
|
memset(txq, 0, sizeof(*txq));
|
|
|
|
}
|
2009-01-24 05:45:14 +08:00
|
|
|
EXPORT_SYMBOL(iwl_tx_queue_free);
|
2008-10-15 03:32:44 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_cmd_queue_free - Deallocate DMA queue.
|
|
|
|
* @txq: Transmit queue to deallocate.
|
|
|
|
*
|
|
|
|
* Empty queue by removing and destroying all BD's.
|
|
|
|
* Free all buffers.
|
|
|
|
* 0-fill, but do not free "txq" descriptor structure.
|
|
|
|
*/
|
2009-03-18 12:51:49 +08:00
|
|
|
void iwl_cmd_queue_free(struct iwl_priv *priv)
|
2008-10-15 03:32:44 +08:00
|
|
|
{
|
|
|
|
struct iwl_tx_queue *txq = &priv->txq[IWL_CMD_QUEUE_NUM];
|
|
|
|
struct iwl_queue *q = &txq->q;
|
|
|
|
struct pci_dev *dev = priv->pci_dev;
|
2009-10-24 04:42:31 +08:00
|
|
|
int i;
|
2008-10-15 03:32:44 +08:00
|
|
|
|
|
|
|
if (q->n_bd == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* De-alloc array of command/tx buffers */
|
|
|
|
for (i = 0; i <= TFD_CMD_SLOTS; i++)
|
|
|
|
kfree(txq->cmd[i]);
|
|
|
|
|
|
|
|
/* De-alloc circular buffer of TFDs */
|
|
|
|
if (txq->q.n_bd)
|
2009-03-18 12:51:49 +08:00
|
|
|
pci_free_consistent(dev, priv->hw_params.tfd_size *
|
2008-10-15 03:32:48 +08:00
|
|
|
txq->q.n_bd, txq->tfds, txq->q.dma_addr);
|
2008-10-15 03:32:44 +08:00
|
|
|
|
2009-09-26 05:24:22 +08:00
|
|
|
/* deallocate arrays */
|
|
|
|
kfree(txq->cmd);
|
|
|
|
kfree(txq->meta);
|
|
|
|
txq->cmd = NULL;
|
|
|
|
txq->meta = NULL;
|
|
|
|
|
2008-10-15 03:32:44 +08:00
|
|
|
/* 0-fill queue descriptor structure */
|
|
|
|
memset(txq, 0, sizeof(*txq));
|
|
|
|
}
|
2009-03-18 12:51:49 +08:00
|
|
|
EXPORT_SYMBOL(iwl_cmd_queue_free);
|
|
|
|
|
2008-05-15 13:54:07 +08:00
|
|
|
/*************** DMA-QUEUE-GENERAL-FUNCTIONS *****
|
|
|
|
* DMA services
|
|
|
|
*
|
|
|
|
* Theory of operation
|
|
|
|
*
|
|
|
|
* A Tx or Rx queue resides in host DRAM, and is comprised of a circular buffer
|
|
|
|
* of buffer descriptors, each of which points to one or more data buffers for
|
|
|
|
* the device to read from or fill. Driver and device exchange status of each
|
|
|
|
* queue via "read" and "write" pointers. Driver keeps minimum of 2 empty
|
|
|
|
* entries in each circular buffer, to protect against confusing empty and full
|
|
|
|
* queue states.
|
|
|
|
*
|
|
|
|
* The device reads or writes the data in the queues via the device's several
|
|
|
|
* DMA/FIFO channels. Each queue is mapped to a single DMA channel.
|
|
|
|
*
|
|
|
|
* For Tx queue, there are low mark and high mark limits. If, after queuing
|
|
|
|
* the packet for Tx, free space become < low mark, Tx queue stopped. When
|
|
|
|
* reclaiming packets (on 'tx done IRQ), if free space become > high mark,
|
|
|
|
* Tx queue resumed.
|
|
|
|
*
|
|
|
|
* See more detailed info in iwl-4965-hw.h.
|
|
|
|
***************************************************/
|
|
|
|
|
|
|
|
int iwl_queue_space(const struct iwl_queue *q)
|
|
|
|
{
|
|
|
|
int s = q->read_ptr - q->write_ptr;
|
|
|
|
|
|
|
|
if (q->read_ptr > q->write_ptr)
|
|
|
|
s -= q->n_bd;
|
|
|
|
|
|
|
|
if (s <= 0)
|
|
|
|
s += q->n_window;
|
|
|
|
/* keep some reserve to not confuse empty and full situations */
|
|
|
|
s -= 2;
|
|
|
|
if (s < 0)
|
|
|
|
s = 0;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_queue_space);
|
|
|
|
|
|
|
|
|
2008-05-05 10:22:43 +08:00
|
|
|
/**
|
|
|
|
* iwl_queue_init - Initialize queue's high/low-water and read/write indexes
|
|
|
|
*/
|
2008-05-15 13:53:57 +08:00
|
|
|
static int iwl_queue_init(struct iwl_priv *priv, struct iwl_queue *q,
|
2008-05-05 10:22:43 +08:00
|
|
|
int count, int slots_num, u32 id)
|
|
|
|
{
|
|
|
|
q->n_bd = count;
|
|
|
|
q->n_window = slots_num;
|
|
|
|
q->id = id;
|
|
|
|
|
|
|
|
/* count must be power-of-two size, otherwise iwl_queue_inc_wrap
|
|
|
|
* and iwl_queue_dec_wrap are broken. */
|
|
|
|
BUG_ON(!is_power_of_2(count));
|
|
|
|
|
|
|
|
/* slots_num must be power-of-two size, otherwise
|
|
|
|
* get_cmd_index is broken. */
|
|
|
|
BUG_ON(!is_power_of_2(slots_num));
|
|
|
|
|
|
|
|
q->low_mark = q->n_window / 4;
|
|
|
|
if (q->low_mark < 4)
|
|
|
|
q->low_mark = 4;
|
|
|
|
|
|
|
|
q->high_mark = q->n_window / 8;
|
|
|
|
if (q->high_mark < 2)
|
|
|
|
q->high_mark = 2;
|
|
|
|
|
|
|
|
q->write_ptr = q->read_ptr = 0;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
|
|
|
|
*/
|
|
|
|
static int iwl_tx_queue_alloc(struct iwl_priv *priv,
|
2008-05-05 10:22:50 +08:00
|
|
|
struct iwl_tx_queue *txq, u32 id)
|
2008-05-05 10:22:43 +08:00
|
|
|
{
|
|
|
|
struct pci_dev *dev = priv->pci_dev;
|
2009-01-24 05:45:23 +08:00
|
|
|
size_t tfd_sz = priv->hw_params.tfd_size * TFD_QUEUE_SIZE_MAX;
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
/* Driver private data, only for Tx (not command) queues,
|
|
|
|
* not shared with device. */
|
|
|
|
if (id != IWL_CMD_QUEUE_NUM) {
|
|
|
|
txq->txb = kmalloc(sizeof(txq->txb[0]) *
|
|
|
|
TFD_QUEUE_SIZE_MAX, GFP_KERNEL);
|
|
|
|
if (!txq->txb) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "kmalloc for auxiliary BD "
|
2008-05-05 10:22:43 +08:00
|
|
|
"structures failed\n");
|
|
|
|
goto error;
|
|
|
|
}
|
2009-01-24 05:45:23 +08:00
|
|
|
} else {
|
2008-05-05 10:22:43 +08:00
|
|
|
txq->txb = NULL;
|
2009-01-24 05:45:23 +08:00
|
|
|
}
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
/* Circular buffer of transmit frame descriptors (TFDs),
|
|
|
|
* shared with device */
|
2009-01-24 05:45:23 +08:00
|
|
|
txq->tfds = pci_alloc_consistent(dev, tfd_sz, &txq->q.dma_addr);
|
2008-05-05 10:22:43 +08:00
|
|
|
|
2008-10-15 03:32:48 +08:00
|
|
|
if (!txq->tfds) {
|
2009-01-24 05:45:23 +08:00
|
|
|
IWL_ERR(priv, "pci_alloc_consistent(%zd) failed\n", tfd_sz);
|
2008-05-05 10:22:43 +08:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
txq->q.id = id;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error:
|
|
|
|
kfree(txq->txb);
|
|
|
|
txq->txb = NULL;
|
|
|
|
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_tx_queue_init - Allocate and initialize one tx/cmd queue
|
|
|
|
*/
|
2009-01-24 05:45:14 +08:00
|
|
|
int iwl_tx_queue_init(struct iwl_priv *priv, struct iwl_tx_queue *txq,
|
|
|
|
int slots_num, u32 txq_id)
|
2008-05-05 10:22:43 +08:00
|
|
|
{
|
2008-08-04 16:00:40 +08:00
|
|
|
int i, len;
|
2008-09-03 11:18:48 +08:00
|
|
|
int ret;
|
2009-07-25 02:13:05 +08:00
|
|
|
int actual_slots = slots_num;
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Alloc buffer array for commands (Tx or other types of commands).
|
|
|
|
* For the command queue (#4), allocate command space + one big
|
|
|
|
* command for scan, since scan command is very huge; the system will
|
|
|
|
* not have two scans at the same time, so only one is needed.
|
|
|
|
* For normal Tx queues (all other queues), no super-size command
|
|
|
|
* space is needed.
|
|
|
|
*/
|
2009-07-25 02:13:05 +08:00
|
|
|
if (txq_id == IWL_CMD_QUEUE_NUM)
|
|
|
|
actual_slots++;
|
|
|
|
|
|
|
|
txq->meta = kzalloc(sizeof(struct iwl_cmd_meta) * actual_slots,
|
|
|
|
GFP_KERNEL);
|
|
|
|
txq->cmd = kzalloc(sizeof(struct iwl_device_cmd *) * actual_slots,
|
|
|
|
GFP_KERNEL);
|
|
|
|
|
|
|
|
if (!txq->meta || !txq->cmd)
|
|
|
|
goto out_free_arrays;
|
|
|
|
|
|
|
|
len = sizeof(struct iwl_device_cmd);
|
|
|
|
for (i = 0; i < actual_slots; i++) {
|
|
|
|
/* only happens for cmd queue */
|
|
|
|
if (i == slots_num)
|
|
|
|
len += IWL_MAX_SCAN_SIZE;
|
2008-08-04 16:00:40 +08:00
|
|
|
|
2008-09-03 03:07:18 +08:00
|
|
|
txq->cmd[i] = kmalloc(len, GFP_KERNEL);
|
2008-08-04 16:00:40 +08:00
|
|
|
if (!txq->cmd[i])
|
2008-09-03 11:18:48 +08:00
|
|
|
goto err;
|
2008-08-04 16:00:40 +08:00
|
|
|
}
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
/* Alloc driver data array and TFD circular buffer */
|
2008-09-03 11:18:48 +08:00
|
|
|
ret = iwl_tx_queue_alloc(priv, txq, txq_id);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
txq->need_update = 0;
|
|
|
|
|
2009-11-07 06:52:51 +08:00
|
|
|
/*
|
|
|
|
* Aggregation TX queues will get their ID when aggregation begins;
|
|
|
|
* they overwrite the setting done here. The command FIFO doesn't
|
|
|
|
* need an swq_id so don't set one to catch errors, all others can
|
|
|
|
* be set up to the identity mapping.
|
|
|
|
*/
|
|
|
|
if (txq_id != IWL_CMD_QUEUE_NUM)
|
2009-06-20 04:52:43 +08:00
|
|
|
txq->swq_id = txq_id;
|
|
|
|
|
2008-05-05 10:22:43 +08:00
|
|
|
/* TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
|
|
|
|
* iwl_queue_inc_wrap and iwl_queue_dec_wrap are broken. */
|
|
|
|
BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
|
|
|
|
|
|
|
|
/* Initialize queue's high/low-water marks, and head/tail indexes */
|
|
|
|
iwl_queue_init(priv, &txq->q, TFD_QUEUE_SIZE_MAX, slots_num, txq_id);
|
|
|
|
|
|
|
|
/* Tell device where to find queue */
|
2009-01-24 05:45:14 +08:00
|
|
|
priv->cfg->ops->lib->txq_init(priv, txq);
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
return 0;
|
2008-09-03 11:18:48 +08:00
|
|
|
err:
|
2009-07-25 02:13:05 +08:00
|
|
|
for (i = 0; i < actual_slots; i++)
|
2008-09-03 11:18:48 +08:00
|
|
|
kfree(txq->cmd[i]);
|
2009-07-25 02:13:05 +08:00
|
|
|
out_free_arrays:
|
|
|
|
kfree(txq->meta);
|
|
|
|
kfree(txq->cmd);
|
2008-09-03 11:18:48 +08:00
|
|
|
|
|
|
|
return -ENOMEM;
|
2008-05-05 10:22:43 +08:00
|
|
|
}
|
2009-01-24 05:45:14 +08:00
|
|
|
EXPORT_SYMBOL(iwl_tx_queue_init);
|
|
|
|
|
2008-05-29 16:35:00 +08:00
|
|
|
/**
|
|
|
|
* iwl_hw_txq_ctx_free - Free TXQ Context
|
|
|
|
*
|
|
|
|
* Destroy all TX DMA queues and structures
|
|
|
|
*/
|
|
|
|
void iwl_hw_txq_ctx_free(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
int txq_id;
|
|
|
|
|
|
|
|
/* Tx queues */
|
2009-12-15 07:56:54 +08:00
|
|
|
if (priv->txq) {
|
2009-10-10 04:20:28 +08:00
|
|
|
for (txq_id = 0; txq_id < priv->hw_params.max_txq_num;
|
|
|
|
txq_id++)
|
|
|
|
if (txq_id == IWL_CMD_QUEUE_NUM)
|
|
|
|
iwl_cmd_queue_free(priv);
|
|
|
|
else
|
|
|
|
iwl_tx_queue_free(priv, txq_id);
|
2009-12-15 07:56:54 +08:00
|
|
|
}
|
2008-11-08 01:58:40 +08:00
|
|
|
iwl_free_dma_ptr(priv, &priv->kw);
|
|
|
|
|
|
|
|
iwl_free_dma_ptr(priv, &priv->scd_bc_tbls);
|
2009-10-10 04:20:28 +08:00
|
|
|
|
|
|
|
/* free tx queue structure */
|
|
|
|
iwl_free_txq_mem(priv);
|
2008-05-29 16:35:00 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_hw_txq_ctx_free);
|
|
|
|
|
2008-05-05 10:22:43 +08:00
|
|
|
/**
|
|
|
|
* iwl_txq_ctx_reset - Reset TX queue context
|
2008-10-24 14:48:56 +08:00
|
|
|
* Destroys all DMA structures and initialize them again
|
2008-05-05 10:22:43 +08:00
|
|
|
*
|
|
|
|
* @param priv
|
|
|
|
* @return error code
|
|
|
|
*/
|
|
|
|
int iwl_txq_ctx_reset(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
int txq_id, slots_num;
|
2008-05-29 16:35:00 +08:00
|
|
|
unsigned long flags;
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
/* Free all tx/cmd queues and keep-warm buffer */
|
|
|
|
iwl_hw_txq_ctx_free(priv);
|
|
|
|
|
2008-11-08 01:58:40 +08:00
|
|
|
ret = iwl_alloc_dma_ptr(priv, &priv->scd_bc_tbls,
|
|
|
|
priv->hw_params.scd_bc_tbls_size);
|
|
|
|
if (ret) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "Scheduler BC Table allocation failed\n");
|
2008-11-08 01:58:40 +08:00
|
|
|
goto error_bc_tbls;
|
|
|
|
}
|
2008-05-05 10:22:43 +08:00
|
|
|
/* Alloc keep-warm buffer */
|
2008-11-08 01:58:40 +08:00
|
|
|
ret = iwl_alloc_dma_ptr(priv, &priv->kw, IWL_KW_SIZE);
|
2008-05-05 10:22:43 +08:00
|
|
|
if (ret) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "Keep Warm allocation failed\n");
|
2008-05-05 10:22:43 +08:00
|
|
|
goto error_kw;
|
|
|
|
}
|
2009-10-10 04:20:28 +08:00
|
|
|
|
|
|
|
/* allocate tx queue structure */
|
|
|
|
ret = iwl_alloc_txq_mem(priv);
|
|
|
|
if (ret)
|
|
|
|
goto error;
|
|
|
|
|
2008-05-29 16:35:00 +08:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-05-05 10:22:43 +08:00
|
|
|
|
|
|
|
/* Turn off all Tx DMA fifos */
|
2008-05-29 16:35:00 +08:00
|
|
|
priv->cfg->ops->lib->txq_set_sched(priv, 0);
|
|
|
|
|
2008-11-08 01:58:40 +08:00
|
|
|
/* Tell NIC where to find the "keep warm" buffer */
|
|
|
|
iwl_write_direct32(priv, FH_KW_MEM_ADDR_REG, priv->kw.dma >> 4);
|
|
|
|
|
2008-05-29 16:35:00 +08:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
/* Alloc and init all Tx queues, including the command queue (#4) */
|
2008-05-05 10:22:43 +08:00
|
|
|
for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++) {
|
|
|
|
slots_num = (txq_id == IWL_CMD_QUEUE_NUM) ?
|
|
|
|
TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
|
|
|
|
ret = iwl_tx_queue_init(priv, &priv->txq[txq_id], slots_num,
|
|
|
|
txq_id);
|
|
|
|
if (ret) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "Tx %d queue init failed\n", txq_id);
|
2008-05-05 10:22:43 +08:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
error:
|
|
|
|
iwl_hw_txq_ctx_free(priv);
|
2008-11-08 01:58:40 +08:00
|
|
|
iwl_free_dma_ptr(priv, &priv->kw);
|
2008-05-05 10:22:43 +08:00
|
|
|
error_kw:
|
2008-11-08 01:58:40 +08:00
|
|
|
iwl_free_dma_ptr(priv, &priv->scd_bc_tbls);
|
|
|
|
error_bc_tbls:
|
2008-05-05 10:22:43 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2008-09-03 11:26:56 +08:00
|
|
|
|
2008-05-29 16:35:00 +08:00
|
|
|
/**
|
|
|
|
* iwl_txq_ctx_stop - Stop all Tx DMA channels, free Tx queue memory
|
|
|
|
*/
|
|
|
|
void iwl_txq_ctx_stop(struct iwl_priv *priv)
|
|
|
|
{
|
2008-12-03 04:14:04 +08:00
|
|
|
int ch;
|
2008-05-29 16:35:00 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
/* Turn off all Tx DMA fifos */
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
|
|
|
priv->cfg->ops->lib->txq_set_sched(priv, 0);
|
|
|
|
|
|
|
|
/* Stop each Tx DMA channel, and wait for it to be idle */
|
2008-12-03 04:14:04 +08:00
|
|
|
for (ch = 0; ch < priv->hw_params.dma_chnl_num; ch++) {
|
|
|
|
iwl_write_direct32(priv, FH_TCSR_CHNL_TX_CONFIG_REG(ch), 0x0);
|
2008-05-29 16:35:00 +08:00
|
|
|
iwl_poll_direct_bit(priv, FH_TSSR_TX_STATUS_REG,
|
2008-12-03 04:14:04 +08:00
|
|
|
FH_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch),
|
2008-12-05 23:58:38 +08:00
|
|
|
1000);
|
2008-05-29 16:35:00 +08:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
/* Deallocate memory for all Tx queues */
|
|
|
|
iwl_hw_txq_ctx_free(priv);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_txq_ctx_stop);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* handle build REPLY_TX command notification.
|
|
|
|
*/
|
|
|
|
static void iwl_tx_cmd_build_basic(struct iwl_priv *priv,
|
|
|
|
struct iwl_tx_cmd *tx_cmd,
|
2008-05-15 18:55:29 +08:00
|
|
|
struct ieee80211_tx_info *info,
|
2008-05-15 13:54:07 +08:00
|
|
|
struct ieee80211_hdr *hdr,
|
2008-12-19 00:04:51 +08:00
|
|
|
u8 std_id)
|
2008-05-15 13:54:07 +08:00
|
|
|
{
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
__le16 fc = hdr->frame_control;
|
2008-05-15 13:54:07 +08:00
|
|
|
__le32 tx_flags = tx_cmd->tx_flags;
|
|
|
|
|
|
|
|
tx_cmd->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
|
2008-05-15 18:55:29 +08:00
|
|
|
if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
|
2008-05-15 13:54:07 +08:00
|
|
|
tx_flags |= TX_CMD_FLG_ACK_MSK;
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
if (ieee80211_is_mgmt(fc))
|
2008-05-15 13:54:07 +08:00
|
|
|
tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
if (ieee80211_is_probe_resp(fc) &&
|
2008-05-15 13:54:07 +08:00
|
|
|
!(le16_to_cpu(hdr->seq_ctrl) & 0xf))
|
|
|
|
tx_flags |= TX_CMD_FLG_TSF_MSK;
|
|
|
|
} else {
|
|
|
|
tx_flags &= (~TX_CMD_FLG_ACK_MSK);
|
|
|
|
tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
|
|
|
|
}
|
|
|
|
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
if (ieee80211_is_back_req(fc))
|
2008-05-15 13:54:07 +08:00
|
|
|
tx_flags |= TX_CMD_FLG_ACK_MSK | TX_CMD_FLG_IMM_BA_RSP_MASK;
|
|
|
|
|
|
|
|
|
|
|
|
tx_cmd->sta_id = std_id;
|
2008-06-12 05:21:56 +08:00
|
|
|
if (ieee80211_has_morefrags(fc))
|
2008-05-15 13:54:07 +08:00
|
|
|
tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;
|
|
|
|
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
if (ieee80211_is_data_qos(fc)) {
|
|
|
|
u8 *qc = ieee80211_get_qos_ctl(hdr);
|
2008-05-15 13:54:07 +08:00
|
|
|
tx_cmd->tid_tspec = qc[0] & 0xf;
|
|
|
|
tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
|
|
|
|
} else {
|
|
|
|
tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
|
|
|
|
}
|
|
|
|
|
2008-07-11 11:53:31 +08:00
|
|
|
priv->cfg->ops->utils->rts_tx_cmd_flag(info, &tx_flags);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
if ((tx_flags & TX_CMD_FLG_RTS_MSK) || (tx_flags & TX_CMD_FLG_CTS_MSK))
|
|
|
|
tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
|
|
|
|
|
|
|
|
tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
if (ieee80211_is_mgmt(fc)) {
|
|
|
|
if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
|
2008-05-15 13:54:07 +08:00
|
|
|
tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(3);
|
|
|
|
else
|
|
|
|
tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(2);
|
|
|
|
} else {
|
|
|
|
tx_cmd->timeout.pm_frame_timeout = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
tx_cmd->driver_txop = 0;
|
|
|
|
tx_cmd->tx_flags = tx_flags;
|
|
|
|
tx_cmd->next_frame_len = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define RTS_HCCA_RETRY_LIMIT 3
|
|
|
|
#define RTS_DFAULT_RETRY_LIMIT 60
|
|
|
|
|
|
|
|
static void iwl_tx_cmd_build_rate(struct iwl_priv *priv,
|
|
|
|
struct iwl_tx_cmd *tx_cmd,
|
2008-05-15 18:55:29 +08:00
|
|
|
struct ieee80211_tx_info *info,
|
2009-08-29 00:44:46 +08:00
|
|
|
__le16 fc, int is_hcca)
|
2008-05-15 13:54:07 +08:00
|
|
|
{
|
2009-08-29 00:44:46 +08:00
|
|
|
u32 rate_flags;
|
2008-10-15 03:32:45 +08:00
|
|
|
int rate_idx;
|
2009-08-29 00:44:46 +08:00
|
|
|
u8 rts_retry_limit;
|
|
|
|
u8 data_retry_limit;
|
2008-05-15 13:54:07 +08:00
|
|
|
u8 rate_plcp;
|
2008-05-15 18:55:27 +08:00
|
|
|
|
2009-08-29 00:44:46 +08:00
|
|
|
/* Set retry limit on DATA packets and Probe Responses*/
|
2009-10-10 04:20:32 +08:00
|
|
|
if (ieee80211_is_probe_resp(fc))
|
2009-08-29 00:44:46 +08:00
|
|
|
data_retry_limit = 3;
|
|
|
|
else
|
|
|
|
data_retry_limit = IWL_DEFAULT_TX_RETRY;
|
|
|
|
tx_cmd->data_retry_limit = data_retry_limit;
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2009-08-29 00:44:46 +08:00
|
|
|
/* Set retry limit on RTS packets */
|
|
|
|
rts_retry_limit = (is_hcca) ? RTS_HCCA_RETRY_LIMIT :
|
|
|
|
RTS_DFAULT_RETRY_LIMIT;
|
|
|
|
if (data_retry_limit < rts_retry_limit)
|
|
|
|
rts_retry_limit = data_retry_limit;
|
|
|
|
tx_cmd->rts_retry_limit = rts_retry_limit;
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2009-08-29 00:44:46 +08:00
|
|
|
/* DATA packets will use the uCode station table for rate/antenna
|
|
|
|
* selection */
|
2008-05-15 13:54:07 +08:00
|
|
|
if (ieee80211_is_data(fc)) {
|
|
|
|
tx_cmd->initial_rate_index = 0;
|
|
|
|
tx_cmd->tx_flags |= TX_CMD_FLG_STA_RATE_MSK;
|
2009-08-29 00:44:46 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* If the current TX rate stored in mac80211 has the MCS bit set, it's
|
|
|
|
* not really a TX rate. Thus, we use the lowest supported rate for
|
|
|
|
* this band. Also use the lowest supported rate if the stored rate
|
|
|
|
* index is invalid.
|
|
|
|
*/
|
|
|
|
rate_idx = info->control.rates[0].idx;
|
|
|
|
if (info->control.rates[0].flags & IEEE80211_TX_RC_MCS ||
|
|
|
|
(rate_idx < 0) || (rate_idx > IWL_RATE_COUNT_LEGACY))
|
|
|
|
rate_idx = rate_lowest_index(&priv->bands[info->band],
|
|
|
|
info->control.sta);
|
|
|
|
/* For 5 GHZ band, remap mac80211 rate indices into driver indices */
|
|
|
|
if (info->band == IEEE80211_BAND_5GHZ)
|
|
|
|
rate_idx += IWL_FIRST_OFDM_RATE;
|
|
|
|
/* Get PLCP rate for tx_cmd->rate_n_flags */
|
|
|
|
rate_plcp = iwl_rates[rate_idx].plcp;
|
|
|
|
/* Zero out flags for this packet */
|
|
|
|
rate_flags = 0;
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2009-08-29 00:44:46 +08:00
|
|
|
/* Set CCK flag as needed */
|
|
|
|
if ((rate_idx >= IWL_FIRST_CCK_RATE) && (rate_idx <= IWL_LAST_CCK_RATE))
|
|
|
|
rate_flags |= RATE_MCS_CCK_MSK;
|
|
|
|
|
|
|
|
/* Set up RTS and CTS flags for certain packets */
|
|
|
|
switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
|
|
|
|
case cpu_to_le16(IEEE80211_STYPE_AUTH):
|
|
|
|
case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
|
|
|
|
case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ):
|
|
|
|
case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ):
|
|
|
|
if (tx_cmd->tx_flags & TX_CMD_FLG_RTS_MSK) {
|
|
|
|
tx_cmd->tx_flags &= ~TX_CMD_FLG_RTS_MSK;
|
|
|
|
tx_cmd->tx_flags |= TX_CMD_FLG_CTS_MSK;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2008-05-15 13:54:07 +08:00
|
|
|
}
|
|
|
|
|
2009-08-29 00:44:46 +08:00
|
|
|
/* Set up antennas */
|
|
|
|
priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant);
|
|
|
|
rate_flags |= iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
|
|
|
|
|
|
|
|
/* Set the rate in the TX cmd */
|
2008-06-12 09:47:11 +08:00
|
|
|
tx_cmd->rate_n_flags = iwl_hw_set_rate_n_flags(rate_plcp, rate_flags);
|
2008-05-15 13:54:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void iwl_tx_cmd_build_hwcrypto(struct iwl_priv *priv,
|
2008-05-15 18:55:29 +08:00
|
|
|
struct ieee80211_tx_info *info,
|
2008-05-15 13:54:07 +08:00
|
|
|
struct iwl_tx_cmd *tx_cmd,
|
|
|
|
struct sk_buff *skb_frag,
|
|
|
|
int sta_id)
|
|
|
|
{
|
2008-05-15 18:55:29 +08:00
|
|
|
struct ieee80211_key_conf *keyconf = info->control.hw_key;
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2008-05-15 13:54:09 +08:00
|
|
|
switch (keyconf->alg) {
|
2008-05-15 13:54:07 +08:00
|
|
|
case ALG_CCMP:
|
|
|
|
tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
|
2008-05-15 13:54:09 +08:00
|
|
|
memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
|
2008-05-15 18:55:29 +08:00
|
|
|
if (info->flags & IEEE80211_TX_CTL_AMPDU)
|
2008-05-15 13:54:07 +08:00
|
|
|
tx_cmd->tx_flags |= TX_CMD_FLG_AGG_CCMP_MSK;
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX(priv, "tx_cmd with AES hwcrypto\n");
|
2008-05-15 13:54:07 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ALG_TKIP:
|
|
|
|
tx_cmd->sec_ctl = TX_CMD_SEC_TKIP;
|
2008-05-15 13:54:09 +08:00
|
|
|
ieee80211_get_tkip_key(keyconf, skb_frag,
|
2008-05-15 13:54:07 +08:00
|
|
|
IEEE80211_TKIP_P2_KEY, tx_cmd->key);
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX(priv, "tx_cmd with tkip hwcrypto\n");
|
2008-05-15 13:54:07 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case ALG_WEP:
|
|
|
|
tx_cmd->sec_ctl |= (TX_CMD_SEC_WEP |
|
2008-05-15 13:54:09 +08:00
|
|
|
(keyconf->keyidx & TX_CMD_SEC_MSK) << TX_CMD_SEC_SHIFT);
|
|
|
|
|
|
|
|
if (keyconf->keylen == WEP_KEY_LEN_128)
|
|
|
|
tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
|
|
|
|
|
|
|
|
memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX(priv, "Configuring packet for WEP encryption "
|
2008-05-15 13:54:09 +08:00
|
|
|
"with key %d\n", keyconf->keyidx);
|
2008-05-15 13:54:07 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2008-12-19 10:37:31 +08:00
|
|
|
IWL_ERR(priv, "Unknown encode alg %d\n", keyconf->alg);
|
2008-05-15 13:54:07 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* start REPLY_TX command process
|
|
|
|
*/
|
2008-05-15 18:55:29 +08:00
|
|
|
int iwl_tx_skb(struct iwl_priv *priv, struct sk_buff *skb)
|
2008-05-15 13:54:07 +08:00
|
|
|
{
|
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
|
2008-05-15 18:55:29 +08:00
|
|
|
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
|
2009-11-14 03:56:37 +08:00
|
|
|
struct ieee80211_sta *sta = info->control.sta;
|
|
|
|
struct iwl_station_priv *sta_priv = NULL;
|
2008-08-04 16:00:44 +08:00
|
|
|
struct iwl_tx_queue *txq;
|
|
|
|
struct iwl_queue *q;
|
2009-07-25 02:13:05 +08:00
|
|
|
struct iwl_device_cmd *out_cmd;
|
|
|
|
struct iwl_cmd_meta *out_meta;
|
2008-08-04 16:00:44 +08:00
|
|
|
struct iwl_tx_cmd *tx_cmd;
|
|
|
|
int swq_id, txq_id;
|
2008-05-15 13:54:07 +08:00
|
|
|
dma_addr_t phys_addr;
|
|
|
|
dma_addr_t txcmd_phys;
|
|
|
|
dma_addr_t scratch_phys;
|
2009-10-03 04:44:02 +08:00
|
|
|
u16 len, len_org, firstlen, secondlen;
|
2008-05-15 13:54:07 +08:00
|
|
|
u16 seq_number = 0;
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
__le16 fc;
|
2008-12-19 00:04:51 +08:00
|
|
|
u8 hdr_len;
|
2008-08-04 16:00:44 +08:00
|
|
|
u8 sta_id;
|
2008-05-15 13:54:07 +08:00
|
|
|
u8 wait_write_ptr = 0;
|
|
|
|
u8 tid = 0;
|
|
|
|
u8 *qc = NULL;
|
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
if (iwl_is_rfkill(priv)) {
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_DROP(priv, "Dropping - RF KILL\n");
|
2008-05-15 13:54:07 +08:00
|
|
|
goto drop_unlock;
|
|
|
|
}
|
|
|
|
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
fc = hdr->frame_control;
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
|
|
|
if (ieee80211_is_auth(fc))
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX(priv, "Sending AUTH frame\n");
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
else if (ieee80211_is_assoc_req(fc))
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX(priv, "Sending ASSOC frame\n");
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
else if (ieee80211_is_reassoc_req(fc))
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX(priv, "Sending REASSOC frame\n");
|
2008-05-15 13:54:07 +08:00
|
|
|
#endif
|
|
|
|
|
2009-08-22 02:44:09 +08:00
|
|
|
/* drop all non-injected data frame if we are not associated */
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
if (ieee80211_is_data(fc) &&
|
2009-08-22 02:44:09 +08:00
|
|
|
!(info->flags & IEEE80211_TX_CTL_INJECTED) &&
|
2008-09-03 11:26:59 +08:00
|
|
|
(!iwl_is_associated(priv) ||
|
2008-09-11 06:01:58 +08:00
|
|
|
((priv->iw_mode == NL80211_IFTYPE_STATION) && !priv->assoc_id) ||
|
2008-09-03 11:26:59 +08:00
|
|
|
!priv->assoc_station_added)) {
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_DROP(priv, "Dropping - !iwl_is_associated\n");
|
2008-05-15 13:54:07 +08:00
|
|
|
goto drop_unlock;
|
|
|
|
}
|
|
|
|
|
2008-07-16 09:43:59 +08:00
|
|
|
hdr_len = ieee80211_hdrlen(fc);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
/* Find (or create) index into station table for destination station */
|
2009-08-22 02:44:09 +08:00
|
|
|
if (info->flags & IEEE80211_TX_CTL_INJECTED)
|
|
|
|
sta_id = priv->hw_params.bcast_sta_id;
|
|
|
|
else
|
|
|
|
sta_id = iwl_get_sta_id(priv, hdr);
|
2008-05-15 13:54:07 +08:00
|
|
|
if (sta_id == IWL_INVALID_STATION) {
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_DROP(priv, "Dropping - INVALID STATION: %pM\n",
|
2008-10-28 06:59:26 +08:00
|
|
|
hdr->addr1);
|
iwlwifi: fix TX queue race
I had a problem on 4965 hardware (well, probably other hardware too,
but others don't survive my stress testing right now, unfortunately)
where the driver was sending invalid commands to the device, but no
such thing could be seen from the driver's point of view. I could
reproduce this fairly easily by sending multiple TCP streams with
iperf on different TIDs, though sometimes a single iperf stream was
sufficient. It even happened with a single core, but I have forced
preemption turned on.
The culprit was a queue overrun, where we advanced the queue's write
pointer over the read pointer. After careful analysis I've come to
the conclusion that the cause is a race condition between iwlwifi
and mac80211.
mac80211, of course, checks whether the queue is stopped, before
transmitting a frame. This effectively looks like this:
lock(queues)
if (stopped(queue)) {
unlock(queues)
return busy;
}
unlock(queues)
... <-- this place will be important
there is some more code here
drv_tx(frame)
The driver, on the other hand, can stop and start queues, which does
lock(queues)
mark_running/stopped(queue)
unlock(queues)
[if marked running: wake up tasklet to send pending frames]
Now, however, once the driver starts the queue, mac80211 can see that
and end up at the marked place above, at which point for some reason the
driver seems to stop the queue again (I don't understand that) and then
we end up transmitting while the queue is actually full.
Now, this shouldn't actually matter much, but for some reason I've seen
it happen multiple times in a row and the queue actually overflows, at
which point the queue bites itself in the tail and things go completely
wrong.
This patch fixes this by just dropping the packet should this have
happened, and making the lock in iwlwifi cover everything so iwlwifi
can't race against itself (dropping the lock there might make it more
likely, but it did seem to happen without that too).
Since we can't hold the lock across drv_tx() above, I see no way to fix
this in mac80211, but I also don't understand why I haven't seen this
before -- maybe I just never stress tested it this badly.
With this patch, the device has survived many minutes of simultanously
sending two iperf streams on different TIDs with combined throughput
of about 60 Mbps.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-25 02:13:14 +08:00
|
|
|
goto drop_unlock;
|
2008-05-15 13:54:07 +08:00
|
|
|
}
|
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX(priv, "station Id %d\n", sta_id);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2009-11-14 03:56:37 +08:00
|
|
|
if (sta)
|
|
|
|
sta_priv = (void *)sta->drv_priv;
|
|
|
|
|
|
|
|
if (sta_priv && sta_id != priv->hw_params.bcast_sta_id &&
|
|
|
|
sta_priv->asleep) {
|
|
|
|
WARN_ON(!(info->flags & IEEE80211_TX_CTL_PSPOLL_RESPONSE));
|
|
|
|
/*
|
|
|
|
* This sends an asynchronous command to the device,
|
|
|
|
* but we can rely on it being processed before the
|
|
|
|
* next frame is processed -- and the next frame to
|
|
|
|
* this station is the one that will consume this
|
|
|
|
* counter.
|
|
|
|
* For now set the counter to just 1 since we do not
|
|
|
|
* support uAPSD yet.
|
|
|
|
*/
|
|
|
|
iwl_sta_modify_sleep_tx_count(priv, sta_id, 1);
|
|
|
|
}
|
|
|
|
|
2009-06-20 04:52:43 +08:00
|
|
|
txq_id = skb_get_queue_mapping(skb);
|
mac80211: add helpers for frame control testing
A few general categories:
1) ieee80211_has_* tests if particular fctl bits are set, the helpers are de
in the same order as the fctl defines:
A combined _has_a4 was also added to test when both FROMDS and TODS are set.
2) ieee80211_is_* is meant to test whether the frame control is of a certain
ftype - data, mgmt, ctl, and two special helpers _is_data_qos, _is_data_pres
which also test a subset of the stype space.
When testing for a particular stype applicable only to one ftype, functions
like ieee80211_is_ack have been added. Note that the ftype is also being
checked in these helpers. They have been added for all mgmt and ctl stypes
in the same order as the STYPE defines.
3) ieee80211_get_* is meant to take a struct ieee80211_hdr * and returns a
pointer to somewhere in the struct, see get_SA, get_DA, get_qos_ctl.
The intel wireless drivers had helpers that used this namespace, convert the
all to use the new helpers and remove the byteshifting as they were defined
in cpu-order rather than little-endian.
Signed-off-by: Harvey Harrison <harvey.harrison@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-06-12 05:21:56 +08:00
|
|
|
if (ieee80211_is_data_qos(fc)) {
|
|
|
|
qc = ieee80211_get_qos_ctl(hdr);
|
2008-07-16 09:43:59 +08:00
|
|
|
tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
|
2009-08-14 04:30:50 +08:00
|
|
|
if (unlikely(tid >= MAX_TID_COUNT))
|
|
|
|
goto drop_unlock;
|
2008-08-04 16:00:44 +08:00
|
|
|
seq_number = priv->stations[sta_id].tid[tid].seq_number;
|
|
|
|
seq_number &= IEEE80211_SCTL_SEQ;
|
|
|
|
hdr->seq_ctrl = hdr->seq_ctrl &
|
2009-01-30 05:26:44 +08:00
|
|
|
cpu_to_le16(IEEE80211_SCTL_FRAG);
|
2008-08-04 16:00:44 +08:00
|
|
|
hdr->seq_ctrl |= cpu_to_le16(seq_number);
|
2008-05-15 13:54:07 +08:00
|
|
|
seq_number += 0x10;
|
|
|
|
/* aggregation is on for this <sta,tid> */
|
2009-06-20 04:52:43 +08:00
|
|
|
if (info->flags & IEEE80211_TX_CTL_AMPDU)
|
2008-05-15 13:54:07 +08:00
|
|
|
txq_id = priv->stations[sta_id].tid[tid].agg.txq_id;
|
|
|
|
}
|
|
|
|
|
|
|
|
txq = &priv->txq[txq_id];
|
2009-06-20 04:52:43 +08:00
|
|
|
swq_id = txq->swq_id;
|
2008-05-15 13:54:07 +08:00
|
|
|
q = &txq->q;
|
|
|
|
|
iwlwifi: fix TX queue race
I had a problem on 4965 hardware (well, probably other hardware too,
but others don't survive my stress testing right now, unfortunately)
where the driver was sending invalid commands to the device, but no
such thing could be seen from the driver's point of view. I could
reproduce this fairly easily by sending multiple TCP streams with
iperf on different TIDs, though sometimes a single iperf stream was
sufficient. It even happened with a single core, but I have forced
preemption turned on.
The culprit was a queue overrun, where we advanced the queue's write
pointer over the read pointer. After careful analysis I've come to
the conclusion that the cause is a race condition between iwlwifi
and mac80211.
mac80211, of course, checks whether the queue is stopped, before
transmitting a frame. This effectively looks like this:
lock(queues)
if (stopped(queue)) {
unlock(queues)
return busy;
}
unlock(queues)
... <-- this place will be important
there is some more code here
drv_tx(frame)
The driver, on the other hand, can stop and start queues, which does
lock(queues)
mark_running/stopped(queue)
unlock(queues)
[if marked running: wake up tasklet to send pending frames]
Now, however, once the driver starts the queue, mac80211 can see that
and end up at the marked place above, at which point for some reason the
driver seems to stop the queue again (I don't understand that) and then
we end up transmitting while the queue is actually full.
Now, this shouldn't actually matter much, but for some reason I've seen
it happen multiple times in a row and the queue actually overflows, at
which point the queue bites itself in the tail and things go completely
wrong.
This patch fixes this by just dropping the packet should this have
happened, and making the lock in iwlwifi cover everything so iwlwifi
can't race against itself (dropping the lock there might make it more
likely, but it did seem to happen without that too).
Since we can't hold the lock across drv_tx() above, I see no way to fix
this in mac80211, but I also don't understand why I haven't seen this
before -- maybe I just never stress tested it this badly.
With this patch, the device has survived many minutes of simultanously
sending two iperf streams on different TIDs with combined throughput
of about 60 Mbps.
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-07-25 02:13:14 +08:00
|
|
|
if (unlikely(iwl_queue_space(q) < q->high_mark))
|
|
|
|
goto drop_unlock;
|
|
|
|
|
|
|
|
if (ieee80211_is_data_qos(fc))
|
|
|
|
priv->stations[sta_id].tid[tid].tfds_in_queue++;
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
/* Set up driver data for this TFD */
|
|
|
|
memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct iwl_tx_info));
|
|
|
|
txq->txb[q->write_ptr].skb[0] = skb;
|
|
|
|
|
|
|
|
/* Set up first empty entry in queue's array of Tx/cmd buffers */
|
2008-10-15 03:32:49 +08:00
|
|
|
out_cmd = txq->cmd[q->write_ptr];
|
2009-07-25 02:13:05 +08:00
|
|
|
out_meta = &txq->meta[q->write_ptr];
|
2008-05-15 13:54:07 +08:00
|
|
|
tx_cmd = &out_cmd->cmd.tx;
|
|
|
|
memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
|
|
|
|
memset(tx_cmd, 0, sizeof(struct iwl_tx_cmd));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set up the Tx-command (not MAC!) header.
|
|
|
|
* Store the chosen Tx queue and TFD index within the sequence field;
|
|
|
|
* after Tx, uCode's Tx response will return this value so driver can
|
|
|
|
* locate the frame within the tx queue and do post-tx processing.
|
|
|
|
*/
|
|
|
|
out_cmd->hdr.cmd = REPLY_TX;
|
|
|
|
out_cmd->hdr.sequence = cpu_to_le16((u16)(QUEUE_TO_SEQ(txq_id) |
|
|
|
|
INDEX_TO_SEQ(q->write_ptr)));
|
|
|
|
|
|
|
|
/* Copy MAC header from skb into command buffer */
|
|
|
|
memcpy(tx_cmd->hdr, hdr, hdr_len);
|
|
|
|
|
2009-04-22 01:55:48 +08:00
|
|
|
|
|
|
|
/* Total # bytes to be transmitted */
|
|
|
|
len = (u16)skb->len;
|
|
|
|
tx_cmd->len = cpu_to_le16(len);
|
|
|
|
|
|
|
|
if (info->control.hw_key)
|
|
|
|
iwl_tx_cmd_build_hwcrypto(priv, info, tx_cmd, skb, sta_id);
|
|
|
|
|
|
|
|
/* TODO need this for burst mode later on */
|
|
|
|
iwl_tx_cmd_build_basic(priv, tx_cmd, info, hdr, sta_id);
|
2009-08-08 06:41:39 +08:00
|
|
|
iwl_dbg_log_tx_data_frame(priv, len, hdr);
|
2009-04-22 01:55:48 +08:00
|
|
|
|
|
|
|
/* set is_hcca to 0; it probably will never be implemented */
|
2009-08-29 00:44:46 +08:00
|
|
|
iwl_tx_cmd_build_rate(priv, tx_cmd, info, fc, 0);
|
2009-04-22 01:55:48 +08:00
|
|
|
|
2009-08-08 06:41:40 +08:00
|
|
|
iwl_update_stats(priv, true, fc, len);
|
2008-05-15 13:54:07 +08:00
|
|
|
/*
|
|
|
|
* Use the first empty entry in this queue's command buffer array
|
|
|
|
* to contain the Tx command and MAC header concatenated together
|
|
|
|
* (payload data will be in another buffer).
|
|
|
|
* Size of this varies, due to varying MAC header length.
|
|
|
|
* If end is not dword aligned, we'll have 2 extra bytes at the end
|
|
|
|
* of the MAC header (device reads on dword boundaries).
|
|
|
|
* We'll tell device about this padding later.
|
|
|
|
*/
|
|
|
|
len = sizeof(struct iwl_tx_cmd) +
|
|
|
|
sizeof(struct iwl_cmd_header) + hdr_len;
|
|
|
|
|
|
|
|
len_org = len;
|
2009-10-03 04:44:02 +08:00
|
|
|
firstlen = len = (len + 3) & ~3;
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
if (len_org != len)
|
|
|
|
len_org = 1;
|
|
|
|
else
|
|
|
|
len_org = 0;
|
|
|
|
|
2009-04-22 01:55:48 +08:00
|
|
|
/* Tell NIC about any 2-byte padding after MAC header */
|
|
|
|
if (len_org)
|
|
|
|
tx_cmd->tx_flags |= TX_CMD_FLG_MH_PAD_MSK;
|
|
|
|
|
2008-05-15 13:54:07 +08:00
|
|
|
/* Physical address of this Tx command's header (not MAC header!),
|
|
|
|
* within command buffer array. */
|
2008-10-15 03:32:48 +08:00
|
|
|
txcmd_phys = pci_map_single(priv->pci_dev,
|
2009-04-22 01:55:48 +08:00
|
|
|
&out_cmd->hdr, len,
|
2009-02-19 07:54:33 +08:00
|
|
|
PCI_DMA_BIDIRECTIONAL);
|
2009-07-25 02:13:05 +08:00
|
|
|
pci_unmap_addr_set(out_meta, mapping, txcmd_phys);
|
|
|
|
pci_unmap_len_set(out_meta, len, len);
|
2008-05-15 13:54:07 +08:00
|
|
|
/* Add buffer containing Tx command and MAC(!) header to TFD's
|
|
|
|
* first entry */
|
2009-01-20 07:30:26 +08:00
|
|
|
priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
|
|
|
|
txcmd_phys, len, 1, 0);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2009-04-22 01:55:48 +08:00
|
|
|
if (!ieee80211_has_morefrags(hdr->frame_control)) {
|
|
|
|
txq->need_update = 1;
|
|
|
|
if (qc)
|
|
|
|
priv->stations[sta_id].tid[tid].seq_number = seq_number;
|
|
|
|
} else {
|
|
|
|
wait_write_ptr = 1;
|
|
|
|
txq->need_update = 0;
|
|
|
|
}
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
/* Set up TFD's 2nd entry to point directly to remainder of skb,
|
|
|
|
* if any (802.11 null frames have no payload). */
|
2009-10-03 04:44:02 +08:00
|
|
|
secondlen = len = skb->len - hdr_len;
|
2008-05-15 13:54:07 +08:00
|
|
|
if (len) {
|
|
|
|
phys_addr = pci_map_single(priv->pci_dev, skb->data + hdr_len,
|
|
|
|
len, PCI_DMA_TODEVICE);
|
2009-01-20 07:30:26 +08:00
|
|
|
priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
|
|
|
|
phys_addr, len,
|
|
|
|
0, 0);
|
2008-05-15 13:54:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
scratch_phys = txcmd_phys + sizeof(struct iwl_cmd_header) +
|
2009-04-22 01:55:48 +08:00
|
|
|
offsetof(struct iwl_tx_cmd, scratch);
|
|
|
|
|
|
|
|
len = sizeof(struct iwl_tx_cmd) +
|
|
|
|
sizeof(struct iwl_cmd_header) + hdr_len;
|
|
|
|
/* take back ownership of DMA buffer to enable update */
|
|
|
|
pci_dma_sync_single_for_cpu(priv->pci_dev, txcmd_phys,
|
|
|
|
len, PCI_DMA_BIDIRECTIONAL);
|
2008-05-15 13:54:07 +08:00
|
|
|
tx_cmd->dram_lsb_ptr = cpu_to_le32(scratch_phys);
|
2008-10-15 03:32:48 +08:00
|
|
|
tx_cmd->dram_msb_ptr = iwl_get_dma_hi_addr(scratch_phys);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2009-04-22 01:55:47 +08:00
|
|
|
IWL_DEBUG_TX(priv, "sequence nr = 0X%x \n",
|
|
|
|
le16_to_cpu(out_cmd->hdr.sequence));
|
|
|
|
IWL_DEBUG_TX(priv, "tx_flags = 0X%x \n", le32_to_cpu(tx_cmd->tx_flags));
|
2009-08-08 06:41:37 +08:00
|
|
|
iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx_cmd, sizeof(*tx_cmd));
|
|
|
|
iwl_print_hex_dump(priv, IWL_DL_TX, (u8 *)tx_cmd->hdr, hdr_len);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
/* Set up entry for this TFD in Tx byte-count array */
|
2009-07-10 01:33:39 +08:00
|
|
|
if (info->flags & IEEE80211_TX_CTL_AMPDU)
|
|
|
|
priv->cfg->ops->lib->txq_update_byte_cnt_tbl(priv, txq,
|
2009-04-22 01:55:48 +08:00
|
|
|
le16_to_cpu(tx_cmd->len));
|
|
|
|
|
|
|
|
pci_dma_sync_single_for_device(priv->pci_dev, txcmd_phys,
|
|
|
|
len, PCI_DMA_BIDIRECTIONAL);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2009-10-03 04:44:02 +08:00
|
|
|
trace_iwlwifi_dev_tx(priv,
|
|
|
|
&((struct iwl_tfd *)txq->tfds)[txq->q.write_ptr],
|
|
|
|
sizeof(struct iwl_tfd),
|
|
|
|
&out_cmd->hdr, firstlen,
|
|
|
|
skb->data + hdr_len, secondlen);
|
|
|
|
|
2008-05-15 13:54:07 +08:00
|
|
|
/* Tell device the write index *just past* this latest filled TFD */
|
|
|
|
q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
|
|
|
|
ret = iwl_txq_update_write_ptr(priv, txq);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2009-11-14 03:56:37 +08:00
|
|
|
/*
|
|
|
|
* At this point the frame is "transmitted" successfully
|
|
|
|
* and we will get a TX status notification eventually,
|
|
|
|
* regardless of the value of ret. "ret" only indicates
|
|
|
|
* whether or not we should update the write pointer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* avoid atomic ops if it isn't an associated client */
|
|
|
|
if (sta_priv && sta_priv->client)
|
|
|
|
atomic_inc(&sta_priv->pending_frames);
|
|
|
|
|
2008-05-15 13:54:07 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2008-07-25 02:33:42 +08:00
|
|
|
if ((iwl_queue_space(q) < q->high_mark) && priv->mac80211_registered) {
|
2008-05-15 13:54:07 +08:00
|
|
|
if (wait_write_ptr) {
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
txq->need_update = 1;
|
|
|
|
iwl_txq_update_write_ptr(priv, txq);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2008-07-25 02:33:42 +08:00
|
|
|
} else {
|
2009-03-24 00:28:42 +08:00
|
|
|
iwl_stop_queue(priv, txq->swq_id);
|
2008-05-15 13:54:07 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
drop_unlock:
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_tx_skb);
|
|
|
|
|
|
|
|
/*************** HOST COMMAND QUEUE FUNCTIONS *****/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_enqueue_hcmd - enqueue a uCode command
|
|
|
|
* @priv: device private data point
|
|
|
|
* @cmd: a point to the ucode command structure
|
|
|
|
*
|
|
|
|
* The function returns < 0 values to indicate the operation is
|
|
|
|
* failed. On success, it turns the index (> 0) of command in the
|
|
|
|
* command queue.
|
|
|
|
*/
|
|
|
|
int iwl_enqueue_hcmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
|
|
|
|
{
|
|
|
|
struct iwl_tx_queue *txq = &priv->txq[IWL_CMD_QUEUE_NUM];
|
|
|
|
struct iwl_queue *q = &txq->q;
|
2009-07-25 02:13:05 +08:00
|
|
|
struct iwl_device_cmd *out_cmd;
|
|
|
|
struct iwl_cmd_meta *out_meta;
|
2008-05-15 13:54:07 +08:00
|
|
|
dma_addr_t phys_addr;
|
|
|
|
unsigned long flags;
|
2008-08-04 16:00:44 +08:00
|
|
|
int len, ret;
|
|
|
|
u32 idx;
|
|
|
|
u16 fix_size;
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
cmd->len = priv->cfg->ops->utils->get_hcmd_size(cmd->id, cmd->len);
|
|
|
|
fix_size = (u16)(cmd->len + sizeof(out_cmd->hdr));
|
|
|
|
|
|
|
|
/* If any of the command structures end up being larger than
|
|
|
|
* the TFD_MAX_PAYLOAD_SIZE, and it sent as a 'small' command then
|
|
|
|
* we will need to increase the size of the TFD entries */
|
|
|
|
BUG_ON((fix_size > TFD_MAX_PAYLOAD_SIZE) &&
|
2009-07-25 02:13:05 +08:00
|
|
|
!(cmd->flags & CMD_SIZE_HUGE));
|
2008-05-15 13:54:07 +08:00
|
|
|
|
iwlwifi: reliable entering of critical temperature state
When uCode detects critical temperature it should send "card state
notification" interrupt to driver and then shut itself down to prevent
overheating. There is a race condition where uCode shuts down before it
can deliver the interrupt to driver.
Additional method provided here for driver to enter CT_KILL state based
on temperature reading.
How it works:
Method 1:
If driver receive "card state notification" interrupt from uCode; it
enters "CT_KILL" state immediately
Method 2:
If the last temperature report by Card reach Critical temperature,
driver will send "statistic notification" request to uCode to verify the
temperature reading, if driver can not get reply from uCode within
300ms, driver will enter CT_KILL state automatically.
Method 3:
If the last temperature report by Card did not reach Critical
temperature, but uCode already shut down due to critical temperature.
All the host commands send to uCode will not get process by uCode;
when command queue reach the limit, driver will check the last reported
temperature reading, if it is within pre-defined margin, enter "CT_KILL"
state immediately. In this case, when uCode ready to exit from "CT_KILL" state,
driver need to restart the adapter in order to reset all the queues and
resume normal operation.
One additional issue being address here, when system is in CT_KILL
state, both tx and rx already stopped, but driver still can send host
command to uCode, it will flood the command queue since card was not
responding; adding STATUS_CT_KILL flag to reject enqueue host commands
to uCode if it is in CT_KILL state, when uCode is ready to come out of
CT_KILL, driver will clear the STATUS_CT_KILL bit and allow enqueue the host
commands to uCode to recover from CT_KILL state.
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-10-03 04:43:58 +08:00
|
|
|
if (iwl_is_rfkill(priv) || iwl_is_ctkill(priv)) {
|
2009-10-31 05:36:15 +08:00
|
|
|
IWL_WARN(priv, "Not sending command - %s KILL\n",
|
|
|
|
iwl_is_rfkill(priv) ? "RF" : "CT");
|
2008-05-15 13:54:07 +08:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2009-07-25 02:13:05 +08:00
|
|
|
if (iwl_queue_space(q) < ((cmd->flags & CMD_ASYNC) ? 2 : 1)) {
|
2009-11-21 04:05:08 +08:00
|
|
|
IWL_ERR(priv, "No space in command queue\n");
|
iwlwifi: reliable entering of critical temperature state
When uCode detects critical temperature it should send "card state
notification" interrupt to driver and then shut itself down to prevent
overheating. There is a race condition where uCode shuts down before it
can deliver the interrupt to driver.
Additional method provided here for driver to enter CT_KILL state based
on temperature reading.
How it works:
Method 1:
If driver receive "card state notification" interrupt from uCode; it
enters "CT_KILL" state immediately
Method 2:
If the last temperature report by Card reach Critical temperature,
driver will send "statistic notification" request to uCode to verify the
temperature reading, if driver can not get reply from uCode within
300ms, driver will enter CT_KILL state automatically.
Method 3:
If the last temperature report by Card did not reach Critical
temperature, but uCode already shut down due to critical temperature.
All the host commands send to uCode will not get process by uCode;
when command queue reach the limit, driver will check the last reported
temperature reading, if it is within pre-defined margin, enter "CT_KILL"
state immediately. In this case, when uCode ready to exit from "CT_KILL" state,
driver need to restart the adapter in order to reset all the queues and
resume normal operation.
One additional issue being address here, when system is in CT_KILL
state, both tx and rx already stopped, but driver still can send host
command to uCode, it will flood the command queue since card was not
responding; adding STATUS_CT_KILL flag to reject enqueue host commands
to uCode if it is in CT_KILL state, when uCode is ready to come out of
CT_KILL, driver will clear the STATUS_CT_KILL bit and allow enqueue the host
commands to uCode to recover from CT_KILL state.
Signed-off-by: Wey-Yi Guy <wey-yi.w.guy@intel.com>
Signed-off-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2009-10-03 04:43:58 +08:00
|
|
|
if (iwl_within_ct_kill_margin(priv))
|
|
|
|
iwl_tt_enter_ct_kill(priv);
|
|
|
|
else {
|
|
|
|
IWL_ERR(priv, "Restarting adapter due to queue full\n");
|
|
|
|
queue_work(priv->workqueue, &priv->restart);
|
|
|
|
}
|
2008-05-15 13:54:07 +08:00
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->hcmd_lock, flags);
|
|
|
|
|
2009-07-25 02:13:05 +08:00
|
|
|
idx = get_cmd_index(q, q->write_ptr, cmd->flags & CMD_SIZE_HUGE);
|
2008-08-04 16:00:40 +08:00
|
|
|
out_cmd = txq->cmd[idx];
|
2009-07-25 02:13:05 +08:00
|
|
|
out_meta = &txq->meta[idx];
|
|
|
|
|
2009-08-01 05:28:06 +08:00
|
|
|
memset(out_meta, 0, sizeof(*out_meta)); /* re-initialize to NULL */
|
2009-07-25 02:13:05 +08:00
|
|
|
out_meta->flags = cmd->flags;
|
|
|
|
if (cmd->flags & CMD_WANT_SKB)
|
|
|
|
out_meta->source = cmd;
|
|
|
|
if (cmd->flags & CMD_ASYNC)
|
|
|
|
out_meta->callback = cmd->callback;
|
2008-05-15 13:54:07 +08:00
|
|
|
|
|
|
|
out_cmd->hdr.cmd = cmd->id;
|
|
|
|
memcpy(&out_cmd->cmd.payload, cmd->data, cmd->len);
|
|
|
|
|
|
|
|
/* At this point, the out_cmd now has all of the incoming cmd
|
|
|
|
* information */
|
|
|
|
|
|
|
|
out_cmd->hdr.flags = 0;
|
|
|
|
out_cmd->hdr.sequence = cpu_to_le16(QUEUE_TO_SEQ(IWL_CMD_QUEUE_NUM) |
|
|
|
|
INDEX_TO_SEQ(q->write_ptr));
|
2009-07-25 02:13:05 +08:00
|
|
|
if (cmd->flags & CMD_SIZE_HUGE)
|
2008-09-03 11:26:52 +08:00
|
|
|
out_cmd->hdr.sequence |= SEQ_HUGE_FRAME;
|
2009-07-25 02:13:05 +08:00
|
|
|
len = sizeof(struct iwl_device_cmd);
|
2009-04-22 01:55:48 +08:00
|
|
|
len += (idx == TFD_CMD_SLOTS) ? IWL_MAX_SCAN_SIZE : 0;
|
2008-10-15 03:32:48 +08:00
|
|
|
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2008-08-04 16:00:45 +08:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
|
|
|
switch (out_cmd->hdr.cmd) {
|
|
|
|
case REPLY_TX_LINK_QUALITY_CMD:
|
|
|
|
case SENSITIVITY_CMD:
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HC_DUMP(priv, "Sending command %s (#%x), seq: 0x%04X, "
|
2008-08-04 16:00:45 +08:00
|
|
|
"%d bytes at %d[%d]:%d\n",
|
|
|
|
get_cmd_string(out_cmd->hdr.cmd),
|
|
|
|
out_cmd->hdr.cmd,
|
|
|
|
le16_to_cpu(out_cmd->hdr.sequence), fix_size,
|
|
|
|
q->write_ptr, idx, IWL_CMD_QUEUE_NUM);
|
|
|
|
break;
|
|
|
|
default:
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HC(priv, "Sending command %s (#%x), seq: 0x%04X, "
|
2008-08-04 16:00:45 +08:00
|
|
|
"%d bytes at %d[%d]:%d\n",
|
|
|
|
get_cmd_string(out_cmd->hdr.cmd),
|
|
|
|
out_cmd->hdr.cmd,
|
|
|
|
le16_to_cpu(out_cmd->hdr.sequence), fix_size,
|
|
|
|
q->write_ptr, idx, IWL_CMD_QUEUE_NUM);
|
|
|
|
}
|
|
|
|
#endif
|
2008-05-15 13:54:07 +08:00
|
|
|
txq->need_update = 1;
|
|
|
|
|
2009-01-20 07:30:27 +08:00
|
|
|
if (priv->cfg->ops->lib->txq_update_byte_cnt_tbl)
|
|
|
|
/* Set up entry in queue's byte count circular buffer */
|
|
|
|
priv->cfg->ops->lib->txq_update_byte_cnt_tbl(priv, txq, 0);
|
2008-05-15 13:54:07 +08:00
|
|
|
|
2009-04-22 01:55:48 +08:00
|
|
|
phys_addr = pci_map_single(priv->pci_dev, &out_cmd->hdr,
|
|
|
|
fix_size, PCI_DMA_BIDIRECTIONAL);
|
2009-07-25 02:13:05 +08:00
|
|
|
pci_unmap_addr_set(out_meta, mapping, phys_addr);
|
|
|
|
pci_unmap_len_set(out_meta, len, fix_size);
|
2009-04-22 01:55:48 +08:00
|
|
|
|
2009-10-03 04:44:02 +08:00
|
|
|
trace_iwlwifi_dev_hcmd(priv, &out_cmd->hdr, fix_size, cmd->flags);
|
|
|
|
|
2009-04-22 01:55:48 +08:00
|
|
|
priv->cfg->ops->lib->txq_attach_buf_to_tfd(priv, txq,
|
|
|
|
phys_addr, fix_size, 1,
|
|
|
|
U32_PAD(cmd->len));
|
|
|
|
|
2008-05-15 13:54:07 +08:00
|
|
|
/* Increment and update queue's write index */
|
|
|
|
q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
|
|
|
|
ret = iwl_txq_update_write_ptr(priv, txq);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&priv->hcmd_lock, flags);
|
|
|
|
return ret ? ret : idx;
|
|
|
|
}
|
|
|
|
|
2009-11-14 03:56:37 +08:00
|
|
|
static void iwl_tx_status(struct iwl_priv *priv, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
|
|
|
|
struct ieee80211_sta *sta;
|
|
|
|
struct iwl_station_priv *sta_priv;
|
|
|
|
|
|
|
|
sta = ieee80211_find_sta(priv->vif, hdr->addr1);
|
|
|
|
if (sta) {
|
|
|
|
sta_priv = (void *)sta->drv_priv;
|
|
|
|
/* avoid atomic ops if this isn't a client */
|
|
|
|
if (sta_priv->client &&
|
|
|
|
atomic_dec_return(&sta_priv->pending_frames) == 0)
|
|
|
|
ieee80211_sta_block_awake(priv->hw, sta, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
ieee80211_tx_status_irqsafe(priv->hw, skb);
|
|
|
|
}
|
|
|
|
|
2008-05-29 16:35:12 +08:00
|
|
|
int iwl_tx_queue_reclaim(struct iwl_priv *priv, int txq_id, int index)
|
|
|
|
{
|
|
|
|
struct iwl_tx_queue *txq = &priv->txq[txq_id];
|
|
|
|
struct iwl_queue *q = &txq->q;
|
|
|
|
struct iwl_tx_info *tx_info;
|
|
|
|
int nfreed = 0;
|
|
|
|
|
|
|
|
if ((index >= q->n_bd) || (iwl_queue_used(q, index) == 0)) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
|
2008-05-29 16:35:12 +08:00
|
|
|
"is out of range [0-%d] %d %d.\n", txq_id,
|
|
|
|
index, q->n_bd, q->write_ptr, q->read_ptr);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-15 03:32:48 +08:00
|
|
|
for (index = iwl_queue_inc_wrap(index, q->n_bd);
|
|
|
|
q->read_ptr != index;
|
|
|
|
q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd)) {
|
2008-05-29 16:35:12 +08:00
|
|
|
|
|
|
|
tx_info = &txq->txb[txq->q.read_ptr];
|
2009-11-14 03:56:37 +08:00
|
|
|
iwl_tx_status(priv, tx_info->skb[0]);
|
2008-05-29 16:35:12 +08:00
|
|
|
tx_info->skb[0] = NULL;
|
|
|
|
|
2008-05-29 16:35:13 +08:00
|
|
|
if (priv->cfg->ops->lib->txq_inval_byte_cnt_tbl)
|
|
|
|
priv->cfg->ops->lib->txq_inval_byte_cnt_tbl(priv, txq);
|
|
|
|
|
2009-01-20 07:30:26 +08:00
|
|
|
priv->cfg->ops->lib->txq_free_tfd(priv, txq);
|
2008-05-29 16:35:12 +08:00
|
|
|
nfreed++;
|
|
|
|
}
|
|
|
|
return nfreed;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_tx_queue_reclaim);
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_hcmd_queue_reclaim - Reclaim TX command queue entries already Tx'd
|
|
|
|
*
|
|
|
|
* When FW advances 'R' index, all entries between old and new 'R' index
|
|
|
|
* need to be reclaimed. As result, some free space forms. If there is
|
|
|
|
* enough free space (> low mark), wake the stack that feeds us.
|
|
|
|
*/
|
2008-10-15 03:32:48 +08:00
|
|
|
static void iwl_hcmd_queue_reclaim(struct iwl_priv *priv, int txq_id,
|
|
|
|
int idx, int cmd_idx)
|
2008-05-29 16:35:12 +08:00
|
|
|
{
|
|
|
|
struct iwl_tx_queue *txq = &priv->txq[txq_id];
|
|
|
|
struct iwl_queue *q = &txq->q;
|
|
|
|
int nfreed = 0;
|
|
|
|
|
2008-10-15 03:32:48 +08:00
|
|
|
if ((idx >= q->n_bd) || (iwl_queue_used(q, idx) == 0)) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
|
2008-05-29 16:35:12 +08:00
|
|
|
"is out of range [0-%d] %d %d.\n", txq_id,
|
2008-10-15 03:32:48 +08:00
|
|
|
idx, q->n_bd, q->write_ptr, q->read_ptr);
|
2008-05-29 16:35:12 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-10-15 03:32:48 +08:00
|
|
|
for (idx = iwl_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
|
|
|
|
q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd)) {
|
2008-05-29 16:35:12 +08:00
|
|
|
|
2008-10-15 03:32:48 +08:00
|
|
|
if (nfreed++ > 0) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "HCMD skipped: index (%d) %d %d\n", idx,
|
2008-05-29 16:35:12 +08:00
|
|
|
q->write_ptr, q->read_ptr);
|
|
|
|
queue_work(priv->workqueue, &priv->restart);
|
|
|
|
}
|
2008-08-04 16:00:40 +08:00
|
|
|
|
2008-05-29 16:35:12 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
|
|
|
|
* @rxb: Rx buffer to reclaim
|
|
|
|
*
|
|
|
|
* If an Rx buffer has an async callback associated with it the callback
|
|
|
|
* will be executed. The attached skb (if present) will only be freed
|
|
|
|
* if the callback returns 1
|
|
|
|
*/
|
|
|
|
void iwl_tx_cmd_complete(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
|
|
|
|
{
|
2009-10-09 17:19:45 +08:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-05-29 16:35:12 +08:00
|
|
|
u16 sequence = le16_to_cpu(pkt->hdr.sequence);
|
|
|
|
int txq_id = SEQ_TO_QUEUE(sequence);
|
|
|
|
int index = SEQ_TO_INDEX(sequence);
|
|
|
|
int cmd_index;
|
2008-09-03 11:26:52 +08:00
|
|
|
bool huge = !!(pkt->hdr.sequence & SEQ_HUGE_FRAME);
|
2009-07-25 02:13:05 +08:00
|
|
|
struct iwl_device_cmd *cmd;
|
|
|
|
struct iwl_cmd_meta *meta;
|
2008-05-29 16:35:12 +08:00
|
|
|
|
|
|
|
/* If a Tx command is being handled and it isn't in the actual
|
|
|
|
* command queue then there a command routing bug has been introduced
|
|
|
|
* in the queue management code. */
|
2008-09-24 01:18:43 +08:00
|
|
|
if (WARN(txq_id != IWL_CMD_QUEUE_NUM,
|
2008-11-08 01:58:45 +08:00
|
|
|
"wrong command queue %d, sequence 0x%X readp=%d writep=%d\n",
|
|
|
|
txq_id, sequence,
|
|
|
|
priv->txq[IWL_CMD_QUEUE_NUM].q.read_ptr,
|
|
|
|
priv->txq[IWL_CMD_QUEUE_NUM].q.write_ptr)) {
|
2009-07-25 02:13:08 +08:00
|
|
|
iwl_print_hex_error(priv, pkt, 32);
|
2008-09-24 01:18:43 +08:00
|
|
|
return;
|
2008-11-08 01:58:45 +08:00
|
|
|
}
|
2008-05-29 16:35:12 +08:00
|
|
|
|
|
|
|
cmd_index = get_cmd_index(&priv->txq[IWL_CMD_QUEUE_NUM].q, index, huge);
|
2008-08-04 16:00:40 +08:00
|
|
|
cmd = priv->txq[IWL_CMD_QUEUE_NUM].cmd[cmd_index];
|
2009-07-25 02:13:05 +08:00
|
|
|
meta = &priv->txq[IWL_CMD_QUEUE_NUM].meta[cmd_index];
|
2008-05-29 16:35:12 +08:00
|
|
|
|
2009-10-31 05:36:10 +08:00
|
|
|
pci_unmap_single(priv->pci_dev,
|
|
|
|
pci_unmap_addr(meta, mapping),
|
|
|
|
pci_unmap_len(meta, len),
|
|
|
|
PCI_DMA_BIDIRECTIONAL);
|
|
|
|
|
2008-05-29 16:35:12 +08:00
|
|
|
/* Input error checking is done when commands are added to queue. */
|
2009-07-25 02:13:05 +08:00
|
|
|
if (meta->flags & CMD_WANT_SKB) {
|
2009-10-09 17:19:45 +08:00
|
|
|
meta->source->reply_page = (unsigned long)rxb_addr(rxb);
|
|
|
|
rxb->page = NULL;
|
2009-07-25 02:13:06 +08:00
|
|
|
} else if (meta->callback)
|
2009-10-09 17:19:45 +08:00
|
|
|
meta->callback(priv, cmd, pkt);
|
2008-05-29 16:35:12 +08:00
|
|
|
|
2008-10-15 03:32:48 +08:00
|
|
|
iwl_hcmd_queue_reclaim(priv, txq_id, index, cmd_index);
|
2008-05-29 16:35:12 +08:00
|
|
|
|
2009-07-25 02:13:05 +08:00
|
|
|
if (!(meta->flags & CMD_ASYNC)) {
|
2008-05-29 16:35:12 +08:00
|
|
|
clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
|
|
|
|
wake_up_interruptible(&priv->wait_command_queue);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_tx_cmd_complete);
|
|
|
|
|
2008-05-29 16:35:16 +08:00
|
|
|
/*
|
|
|
|
* Find first available (lowest unused) Tx Queue, mark it "active".
|
|
|
|
* Called only when finding queue for aggregation.
|
|
|
|
* Should never return anything < 7, because they should already
|
|
|
|
* be in use as EDCA AC (0-3), Command (4), HCCA (5, 6).
|
|
|
|
*/
|
|
|
|
static int iwl_txq_ctx_activate_free(struct iwl_priv *priv)
|
|
|
|
{
|
|
|
|
int txq_id;
|
|
|
|
|
|
|
|
for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++)
|
|
|
|
if (!test_and_set_bit(txq_id, &priv->txq_ctx_active_msk))
|
|
|
|
return txq_id;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int iwl_tx_agg_start(struct iwl_priv *priv, const u8 *ra, u16 tid, u16 *ssn)
|
|
|
|
{
|
|
|
|
int sta_id;
|
|
|
|
int tx_fifo;
|
|
|
|
int txq_id;
|
|
|
|
int ret;
|
|
|
|
unsigned long flags;
|
|
|
|
struct iwl_tid_data *tid_data;
|
|
|
|
|
|
|
|
if (likely(tid < ARRAY_SIZE(default_tid_to_tx_fifo)))
|
|
|
|
tx_fifo = default_tid_to_tx_fifo[tid];
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-12-19 10:37:32 +08:00
|
|
|
IWL_WARN(priv, "%s on ra = %pM tid = %d\n",
|
2008-10-28 06:59:26 +08:00
|
|
|
__func__, ra, tid);
|
2008-05-29 16:35:16 +08:00
|
|
|
|
|
|
|
sta_id = iwl_find_station(priv, ra);
|
2009-04-02 05:33:25 +08:00
|
|
|
if (sta_id == IWL_INVALID_STATION) {
|
|
|
|
IWL_ERR(priv, "Start AGG on invalid station\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
return -ENXIO;
|
2009-04-02 05:33:25 +08:00
|
|
|
}
|
2009-07-26 05:34:31 +08:00
|
|
|
if (unlikely(tid >= MAX_TID_COUNT))
|
|
|
|
return -EINVAL;
|
2008-05-29 16:35:16 +08:00
|
|
|
|
|
|
|
if (priv->stations[sta_id].tid[tid].agg.state != IWL_AGG_OFF) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "Start AGG when state is not IWL_AGG_OFF !\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
txq_id = iwl_txq_ctx_activate_free(priv);
|
2009-04-02 05:33:25 +08:00
|
|
|
if (txq_id == -1) {
|
|
|
|
IWL_ERR(priv, "No free aggregation queue available\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
return -ENXIO;
|
2009-04-02 05:33:25 +08:00
|
|
|
}
|
2008-05-29 16:35:16 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->sta_lock, flags);
|
|
|
|
tid_data = &priv->stations[sta_id].tid[tid];
|
|
|
|
*ssn = SEQ_TO_SN(tid_data->seq_number);
|
|
|
|
tid_data->agg.txq_id = txq_id;
|
2009-06-20 04:52:43 +08:00
|
|
|
priv->txq[txq_id].swq_id = iwl_virtual_agg_queue_num(tx_fifo, txq_id);
|
2008-05-29 16:35:16 +08:00
|
|
|
spin_unlock_irqrestore(&priv->sta_lock, flags);
|
|
|
|
|
|
|
|
ret = priv->cfg->ops->lib->txq_agg_enable(priv, txq_id, tx_fifo,
|
|
|
|
sta_id, tid, *ssn);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (tid_data->tfds_in_queue == 0) {
|
2009-04-02 05:33:25 +08:00
|
|
|
IWL_DEBUG_HT(priv, "HW queue is empty\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
tid_data->agg.state = IWL_AGG_ON;
|
2009-11-16 19:00:38 +08:00
|
|
|
ieee80211_start_tx_ba_cb_irqsafe(priv->vif, ra, tid);
|
2008-05-29 16:35:16 +08:00
|
|
|
} else {
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "HW queue is NOT empty: %d packets in HW queue\n",
|
2008-05-29 16:35:16 +08:00
|
|
|
tid_data->tfds_in_queue);
|
|
|
|
tid_data->agg.state = IWL_EMPTYING_HW_QUEUE_ADDBA;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_tx_agg_start);
|
|
|
|
|
|
|
|
int iwl_tx_agg_stop(struct iwl_priv *priv , const u8 *ra, u16 tid)
|
|
|
|
{
|
|
|
|
int tx_fifo_id, txq_id, sta_id, ssn = -1;
|
|
|
|
struct iwl_tid_data *tid_data;
|
|
|
|
int ret, write_ptr, read_ptr;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (!ra) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "ra = NULL\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-08-14 04:30:50 +08:00
|
|
|
if (unlikely(tid >= MAX_TID_COUNT))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-05-29 16:35:16 +08:00
|
|
|
if (likely(tid < ARRAY_SIZE(default_tid_to_tx_fifo)))
|
|
|
|
tx_fifo_id = default_tid_to_tx_fifo[tid];
|
|
|
|
else
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
sta_id = iwl_find_station(priv, ra);
|
|
|
|
|
2009-03-18 12:51:52 +08:00
|
|
|
if (sta_id == IWL_INVALID_STATION) {
|
|
|
|
IWL_ERR(priv, "Invalid station for AGG tid %d\n", tid);
|
2008-05-29 16:35:16 +08:00
|
|
|
return -ENXIO;
|
2009-03-18 12:51:52 +08:00
|
|
|
}
|
2008-05-29 16:35:16 +08:00
|
|
|
|
2009-11-22 19:28:41 +08:00
|
|
|
if (priv->stations[sta_id].tid[tid].agg.state ==
|
|
|
|
IWL_EMPTYING_HW_QUEUE_ADDBA) {
|
|
|
|
IWL_DEBUG_HT(priv, "AGG stop before setup done\n");
|
2009-12-08 05:37:42 +08:00
|
|
|
ieee80211_stop_tx_ba_cb_irqsafe(priv->vif, ra, tid);
|
2009-11-22 19:28:41 +08:00
|
|
|
priv->stations[sta_id].tid[tid].agg.state = IWL_AGG_OFF;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-05-29 16:35:16 +08:00
|
|
|
if (priv->stations[sta_id].tid[tid].agg.state != IWL_AGG_ON)
|
2009-11-22 19:28:41 +08:00
|
|
|
IWL_WARN(priv, "Stopping AGG while state not ON or starting\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
|
|
|
|
tid_data = &priv->stations[sta_id].tid[tid];
|
|
|
|
ssn = (tid_data->seq_number & IEEE80211_SCTL_SEQ) >> 4;
|
|
|
|
txq_id = tid_data->agg.txq_id;
|
|
|
|
write_ptr = priv->txq[txq_id].q.write_ptr;
|
|
|
|
read_ptr = priv->txq[txq_id].q.read_ptr;
|
|
|
|
|
|
|
|
/* The queue is not empty */
|
|
|
|
if (write_ptr != read_ptr) {
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "Stopping a non empty AGG HW QUEUE\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
priv->stations[sta_id].tid[tid].agg.state =
|
|
|
|
IWL_EMPTYING_HW_QUEUE_DELBA;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "HW queue is empty\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
priv->stations[sta_id].tid[tid].agg.state = IWL_AGG_OFF;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
ret = priv->cfg->ops->lib->txq_agg_disable(priv, txq_id, ssn,
|
|
|
|
tx_fifo_id);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2009-11-16 19:00:38 +08:00
|
|
|
ieee80211_stop_tx_ba_cb_irqsafe(priv->vif, ra, tid);
|
2008-05-29 16:35:16 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_tx_agg_stop);
|
|
|
|
|
|
|
|
int iwl_txq_check_empty(struct iwl_priv *priv, int sta_id, u8 tid, int txq_id)
|
|
|
|
{
|
|
|
|
struct iwl_queue *q = &priv->txq[txq_id].q;
|
|
|
|
u8 *addr = priv->stations[sta_id].sta.sta.addr;
|
|
|
|
struct iwl_tid_data *tid_data = &priv->stations[sta_id].tid[tid];
|
|
|
|
|
|
|
|
switch (priv->stations[sta_id].tid[tid].agg.state) {
|
|
|
|
case IWL_EMPTYING_HW_QUEUE_DELBA:
|
|
|
|
/* We are reclaiming the last packet of the */
|
|
|
|
/* aggregated HW queue */
|
2008-10-24 14:48:49 +08:00
|
|
|
if ((txq_id == tid_data->agg.txq_id) &&
|
|
|
|
(q->read_ptr == q->write_ptr)) {
|
2008-05-29 16:35:16 +08:00
|
|
|
u16 ssn = SEQ_TO_SN(tid_data->seq_number);
|
|
|
|
int tx_fifo = default_tid_to_tx_fifo[tid];
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "HW queue empty: continue DELBA flow\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
priv->cfg->ops->lib->txq_agg_disable(priv, txq_id,
|
|
|
|
ssn, tx_fifo);
|
|
|
|
tid_data->agg.state = IWL_AGG_OFF;
|
2009-11-16 19:00:38 +08:00
|
|
|
ieee80211_stop_tx_ba_cb_irqsafe(priv->vif, addr, tid);
|
2008-05-29 16:35:16 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case IWL_EMPTYING_HW_QUEUE_ADDBA:
|
|
|
|
/* We are reclaiming the last packet of the queue */
|
|
|
|
if (tid_data->tfds_in_queue == 0) {
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_HT(priv, "HW queue empty: continue ADDBA flow\n");
|
2008-05-29 16:35:16 +08:00
|
|
|
tid_data->agg.state = IWL_AGG_ON;
|
2009-11-16 19:00:38 +08:00
|
|
|
ieee80211_start_tx_ba_cb_irqsafe(priv->vif, addr, tid);
|
2008-05-29 16:35:16 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_txq_check_empty);
|
|
|
|
|
2008-06-30 17:23:11 +08:00
|
|
|
/**
|
|
|
|
* iwl_tx_status_reply_compressed_ba - Update tx status from block-ack
|
|
|
|
*
|
|
|
|
* Go through block-ack's bitmap of ACK'd frames, update driver's record of
|
|
|
|
* ACK vs. not. This gets sent to mac80211, then to rate scaling algo.
|
|
|
|
*/
|
|
|
|
static int iwl_tx_status_reply_compressed_ba(struct iwl_priv *priv,
|
|
|
|
struct iwl_ht_agg *agg,
|
|
|
|
struct iwl_compressed_ba_resp *ba_resp)
|
|
|
|
|
|
|
|
{
|
|
|
|
int i, sh, ack;
|
|
|
|
u16 seq_ctl = le16_to_cpu(ba_resp->seq_ctl);
|
|
|
|
u16 scd_flow = le16_to_cpu(ba_resp->scd_flow);
|
|
|
|
u64 bitmap;
|
|
|
|
int successes = 0;
|
|
|
|
struct ieee80211_tx_info *info;
|
|
|
|
|
|
|
|
if (unlikely(!agg->wait_for_ba)) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv, "Received BA when not expected\n");
|
2008-06-30 17:23:11 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Mark that the expected block-ack response arrived */
|
|
|
|
agg->wait_for_ba = 0;
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX_REPLY(priv, "BA %d %d\n", agg->start_idx, ba_resp->seq_ctl);
|
2008-06-30 17:23:11 +08:00
|
|
|
|
|
|
|
/* Calculate shift to align block-ack bits with our Tx window bits */
|
2008-10-24 14:48:49 +08:00
|
|
|
sh = agg->start_idx - SEQ_TO_INDEX(seq_ctl >> 4);
|
2008-06-30 17:23:11 +08:00
|
|
|
if (sh < 0) /* tbw something is wrong with indices */
|
|
|
|
sh += 0x100;
|
|
|
|
|
|
|
|
/* don't use 64-bit values for now */
|
|
|
|
bitmap = le64_to_cpu(ba_resp->bitmap) >> sh;
|
|
|
|
|
|
|
|
if (agg->frame_count > (64 - sh)) {
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX_REPLY(priv, "more frames than bitmap size");
|
2008-06-30 17:23:11 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check for success or failure according to the
|
|
|
|
* transmitted bitmap and block-ack bitmap */
|
|
|
|
bitmap &= agg->bitmap;
|
|
|
|
|
|
|
|
/* For each frame attempted in aggregation,
|
|
|
|
* update driver's record of tx frame's status. */
|
|
|
|
for (i = 0; i < agg->frame_count ; i++) {
|
2008-07-18 13:53:09 +08:00
|
|
|
ack = bitmap & (1ULL << i);
|
2008-06-30 17:23:11 +08:00
|
|
|
successes += !!ack;
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX_REPLY(priv, "%s ON i=%d idx=%d raw=%d\n",
|
2008-11-13 05:14:08 +08:00
|
|
|
ack ? "ACK" : "NACK", i, (agg->start_idx + i) & 0xff,
|
2008-06-30 17:23:11 +08:00
|
|
|
agg->start_idx + i);
|
|
|
|
}
|
|
|
|
|
|
|
|
info = IEEE80211_SKB_CB(priv->txq[scd_flow].txb[agg->start_idx].skb[0]);
|
|
|
|
memset(&info->status, 0, sizeof(info->status));
|
2009-09-18 01:43:49 +08:00
|
|
|
info->flags |= IEEE80211_TX_STAT_ACK;
|
2008-06-30 17:23:11 +08:00
|
|
|
info->flags |= IEEE80211_TX_STAT_AMPDU;
|
|
|
|
info->status.ampdu_ack_map = successes;
|
|
|
|
info->status.ampdu_ack_len = agg->frame_count;
|
|
|
|
iwl_hwrate_to_tx_control(priv, agg->rate_n_flags, info);
|
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX_REPLY(priv, "Bitmap %llx\n", (unsigned long long)bitmap);
|
2008-06-30 17:23:11 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* iwl_rx_reply_compressed_ba - Handler for REPLY_COMPRESSED_BA
|
|
|
|
*
|
|
|
|
* Handles block-acknowledge notification from device, which reports success
|
|
|
|
* of frames sent via aggregation.
|
|
|
|
*/
|
|
|
|
void iwl_rx_reply_compressed_ba(struct iwl_priv *priv,
|
|
|
|
struct iwl_rx_mem_buffer *rxb)
|
|
|
|
{
|
2009-10-09 17:19:45 +08:00
|
|
|
struct iwl_rx_packet *pkt = rxb_addr(rxb);
|
2008-06-30 17:23:11 +08:00
|
|
|
struct iwl_compressed_ba_resp *ba_resp = &pkt->u.compressed_ba;
|
|
|
|
struct iwl_tx_queue *txq = NULL;
|
|
|
|
struct iwl_ht_agg *agg;
|
2008-10-24 14:48:49 +08:00
|
|
|
int index;
|
|
|
|
int sta_id;
|
|
|
|
int tid;
|
2008-06-30 17:23:11 +08:00
|
|
|
|
|
|
|
/* "flow" corresponds to Tx queue */
|
|
|
|
u16 scd_flow = le16_to_cpu(ba_resp->scd_flow);
|
|
|
|
|
|
|
|
/* "ssn" is start of block-ack Tx window, corresponds to index
|
|
|
|
* (in Tx queue's circular buffer) of first TFD/frame in window */
|
|
|
|
u16 ba_resp_scd_ssn = le16_to_cpu(ba_resp->scd_ssn);
|
|
|
|
|
|
|
|
if (scd_flow >= priv->hw_params.max_txq_num) {
|
2008-12-19 10:37:33 +08:00
|
|
|
IWL_ERR(priv,
|
|
|
|
"BUG_ON scd_flow is bigger than number of queues\n");
|
2008-06-30 17:23:11 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
txq = &priv->txq[scd_flow];
|
2008-10-24 14:48:49 +08:00
|
|
|
sta_id = ba_resp->sta_id;
|
|
|
|
tid = ba_resp->tid;
|
|
|
|
agg = &priv->stations[sta_id].tid[tid].agg;
|
2008-06-30 17:23:11 +08:00
|
|
|
|
|
|
|
/* Find index just before block-ack window */
|
|
|
|
index = iwl_queue_dec_wrap(ba_resp_scd_ssn & 0xff, txq->q.n_bd);
|
|
|
|
|
|
|
|
/* TODO: Need to get this copy more safely - now good for debug */
|
|
|
|
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX_REPLY(priv, "REPLY_COMPRESSED_BA [%d] Received from %pM, "
|
2008-06-30 17:23:11 +08:00
|
|
|
"sta_id = %d\n",
|
|
|
|
agg->wait_for_ba,
|
2008-10-28 06:59:26 +08:00
|
|
|
(u8 *) &ba_resp->sta_addr_lo32,
|
2008-06-30 17:23:11 +08:00
|
|
|
ba_resp->sta_id);
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX_REPLY(priv, "TID = %d, SeqCtl = %d, bitmap = 0x%llx, scd_flow = "
|
2008-06-30 17:23:11 +08:00
|
|
|
"%d, scd_ssn = %d\n",
|
|
|
|
ba_resp->tid,
|
|
|
|
ba_resp->seq_ctl,
|
|
|
|
(unsigned long long)le64_to_cpu(ba_resp->bitmap),
|
|
|
|
ba_resp->scd_flow,
|
|
|
|
ba_resp->scd_ssn);
|
2009-01-28 06:27:56 +08:00
|
|
|
IWL_DEBUG_TX_REPLY(priv, "DAT start_idx = %d, bitmap = 0x%llx \n",
|
2008-06-30 17:23:11 +08:00
|
|
|
agg->start_idx,
|
|
|
|
(unsigned long long)agg->bitmap);
|
|
|
|
|
|
|
|
/* Update driver's record of ACK vs. not for each frame in window */
|
|
|
|
iwl_tx_status_reply_compressed_ba(priv, agg, ba_resp);
|
|
|
|
|
|
|
|
/* Release all TFDs before the SSN, i.e. all TFDs in front of
|
|
|
|
* block-ack window (we assume that they've been successfully
|
|
|
|
* transmitted ... if not, it's too late anyway). */
|
|
|
|
if (txq->q.read_ptr != (ba_resp_scd_ssn & 0xff)) {
|
|
|
|
/* calculate mac80211 ampdu sw queue to wake */
|
|
|
|
int freed = iwl_tx_queue_reclaim(priv, scd_flow, index);
|
2008-10-24 14:48:49 +08:00
|
|
|
priv->stations[sta_id].tid[tid].tfds_in_queue -= freed;
|
|
|
|
|
|
|
|
if ((iwl_queue_space(&txq->q) > txq->q.low_mark) &&
|
|
|
|
priv->mac80211_registered &&
|
|
|
|
(agg->state != IWL_EMPTYING_HW_QUEUE_DELBA))
|
2009-03-24 00:28:42 +08:00
|
|
|
iwl_wake_queue(priv, txq->swq_id);
|
2008-10-24 14:48:49 +08:00
|
|
|
|
|
|
|
iwl_txq_check_empty(priv, sta_id, tid, scd_flow);
|
2008-06-30 17:23:11 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_rx_reply_compressed_ba);
|
|
|
|
|
2008-07-02 18:17:06 +08:00
|
|
|
#ifdef CONFIG_IWLWIFI_DEBUG
|
2008-05-29 16:35:08 +08:00
|
|
|
#define TX_STATUS_ENTRY(x) case TX_STATUS_FAIL_ ## x: return #x
|
|
|
|
|
|
|
|
const char *iwl_get_tx_fail_reason(u32 status)
|
|
|
|
{
|
|
|
|
switch (status & TX_STATUS_MSK) {
|
|
|
|
case TX_STATUS_SUCCESS:
|
|
|
|
return "SUCCESS";
|
|
|
|
TX_STATUS_ENTRY(SHORT_LIMIT);
|
|
|
|
TX_STATUS_ENTRY(LONG_LIMIT);
|
|
|
|
TX_STATUS_ENTRY(FIFO_UNDERRUN);
|
|
|
|
TX_STATUS_ENTRY(MGMNT_ABORT);
|
|
|
|
TX_STATUS_ENTRY(NEXT_FRAG);
|
|
|
|
TX_STATUS_ENTRY(LIFE_EXPIRE);
|
|
|
|
TX_STATUS_ENTRY(DEST_PS);
|
|
|
|
TX_STATUS_ENTRY(ABORTED);
|
|
|
|
TX_STATUS_ENTRY(BT_RETRY);
|
|
|
|
TX_STATUS_ENTRY(STA_INVALID);
|
|
|
|
TX_STATUS_ENTRY(FRAG_DROPPED);
|
|
|
|
TX_STATUS_ENTRY(TID_DISABLE);
|
|
|
|
TX_STATUS_ENTRY(FRAME_FLUSHED);
|
|
|
|
TX_STATUS_ENTRY(INSUFFICIENT_CF_POLL);
|
|
|
|
TX_STATUS_ENTRY(TX_LOCKED);
|
|
|
|
TX_STATUS_ENTRY(NO_BEACON_ON_RADAR);
|
|
|
|
}
|
|
|
|
|
|
|
|
return "UNKNOWN";
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(iwl_get_tx_fail_reason);
|
|
|
|
#endif /* CONFIG_IWLWIFI_DEBUG */
|