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
  70 static int iwl_trans_rx_alloc(struct iwl_priv *priv)
  71 {
  72         struct iwl_rx_queue *rxq = &priv->rxq;
  73         struct device *dev = priv->bus.dev;
  74
  75         memset(&priv->rxq, 0, sizeof(priv->rxq));
  76
  77         spin_lock_init(&rxq->lock);
  78         INIT_LIST_HEAD(&rxq->rx_free);
  79         INIT_LIST_HEAD(&rxq->rx_used);
  80
  81         if (WARN_ON(rxq->bd || rxq->rb_stts))
  82                 return -EINVAL;
  83
  84         /* Allocate the circular buffer of Read Buffer Descriptors (RBDs) */
  85         rxq->bd = dma_alloc_coherent(dev, sizeof(__le32) * RX_QUEUE_SIZE,
  86                                      &rxq->bd_dma, GFP_KERNEL);
  87         if (!rxq->bd)
  88                 goto err_bd;
  89         memset(rxq->bd, 0, sizeof(__le32) * RX_QUEUE_SIZE);
  90
  91         /*Allocate the driver's pointer to receive buffer status */
  92         rxq->rb_stts = dma_alloc_coherent(dev, sizeof(*rxq->rb_stts),
  93                                           &rxq->rb_stts_dma, GFP_KERNEL);
  94         if (!rxq->rb_stts)
  95                 goto err_rb_stts;
  96         memset(rxq->rb_stts, 0, sizeof(*rxq->rb_stts));
  97
  98         return 0;
  99
 100 err_rb_stts:
 101         dma_free_coherent(dev, sizeof(__le32) * RX_QUEUE_SIZE,
 102                         rxq->bd, rxq->bd_dma);
 103         memset(&rxq->bd_dma, 0, sizeof(rxq->bd_dma));
 104         rxq->bd = NULL;
 105 err_bd:
 106         return -ENOMEM;
 107 }
 108
 109 static void iwl_trans_rxq_free_rx_bufs(struct iwl_priv *priv)
 110 {
 111         struct iwl_rx_queue *rxq = &priv->rxq;
 112         int i;
 113
 114         /* Fill the rx_used queue with _all_ of the Rx buffers */
 115         for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
 116                 /* In the reset function, these buffers may have been allocated
 117                  * to an SKB, so we need to unmap and free potential storage */
 118                 if (rxq->pool[i].page != NULL) {
 119                         dma_unmap_page(priv->bus.dev, rxq->pool[i].page_dma,
 120                                 PAGE_SIZE << priv->hw_params.rx_page_order,
 121                                 DMA_FROM_DEVICE);
 122                         __iwl_free_pages(priv, rxq->pool[i].page);
 123                         rxq->pool[i].page = NULL;
 124                 }
 125                 list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
 126         }
 127 }
 128
 129 static int iwl_trans_rx_init(struct iwl_priv *priv)
 130 {
 131         struct iwl_rx_queue *rxq = &priv->rxq;
 132         int i, err;
 133         unsigned long flags;
 134
 135         if (!rxq->bd) {
 136                 err = iwl_trans_rx_alloc(priv);
 137                 if (err)
 138                         return err;
 139         }
 140
 141         spin_lock_irqsave(&rxq->lock, flags);
 142         INIT_LIST_HEAD(&rxq->rx_free);
 143         INIT_LIST_HEAD(&rxq->rx_used);
 144
 145         iwl_trans_rxq_free_rx_bufs(priv);
 146
 147         for (i = 0; i < RX_QUEUE_SIZE; i++)
 148                 rxq->queue[i] = NULL;
 149
 150         /* Set us so that we have processed and used all buffers, but have
 151          * not restocked the Rx queue with fresh buffers */
 152         rxq->read = rxq->write = 0;
 153         rxq->write_actual = 0;
 154         rxq->free_count = 0;
 155         spin_unlock_irqrestore(&rxq->lock, flags);
 156
 157         return 0;
 158 }
 159
 160 static void iwl_trans_rx_free(struct iwl_priv *priv)
 161 {
 162         struct iwl_rx_queue *rxq = &priv->rxq;
 163         unsigned long flags;
 164
 165         /*if rxq->bd is NULL, it means that nothing has been allocated,
 166          * exit now */
 167         if (!rxq->bd) {
 168                 IWL_DEBUG_INFO(priv, "Free NULL rx context\n");
 169                 return;
 170         }
 171
 172         spin_lock_irqsave(&rxq->lock, flags);
 173         iwl_trans_rxq_free_rx_bufs(priv);
 174         spin_unlock_irqrestore(&rxq->lock, flags);
 175
 176         dma_free_coherent(priv->bus.dev, sizeof(__le32) * RX_QUEUE_SIZE,
 177                           rxq->bd, rxq->bd_dma);
 178         memset(&rxq->bd_dma, 0, sizeof(rxq->bd_dma));
 179         rxq->bd = NULL;
 180
 181         if (rxq->rb_stts)
 182                 dma_free_coherent(priv->bus.dev,
 183                                   sizeof(struct iwl_rb_status),
 184                                   rxq->rb_stts, rxq->rb_stts_dma);
 185         else
 186                 IWL_DEBUG_INFO(priv, "Free rxq->rb_stts which is NULL\n");
 187         memset(&rxq->rb_stts_dma, 0, sizeof(rxq->rb_stts_dma));
 188         rxq->rb_stts = NULL;
 189 }
 190
 191 /* TODO:remove this code duplication */
 192 static inline int iwlagn_alloc_dma_ptr(struct iwl_priv *priv,
 193                                     struct iwl_dma_ptr *ptr, size_t size)
 194 {
 195         if (WARN_ON(ptr->addr))
 196                 return -EINVAL;
 197
 198         ptr->addr = dma_alloc_coherent(priv->bus.dev, size,
 199                                        &ptr->dma, GFP_KERNEL);
 200         if (!ptr->addr)
 201                 return -ENOMEM;
 202         ptr->size = size;
 203         return 0;
 204 }
 205
 206 static inline void iwlagn_free_dma_ptr(struct iwl_priv *priv,
 207                                     struct iwl_dma_ptr *ptr)
 208 {
 209         if (unlikely(!ptr->addr))
 210                 return;
 211
 212         dma_free_coherent(priv->bus.dev, ptr->size, ptr->addr, ptr->dma);
 213         memset(ptr, 0, sizeof(*ptr));
 214 }
 215
 216 static int iwl_trans_txq_alloc(struct iwl_priv *priv, struct iwl_tx_queue *txq,
 217                       int slots_num, u32 txq_id)
 218 {
 219         size_t tfd_sz = priv->hw_params.tfd_size * TFD_QUEUE_SIZE_MAX;
 220         int i;
 221
 222         if (WARN_ON(txq->meta || txq->cmd || txq->txb || txq->tfds))
 223                 return -EINVAL;
 224
 225         txq->q.n_window = slots_num;
 226
 227         txq->meta = kzalloc(sizeof(txq->meta[0]) * slots_num,
 228                             GFP_KERNEL);
 229         txq->cmd = kzalloc(sizeof(txq->cmd[0]) * slots_num,
 230                            GFP_KERNEL);
 231
 232         if (!txq->meta || !txq->cmd)
 233                 goto error;
 234
 235         for (i = 0; i < slots_num; i++) {
 236                 txq->cmd[i] = kmalloc(sizeof(struct iwl_device_cmd),
 237                                         GFP_KERNEL);
 238                 if (!txq->cmd[i])
 239                         goto error;
 240         }
 241
 242         /* Alloc driver data array and TFD circular buffer */
 243         /* Driver private data, only for Tx (not command) queues,
 244          * not shared with device. */
 245         if (txq_id != priv->cmd_queue) {
 246                 txq->txb = kzalloc(sizeof(txq->txb[0]) *
 247                                    TFD_QUEUE_SIZE_MAX, GFP_KERNEL);
 248                 if (!txq->txb) {
 249                         IWL_ERR(priv, "kmalloc for auxiliary BD "
 250                                   "structures failed\n");
 251                         goto error;
 252                 }
 253         } else {
 254                 txq->txb = NULL;
 255         }
 256
 257         /* Circular buffer of transmit frame descriptors (TFDs),
 258          * shared with device */
 259         txq->tfds = dma_alloc_coherent(priv->bus.dev, tfd_sz, &txq->q.dma_addr,
 260                                        GFP_KERNEL);
 261         if (!txq->tfds) {
 262                 IWL_ERR(priv, "dma_alloc_coherent(%zd) failed\n", tfd_sz);
 263                 goto error;
 264         }
 265         txq->q.id = txq_id;
 266
 267         return 0;
 268 error:
 269         kfree(txq->txb);
 270         txq->txb = NULL;
 271         /* since txq->cmd has been zeroed,
 272          * all non allocated cmd[i] will be NULL */
 273         if (txq->cmd)
 274                 for (i = 0; i < slots_num; i++)
 275                         kfree(txq->cmd[i]);
 276         kfree(txq->meta);
 277         kfree(txq->cmd);
 278         txq->meta = NULL;
 279         txq->cmd = NULL;
 280
 281         return -ENOMEM;
 282
 283 }
 284
 285 static int iwl_trans_txq_init(struct iwl_priv *priv, struct iwl_tx_queue *txq,
 286                       int slots_num, u32 txq_id)
 287 {
 288         int ret;
 289
 290         txq->need_update = 0;
 291         memset(txq->meta, 0, sizeof(txq->meta[0]) * slots_num);
 292
 293         /*
 294          * For the default queues 0-3, set up the swq_id
 295          * already -- all others need to get one later
 296          * (if they need one at all).
 297          */
 298         if (txq_id < 4)
 299                 iwl_set_swq_id(txq, txq_id, txq_id);
 300
 301         /* TFD_QUEUE_SIZE_MAX must be power-of-two size, otherwise
 302          * iwl_queue_inc_wrap and iwl_queue_dec_wrap are broken. */
 303         BUILD_BUG_ON(TFD_QUEUE_SIZE_MAX & (TFD_QUEUE_SIZE_MAX - 1));
 304
 305         /* Initialize queue's high/low-water marks, and head/tail indexes */
 306         ret = iwl_queue_init(priv, &txq->q, TFD_QUEUE_SIZE_MAX, slots_num,
 307                         txq_id);
 308         if (ret)
 309                 return ret;
 310
 311         /*
 312          * Tell nic where to find circular buffer of Tx Frame Descriptors for
 313          * given Tx queue, and enable the DMA channel used for that queue.
 314          * Circular buffer (TFD queue in DRAM) physical base address */
 315         iwl_write_direct32(priv, FH_MEM_CBBC_QUEUE(txq_id),
 316                              txq->q.dma_addr >> 8);
 317
 318         return 0;
 319 }
 320
 321 /**
 322  * iwl_tx_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  */
 329 static void iwl_tx_queue_free(struct iwl_priv *priv, int txq_id)
 330 {
 331         struct iwl_tx_queue *txq = &priv->txq[txq_id];
 332         struct device *dev = priv->bus.dev;
 333         int i;
 334         if (WARN_ON(!txq))
 335                 return;
 336
 337         iwl_tx_queue_unmap(priv, txq_id);
 338
 339         /* De-alloc array of command/tx buffers */
 340         for (i = 0; i < txq->q.n_window; i++)
 341                 kfree(txq->cmd[i]);
 342
 343         /* De-alloc circular buffer of TFDs */
 344         if (txq->q.n_bd) {
 345                 dma_free_coherent(dev, priv->hw_params.tfd_size *
 346                                   txq->q.n_bd, txq->tfds, txq->q.dma_addr);
 347                 memset(&txq->q.dma_addr, 0, sizeof(txq->q.dma_addr));
 348         }
 349
 350         /* De-alloc array of per-TFD driver data */
 351         kfree(txq->txb);
 352         txq->txb = NULL;
 353
 354         /* deallocate arrays */
 355         kfree(txq->cmd);
 356         kfree(txq->meta);
 357         txq->cmd = NULL;
 358         txq->meta = NULL;
 359
 360         /* 0-fill queue descriptor structure */
 361         memset(txq, 0, sizeof(*txq));
 362 }
 363
 364 /**
 365  * iwl_trans_tx_free - Free TXQ Context
 366  *
 367  * Destroy all TX DMA queues and structures
 368  */
 369 static void iwl_trans_tx_free(struct iwl_priv *priv)
 370 {
 371         int txq_id;
 372
 373         /* Tx queues */
 374         if (priv->txq) {
 375                 for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++)
 376                         iwl_tx_queue_free(priv, txq_id);
 377         }
 378
 379         kfree(priv->txq);
 380         priv->txq = NULL;
 381
 382         iwlagn_free_dma_ptr(priv, &priv->kw);
 383
 384         iwlagn_free_dma_ptr(priv, &priv->scd_bc_tbls);
 385 }
 386
 387 /**
 388  * iwl_trans_tx_alloc - allocate TX context
 389  * Allocate all Tx DMA structures and initialize them
 390  *
 391  * @param priv
 392  * @return error code
 393  */
 394 static int iwl_trans_tx_alloc(struct iwl_priv *priv)
 395 {
 396         int ret;
 397         int txq_id, slots_num;
 398
 399         /*It is not allowed to alloc twice, so warn when this happens.
 400          * We cannot rely on the previous allocation, so free and fail */
 401         if (WARN_ON(priv->txq)) {
 402                 ret = -EINVAL;
 403                 goto error;
 404         }
 405
 406         ret = iwlagn_alloc_dma_ptr(priv, &priv->scd_bc_tbls,
 407                                 priv->hw_params.scd_bc_tbls_size);
 408         if (ret) {
 409                 IWL_ERR(priv, "Scheduler BC Table allocation failed\n");
 410                 goto error;
 411         }
 412
 413         /* Alloc keep-warm buffer */
 414         ret = iwlagn_alloc_dma_ptr(priv, &priv->kw, IWL_KW_SIZE);
 415         if (ret) {
 416                 IWL_ERR(priv, "Keep Warm allocation failed\n");
 417                 goto error;
 418         }
 419
 420         priv->txq = kzalloc(sizeof(struct iwl_tx_queue) *
 421                         priv->cfg->base_params->num_of_queues, GFP_KERNEL);
 422         if (!priv->txq) {
 423                 IWL_ERR(priv, "Not enough memory for txq\n");
 424                 ret = ENOMEM;
 425                 goto error;
 426         }
 427
 428         /* Alloc and init all Tx queues, including the command queue (#4/#9) */
 429         for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++) {
 430                 slots_num = (txq_id == priv->cmd_queue) ?
 431                                         TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
 432                 ret = iwl_trans_txq_alloc(priv, &priv->txq[txq_id], slots_num,
 433                                        txq_id);
 434                 if (ret) {
 435                         IWL_ERR(priv, "Tx %d queue alloc failed\n", txq_id);
 436                         goto error;
 437                 }
 438         }
 439
 440         return 0;
 441
 442 error:
 443         priv->trans.ops->tx_free(priv);
 444
 445         return ret;
 446 }
 447 static int iwl_trans_tx_init(struct iwl_priv *priv)
 448 {
 449         int ret;
 450         int txq_id, slots_num;
 451         unsigned long flags;
 452         bool alloc = false;
 453
 454         if (!priv->txq) {
 455                 ret = iwl_trans_tx_alloc(priv);
 456                 if (ret)
 457                         goto error;
 458                 alloc = true;
 459         }
 460
 461         spin_lock_irqsave(&priv->lock, flags);
 462
 463         /* Turn off all Tx DMA fifos */
 464         iwl_write_prph(priv, IWLAGN_SCD_TXFACT, 0);
 465
 466         /* Tell NIC where to find the "keep warm" buffer */
 467         iwl_write_direct32(priv, FH_KW_MEM_ADDR_REG, priv->kw.dma >> 4);
 468
 469         spin_unlock_irqrestore(&priv->lock, flags);
 470
 471         /* Alloc and init all Tx queues, including the command queue (#4/#9) */
 472         for (txq_id = 0; txq_id < priv->hw_params.max_txq_num; txq_id++) {
 473                 slots_num = (txq_id == priv->cmd_queue) ?
 474                                         TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
 475                 ret = iwl_trans_txq_init(priv, &priv->txq[txq_id], slots_num,
 476                                        txq_id);
 477                 if (ret) {
 478                         IWL_ERR(priv, "Tx %d queue init failed\n", txq_id);
 479                         goto error;
 480                 }
 481         }
 482
 483         return 0;
 484 error:
 485         /*Upon error, free only if we allocated something */
 486         if (alloc)
 487                 priv->trans.ops->tx_free(priv);
 488         return ret;
 489 }
 490
 491 static const struct iwl_trans_ops trans_ops = {
 492         .rx_init = iwl_trans_rx_init,
 493         .rx_free = iwl_trans_rx_free,
 494
 495         .tx_init = iwl_trans_tx_init,
 496         .tx_free = iwl_trans_tx_free,
 497 };
 498
 499 void iwl_trans_register(struct iwl_trans *trans)
 500 {
 501         trans->ops = &trans_ops;
 502 }