1dc7e38acSHans Petter Selasky /*- 21c807f67SHans Petter Selasky * Copyright (c) 2013-2017, 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 28dc7e38acSHans Petter Selasky #include <linux/module.h> 29dc7e38acSHans Petter Selasky #include <linux/errno.h> 30dc7e38acSHans Petter Selasky #include <linux/pci.h> 31dc7e38acSHans Petter Selasky #include <linux/dma-mapping.h> 32dc7e38acSHans Petter Selasky #include <linux/slab.h> 33dc7e38acSHans Petter Selasky #include <linux/delay.h> 34dc7e38acSHans Petter Selasky #include <linux/random.h> 35dc7e38acSHans Petter Selasky #include <linux/io-mapping.h> 36dc7e38acSHans Petter Selasky #include <linux/hardirq.h> 37dc7e38acSHans Petter Selasky #include <linux/ktime.h> 38dc7e38acSHans Petter Selasky #include <dev/mlx5/driver.h> 39dc7e38acSHans Petter Selasky 40dc7e38acSHans Petter Selasky #include "mlx5_core.h" 41dc7e38acSHans Petter Selasky 428e7e0ce1SHans Petter Selasky static int mlx5_copy_from_msg(void *to, struct mlx5_cmd_msg *from, int size); 438e7e0ce1SHans Petter Selasky static void mlx5_free_cmd_msg(struct mlx5_core_dev *dev, 448e7e0ce1SHans Petter Selasky struct mlx5_cmd_msg *msg); 458e7e0ce1SHans Petter Selasky static void free_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg); 468e7e0ce1SHans Petter Selasky 47dc7e38acSHans Petter Selasky enum { 48dc7e38acSHans Petter Selasky CMD_IF_REV = 5, 49dc7e38acSHans Petter Selasky }; 50dc7e38acSHans Petter Selasky 51dc7e38acSHans Petter Selasky enum { 52dc7e38acSHans Petter Selasky CMD_MODE_POLLING, 53dc7e38acSHans Petter Selasky CMD_MODE_EVENTS 54dc7e38acSHans Petter Selasky }; 55dc7e38acSHans Petter Selasky 56dc7e38acSHans Petter Selasky enum { 57dc7e38acSHans Petter Selasky NUM_LONG_LISTS = 2, 58dc7e38acSHans Petter Selasky NUM_MED_LISTS = 64, 59dc7e38acSHans Petter Selasky LONG_LIST_SIZE = (2ULL * 1024 * 1024 * 1024 / PAGE_SIZE) * 8 + 16 + 60dc7e38acSHans Petter Selasky MLX5_CMD_DATA_BLOCK_SIZE, 61dc7e38acSHans Petter Selasky MED_LIST_SIZE = 16 + MLX5_CMD_DATA_BLOCK_SIZE, 62dc7e38acSHans Petter Selasky }; 63dc7e38acSHans Petter Selasky 64dc7e38acSHans Petter Selasky enum { 65dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_OK = 0x0, 66dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_SIGNAT_ERR = 0x1, 67dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_TOK_ERR = 0x2, 68dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_BAD_BLK_NUM_ERR = 0x3, 69dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_OUT_PTR_ALIGN_ERR = 0x4, 70dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_IN_PTR_ALIGN_ERR = 0x5, 71dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_FW_ERR = 0x6, 72dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_IN_LENGTH_ERR = 0x7, 73dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_OUT_LENGTH_ERR = 0x8, 74dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_RES_FLD_NOT_CLR_ERR = 0x9, 75dc7e38acSHans Petter Selasky MLX5_CMD_DELIVERY_STAT_CMD_DESCR_ERR = 0x10, 76dc7e38acSHans Petter Selasky }; 77dc7e38acSHans Petter Selasky 78dc7e38acSHans Petter Selasky static struct mlx5_cmd_work_ent *alloc_cmd(struct mlx5_cmd *cmd, 79dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *in, 801c807f67SHans Petter Selasky int uin_size, 81dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *out, 82dc7e38acSHans Petter Selasky void *uout, int uout_size, 83dc7e38acSHans Petter Selasky mlx5_cmd_cbk_t cbk, 84dc7e38acSHans Petter Selasky void *context, int page_queue) 85dc7e38acSHans Petter Selasky { 86dc7e38acSHans Petter Selasky gfp_t alloc_flags = cbk ? GFP_ATOMIC : GFP_KERNEL; 87dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent; 88dc7e38acSHans Petter Selasky 89dc7e38acSHans Petter Selasky ent = kzalloc(sizeof(*ent), alloc_flags); 90dc7e38acSHans Petter Selasky if (!ent) 91dc7e38acSHans Petter Selasky return ERR_PTR(-ENOMEM); 92dc7e38acSHans Petter Selasky 93dc7e38acSHans Petter Selasky ent->in = in; 941c807f67SHans Petter Selasky ent->uin_size = uin_size; 95dc7e38acSHans Petter Selasky ent->out = out; 96dc7e38acSHans Petter Selasky ent->uout = uout; 97dc7e38acSHans Petter Selasky ent->uout_size = uout_size; 98dc7e38acSHans Petter Selasky ent->callback = cbk; 99dc7e38acSHans Petter Selasky ent->context = context; 100dc7e38acSHans Petter Selasky ent->cmd = cmd; 101dc7e38acSHans Petter Selasky ent->page_queue = page_queue; 102dc7e38acSHans Petter Selasky 103dc7e38acSHans Petter Selasky return ent; 104dc7e38acSHans Petter Selasky } 105dc7e38acSHans Petter Selasky 106dc7e38acSHans Petter Selasky static u8 alloc_token(struct mlx5_cmd *cmd) 107dc7e38acSHans Petter Selasky { 108dc7e38acSHans Petter Selasky u8 token; 109dc7e38acSHans Petter Selasky 110dc7e38acSHans Petter Selasky spin_lock(&cmd->token_lock); 111dc7e38acSHans Petter Selasky cmd->token++; 112dc7e38acSHans Petter Selasky if (cmd->token == 0) 113dc7e38acSHans Petter Selasky cmd->token++; 114dc7e38acSHans Petter Selasky token = cmd->token; 115dc7e38acSHans Petter Selasky spin_unlock(&cmd->token_lock); 116dc7e38acSHans Petter Selasky 117dc7e38acSHans Petter Selasky return token; 118dc7e38acSHans Petter Selasky } 119dc7e38acSHans Petter Selasky 1208e7e0ce1SHans Petter Selasky static int alloc_ent(struct mlx5_cmd_work_ent *ent) 121dc7e38acSHans Petter Selasky { 122dc7e38acSHans Petter Selasky unsigned long flags; 1238e7e0ce1SHans Petter Selasky struct mlx5_cmd *cmd = ent->cmd; 12430dfc051SHans Petter Selasky struct mlx5_core_dev *dev = 12530dfc051SHans Petter Selasky container_of(cmd, struct mlx5_core_dev, cmd); 1268e7e0ce1SHans Petter Selasky int ret = cmd->max_reg_cmds; 127dc7e38acSHans Petter Selasky 128dc7e38acSHans Petter Selasky spin_lock_irqsave(&cmd->alloc_lock, flags); 1298e7e0ce1SHans Petter Selasky if (!ent->page_queue) { 130dc7e38acSHans Petter Selasky ret = find_first_bit(&cmd->bitmask, cmd->max_reg_cmds); 1318e7e0ce1SHans Petter Selasky if (ret >= cmd->max_reg_cmds) 1328e7e0ce1SHans Petter Selasky ret = -1; 1338e7e0ce1SHans Petter Selasky } 1348e7e0ce1SHans Petter Selasky 13530dfc051SHans Petter Selasky if (dev->state != MLX5_DEVICE_STATE_UP) 13630dfc051SHans Petter Selasky ret = -1; 13730dfc051SHans Petter Selasky 1388e7e0ce1SHans Petter Selasky if (ret != -1) { 13930dfc051SHans Petter Selasky ent->busy = 1; 1408e7e0ce1SHans Petter Selasky ent->idx = ret; 1418e7e0ce1SHans Petter Selasky clear_bit(ent->idx, &cmd->bitmask); 1428e7e0ce1SHans Petter Selasky cmd->ent_arr[ent->idx] = ent; 1438e7e0ce1SHans Petter Selasky } 144dc7e38acSHans Petter Selasky spin_unlock_irqrestore(&cmd->alloc_lock, flags); 145dc7e38acSHans Petter Selasky 1468e7e0ce1SHans Petter Selasky return ret; 147dc7e38acSHans Petter Selasky } 148dc7e38acSHans Petter Selasky 149dc7e38acSHans Petter Selasky static void free_ent(struct mlx5_cmd *cmd, int idx) 150dc7e38acSHans Petter Selasky { 151dc7e38acSHans Petter Selasky unsigned long flags; 152dc7e38acSHans Petter Selasky 153dc7e38acSHans Petter Selasky spin_lock_irqsave(&cmd->alloc_lock, flags); 154dc7e38acSHans Petter Selasky set_bit(idx, &cmd->bitmask); 155dc7e38acSHans Petter Selasky spin_unlock_irqrestore(&cmd->alloc_lock, flags); 156dc7e38acSHans Petter Selasky } 157dc7e38acSHans Petter Selasky 158dc7e38acSHans Petter Selasky static struct mlx5_cmd_layout *get_inst(struct mlx5_cmd *cmd, int idx) 159dc7e38acSHans Petter Selasky { 160dc7e38acSHans Petter Selasky return cmd->cmd_buf + (idx << cmd->log_stride); 161dc7e38acSHans Petter Selasky } 162dc7e38acSHans Petter Selasky 163dc7e38acSHans Petter Selasky static u8 xor8_buf(void *buf, int len) 164dc7e38acSHans Petter Selasky { 165dc7e38acSHans Petter Selasky u8 *ptr = buf; 166dc7e38acSHans Petter Selasky u8 sum = 0; 167dc7e38acSHans Petter Selasky int i; 168dc7e38acSHans Petter Selasky 169dc7e38acSHans Petter Selasky for (i = 0; i < len; i++) 170dc7e38acSHans Petter Selasky sum ^= ptr[i]; 171dc7e38acSHans Petter Selasky 172dc7e38acSHans Petter Selasky return sum; 173dc7e38acSHans Petter Selasky } 174dc7e38acSHans Petter Selasky 175dc7e38acSHans Petter Selasky static int verify_block_sig(struct mlx5_cmd_prot_block *block) 176dc7e38acSHans Petter Selasky { 177dc7e38acSHans Petter Selasky if (xor8_buf(block->rsvd0, sizeof(*block) - sizeof(block->data) - 1) != 0xff) 178dc7e38acSHans Petter Selasky return -EINVAL; 179dc7e38acSHans Petter Selasky 180dc7e38acSHans Petter Selasky if (xor8_buf(block, sizeof(*block)) != 0xff) 181dc7e38acSHans Petter Selasky return -EINVAL; 182dc7e38acSHans Petter Selasky 183dc7e38acSHans Petter Selasky return 0; 184dc7e38acSHans Petter Selasky } 185dc7e38acSHans Petter Selasky 186dc7e38acSHans Petter Selasky static void calc_block_sig(struct mlx5_cmd_prot_block *block, u8 token, 187dc7e38acSHans Petter Selasky int csum) 188dc7e38acSHans Petter Selasky { 189dc7e38acSHans Petter Selasky block->token = token; 190dc7e38acSHans Petter Selasky if (csum) { 191dc7e38acSHans Petter Selasky block->ctrl_sig = ~xor8_buf(block->rsvd0, sizeof(*block) - 192dc7e38acSHans Petter Selasky sizeof(block->data) - 2); 193dc7e38acSHans Petter Selasky block->sig = ~xor8_buf(block, sizeof(*block) - 1); 194dc7e38acSHans Petter Selasky } 195dc7e38acSHans Petter Selasky } 196dc7e38acSHans Petter Selasky 1971c807f67SHans Petter Selasky static void 1981c807f67SHans Petter Selasky calc_chain_sig(struct mlx5_cmd_msg *msg, u8 token, int csum) 199dc7e38acSHans Petter Selasky { 2001c807f67SHans Petter Selasky size_t i; 201dc7e38acSHans Petter Selasky 2021c807f67SHans Petter Selasky for (i = 0; i != (msg->numpages * MLX5_NUM_CMDS_IN_ADAPTER_PAGE); i++) { 2031c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block; 2041c807f67SHans Petter Selasky 2051c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE); 2061c807f67SHans Petter Selasky 2071c807f67SHans Petter Selasky /* compute signature */ 2081c807f67SHans Petter Selasky calc_block_sig(block, token, csum); 2091c807f67SHans Petter Selasky 2101c807f67SHans Petter Selasky /* check for last block */ 2111c807f67SHans Petter Selasky if (block->next == 0) 2121c807f67SHans Petter Selasky break; 213dc7e38acSHans Petter Selasky } 2141c807f67SHans Petter Selasky 2151c807f67SHans Petter Selasky /* make sure data gets written to RAM */ 2161c807f67SHans Petter Selasky mlx5_fwp_flush(msg); 217dc7e38acSHans Petter Selasky } 218dc7e38acSHans Petter Selasky 219dc7e38acSHans Petter Selasky static void set_signature(struct mlx5_cmd_work_ent *ent, int csum) 220dc7e38acSHans Petter Selasky { 221dc7e38acSHans Petter Selasky ent->lay->sig = ~xor8_buf(ent->lay, sizeof(*ent->lay)); 222dc7e38acSHans Petter Selasky calc_chain_sig(ent->in, ent->token, csum); 223dc7e38acSHans Petter Selasky calc_chain_sig(ent->out, ent->token, csum); 224dc7e38acSHans Petter Selasky } 225dc7e38acSHans Petter Selasky 226dc7e38acSHans Petter Selasky static void poll_timeout(struct mlx5_cmd_work_ent *ent) 227dc7e38acSHans Petter Selasky { 22830dfc051SHans Petter Selasky struct mlx5_core_dev *dev = container_of(ent->cmd, 22930dfc051SHans Petter Selasky struct mlx5_core_dev, cmd); 23030dfc051SHans Petter Selasky int poll_end = jiffies + 23130dfc051SHans Petter Selasky msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC + 1000); 232dc7e38acSHans Petter Selasky u8 own; 233dc7e38acSHans Petter Selasky 234dc7e38acSHans Petter Selasky do { 235dc7e38acSHans Petter Selasky own = ent->lay->status_own; 23630dfc051SHans Petter Selasky if (!(own & CMD_OWNER_HW) || 23730dfc051SHans Petter Selasky dev->state != MLX5_DEVICE_STATE_UP) { 238dc7e38acSHans Petter Selasky ent->ret = 0; 239dc7e38acSHans Petter Selasky return; 240dc7e38acSHans Petter Selasky } 241dc7e38acSHans Petter Selasky usleep_range(5000, 10000); 242dc7e38acSHans Petter Selasky } while (time_before(jiffies, poll_end)); 243dc7e38acSHans Petter Selasky 244dc7e38acSHans Petter Selasky ent->ret = -ETIMEDOUT; 245dc7e38acSHans Petter Selasky } 246dc7e38acSHans Petter Selasky 247dc7e38acSHans Petter Selasky static void free_cmd(struct mlx5_cmd_work_ent *ent) 248dc7e38acSHans Petter Selasky { 24911546d06SHans Petter Selasky cancel_delayed_work_sync(&ent->cb_timeout_work); 250dc7e38acSHans Petter Selasky kfree(ent); 251dc7e38acSHans Petter Selasky } 252dc7e38acSHans Petter Selasky 2531c807f67SHans Petter Selasky static int 2541c807f67SHans Petter Selasky verify_signature(struct mlx5_cmd_work_ent *ent) 255dc7e38acSHans Petter Selasky { 2561c807f67SHans Petter Selasky struct mlx5_cmd_msg *msg = ent->out; 2571c807f67SHans Petter Selasky size_t i; 258dc7e38acSHans Petter Selasky int err; 259dc7e38acSHans Petter Selasky u8 sig; 260dc7e38acSHans Petter Selasky 261dc7e38acSHans Petter Selasky sig = xor8_buf(ent->lay, sizeof(*ent->lay)); 262dc7e38acSHans Petter Selasky if (sig != 0xff) 263dc7e38acSHans Petter Selasky return -EINVAL; 264dc7e38acSHans Petter Selasky 2651c807f67SHans Petter Selasky for (i = 0; i != (msg->numpages * MLX5_NUM_CMDS_IN_ADAPTER_PAGE); i++) { 2661c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block; 267dc7e38acSHans Petter Selasky 2681c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE); 2691c807f67SHans Petter Selasky 2701c807f67SHans Petter Selasky /* compute signature */ 2711c807f67SHans Petter Selasky err = verify_block_sig(block); 2721c807f67SHans Petter Selasky if (err != 0) 2731c807f67SHans Petter Selasky return (err); 2741c807f67SHans Petter Selasky 2751c807f67SHans Petter Selasky /* check for last block */ 2761c807f67SHans Petter Selasky if (block->next == 0) 2771c807f67SHans Petter Selasky break; 278dc7e38acSHans Petter Selasky } 2791c807f67SHans Petter Selasky return (0); 280dc7e38acSHans Petter Selasky } 281dc7e38acSHans Petter Selasky 282dc7e38acSHans Petter Selasky static void dump_buf(void *buf, int size, int data_only, int offset) 283dc7e38acSHans Petter Selasky { 284dc7e38acSHans Petter Selasky __be32 *p = buf; 285dc7e38acSHans Petter Selasky int i; 286dc7e38acSHans Petter Selasky 287dc7e38acSHans Petter Selasky for (i = 0; i < size; i += 16) { 288dc7e38acSHans Petter Selasky pr_debug("%03x: %08x %08x %08x %08x\n", offset, be32_to_cpu(p[0]), 289dc7e38acSHans Petter Selasky be32_to_cpu(p[1]), be32_to_cpu(p[2]), 290dc7e38acSHans Petter Selasky be32_to_cpu(p[3])); 291dc7e38acSHans Petter Selasky p += 4; 292dc7e38acSHans Petter Selasky offset += 16; 293dc7e38acSHans Petter Selasky } 294dc7e38acSHans Petter Selasky if (!data_only) 295dc7e38acSHans Petter Selasky pr_debug("\n"); 296dc7e38acSHans Petter Selasky } 297dc7e38acSHans Petter Selasky 298dc7e38acSHans Petter Selasky const char *mlx5_command_str(int command) 299dc7e38acSHans Petter Selasky { 300ee1b5c58SHans Petter Selasky #define MLX5_COMMAND_STR_CASE(__cmd) case MLX5_CMD_OP_ ## __cmd: return #__cmd 301ee1b5c58SHans Petter Selasky 302dc7e38acSHans Petter Selasky switch (command) { 303ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_CAP); 304ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_HCA_CAP); 305ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ADAPTER); 306ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(INIT_HCA); 307ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(TEARDOWN_HCA); 308ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ENABLE_HCA); 309ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DISABLE_HCA); 310ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_PAGES); 311ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MANAGE_PAGES); 312ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ISSI); 313ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_ISSI); 314ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_MKEY); 315ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_MKEY); 316ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_MKEY); 317ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_SPECIAL_CONTEXTS); 318ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(PAGE_FAULT_RESUME); 319ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_EQ); 320ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_EQ); 321ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_EQ); 322ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(GEN_EQE); 323ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_CQ); 324ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_CQ); 325ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CQ); 326ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_CQ); 327ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_QP); 328ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_QP); 329ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(RST2INIT_QP); 330ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(INIT2RTR_QP); 331ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(RTR2RTS_QP); 332ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(RTS2RTS_QP); 333ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SQERR2RTS_QP); 334ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(2ERR_QP); 335ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(2RST_QP); 336ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_QP); 337ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SQD_RTS_QP); 338ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MAD_IFC); 339ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(INIT2INIT_QP); 340ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_PSV); 341ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_PSV); 342ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_SRQ); 343ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_SRQ); 344ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_SRQ); 345ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ARM_RQ); 346ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_XRC_SRQ); 347ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_XRC_SRQ); 348ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_XRC_SRQ); 349ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ARM_XRC_SRQ); 350ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_DCT); 351ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_DC_CNAK_TRACE); 352ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_DCT); 353ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DRAIN_DCT); 354ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_DCT); 355ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ARM_DCT_FOR_KEY_VIOLATION); 356ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_VPORT_STATE); 357ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_VPORT_STATE); 358ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ESW_VPORT_CONTEXT); 359ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_ESW_VPORT_CONTEXT); 360ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_NIC_VPORT_CONTEXT); 361ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_NIC_VPORT_CONTEXT); 362ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_ROCE_ADDRESS); 363ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_ROCE_ADDRESS); 364ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_VPORT_CONTEXT); 365ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_HCA_VPORT_CONTEXT); 366ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_VPORT_GID); 367ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_HCA_VPORT_PKEY); 368ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_VPORT_COUNTER); 369ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_WOL_ROL); 370ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_WOL_ROL); 371ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_Q_COUNTER); 372ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_Q_COUNTER); 373ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_Q_COUNTER); 374ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_PD); 375ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_PD); 376ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_UAR); 377ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_UAR); 378ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CONFIG_INT_MODERATION); 379ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ATTACH_TO_MCG); 380ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DETACH_FROM_MCG); 381ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(GET_DROPPED_PACKET_LOG); 382ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_MAD_DEMUX); 383ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_MAD_DEMUX); 384ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(NOP); 385ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_XRCD); 386ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_XRCD); 387ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ALLOC_TRANSPORT_DOMAIN); 388ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DEALLOC_TRANSPORT_DOMAIN); 389ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CONG_STATUS); 390ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_CONG_STATUS); 391ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CONG_PARAMS); 392ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_CONG_PARAMS); 393ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_CONG_STATISTICS); 394ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ADD_VXLAN_UDP_DPORT); 395ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DELETE_VXLAN_UDP_DPORT); 396ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_L2_TABLE_ENTRY); 397ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_L2_TABLE_ENTRY); 398ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DELETE_L2_TABLE_ENTRY); 399ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_RMP); 400ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_RMP); 401ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_RMP); 402ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_RMP); 403ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_RQT); 404ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_RQT); 405ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_RQT); 406ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_RQT); 407ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(ACCESS_REG); 408ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_SQ); 409ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_SQ); 410ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_SQ); 411ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_SQ); 412ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_RQ); 413ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_RQ); 414ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_RQ); 415ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_RQ); 416ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_TIR); 417ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_TIR); 418ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_TIR); 419ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_TIR); 420ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_TIS); 421ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(MODIFY_TIS); 422ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_TIS); 423ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_TIS); 424ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_FLOW_TABLE); 425ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_FLOW_TABLE); 426ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_FLOW_TABLE); 427ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(CREATE_FLOW_GROUP); 428ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DESTROY_FLOW_GROUP); 429ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_FLOW_GROUP); 430ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_FLOW_TABLE_ENTRY); 431ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_FLOW_TABLE_ENTRY); 432ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(DELETE_FLOW_TABLE_ENTRY); 433ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(SET_DIAGNOSTICS); 434ee1b5c58SHans Petter Selasky MLX5_COMMAND_STR_CASE(QUERY_DIAGNOSTICS); 435dc7e38acSHans Petter Selasky default: return "unknown command opcode"; 436dc7e38acSHans Petter Selasky } 437dc7e38acSHans Petter Selasky } 438dc7e38acSHans Petter Selasky 439dc7e38acSHans Petter Selasky static void dump_command(struct mlx5_core_dev *dev, 440dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent, int input) 441dc7e38acSHans Petter Selasky { 442dc7e38acSHans Petter Selasky u16 op = be16_to_cpu(((struct mlx5_inbox_hdr *)(ent->lay->in))->opcode); 443dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg = input ? ent->in : ent->out; 4441c807f67SHans Petter Selasky size_t i; 445dc7e38acSHans Petter Selasky int data_only; 4461c807f67SHans Petter Selasky int offset = 0; 4471c807f67SHans Petter Selasky int msg_len = input ? ent->uin_size : ent->uout_size; 448dc7e38acSHans Petter Selasky int dump_len; 449dc7e38acSHans Petter Selasky 450dc7e38acSHans Petter Selasky data_only = !!(mlx5_core_debug_mask & (1 << MLX5_CMD_DATA)); 451dc7e38acSHans Petter Selasky 452dc7e38acSHans Petter Selasky if (data_only) 453dc7e38acSHans Petter Selasky mlx5_core_dbg_mask(dev, 1 << MLX5_CMD_DATA, 454dc7e38acSHans Petter Selasky "dump command data %s(0x%x) %s\n", 455dc7e38acSHans Petter Selasky mlx5_command_str(op), op, 456dc7e38acSHans Petter Selasky input ? "INPUT" : "OUTPUT"); 457dc7e38acSHans Petter Selasky else 458dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "dump command %s(0x%x) %s\n", 459dc7e38acSHans Petter Selasky mlx5_command_str(op), op, 460dc7e38acSHans Petter Selasky input ? "INPUT" : "OUTPUT"); 461dc7e38acSHans Petter Selasky 462dc7e38acSHans Petter Selasky if (data_only) { 463dc7e38acSHans Petter Selasky if (input) { 464dc7e38acSHans Petter Selasky dump_buf(ent->lay->in, sizeof(ent->lay->in), 1, offset); 465dc7e38acSHans Petter Selasky offset += sizeof(ent->lay->in); 466dc7e38acSHans Petter Selasky } else { 467dc7e38acSHans Petter Selasky dump_buf(ent->lay->out, sizeof(ent->lay->out), 1, offset); 468dc7e38acSHans Petter Selasky offset += sizeof(ent->lay->out); 469dc7e38acSHans Petter Selasky } 470dc7e38acSHans Petter Selasky } else { 471dc7e38acSHans Petter Selasky dump_buf(ent->lay, sizeof(*ent->lay), 0, offset); 472dc7e38acSHans Petter Selasky offset += sizeof(*ent->lay); 473dc7e38acSHans Petter Selasky } 474dc7e38acSHans Petter Selasky 4751c807f67SHans Petter Selasky for (i = 0; i != (msg->numpages * MLX5_NUM_CMDS_IN_ADAPTER_PAGE); i++) { 4761c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block; 4771c807f67SHans Petter Selasky 4781c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE); 4791c807f67SHans Petter Selasky 480dc7e38acSHans Petter Selasky if (data_only) { 4811c807f67SHans Petter Selasky if (offset >= msg_len) 4821c807f67SHans Petter Selasky break; 4831c807f67SHans Petter Selasky dump_len = min_t(int, 4841c807f67SHans Petter Selasky MLX5_CMD_DATA_BLOCK_SIZE, msg_len - offset); 4851c807f67SHans Petter Selasky 4861c807f67SHans Petter Selasky dump_buf(block->data, dump_len, 1, offset); 487dc7e38acSHans Petter Selasky offset += MLX5_CMD_DATA_BLOCK_SIZE; 488dc7e38acSHans Petter Selasky } else { 489dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "command block:\n"); 4901c807f67SHans Petter Selasky dump_buf(block, sizeof(*block), 0, offset); 4911c807f67SHans Petter Selasky offset += sizeof(*block); 492dc7e38acSHans Petter Selasky } 4931c807f67SHans Petter Selasky 4941c807f67SHans Petter Selasky /* check for last block */ 4951c807f67SHans Petter Selasky if (block->next == 0) 4961c807f67SHans Petter Selasky break; 497dc7e38acSHans Petter Selasky } 498dc7e38acSHans Petter Selasky 499dc7e38acSHans Petter Selasky if (data_only) 500dc7e38acSHans Petter Selasky pr_debug("\n"); 501dc7e38acSHans Petter Selasky } 502dc7e38acSHans Petter Selasky 50311546d06SHans Petter Selasky static u16 msg_to_opcode(struct mlx5_cmd_msg *in) 50411546d06SHans Petter Selasky { 50511546d06SHans Petter Selasky struct mlx5_inbox_hdr *hdr = (struct mlx5_inbox_hdr *)(in->first.data); 50611546d06SHans Petter Selasky 50711546d06SHans Petter Selasky return be16_to_cpu(hdr->opcode); 50811546d06SHans Petter Selasky } 50911546d06SHans Petter Selasky 51011546d06SHans Petter Selasky static void cb_timeout_handler(struct work_struct *work) 51111546d06SHans Petter Selasky { 51211546d06SHans Petter Selasky struct delayed_work *dwork = container_of(work, struct delayed_work, 51311546d06SHans Petter Selasky work); 51411546d06SHans Petter Selasky struct mlx5_cmd_work_ent *ent = container_of(dwork, 51511546d06SHans Petter Selasky struct mlx5_cmd_work_ent, 51611546d06SHans Petter Selasky cb_timeout_work); 51711546d06SHans Petter Selasky struct mlx5_core_dev *dev = container_of(ent->cmd, struct mlx5_core_dev, 51811546d06SHans Petter Selasky cmd); 51911546d06SHans Petter Selasky 52011546d06SHans Petter Selasky ent->ret = -ETIMEDOUT; 52111546d06SHans Petter Selasky mlx5_core_warn(dev, "%s(0x%x) timeout. Will cause a leak of a command resource\n", 52211546d06SHans Petter Selasky mlx5_command_str(msg_to_opcode(ent->in)), 52311546d06SHans Petter Selasky msg_to_opcode(ent->in)); 52411546d06SHans Petter Selasky mlx5_cmd_comp_handler(dev, 1UL << ent->idx); 52511546d06SHans Petter Selasky } 52611546d06SHans Petter Selasky 52730dfc051SHans Petter Selasky static int set_internal_err_outbox(struct mlx5_core_dev *dev, u16 opcode, 52830dfc051SHans Petter Selasky struct mlx5_outbox_hdr *hdr) 52930dfc051SHans Petter Selasky { 53030dfc051SHans Petter Selasky hdr->status = 0; 53130dfc051SHans Petter Selasky hdr->syndrome = 0; 53230dfc051SHans Petter Selasky 53330dfc051SHans Petter Selasky switch (opcode) { 53430dfc051SHans Petter Selasky case MLX5_CMD_OP_TEARDOWN_HCA: 53530dfc051SHans Petter Selasky case MLX5_CMD_OP_DISABLE_HCA: 53630dfc051SHans Petter Selasky case MLX5_CMD_OP_MANAGE_PAGES: 53730dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_MKEY: 53830dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_EQ: 53930dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_CQ: 54030dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_QP: 54130dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_PSV: 54230dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_SRQ: 54330dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_XRC_SRQ: 54430dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_DCT: 54530dfc051SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_Q_COUNTER: 54630dfc051SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_PD: 54730dfc051SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_UAR: 54830dfc051SHans Petter Selasky case MLX5_CMD_OP_DETACH_FROM_MCG: 54930dfc051SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_XRCD: 55030dfc051SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_TRANSPORT_DOMAIN: 55130dfc051SHans Petter Selasky case MLX5_CMD_OP_DELETE_VXLAN_UDP_DPORT: 55230dfc051SHans Petter Selasky case MLX5_CMD_OP_DELETE_L2_TABLE_ENTRY: 55330dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_LAG: 55430dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_VPORT_LAG: 55530dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_TIR: 55630dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_SQ: 55730dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_RQ: 55830dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_RMP: 55930dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_TIS: 56030dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_RQT: 56130dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_FLOW_TABLE: 56230dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_FLOW_GROUP: 56330dfc051SHans Petter Selasky case MLX5_CMD_OP_DELETE_FLOW_TABLE_ENTRY: 56430dfc051SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_FLOW_COUNTER: 56530dfc051SHans Petter Selasky case MLX5_CMD_OP_2ERR_QP: 56630dfc051SHans Petter Selasky case MLX5_CMD_OP_2RST_QP: 56730dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT: 56830dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_FLOW_TABLE: 56930dfc051SHans Petter Selasky case MLX5_CMD_OP_SET_FLOW_TABLE_ENTRY: 57030dfc051SHans Petter Selasky case MLX5_CMD_OP_SET_FLOW_TABLE_ROOT: 57130dfc051SHans Petter Selasky case MLX5_CMD_OP_DEALLOC_ENCAP_HEADER: 57230dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_SCHEDULING_ELEMENT: 57330dfc051SHans Petter Selasky case MLX5_CMD_OP_DESTROY_QOS_PARA_VPORT: 57430dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_VPORT_STATE: 57530dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_SQ: 57630dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_RQ: 57730dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_TIS: 57830dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_LAG: 57930dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_TIR: 58030dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_RMP: 58130dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_RQT: 58230dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_SCHEDULING_ELEMENT: 58330dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_CONG_PARAMS: 58430dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_CONG_STATUS: 58530dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_CQ: 58630dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT: 58730dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_HCA_VPORT_CONTEXT: 58830dfc051SHans Petter Selasky case MLX5_CMD_OP_MODIFY_OTHER_HCA_CAP: 58930dfc051SHans Petter Selasky case MLX5_CMD_OP_ACCESS_REG: 59030dfc051SHans Petter Selasky case MLX5_CMD_OP_DRAIN_DCT: 59130dfc051SHans Petter Selasky return 0; 59230dfc051SHans Petter Selasky 59330dfc051SHans Petter Selasky case MLX5_CMD_OP_ADD_VXLAN_UDP_DPORT: 59430dfc051SHans Petter Selasky case MLX5_CMD_OP_ALLOC_ENCAP_HEADER: 59530dfc051SHans Petter Selasky case MLX5_CMD_OP_ALLOC_FLOW_COUNTER: 59630dfc051SHans Petter Selasky case MLX5_CMD_OP_ALLOC_PD: 59730dfc051SHans Petter Selasky case MLX5_CMD_OP_ALLOC_Q_COUNTER: 59830dfc051SHans Petter Selasky case MLX5_CMD_OP_ALLOC_TRANSPORT_DOMAIN: 59930dfc051SHans Petter Selasky case MLX5_CMD_OP_ALLOC_UAR: 60030dfc051SHans Petter Selasky case MLX5_CMD_OP_ALLOC_XRCD: 60130dfc051SHans Petter Selasky case MLX5_CMD_OP_ARM_DCT_FOR_KEY_VIOLATION: 60230dfc051SHans Petter Selasky case MLX5_CMD_OP_ARM_RQ: 60330dfc051SHans Petter Selasky case MLX5_CMD_OP_ARM_XRC_SRQ: 60430dfc051SHans Petter Selasky case MLX5_CMD_OP_ATTACH_TO_MCG: 60530dfc051SHans Petter Selasky case MLX5_CMD_OP_CONFIG_INT_MODERATION: 60630dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_CQ: 60730dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_DCT: 60830dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_EQ: 60930dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_FLOW_GROUP: 61030dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_FLOW_TABLE: 61130dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_LAG: 61230dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_MKEY: 61330dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_PSV: 61430dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_QOS_PARA_VPORT: 61530dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_QP: 61630dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_RMP: 61730dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_RQ: 61830dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_RQT: 61930dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_SCHEDULING_ELEMENT: 62030dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_SQ: 62130dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_SRQ: 62230dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_TIR: 62330dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_TIS: 62430dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_VPORT_LAG: 62530dfc051SHans Petter Selasky case MLX5_CMD_OP_CREATE_XRC_SRQ: 62630dfc051SHans Petter Selasky case MLX5_CMD_OP_ENABLE_HCA: 62730dfc051SHans Petter Selasky case MLX5_CMD_OP_GEN_EQE: 62830dfc051SHans Petter Selasky case MLX5_CMD_OP_GET_DROPPED_PACKET_LOG: 62930dfc051SHans Petter Selasky case MLX5_CMD_OP_INIT2INIT_QP: 63030dfc051SHans Petter Selasky case MLX5_CMD_OP_INIT2RTR_QP: 63130dfc051SHans Petter Selasky case MLX5_CMD_OP_INIT_HCA: 63230dfc051SHans Petter Selasky case MLX5_CMD_OP_MAD_IFC: 63330dfc051SHans Petter Selasky case MLX5_CMD_OP_NOP: 63430dfc051SHans Petter Selasky case MLX5_CMD_OP_PAGE_FAULT_RESUME: 63530dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_ADAPTER: 63630dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_CONG_PARAMS: 63730dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_CONG_STATISTICS: 63830dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_CONG_STATUS: 63930dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_CQ: 64030dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_DCT: 64130dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_EQ: 64230dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_ESW_VPORT_CONTEXT: 64330dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_COUNTER: 64430dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_GROUP: 64530dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_TABLE: 64630dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_FLOW_TABLE_ENTRY: 64730dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_CAP: 64830dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_VPORT_CONTEXT: 64930dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_VPORT_GID: 65030dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_HCA_VPORT_PKEY: 65130dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_ISSI: 65230dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_L2_TABLE_ENTRY: 65330dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_LAG: 65430dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_MAD_DEMUX: 65530dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_MKEY: 65630dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_NIC_VPORT_CONTEXT: 65730dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_OTHER_HCA_CAP: 65830dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_PAGES: 65930dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_QP: 66030dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_Q_COUNTER: 66130dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_RMP: 66230dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_ROCE_ADDRESS: 66330dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_RQ: 66430dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_RQT: 66530dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_SCHEDULING_ELEMENT: 66630dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_SPECIAL_CONTEXTS: 66730dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_SQ: 66830dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_SRQ: 66930dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_TIR: 67030dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_TIS: 67130dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_VPORT_COUNTER: 67230dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_VPORT_STATE: 67330dfc051SHans Petter Selasky case MLX5_CMD_OP_QUERY_XRC_SRQ: 67430dfc051SHans Petter Selasky case MLX5_CMD_OP_RST2INIT_QP: 67530dfc051SHans Petter Selasky case MLX5_CMD_OP_RTR2RTS_QP: 67630dfc051SHans Petter Selasky case MLX5_CMD_OP_RTS2RTS_QP: 67730dfc051SHans Petter Selasky case MLX5_CMD_OP_SET_DC_CNAK_TRACE: 67830dfc051SHans Petter Selasky case MLX5_CMD_OP_SET_HCA_CAP: 67930dfc051SHans Petter Selasky case MLX5_CMD_OP_SET_ISSI: 68030dfc051SHans Petter Selasky case MLX5_CMD_OP_SET_L2_TABLE_ENTRY: 68130dfc051SHans Petter Selasky case MLX5_CMD_OP_SET_MAD_DEMUX: 68230dfc051SHans Petter Selasky case MLX5_CMD_OP_SET_ROCE_ADDRESS: 68330dfc051SHans Petter Selasky case MLX5_CMD_OP_SQD_RTS_QP: 68430dfc051SHans Petter Selasky case MLX5_CMD_OP_SQERR2RTS_QP: 68530dfc051SHans Petter Selasky hdr->status = MLX5_CMD_STAT_INT_ERR; 68630dfc051SHans Petter Selasky hdr->syndrome = 0xFFFFFFFF; 68730dfc051SHans Petter Selasky return -ECANCELED; 68830dfc051SHans Petter Selasky default: 68930dfc051SHans Petter Selasky mlx5_core_err(dev, "Unknown FW command (%d)\n", opcode); 69030dfc051SHans Petter Selasky return -EINVAL; 69130dfc051SHans Petter Selasky } 69230dfc051SHans Petter Selasky } 69330dfc051SHans Petter Selasky 6948e7e0ce1SHans Petter Selasky static void complete_command(struct mlx5_cmd_work_ent *ent) 6958e7e0ce1SHans Petter Selasky { 6968e7e0ce1SHans Petter Selasky struct mlx5_cmd *cmd = ent->cmd; 6978e7e0ce1SHans Petter Selasky struct mlx5_core_dev *dev = container_of(cmd, struct mlx5_core_dev, 6988e7e0ce1SHans Petter Selasky cmd); 699f361e561SHans Petter Selasky mlx5_cmd_cbk_t callback; 700f361e561SHans Petter Selasky void *context; 701f361e561SHans Petter Selasky 7028e7e0ce1SHans Petter Selasky s64 ds; 7038e7e0ce1SHans Petter Selasky struct mlx5_cmd_stats *stats; 7048e7e0ce1SHans Petter Selasky unsigned long flags; 7058e7e0ce1SHans Petter Selasky int err; 7068e7e0ce1SHans Petter Selasky struct semaphore *sem; 7078e7e0ce1SHans Petter Selasky 7088e7e0ce1SHans Petter Selasky if (ent->page_queue) 7098e7e0ce1SHans Petter Selasky sem = &cmd->pages_sem; 7108e7e0ce1SHans Petter Selasky else 7118e7e0ce1SHans Petter Selasky sem = &cmd->sem; 7128e7e0ce1SHans Petter Selasky 71330dfc051SHans Petter Selasky if (dev->state != MLX5_DEVICE_STATE_UP) { 71430dfc051SHans Petter Selasky struct mlx5_outbox_hdr *out_hdr = 71530dfc051SHans Petter Selasky (struct mlx5_outbox_hdr *)ent->out; 71630dfc051SHans Petter Selasky struct mlx5_inbox_hdr *in_hdr = 71730dfc051SHans Petter Selasky (struct mlx5_inbox_hdr *)(ent->in->first.data); 71830dfc051SHans Petter Selasky u16 opcode = be16_to_cpu(in_hdr->opcode); 71930dfc051SHans Petter Selasky 72030dfc051SHans Petter Selasky ent->ret = set_internal_err_outbox(dev, 72130dfc051SHans Petter Selasky opcode, 72230dfc051SHans Petter Selasky out_hdr); 72330dfc051SHans Petter Selasky } 72430dfc051SHans Petter Selasky 7258e7e0ce1SHans Petter Selasky if (ent->callback) { 7268e7e0ce1SHans Petter Selasky ds = ent->ts2 - ent->ts1; 7278e7e0ce1SHans Petter Selasky if (ent->op < ARRAY_SIZE(cmd->stats)) { 7288e7e0ce1SHans Petter Selasky stats = &cmd->stats[ent->op]; 7298e7e0ce1SHans Petter Selasky spin_lock_irqsave(&stats->lock, flags); 7308e7e0ce1SHans Petter Selasky stats->sum += ds; 7318e7e0ce1SHans Petter Selasky ++stats->n; 7328e7e0ce1SHans Petter Selasky spin_unlock_irqrestore(&stats->lock, flags); 7338e7e0ce1SHans Petter Selasky } 7348e7e0ce1SHans Petter Selasky 735f361e561SHans Petter Selasky callback = ent->callback; 736f361e561SHans Petter Selasky context = ent->context; 7378e7e0ce1SHans Petter Selasky err = ent->ret; 7388e7e0ce1SHans Petter Selasky if (!err) 7398e7e0ce1SHans Petter Selasky err = mlx5_copy_from_msg(ent->uout, 7408e7e0ce1SHans Petter Selasky ent->out, 7418e7e0ce1SHans Petter Selasky ent->uout_size); 7428e7e0ce1SHans Petter Selasky 7438e7e0ce1SHans Petter Selasky mlx5_free_cmd_msg(dev, ent->out); 7448e7e0ce1SHans Petter Selasky free_msg(dev, ent->in); 7458e7e0ce1SHans Petter Selasky 7468e7e0ce1SHans Petter Selasky free_cmd(ent); 747f361e561SHans Petter Selasky callback(err, context); 7488e7e0ce1SHans Petter Selasky } else { 7498e7e0ce1SHans Petter Selasky complete(&ent->done); 7508e7e0ce1SHans Petter Selasky } 7518e7e0ce1SHans Petter Selasky up(sem); 7528e7e0ce1SHans Petter Selasky } 7538e7e0ce1SHans Petter Selasky 754dc7e38acSHans Petter Selasky static void cmd_work_handler(struct work_struct *work) 755dc7e38acSHans Petter Selasky { 756dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent = container_of(work, struct mlx5_cmd_work_ent, work); 757dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = ent->cmd; 758dc7e38acSHans Petter Selasky struct mlx5_core_dev *dev = container_of(cmd, struct mlx5_core_dev, cmd); 75911546d06SHans Petter Selasky unsigned long cb_timeout = msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC); 760dc7e38acSHans Petter Selasky struct mlx5_cmd_layout *lay; 761dc7e38acSHans Petter Selasky struct semaphore *sem; 762dc7e38acSHans Petter Selasky 763dc7e38acSHans Petter Selasky sem = ent->page_queue ? &cmd->pages_sem : &cmd->sem; 764dc7e38acSHans Petter Selasky down(sem); 7658e7e0ce1SHans Petter Selasky 7668e7e0ce1SHans Petter Selasky if (alloc_ent(ent) < 0) { 7678e7e0ce1SHans Petter Selasky complete_command(ent); 768dc7e38acSHans Petter Selasky return; 769dc7e38acSHans Petter Selasky } 770dc7e38acSHans Petter Selasky 771dc7e38acSHans Petter Selasky ent->token = alloc_token(cmd); 772dc7e38acSHans Petter Selasky lay = get_inst(cmd, ent->idx); 773dc7e38acSHans Petter Selasky ent->lay = lay; 774dc7e38acSHans Petter Selasky memset(lay, 0, sizeof(*lay)); 775dc7e38acSHans Petter Selasky memcpy(lay->in, ent->in->first.data, sizeof(lay->in)); 776dc7e38acSHans Petter Selasky ent->op = be32_to_cpu(lay->in[0]) >> 16; 7771c807f67SHans Petter Selasky if (ent->in->numpages != 0) 7781c807f67SHans Petter Selasky lay->in_ptr = cpu_to_be64(mlx5_fwp_get_dma(ent->in, 0)); 7791c807f67SHans Petter Selasky if (ent->out->numpages != 0) 7801c807f67SHans Petter Selasky lay->out_ptr = cpu_to_be64(mlx5_fwp_get_dma(ent->out, 0)); 7811c807f67SHans Petter Selasky lay->inlen = cpu_to_be32(ent->uin_size); 7821c807f67SHans Petter Selasky lay->outlen = cpu_to_be32(ent->uout_size); 783dc7e38acSHans Petter Selasky lay->type = MLX5_PCI_CMD_XPORT; 784dc7e38acSHans Petter Selasky lay->token = ent->token; 785dc7e38acSHans Petter Selasky lay->status_own = CMD_OWNER_HW; 786dc7e38acSHans Petter Selasky set_signature(ent, !cmd->checksum_disabled); 787dc7e38acSHans Petter Selasky dump_command(dev, ent, 1); 788dc7e38acSHans Petter Selasky ent->ts1 = ktime_get_ns(); 78930dfc051SHans Petter Selasky ent->busy = 0; 79011546d06SHans Petter Selasky if (ent->callback) 79111546d06SHans Petter Selasky schedule_delayed_work(&ent->cb_timeout_work, cb_timeout); 79211546d06SHans Petter Selasky 793dc7e38acSHans Petter Selasky /* ring doorbell after the descriptor is valid */ 794dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "writing 0x%x to command doorbell\n", 1 << ent->idx); 7951c807f67SHans Petter Selasky /* make sure data is written to RAM */ 7961c807f67SHans Petter Selasky mlx5_fwp_flush(cmd->cmd_page); 797dc7e38acSHans Petter Selasky iowrite32be(1 << ent->idx, &dev->iseg->cmd_dbell); 798dc7e38acSHans Petter Selasky mmiowb(); 799dc7e38acSHans Petter Selasky /* if not in polling don't use ent after this point*/ 800dc7e38acSHans Petter Selasky if (cmd->mode == CMD_MODE_POLLING) { 801dc7e38acSHans Petter Selasky poll_timeout(ent); 802dc7e38acSHans Petter Selasky /* make sure we read the descriptor after ownership is SW */ 803d0ce5a0dSHans Petter Selasky mlx5_cmd_comp_handler(dev, 1U << ent->idx); 804dc7e38acSHans Petter Selasky } 805dc7e38acSHans Petter Selasky } 806dc7e38acSHans Petter Selasky 807dc7e38acSHans Petter Selasky static const char *deliv_status_to_str(u8 status) 808dc7e38acSHans Petter Selasky { 809dc7e38acSHans Petter Selasky switch (status) { 810dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_OK: 811dc7e38acSHans Petter Selasky return "no errors"; 812dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_SIGNAT_ERR: 813dc7e38acSHans Petter Selasky return "signature error"; 814dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_TOK_ERR: 815dc7e38acSHans Petter Selasky return "token error"; 816dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_BAD_BLK_NUM_ERR: 817dc7e38acSHans Petter Selasky return "bad block number"; 818dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_OUT_PTR_ALIGN_ERR: 819dc7e38acSHans Petter Selasky return "output pointer not aligned to block size"; 820dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_IN_PTR_ALIGN_ERR: 821dc7e38acSHans Petter Selasky return "input pointer not aligned to block size"; 822dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_FW_ERR: 823dc7e38acSHans Petter Selasky return "firmware internal error"; 824dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_IN_LENGTH_ERR: 825dc7e38acSHans Petter Selasky return "command input length error"; 826dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_OUT_LENGTH_ERR: 827dc7e38acSHans Petter Selasky return "command ouput length error"; 828dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_RES_FLD_NOT_CLR_ERR: 829dc7e38acSHans Petter Selasky return "reserved fields not cleared"; 830dc7e38acSHans Petter Selasky case MLX5_CMD_DELIVERY_STAT_CMD_DESCR_ERR: 831dc7e38acSHans Petter Selasky return "bad command descriptor type"; 832dc7e38acSHans Petter Selasky default: 833dc7e38acSHans Petter Selasky return "unknown status code"; 834dc7e38acSHans Petter Selasky } 835dc7e38acSHans Petter Selasky } 836dc7e38acSHans Petter Selasky 837dc7e38acSHans Petter Selasky static int wait_func(struct mlx5_core_dev *dev, struct mlx5_cmd_work_ent *ent) 838dc7e38acSHans Petter Selasky { 839dc7e38acSHans Petter Selasky int timeout = msecs_to_jiffies(MLX5_CMD_TIMEOUT_MSEC); 840dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 841dc7e38acSHans Petter Selasky int err; 842dc7e38acSHans Petter Selasky 843dc7e38acSHans Petter Selasky if (cmd->mode == CMD_MODE_POLLING) { 844dc7e38acSHans Petter Selasky wait_for_completion(&ent->done); 845dc7e38acSHans Petter Selasky err = ent->ret; 8462327a753SHans Petter Selasky } else if (!wait_for_completion_timeout(&ent->done, timeout)) { 8472327a753SHans Petter Selasky ent->ret = -ETIMEDOUT; 8482327a753SHans Petter Selasky mlx5_cmd_comp_handler(dev, 1UL << ent->idx); 849dc7e38acSHans Petter Selasky } 85030dfc051SHans Petter Selasky 8512327a753SHans Petter Selasky err = ent->ret; 8522327a753SHans Petter Selasky 853dc7e38acSHans Petter Selasky if (err == -ETIMEDOUT) { 854dc7e38acSHans Petter Selasky mlx5_core_warn(dev, "%s(0x%x) timeout. Will cause a leak of a command resource\n", 855dc7e38acSHans Petter Selasky mlx5_command_str(msg_to_opcode(ent->in)), 856dc7e38acSHans Petter Selasky msg_to_opcode(ent->in)); 857dc7e38acSHans Petter Selasky } 858dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "err %d, delivery status %s(%d)\n", 859dc7e38acSHans Petter Selasky err, deliv_status_to_str(ent->status), ent->status); 860dc7e38acSHans Petter Selasky 861dc7e38acSHans Petter Selasky return err; 862dc7e38acSHans Petter Selasky } 863dc7e38acSHans Petter Selasky 864dc7e38acSHans Petter Selasky /* Notes: 865dc7e38acSHans Petter Selasky * 1. Callback functions may not sleep 866dc7e38acSHans Petter Selasky * 2. page queue commands do not support asynchrous completion 867dc7e38acSHans Petter Selasky */ 868dc7e38acSHans Petter Selasky static int mlx5_cmd_invoke(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *in, 8691c807f67SHans Petter Selasky int uin_size, 870dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *out, void *uout, int uout_size, 871dc7e38acSHans Petter Selasky mlx5_cmd_cbk_t callback, 872dc7e38acSHans Petter Selasky void *context, int page_queue, u8 *status) 873dc7e38acSHans Petter Selasky { 874dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 875dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent; 876dc7e38acSHans Petter Selasky struct mlx5_cmd_stats *stats; 877dc7e38acSHans Petter Selasky int err = 0; 878dc7e38acSHans Petter Selasky s64 ds; 879dc7e38acSHans Petter Selasky u16 op; 880dc7e38acSHans Petter Selasky 881dc7e38acSHans Petter Selasky if (callback && page_queue) 882dc7e38acSHans Petter Selasky return -EINVAL; 883dc7e38acSHans Petter Selasky 8841c807f67SHans Petter Selasky ent = alloc_cmd(cmd, in, uin_size, out, uout, uout_size, callback, 8851c807f67SHans Petter Selasky context, page_queue); 886dc7e38acSHans Petter Selasky if (IS_ERR(ent)) 887dc7e38acSHans Petter Selasky return PTR_ERR(ent); 888dc7e38acSHans Petter Selasky 889dc7e38acSHans Petter Selasky if (!callback) 890dc7e38acSHans Petter Selasky init_completion(&ent->done); 891dc7e38acSHans Petter Selasky 89211546d06SHans Petter Selasky INIT_DELAYED_WORK(&ent->cb_timeout_work, cb_timeout_handler); 893dc7e38acSHans Petter Selasky INIT_WORK(&ent->work, cmd_work_handler); 894dc7e38acSHans Petter Selasky if (page_queue) { 895dc7e38acSHans Petter Selasky cmd_work_handler(&ent->work); 896dc7e38acSHans Petter Selasky } else if (!queue_work(cmd->wq, &ent->work)) { 897dc7e38acSHans Petter Selasky mlx5_core_warn(dev, "failed to queue work\n"); 898dc7e38acSHans Petter Selasky err = -ENOMEM; 899dc7e38acSHans Petter Selasky goto out_free; 900dc7e38acSHans Petter Selasky } 901dc7e38acSHans Petter Selasky 9022327a753SHans Petter Selasky if (callback) 9032327a753SHans Petter Selasky goto out; 9042327a753SHans Petter Selasky 905dc7e38acSHans Petter Selasky err = wait_func(dev, ent); 906dc7e38acSHans Petter Selasky if (err == -ETIMEDOUT) 907dc7e38acSHans Petter Selasky goto out; 908dc7e38acSHans Petter Selasky 909dc7e38acSHans Petter Selasky ds = ent->ts2 - ent->ts1; 910dc7e38acSHans Petter Selasky op = be16_to_cpu(((struct mlx5_inbox_hdr *)in->first.data)->opcode); 911dc7e38acSHans Petter Selasky if (op < ARRAY_SIZE(cmd->stats)) { 912dc7e38acSHans Petter Selasky stats = &cmd->stats[op]; 913dc7e38acSHans Petter Selasky spin_lock_irq(&stats->lock); 914dc7e38acSHans Petter Selasky stats->sum += ds; 915dc7e38acSHans Petter Selasky ++stats->n; 916dc7e38acSHans Petter Selasky spin_unlock_irq(&stats->lock); 917dc7e38acSHans Petter Selasky } 918dc7e38acSHans Petter Selasky mlx5_core_dbg_mask(dev, 1 << MLX5_CMD_TIME, 919dc7e38acSHans Petter Selasky "fw exec time for %s is %lld nsec\n", 920dc7e38acSHans Petter Selasky mlx5_command_str(op), (long long)ds); 921dc7e38acSHans Petter Selasky *status = ent->status; 922dc7e38acSHans Petter Selasky free_cmd(ent); 923dc7e38acSHans Petter Selasky 924dc7e38acSHans Petter Selasky return err; 925dc7e38acSHans Petter Selasky 926dc7e38acSHans Petter Selasky out_free: 927dc7e38acSHans Petter Selasky free_cmd(ent); 928dc7e38acSHans Petter Selasky out: 929dc7e38acSHans Petter Selasky return err; 930dc7e38acSHans Petter Selasky } 931dc7e38acSHans Petter Selasky 9321c807f67SHans Petter Selasky static int mlx5_copy_to_msg(struct mlx5_cmd_msg *to, void *from, size_t size) 933dc7e38acSHans Petter Selasky { 9341c807f67SHans Petter Selasky size_t delta; 9351c807f67SHans Petter Selasky size_t i; 9361c807f67SHans Petter Selasky 9371c807f67SHans Petter Selasky if (to == NULL || from == NULL) 9381c807f67SHans Petter Selasky return (-ENOMEM); 9391c807f67SHans Petter Selasky 9401c807f67SHans Petter Selasky delta = min_t(size_t, size, sizeof(to->first.data)); 9411c807f67SHans Petter Selasky memcpy(to->first.data, from, delta); 9421c807f67SHans Petter Selasky from = (char *)from + delta; 9431c807f67SHans Petter Selasky size -= delta; 9441c807f67SHans Petter Selasky 9451c807f67SHans Petter Selasky for (i = 0; size != 0; i++) { 946dc7e38acSHans Petter Selasky struct mlx5_cmd_prot_block *block; 947dc7e38acSHans Petter Selasky 9481c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(to, i * MLX5_CMD_MBOX_SIZE); 949dc7e38acSHans Petter Selasky 9501c807f67SHans Petter Selasky delta = min_t(size_t, size, MLX5_CMD_DATA_BLOCK_SIZE); 9511c807f67SHans Petter Selasky memcpy(block->data, from, delta); 9521c807f67SHans Petter Selasky from = (char *)from + delta; 9531c807f67SHans Petter Selasky size -= delta; 954dc7e38acSHans Petter Selasky } 9551c807f67SHans Petter Selasky return (0); 956dc7e38acSHans Petter Selasky } 957dc7e38acSHans Petter Selasky 958dc7e38acSHans Petter Selasky static int mlx5_copy_from_msg(void *to, struct mlx5_cmd_msg *from, int size) 959dc7e38acSHans Petter Selasky { 9601c807f67SHans Petter Selasky size_t delta; 9611c807f67SHans Petter Selasky size_t i; 9621c807f67SHans Petter Selasky 9631c807f67SHans Petter Selasky if (to == NULL || from == NULL) 9641c807f67SHans Petter Selasky return (-ENOMEM); 9651c807f67SHans Petter Selasky 9661c807f67SHans Petter Selasky delta = min_t(size_t, size, sizeof(from->first.data)); 9671c807f67SHans Petter Selasky memcpy(to, from->first.data, delta); 9681c807f67SHans Petter Selasky to = (char *)to + delta; 9691c807f67SHans Petter Selasky size -= delta; 9701c807f67SHans Petter Selasky 9711c807f67SHans Petter Selasky for (i = 0; size != 0; i++) { 972dc7e38acSHans Petter Selasky struct mlx5_cmd_prot_block *block; 973dc7e38acSHans Petter Selasky 9741c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(from, i * MLX5_CMD_MBOX_SIZE); 975dc7e38acSHans Petter Selasky 9761c807f67SHans Petter Selasky delta = min_t(size_t, size, MLX5_CMD_DATA_BLOCK_SIZE); 9771c807f67SHans Petter Selasky memcpy(to, block->data, delta); 9781c807f67SHans Petter Selasky to = (char *)to + delta; 9791c807f67SHans Petter Selasky size -= delta; 9801c807f67SHans Petter Selasky } 9811c807f67SHans Petter Selasky return (0); 982dc7e38acSHans Petter Selasky } 983dc7e38acSHans Petter Selasky 9841c807f67SHans Petter Selasky static struct mlx5_cmd_msg * 9851c807f67SHans Petter Selasky mlx5_alloc_cmd_msg(struct mlx5_core_dev *dev, gfp_t flags, size_t size) 986dc7e38acSHans Petter Selasky { 987dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg; 9881c807f67SHans Petter Selasky size_t blen; 9891c807f67SHans Petter Selasky size_t n; 9901c807f67SHans Petter Selasky size_t i; 991dc7e38acSHans Petter Selasky 9921c807f67SHans Petter Selasky blen = size - min_t(size_t, sizeof(msg->first.data), size); 9931c807f67SHans Petter Selasky n = howmany(blen, MLX5_CMD_DATA_BLOCK_SIZE); 994dc7e38acSHans Petter Selasky 9951c807f67SHans Petter Selasky msg = mlx5_fwp_alloc(dev, flags, howmany(n, MLX5_NUM_CMDS_IN_ADAPTER_PAGE)); 9961c807f67SHans Petter Selasky if (msg == NULL) 9971c807f67SHans Petter Selasky return (ERR_PTR(-ENOMEM)); 998dc7e38acSHans Petter Selasky 9991c807f67SHans Petter Selasky for (i = 0; i != n; i++) { 10001c807f67SHans Petter Selasky struct mlx5_cmd_prot_block *block; 10011c807f67SHans Petter Selasky 10021c807f67SHans Petter Selasky block = mlx5_fwp_get_virt(msg, i * MLX5_CMD_MBOX_SIZE); 10031c807f67SHans Petter Selasky 10041c807f67SHans Petter Selasky memset(block, 0, MLX5_CMD_MBOX_SIZE); 10051c807f67SHans Petter Selasky 10061c807f67SHans Petter Selasky if (i != (n - 1)) { 10071c807f67SHans Petter Selasky u64 dma = mlx5_fwp_get_dma(msg, (i + 1) * MLX5_CMD_MBOX_SIZE); 10081c807f67SHans Petter Selasky block->next = cpu_to_be64(dma); 10091c807f67SHans Petter Selasky } 10101c807f67SHans Petter Selasky block->block_num = cpu_to_be32(i); 1011dc7e38acSHans Petter Selasky } 1012dc7e38acSHans Petter Selasky 10131c807f67SHans Petter Selasky /* make sure initial data is written to RAM */ 10141c807f67SHans Petter Selasky mlx5_fwp_flush(msg); 1015dc7e38acSHans Petter Selasky 10161c807f67SHans Petter Selasky return (msg); 1017dc7e38acSHans Petter Selasky } 1018dc7e38acSHans Petter Selasky 10191c807f67SHans Petter Selasky static void 10201c807f67SHans Petter Selasky mlx5_free_cmd_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg) 1021dc7e38acSHans Petter Selasky { 1022dc7e38acSHans Petter Selasky 10231c807f67SHans Petter Selasky mlx5_fwp_free(msg); 1024dc7e38acSHans Petter Selasky } 1025dc7e38acSHans Petter Selasky 1026dc7e38acSHans Petter Selasky static void set_wqname(struct mlx5_core_dev *dev) 1027dc7e38acSHans Petter Selasky { 1028dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1029dc7e38acSHans Petter Selasky 1030dc7e38acSHans Petter Selasky snprintf(cmd->wq_name, sizeof(cmd->wq_name), "mlx5_cmd_%s", 1031dc7e38acSHans Petter Selasky dev_name(&dev->pdev->dev)); 1032dc7e38acSHans Petter Selasky } 1033dc7e38acSHans Petter Selasky 1034dc7e38acSHans Petter Selasky static void clean_debug_files(struct mlx5_core_dev *dev) 1035dc7e38acSHans Petter Selasky { 1036dc7e38acSHans Petter Selasky } 1037dc7e38acSHans Petter Selasky 1038dc7e38acSHans Petter Selasky 10392327a753SHans Petter Selasky static void mlx5_cmd_change_mod(struct mlx5_core_dev *dev, int mode) 1040dc7e38acSHans Petter Selasky { 1041dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1042dc7e38acSHans Petter Selasky int i; 1043dc7e38acSHans Petter Selasky 1044dc7e38acSHans Petter Selasky for (i = 0; i < cmd->max_reg_cmds; i++) 1045dc7e38acSHans Petter Selasky down(&cmd->sem); 1046dc7e38acSHans Petter Selasky 1047dc7e38acSHans Petter Selasky down(&cmd->pages_sem); 10482327a753SHans Petter Selasky cmd->mode = mode; 1049dc7e38acSHans Petter Selasky 1050dc7e38acSHans Petter Selasky up(&cmd->pages_sem); 1051dc7e38acSHans Petter Selasky for (i = 0; i < cmd->max_reg_cmds; i++) 1052dc7e38acSHans Petter Selasky up(&cmd->sem); 1053dc7e38acSHans Petter Selasky } 1054dc7e38acSHans Petter Selasky 10552327a753SHans Petter Selasky void mlx5_cmd_use_events(struct mlx5_core_dev *dev) 10562327a753SHans Petter Selasky { 10572327a753SHans Petter Selasky mlx5_cmd_change_mod(dev, CMD_MODE_EVENTS); 10582327a753SHans Petter Selasky } 10592327a753SHans Petter Selasky 1060dc7e38acSHans Petter Selasky void mlx5_cmd_use_polling(struct mlx5_core_dev *dev) 1061dc7e38acSHans Petter Selasky { 10622327a753SHans Petter Selasky mlx5_cmd_change_mod(dev, CMD_MODE_POLLING); 1063dc7e38acSHans Petter Selasky } 1064dc7e38acSHans Petter Selasky 1065dc7e38acSHans Petter Selasky static void free_msg(struct mlx5_core_dev *dev, struct mlx5_cmd_msg *msg) 1066dc7e38acSHans Petter Selasky { 1067dc7e38acSHans Petter Selasky unsigned long flags; 1068dc7e38acSHans Petter Selasky 1069dc7e38acSHans Petter Selasky if (msg->cache) { 1070dc7e38acSHans Petter Selasky spin_lock_irqsave(&msg->cache->lock, flags); 1071dc7e38acSHans Petter Selasky list_add_tail(&msg->list, &msg->cache->head); 1072dc7e38acSHans Petter Selasky spin_unlock_irqrestore(&msg->cache->lock, flags); 1073dc7e38acSHans Petter Selasky } else { 1074dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, msg); 1075dc7e38acSHans Petter Selasky } 1076dc7e38acSHans Petter Selasky } 1077dc7e38acSHans Petter Selasky 1078d0ce5a0dSHans Petter Selasky void mlx5_cmd_comp_handler(struct mlx5_core_dev *dev, u32 vector) 1079dc7e38acSHans Petter Selasky { 1080dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1081dc7e38acSHans Petter Selasky struct mlx5_cmd_work_ent *ent; 1082dc7e38acSHans Petter Selasky int i; 1083dc7e38acSHans Petter Selasky 10841c807f67SHans Petter Selasky /* make sure data gets read from RAM */ 10851c807f67SHans Petter Selasky mlx5_fwp_invalidate(cmd->cmd_page); 10861c807f67SHans Petter Selasky 1087d0ce5a0dSHans Petter Selasky while (vector != 0) { 1088d0ce5a0dSHans Petter Selasky i = ffs(vector) - 1; 1089d0ce5a0dSHans Petter Selasky vector &= ~(1U << i); 1090dc7e38acSHans Petter Selasky ent = cmd->ent_arr[i]; 109111546d06SHans Petter Selasky if (ent->callback) 109211546d06SHans Petter Selasky cancel_delayed_work(&ent->cb_timeout_work); 1093dc7e38acSHans Petter Selasky ent->ts2 = ktime_get_ns(); 1094d0ce5a0dSHans Petter Selasky memcpy(ent->out->first.data, ent->lay->out, 1095d0ce5a0dSHans Petter Selasky sizeof(ent->lay->out)); 10961c807f67SHans Petter Selasky /* make sure data gets read from RAM */ 10971c807f67SHans Petter Selasky mlx5_fwp_invalidate(ent->out); 1098dc7e38acSHans Petter Selasky dump_command(dev, ent, 0); 1099dc7e38acSHans Petter Selasky if (!ent->ret) { 1100dc7e38acSHans Petter Selasky if (!cmd->checksum_disabled) 1101dc7e38acSHans Petter Selasky ent->ret = verify_signature(ent); 1102dc7e38acSHans Petter Selasky else 1103dc7e38acSHans Petter Selasky ent->ret = 0; 1104dc7e38acSHans Petter Selasky ent->status = ent->lay->status_own >> 1; 110530dfc051SHans Petter Selasky 1106d0ce5a0dSHans Petter Selasky mlx5_core_dbg(dev, 1107d0ce5a0dSHans Petter Selasky "FW command ret 0x%x, status %s(0x%x)\n", 1108d0ce5a0dSHans Petter Selasky ent->ret, 1109d0ce5a0dSHans Petter Selasky deliv_status_to_str(ent->status), 1110d0ce5a0dSHans Petter Selasky ent->status); 1111dc7e38acSHans Petter Selasky } 1112dc7e38acSHans Petter Selasky free_ent(cmd, ent->idx); 11138e7e0ce1SHans Petter Selasky complete_command(ent); 1114dc7e38acSHans Petter Selasky } 1115dc7e38acSHans Petter Selasky } 1116dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_comp_handler); 1117dc7e38acSHans Petter Selasky 111830dfc051SHans Petter Selasky void mlx5_trigger_cmd_completions(struct mlx5_core_dev *dev) 111930dfc051SHans Petter Selasky { 112030dfc051SHans Petter Selasky unsigned long vector; 112130dfc051SHans Petter Selasky int i = 0; 112230dfc051SHans Petter Selasky unsigned long flags; 112330dfc051SHans Petter Selasky synchronize_irq(dev->priv.eq_table.cmd_eq.irqn); 112430dfc051SHans Petter Selasky spin_lock_irqsave(&dev->cmd.alloc_lock, flags); 112530dfc051SHans Petter Selasky vector = ~dev->cmd.bitmask & ((1ul << (1 << dev->cmd.log_sz)) - 1); 112630dfc051SHans Petter Selasky spin_unlock_irqrestore(&dev->cmd.alloc_lock, flags); 112730dfc051SHans Petter Selasky 112830dfc051SHans Petter Selasky if (!vector) 112930dfc051SHans Petter Selasky return; 113030dfc051SHans Petter Selasky 113130dfc051SHans Petter Selasky for (i = 0; i < (1 << dev->cmd.log_sz); i++) { 113230dfc051SHans Petter Selasky struct mlx5_cmd_work_ent *ent = dev->cmd.ent_arr[i]; 113330dfc051SHans Petter Selasky 113430dfc051SHans Petter Selasky if (!test_bit(i, &vector)) 113530dfc051SHans Petter Selasky continue; 113630dfc051SHans Petter Selasky 113730dfc051SHans Petter Selasky while (ent->busy) 113830dfc051SHans Petter Selasky usleep_range(1000, 1100); 113930dfc051SHans Petter Selasky free_ent(&dev->cmd, i); 114030dfc051SHans Petter Selasky complete_command(ent); 114130dfc051SHans Petter Selasky } 114230dfc051SHans Petter Selasky } 114330dfc051SHans Petter Selasky EXPORT_SYMBOL(mlx5_trigger_cmd_completions); 114430dfc051SHans Petter Selasky 1145dc7e38acSHans Petter Selasky static int status_to_err(u8 status) 1146dc7e38acSHans Petter Selasky { 1147dc7e38acSHans Petter Selasky return status ? -1 : 0; /* TBD more meaningful codes */ 1148dc7e38acSHans Petter Selasky } 1149dc7e38acSHans Petter Selasky 1150dc7e38acSHans Petter Selasky static struct mlx5_cmd_msg *alloc_msg(struct mlx5_core_dev *dev, int in_size, 1151dc7e38acSHans Petter Selasky gfp_t gfp) 1152dc7e38acSHans Petter Selasky { 1153dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg = ERR_PTR(-ENOMEM); 1154dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1155dc7e38acSHans Petter Selasky struct cache_ent *ent = NULL; 1156dc7e38acSHans Petter Selasky 1157dc7e38acSHans Petter Selasky if (in_size > MED_LIST_SIZE && in_size <= LONG_LIST_SIZE) 1158dc7e38acSHans Petter Selasky ent = &cmd->cache.large; 1159dc7e38acSHans Petter Selasky else if (in_size > 16 && in_size <= MED_LIST_SIZE) 1160dc7e38acSHans Petter Selasky ent = &cmd->cache.med; 1161dc7e38acSHans Petter Selasky 1162dc7e38acSHans Petter Selasky if (ent) { 1163dc7e38acSHans Petter Selasky spin_lock_irq(&ent->lock); 1164dc7e38acSHans Petter Selasky if (!list_empty(&ent->head)) { 1165dc7e38acSHans Petter Selasky msg = list_entry(ent->head.next, struct mlx5_cmd_msg, 1166dc7e38acSHans Petter Selasky list); 1167dc7e38acSHans Petter Selasky list_del(&msg->list); 1168dc7e38acSHans Petter Selasky } 1169dc7e38acSHans Petter Selasky spin_unlock_irq(&ent->lock); 1170dc7e38acSHans Petter Selasky } 1171dc7e38acSHans Petter Selasky 1172dc7e38acSHans Petter Selasky if (IS_ERR(msg)) 1173dc7e38acSHans Petter Selasky msg = mlx5_alloc_cmd_msg(dev, gfp, in_size); 1174dc7e38acSHans Petter Selasky 1175dc7e38acSHans Petter Selasky return msg; 1176dc7e38acSHans Petter Selasky } 1177dc7e38acSHans Petter Selasky 1178dc7e38acSHans Petter Selasky static int is_manage_pages(struct mlx5_inbox_hdr *in) 1179dc7e38acSHans Petter Selasky { 1180dc7e38acSHans Petter Selasky return be16_to_cpu(in->opcode) == MLX5_CMD_OP_MANAGE_PAGES; 1181dc7e38acSHans Petter Selasky } 1182dc7e38acSHans Petter Selasky 118330dfc051SHans Petter Selasky static int cmd_exec_helper(struct mlx5_core_dev *dev, 118430dfc051SHans Petter Selasky void *in, int in_size, 118530dfc051SHans Petter Selasky void *out, int out_size, 118630dfc051SHans Petter Selasky mlx5_cmd_cbk_t callback, void *context) 1187dc7e38acSHans Petter Selasky { 1188dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *inb; 1189dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *outb; 1190dc7e38acSHans Petter Selasky int pages_queue; 11911d4905b5SHans Petter Selasky const gfp_t gfp = GFP_KERNEL; 1192dc7e38acSHans Petter Selasky int err; 1193dc7e38acSHans Petter Selasky u8 status = 0; 1194dc7e38acSHans Petter Selasky 1195dc7e38acSHans Petter Selasky pages_queue = is_manage_pages(in); 1196dc7e38acSHans Petter Selasky 1197dc7e38acSHans Petter Selasky inb = alloc_msg(dev, in_size, gfp); 1198dc7e38acSHans Petter Selasky if (IS_ERR(inb)) { 1199dc7e38acSHans Petter Selasky err = PTR_ERR(inb); 1200dc7e38acSHans Petter Selasky return err; 1201dc7e38acSHans Petter Selasky } 1202dc7e38acSHans Petter Selasky 1203dc7e38acSHans Petter Selasky err = mlx5_copy_to_msg(inb, in, in_size); 1204dc7e38acSHans Petter Selasky if (err) { 1205dc7e38acSHans Petter Selasky mlx5_core_warn(dev, "err %d\n", err); 1206dc7e38acSHans Petter Selasky goto out_in; 1207dc7e38acSHans Petter Selasky } 1208dc7e38acSHans Petter Selasky 1209dc7e38acSHans Petter Selasky outb = mlx5_alloc_cmd_msg(dev, gfp, out_size); 1210dc7e38acSHans Petter Selasky if (IS_ERR(outb)) { 1211dc7e38acSHans Petter Selasky err = PTR_ERR(outb); 1212dc7e38acSHans Petter Selasky goto out_in; 1213dc7e38acSHans Petter Selasky } 1214dc7e38acSHans Petter Selasky 12151c807f67SHans Petter Selasky err = mlx5_cmd_invoke(dev, inb, in_size, outb, out, out_size, callback, 12161c807f67SHans Petter Selasky context, pages_queue, &status); 121797ac3908SHans Petter Selasky if (err) { 121897ac3908SHans Petter Selasky if (err == -ETIMEDOUT) 121997ac3908SHans Petter Selasky return err; 1220dc7e38acSHans Petter Selasky goto out_out; 122197ac3908SHans Petter Selasky } 1222dc7e38acSHans Petter Selasky 1223dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "err %d, status %d\n", err, status); 1224dc7e38acSHans Petter Selasky if (status) { 1225dc7e38acSHans Petter Selasky err = status_to_err(status); 1226dc7e38acSHans Petter Selasky goto out_out; 1227dc7e38acSHans Petter Selasky } 1228dc7e38acSHans Petter Selasky 1229dc7e38acSHans Petter Selasky if (callback) 1230dc7e38acSHans Petter Selasky return err; 1231dc7e38acSHans Petter Selasky 1232dc7e38acSHans Petter Selasky err = mlx5_copy_from_msg(out, outb, out_size); 1233dc7e38acSHans Petter Selasky 1234dc7e38acSHans Petter Selasky out_out: 1235dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, outb); 1236dc7e38acSHans Petter Selasky 1237dc7e38acSHans Petter Selasky out_in: 1238dc7e38acSHans Petter Selasky free_msg(dev, inb); 1239dc7e38acSHans Petter Selasky return err; 1240dc7e38acSHans Petter Selasky } 1241dc7e38acSHans Petter Selasky 1242dc7e38acSHans Petter Selasky int mlx5_cmd_exec(struct mlx5_core_dev *dev, void *in, int in_size, void *out, 1243dc7e38acSHans Petter Selasky int out_size) 1244dc7e38acSHans Petter Selasky { 1245dc7e38acSHans Petter Selasky return cmd_exec_helper(dev, in, in_size, out, out_size, NULL, NULL); 1246dc7e38acSHans Petter Selasky } 1247dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_exec); 1248dc7e38acSHans Petter Selasky 1249dc7e38acSHans Petter Selasky int mlx5_cmd_exec_cb(struct mlx5_core_dev *dev, void *in, int in_size, 1250dc7e38acSHans Petter Selasky void *out, int out_size, mlx5_cmd_cbk_t callback, 1251dc7e38acSHans Petter Selasky void *context) 1252dc7e38acSHans Petter Selasky { 1253dc7e38acSHans Petter Selasky return cmd_exec_helper(dev, in, in_size, out, out_size, callback, context); 1254dc7e38acSHans Petter Selasky } 1255dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_exec_cb); 1256dc7e38acSHans Petter Selasky 1257dc7e38acSHans Petter Selasky static void destroy_msg_cache(struct mlx5_core_dev *dev) 1258dc7e38acSHans Petter Selasky { 1259dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1260dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg; 1261dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *n; 1262dc7e38acSHans Petter Selasky 1263dc7e38acSHans Petter Selasky list_for_each_entry_safe(msg, n, &cmd->cache.large.head, list) { 1264dc7e38acSHans Petter Selasky list_del(&msg->list); 1265dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, msg); 1266dc7e38acSHans Petter Selasky } 1267dc7e38acSHans Petter Selasky 1268dc7e38acSHans Petter Selasky list_for_each_entry_safe(msg, n, &cmd->cache.med.head, list) { 1269dc7e38acSHans Petter Selasky list_del(&msg->list); 1270dc7e38acSHans Petter Selasky mlx5_free_cmd_msg(dev, msg); 1271dc7e38acSHans Petter Selasky } 1272dc7e38acSHans Petter Selasky } 1273dc7e38acSHans Petter Selasky 1274dc7e38acSHans Petter Selasky static int create_msg_cache(struct mlx5_core_dev *dev) 1275dc7e38acSHans Petter Selasky { 1276dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1277dc7e38acSHans Petter Selasky struct mlx5_cmd_msg *msg; 1278dc7e38acSHans Petter Selasky int err; 1279dc7e38acSHans Petter Selasky int i; 1280dc7e38acSHans Petter Selasky 1281dc7e38acSHans Petter Selasky spin_lock_init(&cmd->cache.large.lock); 1282dc7e38acSHans Petter Selasky INIT_LIST_HEAD(&cmd->cache.large.head); 1283dc7e38acSHans Petter Selasky spin_lock_init(&cmd->cache.med.lock); 1284dc7e38acSHans Petter Selasky INIT_LIST_HEAD(&cmd->cache.med.head); 1285dc7e38acSHans Petter Selasky 1286dc7e38acSHans Petter Selasky for (i = 0; i < NUM_LONG_LISTS; i++) { 1287dc7e38acSHans Petter Selasky msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, LONG_LIST_SIZE); 1288dc7e38acSHans Petter Selasky if (IS_ERR(msg)) { 1289dc7e38acSHans Petter Selasky err = PTR_ERR(msg); 1290dc7e38acSHans Petter Selasky goto ex_err; 1291dc7e38acSHans Petter Selasky } 1292dc7e38acSHans Petter Selasky msg->cache = &cmd->cache.large; 1293dc7e38acSHans Petter Selasky list_add_tail(&msg->list, &cmd->cache.large.head); 1294dc7e38acSHans Petter Selasky } 1295dc7e38acSHans Petter Selasky 1296dc7e38acSHans Petter Selasky for (i = 0; i < NUM_MED_LISTS; i++) { 1297dc7e38acSHans Petter Selasky msg = mlx5_alloc_cmd_msg(dev, GFP_KERNEL, MED_LIST_SIZE); 1298dc7e38acSHans Petter Selasky if (IS_ERR(msg)) { 1299dc7e38acSHans Petter Selasky err = PTR_ERR(msg); 1300dc7e38acSHans Petter Selasky goto ex_err; 1301dc7e38acSHans Petter Selasky } 1302dc7e38acSHans Petter Selasky msg->cache = &cmd->cache.med; 1303dc7e38acSHans Petter Selasky list_add_tail(&msg->list, &cmd->cache.med.head); 1304dc7e38acSHans Petter Selasky } 1305dc7e38acSHans Petter Selasky 1306dc7e38acSHans Petter Selasky return 0; 1307dc7e38acSHans Petter Selasky 1308dc7e38acSHans Petter Selasky ex_err: 1309dc7e38acSHans Petter Selasky destroy_msg_cache(dev); 1310dc7e38acSHans Petter Selasky return err; 1311dc7e38acSHans Petter Selasky } 1312dc7e38acSHans Petter Selasky 13131c807f67SHans Petter Selasky static int 13141c807f67SHans Petter Selasky alloc_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd) 1315dc7e38acSHans Petter Selasky { 13161c807f67SHans Petter Selasky int err; 1317dc7e38acSHans Petter Selasky 13181c807f67SHans Petter Selasky sx_init(&cmd->dma_sx, "MLX5-DMA-SX"); 13191c807f67SHans Petter Selasky mtx_init(&cmd->dma_mtx, "MLX5-DMA-MTX", NULL, MTX_DEF); 13201c807f67SHans Petter Selasky cv_init(&cmd->dma_cv, "MLX5-DMA-CV"); 13211c807f67SHans Petter Selasky 13221c807f67SHans Petter Selasky /* 13231c807f67SHans Petter Selasky * Create global DMA descriptor tag for allocating 13241c807f67SHans Petter Selasky * 4K firmware pages: 13251c807f67SHans Petter Selasky */ 13261c807f67SHans Petter Selasky err = -bus_dma_tag_create( 13271c807f67SHans Petter Selasky bus_get_dma_tag(dev->pdev->dev.bsddev), 13281c807f67SHans Petter Selasky MLX5_ADAPTER_PAGE_SIZE, /* alignment */ 13291c807f67SHans Petter Selasky 0, /* no boundary */ 13301c807f67SHans Petter Selasky BUS_SPACE_MAXADDR, /* lowaddr */ 13311c807f67SHans Petter Selasky BUS_SPACE_MAXADDR, /* highaddr */ 13321c807f67SHans Petter Selasky NULL, NULL, /* filter, filterarg */ 13331c807f67SHans Petter Selasky MLX5_ADAPTER_PAGE_SIZE, /* maxsize */ 13341c807f67SHans Petter Selasky 1, /* nsegments */ 13351c807f67SHans Petter Selasky MLX5_ADAPTER_PAGE_SIZE, /* maxsegsize */ 13361c807f67SHans Petter Selasky 0, /* flags */ 13371c807f67SHans Petter Selasky NULL, NULL, /* lockfunc, lockfuncarg */ 13381c807f67SHans Petter Selasky &cmd->dma_tag); 13391c807f67SHans Petter Selasky if (err != 0) 13401c807f67SHans Petter Selasky goto failure_destroy_sx; 13411c807f67SHans Petter Selasky 13421c807f67SHans Petter Selasky cmd->cmd_page = mlx5_fwp_alloc(dev, GFP_KERNEL, 1); 13431c807f67SHans Petter Selasky if (cmd->cmd_page == NULL) { 13441c807f67SHans Petter Selasky err = -ENOMEM; 13451c807f67SHans Petter Selasky goto failure_alloc_page; 13461c807f67SHans Petter Selasky } 13471c807f67SHans Petter Selasky cmd->dma = mlx5_fwp_get_dma(cmd->cmd_page, 0); 13481c807f67SHans Petter Selasky cmd->cmd_buf = mlx5_fwp_get_virt(cmd->cmd_page, 0); 13491c807f67SHans Petter Selasky return (0); 13501c807f67SHans Petter Selasky 13511c807f67SHans Petter Selasky failure_alloc_page: 13521c807f67SHans Petter Selasky bus_dma_tag_destroy(cmd->dma_tag); 13531c807f67SHans Petter Selasky 13541c807f67SHans Petter Selasky failure_destroy_sx: 13551c807f67SHans Petter Selasky cv_destroy(&cmd->dma_cv); 13561c807f67SHans Petter Selasky mtx_destroy(&cmd->dma_mtx); 13571c807f67SHans Petter Selasky sx_destroy(&cmd->dma_sx); 13581c807f67SHans Petter Selasky return (err); 1359dc7e38acSHans Petter Selasky } 1360dc7e38acSHans Petter Selasky 13611c807f67SHans Petter Selasky static void 13621c807f67SHans Petter Selasky free_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd) 1363dc7e38acSHans Petter Selasky { 13641c807f67SHans Petter Selasky 13651c807f67SHans Petter Selasky mlx5_fwp_free(cmd->cmd_page); 13661c807f67SHans Petter Selasky bus_dma_tag_destroy(cmd->dma_tag); 13671c807f67SHans Petter Selasky cv_destroy(&cmd->dma_cv); 13681c807f67SHans Petter Selasky mtx_destroy(&cmd->dma_mtx); 13691c807f67SHans Petter Selasky sx_destroy(&cmd->dma_sx); 1370dc7e38acSHans Petter Selasky } 1371dc7e38acSHans Petter Selasky 1372dc7e38acSHans Petter Selasky int mlx5_cmd_init(struct mlx5_core_dev *dev) 1373dc7e38acSHans Petter Selasky { 1374dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1375dc7e38acSHans Petter Selasky u32 cmd_h, cmd_l; 1376dc7e38acSHans Petter Selasky u16 cmd_if_rev; 1377dc7e38acSHans Petter Selasky int err; 1378dc7e38acSHans Petter Selasky int i; 1379dc7e38acSHans Petter Selasky 1380dc7e38acSHans Petter Selasky cmd_if_rev = cmdif_rev_get(dev); 1381dc7e38acSHans Petter Selasky if (cmd_if_rev != CMD_IF_REV) { 1382dc7e38acSHans Petter Selasky device_printf((&dev->pdev->dev)->bsddev, "ERR: ""Driver cmdif rev(%d) differs from firmware's(%d)\n", CMD_IF_REV, cmd_if_rev); 1383dc7e38acSHans Petter Selasky return -EINVAL; 1384dc7e38acSHans Petter Selasky } 1385dc7e38acSHans Petter Selasky 1386dc7e38acSHans Petter Selasky err = alloc_cmd_page(dev, cmd); 1387dc7e38acSHans Petter Selasky if (err) 1388dc7e38acSHans Petter Selasky goto err_free_pool; 1389dc7e38acSHans Petter Selasky 1390dc7e38acSHans Petter Selasky cmd_l = ioread32be(&dev->iseg->cmdq_addr_l_sz) & 0xff; 1391dc7e38acSHans Petter Selasky cmd->log_sz = cmd_l >> 4 & 0xf; 1392dc7e38acSHans Petter Selasky cmd->log_stride = cmd_l & 0xf; 1393dc7e38acSHans Petter Selasky if (1 << cmd->log_sz > MLX5_MAX_COMMANDS) { 1394dc7e38acSHans Petter Selasky device_printf((&dev->pdev->dev)->bsddev, "ERR: ""firmware reports too many outstanding commands %d\n", 1 << cmd->log_sz); 1395dc7e38acSHans Petter Selasky err = -EINVAL; 1396dc7e38acSHans Petter Selasky goto err_free_page; 1397dc7e38acSHans Petter Selasky } 1398dc7e38acSHans Petter Selasky 1399dc7e38acSHans Petter Selasky if (cmd->log_sz + cmd->log_stride > MLX5_ADAPTER_PAGE_SHIFT) { 1400dc7e38acSHans Petter Selasky device_printf((&dev->pdev->dev)->bsddev, "ERR: ""command queue size overflow\n"); 1401dc7e38acSHans Petter Selasky err = -EINVAL; 1402dc7e38acSHans Petter Selasky goto err_free_page; 1403dc7e38acSHans Petter Selasky } 1404dc7e38acSHans Petter Selasky 1405dc7e38acSHans Petter Selasky cmd->checksum_disabled = 1; 1406dc7e38acSHans Petter Selasky cmd->max_reg_cmds = (1 << cmd->log_sz) - 1; 1407dc7e38acSHans Petter Selasky cmd->bitmask = (1 << cmd->max_reg_cmds) - 1; 1408dc7e38acSHans Petter Selasky 1409dc7e38acSHans Petter Selasky cmd->cmdif_rev = ioread32be(&dev->iseg->cmdif_rev_fw_sub) >> 16; 1410dc7e38acSHans Petter Selasky if (cmd->cmdif_rev > CMD_IF_REV) { 1411dc7e38acSHans Petter Selasky device_printf((&dev->pdev->dev)->bsddev, "ERR: ""driver does not support command interface version. driver %d, firmware %d\n", CMD_IF_REV, cmd->cmdif_rev); 1412dc7e38acSHans Petter Selasky err = -ENOTSUPP; 1413dc7e38acSHans Petter Selasky goto err_free_page; 1414dc7e38acSHans Petter Selasky } 1415dc7e38acSHans Petter Selasky 1416dc7e38acSHans Petter Selasky spin_lock_init(&cmd->alloc_lock); 1417dc7e38acSHans Petter Selasky spin_lock_init(&cmd->token_lock); 1418dc7e38acSHans Petter Selasky for (i = 0; i < ARRAY_SIZE(cmd->stats); i++) 1419dc7e38acSHans Petter Selasky spin_lock_init(&cmd->stats[i].lock); 1420dc7e38acSHans Petter Selasky 1421dc7e38acSHans Petter Selasky sema_init(&cmd->sem, cmd->max_reg_cmds); 1422dc7e38acSHans Petter Selasky sema_init(&cmd->pages_sem, 1); 1423dc7e38acSHans Petter Selasky 1424dc7e38acSHans Petter Selasky cmd_h = (u32)((u64)(cmd->dma) >> 32); 1425dc7e38acSHans Petter Selasky cmd_l = (u32)(cmd->dma); 1426dc7e38acSHans Petter Selasky if (cmd_l & 0xfff) { 1427dc7e38acSHans Petter Selasky device_printf((&dev->pdev->dev)->bsddev, "ERR: ""invalid command queue address\n"); 1428dc7e38acSHans Petter Selasky err = -ENOMEM; 1429dc7e38acSHans Petter Selasky goto err_free_page; 1430dc7e38acSHans Petter Selasky } 1431dc7e38acSHans Petter Selasky 1432dc7e38acSHans Petter Selasky iowrite32be(cmd_h, &dev->iseg->cmdq_addr_h); 1433dc7e38acSHans Petter Selasky iowrite32be(cmd_l, &dev->iseg->cmdq_addr_l_sz); 1434dc7e38acSHans Petter Selasky 1435dc7e38acSHans Petter Selasky /* Make sure firmware sees the complete address before we proceed */ 1436dc7e38acSHans Petter Selasky wmb(); 1437dc7e38acSHans Petter Selasky 1438dc7e38acSHans Petter Selasky mlx5_core_dbg(dev, "descriptor at dma 0x%llx\n", (unsigned long long)(cmd->dma)); 1439dc7e38acSHans Petter Selasky 1440dc7e38acSHans Petter Selasky cmd->mode = CMD_MODE_POLLING; 1441dc7e38acSHans Petter Selasky 1442dc7e38acSHans Petter Selasky err = create_msg_cache(dev); 1443dc7e38acSHans Petter Selasky if (err) { 1444dc7e38acSHans Petter Selasky device_printf((&dev->pdev->dev)->bsddev, "ERR: ""failed to create command cache\n"); 1445dc7e38acSHans Petter Selasky goto err_free_page; 1446dc7e38acSHans Petter Selasky } 1447dc7e38acSHans Petter Selasky 1448dc7e38acSHans Petter Selasky set_wqname(dev); 1449dc7e38acSHans Petter Selasky cmd->wq = create_singlethread_workqueue(cmd->wq_name); 1450dc7e38acSHans Petter Selasky if (!cmd->wq) { 1451dc7e38acSHans Petter Selasky device_printf((&dev->pdev->dev)->bsddev, "ERR: ""failed to create command workqueue\n"); 1452dc7e38acSHans Petter Selasky err = -ENOMEM; 1453dc7e38acSHans Petter Selasky goto err_cache; 1454dc7e38acSHans Petter Selasky } 1455dc7e38acSHans Petter Selasky 1456dc7e38acSHans Petter Selasky return 0; 1457dc7e38acSHans Petter Selasky 1458dc7e38acSHans Petter Selasky err_cache: 1459dc7e38acSHans Petter Selasky destroy_msg_cache(dev); 1460dc7e38acSHans Petter Selasky 1461dc7e38acSHans Petter Selasky err_free_page: 1462dc7e38acSHans Petter Selasky free_cmd_page(dev, cmd); 1463dc7e38acSHans Petter Selasky 1464dc7e38acSHans Petter Selasky err_free_pool: 1465dc7e38acSHans Petter Selasky return err; 1466dc7e38acSHans Petter Selasky } 1467dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_init); 1468dc7e38acSHans Petter Selasky 1469dc7e38acSHans Petter Selasky void mlx5_cmd_cleanup(struct mlx5_core_dev *dev) 1470dc7e38acSHans Petter Selasky { 1471dc7e38acSHans Petter Selasky struct mlx5_cmd *cmd = &dev->cmd; 1472dc7e38acSHans Petter Selasky 1473dc7e38acSHans Petter Selasky clean_debug_files(dev); 1474dc7e38acSHans Petter Selasky destroy_workqueue(cmd->wq); 1475dc7e38acSHans Petter Selasky destroy_msg_cache(dev); 1476dc7e38acSHans Petter Selasky free_cmd_page(dev, cmd); 1477dc7e38acSHans Petter Selasky } 1478dc7e38acSHans Petter Selasky EXPORT_SYMBOL(mlx5_cmd_cleanup); 1479dc7e38acSHans Petter Selasky 1480dc7e38acSHans Petter Selasky static const char *cmd_status_str(u8 status) 1481dc7e38acSHans Petter Selasky { 1482dc7e38acSHans Petter Selasky switch (status) { 1483dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_OK: 1484dc7e38acSHans Petter Selasky return "OK"; 1485dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_INT_ERR: 1486dc7e38acSHans Petter Selasky return "internal error"; 1487dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_OP_ERR: 1488dc7e38acSHans Petter Selasky return "bad operation"; 1489dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_PARAM_ERR: 1490dc7e38acSHans Petter Selasky return "bad parameter"; 1491dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_SYS_STATE_ERR: 1492dc7e38acSHans Petter Selasky return "bad system state"; 1493dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_ERR: 1494dc7e38acSHans Petter Selasky return "bad resource"; 1495dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_RES_BUSY: 1496dc7e38acSHans Petter Selasky return "resource busy"; 1497dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_LIM_ERR: 1498dc7e38acSHans Petter Selasky return "limits exceeded"; 1499dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_STATE_ERR: 1500dc7e38acSHans Petter Selasky return "bad resource state"; 1501dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_IX_ERR: 1502dc7e38acSHans Petter Selasky return "bad index"; 1503dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_NO_RES_ERR: 1504dc7e38acSHans Petter Selasky return "no resources"; 1505dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_INP_LEN_ERR: 1506dc7e38acSHans Petter Selasky return "bad input length"; 1507dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_OUTP_LEN_ERR: 1508dc7e38acSHans Petter Selasky return "bad output length"; 1509dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_QP_STATE_ERR: 1510dc7e38acSHans Petter Selasky return "bad QP state"; 1511dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_PKT_ERR: 1512dc7e38acSHans Petter Selasky return "bad packet (discarded)"; 1513dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_SIZE_OUTS_CQES_ERR: 1514dc7e38acSHans Petter Selasky return "bad size too many outstanding CQEs"; 1515dc7e38acSHans Petter Selasky default: 1516dc7e38acSHans Petter Selasky return "unknown status"; 1517dc7e38acSHans Petter Selasky } 1518dc7e38acSHans Petter Selasky } 1519dc7e38acSHans Petter Selasky 1520dc7e38acSHans Petter Selasky static int cmd_status_to_err_helper(u8 status) 1521dc7e38acSHans Petter Selasky { 1522dc7e38acSHans Petter Selasky switch (status) { 1523dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_OK: return 0; 1524dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_INT_ERR: return -EIO; 1525dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_OP_ERR: return -EINVAL; 1526dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_PARAM_ERR: return -EINVAL; 1527dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_SYS_STATE_ERR: return -EIO; 1528dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_ERR: return -EINVAL; 1529dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_RES_BUSY: return -EBUSY; 1530dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_LIM_ERR: return -ENOMEM; 1531dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_RES_STATE_ERR: return -EINVAL; 1532dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_IX_ERR: return -EINVAL; 1533dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_NO_RES_ERR: return -EAGAIN; 1534dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_INP_LEN_ERR: return -EIO; 1535dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_OUTP_LEN_ERR: return -EIO; 1536dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_QP_STATE_ERR: return -EINVAL; 1537dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_PKT_ERR: return -EINVAL; 1538dc7e38acSHans Petter Selasky case MLX5_CMD_STAT_BAD_SIZE_OUTS_CQES_ERR: return -EINVAL; 1539dc7e38acSHans Petter Selasky default: return -EIO; 1540dc7e38acSHans Petter Selasky } 1541dc7e38acSHans Petter Selasky } 1542dc7e38acSHans Petter Selasky 1543dc7e38acSHans Petter Selasky /* this will be available till all the commands use set/get macros */ 1544dc7e38acSHans Petter Selasky int mlx5_cmd_status_to_err(struct mlx5_outbox_hdr *hdr) 1545dc7e38acSHans Petter Selasky { 1546dc7e38acSHans Petter Selasky if (!hdr->status) 1547dc7e38acSHans Petter Selasky return 0; 1548dc7e38acSHans Petter Selasky 1549dc7e38acSHans Petter Selasky printf("mlx5_core: WARN: ""command failed, status %s(0x%x), syndrome 0x%x\n", cmd_status_str(hdr->status), hdr->status, be32_to_cpu(hdr->syndrome)); 1550dc7e38acSHans Petter Selasky 1551dc7e38acSHans Petter Selasky return cmd_status_to_err_helper(hdr->status); 1552dc7e38acSHans Petter Selasky } 1553dc7e38acSHans Petter Selasky 1554dc7e38acSHans Petter Selasky int mlx5_cmd_status_to_err_v2(void *ptr) 1555dc7e38acSHans Petter Selasky { 1556dc7e38acSHans Petter Selasky u32 syndrome; 1557dc7e38acSHans Petter Selasky u8 status; 1558dc7e38acSHans Petter Selasky 1559dc7e38acSHans Petter Selasky status = be32_to_cpu(*(__be32 *)ptr) >> 24; 1560dc7e38acSHans Petter Selasky if (!status) 1561dc7e38acSHans Petter Selasky return 0; 1562dc7e38acSHans Petter Selasky 1563dc7e38acSHans Petter Selasky syndrome = be32_to_cpu(*(__be32 *)(ptr + 4)); 1564dc7e38acSHans Petter Selasky 1565dc7e38acSHans Petter Selasky printf("mlx5_core: WARN: ""command failed, status %s(0x%x), syndrome 0x%x\n", cmd_status_str(status), status, syndrome); 1566dc7e38acSHans Petter Selasky 1567dc7e38acSHans Petter Selasky return cmd_status_to_err_helper(status); 1568dc7e38acSHans Petter Selasky } 156930dfc051SHans Petter Selasky 1570