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 * $FreeBSD$ 26dc7e38acSHans Petter Selasky */ 27dc7e38acSHans Petter Selasky 28ee9d634bSKonstantin Belousov #include "opt_rss.h" 29ee9d634bSKonstantin Belousov #include "opt_ratelimit.h" 30ee9d634bSKonstantin Belousov 31dc7e38acSHans Petter Selasky #include <linux/module.h> 32dc7e38acSHans Petter Selasky #include <linux/errno.h> 33dc7e38acSHans Petter Selasky #include <linux/pci.h> 34dc7e38acSHans Petter Selasky #include <linux/dma-mapping.h> 35dc7e38acSHans Petter Selasky #include <linux/slab.h> 36dc7e38acSHans Petter Selasky #include <linux/delay.h> 37dc7e38acSHans Petter Selasky #include <linux/random.h> 38dc7e38acSHans Petter Selasky #include <linux/io-mapping.h> 39dc7e38acSHans Petter Selasky #include <linux/hardirq.h> 40dc7e38acSHans Petter Selasky #include <linux/ktime.h> 41dc7e38acSHans Petter Selasky #include <dev/mlx5/driver.h> 42118063fbSHans Petter Selasky #include <dev/mlx5/cmd.h> 43dc7e38acSHans Petter Selasky 44dc7e38acSHans Petter Selasky #include "mlx5_core.h" 45dc7e38acSHans Petter Selasky 468e7e0ce1SHans Petter Selasky static int mlx5_copy_from_msg(void *to, struct mlx5_cmd_msg *from, int size); 478e7e0ce1SHans Petter Selasky static void mlx5_free_cmd_msg(struct mlx5_core_dev *dev, 488e7e0ce1SHans Petter Selasky struct mlx5_cmd_msg *msg); 498e7e0ce1SHans Petter Selasky static void free_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg); 508e7e0ce1SHans Petter Selasky 51dc7e38acSHans Petter Selasky enum { 52dc7e38acSHans Petter Selasky CMD_IF_REV = 5, 53dc7e38acSHans Petter Selasky }; 54dc7e38acSHans Petter Selasky 55dc7e38acSHans Petter Selasky enum { 56dc7e38acSHans Petter Selasky NUM_LONG_LISTS = 2, 57dc7e38acSHans Petter Selasky NUM_MED_LISTS = 64, 58dc7e38acSHans Petter Selasky LONG_LIST_SIZE = (2ULL * 1024 * 1024 * 1024 / PAGE_SIZE) * 8 + 16 + 59dc7e38acSHans Petter Selasky MLX5_CMD_DATA_BLOCK_SIZE, 60dc7e38acSHans Petter Selasky MED_LIST_SIZE = 16 + MLX5_CMD_DATA_BLOCK_SIZE, 61dc7e38acSHans Petter Selasky }; 62dc7e38acSHans Petter Selasky 63dc7e38acSHans Petter Selasky enum { 64dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_OK = 0x0, 65dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_SIGNAT_ERR = 0x1, 66dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_TOK_ERR = 0x2, 67dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_BAD_BLK_NUM_ERR = 0x3, 68dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_OUT_PTR_ALIGN_ERR = 0x4, 69dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_IN_PTR_ALIGN_ERR = 0x5, 70dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_FW_ERR = 0x6, 71dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_IN_LENGTH_ERR = 0x7, 72dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_OUT_LENGTH_ERR = 0x8, 73dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_RES_FLD_NOT_CLR_ERR = 0x9, 74dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_CMD_DESCR_ERR = 0x10, 75dc7e38acSHans Petter Selasky }; 76dc7e38acSHans Petter Selasky 77788333d9SHans Petter Selasky struct mlx5_ifc_mbox_out_bits { 78788333d9SHans Petter Selasky u8 status[0x8]; 79788333d9SHans Petter Selasky u8 reserved_at_8[0x18]; 80788333d9SHans Petter Selasky 81788333d9SHans Petter Selasky u8 syndrome[0x20]; 82788333d9SHans Petter Selasky 83788333d9SHans Petter Selasky u8 reserved_at_40[0x40]; 84788333d9SHans Petter Selasky }; 85788333d9SHans Petter Selasky 86788333d9SHans Petter Selasky struct mlx5_ifc_mbox_in_bits { 87788333d9SHans Petter Selasky u8 opcode[0x10]; 88788333d9SHans Petter Selasky u8 reserved_at_10[0x10]; 89788333d9SHans Petter Selasky 90788333d9SHans Petter Selasky u8 reserved_at_20[0x10]; 91788333d9SHans Petter Selasky u8 op_mod[0x10]; 92788333d9SHans Petter Selasky 93788333d9SHans Petter Selasky u8 reserved_at_40[0x40]; 94788333d9SHans Petter Selasky }; 95788333d9SHans Petter Selasky 96788333d9SHans Petter Selasky 97dc7e38acSHans Petter Selasky static struct mlx5_cmd_work_ent *alloc_cmd(struct mlx5_cmd *cmd, 98dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *in, 991c807f67SHans Petter Selasky int uin_size, 100dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *out, 101dc7e38acSHans Petter Selasky void *uout, int uout_size, 102dc7e38acSHans Petter Selasky mlx5_cmd_cbk_t cbk, 103dc7e38acSHans Petter Selasky void *context, int page_queue) 104dc7e38acSHans Petter Selasky { 105dc7e38acSHans Petter Selasky gfp_t alloc_flags = cbk ? GFP_ATOMIC : GFP_KERNEL; 106dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent; 107dc7e38acSHans Petter Selasky 108dc7e38acSHans Petter Selasky ent = kzalloc(sizeof(*ent), alloc_flags); 109dc7e38acSHans Petter Selasky if (!ent) 110dc7e38acSHans Petter Selasky return ERR_PTR(-ENOMEM); 111dc7e38acSHans Petter Selasky 112dc7e38acSHans Petter Selasky ent->in = in; 1131c807f67SHans Petter Selasky ent->uin_size = uin_size; 114dc7e38acSHans Petter Selasky ent->out = out; 115dc7e38acSHans Petter Selasky ent->uout = uout; 116dc7e38acSHans Petter Selasky ent->uout_size = uout_size; 117dc7e38acSHans Petter Selasky ent->callback = cbk; 118dc7e38acSHans Petter Selasky ent->context = context; 119dc7e38acSHans Petter Selasky ent->cmd = cmd; 120dc7e38acSHans Petter Selasky ent->page_queue = page_queue; 121dc7e38acSHans Petter Selasky 122dc7e38acSHans Petter Selasky return ent; 123dc7e38acSHans Petter Selasky } 124dc7e38acSHans Petter Selasky 125dc7e38acSHans Petter Selasky static u8 alloc_token(struct mlx5_cmd *cmd) 126dc7e38acSHans Petter Selasky { 127dc7e38acSHans Petter Selasky u8 token; 128dc7e38acSHans Petter Selasky 129dc7e38acSHans Petter Selasky spin_lock(&cmd->token_lock); 130dc7e38acSHans Petter Selasky cmd->token++; 131dc7e38acSHans Petter Selasky if (cmd->token == 0) 132dc7e38acSHans Petter Selasky cmd->token++; 133dc7e38acSHans Petter Selasky token = cmd->token; 134dc7e38acSHans Petter Selasky spin_unlock(&cmd->token_lock); 135dc7e38acSHans Petter Selasky 136dc7e38acSHans Petter Selasky return token; 137dc7e38acSHans Petter Selasky } 138dc7e38acSHans Petter Selasky 1398e7e0ce1SHans Petter Selasky static int alloc_ent(struct mlx5_cmd_work_ent *ent) 140dc7e38acSHans Petter Selasky { 141dc7e38acSHans Petter Selasky unsigned long flags; 1428e7e0ce1SHans Petter Selasky struct mlx5_cmd *cmd = ent->cmd; 14330dfc051SHans Petter Selasky struct mlx5_core_dev *dev = 14430dfc051SHans Petter Selasky container_of(cmd, struct mlx5_core_dev, cmd); 1458e7e0ce1SHans Petter Selasky int ret = cmd->max_reg_cmds; 146dc7e38acSHans Petter Selasky 147dc7e38acSHans Petter Selasky spin_lock_irqsave(&cmd->alloc_lock, flags); 1488e7e0ce1SHans Petter Selasky if (!ent->page_queue) { 149dc7e38acSHans Petter Selasky ret = find_first_bit(&cmd->bitmask, cmd->max_reg_cmds); 1508e7e0ce1SHans Petter Selasky if (ret >= cmd->max_reg_cmds) 1518e7e0ce1SHans Petter Selasky ret = -1; 1528e7e0ce1SHans Petter Selasky } 1538e7e0ce1SHans Petter Selasky 15430dfc051SHans Petter Selasky if (dev->state != MLX5_DEVICE_STATE_UP) 15530dfc051SHans Petter Selasky ret = -1; 15630dfc051SHans Petter Selasky 1578e7e0ce1SHans Petter Selasky if (ret != -1) { 15830dfc051SHans Petter Selasky ent->busy = 1; 1598e7e0ce1SHans Petter Selasky ent->idx = ret; 1608e7e0ce1SHans Petter Selasky clear_bit(ent->idx, &cmd->bitmask); 161721a1a6aSSlava Shwartsman cmd->ent_mode[ent->idx] = 162721a1a6aSSlava Shwartsman ent->polling ? MLX5_CMD_MODE_POLLING : MLX5_CMD_MODE_EVENTS; 1638e7e0ce1SHans Petter Selasky cmd->ent_arr[ent->idx] = ent; 1648e7e0ce1SHans Petter Selasky } 165dc7e38acSHans Petter Selasky spin_unlock_irqrestore(&cmd->alloc_lock, flags); 166dc7e38acSHans Petter Selasky 1678e7e0ce1SHans Petter Selasky return ret; 168dc7e38acSHans Petter Selasky } 169dc7e38acSHans Petter Selasky 170dc7e38acSHans Petter Selasky static void free_ent(struct mlx5_cmd *cmd, int idx) 171dc7e38acSHans Petter Selasky { 172dc7e38acSHans Petter Selasky unsigned long flags; 173dc7e38acSHans Petter Selasky 174dc7e38acSHans Petter Selasky spin_lock_irqsave(&cmd->alloc_lock, flags); 175721a1a6aSSlava Shwartsman cmd->ent_arr[idx] = NULL; /* safety clear */ 176721a1a6aSSlava Shwartsman cmd->ent_mode[idx] = MLX5_CMD_MODE_POLLING; /* reset mode */ 177dc7e38acSHans Petter Selasky set_bit(idx, &cmd->bitmask); 178dc7e38acSHans Petter Selasky spin_unlock_irqrestore(&cmd->alloc_lock, flags); 179dc7e38acSHans Petter Selasky } 180dc7e38acSHans Petter Selasky 181dc7e38acSHans Petter Selasky static struct mlx5_cmd_layout *get_inst(struct mlx5_cmd *cmd, int idx) 182dc7e38acSHans Petter Selasky { 183dc7e38acSHans Petter Selasky return cmd->cmd_buf + (idx << cmd->log_stride); 184dc7e38acSHans Petter Selasky } 185dc7e38acSHans Petter Selasky 186dc7e38acSHans Petter Selasky static u8 xor8_buf(void *buf, int len) 187dc7e38acSHans Petter Selasky { 188dc7e38acSHans Petter Selasky u8 *ptr = buf; 189dc7e38acSHans Petter Selasky u8 sum = 0; 190dc7e38acSHans Petter Selasky int i; 191dc7e38acSHans Petter Selasky 192dc7e38acSHans Petter Selasky for (i = 0; i < len; i++) 193dc7e38acSHans Petter Selasky sum ^= ptr[i]; 194dc7e38acSHans Petter Selasky 195dc7e38acSHans Petter Selasky return sum; 196dc7e38acSHans Petter Selasky } 197dc7e38acSHans Petter Selasky 198dc7e38acSHans Petter Selasky static int verify_block_sig(struct mlx5_cmd_prot_block *block) 199dc7e38acSHans Petter Selasky { 200dc7e38acSHans Petter Selasky if (xor8_buf(block->rsvd0, sizeof(*block) - sizeof(block->data) - 1) != 0xff) 201dc7e38acSHans Petter Selasky return -EINVAL; 202dc7e38acSHans Petter Selasky 203dc7e38acSHans Petter Selasky if (xor8_buf(block, sizeof(*block)) != 0xff) 204dc7e38acSHans Petter Selasky return -EINVAL; 205dc7e38acSHans Petter Selasky 206dc7e38acSHans Petter Selasky return 0; 207dc7e38acSHans Petter Selasky } 208dc7e38acSHans Petter Selasky 209dc7e38acSHans Petter Selasky static void calc_block_sig(struct mlx5_cmd_prot_block *block, u8 token, 210dc7e38acSHans Petter Selasky int csum) 211dc7e38acSHans Petter Selasky { 212dc7e38acSHans Petter Selasky block->token = token; 213dc7e38acSHans Petter Selasky if (csum) { 214dc7e38acSHans Petter Selasky block->ctrl_sig = ~xor8_buf(block->rsvd0, sizeof(*block) - 215dc7e38acSHans Petter Selasky sizeof(block->data) - 2); 216dc7e38acSHans Petter Selasky block->sig = ~xor8_buf(block, sizeof(*block) - 1); 217dc7e38acSHans Petter Selasky } 218dc7e38acSHans Petter Selasky } 219dc7e38acSHans Petter Selasky 2201c807f67SHans Petter Selasky static void 2211c807f67SHans Petter Selasky calc_chain_sig(struct mlx5_cmd_msg *msg, u8 token, int csum) 222dc7e38acSHans Petter Selasky { 2231c807f67SHans Petter Selasky size_t i; 224dc7e38acSHans Petter Selasky 2251c807f67SHans Petter Selasky for (i = 0; i != (msg->numpages * MLX5_NUM_CMDS_IN_ADAPTER_PAGE); i++) { 2261c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block; 2271c807f67SHans Petter Selasky 2281c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE); 2291c807f67SHans Petter Selasky 2301c807f67SHans Petter Selasky /* compute signature */ 2311c807f67SHans Petter Selasky calc_block_sig(block, token, csum); 2321c807f67SHans Petter Selasky 2331c807f67SHans Petter Selasky /* check for last block */ 2341c807f67SHans Petter Selasky if (block->next == 0) 2351c807f67SHans Petter Selasky break; 236dc7e38acSHans Petter Selasky } 2371c807f67SHans Petter Selasky 2381c807f67SHans Petter Selasky /* make sure data gets written to RAM */ 2391c807f67SHans Petter Selasky mlx5_fwp_flush(msg); 240dc7e38acSHans Petter Selasky } 241dc7e38acSHans Petter Selasky 242dc7e38acSHans Petter Selasky static void set_signature(struct mlx5_cmd_work_ent *ent, int csum) 243dc7e38acSHans Petter Selasky { 244dc7e38acSHans Petter Selasky ent->lay->sig = ~xor8_buf(ent->lay, sizeof(*ent->lay)); 245dc7e38acSHans Petter Selasky calc_chain_sig(ent->in, ent->token, csum); 246dc7e38acSHans Petter Selasky calc_chain_sig(ent->out, ent->token, csum); 247dc7e38acSHans Petter Selasky } 248dc7e38acSHans Petter Selasky 249dc7e38acSHans Petter Selasky static void poll_timeout(struct mlx5_cmd_work_ent *ent) 250dc7e38acSHans Petter Selasky { 25130dfc051SHans Petter Selasky struct mlx5_core_dev *dev = container_of(ent->cmd, 25230dfc051SHans Petter Selasky struct mlx5_core_dev, cmd); 25330dfc051SHans Petter Selasky int poll_end = jiffies + 25430dfc051SHans Petter Selasky msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC + 1000); 255dc7e38acSHans Petter Selasky u8 own; 256dc7e38acSHans Petter Selasky 257dc7e38acSHans Petter Selasky do { 258dc7e38acSHans Petter Selasky own = ent->lay->status_own; 25930dfc051SHans Petter Selasky if (!(own & CMD_OWNER_HW) || 26030dfc051SHans Petter Selasky dev->state != MLX5_DEVICE_STATE_UP) { 261dc7e38acSHans Petter Selasky ent->ret = 0; 262dc7e38acSHans Petter Selasky return; 263dc7e38acSHans Petter Selasky } 264dc7e38acSHans Petter Selasky usleep_range(5000, 10000); 265dc7e38acSHans Petter Selasky } while (time_before(jiffies, poll_end)); 266dc7e38acSHans Petter Selasky 267dc7e38acSHans Petter Selasky ent->ret = -ETIMEDOUT; 268dc7e38acSHans Petter Selasky } 269dc7e38acSHans Petter Selasky 270dc7e38acSHans Petter Selasky static void free_cmd(struct mlx5_cmd_work_ent *ent) 271dc7e38acSHans Petter Selasky { 27211546d06SHans Petter Selasky cancel_delayed_work_sync(&ent->cb_timeout_work); 273dc7e38acSHans Petter Selasky kfree(ent); 274dc7e38acSHans Petter Selasky } 275dc7e38acSHans Petter Selasky 2761c807f67SHans Petter Selasky static int 2771c807f67SHans Petter Selasky verify_signature(struct mlx5_cmd_work_ent *ent) 278dc7e38acSHans Petter Selasky { 2791c807f67SHans Petter Selasky struct mlx5_cmd_msg *msg = ent->out; 2801c807f67SHans Petter Selasky size_t i; 281dc7e38acSHans Petter Selasky int err; 282dc7e38acSHans Petter Selasky u8 sig; 283dc7e38acSHans Petter Selasky 284dc7e38acSHans Petter Selasky sig = xor8_buf(ent->lay, sizeof(*ent->lay)); 285dc7e38acSHans Petter Selasky if (sig != 0xff) 286dc7e38acSHans Petter Selasky return -EINVAL; 287dc7e38acSHans Petter Selasky 2881c807f67SHans Petter Selasky for (i = 0; i != (msg->numpages * MLX5_NUM_CMDS_IN_ADAPTER_PAGE); i++) { 2891c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block; 290dc7e38acSHans Petter Selasky 2911c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE); 2921c807f67SHans Petter Selasky 2931c807f67SHans Petter Selasky /* compute signature */ 2941c807f67SHans Petter Selasky err = verify_block_sig(block); 2951c807f67SHans Petter Selasky if (err != 0) 2961c807f67SHans Petter Selasky return (err); 2971c807f67SHans Petter Selasky 2981c807f67SHans Petter Selasky /* check for last block */ 2991c807f67SHans Petter Selasky if (block->next == 0) 3001c807f67SHans Petter Selasky break; 301dc7e38acSHans Petter Selasky } 3021c807f67SHans Petter Selasky return (0); 303dc7e38acSHans Petter Selasky } 304dc7e38acSHans Petter Selasky 305dc7e38acSHans Petter Selasky static void dump_buf(void *buf, int size, int data_only, int offset) 306dc7e38acSHans Petter Selasky { 307dc7e38acSHans Petter Selasky __be32 *p = buf; 308dc7e38acSHans Petter Selasky int i; 309dc7e38acSHans Petter Selasky 310dc7e38acSHans Petter Selasky for (i = 0; i < size; i += 16) { 311dc7e38acSHans Petter Selasky pr_debug("%03x: %08x %08x %08x %08x\n", offset, be32_to_cpu(p[0]), 312dc7e38acSHans Petter Selasky be32_to_cpu(p[1]), be32_to_cpu(p[2]), 313dc7e38acSHans Petter Selasky be32_to_cpu(p[3])); 314dc7e38acSHans Petter Selasky p += 4; 315dc7e38acSHans Petter Selasky offset += 16; 316dc7e38acSHans Petter Selasky } 317dc7e38acSHans Petter Selasky if (!data_only) 318dc7e38acSHans Petter Selasky pr_debug("\n"); 319dc7e38acSHans Petter Selasky } 320dc7e38acSHans Petter Selasky 321a2485fe5SHans Petter Selasky enum { 322a2485fe5SHans Petter Selasky MLX5_DRIVER_STATUS_ABORTED = 0xfe, 323a2485fe5SHans Petter Selasky MLX5_DRIVER_SYND = 0xbadd00de, 324a2485fe5SHans Petter Selasky }; 325a2485fe5SHans Petter Selasky 326a2485fe5SHans Petter Selasky static int mlx5_internal_err_ret_value(struct mlx5_core_dev *dev, u16 op, 327a2485fe5SHans Petter Selasky u32 *synd, u8 *status) 328a2485fe5SHans Petter Selasky { 329a2485fe5SHans Petter Selasky *synd = 0; 330a2485fe5SHans Petter Selasky *status = 0; 331a2485fe5SHans Petter Selasky 332a2485fe5SHans Petter Selasky switch (op) { 333a2485fe5SHans Petter Selasky case MLX5_CMD_OP_TEARDOWN_HCA: 334a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DISABLE_HCA: 335a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MANAGE_PAGES: 336a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_MKEY: 337a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_EQ: 338a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_CQ: 339a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_QP: 340a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_PSV: 341a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_SRQ: 342a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_XRC_SRQ: 343a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_DCT: 344a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_Q_COUNTER: 345a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_PD: 346a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_UAR: 347a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DETACH_FROM_MCG: 348a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_XRCD: 349a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_TRANSPORT_DOMAIN: 350a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DELETE_VXLAN_UDP_DPORT: 351a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DELETE_L2_TABLE_ENTRY: 352a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_TIR: 353a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_SQ: 354a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_RQ: 355a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_RMP: 356a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_TIS: 357a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_RQT: 358a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_FLOW_TABLE: 359a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DESTROY_FLOW_GROUP: 360a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DELETE_FLOW_TABLE_ENTRY: 361a2485fe5SHans Petter Selasky case MLX5_CMD_OP_2ERR_QP: 362a2485fe5SHans Petter Selasky case MLX5_CMD_OP_2RST_QP: 363a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT: 364a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_FLOW_TABLE: 365a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY: 366a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_FLOW_TABLE_ROOT: 36704f1690bSHans Petter Selasky case MLX5_CMD_OP_DESTROY_GENERAL_OBJ: 368a2485fe5SHans Petter Selasky return MLX5_CMD_STAT_OK; 369a2485fe5SHans Petter Selasky 370a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_CAP: 371a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_ADAPTER: 372a2485fe5SHans Petter Selasky case MLX5_CMD_OP_INIT_HCA: 373a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ENABLE_HCA: 374a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_PAGES: 375a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_HCA_CAP: 376a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_ISSI: 377a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_ISSI: 378a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_MKEY: 379a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_MKEY: 380a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_SPECIAL_CONTEXTS: 381a2485fe5SHans Petter Selasky case MLX5_CMD_OP_PAGE_FAULT_RESUME: 382a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_EQ: 383a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_EQ: 384a2485fe5SHans Petter Selasky case MLX5_CMD_OP_GEN_EQE: 385a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_CQ: 386a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_CQ: 387a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_CQ: 388a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_QP: 389a2485fe5SHans Petter Selasky case MLX5_CMD_OP_RST2INIT_QP: 390a2485fe5SHans Petter Selasky case MLX5_CMD_OP_INIT2RTR_QP: 391a2485fe5SHans Petter Selasky case MLX5_CMD_OP_RTR2RTS_QP: 392a2485fe5SHans Petter Selasky case MLX5_CMD_OP_RTS2RTS_QP: 393a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SQERR2RTS_QP: 394a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_QP: 395a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SQD_RTS_QP: 396a2485fe5SHans Petter Selasky case MLX5_CMD_OP_INIT2INIT_QP: 397a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_PSV: 398a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_SRQ: 399a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_SRQ: 400a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ARM_RQ: 401a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_XRC_SRQ: 402a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_XRC_SRQ: 403a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ARM_XRC_SRQ: 404a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_DCT: 405a2485fe5SHans Petter Selasky case MLX5_CMD_OP_DRAIN_DCT: 406a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_DCT: 407a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ARM_DCT_FOR_KEY_VIOLATION: 408a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_VPORT_STATE: 409a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_VPORT_STATE: 410a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_ESW_VPORT_CONTEXT: 411a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT: 412a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_NIC_VPORT_CONTEXT: 413a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_ROCE_ADDRESS: 414a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_ROCE_ADDRESS: 415a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_VPORT_CONTEXT: 416a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_HCA_VPORT_CONTEXT: 417a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_VPORT_GID: 418a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_VPORT_PKEY: 419c29b90baSHans Petter Selasky case MLX5_CMD_OP_QUERY_VNIC_ENV: 420a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_VPORT_COUNTER: 421a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_Q_COUNTER: 422a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_Q_COUNTER: 423a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_PD: 424a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_UAR: 425a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CONFIG_INT_MODERATION: 426a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ACCESS_REG: 427a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ATTACH_TO_MCG: 428a2485fe5SHans Petter Selasky case MLX5_CMD_OP_GET_DROPPED_PACKET_LOG: 429a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MAD_IFC: 430a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_MAD_DEMUX: 431a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_MAD_DEMUX: 432a2485fe5SHans Petter Selasky case MLX5_CMD_OP_NOP: 433a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_XRCD: 434a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ALLOC_TRANSPORT_DOMAIN: 435a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_CONG_STATUS: 436a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_CONG_STATUS: 437a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_CONG_PARAMS: 438a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_CONG_PARAMS: 439a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_CONG_STATISTICS: 440a2485fe5SHans Petter Selasky case MLX5_CMD_OP_ADD_VXLAN_UDP_DPORT: 441a2485fe5SHans Petter Selasky case MLX5_CMD_OP_SET_L2_TABLE_ENTRY: 442a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_L2_TABLE_ENTRY: 443a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_TIR: 444a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_TIR: 445a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_TIR: 446a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_SQ: 447a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_SQ: 448a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_SQ: 449a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_RQ: 450a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_RQ: 451a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_RQ: 452a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_RMP: 453a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_RMP: 454a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_RMP: 455a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_TIS: 456a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_TIS: 457a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_TIS: 458a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_RQT: 459a2485fe5SHans Petter Selasky case MLX5_CMD_OP_MODIFY_RQT: 460a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_RQT: 461a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_FLOW_TABLE: 462a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_TABLE: 463a2485fe5SHans Petter Selasky case MLX5_CMD_OP_CREATE_FLOW_GROUP: 464a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_GROUP: 465a2485fe5SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_TABLE_ENTRY: 46604f1690bSHans Petter Selasky case MLX5_CMD_OP_CREATE_GENERAL_OBJ: 46704f1690bSHans Petter Selasky case MLX5_CMD_OP_MODIFY_GENERAL_OBJ: 46804f1690bSHans Petter Selasky case MLX5_CMD_OP_QUERY_GENERAL_OBJ: 469a2485fe5SHans Petter Selasky *status = MLX5_DRIVER_STATUS_ABORTED; 470a2485fe5SHans Petter Selasky *synd = MLX5_DRIVER_SYND; 471a2485fe5SHans Petter Selasky return -EIO; 472a2485fe5SHans Petter Selasky default: 473a2485fe5SHans Petter Selasky mlx5_core_err(dev, "Unknown FW command (%d)\n", op); 474a2485fe5SHans Petter Selasky return -EINVAL; 475a2485fe5SHans Petter Selasky } 476a2485fe5SHans Petter Selasky } 477a2485fe5SHans Petter Selasky 478dc7e38acSHans Petter Selasky const char *mlx5_command_str(int command) 479dc7e38acSHans Petter Selasky { 480ee1b5c58SHans Petter Selasky #define MLX5_COMMAND_STR_CASE(__cmd) case MLX5_CMD_OP_ ## __cmd: return #__cmd 481ee1b5c58SHans Petter Selasky 482dc7e38acSHans Petter Selasky switch (command) { 483ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_CAP); 484ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_HCA_CAP); 485ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ADAPTER); 486ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(INIT_HCA); 487ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(TEARDOWN_HCA); 488ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ENABLE_HCA); 489ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DISABLE_HCA); 490ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_PAGES); 491ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MANAGE_PAGES); 492ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ISSI); 493ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_ISSI); 494ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_MKEY); 495ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_MKEY); 496ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_MKEY); 497ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_SPECIAL_CONTEXTS); 498ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(PAGE_FAULT_RESUME); 499ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_EQ); 500ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_EQ); 501ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_EQ); 502ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(GEN_EQE); 503ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_CQ); 504ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_CQ); 505ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CQ); 506ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_CQ); 507ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_QP); 508ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_QP); 509ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(RST2INIT_QP); 510ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(INIT2RTR_QP); 511ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(RTR2RTS_QP); 512ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(RTS2RTS_QP); 513ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SQERR2RTS_QP); 514ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(2ERR_QP); 515ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(2RST_QP); 516ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_QP); 517ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SQD_RTS_QP); 518ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MAD_IFC); 519ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(INIT2INIT_QP); 520ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_PSV); 521ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_PSV); 522ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_SRQ); 523ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_SRQ); 524ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_SRQ); 525ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ARM_RQ); 526ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_XRC_SRQ); 527ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_XRC_SRQ); 528ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_XRC_SRQ); 529ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ARM_XRC_SRQ); 530ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_DCT); 531ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_DC_CNAK_TRACE); 532ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_DCT); 533ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DRAIN_DCT); 534ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_DCT); 535ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ARM_DCT_FOR_KEY_VIOLATION); 536ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_VPORT_STATE); 537ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_VPORT_STATE); 538ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ESW_VPORT_CONTEXT); 539ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_ESW_VPORT_CONTEXT); 540ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_NIC_VPORT_CONTEXT); 541ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_NIC_VPORT_CONTEXT); 542ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ROCE_ADDRESS); 543ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_ROCE_ADDRESS); 544ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_VPORT_CONTEXT); 545ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_HCA_VPORT_CONTEXT); 546ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_VPORT_GID); 547ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_VPORT_PKEY); 548c29b90baSHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_VNIC_ENV); 549ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_VPORT_COUNTER); 550ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_WOL_ROL); 551ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_WOL_ROL); 552ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_Q_COUNTER); 553ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_Q_COUNTER); 554ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_Q_COUNTER); 555ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_PD); 556ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_PD); 557ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_UAR); 558ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_UAR); 559ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CONFIG_INT_MODERATION); 560ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ATTACH_TO_MCG); 561ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DETACH_FROM_MCG); 562ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(GET_DROPPED_PACKET_LOG); 563ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_MAD_DEMUX); 564ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_MAD_DEMUX); 565ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(NOP); 566ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_XRCD); 567ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_XRCD); 568ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_TRANSPORT_DOMAIN); 569ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_TRANSPORT_DOMAIN); 570ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CONG_STATUS); 571ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_CONG_STATUS); 572ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CONG_PARAMS); 573ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_CONG_PARAMS); 574ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CONG_STATISTICS); 575ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ADD_VXLAN_UDP_DPORT); 576ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DELETE_VXLAN_UDP_DPORT); 577ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_L2_TABLE_ENTRY); 578ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_L2_TABLE_ENTRY); 579ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DELETE_L2_TABLE_ENTRY); 580ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_RMP); 581ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_RMP); 582ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_RMP); 583ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_RMP); 584ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_RQT); 585ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_RQT); 586ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_RQT); 587ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_RQT); 588ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ACCESS_REG); 589ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_SQ); 590ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_SQ); 591ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_SQ); 592ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_SQ); 593ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_RQ); 594ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_RQ); 595ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_RQ); 596ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_RQ); 597ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_TIR); 598ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_TIR); 599ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_TIR); 600ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_TIR); 601ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_TIS); 602ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_TIS); 603ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_TIS); 604ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_TIS); 605ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_FLOW_TABLE); 606ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_FLOW_TABLE); 607ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_FLOW_TABLE); 608ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_FLOW_GROUP); 609ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_FLOW_GROUP); 610ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_FLOW_GROUP); 611ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_FLOW_TABLE_ENTRY); 612ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_FLOW_TABLE_ENTRY); 613ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DELETE_FLOW_TABLE_ENTRY); 614ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_DIAGNOSTICS); 615ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_DIAGNOSTICS); 61604f1690bSHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_GENERAL_OBJ); 61704f1690bSHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_GENERAL_OBJ); 61804f1690bSHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_GENERAL_OBJ); 61904f1690bSHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_GENERAL_OBJ); 620dc7e38acSHans Petter Selasky default: return "unknown command opcode"; 621dc7e38acSHans Petter Selasky } 622dc7e38acSHans Petter Selasky } 623dc7e38acSHans Petter Selasky 624788333d9SHans Petter Selasky static const char *cmd_status_str(u8 status) 625788333d9SHans Petter Selasky { 626788333d9SHans Petter Selasky switch (status) { 627788333d9SHans Petter Selasky case MLX5_CMD_STAT_OK: 628788333d9SHans Petter Selasky return "OK"; 629788333d9SHans Petter Selasky case MLX5_CMD_STAT_INT_ERR: 630788333d9SHans Petter Selasky return "internal error"; 631788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_OP_ERR: 632788333d9SHans Petter Selasky return "bad operation"; 633788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_PARAM_ERR: 634788333d9SHans Petter Selasky return "bad parameter"; 635788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_SYS_STATE_ERR: 636788333d9SHans Petter Selasky return "bad system state"; 637788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_ERR: 638788333d9SHans Petter Selasky return "bad resource"; 639788333d9SHans Petter Selasky case MLX5_CMD_STAT_RES_BUSY: 640788333d9SHans Petter Selasky return "resource busy"; 641788333d9SHans Petter Selasky case MLX5_CMD_STAT_LIM_ERR: 642788333d9SHans Petter Selasky return "limits exceeded"; 643788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_STATE_ERR: 644788333d9SHans Petter Selasky return "bad resource state"; 645788333d9SHans Petter Selasky case MLX5_CMD_STAT_IX_ERR: 646788333d9SHans Petter Selasky return "bad index"; 647788333d9SHans Petter Selasky case MLX5_CMD_STAT_NO_RES_ERR: 648788333d9SHans Petter Selasky return "no resources"; 649788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_INP_LEN_ERR: 650788333d9SHans Petter Selasky return "bad input length"; 651788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_OUTP_LEN_ERR: 652788333d9SHans Petter Selasky return "bad output length"; 653788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_QP_STATE_ERR: 654788333d9SHans Petter Selasky return "bad QP state"; 655788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_PKT_ERR: 656788333d9SHans Petter Selasky return "bad packet (discarded)"; 657788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_SIZE_OUTS_CQES_ERR: 658788333d9SHans Petter Selasky return "bad size too many outstanding CQEs"; 659788333d9SHans Petter Selasky default: 660788333d9SHans Petter Selasky return "unknown status"; 661788333d9SHans Petter Selasky } 662788333d9SHans Petter Selasky } 663788333d9SHans Petter Selasky 664788333d9SHans Petter Selasky static int cmd_status_to_err_helper(u8 status) 665788333d9SHans Petter Selasky { 666788333d9SHans Petter Selasky switch (status) { 667788333d9SHans Petter Selasky case MLX5_CMD_STAT_OK: return 0; 668788333d9SHans Petter Selasky case MLX5_CMD_STAT_INT_ERR: return -EIO; 669788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_OP_ERR: return -EINVAL; 670788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_PARAM_ERR: return -EINVAL; 671788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_SYS_STATE_ERR: return -EIO; 672788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_ERR: return -EINVAL; 673788333d9SHans Petter Selasky case MLX5_CMD_STAT_RES_BUSY: return -EBUSY; 674788333d9SHans Petter Selasky case MLX5_CMD_STAT_LIM_ERR: return -ENOMEM; 675788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_STATE_ERR: return -EINVAL; 676788333d9SHans Petter Selasky case MLX5_CMD_STAT_IX_ERR: return -EINVAL; 677788333d9SHans Petter Selasky case MLX5_CMD_STAT_NO_RES_ERR: return -EAGAIN; 678788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_INP_LEN_ERR: return -EIO; 679788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_OUTP_LEN_ERR: return -EIO; 680788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_QP_STATE_ERR: return -EINVAL; 681788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_PKT_ERR: return -EINVAL; 682788333d9SHans Petter Selasky case MLX5_CMD_STAT_BAD_SIZE_OUTS_CQES_ERR: return -EINVAL; 683788333d9SHans Petter Selasky default: return -EIO; 684788333d9SHans Petter Selasky } 685788333d9SHans Petter Selasky } 686788333d9SHans Petter Selasky 687788333d9SHans Petter Selasky void mlx5_cmd_mbox_status(void *out, u8 *status, u32 *syndrome) 688788333d9SHans Petter Selasky { 689788333d9SHans Petter Selasky *status = MLX5_GET(mbox_out, out, status); 690788333d9SHans Petter Selasky *syndrome = MLX5_GET(mbox_out, out, syndrome); 691788333d9SHans Petter Selasky } 692788333d9SHans Petter Selasky 693788333d9SHans Petter Selasky static int mlx5_cmd_check(struct mlx5_core_dev *dev, void *in, void *out) 694788333d9SHans Petter Selasky { 695788333d9SHans Petter Selasky u32 syndrome; 696788333d9SHans Petter Selasky u8 status; 697788333d9SHans Petter Selasky u16 opcode; 698788333d9SHans Petter Selasky u16 op_mod; 699788333d9SHans Petter Selasky 700788333d9SHans Petter Selasky mlx5_cmd_mbox_status(out, &status, &syndrome); 701788333d9SHans Petter Selasky if (!status) 702788333d9SHans Petter Selasky return 0; 703788333d9SHans Petter Selasky 704788333d9SHans Petter Selasky opcode = MLX5_GET(mbox_in, in, opcode); 705788333d9SHans Petter Selasky op_mod = MLX5_GET(mbox_in, in, op_mod); 706788333d9SHans Petter Selasky 707788333d9SHans Petter Selasky mlx5_core_err(dev, 708788333d9SHans Petter Selasky "%s(0x%x) op_mod(0x%x) failed, status %s(0x%x), syndrome (0x%x)\n", 709788333d9SHans Petter Selasky mlx5_command_str(opcode), 710788333d9SHans Petter Selasky opcode, op_mod, 711788333d9SHans Petter Selasky cmd_status_str(status), 712788333d9SHans Petter Selasky status, 713788333d9SHans Petter Selasky syndrome); 714788333d9SHans Petter Selasky 715788333d9SHans Petter Selasky return cmd_status_to_err_helper(status); 716788333d9SHans Petter Selasky } 717788333d9SHans Petter Selasky 718dc7e38acSHans Petter Selasky static void dump_command(struct mlx5_core_dev *dev, 719dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent, int input) 720dc7e38acSHans Petter Selasky { 721dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg = input ? ent->in : ent->out; 722788333d9SHans Petter Selasky u16 op = MLX5_GET(mbox_in, ent->lay->in, opcode); 7231c807f67SHans Petter Selasky size_t i; 724dc7e38acSHans Petter Selasky int data_only; 7251c807f67SHans Petter Selasky int offset = 0; 7261c807f67SHans Petter Selasky int msg_len = input ? ent->uin_size : ent->uout_size; 727dc7e38acSHans Petter Selasky int dump_len; 728dc7e38acSHans Petter Selasky 729dc7e38acSHans Petter Selasky data_only = !!(mlx5_core_debug_mask & (1 << MLX5_CMD_DATA)); 730dc7e38acSHans Petter Selasky 731dc7e38acSHans Petter Selasky if (data_only) 732dc7e38acSHans Petter Selasky mlx5_core_dbg_mask(dev, 1 << MLX5_CMD_DATA, 733dc7e38acSHans Petter Selasky "dump command data %s(0x%x) %s\n", 734dc7e38acSHans Petter Selasky mlx5_command_str(op), op, 735dc7e38acSHans Petter Selasky input ? "INPUT" : "OUTPUT"); 736dc7e38acSHans Petter Selasky else 737dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "dump command %s(0x%x) %s\n", 738dc7e38acSHans Petter Selasky mlx5_command_str(op), op, 739dc7e38acSHans Petter Selasky input ? "INPUT" : "OUTPUT"); 740dc7e38acSHans Petter Selasky 741dc7e38acSHans Petter Selasky if (data_only) { 742dc7e38acSHans Petter Selasky if (input) { 743dc7e38acSHans Petter Selasky dump_buf(ent->lay->in, sizeof(ent->lay->in), 1, offset); 744dc7e38acSHans Petter Selasky offset += sizeof(ent->lay->in); 745dc7e38acSHans Petter Selasky } else { 746dc7e38acSHans Petter Selasky dump_buf(ent->lay->out, sizeof(ent->lay->out), 1, offset); 747dc7e38acSHans Petter Selasky offset += sizeof(ent->lay->out); 748dc7e38acSHans Petter Selasky } 749dc7e38acSHans Petter Selasky } else { 750dc7e38acSHans Petter Selasky dump_buf(ent->lay, sizeof(*ent->lay), 0, offset); 751dc7e38acSHans Petter Selasky offset += sizeof(*ent->lay); 752dc7e38acSHans Petter Selasky } 753dc7e38acSHans Petter Selasky 7541c807f67SHans Petter Selasky for (i = 0; i != (msg->numpages * MLX5_NUM_CMDS_IN_ADAPTER_PAGE); i++) { 7551c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block; 7561c807f67SHans Petter Selasky 7571c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE); 7581c807f67SHans Petter Selasky 759dc7e38acSHans Petter Selasky if (data_only) { 7601c807f67SHans Petter Selasky if (offset >= msg_len) 7611c807f67SHans Petter Selasky break; 7621c807f67SHans Petter Selasky dump_len = min_t(int, 7631c807f67SHans Petter Selasky MLX5_CMD_DATA_BLOCK_SIZE, msg_len - offset); 7641c807f67SHans Petter Selasky 7651c807f67SHans Petter Selasky dump_buf(block->data, dump_len, 1, offset); 766dc7e38acSHans Petter Selasky offset += MLX5_CMD_DATA_BLOCK_SIZE; 767dc7e38acSHans Petter Selasky } else { 768dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "command block:\n"); 7691c807f67SHans Petter Selasky dump_buf(block, sizeof(*block), 0, offset); 7701c807f67SHans Petter Selasky offset += sizeof(*block); 771dc7e38acSHans Petter Selasky } 7721c807f67SHans Petter Selasky 7731c807f67SHans Petter Selasky /* check for last block */ 7741c807f67SHans Petter Selasky if (block->next == 0) 7751c807f67SHans Petter Selasky break; 776dc7e38acSHans Petter Selasky } 777dc7e38acSHans Petter Selasky 778dc7e38acSHans Petter Selasky if (data_only) 779dc7e38acSHans Petter Selasky pr_debug("\n"); 780dc7e38acSHans Petter Selasky } 781dc7e38acSHans Petter Selasky 78211546d06SHans Petter Selasky static u16 msg_to_opcode(struct mlx5_cmd_msg *in) 78311546d06SHans Petter Selasky { 784788333d9SHans Petter Selasky return MLX5_GET(mbox_in, in->first.data, opcode); 78511546d06SHans Petter Selasky } 78611546d06SHans Petter Selasky 78711546d06SHans Petter Selasky static void cb_timeout_handler(struct work_struct *work) 78811546d06SHans Petter Selasky { 78911546d06SHans Petter Selasky struct delayed_work *dwork = container_of(work, struct delayed_work, 79011546d06SHans Petter Selasky work); 79111546d06SHans Petter Selasky struct mlx5_cmd_work_ent *ent = container_of(dwork, 79211546d06SHans Petter Selasky struct mlx5_cmd_work_ent, 79311546d06SHans Petter Selasky cb_timeout_work); 79411546d06SHans Petter Selasky struct mlx5_core_dev *dev = container_of(ent->cmd, struct mlx5_core_dev, 79511546d06SHans Petter Selasky cmd); 79611546d06SHans Petter Selasky 79711546d06SHans Petter Selasky ent->ret = -ETIMEDOUT; 79811546d06SHans Petter Selasky mlx5_core_warn(dev, "%s(0x%x) timeout. Will cause a leak of a command resource\n", 79911546d06SHans Petter Selasky mlx5_command_str(msg_to_opcode(ent->in)), 80011546d06SHans Petter Selasky msg_to_opcode(ent->in)); 801721a1a6aSSlava Shwartsman mlx5_cmd_comp_handler(dev, 1UL << ent->idx, MLX5_CMD_MODE_EVENTS); 80211546d06SHans Petter Selasky } 80311546d06SHans Petter Selasky 8048e7e0ce1SHans Petter Selasky static void complete_command(struct mlx5_cmd_work_ent *ent) 8058e7e0ce1SHans Petter Selasky { 8068e7e0ce1SHans Petter Selasky struct mlx5_cmd *cmd = ent->cmd; 8078e7e0ce1SHans Petter Selasky struct mlx5_core_dev *dev = container_of(cmd, struct mlx5_core_dev, 8088e7e0ce1SHans Petter Selasky cmd); 809f361e561SHans Petter Selasky mlx5_cmd_cbk_t callback; 810f361e561SHans Petter Selasky void *context; 811f361e561SHans Petter Selasky 8128e7e0ce1SHans Petter Selasky s64 ds; 8138e7e0ce1SHans Petter Selasky struct mlx5_cmd_stats *stats; 8148e7e0ce1SHans Petter Selasky unsigned long flags; 8158e7e0ce1SHans Petter Selasky int err; 8168e7e0ce1SHans Petter Selasky struct semaphore *sem; 8178e7e0ce1SHans Petter Selasky 8188e7e0ce1SHans Petter Selasky if (ent->page_queue) 8198e7e0ce1SHans Petter Selasky sem = &cmd->pages_sem; 8208e7e0ce1SHans Petter Selasky else 8218e7e0ce1SHans Petter Selasky sem = &cmd->sem; 8228e7e0ce1SHans Petter Selasky 82330dfc051SHans Petter Selasky if (dev->state != MLX5_DEVICE_STATE_UP) { 824788333d9SHans Petter Selasky u8 status = 0; 825788333d9SHans Petter Selasky u32 drv_synd; 82630dfc051SHans Petter Selasky 827788333d9SHans Petter Selasky ent->ret = mlx5_internal_err_ret_value(dev, msg_to_opcode(ent->in), &drv_synd, &status); 828788333d9SHans Petter Selasky MLX5_SET(mbox_out, ent->out, status, status); 829788333d9SHans Petter Selasky MLX5_SET(mbox_out, ent->out, syndrome, drv_synd); 83030dfc051SHans Petter Selasky } 83130dfc051SHans Petter Selasky 8328e7e0ce1SHans Petter Selasky if (ent->callback) { 8338e7e0ce1SHans Petter Selasky ds = ent->ts2 - ent->ts1; 8348e7e0ce1SHans Petter Selasky if (ent->op < ARRAY_SIZE(cmd->stats)) { 8358e7e0ce1SHans Petter Selasky stats = &cmd->stats[ent->op]; 8368e7e0ce1SHans Petter Selasky spin_lock_irqsave(&stats->lock, flags); 8378e7e0ce1SHans Petter Selasky stats->sum += ds; 8388e7e0ce1SHans Petter Selasky ++stats->n; 8398e7e0ce1SHans Petter Selasky spin_unlock_irqrestore(&stats->lock, flags); 8408e7e0ce1SHans Petter Selasky } 8418e7e0ce1SHans Petter Selasky 842f361e561SHans Petter Selasky callback = ent->callback; 843f361e561SHans Petter Selasky context = ent->context; 8448e7e0ce1SHans Petter Selasky err = ent->ret; 845788333d9SHans Petter Selasky if (!err) { 8468e7e0ce1SHans Petter Selasky err = mlx5_copy_from_msg(ent->uout, 8478e7e0ce1SHans Petter Selasky ent->out, 8488e7e0ce1SHans Petter Selasky ent->uout_size); 849788333d9SHans Petter Selasky err = err ? err : mlx5_cmd_check(dev, 850788333d9SHans Petter Selasky ent->in->first.data, 851788333d9SHans Petter Selasky ent->uout); 852788333d9SHans Petter Selasky } 8538e7e0ce1SHans Petter Selasky 8548e7e0ce1SHans Petter Selasky mlx5_free_cmd_msg(dev, ent->out); 8558e7e0ce1SHans Petter Selasky free_msg(dev, ent->in); 8568e7e0ce1SHans Petter Selasky 857a2485fe5SHans Petter Selasky err = err ? err : ent->status; 8588e7e0ce1SHans Petter Selasky free_cmd(ent); 859f361e561SHans Petter Selasky callback(err, context); 8608e7e0ce1SHans Petter Selasky } else { 8618e7e0ce1SHans Petter Selasky complete(&ent->done); 8628e7e0ce1SHans Petter Selasky } 8638e7e0ce1SHans Petter Selasky up(sem); 8648e7e0ce1SHans Petter Selasky } 8658e7e0ce1SHans Petter Selasky 866dc7e38acSHans Petter Selasky static void cmd_work_handler(struct work_struct *work) 867dc7e38acSHans Petter Selasky { 868dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent = container_of(work, struct mlx5_cmd_work_ent, work); 869dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = ent->cmd; 870dc7e38acSHans Petter Selasky struct mlx5_core_dev *dev = container_of(cmd, struct mlx5_core_dev, cmd); 87111546d06SHans Petter Selasky unsigned long cb_timeout = msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC); 872dc7e38acSHans Petter Selasky struct mlx5_cmd_layout *lay; 873dc7e38acSHans Petter Selasky struct semaphore *sem; 874c0902569SHans Petter Selasky bool poll_cmd = ent->polling; 875dc7e38acSHans Petter Selasky 876dc7e38acSHans Petter Selasky sem = ent->page_queue ? &cmd->pages_sem : &cmd->sem; 877dc7e38acSHans Petter Selasky down(sem); 8788e7e0ce1SHans Petter Selasky 8798e7e0ce1SHans Petter Selasky if (alloc_ent(ent) < 0) { 8808e7e0ce1SHans Petter Selasky complete_command(ent); 881dc7e38acSHans Petter Selasky return; 882dc7e38acSHans Petter Selasky } 883dc7e38acSHans Petter Selasky 884dc7e38acSHans Petter Selasky ent->token = alloc_token(cmd); 885dc7e38acSHans Petter Selasky lay = get_inst(cmd, ent->idx); 886dc7e38acSHans Petter Selasky ent->lay = lay; 887dc7e38acSHans Petter Selasky memset(lay, 0, sizeof(*lay)); 888dc7e38acSHans Petter Selasky memcpy(lay->in, ent->in->first.data, sizeof(lay->in)); 889dc7e38acSHans Petter Selasky ent->op = be32_to_cpu(lay->in[0]) >> 16; 8901c807f67SHans Petter Selasky if (ent->in->numpages != 0) 8911c807f67SHans Petter Selasky lay->in_ptr = cpu_to_be64(mlx5_fwp_get_dma(ent->in, 0)); 8921c807f67SHans Petter Selasky if (ent->out->numpages != 0) 8931c807f67SHans Petter Selasky lay->out_ptr = cpu_to_be64(mlx5_fwp_get_dma(ent->out, 0)); 8941c807f67SHans Petter Selasky lay->inlen = cpu_to_be32(ent->uin_size); 8951c807f67SHans Petter Selasky lay->outlen = cpu_to_be32(ent->uout_size); 896dc7e38acSHans Petter Selasky lay->type = MLX5_PCI_CMD_XPORT; 897dc7e38acSHans Petter Selasky lay->token = ent->token; 898dc7e38acSHans Petter Selasky lay->status_own = CMD_OWNER_HW; 899dc7e38acSHans Petter Selasky set_signature(ent, !cmd->checksum_disabled); 900dc7e38acSHans Petter Selasky dump_command(dev, ent, 1); 901dc7e38acSHans Petter Selasky ent->ts1 = ktime_get_ns(); 90230dfc051SHans Petter Selasky ent->busy = 0; 90311546d06SHans Petter Selasky if (ent->callback) 90411546d06SHans Petter Selasky schedule_delayed_work(&ent->cb_timeout_work, cb_timeout); 90511546d06SHans Petter Selasky 906dc7e38acSHans Petter Selasky /* ring doorbell after the descriptor is valid */ 907dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "writing 0x%x to command doorbell\n", 1 << ent->idx); 9081c807f67SHans Petter Selasky /* make sure data is written to RAM */ 9091c807f67SHans Petter Selasky mlx5_fwp_flush(cmd->cmd_page); 910dc7e38acSHans Petter Selasky iowrite32be(1 << ent->idx, &dev->iseg->cmd_dbell); 911dc7e38acSHans Petter Selasky mmiowb(); 912721a1a6aSSlava Shwartsman 913dc7e38acSHans Petter Selasky /* if not in polling don't use ent after this point */ 914721a1a6aSSlava Shwartsman if (poll_cmd) { 915dc7e38acSHans Petter Selasky poll_timeout(ent); 916dc7e38acSHans Petter Selasky /* make sure we read the descriptor after ownership is SW */ 917721a1a6aSSlava Shwartsman mlx5_cmd_comp_handler(dev, 1U << ent->idx, MLX5_CMD_MODE_POLLING); 918dc7e38acSHans Petter Selasky } 919dc7e38acSHans Petter Selasky } 920dc7e38acSHans Petter Selasky 921dc7e38acSHans Petter Selasky static const char *deliv_status_to_str(u8 status) 922dc7e38acSHans Petter Selasky { 923dc7e38acSHans Petter Selasky switch (status) { 924dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_OK: 925dc7e38acSHans Petter Selasky return "no errors"; 926dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_SIGNAT_ERR: 927dc7e38acSHans Petter Selasky return "signature error"; 928dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_TOK_ERR: 929dc7e38acSHans Petter Selasky return "token error"; 930dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_BAD_BLK_NUM_ERR: 931dc7e38acSHans Petter Selasky return "bad block number"; 932dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_OUT_PTR_ALIGN_ERR: 933dc7e38acSHans Petter Selasky return "output pointer not aligned to block size"; 934dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_IN_PTR_ALIGN_ERR: 935dc7e38acSHans Petter Selasky return "input pointer not aligned to block size"; 936dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_FW_ERR: 937dc7e38acSHans Petter Selasky return "firmware internal error"; 938dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_IN_LENGTH_ERR: 939dc7e38acSHans Petter Selasky return "command input length error"; 940dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_OUT_LENGTH_ERR: 941dc7e38acSHans Petter Selasky return "command ouput length error"; 942dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_RES_FLD_NOT_CLR_ERR: 943dc7e38acSHans Petter Selasky return "reserved fields not cleared"; 944dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_CMD_DESCR_ERR: 945dc7e38acSHans Petter Selasky return "bad command descriptor type"; 946dc7e38acSHans Petter Selasky default: 947dc7e38acSHans Petter Selasky return "unknown status code"; 948dc7e38acSHans Petter Selasky } 949dc7e38acSHans Petter Selasky } 950dc7e38acSHans Petter Selasky 951dc7e38acSHans Petter Selasky static int wait_func(struct mlx5_core_dev *dev, struct mlx5_cmd_work_ent *ent) 952dc7e38acSHans Petter Selasky { 953dc7e38acSHans Petter Selasky int timeout = msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC); 954dc7e38acSHans Petter Selasky int err; 955dc7e38acSHans Petter Selasky 956721a1a6aSSlava Shwartsman if (ent->polling) { 957dc7e38acSHans Petter Selasky wait_for_completion(&ent->done); 9582327a753SHans Petter Selasky } else if (!wait_for_completion_timeout(&ent->done, timeout)) { 9592327a753SHans Petter Selasky ent->ret = -ETIMEDOUT; 960721a1a6aSSlava Shwartsman mlx5_cmd_comp_handler(dev, 1UL << ent->idx, MLX5_CMD_MODE_EVENTS); 961dc7e38acSHans Petter Selasky } 96230dfc051SHans Petter Selasky 9632327a753SHans Petter Selasky err = ent->ret; 9642327a753SHans Petter Selasky 965dc7e38acSHans Petter Selasky if (err == -ETIMEDOUT) { 966dc7e38acSHans Petter Selasky mlx5_core_warn(dev, "%s(0x%x) timeout. Will cause a leak of a command resource\n", 967dc7e38acSHans Petter Selasky mlx5_command_str(msg_to_opcode(ent->in)), 968dc7e38acSHans Petter Selasky msg_to_opcode(ent->in)); 969dc7e38acSHans Petter Selasky } 970dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "err %d, delivery status %s(%d)\n", 971dc7e38acSHans Petter Selasky err, deliv_status_to_str(ent->status), ent->status); 972dc7e38acSHans Petter Selasky 973dc7e38acSHans Petter Selasky return err; 974dc7e38acSHans Petter Selasky } 975dc7e38acSHans Petter Selasky 976dc7e38acSHans Petter Selasky /* Notes: 977dc7e38acSHans Petter Selasky * 1. Callback functions may not sleep 978dc7e38acSHans Petter Selasky * 2. page queue commands do not support asynchrous completion 979dc7e38acSHans Petter Selasky */ 980dc7e38acSHans Petter Selasky static int mlx5_cmd_invoke(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *in, 9811c807f67SHans Petter Selasky int uin_size, 982dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *out, void *uout, int uout_size, 983dc7e38acSHans Petter Selasky mlx5_cmd_cbk_t callback, 984c0902569SHans Petter Selasky void *context, int page_queue, u8 *status, 985c0902569SHans Petter Selasky bool force_polling) 986dc7e38acSHans Petter Selasky { 987dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 988dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent; 989dc7e38acSHans Petter Selasky struct mlx5_cmd_stats *stats; 990dc7e38acSHans Petter Selasky int err = 0; 991dc7e38acSHans Petter Selasky s64 ds; 992dc7e38acSHans Petter Selasky u16 op; 993dc7e38acSHans Petter Selasky 994dc7e38acSHans Petter Selasky if (callback && page_queue) 995dc7e38acSHans Petter Selasky return -EINVAL; 996dc7e38acSHans Petter Selasky 9971c807f67SHans Petter Selasky ent = alloc_cmd(cmd, in, uin_size, out, uout, uout_size, callback, 9981c807f67SHans Petter Selasky context, page_queue); 999dc7e38acSHans Petter Selasky if (IS_ERR(ent)) 1000dc7e38acSHans Petter Selasky return PTR_ERR(ent); 1001dc7e38acSHans Petter Selasky 1002721a1a6aSSlava Shwartsman ent->polling = force_polling || (cmd->mode == MLX5_CMD_MODE_POLLING); 1003c0902569SHans Petter Selasky 1004dc7e38acSHans Petter Selasky if (!callback) 1005dc7e38acSHans Petter Selasky init_completion(&ent->done); 1006dc7e38acSHans Petter Selasky 100711546d06SHans Petter Selasky INIT_DELAYED_WORK(&ent->cb_timeout_work, cb_timeout_handler); 1008dc7e38acSHans Petter Selasky INIT_WORK(&ent->work, cmd_work_handler); 1009dc7e38acSHans Petter Selasky if (page_queue) { 1010dc7e38acSHans Petter Selasky cmd_work_handler(&ent->work); 10118d1eeedbSHans Petter Selasky } else if (!queue_work(dev->priv.health.wq_cmd, &ent->work)) { 1012dc7e38acSHans Petter Selasky mlx5_core_warn(dev, "failed to queue work\n"); 1013dc7e38acSHans Petter Selasky err = -ENOMEM; 1014dc7e38acSHans Petter Selasky goto out_free; 1015dc7e38acSHans Petter Selasky } 1016dc7e38acSHans Petter Selasky 10172327a753SHans Petter Selasky if (callback) 10182327a753SHans Petter Selasky goto out; 10192327a753SHans Petter Selasky 1020dc7e38acSHans Petter Selasky err = wait_func(dev, ent); 1021dc7e38acSHans Petter Selasky if (err == -ETIMEDOUT) 1022dc7e38acSHans Petter Selasky goto out; 1023dc7e38acSHans Petter Selasky 1024dc7e38acSHans Petter Selasky ds = ent->ts2 - ent->ts1; 1025788333d9SHans Petter Selasky op = MLX5_GET(mbox_in, in->first.data, opcode); 1026dc7e38acSHans Petter Selasky if (op < ARRAY_SIZE(cmd->stats)) { 1027dc7e38acSHans Petter Selasky stats = &cmd->stats[op]; 1028dc7e38acSHans Petter Selasky spin_lock_irq(&stats->lock); 1029dc7e38acSHans Petter Selasky stats->sum += ds; 1030dc7e38acSHans Petter Selasky ++stats->n; 1031dc7e38acSHans Petter Selasky spin_unlock_irq(&stats->lock); 1032dc7e38acSHans Petter Selasky } 1033dc7e38acSHans Petter Selasky mlx5_core_dbg_mask(dev, 1 << MLX5_CMD_TIME, 1034dc7e38acSHans Petter Selasky "fw exec time for %s is %lld nsec\n", 1035dc7e38acSHans Petter Selasky mlx5_command_str(op), (long long)ds); 1036dc7e38acSHans Petter Selasky *status = ent->status; 1037dc7e38acSHans Petter Selasky free_cmd(ent); 1038dc7e38acSHans Petter Selasky 1039dc7e38acSHans Petter Selasky return err; 1040dc7e38acSHans Petter Selasky 1041dc7e38acSHans Petter Selasky out_free: 1042dc7e38acSHans Petter Selasky free_cmd(ent); 1043dc7e38acSHans Petter Selasky out: 1044dc7e38acSHans Petter Selasky return err; 1045dc7e38acSHans Petter Selasky } 1046dc7e38acSHans Petter Selasky 10471c807f67SHans Petter Selasky static int mlx5_copy_to_msg(struct mlx5_cmd_msg *to, void *from, size_t size) 1048dc7e38acSHans Petter Selasky { 10491c807f67SHans Petter Selasky size_t delta; 10501c807f67SHans Petter Selasky size_t i; 10511c807f67SHans Petter Selasky 10521c807f67SHans Petter Selasky if (to == NULL || from == NULL) 10531c807f67SHans Petter Selasky return (-ENOMEM); 10541c807f67SHans Petter Selasky 10551c807f67SHans Petter Selasky delta = min_t(size_t, size, sizeof(to->first.data)); 10561c807f67SHans Petter Selasky memcpy(to->first.data, from, delta); 10571c807f67SHans Petter Selasky from = (char *)from + delta; 10581c807f67SHans Petter Selasky size -= delta; 10591c807f67SHans Petter Selasky 10601c807f67SHans Petter Selasky for (i = 0; size != 0; i++) { 1061dc7e38acSHans Petter Selasky struct mlx5_cmd_prot_block *block; 1062dc7e38acSHans Petter Selasky 10631c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(to, i * MLX5_CMD_MBOX_SIZE); 1064dc7e38acSHans Petter Selasky 10651c807f67SHans Petter Selasky delta = min_t(size_t, size, MLX5_CMD_DATA_BLOCK_SIZE); 10661c807f67SHans Petter Selasky memcpy(block->data, from, delta); 10671c807f67SHans Petter Selasky from = (char *)from + delta; 10681c807f67SHans Petter Selasky size -= delta; 1069dc7e38acSHans Petter Selasky } 10701c807f67SHans Petter Selasky return (0); 1071dc7e38acSHans Petter Selasky } 1072dc7e38acSHans Petter Selasky 1073dc7e38acSHans Petter Selasky static int mlx5_copy_from_msg(void *to, struct mlx5_cmd_msg *from, int size) 1074dc7e38acSHans Petter Selasky { 10751c807f67SHans Petter Selasky size_t delta; 10761c807f67SHans Petter Selasky size_t i; 10771c807f67SHans Petter Selasky 10781c807f67SHans Petter Selasky if (to == NULL || from == NULL) 10791c807f67SHans Petter Selasky return (-ENOMEM); 10801c807f67SHans Petter Selasky 10811c807f67SHans Petter Selasky delta = min_t(size_t, size, sizeof(from->first.data)); 10821c807f67SHans Petter Selasky memcpy(to, from->first.data, delta); 10831c807f67SHans Petter Selasky to = (char *)to + delta; 10841c807f67SHans Petter Selasky size -= delta; 10851c807f67SHans Petter Selasky 10861c807f67SHans Petter Selasky for (i = 0; size != 0; i++) { 1087dc7e38acSHans Petter Selasky struct mlx5_cmd_prot_block *block; 1088dc7e38acSHans Petter Selasky 10891c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(from, i * MLX5_CMD_MBOX_SIZE); 1090dc7e38acSHans Petter Selasky 10911c807f67SHans Petter Selasky delta = min_t(size_t, size, MLX5_CMD_DATA_BLOCK_SIZE); 10921c807f67SHans Petter Selasky memcpy(to, block->data, delta); 10931c807f67SHans Petter Selasky to = (char *)to + delta; 10941c807f67SHans Petter Selasky size -= delta; 10951c807f67SHans Petter Selasky } 10961c807f67SHans Petter Selasky return (0); 1097dc7e38acSHans Petter Selasky } 1098dc7e38acSHans Petter Selasky 10991c807f67SHans Petter Selasky static struct mlx5_cmd_msg * 11001c807f67SHans Petter Selasky mlx5_alloc_cmd_msg(struct mlx5_core_dev *dev, gfp_t flags, size_t size) 1101dc7e38acSHans Petter Selasky { 1102dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg; 11031c807f67SHans Petter Selasky size_t blen; 11041c807f67SHans Petter Selasky size_t n; 11051c807f67SHans Petter Selasky size_t i; 1106dc7e38acSHans Petter Selasky 11071c807f67SHans Petter Selasky blen = size - min_t(size_t, sizeof(msg->first.data), size); 11081c807f67SHans Petter Selasky n = howmany(blen, MLX5_CMD_DATA_BLOCK_SIZE); 1109dc7e38acSHans Petter Selasky 11101c807f67SHans Petter Selasky msg = mlx5_fwp_alloc(dev, flags, howmany(n, MLX5_NUM_CMDS_IN_ADAPTER_PAGE)); 11111c807f67SHans Petter Selasky if (msg == NULL) 11121c807f67SHans Petter Selasky return (ERR_PTR(-ENOMEM)); 1113dc7e38acSHans Petter Selasky 11141c807f67SHans Petter Selasky for (i = 0; i != n; i++) { 11151c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block; 11161c807f67SHans Petter Selasky 11171c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE); 11181c807f67SHans Petter Selasky 11191c807f67SHans Petter Selasky memset(block, 0, MLX5_CMD_MBOX_SIZE); 11201c807f67SHans Petter Selasky 11211c807f67SHans Petter Selasky if (i != (n - 1)) { 11221c807f67SHans Petter Selasky u64 dma = mlx5_fwp_get_dma(msg, (i + 1) * MLX5_CMD_MBOX_SIZE); 11231c807f67SHans Petter Selasky block->next = cpu_to_be64(dma); 11241c807f67SHans Petter Selasky } 11251c807f67SHans Petter Selasky block->block_num = cpu_to_be32(i); 1126dc7e38acSHans Petter Selasky } 1127dc7e38acSHans Petter Selasky 11281c807f67SHans Petter Selasky /* make sure initial data is written to RAM */ 11291c807f67SHans Petter Selasky mlx5_fwp_flush(msg); 1130dc7e38acSHans Petter Selasky 11311c807f67SHans Petter Selasky return (msg); 1132dc7e38acSHans Petter Selasky } 1133dc7e38acSHans Petter Selasky 11341c807f67SHans Petter Selasky static void 11351c807f67SHans Petter Selasky mlx5_free_cmd_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg) 1136dc7e38acSHans Petter Selasky { 1137dc7e38acSHans Petter Selasky 11381c807f67SHans Petter Selasky mlx5_fwp_free(msg); 1139dc7e38acSHans Petter Selasky } 1140dc7e38acSHans Petter Selasky 1141dc7e38acSHans Petter Selasky static void clean_debug_files(struct mlx5_core_dev *dev) 1142dc7e38acSHans Petter Selasky { 1143dc7e38acSHans Petter Selasky } 1144dc7e38acSHans Petter Selasky 1145dc7e38acSHans Petter Selasky 11462327a753SHans Petter Selasky static void mlx5_cmd_change_mod(struct mlx5_core_dev *dev, int mode) 1147dc7e38acSHans Petter Selasky { 1148dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1149dc7e38acSHans Petter Selasky int i; 1150dc7e38acSHans Petter Selasky 1151192fc18dSHans Petter Selasky if (cmd->mode == mode) 1152192fc18dSHans Petter Selasky return; 1153192fc18dSHans Petter Selasky 1154dc7e38acSHans Petter Selasky for (i = 0; i < cmd->max_reg_cmds; i++) 1155dc7e38acSHans Petter Selasky down(&cmd->sem); 1156dc7e38acSHans Petter Selasky 1157dc7e38acSHans Petter Selasky down(&cmd->pages_sem); 11582327a753SHans Petter Selasky cmd->mode = mode; 1159dc7e38acSHans Petter Selasky 1160dc7e38acSHans Petter Selasky up(&cmd->pages_sem); 1161dc7e38acSHans Petter Selasky for (i = 0; i < cmd->max_reg_cmds; i++) 1162dc7e38acSHans Petter Selasky up(&cmd->sem); 1163dc7e38acSHans Petter Selasky } 1164dc7e38acSHans Petter Selasky 11652327a753SHans Petter Selasky void mlx5_cmd_use_events(struct mlx5_core_dev *dev) 11662327a753SHans Petter Selasky { 1167721a1a6aSSlava Shwartsman mlx5_cmd_change_mod(dev, MLX5_CMD_MODE_EVENTS); 11682327a753SHans Petter Selasky } 11692327a753SHans Petter Selasky 1170dc7e38acSHans Petter Selasky void mlx5_cmd_use_polling(struct mlx5_core_dev *dev) 1171dc7e38acSHans Petter Selasky { 1172721a1a6aSSlava Shwartsman mlx5_cmd_change_mod(dev, MLX5_CMD_MODE_POLLING); 1173dc7e38acSHans Petter Selasky } 1174dc7e38acSHans Petter Selasky 1175dc7e38acSHans Petter Selasky static void free_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg) 1176dc7e38acSHans Petter Selasky { 1177dc7e38acSHans Petter Selasky unsigned long flags; 1178dc7e38acSHans Petter Selasky 1179dc7e38acSHans Petter Selasky if (msg->cache) { 1180dc7e38acSHans Petter Selasky spin_lock_irqsave(&msg->cache->lock, flags); 1181dc7e38acSHans Petter Selasky list_add_tail(&msg->list, &msg->cache->head); 1182dc7e38acSHans Petter Selasky spin_unlock_irqrestore(&msg->cache->lock, flags); 1183dc7e38acSHans Petter Selasky } else { 1184dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, msg); 1185dc7e38acSHans Petter Selasky } 1186dc7e38acSHans Petter Selasky } 1187dc7e38acSHans Petter Selasky 1188721a1a6aSSlava Shwartsman void mlx5_cmd_comp_handler(struct mlx5_core_dev *dev, u64 vector_flags, 1189721a1a6aSSlava Shwartsman enum mlx5_cmd_mode cmd_mode) 1190dc7e38acSHans Petter Selasky { 1191dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1192dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent; 119370b417cfSSlava Shwartsman bool triggered = (vector_flags & MLX5_TRIGGERED_CMD_COMP) ? 1 : 0; 119470b417cfSSlava Shwartsman u32 vector = vector_flags; /* discard flags in the upper dword */ 1195dc7e38acSHans Petter Selasky int i; 1196dc7e38acSHans Petter Selasky 11971c807f67SHans Petter Selasky /* make sure data gets read from RAM */ 11981c807f67SHans Petter Selasky mlx5_fwp_invalidate(cmd->cmd_page); 11991c807f67SHans Petter Selasky 1200d0ce5a0dSHans Petter Selasky while (vector != 0) { 1201d0ce5a0dSHans Petter Selasky i = ffs(vector) - 1; 1202d0ce5a0dSHans Petter Selasky vector &= ~(1U << i); 1203721a1a6aSSlava Shwartsman /* check command mode */ 1204721a1a6aSSlava Shwartsman if (cmd->ent_mode[i] != cmd_mode) 1205721a1a6aSSlava Shwartsman continue; 1206dc7e38acSHans Petter Selasky ent = cmd->ent_arr[i]; 1207721a1a6aSSlava Shwartsman /* check if command was already handled */ 1208721a1a6aSSlava Shwartsman if (ent == NULL) 1209721a1a6aSSlava Shwartsman continue; 121011546d06SHans Petter Selasky if (ent->callback) 121111546d06SHans Petter Selasky cancel_delayed_work(&ent->cb_timeout_work); 1212dc7e38acSHans Petter Selasky ent->ts2 = ktime_get_ns(); 1213d0ce5a0dSHans Petter Selasky memcpy(ent->out->first.data, ent->lay->out, 1214d0ce5a0dSHans Petter Selasky sizeof(ent->lay->out)); 12151c807f67SHans Petter Selasky /* make sure data gets read from RAM */ 12161c807f67SHans Petter Selasky mlx5_fwp_invalidate(ent->out); 1217dc7e38acSHans Petter Selasky dump_command(dev, ent, 0); 1218dc7e38acSHans Petter Selasky if (!ent->ret) { 1219dc7e38acSHans Petter Selasky if (!cmd->checksum_disabled) 1220dc7e38acSHans Petter Selasky ent->ret = verify_signature(ent); 1221dc7e38acSHans Petter Selasky else 1222dc7e38acSHans Petter Selasky ent->ret = 0; 1223a5754bd2SHans Petter Selasky 122470b417cfSSlava Shwartsman if (triggered) 1225a2485fe5SHans Petter Selasky ent->status = MLX5_DRIVER_STATUS_ABORTED; 1226a2485fe5SHans Petter Selasky else 1227a2485fe5SHans Petter Selasky ent->status = ent->lay->status_own >> 1; 122830dfc051SHans Petter Selasky 1229d0ce5a0dSHans Petter Selasky mlx5_core_dbg(dev, 1230d0ce5a0dSHans Petter Selasky "FW command ret 0x%x, status %s(0x%x)\n", 1231d0ce5a0dSHans Petter Selasky ent->ret, 1232d0ce5a0dSHans Petter Selasky deliv_status_to_str(ent->status), 1233d0ce5a0dSHans Petter Selasky ent->status); 1234dc7e38acSHans Petter Selasky } 1235dc7e38acSHans Petter Selasky free_ent(cmd, ent->idx); 12368e7e0ce1SHans Petter Selasky complete_command(ent); 1237dc7e38acSHans Petter Selasky } 1238dc7e38acSHans Petter Selasky } 1239dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_comp_handler); 1240dc7e38acSHans Petter Selasky 1241dc7e38acSHans Petter Selasky static int status_to_err(u8 status) 1242dc7e38acSHans Petter Selasky { 124307e68e62SHans Petter Selasky return status ? -EIO : 0; /* TBD more meaningful codes */ 1244dc7e38acSHans Petter Selasky } 1245dc7e38acSHans Petter Selasky 1246dc7e38acSHans Petter Selasky static struct mlx5_cmd_msg *alloc_msg(struct mlx5_core_dev *dev, int in_size, 1247dc7e38acSHans Petter Selasky gfp_t gfp) 1248dc7e38acSHans Petter Selasky { 1249dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg = ERR_PTR(-ENOMEM); 1250dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1251dc7e38acSHans Petter Selasky struct cache_ent *ent = NULL; 1252dc7e38acSHans Petter Selasky 1253dc7e38acSHans Petter Selasky if (in_size > MED_LIST_SIZE && in_size <= LONG_LIST_SIZE) 1254dc7e38acSHans Petter Selasky ent = &cmd->cache.large; 1255dc7e38acSHans Petter Selasky else if (in_size > 16 && in_size <= MED_LIST_SIZE) 1256dc7e38acSHans Petter Selasky ent = &cmd->cache.med; 1257dc7e38acSHans Petter Selasky 1258dc7e38acSHans Petter Selasky if (ent) { 1259dc7e38acSHans Petter Selasky spin_lock_irq(&ent->lock); 1260dc7e38acSHans Petter Selasky if (!list_empty(&ent->head)) { 1261dc7e38acSHans Petter Selasky msg = list_entry(ent->head.next, struct mlx5_cmd_msg, 1262dc7e38acSHans Petter Selasky list); 1263dc7e38acSHans Petter Selasky list_del(&msg->list); 1264dc7e38acSHans Petter Selasky } 1265dc7e38acSHans Petter Selasky spin_unlock_irq(&ent->lock); 1266dc7e38acSHans Petter Selasky } 1267dc7e38acSHans Petter Selasky 1268dc7e38acSHans Petter Selasky if (IS_ERR(msg)) 1269dc7e38acSHans Petter Selasky msg = mlx5_alloc_cmd_msg(dev, gfp, in_size); 1270dc7e38acSHans Petter Selasky 1271dc7e38acSHans Petter Selasky return msg; 1272dc7e38acSHans Petter Selasky } 1273dc7e38acSHans Petter Selasky 1274788333d9SHans Petter Selasky static int is_manage_pages(void *in) 1275a2485fe5SHans Petter Selasky { 1276788333d9SHans Petter Selasky return MLX5_GET(mbox_in, in, opcode) == MLX5_CMD_OP_MANAGE_PAGES; 1277dc7e38acSHans Petter Selasky } 1278dc7e38acSHans Petter Selasky 127930dfc051SHans Petter Selasky static int cmd_exec_helper(struct mlx5_core_dev *dev, 128030dfc051SHans Petter Selasky void *in, int in_size, 128130dfc051SHans Petter Selasky void *out, int out_size, 1282c0902569SHans Petter Selasky mlx5_cmd_cbk_t callback, void *context, 1283c0902569SHans Petter Selasky bool force_polling) 1284dc7e38acSHans Petter Selasky { 1285dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *inb; 1286dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *outb; 1287dc7e38acSHans Petter Selasky int pages_queue; 12881d4905b5SHans Petter Selasky const gfp_t gfp = GFP_KERNEL; 1289dc7e38acSHans Petter Selasky int err; 1290dc7e38acSHans Petter Selasky u8 status = 0; 1291a2485fe5SHans Petter Selasky u32 drv_synd; 1292a2485fe5SHans Petter Selasky 1293e787b5acSHans Petter Selasky if (dev->state == MLX5_DEVICE_STATE_INTERNAL_ERROR) { 1294788333d9SHans Petter Selasky u16 opcode = MLX5_GET(mbox_in, in, opcode); 1295788333d9SHans Petter Selasky err = mlx5_internal_err_ret_value(dev, opcode, &drv_synd, &status); 1296788333d9SHans Petter Selasky MLX5_SET(mbox_out, out, status, status); 1297788333d9SHans Petter Selasky MLX5_SET(mbox_out, out, syndrome, drv_synd); 1298a2485fe5SHans Petter Selasky return err; 1299a2485fe5SHans Petter Selasky } 1300dc7e38acSHans Petter Selasky 1301dc7e38acSHans Petter Selasky pages_queue = is_manage_pages(in); 1302dc7e38acSHans Petter Selasky 1303dc7e38acSHans Petter Selasky inb = alloc_msg(dev, in_size, gfp); 1304dc7e38acSHans Petter Selasky if (IS_ERR(inb)) { 1305dc7e38acSHans Petter Selasky err = PTR_ERR(inb); 1306dc7e38acSHans Petter Selasky return err; 1307dc7e38acSHans Petter Selasky } 1308dc7e38acSHans Petter Selasky 1309dc7e38acSHans Petter Selasky err = mlx5_copy_to_msg(inb, in, in_size); 1310dc7e38acSHans Petter Selasky if (err) { 1311dc7e38acSHans Petter Selasky mlx5_core_warn(dev, "err %d\n", err); 1312dc7e38acSHans Petter Selasky goto out_in; 1313dc7e38acSHans Petter Selasky } 1314dc7e38acSHans Petter Selasky 1315dc7e38acSHans Petter Selasky outb = mlx5_alloc_cmd_msg(dev, gfp, out_size); 1316dc7e38acSHans Petter Selasky if (IS_ERR(outb)) { 1317dc7e38acSHans Petter Selasky err = PTR_ERR(outb); 1318dc7e38acSHans Petter Selasky goto out_in; 1319dc7e38acSHans Petter Selasky } 1320dc7e38acSHans Petter Selasky 13211c807f67SHans Petter Selasky err = mlx5_cmd_invoke(dev, inb, in_size, outb, out, out_size, callback, 1322c0902569SHans Petter Selasky context, pages_queue, &status, force_polling); 132397ac3908SHans Petter Selasky if (err) { 132497ac3908SHans Petter Selasky if (err == -ETIMEDOUT) 132597ac3908SHans Petter Selasky return err; 1326dc7e38acSHans Petter Selasky goto out_out; 132797ac3908SHans Petter Selasky } 1328dc7e38acSHans Petter Selasky 1329dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "err %d, status %d\n", err, status); 1330dc7e38acSHans Petter Selasky if (status) { 1331dc7e38acSHans Petter Selasky err = status_to_err(status); 1332dc7e38acSHans Petter Selasky goto out_out; 1333dc7e38acSHans Petter Selasky } 1334dc7e38acSHans Petter Selasky 1335dc7e38acSHans Petter Selasky if (callback) 1336dc7e38acSHans Petter Selasky return err; 1337dc7e38acSHans Petter Selasky 1338dc7e38acSHans Petter Selasky err = mlx5_copy_from_msg(out, outb, out_size); 1339dc7e38acSHans Petter Selasky 1340dc7e38acSHans Petter Selasky out_out: 1341dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, outb); 1342dc7e38acSHans Petter Selasky 1343dc7e38acSHans Petter Selasky out_in: 1344dc7e38acSHans Petter Selasky free_msg(dev, inb); 1345dc7e38acSHans Petter Selasky return err; 1346dc7e38acSHans Petter Selasky } 1347dc7e38acSHans Petter Selasky 1348dc7e38acSHans Petter Selasky int mlx5_cmd_exec(struct mlx5_core_dev *dev, void *in, int in_size, void *out, 1349dc7e38acSHans Petter Selasky int out_size) 1350dc7e38acSHans Petter Selasky { 1351788333d9SHans Petter Selasky int err; 1352788333d9SHans Petter Selasky 1353c0902569SHans Petter Selasky err = cmd_exec_helper(dev, in, in_size, out, out_size, NULL, NULL, false); 1354788333d9SHans Petter Selasky return err ? : mlx5_cmd_check(dev, in, out); 1355dc7e38acSHans Petter Selasky } 1356dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_exec); 1357dc7e38acSHans Petter Selasky 13587eefcb5eSHans Petter Selasky void mlx5_cmd_init_async_ctx(struct mlx5_core_dev *dev, 13597eefcb5eSHans Petter Selasky struct mlx5_async_ctx *ctx) 1360dc7e38acSHans Petter Selasky { 13617eefcb5eSHans Petter Selasky ctx->dev = dev; 13627eefcb5eSHans Petter Selasky /* Starts at 1 to avoid doing wake_up if we are not cleaning up */ 13637eefcb5eSHans Petter Selasky atomic_set(&ctx->num_inflight, 1); 13647eefcb5eSHans Petter Selasky init_waitqueue_head(&ctx->wait); 13657eefcb5eSHans Petter Selasky } 13667eefcb5eSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_init_async_ctx); 13677eefcb5eSHans Petter Selasky 13687eefcb5eSHans Petter Selasky /** 13697eefcb5eSHans Petter Selasky * mlx5_cmd_cleanup_async_ctx - Clean up an async_ctx 13707eefcb5eSHans Petter Selasky * @ctx: The ctx to clean 13717eefcb5eSHans Petter Selasky * 13727eefcb5eSHans Petter Selasky * Upon return all callbacks given to mlx5_cmd_exec_cb() have been called. The 13737eefcb5eSHans Petter Selasky * caller must ensure that mlx5_cmd_exec_cb() is not called during or after 13747eefcb5eSHans Petter Selasky * the call mlx5_cleanup_async_ctx(). 13757eefcb5eSHans Petter Selasky */ 13767eefcb5eSHans Petter Selasky void mlx5_cmd_cleanup_async_ctx(struct mlx5_async_ctx *ctx) 13777eefcb5eSHans Petter Selasky { 13787eefcb5eSHans Petter Selasky atomic_dec(&ctx->num_inflight); 13797eefcb5eSHans Petter Selasky wait_event(ctx->wait, atomic_read(&ctx->num_inflight) == 0); 13807eefcb5eSHans Petter Selasky } 13817eefcb5eSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_cleanup_async_ctx); 13827eefcb5eSHans Petter Selasky 13837eefcb5eSHans Petter Selasky static void mlx5_cmd_exec_cb_handler(int status, void *_work) 13847eefcb5eSHans Petter Selasky { 13857eefcb5eSHans Petter Selasky struct mlx5_async_work *work = _work; 13867eefcb5eSHans Petter Selasky struct mlx5_async_ctx *ctx = work->ctx; 13877eefcb5eSHans Petter Selasky 13887eefcb5eSHans Petter Selasky work->user_callback(status, work); 13897eefcb5eSHans Petter Selasky if (atomic_dec_and_test(&ctx->num_inflight)) 13907eefcb5eSHans Petter Selasky wake_up(&ctx->wait); 13917eefcb5eSHans Petter Selasky } 13927eefcb5eSHans Petter Selasky 13937eefcb5eSHans Petter Selasky int mlx5_cmd_exec_cb(struct mlx5_async_ctx *ctx, void *in, int in_size, 13947eefcb5eSHans Petter Selasky void *out, int out_size, mlx5_async_cbk_t callback, 13957eefcb5eSHans Petter Selasky struct mlx5_async_work *work) 13967eefcb5eSHans Petter Selasky { 13977eefcb5eSHans Petter Selasky int ret; 13987eefcb5eSHans Petter Selasky 13997eefcb5eSHans Petter Selasky work->ctx = ctx; 14007eefcb5eSHans Petter Selasky work->user_callback = callback; 14017eefcb5eSHans Petter Selasky if (WARN_ON(!atomic_inc_not_zero(&ctx->num_inflight))) 14027eefcb5eSHans Petter Selasky return -EIO; 14037eefcb5eSHans Petter Selasky ret = cmd_exec_helper(ctx->dev, in, in_size, out, out_size, 14047eefcb5eSHans Petter Selasky mlx5_cmd_exec_cb_handler, work, false); 14057eefcb5eSHans Petter Selasky if (ret && atomic_dec_and_test(&ctx->num_inflight)) 14067eefcb5eSHans Petter Selasky wake_up(&ctx->wait); 14077eefcb5eSHans Petter Selasky 14087eefcb5eSHans Petter Selasky return ret; 1409dc7e38acSHans Petter Selasky } 1410dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_exec_cb); 1411dc7e38acSHans Petter Selasky 1412c0902569SHans Petter Selasky int mlx5_cmd_exec_polling(struct mlx5_core_dev *dev, void *in, int in_size, 1413c0902569SHans Petter Selasky void *out, int out_size) 1414c0902569SHans Petter Selasky { 1415c0902569SHans Petter Selasky int err; 1416c0902569SHans Petter Selasky 1417c0902569SHans Petter Selasky err = cmd_exec_helper(dev, in, in_size, out, out_size, NULL, NULL, true); 1418c0902569SHans Petter Selasky return err ? : mlx5_cmd_check(dev, in, out); 1419c0902569SHans Petter Selasky } 1420c0902569SHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_exec_polling); 1421c0902569SHans Petter Selasky 1422dc7e38acSHans Petter Selasky static void destroy_msg_cache(struct mlx5_core_dev *dev) 1423dc7e38acSHans Petter Selasky { 1424dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1425dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg; 1426dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *n; 1427dc7e38acSHans Petter Selasky 1428dc7e38acSHans Petter Selasky list_for_each_entry_safe(msg, n, &cmd->cache.large.head, list) { 1429dc7e38acSHans Petter Selasky list_del(&msg->list); 1430dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, msg); 1431dc7e38acSHans Petter Selasky } 1432dc7e38acSHans Petter Selasky 1433dc7e38acSHans Petter Selasky list_for_each_entry_safe(msg, n, &cmd->cache.med.head, list) { 1434dc7e38acSHans Petter Selasky list_del(&msg->list); 1435dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, msg); 1436dc7e38acSHans Petter Selasky } 1437dc7e38acSHans Petter Selasky } 1438dc7e38acSHans Petter Selasky 1439dc7e38acSHans Petter Selasky static int create_msg_cache(struct mlx5_core_dev *dev) 1440dc7e38acSHans Petter Selasky { 1441dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1442dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg; 1443dc7e38acSHans Petter Selasky int err; 1444dc7e38acSHans Petter Selasky int i; 1445dc7e38acSHans Petter Selasky 1446dc7e38acSHans Petter Selasky spin_lock_init(&cmd->cache.large.lock); 1447dc7e38acSHans Petter Selasky INIT_LIST_HEAD(&cmd->cache.large.head); 1448dc7e38acSHans Petter Selasky spin_lock_init(&cmd->cache.med.lock); 1449dc7e38acSHans Petter Selasky INIT_LIST_HEAD(&cmd->cache.med.head); 1450dc7e38acSHans Petter Selasky 1451dc7e38acSHans Petter Selasky for (i = 0; i < NUM_LONG_LISTS; i++) { 1452dc7e38acSHans Petter Selasky msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, LONG_LIST_SIZE); 1453dc7e38acSHans Petter Selasky if (IS_ERR(msg)) { 1454dc7e38acSHans Petter Selasky err = PTR_ERR(msg); 1455dc7e38acSHans Petter Selasky goto ex_err; 1456dc7e38acSHans Petter Selasky } 1457dc7e38acSHans Petter Selasky msg->cache = &cmd->cache.large; 1458dc7e38acSHans Petter Selasky list_add_tail(&msg->list, &cmd->cache.large.head); 1459dc7e38acSHans Petter Selasky } 1460dc7e38acSHans Petter Selasky 1461dc7e38acSHans Petter Selasky for (i = 0; i < NUM_MED_LISTS; i++) { 1462dc7e38acSHans Petter Selasky msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, MED_LIST_SIZE); 1463dc7e38acSHans Petter Selasky if (IS_ERR(msg)) { 1464dc7e38acSHans Petter Selasky err = PTR_ERR(msg); 1465dc7e38acSHans Petter Selasky goto ex_err; 1466dc7e38acSHans Petter Selasky } 1467dc7e38acSHans Petter Selasky msg->cache = &cmd->cache.med; 1468dc7e38acSHans Petter Selasky list_add_tail(&msg->list, &cmd->cache.med.head); 1469dc7e38acSHans Petter Selasky } 1470dc7e38acSHans Petter Selasky 1471dc7e38acSHans Petter Selasky return 0; 1472dc7e38acSHans Petter Selasky 1473dc7e38acSHans Petter Selasky ex_err: 1474dc7e38acSHans Petter Selasky destroy_msg_cache(dev); 1475dc7e38acSHans Petter Selasky return err; 1476dc7e38acSHans Petter Selasky } 1477dc7e38acSHans Petter Selasky 14781c807f67SHans Petter Selasky static int 14791c807f67SHans Petter Selasky alloc_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd) 1480dc7e38acSHans Petter Selasky { 14811c807f67SHans Petter Selasky int err; 1482dc7e38acSHans Petter Selasky 14831c807f67SHans Petter Selasky sx_init(&cmd->dma_sx, "MLX5-DMA-SX"); 14841c807f67SHans Petter Selasky mtx_init(&cmd->dma_mtx, "MLX5-DMA-MTX", NULL, MTX_DEF); 14851c807f67SHans Petter Selasky cv_init(&cmd->dma_cv, "MLX5-DMA-CV"); 14861c807f67SHans Petter Selasky 14871c807f67SHans Petter Selasky /* 14881c807f67SHans Petter Selasky * Create global DMA descriptor tag for allocating 14891c807f67SHans Petter Selasky * 4K firmware pages: 14901c807f67SHans Petter Selasky */ 14911c807f67SHans Petter Selasky err = -bus_dma_tag_create( 14921c807f67SHans Petter Selasky bus_get_dma_tag(dev->pdev->dev.bsddev), 14931c807f67SHans Petter Selasky MLX5_ADAPTER_PAGE_SIZE, /* alignment */ 14941c807f67SHans Petter Selasky 0, /* no boundary */ 14951c807f67SHans Petter Selasky BUS_SPACE_MAXADDR, /* lowaddr */ 14961c807f67SHans Petter Selasky BUS_SPACE_MAXADDR, /* highaddr */ 14971c807f67SHans Petter Selasky NULL, NULL, /* filter, filterarg */ 14981c807f67SHans Petter Selasky MLX5_ADAPTER_PAGE_SIZE, /* maxsize */ 14991c807f67SHans Petter Selasky 1, /* nsegments */ 15001c807f67SHans Petter Selasky MLX5_ADAPTER_PAGE_SIZE, /* maxsegsize */ 15011c807f67SHans Petter Selasky 0, /* flags */ 15021c807f67SHans Petter Selasky NULL, NULL, /* lockfunc, lockfuncarg */ 15031c807f67SHans Petter Selasky &cmd->dma_tag); 15041c807f67SHans Petter Selasky if (err != 0) 15051c807f67SHans Petter Selasky goto failure_destroy_sx; 15061c807f67SHans Petter Selasky 15071c807f67SHans Petter Selasky cmd->cmd_page = mlx5_fwp_alloc(dev, GFP_KERNEL, 1); 15081c807f67SHans Petter Selasky if (cmd->cmd_page == NULL) { 15091c807f67SHans Petter Selasky err = -ENOMEM; 15101c807f67SHans Petter Selasky goto failure_alloc_page; 15111c807f67SHans Petter Selasky } 15121c807f67SHans Petter Selasky cmd->dma = mlx5_fwp_get_dma(cmd->cmd_page, 0); 15131c807f67SHans Petter Selasky cmd->cmd_buf = mlx5_fwp_get_virt(cmd->cmd_page, 0); 15141c807f67SHans Petter Selasky return (0); 15151c807f67SHans Petter Selasky 15161c807f67SHans Petter Selasky failure_alloc_page: 15171c807f67SHans Petter Selasky bus_dma_tag_destroy(cmd->dma_tag); 15181c807f67SHans Petter Selasky 15191c807f67SHans Petter Selasky failure_destroy_sx: 15201c807f67SHans Petter Selasky cv_destroy(&cmd->dma_cv); 15211c807f67SHans Petter Selasky mtx_destroy(&cmd->dma_mtx); 15221c807f67SHans Petter Selasky sx_destroy(&cmd->dma_sx); 15231c807f67SHans Petter Selasky return (err); 1524dc7e38acSHans Petter Selasky } 1525dc7e38acSHans Petter Selasky 15261c807f67SHans Petter Selasky static void 15271c807f67SHans Petter Selasky free_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd) 1528dc7e38acSHans Petter Selasky { 15291c807f67SHans Petter Selasky 15301c807f67SHans Petter Selasky mlx5_fwp_free(cmd->cmd_page); 15311c807f67SHans Petter Selasky bus_dma_tag_destroy(cmd->dma_tag); 15321c807f67SHans Petter Selasky cv_destroy(&cmd->dma_cv); 15331c807f67SHans Petter Selasky mtx_destroy(&cmd->dma_mtx); 15341c807f67SHans Petter Selasky sx_destroy(&cmd->dma_sx); 1535dc7e38acSHans Petter Selasky } 1536dc7e38acSHans Petter Selasky 1537dc7e38acSHans Petter Selasky int mlx5_cmd_init(struct mlx5_core_dev *dev) 1538dc7e38acSHans Petter Selasky { 1539dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1540dc7e38acSHans Petter Selasky u32 cmd_h, cmd_l; 1541dc7e38acSHans Petter Selasky u16 cmd_if_rev; 1542dc7e38acSHans Petter Selasky int err; 1543dc7e38acSHans Petter Selasky int i; 1544dc7e38acSHans Petter Selasky 1545a2485fe5SHans Petter Selasky memset(cmd, 0, sizeof(*cmd)); 1546dc7e38acSHans Petter Selasky cmd_if_rev = cmdif_rev_get(dev); 1547dc7e38acSHans Petter Selasky if (cmd_if_rev != CMD_IF_REV) { 1548a2f4f59cSHans Petter Selasky mlx5_core_err(dev, 1549a2f4f59cSHans Petter Selasky "Driver cmdif rev(%d) differs from firmware's(%d)\n", 1550a2f4f59cSHans Petter Selasky CMD_IF_REV, cmd_if_rev); 1551dc7e38acSHans Petter Selasky return -EINVAL; 1552dc7e38acSHans Petter Selasky } 1553dc7e38acSHans Petter Selasky 1554dc7e38acSHans Petter Selasky err = alloc_cmd_page(dev, cmd); 1555dc7e38acSHans Petter Selasky if (err) 1556dc7e38acSHans Petter Selasky goto err_free_pool; 1557dc7e38acSHans Petter Selasky 1558dc7e38acSHans Petter Selasky cmd_l = ioread32be(&dev->iseg->cmdq_addr_l_sz) & 0xff; 1559dc7e38acSHans Petter Selasky cmd->log_sz = cmd_l >> 4 & 0xf; 1560dc7e38acSHans Petter Selasky cmd->log_stride = cmd_l & 0xf; 1561dc7e38acSHans Petter Selasky if (1 << cmd->log_sz > MLX5_MAX_COMMANDS) { 1562a2f4f59cSHans Petter Selasky mlx5_core_err(dev, 1563a2f4f59cSHans Petter Selasky "firmware reports too many outstanding commands %d\n", 1564a2f4f59cSHans Petter Selasky 1 << cmd->log_sz); 1565dc7e38acSHans Petter Selasky err = -EINVAL; 1566dc7e38acSHans Petter Selasky goto err_free_page; 1567dc7e38acSHans Petter Selasky } 1568dc7e38acSHans Petter Selasky 1569dc7e38acSHans Petter Selasky if (cmd->log_sz + cmd->log_stride > MLX5_ADAPTER_PAGE_SHIFT) { 1570a2f4f59cSHans Petter Selasky mlx5_core_err(dev, 1571a2f4f59cSHans Petter Selasky "command queue size overflow\n"); 1572dc7e38acSHans Petter Selasky err = -EINVAL; 1573dc7e38acSHans Petter Selasky goto err_free_page; 1574dc7e38acSHans Petter Selasky } 1575dc7e38acSHans Petter Selasky 1576dc7e38acSHans Petter Selasky cmd->checksum_disabled = 1; 1577dc7e38acSHans Petter Selasky cmd->max_reg_cmds = (1 << cmd->log_sz) - 1; 1578dc7e38acSHans Petter Selasky cmd->bitmask = (1 << cmd->max_reg_cmds) - 1; 1579dc7e38acSHans Petter Selasky 1580dc7e38acSHans Petter Selasky cmd->cmdif_rev = ioread32be(&dev->iseg->cmdif_rev_fw_sub) >> 16; 1581dc7e38acSHans Petter Selasky if (cmd->cmdif_rev > CMD_IF_REV) { 1582a2f4f59cSHans Petter Selasky mlx5_core_err(dev, 1583a2f4f59cSHans Petter Selasky "driver does not support command interface version. driver %d, firmware %d\n", 1584a2f4f59cSHans Petter Selasky CMD_IF_REV, cmd->cmdif_rev); 1585dc7e38acSHans Petter Selasky err = -ENOTSUPP; 1586dc7e38acSHans Petter Selasky goto err_free_page; 1587dc7e38acSHans Petter Selasky } 1588dc7e38acSHans Petter Selasky 1589dc7e38acSHans Petter Selasky spin_lock_init(&cmd->alloc_lock); 1590dc7e38acSHans Petter Selasky spin_lock_init(&cmd->token_lock); 1591dc7e38acSHans Petter Selasky for (i = 0; i < ARRAY_SIZE(cmd->stats); i++) 1592dc7e38acSHans Petter Selasky spin_lock_init(&cmd->stats[i].lock); 1593dc7e38acSHans Petter Selasky 1594dc7e38acSHans Petter Selasky sema_init(&cmd->sem, cmd->max_reg_cmds); 1595dc7e38acSHans Petter Selasky sema_init(&cmd->pages_sem, 1); 1596dc7e38acSHans Petter Selasky 1597dc7e38acSHans Petter Selasky cmd_h = (u32)((u64)(cmd->dma) >> 32); 1598dc7e38acSHans Petter Selasky cmd_l = (u32)(cmd->dma); 1599dc7e38acSHans Petter Selasky if (cmd_l & 0xfff) { 1600a2f4f59cSHans Petter Selasky mlx5_core_err(dev, "invalid command queue address\n"); 1601dc7e38acSHans Petter Selasky err = -ENOMEM; 1602dc7e38acSHans Petter Selasky goto err_free_page; 1603dc7e38acSHans Petter Selasky } 1604dc7e38acSHans Petter Selasky 1605dc7e38acSHans Petter Selasky iowrite32be(cmd_h, &dev->iseg->cmdq_addr_h); 1606dc7e38acSHans Petter Selasky iowrite32be(cmd_l, &dev->iseg->cmdq_addr_l_sz); 1607dc7e38acSHans Petter Selasky 1608dc7e38acSHans Petter Selasky /* Make sure firmware sees the complete address before we proceed */ 1609dc7e38acSHans Petter Selasky wmb(); 1610dc7e38acSHans Petter Selasky 1611dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "descriptor at dma 0x%llx\n", (unsigned long long)(cmd->dma)); 1612dc7e38acSHans Petter Selasky 1613721a1a6aSSlava Shwartsman cmd->mode = MLX5_CMD_MODE_POLLING; 1614dc7e38acSHans Petter Selasky 1615dc7e38acSHans Petter Selasky err = create_msg_cache(dev); 1616dc7e38acSHans Petter Selasky if (err) { 1617a2f4f59cSHans Petter Selasky mlx5_core_err(dev, "failed to create command cache\n"); 1618dc7e38acSHans Petter Selasky goto err_free_page; 1619dc7e38acSHans Petter Selasky } 1620dc7e38acSHans Petter Selasky return 0; 1621dc7e38acSHans Petter Selasky 1622dc7e38acSHans Petter Selasky err_free_page: 1623dc7e38acSHans Petter Selasky free_cmd_page(dev, cmd); 1624dc7e38acSHans Petter Selasky 1625dc7e38acSHans Petter Selasky err_free_pool: 1626dc7e38acSHans Petter Selasky return err; 1627dc7e38acSHans Petter Selasky } 1628dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_init); 1629dc7e38acSHans Petter Selasky 1630dc7e38acSHans Petter Selasky void mlx5_cmd_cleanup(struct mlx5_core_dev *dev) 1631dc7e38acSHans Petter Selasky { 1632dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1633dc7e38acSHans Petter Selasky 1634dc7e38acSHans Petter Selasky clean_debug_files(dev); 16358d1eeedbSHans Petter Selasky flush_workqueue(dev->priv.health.wq_cmd); 1636dc7e38acSHans Petter Selasky destroy_msg_cache(dev); 1637dc7e38acSHans Petter Selasky free_cmd_page(dev, cmd); 1638dc7e38acSHans Petter Selasky } 1639dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_cleanup); 1640118063fbSHans Petter Selasky 1641118063fbSHans Petter Selasky int mlx5_cmd_query_cong_counter(struct mlx5_core_dev *dev, 1642118063fbSHans Petter Selasky bool reset, void *out, int out_size) 1643118063fbSHans Petter Selasky { 1644118063fbSHans Petter Selasky u32 in[MLX5_ST_SZ_DW(query_cong_statistics_in)] = { }; 1645118063fbSHans Petter Selasky 1646118063fbSHans Petter Selasky MLX5_SET(query_cong_statistics_in, in, opcode, 1647118063fbSHans Petter Selasky MLX5_CMD_OP_QUERY_CONG_STATISTICS); 1648118063fbSHans Petter Selasky MLX5_SET(query_cong_statistics_in, in, clear, reset); 1649118063fbSHans Petter Selasky return mlx5_cmd_exec(dev, in, sizeof(in), out, out_size); 1650118063fbSHans Petter Selasky } 1651118063fbSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_query_cong_counter); 1652118063fbSHans Petter Selasky 1653118063fbSHans Petter Selasky int mlx5_cmd_query_cong_params(struct mlx5_core_dev *dev, int cong_point, 1654118063fbSHans Petter Selasky void *out, int out_size) 1655118063fbSHans Petter Selasky { 1656118063fbSHans Petter Selasky u32 in[MLX5_ST_SZ_DW(query_cong_params_in)] = { }; 1657118063fbSHans Petter Selasky 1658118063fbSHans Petter Selasky MLX5_SET(query_cong_params_in, in, opcode, 1659118063fbSHans Petter Selasky MLX5_CMD_OP_QUERY_CONG_PARAMS); 1660118063fbSHans Petter Selasky MLX5_SET(query_cong_params_in, in, cong_protocol, cong_point); 1661118063fbSHans Petter Selasky 1662118063fbSHans Petter Selasky return mlx5_cmd_exec(dev, in, sizeof(in), out, out_size); 1663118063fbSHans Petter Selasky } 1664118063fbSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_query_cong_params); 1665118063fbSHans Petter Selasky 1666118063fbSHans Petter Selasky int mlx5_cmd_modify_cong_params(struct mlx5_core_dev *dev, 1667118063fbSHans Petter Selasky void *in, int in_size) 1668118063fbSHans Petter Selasky { 1669118063fbSHans Petter Selasky u32 out[MLX5_ST_SZ_DW(modify_cong_params_out)] = { }; 1670118063fbSHans Petter Selasky 1671118063fbSHans Petter Selasky return mlx5_cmd_exec(dev, in, in_size, out, sizeof(out)); 1672118063fbSHans Petter Selasky } 1673118063fbSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_modify_cong_params); 16748abf5ac0SHans Petter Selasky 16758abf5ac0SHans Petter Selasky int mlx5_cmd_query_cong_status(struct mlx5_core_dev *dev, int cong_point, 16768abf5ac0SHans Petter Selasky int prio, void *out, int out_size) 16778abf5ac0SHans Petter Selasky { 16788abf5ac0SHans Petter Selasky u32 in[MLX5_ST_SZ_DW(query_cong_status_in)] = { }; 16798abf5ac0SHans Petter Selasky 16808abf5ac0SHans Petter Selasky MLX5_SET(query_cong_status_in, in, opcode, 16818abf5ac0SHans Petter Selasky MLX5_CMD_OP_QUERY_CONG_STATUS); 16828abf5ac0SHans Petter Selasky MLX5_SET(query_cong_status_in, in, priority, prio); 16838abf5ac0SHans Petter Selasky MLX5_SET(query_cong_status_in, in, cong_protocol, cong_point); 16848abf5ac0SHans Petter Selasky 16858abf5ac0SHans Petter Selasky return mlx5_cmd_exec(dev, in, sizeof(in), out, out_size); 16868abf5ac0SHans Petter Selasky } 16878abf5ac0SHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_query_cong_status); 16888abf5ac0SHans Petter Selasky 16898abf5ac0SHans Petter Selasky int mlx5_cmd_modify_cong_status(struct mlx5_core_dev *dev, 16908abf5ac0SHans Petter Selasky void *in, int in_size) 16918abf5ac0SHans Petter Selasky { 16928abf5ac0SHans Petter Selasky u32 out[MLX5_ST_SZ_DW(modify_cong_status_out)] = { }; 16938abf5ac0SHans Petter Selasky 16948abf5ac0SHans Petter Selasky return mlx5_cmd_exec(dev, in, in_size, out, sizeof(out)); 16958abf5ac0SHans Petter Selasky } 16968abf5ac0SHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_modify_cong_status); 1697