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) 2017 Intel Deutschland GmbH
9 * Copyright(c) 2018 - 2020 Intel Corporation
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of version 2 of the GNU General Public License as
13 * published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * BSD LICENSE
21 *
22 * Copyright(c) 2017 Intel Deutschland GmbH
23 * Copyright(c) 2018 - 2020 Intel Corporation
24 * All rights reserved.
25 *
26 * Redistribution and use in source and binary forms, with or without
27 * modification, are permitted provided that the following conditions
28 * are met:
29 *
30 * * Redistributions of source code must retain the above copyright
31 * notice, this list of conditions and the following disclaimer.
32 * * Redistributions in binary form must reproduce the above copyright
33 * notice, this list of conditions and the following disclaimer in
34 * the documentation and/or other materials provided with the
35 * distribution.
36 * * Neither the name Intel Corporation nor the names of its
37 * contributors may be used to endorse or promote products derived
38 * from this software without specific prior written permission.
39 *
40 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
41 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
42 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
43 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
44 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
46 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
47 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
48 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
49 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
50 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
51 *
52 *****************************************************************************/
53 #include <net/tso.h>
54 #include <linux/tcp.h>
55
56 #include "iwl-debug.h"
57 #include "iwl-csr.h"
58 #include "iwl-io.h"
59 #include "internal.h"
60 #include "fw/api/tx.h"
61 #include "queue/tx.h"
62
63 /*************** HOST COMMAND QUEUE FUNCTIONS *****/
64
65 /*
66 * iwl_pcie_gen2_enqueue_hcmd - enqueue a uCode command
67 * @priv: device private data point
68 * @cmd: a pointer to the ucode command structure
69 *
70 * The function returns < 0 values to indicate the operation
71 * failed. On success, it returns the index (>= 0) of command in the
72 * command queue.
73 */
iwl_pcie_gen2_enqueue_hcmd(struct iwl_trans * trans,struct iwl_host_cmd * cmd)74 static int iwl_pcie_gen2_enqueue_hcmd(struct iwl_trans *trans,
75 struct iwl_host_cmd *cmd)
76 {
77 struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
78 struct iwl_txq *txq = trans->txqs.txq[trans->txqs.cmd.q_id];
79 struct iwl_device_cmd *out_cmd;
80 struct iwl_cmd_meta *out_meta;
81 void *dup_buf = NULL;
82 dma_addr_t phys_addr;
83 int i, cmd_pos, idx;
84 u16 copy_size, cmd_size, tb0_size;
85 bool had_nocopy = false;
86 u8 group_id = iwl_cmd_groupid(cmd->id);
87 const u8 *cmddata[IWL_MAX_CMD_TBS_PER_TFD];
88 u16 cmdlen[IWL_MAX_CMD_TBS_PER_TFD];
89 struct iwl_tfh_tfd *tfd;
90 unsigned long flags;
91
92 copy_size = sizeof(struct iwl_cmd_header_wide);
93 cmd_size = sizeof(struct iwl_cmd_header_wide);
94
95 for (i = 0; i < IWL_MAX_CMD_TBS_PER_TFD; i++) {
96 cmddata[i] = cmd->data[i];
97 cmdlen[i] = cmd->len[i];
98
99 if (!cmd->len[i])
100 continue;
101
102 /* need at least IWL_FIRST_TB_SIZE copied */
103 if (copy_size < IWL_FIRST_TB_SIZE) {
104 int copy = IWL_FIRST_TB_SIZE - copy_size;
105
106 if (copy > cmdlen[i])
107 copy = cmdlen[i];
108 cmdlen[i] -= copy;
109 cmddata[i] += copy;
110 copy_size += copy;
111 }
112
113 if (cmd->dataflags[i] & IWL_HCMD_DFL_NOCOPY) {
114 had_nocopy = true;
115 if (WARN_ON(cmd->dataflags[i] & IWL_HCMD_DFL_DUP)) {
116 idx = -EINVAL;
117 goto free_dup_buf;
118 }
119 } else if (cmd->dataflags[i] & IWL_HCMD_DFL_DUP) {
120 /*
121 * This is also a chunk that isn't copied
122 * to the static buffer so set had_nocopy.
123 */
124 had_nocopy = true;
125
126 /* only allowed once */
127 if (WARN_ON(dup_buf)) {
128 idx = -EINVAL;
129 goto free_dup_buf;
130 }
131
132 dup_buf = kmemdup(cmddata[i], cmdlen[i],
133 GFP_ATOMIC);
134 if (!dup_buf)
135 return -ENOMEM;
136 } else {
137 /* NOCOPY must not be followed by normal! */
138 if (WARN_ON(had_nocopy)) {
139 idx = -EINVAL;
140 goto free_dup_buf;
141 }
142 copy_size += cmdlen[i];
143 }
144 cmd_size += cmd->len[i];
145 }
146
147 /*
148 * If any of the command structures end up being larger than the
149 * TFD_MAX_PAYLOAD_SIZE and they aren't dynamically allocated into
150 * separate TFDs, then we will need to increase the size of the buffers
151 */
152 if (WARN(copy_size > TFD_MAX_PAYLOAD_SIZE,
153 "Command %s (%#x) is too large (%d bytes)\n",
154 iwl_get_cmd_string(trans, cmd->id), cmd->id, copy_size)) {
155 idx = -EINVAL;
156 goto free_dup_buf;
157 }
158
159 spin_lock_irqsave(&txq->lock, flags);
160
161 idx = iwl_txq_get_cmd_index(txq, txq->write_ptr);
162 tfd = iwl_txq_get_tfd(trans, txq, txq->write_ptr);
163 memset(tfd, 0, sizeof(*tfd));
164
165 if (iwl_txq_space(trans, txq) < ((cmd->flags & CMD_ASYNC) ? 2 : 1)) {
166 spin_unlock_irqrestore(&txq->lock, flags);
167
168 IWL_ERR(trans, "No space in command queue\n");
169 iwl_op_mode_cmd_queue_full(trans->op_mode);
170 idx = -ENOSPC;
171 goto free_dup_buf;
172 }
173
174 out_cmd = txq->entries[idx].cmd;
175 out_meta = &txq->entries[idx].meta;
176
177 /* re-initialize to NULL */
178 memset(out_meta, 0, sizeof(*out_meta));
179 if (cmd->flags & CMD_WANT_SKB)
180 out_meta->source = cmd;
181
182 /* set up the header */
183 out_cmd->hdr_wide.cmd = iwl_cmd_opcode(cmd->id);
184 out_cmd->hdr_wide.group_id = group_id;
185 out_cmd->hdr_wide.version = iwl_cmd_version(cmd->id);
186 out_cmd->hdr_wide.length =
187 cpu_to_le16(cmd_size - sizeof(struct iwl_cmd_header_wide));
188 out_cmd->hdr_wide.reserved = 0;
189 out_cmd->hdr_wide.sequence =
190 cpu_to_le16(QUEUE_TO_SEQ(trans->txqs.cmd.q_id) |
191 INDEX_TO_SEQ(txq->write_ptr));
192
193 cmd_pos = sizeof(struct iwl_cmd_header_wide);
194 copy_size = sizeof(struct iwl_cmd_header_wide);
195
196 /* and copy the data that needs to be copied */
197 for (i = 0; i < IWL_MAX_CMD_TBS_PER_TFD; i++) {
198 int copy;
199
200 if (!cmd->len[i])
201 continue;
202
203 /* copy everything if not nocopy/dup */
204 if (!(cmd->dataflags[i] & (IWL_HCMD_DFL_NOCOPY |
205 IWL_HCMD_DFL_DUP))) {
206 copy = cmd->len[i];
207
208 memcpy((u8 *)out_cmd + cmd_pos, cmd->data[i], copy);
209 cmd_pos += copy;
210 copy_size += copy;
211 continue;
212 }
213
214 /*
215 * Otherwise we need at least IWL_FIRST_TB_SIZE copied
216 * in total (for bi-directional DMA), but copy up to what
217 * we can fit into the payload for debug dump purposes.
218 */
219 copy = min_t(int, TFD_MAX_PAYLOAD_SIZE - cmd_pos, cmd->len[i]);
220
221 memcpy((u8 *)out_cmd + cmd_pos, cmd->data[i], copy);
222 cmd_pos += copy;
223
224 /* However, treat copy_size the proper way, we need it below */
225 if (copy_size < IWL_FIRST_TB_SIZE) {
226 copy = IWL_FIRST_TB_SIZE - copy_size;
227
228 if (copy > cmd->len[i])
229 copy = cmd->len[i];
230 copy_size += copy;
231 }
232 }
233
234 IWL_DEBUG_HC(trans,
235 "Sending command %s (%.2x.%.2x), seq: 0x%04X, %d bytes at %d[%d]:%d\n",
236 iwl_get_cmd_string(trans, cmd->id), group_id,
237 out_cmd->hdr.cmd, le16_to_cpu(out_cmd->hdr.sequence),
238 cmd_size, txq->write_ptr, idx, trans->txqs.cmd.q_id);
239
240 /* start the TFD with the minimum copy bytes */
241 tb0_size = min_t(int, copy_size, IWL_FIRST_TB_SIZE);
242 memcpy(&txq->first_tb_bufs[idx], out_cmd, tb0_size);
243 iwl_txq_gen2_set_tb(trans, tfd, iwl_txq_get_first_tb_dma(txq, idx),
244 tb0_size);
245
246 /* map first command fragment, if any remains */
247 if (copy_size > tb0_size) {
248 phys_addr = dma_map_single(trans->dev,
249 (u8 *)out_cmd + tb0_size,
250 copy_size - tb0_size,
251 DMA_TO_DEVICE);
252 if (dma_mapping_error(trans->dev, phys_addr)) {
253 idx = -ENOMEM;
254 iwl_txq_gen2_tfd_unmap(trans, out_meta, tfd);
255 goto out;
256 }
257 iwl_txq_gen2_set_tb(trans, tfd, phys_addr,
258 copy_size - tb0_size);
259 }
260
261 /* map the remaining (adjusted) nocopy/dup fragments */
262 for (i = 0; i < IWL_MAX_CMD_TBS_PER_TFD; i++) {
263 const void *data = cmddata[i];
264
265 if (!cmdlen[i])
266 continue;
267 if (!(cmd->dataflags[i] & (IWL_HCMD_DFL_NOCOPY |
268 IWL_HCMD_DFL_DUP)))
269 continue;
270 if (cmd->dataflags[i] & IWL_HCMD_DFL_DUP)
271 data = dup_buf;
272 phys_addr = dma_map_single(trans->dev, (void *)data,
273 cmdlen[i], DMA_TO_DEVICE);
274 if (dma_mapping_error(trans->dev, phys_addr)) {
275 idx = -ENOMEM;
276 iwl_txq_gen2_tfd_unmap(trans, out_meta, tfd);
277 goto out;
278 }
279 iwl_txq_gen2_set_tb(trans, tfd, phys_addr, cmdlen[i]);
280 }
281
282 BUILD_BUG_ON(IWL_TFH_NUM_TBS > sizeof(out_meta->tbs) * BITS_PER_BYTE);
283 out_meta->flags = cmd->flags;
284 if (WARN_ON_ONCE(txq->entries[idx].free_buf))
285 kfree_sensitive(txq->entries[idx].free_buf);
286 txq->entries[idx].free_buf = dup_buf;
287
288 trace_iwlwifi_dev_hcmd(trans->dev, cmd, cmd_size, &out_cmd->hdr_wide);
289
290 /* start timer if queue currently empty */
291 if (txq->read_ptr == txq->write_ptr && txq->wd_timeout)
292 mod_timer(&txq->stuck_timer, jiffies + txq->wd_timeout);
293
294 spin_lock(&trans_pcie->reg_lock);
295 /* Increment and update queue's write index */
296 txq->write_ptr = iwl_txq_inc_wrap(trans, txq->write_ptr);
297 iwl_txq_inc_wr_ptr(trans, txq);
298 spin_unlock(&trans_pcie->reg_lock);
299
300 out:
301 spin_unlock_irqrestore(&txq->lock, flags);
302 free_dup_buf:
303 if (idx < 0)
304 kfree(dup_buf);
305 return idx;
306 }
307
308 #define HOST_COMPLETE_TIMEOUT (2 * HZ)
309
iwl_pcie_gen2_send_hcmd_sync(struct iwl_trans * trans,struct iwl_host_cmd * cmd)310 static int iwl_pcie_gen2_send_hcmd_sync(struct iwl_trans *trans,
311 struct iwl_host_cmd *cmd)
312 {
313 struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
314 const char *cmd_str = iwl_get_cmd_string(trans, cmd->id);
315 struct iwl_txq *txq = trans->txqs.txq[trans->txqs.cmd.q_id];
316 int cmd_idx;
317 int ret;
318
319 IWL_DEBUG_INFO(trans, "Attempting to send sync command %s\n", cmd_str);
320
321 if (WARN(test_and_set_bit(STATUS_SYNC_HCMD_ACTIVE,
322 &trans->status),
323 "Command %s: a command is already active!\n", cmd_str))
324 return -EIO;
325
326 IWL_DEBUG_INFO(trans, "Setting HCMD_ACTIVE for command %s\n", cmd_str);
327
328 cmd_idx = iwl_pcie_gen2_enqueue_hcmd(trans, cmd);
329 if (cmd_idx < 0) {
330 ret = cmd_idx;
331 clear_bit(STATUS_SYNC_HCMD_ACTIVE, &trans->status);
332 IWL_ERR(trans, "Error sending %s: enqueue_hcmd failed: %d\n",
333 cmd_str, ret);
334 return ret;
335 }
336
337 ret = wait_event_timeout(trans_pcie->wait_command_queue,
338 !test_bit(STATUS_SYNC_HCMD_ACTIVE,
339 &trans->status),
340 HOST_COMPLETE_TIMEOUT);
341 if (!ret) {
342 IWL_ERR(trans, "Error sending %s: time out after %dms.\n",
343 cmd_str, jiffies_to_msecs(HOST_COMPLETE_TIMEOUT));
344
345 IWL_ERR(trans, "Current CMD queue read_ptr %d write_ptr %d\n",
346 txq->read_ptr, txq->write_ptr);
347
348 clear_bit(STATUS_SYNC_HCMD_ACTIVE, &trans->status);
349 IWL_DEBUG_INFO(trans, "Clearing HCMD_ACTIVE for command %s\n",
350 cmd_str);
351 ret = -ETIMEDOUT;
352
353 iwl_trans_pcie_sync_nmi(trans);
354 goto cancel;
355 }
356
357 if (test_bit(STATUS_FW_ERROR, &trans->status)) {
358 IWL_ERR(trans, "FW error in SYNC CMD %s\n", cmd_str);
359 dump_stack();
360 ret = -EIO;
361 goto cancel;
362 }
363
364 if (!(cmd->flags & CMD_SEND_IN_RFKILL) &&
365 test_bit(STATUS_RFKILL_OPMODE, &trans->status)) {
366 IWL_DEBUG_RF_KILL(trans, "RFKILL in SYNC CMD... no rsp\n");
367 ret = -ERFKILL;
368 goto cancel;
369 }
370
371 if ((cmd->flags & CMD_WANT_SKB) && !cmd->resp_pkt) {
372 IWL_ERR(trans, "Error: Response NULL in '%s'\n", cmd_str);
373 ret = -EIO;
374 goto cancel;
375 }
376
377 return 0;
378
379 cancel:
380 if (cmd->flags & CMD_WANT_SKB) {
381 /*
382 * Cancel the CMD_WANT_SKB flag for the cmd in the
383 * TX cmd queue. Otherwise in case the cmd comes
384 * in later, it will possibly set an invalid
385 * address (cmd->meta.source).
386 */
387 txq->entries[cmd_idx].meta.flags &= ~CMD_WANT_SKB;
388 }
389
390 if (cmd->resp_pkt) {
391 iwl_free_resp(cmd);
392 cmd->resp_pkt = NULL;
393 }
394
395 return ret;
396 }
397
iwl_trans_pcie_gen2_send_hcmd(struct iwl_trans * trans,struct iwl_host_cmd * cmd)398 int iwl_trans_pcie_gen2_send_hcmd(struct iwl_trans *trans,
399 struct iwl_host_cmd *cmd)
400 {
401 if (!(cmd->flags & CMD_SEND_IN_RFKILL) &&
402 test_bit(STATUS_RFKILL_OPMODE, &trans->status)) {
403 IWL_DEBUG_RF_KILL(trans, "Dropping CMD 0x%x: RF KILL\n",
404 cmd->id);
405 return -ERFKILL;
406 }
407
408 if (cmd->flags & CMD_ASYNC) {
409 int ret;
410
411 /* An asynchronous command can not expect an SKB to be set. */
412 if (WARN_ON(cmd->flags & CMD_WANT_SKB))
413 return -EINVAL;
414
415 ret = iwl_pcie_gen2_enqueue_hcmd(trans, cmd);
416 if (ret < 0) {
417 IWL_ERR(trans,
418 "Error sending %s: enqueue_hcmd failed: %d\n",
419 iwl_get_cmd_string(trans, cmd->id), ret);
420 return ret;
421 }
422 return 0;
423 }
424
425 return iwl_pcie_gen2_send_hcmd_sync(trans, cmd);
426 }
427
428