1dc7e38acSHans Petter Selasky /*-
28d1eeedbSHans Petter Selasky * Copyright (c) 2013-2019, Mellanox Technologies, Ltd. All rights reserved.
3dc7e38acSHans Petter Selasky *
4dc7e38acSHans Petter Selasky * Redistribution and use in source and binary forms, with or without
5dc7e38acSHans Petter Selasky * modification, are permitted provided that the following conditions
6dc7e38acSHans Petter Selasky * are met:
7dc7e38acSHans Petter Selasky * 1. Redistributions of source code must retain the above copyright
8dc7e38acSHans Petter Selasky * notice, this list of conditions and the following disclaimer.
9dc7e38acSHans Petter Selasky * 2. Redistributions in binary form must reproduce the above copyright
10dc7e38acSHans Petter Selasky * notice, this list of conditions and the following disclaimer in the
11dc7e38acSHans Petter Selasky * documentation and/or other materials provided with the distribution.
12dc7e38acSHans Petter Selasky *
13dc7e38acSHans Petter Selasky * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS `AS IS' AND
14dc7e38acSHans Petter Selasky * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15dc7e38acSHans Petter Selasky * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16dc7e38acSHans Petter Selasky * ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
17dc7e38acSHans Petter Selasky * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18dc7e38acSHans Petter Selasky * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19dc7e38acSHans Petter Selasky * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20dc7e38acSHans Petter Selasky * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21dc7e38acSHans Petter Selasky * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22dc7e38acSHans Petter Selasky * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
23dc7e38acSHans Petter Selasky * SUCH DAMAGE.
24dc7e38acSHans Petter Selasky */
25dc7e38acSHans Petter Selasky
26ee9d634bSKonstantin Belousov #include "opt_rss.h"
27ee9d634bSKonstantin Belousov #include "opt_ratelimit.h"
28ee9d634bSKonstantin Belousov
29dc7e38acSHans Petter Selasky #include <linux/module.h>
30dc7e38acSHans Petter Selasky #include <linux/errno.h>
31dc7e38acSHans Petter Selasky #include <linux/pci.h>
32dc7e38acSHans Petter Selasky #include <linux/dma-mapping.h>
33dc7e38acSHans Petter Selasky #include <linux/slab.h>
34dc7e38acSHans Petter Selasky #include <linux/delay.h>
35dc7e38acSHans Petter Selasky #include <linux/random.h>
36dc7e38acSHans Petter Selasky #include <linux/io-mapping.h>
37dc7e38acSHans Petter Selasky #include <linux/hardirq.h>
38dc7e38acSHans Petter Selasky #include <linux/ktime.h>
39dc7e38acSHans Petter Selasky #include <dev/mlx5/driver.h>
40118063fbSHans Petter Selasky #include <dev/mlx5/cmd.h>
4112c56d7dSHans Petter Selasky #include <dev/mlx5/mlx5_core/mlx5_core.h>
42dc7e38acSHans Petter Selasky
438e7e0ce1SHans Petter Selasky static int mlx5_copy_from_msg(void *to, struct mlx5_cmd_msg *from, int size);
448e7e0ce1SHans Petter Selasky static void mlx5_free_cmd_msg(struct mlx5_core_dev *dev,
458e7e0ce1SHans Petter Selasky struct mlx5_cmd_msg *msg);
468e7e0ce1SHans Petter Selasky static void free_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg);
478e7e0ce1SHans Petter Selasky
48dc7e38acSHans Petter Selasky enum {
49dc7e38acSHans Petter Selasky CMD_IF_REV = 5,
50dc7e38acSHans Petter Selasky };
51dc7e38acSHans Petter Selasky
52dc7e38acSHans Petter Selasky enum {
53dc7e38acSHans Petter Selasky NUM_LONG_LISTS = 2,
54dc7e38acSHans Petter Selasky NUM_MED_LISTS = 64,
55dc7e38acSHans Petter Selasky LONG_LIST_SIZE = (2ULL * 1024 * 1024 * 1024 / PAGE_SIZE) * 8 + 16 +
56dc7e38acSHans Petter Selasky MLX5_CMD_DATA_BLOCK_SIZE,
57dc7e38acSHans Petter Selasky MED_LIST_SIZE = 16 + MLX5_CMD_DATA_BLOCK_SIZE,
58dc7e38acSHans Petter Selasky };
59dc7e38acSHans Petter Selasky
60dc7e38acSHans Petter Selasky enum {
61dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_OK = 0x0,
62dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_SIGNAT_ERR = 0x1,
63dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_TOK_ERR = 0x2,
64dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_BAD_BLK_NUM_ERR = 0x3,
65dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_OUT_PTR_ALIGN_ERR = 0x4,
66dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_IN_PTR_ALIGN_ERR = 0x5,
67dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_FW_ERR = 0x6,
68dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_IN_LENGTH_ERR = 0x7,
69dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_OUT_LENGTH_ERR = 0x8,
70dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_RES_FLD_NOT_CLR_ERR = 0x9,
71dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_CMD_DESCR_ERR = 0x10,
72dc7e38acSHans Petter Selasky };
73dc7e38acSHans Petter Selasky
74788333d9SHans Petter Selasky struct mlx5_ifc_mbox_out_bits {
75788333d9SHans Petter Selasky u8 status[0x8];
76788333d9SHans Petter Selasky u8 reserved_at_8[0x18];
77788333d9SHans Petter Selasky
78788333d9SHans Petter Selasky u8 syndrome[0x20];
79788333d9SHans Petter Selasky
80788333d9SHans Petter Selasky u8 reserved_at_40[0x40];
81788333d9SHans Petter Selasky };
82788333d9SHans Petter Selasky
83788333d9SHans Petter Selasky struct mlx5_ifc_mbox_in_bits {
84788333d9SHans Petter Selasky u8 opcode[0x10];
85788333d9SHans Petter Selasky u8 reserved_at_10[0x10];
86788333d9SHans Petter Selasky
87788333d9SHans Petter Selasky u8 reserved_at_20[0x10];
88788333d9SHans Petter Selasky u8 op_mod[0x10];
89788333d9SHans Petter Selasky
90788333d9SHans Petter Selasky u8 reserved_at_40[0x40];
91788333d9SHans Petter Selasky };
92788333d9SHans Petter Selasky
93788333d9SHans Petter Selasky
alloc_cmd(struct mlx5_cmd * cmd,struct mlx5_cmd_msg * in,int uin_size,struct mlx5_cmd_msg * out,void * uout,int uout_size,mlx5_cmd_cbk_t cbk,void * context,int page_queue)94dc7e38acSHans Petter Selasky static struct mlx5_cmd_work_ent *alloc_cmd(struct mlx5_cmd *cmd,
95dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *in,
961c807f67SHans Petter Selasky int uin_size,
97dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *out,
98dc7e38acSHans Petter Selasky void *uout, int uout_size,
99dc7e38acSHans Petter Selasky mlx5_cmd_cbk_t cbk,
100dc7e38acSHans Petter Selasky void *context, int page_queue)
101dc7e38acSHans Petter Selasky {
102dc7e38acSHans Petter Selasky gfp_t alloc_flags = cbk ? GFP_ATOMIC : GFP_KERNEL;
103dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent;
104dc7e38acSHans Petter Selasky
105dc7e38acSHans Petter Selasky ent = kzalloc(sizeof(*ent), alloc_flags);
106dc7e38acSHans Petter Selasky if (!ent)
107dc7e38acSHans Petter Selasky return ERR_PTR(-ENOMEM);
108dc7e38acSHans Petter Selasky
109dc7e38acSHans Petter Selasky ent->in = in;
1101c807f67SHans Petter Selasky ent->uin_size = uin_size;
111dc7e38acSHans Petter Selasky ent->out = out;
112dc7e38acSHans Petter Selasky ent->uout = uout;
113dc7e38acSHans Petter Selasky ent->uout_size = uout_size;
114dc7e38acSHans Petter Selasky ent->callback = cbk;
115dc7e38acSHans Petter Selasky ent->context = context;
116dc7e38acSHans Petter Selasky ent->cmd = cmd;
117dc7e38acSHans Petter Selasky ent->page_queue = page_queue;
118dc7e38acSHans Petter Selasky
119dc7e38acSHans Petter Selasky return ent;
120dc7e38acSHans Petter Selasky }
121dc7e38acSHans Petter Selasky
alloc_token(struct mlx5_cmd * cmd)122dc7e38acSHans Petter Selasky static u8 alloc_token(struct mlx5_cmd *cmd)
123dc7e38acSHans Petter Selasky {
124dc7e38acSHans Petter Selasky u8 token;
125dc7e38acSHans Petter Selasky
126dc7e38acSHans Petter Selasky spin_lock(&cmd->token_lock);
127dc7e38acSHans Petter Selasky cmd->token++;
128dc7e38acSHans Petter Selasky if (cmd->token == 0)
129dc7e38acSHans Petter Selasky cmd->token++;
130dc7e38acSHans Petter Selasky token = cmd->token;
131dc7e38acSHans Petter Selasky spin_unlock(&cmd->token_lock);
132dc7e38acSHans Petter Selasky
133dc7e38acSHans Petter Selasky return token;
134dc7e38acSHans Petter Selasky }
135dc7e38acSHans Petter Selasky
alloc_ent(struct mlx5_cmd_work_ent * ent)1368e7e0ce1SHans Petter Selasky static int alloc_ent(struct mlx5_cmd_work_ent *ent)
137dc7e38acSHans Petter Selasky {
138dc7e38acSHans Petter Selasky unsigned long flags;
1398e7e0ce1SHans Petter Selasky struct mlx5_cmd *cmd = ent->cmd;
14030dfc051SHans Petter Selasky struct mlx5_core_dev *dev =
14130dfc051SHans Petter Selasky container_of(cmd, struct mlx5_core_dev, cmd);
1428e7e0ce1SHans Petter Selasky int ret = cmd->max_reg_cmds;
143dc7e38acSHans Petter Selasky
144dc7e38acSHans Petter Selasky spin_lock_irqsave(&cmd->alloc_lock, flags);
1458e7e0ce1SHans Petter Selasky if (!ent->page_queue) {
146dc7e38acSHans Petter Selasky ret = find_first_bit(&cmd->bitmask, cmd->max_reg_cmds);
1478e7e0ce1SHans Petter Selasky if (ret >= cmd->max_reg_cmds)
1488e7e0ce1SHans Petter Selasky ret = -1;
1498e7e0ce1SHans Petter Selasky }
1508e7e0ce1SHans Petter Selasky
15130dfc051SHans Petter Selasky if (dev->state != MLX5_DEVICE_STATE_UP)
15230dfc051SHans Petter Selasky ret = -1;
15330dfc051SHans Petter Selasky
1548e7e0ce1SHans Petter Selasky if (ret != -1) {
15530dfc051SHans Petter Selasky ent->busy = 1;
1568e7e0ce1SHans Petter Selasky ent->idx = ret;
1578e7e0ce1SHans Petter Selasky clear_bit(ent->idx, &cmd->bitmask);
158721a1a6aSSlava Shwartsman cmd->ent_mode[ent->idx] =
159721a1a6aSSlava Shwartsman ent->polling ? MLX5_CMD_MODE_POLLING : MLX5_CMD_MODE_EVENTS;
1608e7e0ce1SHans Petter Selasky cmd->ent_arr[ent->idx] = ent;
1618e7e0ce1SHans Petter Selasky }
162dc7e38acSHans Petter Selasky spin_unlock_irqrestore(&cmd->alloc_lock, flags);
163dc7e38acSHans Petter Selasky
1648e7e0ce1SHans Petter Selasky return ret;
165dc7e38acSHans Petter Selasky }
166dc7e38acSHans Petter Selasky
free_ent(struct mlx5_cmd * cmd,int idx)167dc7e38acSHans Petter Selasky static void free_ent(struct mlx5_cmd *cmd, int idx)
168dc7e38acSHans Petter Selasky {
169dc7e38acSHans Petter Selasky unsigned long flags;
170dc7e38acSHans Petter Selasky
171dc7e38acSHans Petter Selasky spin_lock_irqsave(&cmd->alloc_lock, flags);
172721a1a6aSSlava Shwartsman cmd->ent_arr[idx] = NULL; /* safety clear */
173721a1a6aSSlava Shwartsman cmd->ent_mode[idx] = MLX5_CMD_MODE_POLLING; /* reset mode */
174dc7e38acSHans Petter Selasky set_bit(idx, &cmd->bitmask);
175dc7e38acSHans Petter Selasky spin_unlock_irqrestore(&cmd->alloc_lock, flags);
176dc7e38acSHans Petter Selasky }
177dc7e38acSHans Petter Selasky
get_inst(struct mlx5_cmd * cmd,int idx)178dc7e38acSHans Petter Selasky static struct mlx5_cmd_layout *get_inst(struct mlx5_cmd *cmd, int idx)
179dc7e38acSHans Petter Selasky {
180dc7e38acSHans Petter Selasky return cmd->cmd_buf + (idx << cmd->log_stride);
181dc7e38acSHans Petter Selasky }
182dc7e38acSHans Petter Selasky
xor8_buf(void * buf,int len)183dc7e38acSHans Petter Selasky static u8 xor8_buf(void *buf, int len)
184dc7e38acSHans Petter Selasky {
185dc7e38acSHans Petter Selasky u8 *ptr = buf;
186dc7e38acSHans Petter Selasky u8 sum = 0;
187dc7e38acSHans Petter Selasky int i;
188dc7e38acSHans Petter Selasky
189dc7e38acSHans Petter Selasky for (i = 0; i < len; i++)
190dc7e38acSHans Petter Selasky sum ^= ptr[i];
191dc7e38acSHans Petter Selasky
192dc7e38acSHans Petter Selasky return sum;
193dc7e38acSHans Petter Selasky }
194dc7e38acSHans Petter Selasky
verify_block_sig(struct mlx5_cmd_prot_block * block)195dc7e38acSHans Petter Selasky static int verify_block_sig(struct mlx5_cmd_prot_block *block)
196dc7e38acSHans Petter Selasky {
197dc7e38acSHans Petter Selasky if (xor8_buf(block->rsvd0, sizeof(*block) - sizeof(block->data) - 1) != 0xff)
198dc7e38acSHans Petter Selasky return -EINVAL;
199dc7e38acSHans Petter Selasky
200dc7e38acSHans Petter Selasky if (xor8_buf(block, sizeof(*block)) != 0xff)
201dc7e38acSHans Petter Selasky return -EINVAL;
202dc7e38acSHans Petter Selasky
203dc7e38acSHans Petter Selasky return 0;
204dc7e38acSHans Petter Selasky }
205dc7e38acSHans Petter Selasky
calc_block_sig(struct mlx5_cmd_prot_block * block,u8 token,int csum)206dc7e38acSHans Petter Selasky static void calc_block_sig(struct mlx5_cmd_prot_block *block, u8 token,
207dc7e38acSHans Petter Selasky int csum)
208dc7e38acSHans Petter Selasky {
209dc7e38acSHans Petter Selasky block->token = token;
210dc7e38acSHans Petter Selasky if (csum) {
211dc7e38acSHans Petter Selasky block->ctrl_sig = ~xor8_buf(block->rsvd0, sizeof(*block) -
212dc7e38acSHans Petter Selasky sizeof(block->data) - 2);
213dc7e38acSHans Petter Selasky block->sig = ~xor8_buf(block, sizeof(*block) - 1);
214dc7e38acSHans Petter Selasky }
215dc7e38acSHans Petter Selasky }
216dc7e38acSHans Petter Selasky
2171c807f67SHans Petter Selasky static void
calc_chain_sig(struct mlx5_cmd_msg * msg,u8 token,int csum)2181c807f67SHans Petter Selasky calc_chain_sig(struct mlx5_cmd_msg *msg, u8 token, int csum)
219dc7e38acSHans Petter Selasky {
2201c807f67SHans Petter Selasky size_t i;
221dc7e38acSHans Petter Selasky
2221c807f67SHans Petter Selasky for (i = 0; i != (msg->numpages * MLX5_NUM_CMDS_IN_ADAPTER_PAGE); i++) {
2231c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block;
2241c807f67SHans Petter Selasky
2251c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE);
2261c807f67SHans Petter Selasky
2271c807f67SHans Petter Selasky /* compute signature */
2281c807f67SHans Petter Selasky calc_block_sig(block, token, csum);
2291c807f67SHans Petter Selasky
2301c807f67SHans Petter Selasky /* check for last block */
2311c807f67SHans Petter Selasky if (block->next == 0)
2321c807f67SHans Petter Selasky break;
233dc7e38acSHans Petter Selasky }
2341c807f67SHans Petter Selasky
2351c807f67SHans Petter Selasky /* make sure data gets written to RAM */
2361c807f67SHans Petter Selasky mlx5_fwp_flush(msg);
237dc7e38acSHans Petter Selasky }
238dc7e38acSHans Petter Selasky
set_signature(struct mlx5_cmd_work_ent * ent,int csum)239dc7e38acSHans Petter Selasky static void set_signature(struct mlx5_cmd_work_ent *ent, int csum)
240dc7e38acSHans Petter Selasky {
241dc7e38acSHans Petter Selasky ent->lay->sig = ~xor8_buf(ent->lay, sizeof(*ent->lay));
242dc7e38acSHans Petter Selasky calc_chain_sig(ent->in, ent->token, csum);
243dc7e38acSHans Petter Selasky calc_chain_sig(ent->out, ent->token, csum);
244dc7e38acSHans Petter Selasky }
245dc7e38acSHans Petter Selasky
poll_timeout(struct mlx5_cmd_work_ent * ent)246dc7e38acSHans Petter Selasky static void poll_timeout(struct mlx5_cmd_work_ent *ent)
247dc7e38acSHans Petter Selasky {
24830dfc051SHans Petter Selasky struct mlx5_core_dev *dev = container_of(ent->cmd,
24930dfc051SHans Petter Selasky struct mlx5_core_dev, cmd);
25030dfc051SHans Petter Selasky int poll_end = jiffies +
25130dfc051SHans Petter Selasky msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC + 1000);
252dc7e38acSHans Petter Selasky u8 own;
253dc7e38acSHans Petter Selasky
254dc7e38acSHans Petter Selasky do {
255dc7e38acSHans Petter Selasky own = ent->lay->status_own;
25630dfc051SHans Petter Selasky if (!(own & CMD_OWNER_HW) ||
25730dfc051SHans Petter Selasky dev->state != MLX5_DEVICE_STATE_UP) {
258dc7e38acSHans Petter Selasky ent->ret = 0;
259dc7e38acSHans Petter Selasky return;
260dc7e38acSHans Petter Selasky }
261dc7e38acSHans Petter Selasky usleep_range(5000, 10000);
262dc7e38acSHans Petter Selasky } while (time_before(jiffies, poll_end));
263dc7e38acSHans Petter Selasky
264dc7e38acSHans Petter Selasky ent->ret = -ETIMEDOUT;
265dc7e38acSHans Petter Selasky }
266dc7e38acSHans Petter Selasky
free_cmd(struct mlx5_cmd_work_ent * ent)267dc7e38acSHans Petter Selasky static void free_cmd(struct mlx5_cmd_work_ent *ent)
268dc7e38acSHans Petter Selasky {
26911546d06SHans Petter Selasky cancel_delayed_work_sync(&ent->cb_timeout_work);
270dc7e38acSHans Petter Selasky kfree(ent);
271dc7e38acSHans Petter Selasky }
272dc7e38acSHans Petter Selasky
2731c807f67SHans Petter Selasky static int
verify_signature(struct mlx5_cmd_work_ent * ent)2741c807f67SHans Petter Selasky verify_signature(struct mlx5_cmd_work_ent *ent)
275dc7e38acSHans Petter Selasky {
2761c807f67SHans Petter Selasky struct mlx5_cmd_msg *msg = ent->out;
2771c807f67SHans Petter Selasky size_t i;
278dc7e38acSHans Petter Selasky int err;
279dc7e38acSHans Petter Selasky u8 sig;
280dc7e38acSHans Petter Selasky
281dc7e38acSHans Petter Selasky sig = xor8_buf(ent->lay, sizeof(*ent->lay));
282dc7e38acSHans Petter Selasky if (sig != 0xff)
283dc7e38acSHans Petter Selasky return -EINVAL;
284dc7e38acSHans Petter Selasky
2851c807f67SHans Petter Selasky for (i = 0; i != (msg->numpages * MLX5_NUM_CMDS_IN_ADAPTER_PAGE); i++) {
2861c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block;
287dc7e38acSHans Petter Selasky
2881c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE);
2891c807f67SHans Petter Selasky
2901c807f67SHans Petter Selasky /* compute signature */
2911c807f67SHans Petter Selasky err = verify_block_sig(block);
2921c807f67SHans Petter Selasky if (err != 0)
2931c807f67SHans Petter Selasky return (err);
2941c807f67SHans Petter Selasky
2951c807f67SHans Petter Selasky /* check for last block */
2961c807f67SHans Petter Selasky if (block->next == 0)
2971c807f67SHans Petter Selasky break;
298dc7e38acSHans Petter Selasky }
2991c807f67SHans Petter Selasky return (0);
300dc7e38acSHans Petter Selasky }
301dc7e38acSHans Petter Selasky
dump_buf(void * buf,int size,int data_only,int offset)302dc7e38acSHans Petter Selasky static void dump_buf(void *buf, int size, int data_only, int offset)
303dc7e38acSHans Petter Selasky {
304dc7e38acSHans Petter Selasky __be32 *p = buf;
305dc7e38acSHans Petter Selasky int i;
306dc7e38acSHans Petter Selasky
307dc7e38acSHans Petter Selasky for (i = 0; i < size; i += 16) {
308dc7e38acSHans Petter Selasky pr_debug("%03x: %08x %08x %08x %08x\n", offset, be32_to_cpu(p[0]),
309dc7e38acSHans Petter Selasky be32_to_cpu(p[1]), be32_to_cpu(p[2]),
310dc7e38acSHans Petter Selasky be32_to_cpu(p[3]));
311dc7e38acSHans Petter Selasky p += 4;
312dc7e38acSHans Petter Selasky offset += 16;
313dc7e38acSHans Petter Selasky }
314dc7e38acSHans Petter Selasky if (!data_only)
315dc7e38acSHans Petter Selasky pr_debug("\n");
316dc7e38acSHans Petter Selasky }
317dc7e38acSHans Petter Selasky
318a2485fe5SHans Petter Selasky enum {
319a2485fe5SHans Petter Selasky MLX5_DRIVER_STATUS_ABORTED = 0xfe,
320a2485fe5SHans Petter Selasky MLX5_DRIVER_SYND = 0xbadd00de,
321a2485fe5SHans Petter Selasky };
322a2485fe5SHans Petter Selasky
mlx5_internal_err_ret_value(struct mlx5_core_dev * dev,u16 op,u32 * synd,u8 * status)323a2485fe5SHans Petter Selasky static int mlx5_internal_err_ret_value(struct mlx5_core_dev *dev, u16 op,
324a2485fe5SHans Petter Selasky u32 *synd, u8 *status)
325a2485fe5SHans Petter Selasky {
326a2485fe5SHans Petter Selasky *synd = 0;
327a2485fe5SHans Petter Selasky *status = 0;
328a2485fe5SHans Petter Selasky
329a2485fe5SHans Petter Selasky switch (op) {
330a2485fe5SHans Petter Selasky case MLX5_CMD_OP_TEARDOWN_HCA:
331a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DISABLE_HCA:
332a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MANAGE_PAGES:
333a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_MKEY:
334a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_EQ:
335a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_CQ:
336a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_QP:
337a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_PSV:
338a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_SRQ:
339a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_XRC_SRQ:
340a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_DCT:
341a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_Q_COUNTER:
342a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_PD:
343a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_UAR:
344a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DETACH_FROM_MCG:
345a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_XRCD:
346a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_TRANSPORT_DOMAIN:
347a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DELETE_VXLAN_UDP_DPORT:
348a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DELETE_L2_TABLE_ENTRY:
349a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_TIR:
350a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_SQ:
351a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_RQ:
352a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_RMP:
353a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_TIS:
354a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_RQT:
355a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_FLOW_TABLE:
356a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_FLOW_GROUP:
357a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DELETE_FLOW_TABLE_ENTRY:
358a2485fe5SHans Petter Selasky case MLX5_CMD_OP_2ERR_QP:
359a2485fe5SHans Petter Selasky case MLX5_CMD_OP_2RST_QP:
360a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT:
361a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_FLOW_TABLE:
362a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY:
363a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_FLOW_TABLE_ROOT:
36404f1690bSHans Petter Selasky case MLX5_CMD_OP_DESTROY_GENERAL_OBJ:
365a2485fe5SHans Petter Selasky return MLX5_CMD_STAT_OK;
366a2485fe5SHans Petter Selasky
367a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_CAP:
368a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_ADAPTER:
369a2485fe5SHans Petter Selasky case MLX5_CMD_OP_INIT_HCA:
370a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ENABLE_HCA:
371a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_PAGES:
372a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_HCA_CAP:
373a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_ISSI:
374a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_ISSI:
375a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_MKEY:
376a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_MKEY:
377a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_SPECIAL_CONTEXTS:
378a2485fe5SHans Petter Selasky case MLX5_CMD_OP_PAGE_FAULT_RESUME:
379a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_EQ:
380a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_EQ:
381a2485fe5SHans Petter Selasky case MLX5_CMD_OP_GEN_EQE:
382a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_CQ:
383a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_CQ:
384a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_CQ:
385a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_QP:
386a2485fe5SHans Petter Selasky case MLX5_CMD_OP_RST2INIT_QP:
387a2485fe5SHans Petter Selasky case MLX5_CMD_OP_INIT2RTR_QP:
388a2485fe5SHans Petter Selasky case MLX5_CMD_OP_RTR2RTS_QP:
389a2485fe5SHans Petter Selasky case MLX5_CMD_OP_RTS2RTS_QP:
390a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SQERR2RTS_QP:
391a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_QP:
392a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SQD_RTS_QP:
393a2485fe5SHans Petter Selasky case MLX5_CMD_OP_INIT2INIT_QP:
394a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_PSV:
395a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_SRQ:
396a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_SRQ:
397a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ARM_RQ:
398a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_XRC_SRQ:
399a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_XRC_SRQ:
400a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ARM_XRC_SRQ:
401a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_DCT:
402a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DRAIN_DCT:
403a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_DCT:
404a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ARM_DCT_FOR_KEY_VIOLATION:
405a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_VPORT_STATE:
406a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_VPORT_STATE:
407a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_ESW_VPORT_CONTEXT:
408a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT:
409a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_NIC_VPORT_CONTEXT:
410a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_ROCE_ADDRESS:
411a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_ROCE_ADDRESS:
412a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_VPORT_CONTEXT:
413a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_HCA_VPORT_CONTEXT:
414a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_VPORT_GID:
415a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_VPORT_PKEY:
416c29b90baSHans Petter Selasky case MLX5_CMD_OP_QUERY_VNIC_ENV:
417a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_VPORT_COUNTER:
418a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_Q_COUNTER:
419a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_Q_COUNTER:
420a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_PD:
421a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_UAR:
422a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CONFIG_INT_MODERATION:
423a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ACCESS_REG:
424a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ATTACH_TO_MCG:
425a2485fe5SHans Petter Selasky case MLX5_CMD_OP_GET_DROPPED_PACKET_LOG:
426a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MAD_IFC:
427a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_MAD_DEMUX:
428a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_MAD_DEMUX:
429a2485fe5SHans Petter Selasky case MLX5_CMD_OP_NOP:
430a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_XRCD:
431a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_TRANSPORT_DOMAIN:
432a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_CONG_STATUS:
433a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_CONG_STATUS:
434a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_CONG_PARAMS:
435a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_CONG_PARAMS:
436a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_CONG_STATISTICS:
437a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ADD_VXLAN_UDP_DPORT:
438a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_L2_TABLE_ENTRY:
439a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_L2_TABLE_ENTRY:
440a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_TIR:
441a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_TIR:
442a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_TIR:
443a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_SQ:
444a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_SQ:
445a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_SQ:
446a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_RQ:
447a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_RQ:
448a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_RQ:
449a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_RMP:
450a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_RMP:
451a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_RMP:
452a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_TIS:
453a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_TIS:
454a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_TIS:
455a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_RQT:
456a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_RQT:
457a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_RQT:
458a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_FLOW_TABLE:
459a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_TABLE:
460a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_FLOW_GROUP:
461a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_GROUP:
462a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_TABLE_ENTRY:
46304f1690bSHans Petter Selasky case MLX5_CMD_OP_CREATE_GENERAL_OBJ:
46404f1690bSHans Petter Selasky case MLX5_CMD_OP_MODIFY_GENERAL_OBJ:
46504f1690bSHans Petter Selasky case MLX5_CMD_OP_QUERY_GENERAL_OBJ:
466a2485fe5SHans Petter Selasky *status = MLX5_DRIVER_STATUS_ABORTED;
467a2485fe5SHans Petter Selasky *synd = MLX5_DRIVER_SYND;
468a2485fe5SHans Petter Selasky return -EIO;
469a2485fe5SHans Petter Selasky default:
470a2485fe5SHans Petter Selasky mlx5_core_err(dev, "Unknown FW command (%d)\n", op);
471a2485fe5SHans Petter Selasky return -EINVAL;
472a2485fe5SHans Petter Selasky }
473a2485fe5SHans Petter Selasky }
474a2485fe5SHans Petter Selasky
mlx5_command_str(int command)475dc7e38acSHans Petter Selasky const char *mlx5_command_str(int command)
476dc7e38acSHans Petter Selasky {
477ee1b5c58SHans Petter Selasky #define MLX5_COMMAND_STR_CASE(__cmd) case MLX5_CMD_OP_ ## __cmd: return #__cmd
478ee1b5c58SHans Petter Selasky
479dc7e38acSHans Petter Selasky switch (command) {
480ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_CAP);
481ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_HCA_CAP);
482ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ADAPTER);
483ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(INIT_HCA);
484ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(TEARDOWN_HCA);
485ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ENABLE_HCA);
486ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DISABLE_HCA);
487ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_PAGES);
488ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MANAGE_PAGES);
489ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ISSI);
490ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_ISSI);
491ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_MKEY);
492ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_MKEY);
493ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_MKEY);
494ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_SPECIAL_CONTEXTS);
495ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(PAGE_FAULT_RESUME);
496ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_EQ);
497ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_EQ);
498ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_EQ);
499ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(GEN_EQE);
500ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_CQ);
501ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_CQ);
502ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CQ);
503ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_CQ);
504ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_QP);
505ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_QP);
506ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(RST2INIT_QP);
507ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(INIT2RTR_QP);
508ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(RTR2RTS_QP);
509ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(RTS2RTS_QP);
510ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SQERR2RTS_QP);
511ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(2ERR_QP);
512ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(2RST_QP);
513ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_QP);
514ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SQD_RTS_QP);
515ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MAD_IFC);
516ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(INIT2INIT_QP);
517ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_PSV);
518ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_PSV);
519ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_SRQ);
520ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_SRQ);
521ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_SRQ);
522ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ARM_RQ);
523ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_XRC_SRQ);
524ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_XRC_SRQ);
525ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_XRC_SRQ);
526ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ARM_XRC_SRQ);
527ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_DCT);
528ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_DC_CNAK_TRACE);
529ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_DCT);
530ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DRAIN_DCT);
531ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_DCT);
532ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ARM_DCT_FOR_KEY_VIOLATION);
533ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_VPORT_STATE);
534ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_VPORT_STATE);
535ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ESW_VPORT_CONTEXT);
536ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_ESW_VPORT_CONTEXT);
537ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_NIC_VPORT_CONTEXT);
538ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_NIC_VPORT_CONTEXT);
539ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ROCE_ADDRESS);
540ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_ROCE_ADDRESS);
541ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_VPORT_CONTEXT);
542ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_HCA_VPORT_CONTEXT);
543ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_VPORT_GID);
544ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_VPORT_PKEY);
545c29b90baSHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_VNIC_ENV);
546ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_VPORT_COUNTER);
547ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_WOL_ROL);
548ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_WOL_ROL);
549ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_Q_COUNTER);
550ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_Q_COUNTER);
551ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_Q_COUNTER);
552ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_PD);
553ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_PD);
554ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_UAR);
555ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_UAR);
556ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CONFIG_INT_MODERATION);
557ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ATTACH_TO_MCG);
558ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DETACH_FROM_MCG);
559ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(GET_DROPPED_PACKET_LOG);
560ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_MAD_DEMUX);
561ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_MAD_DEMUX);
562ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(NOP);
563ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_XRCD);
564ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_XRCD);
565ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_TRANSPORT_DOMAIN);
566ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_TRANSPORT_DOMAIN);
567ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CONG_STATUS);
568ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_CONG_STATUS);
569ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CONG_PARAMS);
570ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_CONG_PARAMS);
571ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CONG_STATISTICS);
572ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ADD_VXLAN_UDP_DPORT);
573ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DELETE_VXLAN_UDP_DPORT);
574ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_L2_TABLE_ENTRY);
575ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_L2_TABLE_ENTRY);
576ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DELETE_L2_TABLE_ENTRY);
577ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_RMP);
578ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_RMP);
579ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_RMP);
580ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_RMP);
581ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_RQT);
582ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_RQT);
583ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_RQT);
584ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_RQT);
585ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ACCESS_REG);
586ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_SQ);
587ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_SQ);
588ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_SQ);
589ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_SQ);
590ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_RQ);
591ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_RQ);
592ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_RQ);
593ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_RQ);
594ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_TIR);
595ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_TIR);
596ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_TIR);
597ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_TIR);
598ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_TIS);
599ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_TIS);
600ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_TIS);
601ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_TIS);
602ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_FLOW_TABLE);
603ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_FLOW_TABLE);
604ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_FLOW_TABLE);
605ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_FLOW_GROUP);
606ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_FLOW_GROUP);
607ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_FLOW_GROUP);
608ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_FLOW_TABLE_ENTRY);
609ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_FLOW_TABLE_ENTRY);
610ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DELETE_FLOW_TABLE_ENTRY);
611ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_DIAGNOSTICS);
612ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_DIAGNOSTICS);
61304f1690bSHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_GENERAL_OBJ);
61404f1690bSHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_GENERAL_OBJ);
61504f1690bSHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_GENERAL_OBJ);
61604f1690bSHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_GENERAL_OBJ);
617dc7e38acSHans Petter Selasky default: return "unknown command opcode";
618dc7e38acSHans Petter Selasky }
619dc7e38acSHans Petter Selasky }
620dc7e38acSHans Petter Selasky
cmd_status_str(u8 status)621788333d9SHans Petter Selasky static const char *cmd_status_str(u8 status)
622788333d9SHans Petter Selasky {
623788333d9SHans Petter Selasky switch (status) {
624788333d9SHans Petter Selasky case MLX5_CMD_STAT_OK:
625788333d9SHans Petter Selasky return "OK";
626788333d9SHans Petter Selasky case MLX5_CMD_STAT_INT_ERR:
627788333d9SHans Petter Selasky return "internal error";
628788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_OP_ERR:
629788333d9SHans Petter Selasky return "bad operation";
630788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_PARAM_ERR:
631788333d9SHans Petter Selasky return "bad parameter";
632788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_SYS_STATE_ERR:
633788333d9SHans Petter Selasky return "bad system state";
634788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_ERR:
635788333d9SHans Petter Selasky return "bad resource";
636788333d9SHans Petter Selasky case MLX5_CMD_STAT_RES_BUSY:
637788333d9SHans Petter Selasky return "resource busy";
638788333d9SHans Petter Selasky case MLX5_CMD_STAT_LIM_ERR:
639788333d9SHans Petter Selasky return "limits exceeded";
640788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_STATE_ERR:
641788333d9SHans Petter Selasky return "bad resource state";
642788333d9SHans Petter Selasky case MLX5_CMD_STAT_IX_ERR:
643788333d9SHans Petter Selasky return "bad index";
644788333d9SHans Petter Selasky case MLX5_CMD_STAT_NO_RES_ERR:
645788333d9SHans Petter Selasky return "no resources";
646788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_INP_LEN_ERR:
647788333d9SHans Petter Selasky return "bad input length";
648788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_OUTP_LEN_ERR:
649788333d9SHans Petter Selasky return "bad output length";
650788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_QP_STATE_ERR:
651788333d9SHans Petter Selasky return "bad QP state";
652788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_PKT_ERR:
653788333d9SHans Petter Selasky return "bad packet (discarded)";
654788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_SIZE_OUTS_CQES_ERR:
655788333d9SHans Petter Selasky return "bad size too many outstanding CQEs";
656788333d9SHans Petter Selasky default:
657788333d9SHans Petter Selasky return "unknown status";
658788333d9SHans Petter Selasky }
659788333d9SHans Petter Selasky }
660788333d9SHans Petter Selasky
cmd_status_to_err_helper(u8 status)661788333d9SHans Petter Selasky static int cmd_status_to_err_helper(u8 status)
662788333d9SHans Petter Selasky {
663788333d9SHans Petter Selasky switch (status) {
664788333d9SHans Petter Selasky case MLX5_CMD_STAT_OK: return 0;
665788333d9SHans Petter Selasky case MLX5_CMD_STAT_INT_ERR: return -EIO;
666788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_OP_ERR: return -EINVAL;
667788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_PARAM_ERR: return -EINVAL;
668788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_SYS_STATE_ERR: return -EIO;
669788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_ERR: return -EINVAL;
670788333d9SHans Petter Selasky case MLX5_CMD_STAT_RES_BUSY: return -EBUSY;
671788333d9SHans Petter Selasky case MLX5_CMD_STAT_LIM_ERR: return -ENOMEM;
672788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_STATE_ERR: return -EINVAL;
673788333d9SHans Petter Selasky case MLX5_CMD_STAT_IX_ERR: return -EINVAL;
674788333d9SHans Petter Selasky case MLX5_CMD_STAT_NO_RES_ERR: return -EAGAIN;
675788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_INP_LEN_ERR: return -EIO;
676788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_OUTP_LEN_ERR: return -EIO;
677788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_QP_STATE_ERR: return -EINVAL;
678788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_PKT_ERR: return -EINVAL;
679788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_SIZE_OUTS_CQES_ERR: return -EINVAL;
680788333d9SHans Petter Selasky default: return -EIO;
681788333d9SHans Petter Selasky }
682788333d9SHans Petter Selasky }
683788333d9SHans Petter Selasky
mlx5_cmd_mbox_status(void * out,u8 * status,u32 * syndrome)684788333d9SHans Petter Selasky void mlx5_cmd_mbox_status(void *out, u8 *status, u32 *syndrome)
685788333d9SHans Petter Selasky {
686788333d9SHans Petter Selasky *status = MLX5_GET(mbox_out, out, status);
687788333d9SHans Petter Selasky *syndrome = MLX5_GET(mbox_out, out, syndrome);
688788333d9SHans Petter Selasky }
689788333d9SHans Petter Selasky
mlx5_cmd_check(struct mlx5_core_dev * dev,void * in,void * out)690788333d9SHans Petter Selasky static int mlx5_cmd_check(struct mlx5_core_dev *dev, void *in, void *out)
691788333d9SHans Petter Selasky {
692788333d9SHans Petter Selasky u32 syndrome;
693788333d9SHans Petter Selasky u8 status;
694788333d9SHans Petter Selasky u16 opcode;
695788333d9SHans Petter Selasky u16 op_mod;
696788333d9SHans Petter Selasky
697788333d9SHans Petter Selasky mlx5_cmd_mbox_status(out, &status, &syndrome);
698788333d9SHans Petter Selasky if (!status)
699788333d9SHans Petter Selasky return 0;
700788333d9SHans Petter Selasky
701788333d9SHans Petter Selasky opcode = MLX5_GET(mbox_in, in, opcode);
702788333d9SHans Petter Selasky op_mod = MLX5_GET(mbox_in, in, op_mod);
703788333d9SHans Petter Selasky
704788333d9SHans Petter Selasky mlx5_core_err(dev,
705788333d9SHans Petter Selasky "%s(0x%x) op_mod(0x%x) failed, status %s(0x%x), syndrome (0x%x)\n",
706788333d9SHans Petter Selasky mlx5_command_str(opcode),
707788333d9SHans Petter Selasky opcode, op_mod,
708788333d9SHans Petter Selasky cmd_status_str(status),
709788333d9SHans Petter Selasky status,
710788333d9SHans Petter Selasky syndrome);
711788333d9SHans Petter Selasky
712788333d9SHans Petter Selasky return cmd_status_to_err_helper(status);
713788333d9SHans Petter Selasky }
714788333d9SHans Petter Selasky
dump_command(struct mlx5_core_dev * dev,struct mlx5_cmd_work_ent * ent,int input)715dc7e38acSHans Petter Selasky static void dump_command(struct mlx5_core_dev *dev,
716dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent, int input)
717dc7e38acSHans Petter Selasky {
718dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg = input ? ent->in : ent->out;
719788333d9SHans Petter Selasky u16 op = MLX5_GET(mbox_in, ent->lay->in, opcode);
7201c807f67SHans Petter Selasky size_t i;
721dc7e38acSHans Petter Selasky int data_only;
7221c807f67SHans Petter Selasky int offset = 0;
7231c807f67SHans Petter Selasky int msg_len = input ? ent->uin_size : ent->uout_size;
724dc7e38acSHans Petter Selasky int dump_len;
725dc7e38acSHans Petter Selasky
726dc7e38acSHans Petter Selasky data_only = !!(mlx5_core_debug_mask & (1 << MLX5_CMD_DATA));
727dc7e38acSHans Petter Selasky
728dc7e38acSHans Petter Selasky if (data_only)
729dc7e38acSHans Petter Selasky mlx5_core_dbg_mask(dev, 1 << MLX5_CMD_DATA,
730dc7e38acSHans Petter Selasky "dump command data %s(0x%x) %s\n",
731dc7e38acSHans Petter Selasky mlx5_command_str(op), op,
732dc7e38acSHans Petter Selasky input ? "INPUT" : "OUTPUT");
733dc7e38acSHans Petter Selasky else
734dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "dump command %s(0x%x) %s\n",
735dc7e38acSHans Petter Selasky mlx5_command_str(op), op,
736dc7e38acSHans Petter Selasky input ? "INPUT" : "OUTPUT");
737dc7e38acSHans Petter Selasky
738dc7e38acSHans Petter Selasky if (data_only) {
739dc7e38acSHans Petter Selasky if (input) {
740dc7e38acSHans Petter Selasky dump_buf(ent->lay->in, sizeof(ent->lay->in), 1, offset);
741dc7e38acSHans Petter Selasky offset += sizeof(ent->lay->in);
742dc7e38acSHans Petter Selasky } else {
743dc7e38acSHans Petter Selasky dump_buf(ent->lay->out, sizeof(ent->lay->out), 1, offset);
744dc7e38acSHans Petter Selasky offset += sizeof(ent->lay->out);
745dc7e38acSHans Petter Selasky }
746dc7e38acSHans Petter Selasky } else {
747dc7e38acSHans Petter Selasky dump_buf(ent->lay, sizeof(*ent->lay), 0, offset);
748dc7e38acSHans Petter Selasky offset += sizeof(*ent->lay);
749dc7e38acSHans Petter Selasky }
750dc7e38acSHans Petter Selasky
7511c807f67SHans Petter Selasky for (i = 0; i != (msg->numpages * MLX5_NUM_CMDS_IN_ADAPTER_PAGE); i++) {
7521c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block;
7531c807f67SHans Petter Selasky
7541c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE);
7551c807f67SHans Petter Selasky
756dc7e38acSHans Petter Selasky if (data_only) {
7571c807f67SHans Petter Selasky if (offset >= msg_len)
7581c807f67SHans Petter Selasky break;
7591c807f67SHans Petter Selasky dump_len = min_t(int,
7601c807f67SHans Petter Selasky MLX5_CMD_DATA_BLOCK_SIZE, msg_len - offset);
7611c807f67SHans Petter Selasky
7621c807f67SHans Petter Selasky dump_buf(block->data, dump_len, 1, offset);
763dc7e38acSHans Petter Selasky offset += MLX5_CMD_DATA_BLOCK_SIZE;
764dc7e38acSHans Petter Selasky } else {
765dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "command block:\n");
7661c807f67SHans Petter Selasky dump_buf(block, sizeof(*block), 0, offset);
7671c807f67SHans Petter Selasky offset += sizeof(*block);
768dc7e38acSHans Petter Selasky }
7691c807f67SHans Petter Selasky
7701c807f67SHans Petter Selasky /* check for last block */
7711c807f67SHans Petter Selasky if (block->next == 0)
7721c807f67SHans Petter Selasky break;
773dc7e38acSHans Petter Selasky }
774dc7e38acSHans Petter Selasky
775dc7e38acSHans Petter Selasky if (data_only)
776dc7e38acSHans Petter Selasky pr_debug("\n");
777dc7e38acSHans Petter Selasky }
778dc7e38acSHans Petter Selasky
msg_to_opcode(struct mlx5_cmd_msg * in)77911546d06SHans Petter Selasky static u16 msg_to_opcode(struct mlx5_cmd_msg *in)
78011546d06SHans Petter Selasky {
781788333d9SHans Petter Selasky return MLX5_GET(mbox_in, in->first.data, opcode);
78211546d06SHans Petter Selasky }
78311546d06SHans Petter Selasky
cb_timeout_handler(struct work_struct * work)78411546d06SHans Petter Selasky static void cb_timeout_handler(struct work_struct *work)
78511546d06SHans Petter Selasky {
78611546d06SHans Petter Selasky struct delayed_work *dwork = container_of(work, struct delayed_work,
78711546d06SHans Petter Selasky work);
78811546d06SHans Petter Selasky struct mlx5_cmd_work_ent *ent = container_of(dwork,
78911546d06SHans Petter Selasky struct mlx5_cmd_work_ent,
79011546d06SHans Petter Selasky cb_timeout_work);
79111546d06SHans Petter Selasky struct mlx5_core_dev *dev = container_of(ent->cmd, struct mlx5_core_dev,
79211546d06SHans Petter Selasky cmd);
79311546d06SHans Petter Selasky
79411546d06SHans Petter Selasky ent->ret = -ETIMEDOUT;
79511546d06SHans Petter Selasky mlx5_core_warn(dev, "%s(0x%x) timeout. Will cause a leak of a command resource\n",
79611546d06SHans Petter Selasky mlx5_command_str(msg_to_opcode(ent->in)),
79711546d06SHans Petter Selasky msg_to_opcode(ent->in));
798721a1a6aSSlava Shwartsman mlx5_cmd_comp_handler(dev, 1UL << ent->idx, MLX5_CMD_MODE_EVENTS);
79911546d06SHans Petter Selasky }
80011546d06SHans Petter Selasky
complete_command(struct mlx5_cmd_work_ent * ent)8018e7e0ce1SHans Petter Selasky static void complete_command(struct mlx5_cmd_work_ent *ent)
8028e7e0ce1SHans Petter Selasky {
8038e7e0ce1SHans Petter Selasky struct mlx5_cmd *cmd = ent->cmd;
8048e7e0ce1SHans Petter Selasky struct mlx5_core_dev *dev = container_of(cmd, struct mlx5_core_dev,
8058e7e0ce1SHans Petter Selasky cmd);
806f361e561SHans Petter Selasky mlx5_cmd_cbk_t callback;
807f361e561SHans Petter Selasky void *context;
808f361e561SHans Petter Selasky
8098e7e0ce1SHans Petter Selasky s64 ds;
8108e7e0ce1SHans Petter Selasky struct mlx5_cmd_stats *stats;
8118e7e0ce1SHans Petter Selasky unsigned long flags;
8128e7e0ce1SHans Petter Selasky int err;
8138e7e0ce1SHans Petter Selasky struct semaphore *sem;
8148e7e0ce1SHans Petter Selasky
8158e7e0ce1SHans Petter Selasky if (ent->page_queue)
8168e7e0ce1SHans Petter Selasky sem = &cmd->pages_sem;
8178e7e0ce1SHans Petter Selasky else
8188e7e0ce1SHans Petter Selasky sem = &cmd->sem;
8198e7e0ce1SHans Petter Selasky
82030dfc051SHans Petter Selasky if (dev->state != MLX5_DEVICE_STATE_UP) {
821788333d9SHans Petter Selasky u8 status = 0;
822788333d9SHans Petter Selasky u32 drv_synd;
82330dfc051SHans Petter Selasky
824788333d9SHans Petter Selasky ent->ret = mlx5_internal_err_ret_value(dev, msg_to_opcode(ent->in), &drv_synd, &status);
825788333d9SHans Petter Selasky MLX5_SET(mbox_out, ent->out, status, status);
826788333d9SHans Petter Selasky MLX5_SET(mbox_out, ent->out, syndrome, drv_synd);
82730dfc051SHans Petter Selasky }
82830dfc051SHans Petter Selasky
8298e7e0ce1SHans Petter Selasky if (ent->callback) {
8308e7e0ce1SHans Petter Selasky ds = ent->ts2 - ent->ts1;
8318e7e0ce1SHans Petter Selasky if (ent->op < ARRAY_SIZE(cmd->stats)) {
8328e7e0ce1SHans Petter Selasky stats = &cmd->stats[ent->op];
8338e7e0ce1SHans Petter Selasky spin_lock_irqsave(&stats->lock, flags);
8348e7e0ce1SHans Petter Selasky stats->sum += ds;
8358e7e0ce1SHans Petter Selasky ++stats->n;
8368e7e0ce1SHans Petter Selasky spin_unlock_irqrestore(&stats->lock, flags);
8378e7e0ce1SHans Petter Selasky }
8388e7e0ce1SHans Petter Selasky
839f361e561SHans Petter Selasky callback = ent->callback;
840f361e561SHans Petter Selasky context = ent->context;
8418e7e0ce1SHans Petter Selasky err = ent->ret;
842788333d9SHans Petter Selasky if (!err) {
8438e7e0ce1SHans Petter Selasky err = mlx5_copy_from_msg(ent->uout,
8448e7e0ce1SHans Petter Selasky ent->out,
8458e7e0ce1SHans Petter Selasky ent->uout_size);
846788333d9SHans Petter Selasky err = err ? err : mlx5_cmd_check(dev,
847788333d9SHans Petter Selasky ent->in->first.data,
848788333d9SHans Petter Selasky ent->uout);
849788333d9SHans Petter Selasky }
8508e7e0ce1SHans Petter Selasky
8518e7e0ce1SHans Petter Selasky mlx5_free_cmd_msg(dev, ent->out);
8528e7e0ce1SHans Petter Selasky free_msg(dev, ent->in);
8538e7e0ce1SHans Petter Selasky
854a2485fe5SHans Petter Selasky err = err ? err : ent->status;
8558e7e0ce1SHans Petter Selasky free_cmd(ent);
856f361e561SHans Petter Selasky callback(err, context);
8578e7e0ce1SHans Petter Selasky } else {
8588e7e0ce1SHans Petter Selasky complete(&ent->done);
8598e7e0ce1SHans Petter Selasky }
8608e7e0ce1SHans Petter Selasky up(sem);
8618e7e0ce1SHans Petter Selasky }
8628e7e0ce1SHans Petter Selasky
cmd_work_handler(struct work_struct * work)863dc7e38acSHans Petter Selasky static void cmd_work_handler(struct work_struct *work)
864dc7e38acSHans Petter Selasky {
865dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent = container_of(work, struct mlx5_cmd_work_ent, work);
866dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = ent->cmd;
867dc7e38acSHans Petter Selasky struct mlx5_core_dev *dev = container_of(cmd, struct mlx5_core_dev, cmd);
86811546d06SHans Petter Selasky unsigned long cb_timeout = msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC);
869dc7e38acSHans Petter Selasky struct mlx5_cmd_layout *lay;
870dc7e38acSHans Petter Selasky struct semaphore *sem;
871c0902569SHans Petter Selasky bool poll_cmd = ent->polling;
872dc7e38acSHans Petter Selasky
873dc7e38acSHans Petter Selasky sem = ent->page_queue ? &cmd->pages_sem : &cmd->sem;
874dc7e38acSHans Petter Selasky down(sem);
8758e7e0ce1SHans Petter Selasky
8768e7e0ce1SHans Petter Selasky if (alloc_ent(ent) < 0) {
8778e7e0ce1SHans Petter Selasky complete_command(ent);
878dc7e38acSHans Petter Selasky return;
879dc7e38acSHans Petter Selasky }
880dc7e38acSHans Petter Selasky
881dc7e38acSHans Petter Selasky ent->token = alloc_token(cmd);
882dc7e38acSHans Petter Selasky lay = get_inst(cmd, ent->idx);
883dc7e38acSHans Petter Selasky ent->lay = lay;
884dc7e38acSHans Petter Selasky memset(lay, 0, sizeof(*lay));
885dc7e38acSHans Petter Selasky memcpy(lay->in, ent->in->first.data, sizeof(lay->in));
886dc7e38acSHans Petter Selasky ent->op = be32_to_cpu(lay->in[0]) >> 16;
8871c807f67SHans Petter Selasky if (ent->in->numpages != 0)
8881c807f67SHans Petter Selasky lay->in_ptr = cpu_to_be64(mlx5_fwp_get_dma(ent->in, 0));
8891c807f67SHans Petter Selasky if (ent->out->numpages != 0)
8901c807f67SHans Petter Selasky lay->out_ptr = cpu_to_be64(mlx5_fwp_get_dma(ent->out, 0));
8911c807f67SHans Petter Selasky lay->inlen = cpu_to_be32(ent->uin_size);
8921c807f67SHans Petter Selasky lay->outlen = cpu_to_be32(ent->uout_size);
893dc7e38acSHans Petter Selasky lay->type = MLX5_PCI_CMD_XPORT;
894dc7e38acSHans Petter Selasky lay->token = ent->token;
895dc7e38acSHans Petter Selasky lay->status_own = CMD_OWNER_HW;
896dc7e38acSHans Petter Selasky set_signature(ent, !cmd->checksum_disabled);
897dc7e38acSHans Petter Selasky dump_command(dev, ent, 1);
898dc7e38acSHans Petter Selasky ent->ts1 = ktime_get_ns();
89930dfc051SHans Petter Selasky ent->busy = 0;
90011546d06SHans Petter Selasky if (ent->callback)
90111546d06SHans Petter Selasky schedule_delayed_work(&ent->cb_timeout_work, cb_timeout);
90211546d06SHans Petter Selasky
903dc7e38acSHans Petter Selasky /* ring doorbell after the descriptor is valid */
904dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "writing 0x%x to command doorbell\n", 1 << ent->idx);
9051c807f67SHans Petter Selasky /* make sure data is written to RAM */
9061c807f67SHans Petter Selasky mlx5_fwp_flush(cmd->cmd_page);
907dc7e38acSHans Petter Selasky iowrite32be(1 << ent->idx, &dev->iseg->cmd_dbell);
908dc7e38acSHans Petter Selasky mmiowb();
909721a1a6aSSlava Shwartsman
910dc7e38acSHans Petter Selasky /* if not in polling don't use ent after this point */
911721a1a6aSSlava Shwartsman if (poll_cmd) {
912dc7e38acSHans Petter Selasky poll_timeout(ent);
913dc7e38acSHans Petter Selasky /* make sure we read the descriptor after ownership is SW */
914721a1a6aSSlava Shwartsman mlx5_cmd_comp_handler(dev, 1U << ent->idx, MLX5_CMD_MODE_POLLING);
915dc7e38acSHans Petter Selasky }
916dc7e38acSHans Petter Selasky }
917dc7e38acSHans Petter Selasky
deliv_status_to_str(u8 status)918dc7e38acSHans Petter Selasky static const char *deliv_status_to_str(u8 status)
919dc7e38acSHans Petter Selasky {
920dc7e38acSHans Petter Selasky switch (status) {
921dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_OK:
922dc7e38acSHans Petter Selasky return "no errors";
923dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_SIGNAT_ERR:
924dc7e38acSHans Petter Selasky return "signature error";
925dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_TOK_ERR:
926dc7e38acSHans Petter Selasky return "token error";
927dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_BAD_BLK_NUM_ERR:
928dc7e38acSHans Petter Selasky return "bad block number";
929dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_OUT_PTR_ALIGN_ERR:
930dc7e38acSHans Petter Selasky return "output pointer not aligned to block size";
931dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_IN_PTR_ALIGN_ERR:
932dc7e38acSHans Petter Selasky return "input pointer not aligned to block size";
933dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_FW_ERR:
934dc7e38acSHans Petter Selasky return "firmware internal error";
935dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_IN_LENGTH_ERR:
936dc7e38acSHans Petter Selasky return "command input length error";
937dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_OUT_LENGTH_ERR:
938e1a40dd2SGordon Bergling return "command output length error";
939dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_RES_FLD_NOT_CLR_ERR:
940dc7e38acSHans Petter Selasky return "reserved fields not cleared";
941dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_CMD_DESCR_ERR:
942dc7e38acSHans Petter Selasky return "bad command descriptor type";
943dc7e38acSHans Petter Selasky default:
944dc7e38acSHans Petter Selasky return "unknown status code";
945dc7e38acSHans Petter Selasky }
946dc7e38acSHans Petter Selasky }
947dc7e38acSHans Petter Selasky
wait_func(struct mlx5_core_dev * dev,struct mlx5_cmd_work_ent * ent)948dc7e38acSHans Petter Selasky static int wait_func(struct mlx5_core_dev *dev, struct mlx5_cmd_work_ent *ent)
949dc7e38acSHans Petter Selasky {
950dc7e38acSHans Petter Selasky int timeout = msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC);
951dc7e38acSHans Petter Selasky int err;
952dc7e38acSHans Petter Selasky
953721a1a6aSSlava Shwartsman if (ent->polling) {
954dc7e38acSHans Petter Selasky wait_for_completion(&ent->done);
9552327a753SHans Petter Selasky } else if (!wait_for_completion_timeout(&ent->done, timeout)) {
9562327a753SHans Petter Selasky ent->ret = -ETIMEDOUT;
957721a1a6aSSlava Shwartsman mlx5_cmd_comp_handler(dev, 1UL << ent->idx, MLX5_CMD_MODE_EVENTS);
958dc7e38acSHans Petter Selasky }
95930dfc051SHans Petter Selasky
9602327a753SHans Petter Selasky err = ent->ret;
9612327a753SHans Petter Selasky
962dc7e38acSHans Petter Selasky if (err == -ETIMEDOUT) {
963dc7e38acSHans Petter Selasky mlx5_core_warn(dev, "%s(0x%x) timeout. Will cause a leak of a command resource\n",
964dc7e38acSHans Petter Selasky mlx5_command_str(msg_to_opcode(ent->in)),
965dc7e38acSHans Petter Selasky msg_to_opcode(ent->in));
966dc7e38acSHans Petter Selasky }
967dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "err %d, delivery status %s(%d)\n",
968dc7e38acSHans Petter Selasky err, deliv_status_to_str(ent->status), ent->status);
969dc7e38acSHans Petter Selasky
970dc7e38acSHans Petter Selasky return err;
971dc7e38acSHans Petter Selasky }
972dc7e38acSHans Petter Selasky
973dc7e38acSHans Petter Selasky /* Notes:
974dc7e38acSHans Petter Selasky * 1. Callback functions may not sleep
975dc7e38acSHans Petter Selasky * 2. page queue commands do not support asynchrous completion
976dc7e38acSHans Petter Selasky */
mlx5_cmd_invoke(struct mlx5_core_dev * dev,struct mlx5_cmd_msg * in,int uin_size,struct mlx5_cmd_msg * out,void * uout,int uout_size,mlx5_cmd_cbk_t callback,void * context,int page_queue,u8 * status,bool force_polling)977dc7e38acSHans Petter Selasky static int mlx5_cmd_invoke(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *in,
9781c807f67SHans Petter Selasky int uin_size,
979dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *out, void *uout, int uout_size,
980dc7e38acSHans Petter Selasky mlx5_cmd_cbk_t callback,
981c0902569SHans Petter Selasky void *context, int page_queue, u8 *status,
982c0902569SHans Petter Selasky bool force_polling)
983dc7e38acSHans Petter Selasky {
984dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd;
985dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent;
986dc7e38acSHans Petter Selasky struct mlx5_cmd_stats *stats;
987dc7e38acSHans Petter Selasky int err = 0;
988dc7e38acSHans Petter Selasky s64 ds;
989dc7e38acSHans Petter Selasky u16 op;
990dc7e38acSHans Petter Selasky
991dc7e38acSHans Petter Selasky if (callback && page_queue)
992dc7e38acSHans Petter Selasky return -EINVAL;
993dc7e38acSHans Petter Selasky
9941c807f67SHans Petter Selasky ent = alloc_cmd(cmd, in, uin_size, out, uout, uout_size, callback,
9951c807f67SHans Petter Selasky context, page_queue);
996dc7e38acSHans Petter Selasky if (IS_ERR(ent))
997dc7e38acSHans Petter Selasky return PTR_ERR(ent);
998dc7e38acSHans Petter Selasky
999721a1a6aSSlava Shwartsman ent->polling = force_polling || (cmd->mode == MLX5_CMD_MODE_POLLING);
1000c0902569SHans Petter Selasky
1001dc7e38acSHans Petter Selasky if (!callback)
1002dc7e38acSHans Petter Selasky init_completion(&ent->done);
1003dc7e38acSHans Petter Selasky
100411546d06SHans Petter Selasky INIT_DELAYED_WORK(&ent->cb_timeout_work, cb_timeout_handler);
1005dc7e38acSHans Petter Selasky INIT_WORK(&ent->work, cmd_work_handler);
1006dc7e38acSHans Petter Selasky if (page_queue) {
1007dc7e38acSHans Petter Selasky cmd_work_handler(&ent->work);
10088d1eeedbSHans Petter Selasky } else if (!queue_work(dev->priv.health.wq_cmd, &ent->work)) {
1009dc7e38acSHans Petter Selasky mlx5_core_warn(dev, "failed to queue work\n");
1010dc7e38acSHans Petter Selasky err = -ENOMEM;
1011dc7e38acSHans Petter Selasky goto out_free;
1012dc7e38acSHans Petter Selasky }
1013dc7e38acSHans Petter Selasky
10142327a753SHans Petter Selasky if (callback)
10152327a753SHans Petter Selasky goto out;
10162327a753SHans Petter Selasky
1017dc7e38acSHans Petter Selasky err = wait_func(dev, ent);
1018dc7e38acSHans Petter Selasky if (err == -ETIMEDOUT)
1019dc7e38acSHans Petter Selasky goto out;
1020dc7e38acSHans Petter Selasky
1021dc7e38acSHans Petter Selasky ds = ent->ts2 - ent->ts1;
1022788333d9SHans Petter Selasky op = MLX5_GET(mbox_in, in->first.data, opcode);
1023dc7e38acSHans Petter Selasky if (op < ARRAY_SIZE(cmd->stats)) {
1024dc7e38acSHans Petter Selasky stats = &cmd->stats[op];
1025dc7e38acSHans Petter Selasky spin_lock_irq(&stats->lock);
1026dc7e38acSHans Petter Selasky stats->sum += ds;
1027dc7e38acSHans Petter Selasky ++stats->n;
1028dc7e38acSHans Petter Selasky spin_unlock_irq(&stats->lock);
1029dc7e38acSHans Petter Selasky }
1030dc7e38acSHans Petter Selasky mlx5_core_dbg_mask(dev, 1 << MLX5_CMD_TIME,
1031dc7e38acSHans Petter Selasky "fw exec time for %s is %lld nsec\n",
1032dc7e38acSHans Petter Selasky mlx5_command_str(op), (long long)ds);
1033dc7e38acSHans Petter Selasky *status = ent->status;
1034dc7e38acSHans Petter Selasky free_cmd(ent);
1035dc7e38acSHans Petter Selasky
1036dc7e38acSHans Petter Selasky return err;
1037dc7e38acSHans Petter Selasky
1038dc7e38acSHans Petter Selasky out_free:
1039dc7e38acSHans Petter Selasky free_cmd(ent);
1040dc7e38acSHans Petter Selasky out:
1041dc7e38acSHans Petter Selasky return err;
1042dc7e38acSHans Petter Selasky }
1043dc7e38acSHans Petter Selasky
mlx5_copy_to_msg(struct mlx5_cmd_msg * to,void * from,size_t size)10441c807f67SHans Petter Selasky static int mlx5_copy_to_msg(struct mlx5_cmd_msg *to, void *from, size_t size)
1045dc7e38acSHans Petter Selasky {
10461c807f67SHans Petter Selasky size_t delta;
10471c807f67SHans Petter Selasky size_t i;
10481c807f67SHans Petter Selasky
10491c807f67SHans Petter Selasky if (to == NULL || from == NULL)
10501c807f67SHans Petter Selasky return (-ENOMEM);
10511c807f67SHans Petter Selasky
10521c807f67SHans Petter Selasky delta = min_t(size_t, size, sizeof(to->first.data));
10531c807f67SHans Petter Selasky memcpy(to->first.data, from, delta);
10541c807f67SHans Petter Selasky from = (char *)from + delta;
10551c807f67SHans Petter Selasky size -= delta;
10561c807f67SHans Petter Selasky
10571c807f67SHans Petter Selasky for (i = 0; size != 0; i++) {
1058dc7e38acSHans Petter Selasky struct mlx5_cmd_prot_block *block;
1059dc7e38acSHans Petter Selasky
10601c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(to, i * MLX5_CMD_MBOX_SIZE);
1061dc7e38acSHans Petter Selasky
10621c807f67SHans Petter Selasky delta = min_t(size_t, size, MLX5_CMD_DATA_BLOCK_SIZE);
10631c807f67SHans Petter Selasky memcpy(block->data, from, delta);
10641c807f67SHans Petter Selasky from = (char *)from + delta;
10651c807f67SHans Petter Selasky size -= delta;
1066dc7e38acSHans Petter Selasky }
10671c807f67SHans Petter Selasky return (0);
1068dc7e38acSHans Petter Selasky }
1069dc7e38acSHans Petter Selasky
mlx5_copy_from_msg(void * to,struct mlx5_cmd_msg * from,int size)1070dc7e38acSHans Petter Selasky static int mlx5_copy_from_msg(void *to, struct mlx5_cmd_msg *from, int size)
1071dc7e38acSHans Petter Selasky {
10721c807f67SHans Petter Selasky size_t delta;
10731c807f67SHans Petter Selasky size_t i;
10741c807f67SHans Petter Selasky
10751c807f67SHans Petter Selasky if (to == NULL || from == NULL)
10761c807f67SHans Petter Selasky return (-ENOMEM);
10771c807f67SHans Petter Selasky
10781c807f67SHans Petter Selasky delta = min_t(size_t, size, sizeof(from->first.data));
10791c807f67SHans Petter Selasky memcpy(to, from->first.data, delta);
10801c807f67SHans Petter Selasky to = (char *)to + delta;
10811c807f67SHans Petter Selasky size -= delta;
10821c807f67SHans Petter Selasky
10831c807f67SHans Petter Selasky for (i = 0; size != 0; i++) {
1084dc7e38acSHans Petter Selasky struct mlx5_cmd_prot_block *block;
1085dc7e38acSHans Petter Selasky
10861c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(from, i * MLX5_CMD_MBOX_SIZE);
1087dc7e38acSHans Petter Selasky
10881c807f67SHans Petter Selasky delta = min_t(size_t, size, MLX5_CMD_DATA_BLOCK_SIZE);
10891c807f67SHans Petter Selasky memcpy(to, block->data, delta);
10901c807f67SHans Petter Selasky to = (char *)to + delta;
10911c807f67SHans Petter Selasky size -= delta;
10921c807f67SHans Petter Selasky }
10931c807f67SHans Petter Selasky return (0);
1094dc7e38acSHans Petter Selasky }
1095dc7e38acSHans Petter Selasky
10961c807f67SHans Petter Selasky static struct mlx5_cmd_msg *
mlx5_alloc_cmd_msg(struct mlx5_core_dev * dev,gfp_t flags,size_t size)10971c807f67SHans Petter Selasky mlx5_alloc_cmd_msg(struct mlx5_core_dev *dev, gfp_t flags, size_t size)
1098dc7e38acSHans Petter Selasky {
1099dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg;
11001c807f67SHans Petter Selasky size_t blen;
11011c807f67SHans Petter Selasky size_t n;
11021c807f67SHans Petter Selasky size_t i;
1103dc7e38acSHans Petter Selasky
11041c807f67SHans Petter Selasky blen = size - min_t(size_t, sizeof(msg->first.data), size);
11051c807f67SHans Petter Selasky n = howmany(blen, MLX5_CMD_DATA_BLOCK_SIZE);
1106dc7e38acSHans Petter Selasky
11071c807f67SHans Petter Selasky msg = mlx5_fwp_alloc(dev, flags, howmany(n, MLX5_NUM_CMDS_IN_ADAPTER_PAGE));
11081c807f67SHans Petter Selasky if (msg == NULL)
11091c807f67SHans Petter Selasky return (ERR_PTR(-ENOMEM));
1110dc7e38acSHans Petter Selasky
11111c807f67SHans Petter Selasky for (i = 0; i != n; i++) {
11121c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block;
11131c807f67SHans Petter Selasky
11141c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE);
11151c807f67SHans Petter Selasky
111647a6fb9dSMark Johnston if (i != (n - 1)) {
11171c807f67SHans Petter Selasky memset(block, 0, MLX5_CMD_MBOX_SIZE);
11181c807f67SHans Petter Selasky
11191c807f67SHans Petter Selasky u64 dma = mlx5_fwp_get_dma(msg, (i + 1) * MLX5_CMD_MBOX_SIZE);
11201c807f67SHans Petter Selasky block->next = cpu_to_be64(dma);
112147a6fb9dSMark Johnston } else {
112247a6fb9dSMark Johnston /* Zero the rest of the page to satisfy KMSAN. */
112347a6fb9dSMark Johnston memset(block, 0, MLX5_ADAPTER_PAGE_SIZE -
112447a6fb9dSMark Johnston (i % MLX5_NUM_CMDS_IN_ADAPTER_PAGE) *
112547a6fb9dSMark Johnston MLX5_CMD_MBOX_SIZE);
11261c807f67SHans Petter Selasky }
11271c807f67SHans Petter Selasky block->block_num = cpu_to_be32(i);
1128dc7e38acSHans Petter Selasky }
1129dc7e38acSHans Petter Selasky
11301c807f67SHans Petter Selasky /* make sure initial data is written to RAM */
11311c807f67SHans Petter Selasky mlx5_fwp_flush(msg);
1132dc7e38acSHans Petter Selasky
11331c807f67SHans Petter Selasky return (msg);
1134dc7e38acSHans Petter Selasky }
1135dc7e38acSHans Petter Selasky
11361c807f67SHans Petter Selasky static void
mlx5_free_cmd_msg(struct mlx5_core_dev * dev,struct mlx5_cmd_msg * msg)11371c807f67SHans Petter Selasky mlx5_free_cmd_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg)
1138dc7e38acSHans Petter Selasky {
1139dc7e38acSHans Petter Selasky
11401c807f67SHans Petter Selasky mlx5_fwp_free(msg);
1141dc7e38acSHans Petter Selasky }
1142dc7e38acSHans Petter Selasky
clean_debug_files(struct mlx5_core_dev * dev)1143dc7e38acSHans Petter Selasky static void clean_debug_files(struct mlx5_core_dev *dev)
1144dc7e38acSHans Petter Selasky {
1145dc7e38acSHans Petter Selasky }
1146dc7e38acSHans Petter Selasky
1147dc7e38acSHans Petter Selasky
mlx5_cmd_change_mod(struct mlx5_core_dev * dev,int mode)11482327a753SHans Petter Selasky static void mlx5_cmd_change_mod(struct mlx5_core_dev *dev, int mode)
1149dc7e38acSHans Petter Selasky {
1150dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd;
1151dc7e38acSHans Petter Selasky int i;
1152dc7e38acSHans Petter Selasky
1153192fc18dSHans Petter Selasky if (cmd->mode == mode)
1154192fc18dSHans Petter Selasky return;
1155192fc18dSHans Petter Selasky
1156dc7e38acSHans Petter Selasky for (i = 0; i < cmd->max_reg_cmds; i++)
1157dc7e38acSHans Petter Selasky down(&cmd->sem);
1158dc7e38acSHans Petter Selasky
1159dc7e38acSHans Petter Selasky down(&cmd->pages_sem);
11602327a753SHans Petter Selasky cmd->mode = mode;
1161dc7e38acSHans Petter Selasky
1162dc7e38acSHans Petter Selasky up(&cmd->pages_sem);
1163dc7e38acSHans Petter Selasky for (i = 0; i < cmd->max_reg_cmds; i++)
1164dc7e38acSHans Petter Selasky up(&cmd->sem);
1165dc7e38acSHans Petter Selasky }
1166dc7e38acSHans Petter Selasky
mlx5_cmd_use_events(struct mlx5_core_dev * dev)11672327a753SHans Petter Selasky void mlx5_cmd_use_events(struct mlx5_core_dev *dev)
11682327a753SHans Petter Selasky {
1169721a1a6aSSlava Shwartsman mlx5_cmd_change_mod(dev, MLX5_CMD_MODE_EVENTS);
11702327a753SHans Petter Selasky }
11712327a753SHans Petter Selasky
mlx5_cmd_use_polling(struct mlx5_core_dev * dev)1172dc7e38acSHans Petter Selasky void mlx5_cmd_use_polling(struct mlx5_core_dev *dev)
1173dc7e38acSHans Petter Selasky {
1174721a1a6aSSlava Shwartsman mlx5_cmd_change_mod(dev, MLX5_CMD_MODE_POLLING);
1175dc7e38acSHans Petter Selasky }
1176dc7e38acSHans Petter Selasky
free_msg(struct mlx5_core_dev * dev,struct mlx5_cmd_msg * msg)1177dc7e38acSHans Petter Selasky static void free_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg)
1178dc7e38acSHans Petter Selasky {
1179dc7e38acSHans Petter Selasky unsigned long flags;
1180dc7e38acSHans Petter Selasky
1181dc7e38acSHans Petter Selasky if (msg->cache) {
1182dc7e38acSHans Petter Selasky spin_lock_irqsave(&msg->cache->lock, flags);
1183dc7e38acSHans Petter Selasky list_add_tail(&msg->list, &msg->cache->head);
1184dc7e38acSHans Petter Selasky spin_unlock_irqrestore(&msg->cache->lock, flags);
1185dc7e38acSHans Petter Selasky } else {
1186dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, msg);
1187dc7e38acSHans Petter Selasky }
1188dc7e38acSHans Petter Selasky }
1189dc7e38acSHans Petter Selasky
mlx5_cmd_comp_handler(struct mlx5_core_dev * dev,u64 vector_flags,enum mlx5_cmd_mode cmd_mode)1190721a1a6aSSlava Shwartsman void mlx5_cmd_comp_handler(struct mlx5_core_dev *dev, u64 vector_flags,
1191721a1a6aSSlava Shwartsman enum mlx5_cmd_mode cmd_mode)
1192dc7e38acSHans Petter Selasky {
1193dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd;
1194dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent;
119570b417cfSSlava Shwartsman bool triggered = (vector_flags & MLX5_TRIGGERED_CMD_COMP) ? 1 : 0;
119670b417cfSSlava Shwartsman u32 vector = vector_flags; /* discard flags in the upper dword */
1197dc7e38acSHans Petter Selasky int i;
1198dc7e38acSHans Petter Selasky
11991c807f67SHans Petter Selasky /* make sure data gets read from RAM */
12001c807f67SHans Petter Selasky mlx5_fwp_invalidate(cmd->cmd_page);
12011c807f67SHans Petter Selasky
1202d0ce5a0dSHans Petter Selasky while (vector != 0) {
1203d0ce5a0dSHans Petter Selasky i = ffs(vector) - 1;
1204d0ce5a0dSHans Petter Selasky vector &= ~(1U << i);
1205721a1a6aSSlava Shwartsman /* check command mode */
1206721a1a6aSSlava Shwartsman if (cmd->ent_mode[i] != cmd_mode)
1207721a1a6aSSlava Shwartsman continue;
1208dc7e38acSHans Petter Selasky ent = cmd->ent_arr[i];
1209721a1a6aSSlava Shwartsman /* check if command was already handled */
1210721a1a6aSSlava Shwartsman if (ent == NULL)
1211721a1a6aSSlava Shwartsman continue;
121211546d06SHans Petter Selasky if (ent->callback)
121311546d06SHans Petter Selasky cancel_delayed_work(&ent->cb_timeout_work);
1214dc7e38acSHans Petter Selasky ent->ts2 = ktime_get_ns();
1215d0ce5a0dSHans Petter Selasky memcpy(ent->out->first.data, ent->lay->out,
1216d0ce5a0dSHans Petter Selasky sizeof(ent->lay->out));
12171c807f67SHans Petter Selasky /* make sure data gets read from RAM */
12181c807f67SHans Petter Selasky mlx5_fwp_invalidate(ent->out);
1219dc7e38acSHans Petter Selasky dump_command(dev, ent, 0);
1220dc7e38acSHans Petter Selasky if (!ent->ret) {
1221dc7e38acSHans Petter Selasky if (!cmd->checksum_disabled)
1222dc7e38acSHans Petter Selasky ent->ret = verify_signature(ent);
1223dc7e38acSHans Petter Selasky else
1224dc7e38acSHans Petter Selasky ent->ret = 0;
1225a5754bd2SHans Petter Selasky
122670b417cfSSlava Shwartsman if (triggered)
1227a2485fe5SHans Petter Selasky ent->status = MLX5_DRIVER_STATUS_ABORTED;
1228a2485fe5SHans Petter Selasky else
1229a2485fe5SHans Petter Selasky ent->status = ent->lay->status_own >> 1;
123030dfc051SHans Petter Selasky
1231d0ce5a0dSHans Petter Selasky mlx5_core_dbg(dev,
1232d0ce5a0dSHans Petter Selasky "FW command ret 0x%x, status %s(0x%x)\n",
1233d0ce5a0dSHans Petter Selasky ent->ret,
1234d0ce5a0dSHans Petter Selasky deliv_status_to_str(ent->status),
1235d0ce5a0dSHans Petter Selasky ent->status);
1236dc7e38acSHans Petter Selasky }
1237dc7e38acSHans Petter Selasky free_ent(cmd, ent->idx);
12388e7e0ce1SHans Petter Selasky complete_command(ent);
1239dc7e38acSHans Petter Selasky }
1240dc7e38acSHans Petter Selasky }
1241dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_comp_handler);
1242dc7e38acSHans Petter Selasky
status_to_err(u8 status)1243dc7e38acSHans Petter Selasky static int status_to_err(u8 status)
1244dc7e38acSHans Petter Selasky {
124507e68e62SHans Petter Selasky return status ? -EIO : 0; /* TBD more meaningful codes */
1246dc7e38acSHans Petter Selasky }
1247dc7e38acSHans Petter Selasky
alloc_msg(struct mlx5_core_dev * dev,int in_size,gfp_t gfp)1248dc7e38acSHans Petter Selasky static struct mlx5_cmd_msg *alloc_msg(struct mlx5_core_dev *dev, int in_size,
1249dc7e38acSHans Petter Selasky gfp_t gfp)
1250dc7e38acSHans Petter Selasky {
1251dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg = ERR_PTR(-ENOMEM);
1252dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd;
1253dc7e38acSHans Petter Selasky struct cache_ent *ent = NULL;
1254dc7e38acSHans Petter Selasky
1255dc7e38acSHans Petter Selasky if (in_size > MED_LIST_SIZE && in_size <= LONG_LIST_SIZE)
1256dc7e38acSHans Petter Selasky ent = &cmd->cache.large;
1257dc7e38acSHans Petter Selasky else if (in_size > 16 && in_size <= MED_LIST_SIZE)
1258dc7e38acSHans Petter Selasky ent = &cmd->cache.med;
1259dc7e38acSHans Petter Selasky
1260dc7e38acSHans Petter Selasky if (ent) {
1261dc7e38acSHans Petter Selasky spin_lock_irq(&ent->lock);
1262dc7e38acSHans Petter Selasky if (!list_empty(&ent->head)) {
1263dc7e38acSHans Petter Selasky msg = list_entry(ent->head.next, struct mlx5_cmd_msg,
1264dc7e38acSHans Petter Selasky list);
1265dc7e38acSHans Petter Selasky list_del(&msg->list);
1266dc7e38acSHans Petter Selasky }
1267dc7e38acSHans Petter Selasky spin_unlock_irq(&ent->lock);
1268dc7e38acSHans Petter Selasky }
1269dc7e38acSHans Petter Selasky
1270dc7e38acSHans Petter Selasky if (IS_ERR(msg))
1271dc7e38acSHans Petter Selasky msg = mlx5_alloc_cmd_msg(dev, gfp, in_size);
1272dc7e38acSHans Petter Selasky
1273dc7e38acSHans Petter Selasky return msg;
1274dc7e38acSHans Petter Selasky }
1275dc7e38acSHans Petter Selasky
is_manage_pages(void * in)1276788333d9SHans Petter Selasky static int is_manage_pages(void *in)
1277a2485fe5SHans Petter Selasky {
1278788333d9SHans Petter Selasky return MLX5_GET(mbox_in, in, opcode) == MLX5_CMD_OP_MANAGE_PAGES;
1279dc7e38acSHans Petter Selasky }
1280dc7e38acSHans Petter Selasky
cmd_exec_helper(struct mlx5_core_dev * dev,void * in,int in_size,void * out,int out_size,mlx5_cmd_cbk_t callback,void * context,bool force_polling)128130dfc051SHans Petter Selasky static int cmd_exec_helper(struct mlx5_core_dev *dev,
128230dfc051SHans Petter Selasky void *in, int in_size,
128330dfc051SHans Petter Selasky void *out, int out_size,
1284c0902569SHans Petter Selasky mlx5_cmd_cbk_t callback, void *context,
1285c0902569SHans Petter Selasky bool force_polling)
1286dc7e38acSHans Petter Selasky {
1287dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *inb;
1288dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *outb;
1289dc7e38acSHans Petter Selasky int pages_queue;
12901d4905b5SHans Petter Selasky const gfp_t gfp = GFP_KERNEL;
1291dc7e38acSHans Petter Selasky int err;
1292dc7e38acSHans Petter Selasky u8 status = 0;
1293a2485fe5SHans Petter Selasky u32 drv_synd;
1294a2485fe5SHans Petter Selasky
1295e787b5acSHans Petter Selasky if (dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) {
1296788333d9SHans Petter Selasky u16 opcode = MLX5_GET(mbox_in, in, opcode);
1297788333d9SHans Petter Selasky err = mlx5_internal_err_ret_value(dev, opcode, &drv_synd, &status);
1298788333d9SHans Petter Selasky MLX5_SET(mbox_out, out, status, status);
1299788333d9SHans Petter Selasky MLX5_SET(mbox_out, out, syndrome, drv_synd);
1300a2485fe5SHans Petter Selasky return err;
1301a2485fe5SHans Petter Selasky }
1302dc7e38acSHans Petter Selasky
1303dc7e38acSHans Petter Selasky pages_queue = is_manage_pages(in);
1304dc7e38acSHans Petter Selasky
1305dc7e38acSHans Petter Selasky inb = alloc_msg(dev, in_size, gfp);
1306dc7e38acSHans Petter Selasky if (IS_ERR(inb)) {
1307dc7e38acSHans Petter Selasky err = PTR_ERR(inb);
1308dc7e38acSHans Petter Selasky return err;
1309dc7e38acSHans Petter Selasky }
1310dc7e38acSHans Petter Selasky
1311dc7e38acSHans Petter Selasky err = mlx5_copy_to_msg(inb, in, in_size);
1312dc7e38acSHans Petter Selasky if (err) {
1313dc7e38acSHans Petter Selasky mlx5_core_warn(dev, "err %d\n", err);
1314dc7e38acSHans Petter Selasky goto out_in;
1315dc7e38acSHans Petter Selasky }
1316dc7e38acSHans Petter Selasky
1317dc7e38acSHans Petter Selasky outb = mlx5_alloc_cmd_msg(dev, gfp, out_size);
1318dc7e38acSHans Petter Selasky if (IS_ERR(outb)) {
1319dc7e38acSHans Petter Selasky err = PTR_ERR(outb);
1320dc7e38acSHans Petter Selasky goto out_in;
1321dc7e38acSHans Petter Selasky }
1322dc7e38acSHans Petter Selasky
13231c807f67SHans Petter Selasky err = mlx5_cmd_invoke(dev, inb, in_size, outb, out, out_size, callback,
1324c0902569SHans Petter Selasky context, pages_queue, &status, force_polling);
132597ac3908SHans Petter Selasky if (err) {
132697ac3908SHans Petter Selasky if (err == -ETIMEDOUT)
132797ac3908SHans Petter Selasky return err;
1328dc7e38acSHans Petter Selasky goto out_out;
132997ac3908SHans Petter Selasky }
1330dc7e38acSHans Petter Selasky
1331dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "err %d, status %d\n", err, status);
1332dc7e38acSHans Petter Selasky if (status) {
1333dc7e38acSHans Petter Selasky err = status_to_err(status);
1334dc7e38acSHans Petter Selasky goto out_out;
1335dc7e38acSHans Petter Selasky }
1336dc7e38acSHans Petter Selasky
1337dc7e38acSHans Petter Selasky if (callback)
1338dc7e38acSHans Petter Selasky return err;
1339dc7e38acSHans Petter Selasky
1340dc7e38acSHans Petter Selasky err = mlx5_copy_from_msg(out, outb, out_size);
1341dc7e38acSHans Petter Selasky
1342dc7e38acSHans Petter Selasky out_out:
1343dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, outb);
1344dc7e38acSHans Petter Selasky
1345dc7e38acSHans Petter Selasky out_in:
1346dc7e38acSHans Petter Selasky free_msg(dev, inb);
1347dc7e38acSHans Petter Selasky return err;
1348dc7e38acSHans Petter Selasky }
1349dc7e38acSHans Petter Selasky
mlx5_cmd_exec(struct mlx5_core_dev * dev,void * in,int in_size,void * out,int out_size)1350dc7e38acSHans Petter Selasky int mlx5_cmd_exec(struct mlx5_core_dev *dev, void *in, int in_size, void *out,
1351dc7e38acSHans Petter Selasky int out_size)
1352dc7e38acSHans Petter Selasky {
1353788333d9SHans Petter Selasky int err;
1354788333d9SHans Petter Selasky
1355c0902569SHans Petter Selasky err = cmd_exec_helper(dev, in, in_size, out, out_size, NULL, NULL, false);
1356788333d9SHans Petter Selasky return err ? : mlx5_cmd_check(dev, in, out);
1357dc7e38acSHans Petter Selasky }
1358dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_exec);
1359dc7e38acSHans Petter Selasky
mlx5_cmd_init_async_ctx(struct mlx5_core_dev * dev,struct mlx5_async_ctx * ctx)13607eefcb5eSHans Petter Selasky void mlx5_cmd_init_async_ctx(struct mlx5_core_dev *dev,
13617eefcb5eSHans Petter Selasky struct mlx5_async_ctx *ctx)
1362dc7e38acSHans Petter Selasky {
13637eefcb5eSHans Petter Selasky ctx->dev = dev;
13647eefcb5eSHans Petter Selasky /* Starts at 1 to avoid doing wake_up if we are not cleaning up */
13657eefcb5eSHans Petter Selasky atomic_set(&ctx->num_inflight, 1);
13667eefcb5eSHans Petter Selasky init_waitqueue_head(&ctx->wait);
13677eefcb5eSHans Petter Selasky }
13687eefcb5eSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_init_async_ctx);
13697eefcb5eSHans Petter Selasky
13707eefcb5eSHans Petter Selasky /**
13717eefcb5eSHans Petter Selasky * mlx5_cmd_cleanup_async_ctx - Clean up an async_ctx
13727eefcb5eSHans Petter Selasky * @ctx: The ctx to clean
13737eefcb5eSHans Petter Selasky *
13747eefcb5eSHans Petter Selasky * Upon return all callbacks given to mlx5_cmd_exec_cb() have been called. The
13757eefcb5eSHans Petter Selasky * caller must ensure that mlx5_cmd_exec_cb() is not called during or after
13767eefcb5eSHans Petter Selasky * the call mlx5_cleanup_async_ctx().
13777eefcb5eSHans Petter Selasky */
mlx5_cmd_cleanup_async_ctx(struct mlx5_async_ctx * ctx)13787eefcb5eSHans Petter Selasky void mlx5_cmd_cleanup_async_ctx(struct mlx5_async_ctx *ctx)
13797eefcb5eSHans Petter Selasky {
13807eefcb5eSHans Petter Selasky atomic_dec(&ctx->num_inflight);
13817eefcb5eSHans Petter Selasky wait_event(ctx->wait, atomic_read(&ctx->num_inflight) == 0);
13827eefcb5eSHans Petter Selasky }
13837eefcb5eSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_cleanup_async_ctx);
13847eefcb5eSHans Petter Selasky
mlx5_cmd_exec_cb_handler(int status,void * _work)13857eefcb5eSHans Petter Selasky static void mlx5_cmd_exec_cb_handler(int status, void *_work)
13867eefcb5eSHans Petter Selasky {
13877eefcb5eSHans Petter Selasky struct mlx5_async_work *work = _work;
13887eefcb5eSHans Petter Selasky struct mlx5_async_ctx *ctx = work->ctx;
13897eefcb5eSHans Petter Selasky
13907eefcb5eSHans Petter Selasky work->user_callback(status, work);
13917eefcb5eSHans Petter Selasky if (atomic_dec_and_test(&ctx->num_inflight))
13927eefcb5eSHans Petter Selasky wake_up(&ctx->wait);
13937eefcb5eSHans Petter Selasky }
13947eefcb5eSHans Petter Selasky
mlx5_cmd_exec_cb(struct mlx5_async_ctx * ctx,void * in,int in_size,void * out,int out_size,mlx5_async_cbk_t callback,struct mlx5_async_work * work)13957eefcb5eSHans Petter Selasky int mlx5_cmd_exec_cb(struct mlx5_async_ctx *ctx, void *in, int in_size,
13967eefcb5eSHans Petter Selasky void *out, int out_size, mlx5_async_cbk_t callback,
13977eefcb5eSHans Petter Selasky struct mlx5_async_work *work)
13987eefcb5eSHans Petter Selasky {
13997eefcb5eSHans Petter Selasky int ret;
14007eefcb5eSHans Petter Selasky
14017eefcb5eSHans Petter Selasky work->ctx = ctx;
14027eefcb5eSHans Petter Selasky work->user_callback = callback;
14037eefcb5eSHans Petter Selasky if (WARN_ON(!atomic_inc_not_zero(&ctx->num_inflight)))
14047eefcb5eSHans Petter Selasky return -EIO;
14057eefcb5eSHans Petter Selasky ret = cmd_exec_helper(ctx->dev, in, in_size, out, out_size,
14067eefcb5eSHans Petter Selasky mlx5_cmd_exec_cb_handler, work, false);
14077eefcb5eSHans Petter Selasky if (ret && atomic_dec_and_test(&ctx->num_inflight))
14087eefcb5eSHans Petter Selasky wake_up(&ctx->wait);
14097eefcb5eSHans Petter Selasky
14107eefcb5eSHans Petter Selasky return ret;
1411dc7e38acSHans Petter Selasky }
1412dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_exec_cb);
1413dc7e38acSHans Petter Selasky
mlx5_cmd_exec_polling(struct mlx5_core_dev * dev,void * in,int in_size,void * out,int out_size)1414c0902569SHans Petter Selasky int mlx5_cmd_exec_polling(struct mlx5_core_dev *dev, void *in, int in_size,
1415c0902569SHans Petter Selasky void *out, int out_size)
1416c0902569SHans Petter Selasky {
1417c0902569SHans Petter Selasky int err;
1418c0902569SHans Petter Selasky
1419c0902569SHans Petter Selasky err = cmd_exec_helper(dev, in, in_size, out, out_size, NULL, NULL, true);
1420c0902569SHans Petter Selasky return err ? : mlx5_cmd_check(dev, in, out);
1421c0902569SHans Petter Selasky }
1422c0902569SHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_exec_polling);
1423c0902569SHans Petter Selasky
destroy_msg_cache(struct mlx5_core_dev * dev)1424dc7e38acSHans Petter Selasky static void destroy_msg_cache(struct mlx5_core_dev *dev)
1425dc7e38acSHans Petter Selasky {
1426dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd;
1427dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg;
1428dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *n;
1429dc7e38acSHans Petter Selasky
1430dc7e38acSHans Petter Selasky list_for_each_entry_safe(msg, n, &cmd->cache.large.head, list) {
1431dc7e38acSHans Petter Selasky list_del(&msg->list);
1432dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, msg);
1433dc7e38acSHans Petter Selasky }
1434dc7e38acSHans Petter Selasky
1435dc7e38acSHans Petter Selasky list_for_each_entry_safe(msg, n, &cmd->cache.med.head, list) {
1436dc7e38acSHans Petter Selasky list_del(&msg->list);
1437dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, msg);
1438dc7e38acSHans Petter Selasky }
1439dc7e38acSHans Petter Selasky }
1440dc7e38acSHans Petter Selasky
create_msg_cache(struct mlx5_core_dev * dev)1441dc7e38acSHans Petter Selasky static int create_msg_cache(struct mlx5_core_dev *dev)
1442dc7e38acSHans Petter Selasky {
1443dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd;
1444dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg;
1445dc7e38acSHans Petter Selasky int err;
1446dc7e38acSHans Petter Selasky int i;
1447dc7e38acSHans Petter Selasky
1448dc7e38acSHans Petter Selasky spin_lock_init(&cmd->cache.large.lock);
1449dc7e38acSHans Petter Selasky INIT_LIST_HEAD(&cmd->cache.large.head);
1450dc7e38acSHans Petter Selasky spin_lock_init(&cmd->cache.med.lock);
1451dc7e38acSHans Petter Selasky INIT_LIST_HEAD(&cmd->cache.med.head);
1452dc7e38acSHans Petter Selasky
1453dc7e38acSHans Petter Selasky for (i = 0; i < NUM_LONG_LISTS; i++) {
1454dc7e38acSHans Petter Selasky msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, LONG_LIST_SIZE);
1455dc7e38acSHans Petter Selasky if (IS_ERR(msg)) {
1456dc7e38acSHans Petter Selasky err = PTR_ERR(msg);
1457dc7e38acSHans Petter Selasky goto ex_err;
1458dc7e38acSHans Petter Selasky }
1459dc7e38acSHans Petter Selasky msg->cache = &cmd->cache.large;
1460dc7e38acSHans Petter Selasky list_add_tail(&msg->list, &cmd->cache.large.head);
1461dc7e38acSHans Petter Selasky }
1462dc7e38acSHans Petter Selasky
1463dc7e38acSHans Petter Selasky for (i = 0; i < NUM_MED_LISTS; i++) {
1464dc7e38acSHans Petter Selasky msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, MED_LIST_SIZE);
1465dc7e38acSHans Petter Selasky if (IS_ERR(msg)) {
1466dc7e38acSHans Petter Selasky err = PTR_ERR(msg);
1467dc7e38acSHans Petter Selasky goto ex_err;
1468dc7e38acSHans Petter Selasky }
1469dc7e38acSHans Petter Selasky msg->cache = &cmd->cache.med;
1470dc7e38acSHans Petter Selasky list_add_tail(&msg->list, &cmd->cache.med.head);
1471dc7e38acSHans Petter Selasky }
1472dc7e38acSHans Petter Selasky
1473dc7e38acSHans Petter Selasky return 0;
1474dc7e38acSHans Petter Selasky
1475dc7e38acSHans Petter Selasky ex_err:
1476dc7e38acSHans Petter Selasky destroy_msg_cache(dev);
1477dc7e38acSHans Petter Selasky return err;
1478dc7e38acSHans Petter Selasky }
1479dc7e38acSHans Petter Selasky
14801c807f67SHans Petter Selasky static int
alloc_cmd_page(struct mlx5_core_dev * dev,struct mlx5_cmd * cmd)14811c807f67SHans Petter Selasky alloc_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd)
1482dc7e38acSHans Petter Selasky {
14831c807f67SHans Petter Selasky int err;
1484dc7e38acSHans Petter Selasky
14851c807f67SHans Petter Selasky sx_init(&cmd->dma_sx, "MLX5-DMA-SX");
14861c807f67SHans Petter Selasky mtx_init(&cmd->dma_mtx, "MLX5-DMA-MTX", NULL, MTX_DEF);
14871c807f67SHans Petter Selasky cv_init(&cmd->dma_cv, "MLX5-DMA-CV");
14881c807f67SHans Petter Selasky
14891c807f67SHans Petter Selasky /*
14901c807f67SHans Petter Selasky * Create global DMA descriptor tag for allocating
14911c807f67SHans Petter Selasky * 4K firmware pages:
14921c807f67SHans Petter Selasky */
14931c807f67SHans Petter Selasky err = -bus_dma_tag_create(
14941c807f67SHans Petter Selasky bus_get_dma_tag(dev->pdev->dev.bsddev),
14951c807f67SHans Petter Selasky MLX5_ADAPTER_PAGE_SIZE, /* alignment */
14961c807f67SHans Petter Selasky 0, /* no boundary */
14971c807f67SHans Petter Selasky BUS_SPACE_MAXADDR, /* lowaddr */
14981c807f67SHans Petter Selasky BUS_SPACE_MAXADDR, /* highaddr */
14991c807f67SHans Petter Selasky NULL, NULL, /* filter, filterarg */
15001c807f67SHans Petter Selasky MLX5_ADAPTER_PAGE_SIZE, /* maxsize */
15011c807f67SHans Petter Selasky 1, /* nsegments */
15021c807f67SHans Petter Selasky MLX5_ADAPTER_PAGE_SIZE, /* maxsegsize */
15031c807f67SHans Petter Selasky 0, /* flags */
15041c807f67SHans Petter Selasky NULL, NULL, /* lockfunc, lockfuncarg */
15051c807f67SHans Petter Selasky &cmd->dma_tag);
15061c807f67SHans Petter Selasky if (err != 0)
15071c807f67SHans Petter Selasky goto failure_destroy_sx;
15081c807f67SHans Petter Selasky
15091c807f67SHans Petter Selasky cmd->cmd_page = mlx5_fwp_alloc(dev, GFP_KERNEL, 1);
15101c807f67SHans Petter Selasky if (cmd->cmd_page == NULL) {
15111c807f67SHans Petter Selasky err = -ENOMEM;
15121c807f67SHans Petter Selasky goto failure_alloc_page;
15131c807f67SHans Petter Selasky }
15141c807f67SHans Petter Selasky cmd->dma = mlx5_fwp_get_dma(cmd->cmd_page, 0);
15151c807f67SHans Petter Selasky cmd->cmd_buf = mlx5_fwp_get_virt(cmd->cmd_page, 0);
151647a6fb9dSMark Johnston memset(cmd->cmd_buf, 0, MLX5_ADAPTER_PAGE_SIZE);
15171c807f67SHans Petter Selasky return (0);
15181c807f67SHans Petter Selasky
15191c807f67SHans Petter Selasky failure_alloc_page:
15201c807f67SHans Petter Selasky bus_dma_tag_destroy(cmd->dma_tag);
15211c807f67SHans Petter Selasky
15221c807f67SHans Petter Selasky failure_destroy_sx:
15231c807f67SHans Petter Selasky cv_destroy(&cmd->dma_cv);
15241c807f67SHans Petter Selasky mtx_destroy(&cmd->dma_mtx);
15251c807f67SHans Petter Selasky sx_destroy(&cmd->dma_sx);
15261c807f67SHans Petter Selasky return (err);
1527dc7e38acSHans Petter Selasky }
1528dc7e38acSHans Petter Selasky
15291c807f67SHans Petter Selasky static void
free_cmd_page(struct mlx5_core_dev * dev,struct mlx5_cmd * cmd)15301c807f67SHans Petter Selasky free_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd)
1531dc7e38acSHans Petter Selasky {
15321c807f67SHans Petter Selasky
15331c807f67SHans Petter Selasky mlx5_fwp_free(cmd->cmd_page);
15341c807f67SHans Petter Selasky bus_dma_tag_destroy(cmd->dma_tag);
15351c807f67SHans Petter Selasky cv_destroy(&cmd->dma_cv);
15361c807f67SHans Petter Selasky mtx_destroy(&cmd->dma_mtx);
15371c807f67SHans Petter Selasky sx_destroy(&cmd->dma_sx);
1538dc7e38acSHans Petter Selasky }
1539dc7e38acSHans Petter Selasky
mlx5_cmd_init(struct mlx5_core_dev * dev)1540dc7e38acSHans Petter Selasky int mlx5_cmd_init(struct mlx5_core_dev *dev)
1541dc7e38acSHans Petter Selasky {
1542dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd;
1543dc7e38acSHans Petter Selasky u32 cmd_h, cmd_l;
1544dc7e38acSHans Petter Selasky u16 cmd_if_rev;
1545dc7e38acSHans Petter Selasky int err;
1546dc7e38acSHans Petter Selasky int i;
1547dc7e38acSHans Petter Selasky
1548a2485fe5SHans Petter Selasky memset(cmd, 0, sizeof(*cmd));
1549dc7e38acSHans Petter Selasky cmd_if_rev = cmdif_rev_get(dev);
1550dc7e38acSHans Petter Selasky if (cmd_if_rev != CMD_IF_REV) {
1551a2f4f59cSHans Petter Selasky mlx5_core_err(dev,
1552a2f4f59cSHans Petter Selasky "Driver cmdif rev(%d) differs from firmware's(%d)\n",
1553a2f4f59cSHans Petter Selasky CMD_IF_REV, cmd_if_rev);
1554dc7e38acSHans Petter Selasky return -EINVAL;
1555dc7e38acSHans Petter Selasky }
1556dc7e38acSHans Petter Selasky
1557dc7e38acSHans Petter Selasky err = alloc_cmd_page(dev, cmd);
1558dc7e38acSHans Petter Selasky if (err)
1559dc7e38acSHans Petter Selasky goto err_free_pool;
1560dc7e38acSHans Petter Selasky
1561dc7e38acSHans Petter Selasky cmd_l = ioread32be(&dev->iseg->cmdq_addr_l_sz) & 0xff;
1562dc7e38acSHans Petter Selasky cmd->log_sz = cmd_l >> 4 & 0xf;
1563dc7e38acSHans Petter Selasky cmd->log_stride = cmd_l & 0xf;
1564dc7e38acSHans Petter Selasky if (1 << cmd->log_sz > MLX5_MAX_COMMANDS) {
1565a2f4f59cSHans Petter Selasky mlx5_core_err(dev,
1566a2f4f59cSHans Petter Selasky "firmware reports too many outstanding commands %d\n",
1567a2f4f59cSHans Petter Selasky 1 << cmd->log_sz);
1568dc7e38acSHans Petter Selasky err = -EINVAL;
1569dc7e38acSHans Petter Selasky goto err_free_page;
1570dc7e38acSHans Petter Selasky }
1571dc7e38acSHans Petter Selasky
1572dc7e38acSHans Petter Selasky if (cmd->log_sz + cmd->log_stride > MLX5_ADAPTER_PAGE_SHIFT) {
1573a2f4f59cSHans Petter Selasky mlx5_core_err(dev,
1574a2f4f59cSHans Petter Selasky "command queue size overflow\n");
1575dc7e38acSHans Petter Selasky err = -EINVAL;
1576dc7e38acSHans Petter Selasky goto err_free_page;
1577dc7e38acSHans Petter Selasky }
1578dc7e38acSHans Petter Selasky
1579dc7e38acSHans Petter Selasky cmd->checksum_disabled = 1;
1580dc7e38acSHans Petter Selasky cmd->max_reg_cmds = (1 << cmd->log_sz) - 1;
1581dc7e38acSHans Petter Selasky cmd->bitmask = (1 << cmd->max_reg_cmds) - 1;
1582dc7e38acSHans Petter Selasky
1583dc7e38acSHans Petter Selasky cmd->cmdif_rev = ioread32be(&dev->iseg->cmdif_rev_fw_sub) >> 16;
1584dc7e38acSHans Petter Selasky if (cmd->cmdif_rev > CMD_IF_REV) {
1585a2f4f59cSHans Petter Selasky mlx5_core_err(dev,
1586a2f4f59cSHans Petter Selasky "driver does not support command interface version. driver %d, firmware %d\n",
1587a2f4f59cSHans Petter Selasky CMD_IF_REV, cmd->cmdif_rev);
1588dc7e38acSHans Petter Selasky err = -ENOTSUPP;
1589dc7e38acSHans Petter Selasky goto err_free_page;
1590dc7e38acSHans Petter Selasky }
1591dc7e38acSHans Petter Selasky
1592dc7e38acSHans Petter Selasky spin_lock_init(&cmd->alloc_lock);
1593dc7e38acSHans Petter Selasky spin_lock_init(&cmd->token_lock);
1594dc7e38acSHans Petter Selasky for (i = 0; i < ARRAY_SIZE(cmd->stats); i++)
1595dc7e38acSHans Petter Selasky spin_lock_init(&cmd->stats[i].lock);
1596dc7e38acSHans Petter Selasky
1597dc7e38acSHans Petter Selasky sema_init(&cmd->sem, cmd->max_reg_cmds);
1598dc7e38acSHans Petter Selasky sema_init(&cmd->pages_sem, 1);
1599dc7e38acSHans Petter Selasky
1600dc7e38acSHans Petter Selasky cmd_h = (u32)((u64)(cmd->dma) >> 32);
1601dc7e38acSHans Petter Selasky cmd_l = (u32)(cmd->dma);
1602dc7e38acSHans Petter Selasky if (cmd_l & 0xfff) {
1603a2f4f59cSHans Petter Selasky mlx5_core_err(dev, "invalid command queue address\n");
1604dc7e38acSHans Petter Selasky err = -ENOMEM;
1605dc7e38acSHans Petter Selasky goto err_free_page;
1606dc7e38acSHans Petter Selasky }
1607dc7e38acSHans Petter Selasky
1608dc7e38acSHans Petter Selasky iowrite32be(cmd_h, &dev->iseg->cmdq_addr_h);
1609dc7e38acSHans Petter Selasky iowrite32be(cmd_l, &dev->iseg->cmdq_addr_l_sz);
1610dc7e38acSHans Petter Selasky
1611dc7e38acSHans Petter Selasky /* Make sure firmware sees the complete address before we proceed */
1612dc7e38acSHans Petter Selasky wmb();
1613dc7e38acSHans Petter Selasky
1614dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "descriptor at dma 0x%llx\n", (unsigned long long)(cmd->dma));
1615dc7e38acSHans Petter Selasky
1616721a1a6aSSlava Shwartsman cmd->mode = MLX5_CMD_MODE_POLLING;
1617dc7e38acSHans Petter Selasky
1618dc7e38acSHans Petter Selasky err = create_msg_cache(dev);
1619dc7e38acSHans Petter Selasky if (err) {
1620a2f4f59cSHans Petter Selasky mlx5_core_err(dev, "failed to create command cache\n");
1621dc7e38acSHans Petter Selasky goto err_free_page;
1622dc7e38acSHans Petter Selasky }
1623dc7e38acSHans Petter Selasky return 0;
1624dc7e38acSHans Petter Selasky
1625dc7e38acSHans Petter Selasky err_free_page:
1626dc7e38acSHans Petter Selasky free_cmd_page(dev, cmd);
1627dc7e38acSHans Petter Selasky
1628dc7e38acSHans Petter Selasky err_free_pool:
1629dc7e38acSHans Petter Selasky return err;
1630dc7e38acSHans Petter Selasky }
1631dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_init);
1632dc7e38acSHans Petter Selasky
mlx5_cmd_cleanup(struct mlx5_core_dev * dev)1633dc7e38acSHans Petter Selasky void mlx5_cmd_cleanup(struct mlx5_core_dev *dev)
1634dc7e38acSHans Petter Selasky {
1635dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd;
1636dc7e38acSHans Petter Selasky
1637dc7e38acSHans Petter Selasky clean_debug_files(dev);
16388d1eeedbSHans Petter Selasky flush_workqueue(dev->priv.health.wq_cmd);
1639dc7e38acSHans Petter Selasky destroy_msg_cache(dev);
1640dc7e38acSHans Petter Selasky free_cmd_page(dev, cmd);
1641dc7e38acSHans Petter Selasky }
1642dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_cleanup);
1643118063fbSHans Petter Selasky
mlx5_cmd_query_cong_counter(struct mlx5_core_dev * dev,bool reset,void * out,int out_size)1644118063fbSHans Petter Selasky int mlx5_cmd_query_cong_counter(struct mlx5_core_dev *dev,
1645118063fbSHans Petter Selasky bool reset, void *out, int out_size)
1646118063fbSHans Petter Selasky {
1647118063fbSHans Petter Selasky u32 in[MLX5_ST_SZ_DW(query_cong_statistics_in)] = { };
1648118063fbSHans Petter Selasky
1649118063fbSHans Petter Selasky MLX5_SET(query_cong_statistics_in, in, opcode,
1650118063fbSHans Petter Selasky MLX5_CMD_OP_QUERY_CONG_STATISTICS);
1651118063fbSHans Petter Selasky MLX5_SET(query_cong_statistics_in, in, clear, reset);
1652118063fbSHans Petter Selasky return mlx5_cmd_exec(dev, in, sizeof(in), out, out_size);
1653118063fbSHans Petter Selasky }
1654118063fbSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_query_cong_counter);
1655118063fbSHans Petter Selasky
mlx5_cmd_query_cong_params(struct mlx5_core_dev * dev,int cong_point,void * out,int out_size)1656118063fbSHans Petter Selasky int mlx5_cmd_query_cong_params(struct mlx5_core_dev *dev, int cong_point,
1657118063fbSHans Petter Selasky void *out, int out_size)
1658118063fbSHans Petter Selasky {
1659118063fbSHans Petter Selasky u32 in[MLX5_ST_SZ_DW(query_cong_params_in)] = { };
1660118063fbSHans Petter Selasky
1661118063fbSHans Petter Selasky MLX5_SET(query_cong_params_in, in, opcode,
1662118063fbSHans Petter Selasky MLX5_CMD_OP_QUERY_CONG_PARAMS);
1663118063fbSHans Petter Selasky MLX5_SET(query_cong_params_in, in, cong_protocol, cong_point);
1664118063fbSHans Petter Selasky
1665118063fbSHans Petter Selasky return mlx5_cmd_exec(dev, in, sizeof(in), out, out_size);
1666118063fbSHans Petter Selasky }
1667118063fbSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_query_cong_params);
1668118063fbSHans Petter Selasky
mlx5_cmd_modify_cong_params(struct mlx5_core_dev * dev,void * in,int in_size)1669118063fbSHans Petter Selasky int mlx5_cmd_modify_cong_params(struct mlx5_core_dev *dev,
1670118063fbSHans Petter Selasky void *in, int in_size)
1671118063fbSHans Petter Selasky {
1672118063fbSHans Petter Selasky u32 out[MLX5_ST_SZ_DW(modify_cong_params_out)] = { };
1673118063fbSHans Petter Selasky
1674118063fbSHans Petter Selasky return mlx5_cmd_exec(dev, in, in_size, out, sizeof(out));
1675118063fbSHans Petter Selasky }
1676118063fbSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_modify_cong_params);
16778abf5ac0SHans Petter Selasky
mlx5_cmd_query_cong_status(struct mlx5_core_dev * dev,int cong_point,int prio,void * out,int out_size)16788abf5ac0SHans Petter Selasky int mlx5_cmd_query_cong_status(struct mlx5_core_dev *dev, int cong_point,
16798abf5ac0SHans Petter Selasky int prio, void *out, int out_size)
16808abf5ac0SHans Petter Selasky {
16818abf5ac0SHans Petter Selasky u32 in[MLX5_ST_SZ_DW(query_cong_status_in)] = { };
16828abf5ac0SHans Petter Selasky
16838abf5ac0SHans Petter Selasky MLX5_SET(query_cong_status_in, in, opcode,
16848abf5ac0SHans Petter Selasky MLX5_CMD_OP_QUERY_CONG_STATUS);
16858abf5ac0SHans Petter Selasky MLX5_SET(query_cong_status_in, in, priority, prio);
16868abf5ac0SHans Petter Selasky MLX5_SET(query_cong_status_in, in, cong_protocol, cong_point);
16878abf5ac0SHans Petter Selasky
16888abf5ac0SHans Petter Selasky return mlx5_cmd_exec(dev, in, sizeof(in), out, out_size);
16898abf5ac0SHans Petter Selasky }
16908abf5ac0SHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_query_cong_status);
16918abf5ac0SHans Petter Selasky
mlx5_cmd_modify_cong_status(struct mlx5_core_dev * dev,void * in,int in_size)16928abf5ac0SHans Petter Selasky int mlx5_cmd_modify_cong_status(struct mlx5_core_dev *dev,
16938abf5ac0SHans Petter Selasky void *in, int in_size)
16948abf5ac0SHans Petter Selasky {
16958abf5ac0SHans Petter Selasky u32 out[MLX5_ST_SZ_DW(modify_cong_status_out)] = { };
16968abf5ac0SHans Petter Selasky
16978abf5ac0SHans Petter Selasky return mlx5_cmd_exec(dev, in, in_size, out, sizeof(out));
16988abf5ac0SHans Petter Selasky }
16998abf5ac0SHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_modify_cong_status);
1700