tx-gen2.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
    2 /*
    3  * Copyright (C) 2017 Intel Deutschland GmbH
    4  * Copyright (C) 2018-2020 Intel Corporation
    5  */
    6 #ifdef CONFIG_INET
    7 #include <net/tso.h>
    8 #endif
    9 #include <linux/tcp.h>
   10 
   11 #include "iwl-debug.h"
   12 #include "iwl-csr.h"
   13 #include "iwl-io.h"
   14 #include "internal.h"
   15 #include "fw/api/tx.h"
   16 #include "queue/tx.h"
   17 
   18 /*************** HOST COMMAND QUEUE FUNCTIONS   *****/
   19 
   20 /*
   21  * iwl_pcie_gen2_enqueue_hcmd - enqueue a uCode command
   22  * @priv: device private data point
   23  * @cmd: a pointer to the ucode command structure
   24  *
   25  * The function returns < 0 values to indicate the operation
   26  * failed. On success, it returns the index (>= 0) of command in the
   27  * command queue.
   28  */
   29 int iwl_pcie_gen2_enqueue_hcmd(struct iwl_trans *trans,
   30                                struct iwl_host_cmd *cmd)
   31 {
   32         struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
   33         struct iwl_txq *txq = trans->txqs.txq[trans->txqs.cmd.q_id];
   34         struct iwl_device_cmd *out_cmd;
   35         struct iwl_cmd_meta *out_meta;
   36         void *dup_buf = NULL;
   37         dma_addr_t phys_addr;
   38         int i, cmd_pos, idx;
   39         u16 copy_size, cmd_size, tb0_size;
   40         bool had_nocopy = false;
   41         u8 group_id = iwl_cmd_groupid(cmd->id);
   42         const u8 *cmddata[IWL_MAX_CMD_TBS_PER_TFD];
   43         u16 cmdlen[IWL_MAX_CMD_TBS_PER_TFD];
   44         struct iwl_tfh_tfd *tfd;
   45         unsigned long flags;
   46 
   47         copy_size = sizeof(struct iwl_cmd_header_wide);
   48         cmd_size = sizeof(struct iwl_cmd_header_wide);
   49 
   50         for (i = 0; i < IWL_MAX_CMD_TBS_PER_TFD; i++) {
   51                 cmddata[i] = cmd->data[i];
   52                 cmdlen[i] = cmd->len[i];
   53 
   54                 if (!cmd->len[i])
   55                         continue;
   56 
   57                 /* need at least IWL_FIRST_TB_SIZE copied */
   58                 if (copy_size < IWL_FIRST_TB_SIZE) {
   59                         int copy = IWL_FIRST_TB_SIZE - copy_size;
   60 
   61                         if (copy > cmdlen[i])
   62                                 copy = cmdlen[i];
   63                         cmdlen[i] -= copy;
   64                         cmddata[i] += copy;
   65                         copy_size += copy;
   66                 }
   67 
   68                 if (cmd->dataflags[i] & IWL_HCMD_DFL_NOCOPY) {
   69                         had_nocopy = true;
   70                         if (WARN_ON(cmd->dataflags[i] & IWL_HCMD_DFL_DUP)) {
   71                                 idx = -EINVAL;
   72                                 goto free_dup_buf;
   73                         }
   74                 } else if (cmd->dataflags[i] & IWL_HCMD_DFL_DUP) {
   75                         /*
   76                          * This is also a chunk that isn't copied
   77                          * to the static buffer so set had_nocopy.
   78                          */
   79                         had_nocopy = true;
   80 
   81                         /* only allowed once */
   82                         if (WARN_ON(dup_buf)) {
   83                                 idx = -EINVAL;
   84                                 goto free_dup_buf;
   85                         }
   86 
   87                         dup_buf = kmemdup(cmddata[i], cmdlen[i],
   88                                           GFP_ATOMIC);
   89                         if (!dup_buf)
   90                                 return -ENOMEM;
   91                 } else {
   92                         /* NOCOPY must not be followed by normal! */
   93                         if (WARN_ON(had_nocopy)) {
   94                                 idx = -EINVAL;
   95                                 goto free_dup_buf;
   96                         }
   97                         copy_size += cmdlen[i];
   98                 }
   99                 cmd_size += cmd->len[i];
  100         }
  101 
  102         /*
  103          * If any of the command structures end up being larger than the
  104          * TFD_MAX_PAYLOAD_SIZE and they aren't dynamically allocated into
  105          * separate TFDs, then we will need to increase the size of the buffers
  106          */
  107         if (WARN(copy_size > TFD_MAX_PAYLOAD_SIZE,
  108                  "Command %s (%#x) is too large (%d bytes)\n",
  109                  iwl_get_cmd_string(trans, cmd->id), cmd->id, copy_size)) {
  110                 idx = -EINVAL;
  111                 goto free_dup_buf;
  112         }
  113 
  114         spin_lock_irqsave(&txq->lock, flags);
  115 
  116         idx = iwl_txq_get_cmd_index(txq, txq->write_ptr);
  117         tfd = iwl_txq_get_tfd(trans, txq, txq->write_ptr);
  118         memset(tfd, 0, sizeof(*tfd));
  119 
  120         if (iwl_txq_space(trans, txq) < ((cmd->flags & CMD_ASYNC) ? 2 : 1)) {
  121                 spin_unlock_irqrestore(&txq->lock, flags);
  122 
  123                 IWL_ERR(trans, "No space in command queue\n");
  124                 iwl_op_mode_cmd_queue_full(trans->op_mode);
  125                 idx = -ENOSPC;
  126                 goto free_dup_buf;
  127         }
  128 
  129         out_cmd = txq->entries[idx].cmd;
  130         out_meta = &txq->entries[idx].meta;
  131 
  132         /* re-initialize to NULL */
  133         memset(out_meta, 0, sizeof(*out_meta));
  134         if (cmd->flags & CMD_WANT_SKB)
  135                 out_meta->source = cmd;
  136 
  137         /* set up the header */
  138         out_cmd->hdr_wide.cmd = iwl_cmd_opcode(cmd->id);
  139         out_cmd->hdr_wide.group_id = group_id;
  140         out_cmd->hdr_wide.version = iwl_cmd_version(cmd->id);
  141         out_cmd->hdr_wide.length =
  142                 cpu_to_le16(cmd_size - sizeof(struct iwl_cmd_header_wide));
  143         out_cmd->hdr_wide.reserved = 0;
  144         out_cmd->hdr_wide.sequence =
  145                 cpu_to_le16(QUEUE_TO_SEQ(trans->txqs.cmd.q_id) |
  146                                          INDEX_TO_SEQ(txq->write_ptr));
  147 
  148         cmd_pos = sizeof(struct iwl_cmd_header_wide);
  149         copy_size = sizeof(struct iwl_cmd_header_wide);
  150 
  151         /* and copy the data that needs to be copied */
  152         for (i = 0; i < IWL_MAX_CMD_TBS_PER_TFD; i++) {
  153                 int copy;
  154 
  155                 if (!cmd->len[i])
  156                         continue;
  157 
  158                 /* copy everything if not nocopy/dup */
  159                 if (!(cmd->dataflags[i] & (IWL_HCMD_DFL_NOCOPY |
  160                                            IWL_HCMD_DFL_DUP))) {
  161                         copy = cmd->len[i];
  162 
  163                         memcpy((u8 *)out_cmd + cmd_pos, cmd->data[i], copy);
  164                         cmd_pos += copy;
  165                         copy_size += copy;
  166                         continue;
  167                 }
  168 
  169                 /*
  170                  * Otherwise we need at least IWL_FIRST_TB_SIZE copied
  171                  * in total (for bi-directional DMA), but copy up to what
  172                  * we can fit into the payload for debug dump purposes.
  173                  */
  174                 copy = min_t(int, TFD_MAX_PAYLOAD_SIZE - cmd_pos, cmd->len[i]);
  175 
  176                 memcpy((u8 *)out_cmd + cmd_pos, cmd->data[i], copy);
  177                 cmd_pos += copy;
  178 
  179                 /* However, treat copy_size the proper way, we need it below */
  180                 if (copy_size < IWL_FIRST_TB_SIZE) {
  181                         copy = IWL_FIRST_TB_SIZE - copy_size;
  182 
  183                         if (copy > cmd->len[i])
  184                                 copy = cmd->len[i];
  185                         copy_size += copy;
  186                 }
  187         }
  188 
  189         IWL_DEBUG_HC(trans,
  190                      "Sending command %s (%.2x.%.2x), seq: 0x%04X, %d bytes at %d[%d]:%d\n",
  191                      iwl_get_cmd_string(trans, cmd->id), group_id,
  192                      out_cmd->hdr.cmd, le16_to_cpu(out_cmd->hdr.sequence),
  193                      cmd_size, txq->write_ptr, idx, trans->txqs.cmd.q_id);
  194 
  195         /* start the TFD with the minimum copy bytes */
  196         tb0_size = min_t(int, copy_size, IWL_FIRST_TB_SIZE);
  197         memcpy(&txq->first_tb_bufs[idx], out_cmd, tb0_size);
  198         iwl_txq_gen2_set_tb(trans, tfd, iwl_txq_get_first_tb_dma(txq, idx),
  199                             tb0_size);
  200 
  201         /* map first command fragment, if any remains */
  202         if (copy_size > tb0_size) {
  203                 phys_addr = dma_map_single(trans->dev,
  204                                            (u8 *)out_cmd + tb0_size,
  205                                            copy_size - tb0_size,
  206                                            DMA_TO_DEVICE);
  207                 if (dma_mapping_error(trans->dev, phys_addr)) {
  208                         idx = -ENOMEM;
  209                         iwl_txq_gen2_tfd_unmap(trans, out_meta, tfd);
  210                         goto out;
  211                 }
  212                 iwl_txq_gen2_set_tb(trans, tfd, phys_addr,
  213                                     copy_size - tb0_size);
  214         }
  215 
  216         /* map the remaining (adjusted) nocopy/dup fragments */
  217         for (i = 0; i < IWL_MAX_CMD_TBS_PER_TFD; i++) {
  218                 void *data = (void *)(uintptr_t)cmddata[i];
  219 
  220                 if (!cmdlen[i])
  221                         continue;
  222                 if (!(cmd->dataflags[i] & (IWL_HCMD_DFL_NOCOPY |
  223                                            IWL_HCMD_DFL_DUP)))
  224                         continue;
  225                 if (cmd->dataflags[i] & IWL_HCMD_DFL_DUP)
  226                         data = dup_buf;
  227                 phys_addr = dma_map_single(trans->dev, data,
  228                                            cmdlen[i], DMA_TO_DEVICE);
  229                 if (dma_mapping_error(trans->dev, phys_addr)) {
  230                         idx = -ENOMEM;
  231                         iwl_txq_gen2_tfd_unmap(trans, out_meta, tfd);
  232                         goto out;
  233                 }
  234                 iwl_txq_gen2_set_tb(trans, tfd, phys_addr, cmdlen[i]);
  235         }
  236 
  237         BUILD_BUG_ON(IWL_TFH_NUM_TBS > sizeof(out_meta->tbs) * BITS_PER_BYTE);
  238         out_meta->flags = cmd->flags;
  239         if (WARN_ON_ONCE(txq->entries[idx].free_buf))
  240                 kfree_sensitive(txq->entries[idx].free_buf);
  241         txq->entries[idx].free_buf = dup_buf;
  242 
  243         trace_iwlwifi_dev_hcmd(trans->dev, cmd, cmd_size, &out_cmd->hdr_wide);
  244 
  245         /* start timer if queue currently empty */
  246         if (txq->read_ptr == txq->write_ptr && txq->wd_timeout)
  247                 mod_timer(&txq->stuck_timer, jiffies + txq->wd_timeout);
  248 
  249         spin_lock(&trans_pcie->reg_lock);
  250         /* Increment and update queue's write index */
  251         txq->write_ptr = iwl_txq_inc_wrap(trans, txq->write_ptr);
  252         iwl_txq_inc_wr_ptr(trans, txq);
  253         spin_unlock(&trans_pcie->reg_lock);
  254 
  255 out:
  256         spin_unlock_irqrestore(&txq->lock, flags);
  257 free_dup_buf:
  258         if (idx < 0)
  259                 kfree(dup_buf);
  260         return idx;
  261 }
Cache object: 57693c948fa20500d41746ca58875f6a
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/contrib/dev/iwlwifi/pcie/tx-gen2.c

FreeBSD/Linux Kernel Cross Reference
sys/contrib/dev/iwlwifi/pcie/tx-gen2.c
