blob: 8f20065e6dacd58b3b85881c227226572980569b [file] [log] [blame]
Ron Rindjunsky1053d352008-05-05 10:22:43 +08001/******************************************************************************
2 *
Wey-Yi Guy901069c2011-04-05 09:42:00 -07003 * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
Ron Rindjunsky1053d352008-05-05 10:22:43 +08004 *
5 * Portions of this file are derived from the ipw3945 project, as well
6 * as portions of the ieee80211 subsystem header files.
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of version 2 of the GNU General Public License as
10 * published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * more details.
16 *
17 * You should have received a copy of the GNU General Public License along with
18 * this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
20 *
21 * The full GNU General Public License is included in this distribution in the
22 * file called LICENSE.
23 *
24 * Contact Information:
Winkler, Tomas759ef892008-12-09 11:28:58 -080025 * Intel Linux Wireless <ilw@linux.intel.com>
Ron Rindjunsky1053d352008-05-05 10:22:43 +080026 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
27 *
28 *****************************************************************************/
29
Tomas Winklerfd4abac2008-05-15 13:54:07 +080030#include <linux/etherdevice.h>
Alexey Dobriyand43c36d2009-10-07 17:09:06 +040031#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090032#include <linux/slab.h>
Ron Rindjunsky1053d352008-05-05 10:22:43 +080033#include <net/mac80211.h>
34#include "iwl-eeprom.h"
Johannes Berg214d14d2011-05-04 07:50:44 -070035#include "iwl-agn.h"
Ron Rindjunsky1053d352008-05-05 10:22:43 +080036#include "iwl-dev.h"
37#include "iwl-core.h"
38#include "iwl-sta.h"
39#include "iwl-io.h"
40#include "iwl-helpers.h"
41
Tomas Winklerfd4abac2008-05-15 13:54:07 +080042/**
43 * iwl_txq_update_write_ptr - Send new write index to hardware
44 */
Abhijeet Kolekar7bfedc52010-02-03 13:47:56 -080045void iwl_txq_update_write_ptr(struct iwl_priv *priv, struct iwl_tx_queue *txq)
Tomas Winklerfd4abac2008-05-15 13:54:07 +080046{
47 u32 reg = 0;
Tomas Winklerfd4abac2008-05-15 13:54:07 +080048 int txq_id = txq->q.id;
49
50 if (txq->need_update == 0)
Abhijeet Kolekar7bfedc52010-02-03 13:47:56 -080051 return;
Tomas Winklerfd4abac2008-05-15 13:54:07 +080052
Wey-Yi Guyf81c1f42010-11-10 09:56:50 -080053 if (priv->cfg->base_params->shadow_reg_enable) {
54 /* shadow register enabled */
Tomas Winklerfd4abac2008-05-15 13:54:07 +080055 iwl_write32(priv, HBUS_TARG_WRPTR,
56 txq->q.write_ptr | (txq_id << 8));
Wey-Yi Guyf81c1f42010-11-10 09:56:50 -080057 } else {
58 /* if we're trying to save power */
59 if (test_bit(STATUS_POWER_PMI, &priv->status)) {
60 /* wake up nic if it's powered down ...
61 * uCode will wake up, and interrupt us again, so next
62 * time we'll skip this part. */
63 reg = iwl_read32(priv, CSR_UCODE_DRV_GP1);
Tomas Winklerfd4abac2008-05-15 13:54:07 +080064
Wey-Yi Guyf81c1f42010-11-10 09:56:50 -080065 if (reg & CSR_UCODE_DRV_GP1_BIT_MAC_SLEEP) {
66 IWL_DEBUG_INFO(priv,
67 "Tx queue %d requesting wakeup,"
68 " GP1 = 0x%x\n", txq_id, reg);
69 iwl_set_bit(priv, CSR_GP_CNTRL,
70 CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
71 return;
72 }
73
74 iwl_write_direct32(priv, HBUS_TARG_WRPTR,
75 txq->q.write_ptr | (txq_id << 8));
76
77 /*
78 * else not in power-save mode,
79 * uCode will never sleep when we're
80 * trying to tx (during RFKILL, we're not trying to tx).
81 */
82 } else
83 iwl_write32(priv, HBUS_TARG_WRPTR,
84 txq->q.write_ptr | (txq_id << 8));
85 }
Tomas Winklerfd4abac2008-05-15 13:54:07 +080086 txq->need_update = 0;
Tomas Winklerfd4abac2008-05-15 13:54:07 +080087}
Tomas Winklerfd4abac2008-05-15 13:54:07 +080088
Johannes Berg214d14d2011-05-04 07:50:44 -070089static inline dma_addr_t iwl_tfd_tb_get_addr(struct iwl_tfd *tfd, u8 idx)
90{
91 struct iwl_tfd_tb *tb = &tfd->tbs[idx];
92
93 dma_addr_t addr = get_unaligned_le32(&tb->lo);
94 if (sizeof(dma_addr_t) > sizeof(u32))
95 addr |=
96 ((dma_addr_t)(le16_to_cpu(tb->hi_n_len) & 0xF) << 16) << 16;
97
98 return addr;
99}
100
101static inline u16 iwl_tfd_tb_get_len(struct iwl_tfd *tfd, u8 idx)
102{
103 struct iwl_tfd_tb *tb = &tfd->tbs[idx];
104
105 return le16_to_cpu(tb->hi_n_len) >> 4;
106}
107
108static inline void iwl_tfd_set_tb(struct iwl_tfd *tfd, u8 idx,
109 dma_addr_t addr, u16 len)
110{
111 struct iwl_tfd_tb *tb = &tfd->tbs[idx];
112 u16 hi_n_len = len << 4;
113
114 put_unaligned_le32(addr, &tb->lo);
115 if (sizeof(dma_addr_t) > sizeof(u32))
116 hi_n_len |= ((addr >> 16) >> 16) & 0xF;
117
118 tb->hi_n_len = cpu_to_le16(hi_n_len);
119
120 tfd->num_tbs = idx + 1;
121}
122
123static inline u8 iwl_tfd_get_num_tbs(struct iwl_tfd *tfd)
124{
125 return tfd->num_tbs & 0x1f;
126}
127
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700128static void iwlagn_unmap_tfd(struct iwl_priv *priv, struct iwl_cmd_meta *meta,
129 struct iwl_tfd *tfd)
Johannes Berg214d14d2011-05-04 07:50:44 -0700130{
Johannes Berg214d14d2011-05-04 07:50:44 -0700131 struct pci_dev *dev = priv->pci_dev;
Johannes Berg214d14d2011-05-04 07:50:44 -0700132 int i;
133 int num_tbs;
134
Johannes Berg214d14d2011-05-04 07:50:44 -0700135 /* Sanity check on number of chunks */
136 num_tbs = iwl_tfd_get_num_tbs(tfd);
137
138 if (num_tbs >= IWL_NUM_OF_TBS) {
139 IWL_ERR(priv, "Too many chunks: %i\n", num_tbs);
140 /* @todo issue fatal error, it is quite serious situation */
141 return;
142 }
143
144 /* Unmap tx_cmd */
145 if (num_tbs)
146 pci_unmap_single(dev,
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700147 dma_unmap_addr(meta, mapping),
148 dma_unmap_len(meta, len),
Johannes Berg214d14d2011-05-04 07:50:44 -0700149 PCI_DMA_BIDIRECTIONAL);
150
151 /* Unmap chunks, if any. */
152 for (i = 1; i < num_tbs; i++)
153 pci_unmap_single(dev, iwl_tfd_tb_get_addr(tfd, i),
154 iwl_tfd_tb_get_len(tfd, i), PCI_DMA_TODEVICE);
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700155}
156
157/**
158 * iwlagn_txq_free_tfd - Free all chunks referenced by TFD [txq->q.read_ptr]
159 * @priv - driver private data
160 * @txq - tx queue
161 *
162 * Does NOT advance any TFD circular buffer read/write indexes
163 * Does NOT free the TFD itself (which is within circular buffer)
164 */
165void iwlagn_txq_free_tfd(struct iwl_priv *priv, struct iwl_tx_queue *txq)
166{
167 struct iwl_tfd *tfd_tmp = txq->tfds;
168 int index = txq->q.read_ptr;
169
170 iwlagn_unmap_tfd(priv, &txq->meta[index], &tfd_tmp[index]);
Johannes Berg214d14d2011-05-04 07:50:44 -0700171
172 /* free SKB */
173 if (txq->txb) {
174 struct sk_buff *skb;
175
176 skb = txq->txb[txq->q.read_ptr].skb;
177
178 /* can be called from irqs-disabled context */
179 if (skb) {
180 dev_kfree_skb_any(skb);
181 txq->txb[txq->q.read_ptr].skb = NULL;
182 }
183 }
184}
185
186int iwlagn_txq_attach_buf_to_tfd(struct iwl_priv *priv,
187 struct iwl_tx_queue *txq,
188 dma_addr_t addr, u16 len,
Johannes Berg4c42db02011-05-04 07:50:48 -0700189 u8 reset)
Johannes Berg214d14d2011-05-04 07:50:44 -0700190{
191 struct iwl_queue *q;
192 struct iwl_tfd *tfd, *tfd_tmp;
193 u32 num_tbs;
194
195 q = &txq->q;
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700196 tfd_tmp = txq->tfds;
Johannes Berg214d14d2011-05-04 07:50:44 -0700197 tfd = &tfd_tmp[q->write_ptr];
198
199 if (reset)
200 memset(tfd, 0, sizeof(*tfd));
201
202 num_tbs = iwl_tfd_get_num_tbs(tfd);
203
204 /* Each TFD can point to a maximum 20 Tx buffers */
205 if (num_tbs >= IWL_NUM_OF_TBS) {
206 IWL_ERR(priv, "Error can not send more than %d chunks\n",
207 IWL_NUM_OF_TBS);
208 return -EINVAL;
209 }
210
211 if (WARN_ON(addr & ~DMA_BIT_MASK(36)))
212 return -EINVAL;
213
214 if (unlikely(addr & ~IWL_TX_DMA_MASK))
215 IWL_ERR(priv, "Unaligned address = %llx\n",
216 (unsigned long long)addr);
217
218 iwl_tfd_set_tb(tfd, num_tbs, addr, len);
219
220 return 0;
221}
222
223/*
224 * Tell nic where to find circular buffer of Tx Frame Descriptors for
225 * given Tx queue, and enable the DMA channel used for that queue.
226 *
227 * supports up to 16 Tx queues in DRAM, mapped to up to 8 Tx DMA
228 * channels supported in hardware.
229 */
230static int iwlagn_tx_queue_init(struct iwl_priv *priv, struct iwl_tx_queue *txq)
231{
232 int txq_id = txq->q.id;
233
234 /* Circular buffer (TFD queue in DRAM) physical base address */
235 iwl_write_direct32(priv, FH_MEM_CBBC_QUEUE(txq_id),
236 txq->q.dma_addr >> 8);
237
238 return 0;
239}
240
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800241/**
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100242 * iwl_tx_queue_unmap - Unmap any remaining DMA mappings and free skb's
243 */
244void iwl_tx_queue_unmap(struct iwl_priv *priv, int txq_id)
245{
246 struct iwl_tx_queue *txq = &priv->txq[txq_id];
247 struct iwl_queue *q = &txq->q;
248
249 if (q->n_bd == 0)
250 return;
251
252 while (q->write_ptr != q->read_ptr) {
Johannes Berg214d14d2011-05-04 07:50:44 -0700253 iwlagn_txq_free_tfd(priv, txq);
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100254 q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd);
255 }
256}
257
258/**
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800259 * iwl_tx_queue_free - Deallocate DMA queue.
260 * @txq: Transmit queue to deallocate.
261 *
262 * Empty queue by removing and destroying all BD's.
263 * Free all buffers.
264 * 0-fill, but do not free "txq" descriptor structure.
265 */
Samuel Ortiza8e74e22009-01-23 13:45:14 -0800266void iwl_tx_queue_free(struct iwl_priv *priv, int txq_id)
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800267{
Gregory Greenmanda99c4b2008-08-04 16:00:40 +0800268 struct iwl_tx_queue *txq = &priv->txq[txq_id];
Stanislaw Gruszkaf36d04a2010-02-10 05:07:45 -0800269 struct device *dev = &priv->pci_dev->dev;
Wey-Yi Guy71c55d92009-10-23 13:42:31 -0700270 int i;
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800271
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100272 iwl_tx_queue_unmap(priv, txq_id);
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800273
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800274 /* De-alloc array of command/tx buffers */
Tomas Winkler961ba602008-10-14 12:32:44 -0700275 for (i = 0; i < TFD_TX_CMD_SLOTS; i++)
Gregory Greenmanda99c4b2008-08-04 16:00:40 +0800276 kfree(txq->cmd[i]);
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800277
278 /* De-alloc circular buffer of TFDs */
279 if (txq->q.n_bd)
Stanislaw Gruszkaf36d04a2010-02-10 05:07:45 -0800280 dma_free_coherent(dev, priv->hw_params.tfd_size *
281 txq->q.n_bd, txq->tfds, txq->q.dma_addr);
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800282
283 /* De-alloc array of per-TFD driver data */
284 kfree(txq->txb);
285 txq->txb = NULL;
286
Johannes Bergc2acea82009-07-24 11:13:05 -0700287 /* deallocate arrays */
288 kfree(txq->cmd);
289 kfree(txq->meta);
290 txq->cmd = NULL;
291 txq->meta = NULL;
292
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800293 /* 0-fill queue descriptor structure */
294 memset(txq, 0, sizeof(*txq));
295}
Tomas Winkler961ba602008-10-14 12:32:44 -0700296
297/**
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100298 * iwl_cmd_queue_unmap - Unmap any remaining DMA mappings from command queue
299 */
300void iwl_cmd_queue_unmap(struct iwl_priv *priv)
301{
302 struct iwl_tx_queue *txq = &priv->txq[priv->cmd_queue];
303 struct iwl_queue *q = &txq->q;
304 int i;
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100305
306 if (q->n_bd == 0)
307 return;
308
309 while (q->read_ptr != q->write_ptr) {
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700310 i = get_cmd_index(q, q->read_ptr);
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100311
Stanislaw Gruszka3598e172011-03-31 17:36:26 +0200312 if (txq->meta[i].flags & CMD_MAPPED) {
Johannes Berg1107a082011-06-27 07:48:52 -0700313 iwlagn_unmap_tfd(priv, &txq->meta[i], &txq->tfds[i]);
Stanislaw Gruszka3598e172011-03-31 17:36:26 +0200314 txq->meta[i].flags = 0;
315 }
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100316
Stanislaw Gruszka3598e172011-03-31 17:36:26 +0200317 q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd);
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100318 }
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100319}
320
321/**
Tomas Winkler961ba602008-10-14 12:32:44 -0700322 * iwl_cmd_queue_free - Deallocate DMA queue.
323 * @txq: Transmit queue to deallocate.
324 *
325 * Empty queue by removing and destroying all BD's.
326 * Free all buffers.
327 * 0-fill, but do not free "txq" descriptor structure.
328 */
Abhijeet Kolekar3e5d2382009-03-17 21:51:49 -0700329void iwl_cmd_queue_free(struct iwl_priv *priv)
Tomas Winkler961ba602008-10-14 12:32:44 -0700330{
Johannes Berg13bb9482010-08-23 10:46:33 +0200331 struct iwl_tx_queue *txq = &priv->txq[priv->cmd_queue];
Stanislaw Gruszkaf36d04a2010-02-10 05:07:45 -0800332 struct device *dev = &priv->pci_dev->dev;
Wey-Yi Guy71c55d92009-10-23 13:42:31 -0700333 int i;
Tomas Winkler961ba602008-10-14 12:32:44 -0700334
Stanislaw Gruszka387f3382011-02-28 14:33:13 +0100335 iwl_cmd_queue_unmap(priv);
Zhu Yidd487442010-03-22 02:28:41 -0700336
Tomas Winkler961ba602008-10-14 12:32:44 -0700337 /* De-alloc array of command/tx buffers */
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700338 for (i = 0; i < TFD_CMD_SLOTS; i++)
Tomas Winkler961ba602008-10-14 12:32:44 -0700339 kfree(txq->cmd[i]);
340
341 /* De-alloc circular buffer of TFDs */
342 if (txq->q.n_bd)
Stanislaw Gruszkaf36d04a2010-02-10 05:07:45 -0800343 dma_free_coherent(dev, priv->hw_params.tfd_size * txq->q.n_bd,
344 txq->tfds, txq->q.dma_addr);
Tomas Winkler961ba602008-10-14 12:32:44 -0700345
Reinette Chatre28142982009-09-25 14:24:22 -0700346 /* deallocate arrays */
347 kfree(txq->cmd);
348 kfree(txq->meta);
349 txq->cmd = NULL;
350 txq->meta = NULL;
351
Tomas Winkler961ba602008-10-14 12:32:44 -0700352 /* 0-fill queue descriptor structure */
353 memset(txq, 0, sizeof(*txq));
354}
Abhijeet Kolekar3e5d2382009-03-17 21:51:49 -0700355
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800356/*************** DMA-QUEUE-GENERAL-FUNCTIONS *****
357 * DMA services
358 *
359 * Theory of operation
360 *
361 * A Tx or Rx queue resides in host DRAM, and is comprised of a circular buffer
362 * of buffer descriptors, each of which points to one or more data buffers for
363 * the device to read from or fill. Driver and device exchange status of each
364 * queue via "read" and "write" pointers. Driver keeps minimum of 2 empty
365 * entries in each circular buffer, to protect against confusing empty and full
366 * queue states.
367 *
368 * The device reads or writes the data in the queues via the device's several
369 * DMA/FIFO channels. Each queue is mapped to a single DMA channel.
370 *
371 * For Tx queue, there are low mark and high mark limits. If, after queuing
372 * the packet for Tx, free space become < low mark, Tx queue stopped. When
373 * reclaiming packets (on 'tx done IRQ), if free space become > high mark,
374 * Tx queue resumed.
375 *
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800376 ***************************************************/
377
378int iwl_queue_space(const struct iwl_queue *q)
379{
380 int s = q->read_ptr - q->write_ptr;
381
382 if (q->read_ptr > q->write_ptr)
383 s -= q->n_bd;
384
385 if (s <= 0)
386 s += q->n_window;
387 /* keep some reserve to not confuse empty and full situations */
388 s -= 2;
389 if (s < 0)
390 s = 0;
391 return s;
392}
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800393
394
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800395/**
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800396 * iwl_queue_init - Initialize queue's high/low-water and read/write indexes
397 */
Tomas Winkler443cfd42008-05-15 13:53:57 +0800398static int iwl_queue_init(struct iwl_priv *priv, struct iwl_queue *q,
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800399 int count, int slots_num, u32 id)
400{
401 q->n_bd = count;
402 q->n_window = slots_num;
403 q->id = id;
404
405 /* count must be power-of-two size, otherwise iwl_queue_inc_wrap
406 * and iwl_queue_dec_wrap are broken. */
Johannes Berg3e41ace2011-04-18 09:12:37 -0700407 if (WARN_ON(!is_power_of_2(count)))
408 return -EINVAL;
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800409
410 /* slots_num must be power-of-two size, otherwise
411 * get_cmd_index is broken. */
Johannes Berg3e41ace2011-04-18 09:12:37 -0700412 if (WARN_ON(!is_power_of_2(slots_num)))
413 return -EINVAL;
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800414
415 q->low_mark = q->n_window / 4;
416 if (q->low_mark < 4)
417 q->low_mark = 4;
418
419 q->high_mark = q->n_window / 8;
420 if (q->high_mark < 2)
421 q->high_mark = 2;
422
423 q->write_ptr = q->read_ptr = 0;
424
425 return 0;
426}
427
428/**
429 * iwl_tx_queue_alloc - Alloc driver data and TFD CB for one Tx/cmd queue
430 */
431static int iwl_tx_queue_alloc(struct iwl_priv *priv,
Ron Rindjunsky16466902008-05-05 10:22:50 +0800432 struct iwl_tx_queue *txq, u32 id)
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800433{
Stanislaw Gruszkaf36d04a2010-02-10 05:07:45 -0800434 struct device *dev = &priv->pci_dev->dev;
Winkler, Tomas3978e5b2009-01-23 13:45:23 -0800435 size_t tfd_sz = priv->hw_params.tfd_size * TFD_QUEUE_SIZE_MAX;
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800436
437 /* Driver private data, only for Tx (not command) queues,
438 * not shared with device. */
Johannes Berg13bb9482010-08-23 10:46:33 +0200439 if (id != priv->cmd_queue) {
Johannes Berg519c7c42010-05-17 02:37:33 -0700440 txq->txb = kzalloc(sizeof(txq->txb[0]) *
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800441 TFD_QUEUE_SIZE_MAX, GFP_KERNEL);
442 if (!txq->txb) {
Winkler, Tomas15b16872008-12-19 10:37:33 +0800443 IWL_ERR(priv, "kmalloc for auxiliary BD "
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800444 "structures failed\n");
445 goto error;
446 }
Winkler, Tomas3978e5b2009-01-23 13:45:23 -0800447 } else {
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800448 txq->txb = NULL;
Winkler, Tomas3978e5b2009-01-23 13:45:23 -0800449 }
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800450
451 /* Circular buffer of transmit frame descriptors (TFDs),
452 * shared with device */
Stanislaw Gruszkaf36d04a2010-02-10 05:07:45 -0800453 txq->tfds = dma_alloc_coherent(dev, tfd_sz, &txq->q.dma_addr,
454 GFP_KERNEL);
Tomas Winkler499b1882008-10-14 12:32:48 -0700455 if (!txq->tfds) {
Winkler, Tomas3978e5b2009-01-23 13:45:23 -0800456 IWL_ERR(priv, "pci_alloc_consistent(%zd) failed\n", tfd_sz);
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800457 goto error;
458 }
459 txq->q.id = id;
460
461 return 0;
462
463 error:
464 kfree(txq->txb);
465 txq->txb = NULL;
466
467 return -ENOMEM;
468}
469
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800470/**
471 * iwl_tx_queue_init - Allocate and initialize one tx/cmd queue
472 */
Samuel Ortiza8e74e22009-01-23 13:45:14 -0800473int iwl_tx_queue_init(struct iwl_priv *priv, struct iwl_tx_queue *txq,
474 int slots_num, u32 txq_id)
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800475{
Gregory Greenmanda99c4b2008-08-04 16:00:40 +0800476 int i, len;
Tomas Winkler73b7d742008-09-03 11:18:48 +0800477 int ret;
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800478
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700479 txq->meta = kzalloc(sizeof(struct iwl_cmd_meta) * slots_num,
Johannes Bergc2acea82009-07-24 11:13:05 -0700480 GFP_KERNEL);
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700481 txq->cmd = kzalloc(sizeof(struct iwl_device_cmd *) * slots_num,
Johannes Bergc2acea82009-07-24 11:13:05 -0700482 GFP_KERNEL);
483
484 if (!txq->meta || !txq->cmd)
485 goto out_free_arrays;
486
487 len = sizeof(struct iwl_device_cmd);
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700488 for (i = 0; i < slots_num; i++) {
John W. Linville49898852008-09-02 15:07:18 -0400489 txq->cmd[i] = kmalloc(len, GFP_KERNEL);
Gregory Greenmanda99c4b2008-08-04 16:00:40 +0800490 if (!txq->cmd[i])
Tomas Winkler73b7d742008-09-03 11:18:48 +0800491 goto err;
Gregory Greenmanda99c4b2008-08-04 16:00:40 +0800492 }
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800493
494 /* Alloc driver data array and TFD circular buffer */
Tomas Winkler73b7d742008-09-03 11:18:48 +0800495 ret = iwl_tx_queue_alloc(priv, txq, txq_id);
496 if (ret)
497 goto err;
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800498
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800499 txq->need_update = 0;
500
Johannes Berg1a716552009-11-06 14:52:51 -0800501 /*
Johannes Bergea9b3072010-11-10 18:25:45 -0800502 * For the default queues 0-3, set up the swq_id
503 * already -- all others need to get one later
504 * (if they need one at all).
Johannes Berg1a716552009-11-06 14:52:51 -0800505 */
Johannes Bergea9b3072010-11-10 18:25:45 -0800506 if (txq_id < 4)
507 iwl_set_swq_id(txq, txq_id, txq_id);
Johannes Berg45af8192009-06-19 13:52:43 -0700508
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800509 /* TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
510 * iwl_queue_inc_wrap and iwl_queue_dec_wrap are broken. */
511 BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
512
513 /* Initialize queue's high/low-water marks, and head/tail indexes */
Johannes Berg3e41ace2011-04-18 09:12:37 -0700514 ret = iwl_queue_init(priv, &txq->q, TFD_QUEUE_SIZE_MAX, slots_num, txq_id);
515 if (ret)
516 return ret;
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800517
518 /* Tell device where to find queue */
Johannes Berg214d14d2011-05-04 07:50:44 -0700519 iwlagn_tx_queue_init(priv, txq);
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800520
521 return 0;
Tomas Winkler73b7d742008-09-03 11:18:48 +0800522err:
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700523 for (i = 0; i < slots_num; i++)
Tomas Winkler73b7d742008-09-03 11:18:48 +0800524 kfree(txq->cmd[i]);
Johannes Bergc2acea82009-07-24 11:13:05 -0700525out_free_arrays:
526 kfree(txq->meta);
527 kfree(txq->cmd);
Tomas Winkler73b7d742008-09-03 11:18:48 +0800528
Tomas Winkler73b7d742008-09-03 11:18:48 +0800529 return -ENOMEM;
Ron Rindjunsky1053d352008-05-05 10:22:43 +0800530}
Samuel Ortiza8e74e22009-01-23 13:45:14 -0800531
Zhu Yide0f60e2010-03-23 00:45:03 -0700532void iwl_tx_queue_reset(struct iwl_priv *priv, struct iwl_tx_queue *txq,
533 int slots_num, u32 txq_id)
534{
Emmanuel Grumbach77e569e2011-06-21 11:03:01 -0700535 memset(txq->meta, 0, sizeof(struct iwl_cmd_meta) * slots_num);
Zhu Yide0f60e2010-03-23 00:45:03 -0700536
537 txq->need_update = 0;
538
539 /* Initialize queue's high/low-water marks, and head/tail indexes */
540 iwl_queue_init(priv, &txq->q, TFD_QUEUE_SIZE_MAX, slots_num, txq_id);
541
542 /* Tell device where to find queue */
Johannes Berg214d14d2011-05-04 07:50:44 -0700543 iwlagn_tx_queue_init(priv, txq);
Zhu Yide0f60e2010-03-23 00:45:03 -0700544}
Zhu Yide0f60e2010-03-23 00:45:03 -0700545
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800546/*************** HOST COMMAND QUEUE FUNCTIONS *****/
547
548/**
549 * iwl_enqueue_hcmd - enqueue a uCode command
550 * @priv: device private data point
551 * @cmd: a point to the ucode command structure
552 *
553 * The function returns < 0 values to indicate the operation is
554 * failed. On success, it turns the index (> 0) of command in the
555 * command queue.
556 */
557int iwl_enqueue_hcmd(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
558{
Johannes Berg13bb9482010-08-23 10:46:33 +0200559 struct iwl_tx_queue *txq = &priv->txq[priv->cmd_queue];
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800560 struct iwl_queue *q = &txq->q;
Johannes Bergc2acea82009-07-24 11:13:05 -0700561 struct iwl_device_cmd *out_cmd;
562 struct iwl_cmd_meta *out_meta;
Tomas Winklerf3674222008-08-04 16:00:44 +0800563 dma_addr_t phys_addr;
564 unsigned long flags;
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800565 u32 idx;
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700566 u16 copy_size, cmd_size;
Wey-Yi Guy0975cc82010-07-31 08:34:07 -0700567 bool is_ct_kill = false;
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700568 bool had_nocopy = false;
569 int i;
570 u8 *cmd_dest;
571#ifdef CONFIG_IWLWIFI_DEVICE_TRACING
572 const void *trace_bufs[IWL_MAX_CMD_TFDS + 1] = {};
573 int trace_lens[IWL_MAX_CMD_TFDS + 1] = {};
574 int trace_idx;
575#endif
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800576
Wey-Yi Guy3083d032011-05-06 17:06:44 -0700577 if (test_bit(STATUS_FW_ERROR, &priv->status)) {
578 IWL_WARN(priv, "fw recovery, no hcmd send\n");
579 return -EIO;
580 }
581
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700582 copy_size = sizeof(out_cmd->hdr);
583 cmd_size = sizeof(out_cmd->hdr);
584
585 /* need one for the header if the first is NOCOPY */
586 BUILD_BUG_ON(IWL_MAX_CMD_TFDS > IWL_NUM_OF_TBS - 1);
587
588 for (i = 0; i < IWL_MAX_CMD_TFDS; i++) {
589 if (!cmd->len[i])
590 continue;
591 if (cmd->dataflags[i] & IWL_HCMD_DFL_NOCOPY) {
592 had_nocopy = true;
593 } else {
594 /* NOCOPY must not be followed by normal! */
595 if (WARN_ON(had_nocopy))
596 return -EINVAL;
597 copy_size += cmd->len[i];
598 }
599 cmd_size += cmd->len[i];
600 }
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800601
Johannes Berg3e41ace2011-04-18 09:12:37 -0700602 /*
603 * If any of the command structures end up being larger than
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700604 * the TFD_MAX_PAYLOAD_SIZE and they aren't dynamically
605 * allocated into separate TFDs, then we will need to
606 * increase the size of the buffers.
Johannes Berg3e41ace2011-04-18 09:12:37 -0700607 */
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700608 if (WARN_ON(copy_size > TFD_MAX_PAYLOAD_SIZE))
Johannes Berg3e41ace2011-04-18 09:12:37 -0700609 return -EINVAL;
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800610
Wey-Yi Guy7812b162009-10-02 13:43:58 -0700611 if (iwl_is_rfkill(priv) || iwl_is_ctkill(priv)) {
Reinette Chatref2f21b42009-10-30 14:36:15 -0700612 IWL_WARN(priv, "Not sending command - %s KILL\n",
613 iwl_is_rfkill(priv) ? "RF" : "CT");
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800614 return -EIO;
615 }
616
Stanislaw Gruszka3598e172011-03-31 17:36:26 +0200617 spin_lock_irqsave(&priv->hcmd_lock, flags);
618
Johannes Bergc2acea82009-07-24 11:13:05 -0700619 if (iwl_queue_space(q) < ((cmd->flags & CMD_ASYNC) ? 2 : 1)) {
Stanislaw Gruszka3598e172011-03-31 17:36:26 +0200620 spin_unlock_irqrestore(&priv->hcmd_lock, flags);
621
Wey-Yi Guy2d237f72009-11-20 12:05:08 -0800622 IWL_ERR(priv, "No space in command queue\n");
Wey-Yi Guyf42e7662011-04-18 09:30:09 -0700623 is_ct_kill = iwl_check_for_ct_kill(priv);
Wey-Yi Guy0975cc82010-07-31 08:34:07 -0700624 if (!is_ct_kill) {
Wey-Yi Guy7812b162009-10-02 13:43:58 -0700625 IWL_ERR(priv, "Restarting adapter due to queue full\n");
Johannes Berge6494372011-04-05 09:41:58 -0700626 iwlagn_fw_error(priv, false);
Wey-Yi Guy7812b162009-10-02 13:43:58 -0700627 }
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800628 return -ENOSPC;
629 }
630
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700631 idx = get_cmd_index(q, q->write_ptr);
Gregory Greenmanda99c4b2008-08-04 16:00:40 +0800632 out_cmd = txq->cmd[idx];
Johannes Bergc2acea82009-07-24 11:13:05 -0700633 out_meta = &txq->meta[idx];
634
Stanislaw Gruszka3598e172011-03-31 17:36:26 +0200635 if (WARN_ON(out_meta->flags & CMD_MAPPED)) {
636 spin_unlock_irqrestore(&priv->hcmd_lock, flags);
637 return -ENOSPC;
638 }
639
Daniel C Halperin8ce73f32009-07-31 14:28:06 -0700640 memset(out_meta, 0, sizeof(*out_meta)); /* re-initialize to NULL */
Johannes Bergc2acea82009-07-24 11:13:05 -0700641 if (cmd->flags & CMD_WANT_SKB)
642 out_meta->source = cmd;
643 if (cmd->flags & CMD_ASYNC)
644 out_meta->callback = cmd->callback;
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800645
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700646 /* set up the header */
647
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800648 out_cmd->hdr.cmd = cmd->id;
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800649 out_cmd->hdr.flags = 0;
Johannes Berg13bb9482010-08-23 10:46:33 +0200650 out_cmd->hdr.sequence = cpu_to_le16(QUEUE_TO_SEQ(priv->cmd_queue) |
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700651 INDEX_TO_SEQ(q->write_ptr));
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800652
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700653 /* and copy the data that needs to be copied */
654
655 cmd_dest = &out_cmd->cmd.payload[0];
656 for (i = 0; i < IWL_MAX_CMD_TFDS; i++) {
657 if (!cmd->len[i])
658 continue;
659 if (cmd->dataflags[i] & IWL_HCMD_DFL_NOCOPY)
660 break;
661 memcpy(cmd_dest, cmd->data[i], cmd->len[i]);
662 cmd_dest += cmd->len[i];
Esti Kummerded2ae72008-08-04 16:00:45 +0800663 }
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700664
665 IWL_DEBUG_HC(priv, "Sending command %s (#%x), seq: 0x%04X, "
666 "%d bytes at %d[%d]:%d\n",
667 get_cmd_string(out_cmd->hdr.cmd),
668 out_cmd->hdr.cmd,
669 le16_to_cpu(out_cmd->hdr.sequence), cmd_size,
670 q->write_ptr, idx, priv->cmd_queue);
671
Reinette Chatredf833b12009-04-21 10:55:48 -0700672 phys_addr = pci_map_single(priv->pci_dev, &out_cmd->hdr,
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700673 copy_size, PCI_DMA_BIDIRECTIONAL);
Johannes Berg2c46f722011-04-28 07:27:10 -0700674 if (unlikely(pci_dma_mapping_error(priv->pci_dev, phys_addr))) {
675 idx = -ENOMEM;
676 goto out;
677 }
678
FUJITA Tomonori2e724442010-06-03 14:19:20 +0900679 dma_unmap_addr_set(out_meta, mapping, phys_addr);
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700680 dma_unmap_len_set(out_meta, len, copy_size);
681
682 iwlagn_txq_attach_buf_to_tfd(priv, txq, phys_addr, copy_size, 1);
683#ifdef CONFIG_IWLWIFI_DEVICE_TRACING
684 trace_bufs[0] = &out_cmd->hdr;
685 trace_lens[0] = copy_size;
686 trace_idx = 1;
687#endif
688
689 for (i = 0; i < IWL_MAX_CMD_TFDS; i++) {
690 if (!cmd->len[i])
691 continue;
692 if (!(cmd->dataflags[i] & IWL_HCMD_DFL_NOCOPY))
693 continue;
694 phys_addr = pci_map_single(priv->pci_dev, (void *)cmd->data[i],
695 cmd->len[i], PCI_DMA_TODEVICE);
696 if (pci_dma_mapping_error(priv->pci_dev, phys_addr)) {
697 iwlagn_unmap_tfd(priv, out_meta,
698 &txq->tfds[q->write_ptr]);
699 idx = -ENOMEM;
700 goto out;
701 }
702
703 iwlagn_txq_attach_buf_to_tfd(priv, txq, phys_addr,
704 cmd->len[i], 0);
705#ifdef CONFIG_IWLWIFI_DEVICE_TRACING
706 trace_bufs[trace_idx] = cmd->data[i];
707 trace_lens[trace_idx] = cmd->len[i];
708 trace_idx++;
709#endif
710 }
Reinette Chatredf833b12009-04-21 10:55:48 -0700711
Johannes Berg2c46f722011-04-28 07:27:10 -0700712 out_meta->flags = cmd->flags | CMD_MAPPED;
713
714 txq->need_update = 1;
715
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700716 /* check that tracing gets all possible blocks */
717 BUILD_BUG_ON(IWL_MAX_CMD_TFDS + 1 != 3);
718#ifdef CONFIG_IWLWIFI_DEVICE_TRACING
719 trace_iwlwifi_dev_hcmd(priv, cmd->flags,
720 trace_bufs[0], trace_lens[0],
721 trace_bufs[1], trace_lens[1],
722 trace_bufs[2], trace_lens[2]);
723#endif
Reinette Chatredf833b12009-04-21 10:55:48 -0700724
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800725 /* Increment and update queue's write index */
726 q->write_ptr = iwl_queue_inc_wrap(q->write_ptr, q->n_bd);
Abhijeet Kolekar7bfedc52010-02-03 13:47:56 -0800727 iwl_txq_update_write_ptr(priv, txq);
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800728
Johannes Berg2c46f722011-04-28 07:27:10 -0700729 out:
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800730 spin_unlock_irqrestore(&priv->hcmd_lock, flags);
Abhijeet Kolekar7bfedc52010-02-03 13:47:56 -0800731 return idx;
Tomas Winklerfd4abac2008-05-15 13:54:07 +0800732}
733
Tomas Winkler17b88922008-05-29 16:35:12 +0800734/**
735 * iwl_hcmd_queue_reclaim - Reclaim TX command queue entries already Tx'd
736 *
737 * When FW advances 'R' index, all entries between old and new 'R' index
738 * need to be reclaimed. As result, some free space forms. If there is
739 * enough free space (> low mark), wake the stack that feeds us.
740 */
Daniel Halperin20ba2862011-05-16 21:46:28 -0700741static void iwl_hcmd_queue_reclaim(struct iwl_priv *priv, int txq_id, int idx)
Tomas Winkler17b88922008-05-29 16:35:12 +0800742{
743 struct iwl_tx_queue *txq = &priv->txq[txq_id];
744 struct iwl_queue *q = &txq->q;
745 int nfreed = 0;
746
Tomas Winkler499b1882008-10-14 12:32:48 -0700747 if ((idx >= q->n_bd) || (iwl_queue_used(q, idx) == 0)) {
Winkler, Tomas15b16872008-12-19 10:37:33 +0800748 IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
Tomas Winkler17b88922008-05-29 16:35:12 +0800749 "is out of range [0-%d] %d %d.\n", txq_id,
Tomas Winkler499b1882008-10-14 12:32:48 -0700750 idx, q->n_bd, q->write_ptr, q->read_ptr);
Tomas Winkler17b88922008-05-29 16:35:12 +0800751 return;
752 }
753
Tomas Winkler499b1882008-10-14 12:32:48 -0700754 for (idx = iwl_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
755 q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd)) {
756
757 if (nfreed++ > 0) {
Winkler, Tomas15b16872008-12-19 10:37:33 +0800758 IWL_ERR(priv, "HCMD skipped: index (%d) %d %d\n", idx,
Tomas Winkler17b88922008-05-29 16:35:12 +0800759 q->write_ptr, q->read_ptr);
Johannes Berge6494372011-04-05 09:41:58 -0700760 iwlagn_fw_error(priv, false);
Tomas Winkler17b88922008-05-29 16:35:12 +0800761 }
Gregory Greenmanda99c4b2008-08-04 16:00:40 +0800762
Tomas Winkler17b88922008-05-29 16:35:12 +0800763 }
764}
765
766/**
767 * iwl_tx_cmd_complete - Pull unused buffers off the queue and reclaim them
768 * @rxb: Rx buffer to reclaim
769 *
770 * If an Rx buffer has an async callback associated with it the callback
771 * will be executed. The attached skb (if present) will only be freed
772 * if the callback returns 1
773 */
774void iwl_tx_cmd_complete(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
775{
Zhu Yi2f301222009-10-09 17:19:45 +0800776 struct iwl_rx_packet *pkt = rxb_addr(rxb);
Tomas Winkler17b88922008-05-29 16:35:12 +0800777 u16 sequence = le16_to_cpu(pkt->hdr.sequence);
778 int txq_id = SEQ_TO_QUEUE(sequence);
779 int index = SEQ_TO_INDEX(sequence);
Tomas Winkler17b88922008-05-29 16:35:12 +0800780 int cmd_index;
Johannes Bergc2acea82009-07-24 11:13:05 -0700781 struct iwl_device_cmd *cmd;
782 struct iwl_cmd_meta *meta;
Johannes Berg13bb9482010-08-23 10:46:33 +0200783 struct iwl_tx_queue *txq = &priv->txq[priv->cmd_queue];
Stanislaw Gruszka3598e172011-03-31 17:36:26 +0200784 unsigned long flags;
Tomas Winkler17b88922008-05-29 16:35:12 +0800785
786 /* If a Tx command is being handled and it isn't in the actual
787 * command queue then there a command routing bug has been introduced
788 * in the queue management code. */
Johannes Berg13bb9482010-08-23 10:46:33 +0200789 if (WARN(txq_id != priv->cmd_queue,
790 "wrong command queue %d (should be %d), sequence 0x%X readp=%d writep=%d\n",
791 txq_id, priv->cmd_queue, sequence,
792 priv->txq[priv->cmd_queue].q.read_ptr,
793 priv->txq[priv->cmd_queue].q.write_ptr)) {
Reinette Chatreec741162009-07-24 11:13:08 -0700794 iwl_print_hex_error(priv, pkt, 32);
Johannes Berg55d6a3c2008-09-23 19:18:43 +0200795 return;
Winkler, Tomas01ef9322008-11-07 09:58:45 -0800796 }
Tomas Winkler17b88922008-05-29 16:35:12 +0800797
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700798 cmd_index = get_cmd_index(&txq->q, index);
Zhu Yidd487442010-03-22 02:28:41 -0700799 cmd = txq->cmd[cmd_index];
800 meta = &txq->meta[cmd_index];
Tomas Winkler17b88922008-05-29 16:35:12 +0800801
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700802 iwlagn_unmap_tfd(priv, meta, &txq->tfds[index]);
Reinette Chatrec33de622009-10-30 14:36:10 -0700803
Tomas Winkler17b88922008-05-29 16:35:12 +0800804 /* Input error checking is done when commands are added to queue. */
Johannes Bergc2acea82009-07-24 11:13:05 -0700805 if (meta->flags & CMD_WANT_SKB) {
Zhu Yi2f301222009-10-09 17:19:45 +0800806 meta->source->reply_page = (unsigned long)rxb_addr(rxb);
807 rxb->page = NULL;
Stanislaw Gruszka2624e962011-04-20 16:02:58 +0200808 } else if (meta->callback)
809 meta->callback(priv, cmd, pkt);
810
811 spin_lock_irqsave(&priv->hcmd_lock, flags);
Tomas Winkler17b88922008-05-29 16:35:12 +0800812
Daniel Halperin20ba2862011-05-16 21:46:28 -0700813 iwl_hcmd_queue_reclaim(priv, txq_id, index);
Tomas Winkler17b88922008-05-29 16:35:12 +0800814
Johannes Bergc2acea82009-07-24 11:13:05 -0700815 if (!(meta->flags & CMD_ASYNC)) {
Tomas Winkler17b88922008-05-29 16:35:12 +0800816 clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
Frans Pop91dd6c22010-03-24 14:19:58 -0700817 IWL_DEBUG_INFO(priv, "Clearing HCMD_ACTIVE for command %s\n",
Reinette Chatred2dfe6d2010-02-18 22:03:04 -0800818 get_cmd_string(cmd->hdr.cmd));
Tomas Winkler17b88922008-05-29 16:35:12 +0800819 wake_up_interruptible(&priv->wait_command_queue);
820 }
Stanislaw Gruszka3598e172011-03-31 17:36:26 +0200821
822 /* Mark as unmapped */
Zhu Yidd487442010-03-22 02:28:41 -0700823 meta->flags = 0;
Stanislaw Gruszka3598e172011-03-31 17:36:26 +0200824
825 spin_unlock_irqrestore(&priv->hcmd_lock, flags);
Tomas Winkler17b88922008-05-29 16:35:12 +0800826}