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