Merge branch 'core-rcu-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6.git] / drivers / net / wireless / iwlwifi / iwl-trans.c
1 /******************************************************************************
2  *
3  * This file is provided under a dual BSD/GPLv2 license.  When using or
4  * redistributing this file, you may do so under either license.
5  *
6  * GPL LICENSE SUMMARY
7  *
8  * Copyright(c) 2007 - 2011 Intel Corporation. All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of version 2 of the GNU General Public License as
12  * published by the Free Software Foundation.
13  *
14  * This program is distributed in the hope that it will be useful, but
15  * WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
22  * USA
23  *
24  * The full GNU General Public License is included in this distribution
25  * in the file called LICENSE.GPL.
26  *
27  * Contact Information:
28  *  Intel Linux Wireless <ilw@linux.intel.com>
29  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30  *
31  * BSD LICENSE
32  *
33  * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.
34  * All rights reserved.
35  *
36  * Redistribution and use in source and binary forms, with or without
37  * modification, are permitted provided that the following conditions
38  * are met:
39  *
40  *  * Redistributions of source code must retain the above copyright
41  *    notice, this list of conditions and the following disclaimer.
42  *  * Redistributions in binary form must reproduce the above copyright
43  *    notice, this list of conditions and the following disclaimer in
44  *    the documentation and/or other materials provided with the
45  *    distribution.
46  *  * Neither the name Intel Corporation nor the names of its
47  *    contributors may be used to endorse or promote products derived
48  *    from this software without specific prior written permission.
49  *
50  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61  *
62  *****************************************************************************/
63 #include "iwl-dev.h"
64 #include "iwl-trans.h"
65 #include "iwl-core.h"
66 #include "iwl-helpers.h"
67 /*TODO remove uneeded includes when the transport layer tx_free will be here */
68 #include "iwl-agn.h"
69 #include "iwl-core.h"
70
71 static int iwl_trans_rx_alloc(struct iwl_priv *priv)
72 {
73         struct iwl_rx_queue *rxq = &priv->rxq;
74         struct device *dev = priv->bus.dev;
75
76         memset(&priv->rxq, 0, sizeof(priv->rxq));
77
78         spin_lock_init(&rxq->lock);
79         INIT_LIST_HEAD(&rxq->rx_free);
80         INIT_LIST_HEAD(&rxq->rx_used);
81
82         if (WARN_ON(rxq->bd || rxq->rb_stts))
83                 return -EINVAL;
84
85         /* Allocate the circular buffer of Read Buffer Descriptors (RBDs) */
86         rxq->bd = dma_alloc_coherent(dev, sizeof(__le32) * RX_QUEUE_SIZE,
87                                      &rxq->bd_dma, GFP_KERNEL);
88         if (!rxq->bd)
89                 goto err_bd;
90         memset(rxq->bd, 0, sizeof(__le32) * RX_QUEUE_SIZE);
91
92         /*Allocate the driver's pointer to receive buffer status */
93         rxq->rb_stts = dma_alloc_coherent(dev, sizeof(*rxq->rb_stts),
94                                           &rxq->rb_stts_dma, GFP_KERNEL);
95         if (!rxq->rb_stts)
96                 goto err_rb_stts;
97         memset(rxq->rb_stts, 0, sizeof(*rxq->rb_stts));
98
99         return 0;
100
101 err_rb_stts:
102         dma_free_coherent(dev, sizeof(__le32) * RX_QUEUE_SIZE,
103                         rxq->bd, rxq->bd_dma);
104         memset(&rxq->bd_dma, 0, sizeof(rxq->bd_dma));
105         rxq->bd = NULL;
106 err_bd:
107         return -ENOMEM;
108 }
109
110 static void iwl_trans_rxq_free_rx_bufs(struct iwl_priv *priv)
111 {
112         struct iwl_rx_queue *rxq = &priv->rxq;
113         int i;
114
115         /* Fill the rx_used queue with _all_ of the Rx buffers */
116         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
117                 /* In the reset function, these buffers may have been allocated
118                  * to an SKB, so we need to unmap and free potential storage */
119                 if (rxq->pool[i].page != NULL) {
120                         dma_unmap_page(priv->bus.dev, rxq->pool[i].page_dma,
121                                 PAGE_SIZE << priv->hw_params.rx_page_order,
122                                 DMA_FROM_DEVICE);
123                         __iwl_free_pages(priv, rxq->pool[i].page);
124                         rxq->pool[i].page = NULL;
125                 }
126                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
127         }
128 }
129
130 static int iwl_trans_rx_init(struct iwl_priv *priv)
131 {
132         struct iwl_rx_queue *rxq = &priv->rxq;
133         int i, err;
134         unsigned long flags;
135
136         if (!rxq->bd) {
137                 err = iwl_trans_rx_alloc(priv);
138                 if (err)
139                         return err;
140         }
141
142         spin_lock_irqsave(&rxq->lock, flags);
143         INIT_LIST_HEAD(&rxq->rx_free);
144         INIT_LIST_HEAD(&rxq->rx_used);
145
146         iwl_trans_rxq_free_rx_bufs(priv);
147
148         for (i = 0; i < RX_QUEUE_SIZE; i++)
149                 rxq->queue[i] = NULL;
150
151         /* Set us so that we have processed and used all buffers, but have
152          * not restocked the Rx queue with fresh buffers */
153         rxq->read = rxq->write = 0;
154         rxq->write_actual = 0;
155         rxq->free_count = 0;
156         spin_unlock_irqrestore(&rxq->lock, flags);
157
158         return 0;
159 }
160
161 static void iwl_trans_rx_free(struct iwl_priv *priv)
162 {
163         struct iwl_rx_queue *rxq = &priv->rxq;
164         unsigned long flags;
165
166         /*if rxq->bd is NULL, it means that nothing has been allocated,
167          * exit now */
168         if (!rxq->bd) {
169                 IWL_DEBUG_INFO(priv, "Free NULL rx context\n");
170                 return;
171         }
172
173         spin_lock_irqsave(&rxq->lock, flags);
174         iwl_trans_rxq_free_rx_bufs(priv);
175         spin_unlock_irqrestore(&rxq->lock, flags);
176
177         dma_free_coherent(priv->bus.dev, sizeof(__le32) * RX_QUEUE_SIZE,
178                           rxq->bd, rxq->bd_dma);
179         memset(&rxq->bd_dma, 0, sizeof(rxq->bd_dma));
180         rxq->bd = NULL;
181
182         if (rxq->rb_stts)
183                 dma_free_coherent(priv->bus.dev,
184                                   sizeof(struct iwl_rb_status),
185                                   rxq->rb_stts, rxq->rb_stts_dma);
186         else
187                 IWL_DEBUG_INFO(priv, "Free rxq->rb_stts which is NULL\n");
188         memset(&rxq->rb_stts_dma, 0, sizeof(rxq->rb_stts_dma));
189         rxq->rb_stts = NULL;
190 }
191
192 static int iwl_trans_rx_stop(struct iwl_priv *priv)
193 {
194
195         /* stop Rx DMA */
196         iwl_write_direct32(priv, FH_MEM_RCSR_CHNL0_CONFIG_REG, 0);
197         return iwl_poll_direct_bit(priv, FH_MEM_RSSR_RX_STATUS_REG,
198                             FH_RSSR_CHNL0_RX_STATUS_CHNL_IDLE, 1000);
199 }
200
201 static inline int iwlagn_alloc_dma_ptr(struct iwl_priv *priv,
202                                     struct iwl_dma_ptr *ptr, size_t size)
203 {
204         if (WARN_ON(ptr->addr))
205                 return -EINVAL;
206
207         ptr->addr = dma_alloc_coherent(priv->bus.dev, size,
208                                        &ptr->dma, GFP_KERNEL);
209         if (!ptr->addr)
210                 return -ENOMEM;
211         ptr->size = size;
212         return 0;
213 }
214
215 static inline void iwlagn_free_dma_ptr(struct iwl_priv *priv,
216                                     struct iwl_dma_ptr *ptr)
217 {
218         if (unlikely(!ptr->addr))
219                 return;
220
221         dma_free_coherent(priv->bus.dev, ptr->size, ptr->addr, ptr->dma);
222         memset(ptr, 0, sizeof(*ptr));
223 }
224
225 static int iwl_trans_txq_alloc(struct iwl_priv *priv, struct iwl_tx_queue *txq,
226                       int slots_num, u32 txq_id)
227 {
228         size_t tfd_sz = priv->hw_params.tfd_size * TFD_QUEUE_SIZE_MAX;
229         int i;
230
231         if (WARN_ON(txq->meta || txq->cmd || txq->txb || txq->tfds))
232                 return -EINVAL;
233
234         txq->q.n_window = slots_num;
235
236         txq->meta = kzalloc(sizeof(txq->meta[0]) * slots_num,
237                             GFP_KERNEL);
238         txq->cmd = kzalloc(sizeof(txq->cmd[0]) * slots_num,
239                            GFP_KERNEL);
240
241         if (!txq->meta || !txq->cmd)
242                 goto error;
243
244         for (i = 0; i < slots_num; i++) {
245                 txq->cmd[i] = kmalloc(sizeof(struct iwl_device_cmd),
246                                         GFP_KERNEL);
247                 if (!txq->cmd[i])
248                         goto error;
249         }
250
251         /* Alloc driver data array and TFD circular buffer */
252         /* Driver private data, only for Tx (not command) queues,
253          * not shared with device. */
254         if (txq_id != priv->cmd_queue) {
255                 txq->txb = kzalloc(sizeof(txq->txb[0]) *
256                                    TFD_QUEUE_SIZE_MAX, GFP_KERNEL);
257                 if (!txq->txb) {
258                         IWL_ERR(priv, "kmalloc for auxiliary BD "
259                                   "structures failed\n");
260                         goto error;
261                 }
262         } else {
263                 txq->txb = NULL;
264         }
265
266         /* Circular buffer of transmit frame descriptors (TFDs),
267          * shared with device */
268         txq->tfds = dma_alloc_coherent(priv->bus.dev, tfd_sz, &txq->q.dma_addr,
269                                        GFP_KERNEL);
270         if (!txq->tfds) {
271                 IWL_ERR(priv, "dma_alloc_coherent(%zd) failed\n", tfd_sz);
272                 goto error;
273         }
274         txq->q.id = txq_id;
275
276         return 0;
277 error:
278         kfree(txq->txb);
279         txq->txb = NULL;
280         /* since txq->cmd has been zeroed,
281          * all non allocated cmd[i] will be NULL */
282         if (txq->cmd)
283                 for (i = 0; i < slots_num; i++)
284                         kfree(txq->cmd[i]);
285         kfree(txq->meta);
286         kfree(txq->cmd);
287         txq->meta = NULL;
288         txq->cmd = NULL;
289
290         return -ENOMEM;
291
292 }
293
294 static int iwl_trans_txq_init(struct iwl_priv *priv, struct iwl_tx_queue *txq,
295                       int slots_num, u32 txq_id)
296 {
297         int ret;
298
299         txq->need_update = 0;
300         memset(txq->meta, 0, sizeof(txq->meta[0]) * slots_num);
301
302         /*
303          * For the default queues 0-3, set up the swq_id
304          * already -- all others need to get one later
305          * (if they need one at all).
306          */
307         if (txq_id < 4)
308                 iwl_set_swq_id(txq, txq_id, txq_id);
309
310         /* TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
311          * iwl_queue_inc_wrap and iwl_queue_dec_wrap are broken. */
312         BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
313
314         /* Initialize queue's high/low-water marks, and head/tail indexes */
315         ret = iwl_queue_init(priv, &txq->q, TFD_QUEUE_SIZE_MAX, slots_num,
316                         txq_id);
317         if (ret)
318                 return ret;
319
320         /*
321          * Tell nic where to find circular buffer of Tx Frame Descriptors for
322          * given Tx queue, and enable the DMA channel used for that queue.
323          * Circular buffer (TFD queue in DRAM) physical base address */
324         iwl_write_direct32(priv, FH_MEM_CBBC_QUEUE(txq_id),
325                              txq->q.dma_addr >> 8);
326
327         return 0;
328 }
329
330 /**
331  * iwl_tx_queue_unmap -  Unmap any remaining DMA mappings and free skb's
332  */
333 static void iwl_tx_queue_unmap(struct iwl_priv *priv, int txq_id)
334 {
335         struct iwl_tx_queue *txq = &priv->txq[txq_id];
336         struct iwl_queue *q = &txq->q;
337
338         if (!q->n_bd)
339                 return;
340
341         while (q->write_ptr != q->read_ptr) {
342                 /* The read_ptr needs to bound by q->n_window */
343                 iwlagn_txq_free_tfd(priv, txq, get_cmd_index(q, q->read_ptr));
344                 q->read_ptr = iwl_queue_inc_wrap(q->read_ptr, q->n_bd);
345         }
346 }
347
348 /**
349  * iwl_tx_queue_free - Deallocate DMA queue.
350  * @txq: Transmit queue to deallocate.
351  *
352  * Empty queue by removing and destroying all BD's.
353  * Free all buffers.
354  * 0-fill, but do not free "txq" descriptor structure.
355  */
356 static void iwl_tx_queue_free(struct iwl_priv *priv, int txq_id)
357 {
358         struct iwl_tx_queue *txq = &priv->txq[txq_id];
359         struct device *dev = priv->bus.dev;
360         int i;
361         if (WARN_ON(!txq))
362                 return;
363
364         iwl_tx_queue_unmap(priv, txq_id);
365
366         /* De-alloc array of command/tx buffers */
367         for (i = 0; i < txq->q.n_window; i++)
368                 kfree(txq->cmd[i]);
369
370         /* De-alloc circular buffer of TFDs */
371         if (txq->q.n_bd) {
372                 dma_free_coherent(dev, priv->hw_params.tfd_size *
373                                   txq->q.n_bd, txq->tfds, txq->q.dma_addr);
374                 memset(&txq->q.dma_addr, 0, sizeof(txq->q.dma_addr));
375         }
376
377         /* De-alloc array of per-TFD driver data */
378         kfree(txq->txb);
379         txq->txb = NULL;
380
381         /* deallocate arrays */
382         kfree(txq->cmd);
383         kfree(txq->meta);
384         txq->cmd = NULL;
385         txq->meta = NULL;
386
387         /* 0-fill queue descriptor structure */
388         memset(txq, 0, sizeof(*txq));
389 }
390
391 /**
392  * iwl_trans_tx_free - Free TXQ Context
393  *
394  * Destroy all TX DMA queues and structures
395  */
396 static void iwl_trans_tx_free(struct iwl_priv *priv)
397 {
398         int txq_id;
399
400         /* Tx queues */
401         if (priv->txq) {
402                 for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++)
403                         iwl_tx_queue_free(priv, txq_id);
404         }
405
406         kfree(priv->txq);
407         priv->txq = NULL;
408
409         iwlagn_free_dma_ptr(priv, &priv->kw);
410
411         iwlagn_free_dma_ptr(priv, &priv->scd_bc_tbls);
412 }
413
414 /**
415  * iwl_trans_tx_alloc - allocate TX context
416  * Allocate all Tx DMA structures and initialize them
417  *
418  * @param priv
419  * @return error code
420  */
421 static int iwl_trans_tx_alloc(struct iwl_priv *priv)
422 {
423         int ret;
424         int txq_id, slots_num;
425
426         /*It is not allowed to alloc twice, so warn when this happens.
427          * We cannot rely on the previous allocation, so free and fail */
428         if (WARN_ON(priv->txq)) {
429                 ret = -EINVAL;
430                 goto error;
431         }
432
433         ret = iwlagn_alloc_dma_ptr(priv, &priv->scd_bc_tbls,
434                                 priv->hw_params.scd_bc_tbls_size);
435         if (ret) {
436                 IWL_ERR(priv, "Scheduler BC Table allocation failed\n");
437                 goto error;
438         }
439
440         /* Alloc keep-warm buffer */
441         ret = iwlagn_alloc_dma_ptr(priv, &priv->kw, IWL_KW_SIZE);
442         if (ret) {
443                 IWL_ERR(priv, "Keep Warm allocation failed\n");
444                 goto error;
445         }
446
447         priv->txq = kzalloc(sizeof(struct iwl_tx_queue) *
448                         priv->cfg->base_params->num_of_queues, GFP_KERNEL);
449         if (!priv->txq) {
450                 IWL_ERR(priv, "Not enough memory for txq\n");
451                 ret = ENOMEM;
452                 goto error;
453         }
454
455         /* Alloc and init all Tx queues, including the command queue (#4/#9) */
456         for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++) {
457                 slots_num = (txq_id == priv->cmd_queue) ?
458                                         TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
459                 ret = iwl_trans_txq_alloc(priv, &priv->txq[txq_id], slots_num,
460                                        txq_id);
461                 if (ret) {
462                         IWL_ERR(priv, "Tx %d queue alloc failed\n", txq_id);
463                         goto error;
464                 }
465         }
466
467         return 0;
468
469 error:
470         trans_tx_free(priv);
471
472         return ret;
473 }
474 static int iwl_trans_tx_init(struct iwl_priv *priv)
475 {
476         int ret;
477         int txq_id, slots_num;
478         unsigned long flags;
479         bool alloc = false;
480
481         if (!priv->txq) {
482                 ret = iwl_trans_tx_alloc(priv);
483                 if (ret)
484                         goto error;
485                 alloc = true;
486         }
487
488         spin_lock_irqsave(&priv->lock, flags);
489
490         /* Turn off all Tx DMA fifos */
491         iwl_write_prph(priv, IWLAGN_SCD_TXFACT, 0);
492
493         /* Tell NIC where to find the "keep warm" buffer */
494         iwl_write_direct32(priv, FH_KW_MEM_ADDR_REG, priv->kw.dma >> 4);
495
496         spin_unlock_irqrestore(&priv->lock, flags);
497
498         /* Alloc and init all Tx queues, including the command queue (#4/#9) */
499         for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++) {
500                 slots_num = (txq_id == priv->cmd_queue) ?
501                                         TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
502                 ret = iwl_trans_txq_init(priv, &priv->txq[txq_id], slots_num,
503                                        txq_id);
504                 if (ret) {
505                         IWL_ERR(priv, "Tx %d queue init failed\n", txq_id);
506                         goto error;
507                 }
508         }
509
510         return 0;
511 error:
512         /*Upon error, free only if we allocated something */
513         if (alloc)
514                 trans_tx_free(priv);
515         return ret;
516 }
517
518 /**
519  * iwlagn_txq_ctx_stop - Stop all Tx DMA channels
520  */
521 static int iwl_trans_tx_stop(struct iwl_priv *priv)
522 {
523         int ch, txq_id;
524         unsigned long flags;
525
526         /* Turn off all Tx DMA fifos */
527         spin_lock_irqsave(&priv->lock, flags);
528
529         iwlagn_txq_set_sched(priv, 0);
530
531         /* Stop each Tx DMA channel, and wait for it to be idle */
532         for (ch = 0; ch < FH_TCSR_CHNL_NUM; ch++) {
533                 iwl_write_direct32(priv, FH_TCSR_CHNL_TX_CONFIG_REG(ch), 0x0);
534                 if (iwl_poll_direct_bit(priv, FH_TSSR_TX_STATUS_REG,
535                                     FH_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch),
536                                     1000))
537                         IWL_ERR(priv, "Failing on timeout while stopping"
538                             " DMA channel %d [0x%08x]", ch,
539                             iwl_read_direct32(priv, FH_TSSR_TX_STATUS_REG));
540         }
541         spin_unlock_irqrestore(&priv->lock, flags);
542
543         if (!priv->txq) {
544                 IWL_WARN(priv, "Stopping tx queues that aren't allocated...");
545                 return 0;
546         }
547
548         /* Unmap DMA from host system and free skb's */
549         for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++)
550                 iwl_tx_queue_unmap(priv, txq_id);
551
552         return 0;
553 }
554
555 static const struct iwl_trans_ops trans_ops = {
556         .rx_init = iwl_trans_rx_init,
557         .rx_stop = iwl_trans_rx_stop,
558         .rx_free = iwl_trans_rx_free,
559
560         .tx_init = iwl_trans_tx_init,
561         .tx_stop = iwl_trans_tx_stop,
562         .tx_free = iwl_trans_tx_free,
563
564         .send_cmd = iwl_send_cmd,
565         .send_cmd_pdu = iwl_send_cmd_pdu,
566 };
567
568 void iwl_trans_register(struct iwl_trans *trans)
569 {
570         trans->ops = &trans_ops;
571 }