sys/ofed/drivers/net/mlx4/fw.c

   1 /*
   2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
   3  * Copyright (c) 2005, 2006, 2007, 2008, 2014 Mellanox Technologies. All rights reserved.
   4  * Copyright (c) 2005, 2006, 2007 Cisco Systems, Inc.  All rights reserved.
   5  *
   6  * This software is available to you under a choice of one of two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        provided with the distribution.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * SOFTWARE.
  33  */
  34
  35 #include <linux/etherdevice.h>
  36 #include <linux/mlx4/cmd.h>
  37 #include <linux/module.h>
  38 #include <linux/cache.h>
  39
  40 #include "fw.h"
  41 #include "icm.h"
  42
  43 enum {
  44         MLX4_COMMAND_INTERFACE_MIN_REV          = 2,
  45         MLX4_COMMAND_INTERFACE_MAX_REV          = 3,
  46         MLX4_COMMAND_INTERFACE_NEW_PORT_CMDS    = 3,
  47 };
  48
  49 extern void __buggy_use_of_MLX4_GET(void);
  50 extern void __buggy_use_of_MLX4_PUT(void);
  51
  52 static bool enable_qos;
  53 module_param(enable_qos, bool, 0444);
  54 MODULE_PARM_DESC(enable_qos, "Enable Quality of Service support in the HCA (default: off)");
  55
  56 #define MLX4_GET(dest, source, offset)                                \
  57         do {                                                          \
  58                 void *__p = (char *) (source) + (offset);             \
  59                 switch (sizeof (dest)) {                              \
  60                 case 1: (dest) = *(u8 *) __p;       break;            \
  61                 case 2: (dest) = be16_to_cpup(__p); break;            \
  62                 case 4: (dest) = be32_to_cpup(__p); break;            \
  63                 case 8: (dest) = be64_to_cpup(__p); break;            \
  64                 default: __buggy_use_of_MLX4_GET();                   \
  65                 }                                                     \
  66         } while (0)
  67
  68 #define MLX4_PUT(dest, source, offset)                                \
  69         do {                                                          \
  70                 void *__d = ((char *) (dest) + (offset));             \
  71                 switch (sizeof(source)) {                             \
  72                 case 1: *(u8 *) __d = (source);                break; \
  73                 case 2: *(__be16 *) __d = cpu_to_be16(source); break; \
  74                 case 4: *(__be32 *) __d = cpu_to_be32(source); break; \
  75                 case 8: *(__be64 *) __d = cpu_to_be64(source); break; \
  76                 default: __buggy_use_of_MLX4_PUT();                   \
  77                 }                                                     \
  78         } while (0)
  79
  80 static void dump_dev_cap_flags(struct mlx4_dev *dev, u64 flags)
  81 {
  82         static const char *fname[] = {
  83                 [ 0] = "RC transport",
  84                 [ 1] = "UC transport",
  85                 [ 2] = "UD transport",
  86                 [ 3] = "XRC transport",
  87                 [ 4] = "reliable multicast",
  88                 [ 5] = "FCoIB support",
  89                 [ 6] = "SRQ support",
  90                 [ 7] = "IPoIB checksum offload",
  91                 [ 8] = "P_Key violation counter",
  92                 [ 9] = "Q_Key violation counter",
  93                 [10] = "VMM",
  94                 [12] = "DPDP",
  95                 [15] = "Big LSO headers",
  96                 [16] = "MW support",
  97                 [17] = "APM support",
  98                 [18] = "Atomic ops support",
  99                 [19] = "Raw multicast support",
 100                 [20] = "Address vector port checking support",
 101                 [21] = "UD multicast support",
 102                 [24] = "Demand paging support",
 103                 [25] = "Router support",
 104                 [30] = "IBoE support",
 105                 [32] = "Unicast loopback support",
 106                 [34] = "FCS header control",
 107                 [38] = "Wake On LAN support",
 108                 [40] = "UDP RSS support",
 109                 [41] = "Unicast VEP steering support",
 110                 [42] = "Multicast VEP steering support",
 111                 [44] = "Cross-channel (sync_qp) operations support",
 112                 [48] = "Counters support",
 113                 [59] = "Port management change event support",
 114                 [60] = "eSwitch support",
 115                 [61] = "64 byte EQE support",
 116                 [62] = "64 byte CQE support",
 117         };
 118         int i;
 119
 120         mlx4_dbg(dev, "DEV_CAP flags:\n");
 121         for (i = 0; i < ARRAY_SIZE(fname); ++i)
 122                 if (fname[i] && (flags & (1LL << i)))
 123                         mlx4_dbg(dev, "    %s\n", fname[i]);
 124 }
 125
 126 static void dump_dev_cap_flags2(struct mlx4_dev *dev, u64 flags)
 127 {
 128         static const char * const fname[] = {
 129                 [0] = "RSS support",
 130                 [1] = "RSS Toeplitz Hash Function support",
 131                 [2] = "RSS XOR Hash Function support",
 132                 [3] = "Device manage flow steering support",
 133                 [4] = "FSM (MAC unti-spoofing) support",
 134                 [5] = "VST (control vlan insertion/stripping) support",
 135                 [6] = "Dynamic QP updates support",
 136                 [7] = "Loopback source checks support",
 137                 [8] = "Device managed flow steering IPoIB support",
 138                 [9] = "ETS configuration support",
 139                 [10] = "ETH backplane autoneg report",
 140                 [11] = "Ethernet Flow control statistics support",
 141                 [12] = "Recoverable error events support",
 142                 [13] = "Time stamping support",
 143                 [14] = "Report driver version to FW support"
 144         };
 145         int i;
 146
 147         for (i = 0; i < ARRAY_SIZE(fname); ++i)
 148                 if (fname[i] && (flags & (1LL << i)))
 149                         mlx4_dbg(dev, "    %s\n", fname[i]);
 150 }
 151
 152 int mlx4_MOD_STAT_CFG(struct mlx4_dev *dev, struct mlx4_mod_stat_cfg *cfg)
 153 {
 154         struct mlx4_cmd_mailbox *mailbox;
 155         u32 *inbox;
 156         int err = 0;
 157
 158 #define MOD_STAT_CFG_IN_SIZE            0x100
 159
 160 #define MOD_STAT_CFG_PG_SZ_M_OFFSET     0x002
 161 #define MOD_STAT_CFG_PG_SZ_OFFSET       0x003
 162
 163         mailbox = mlx4_alloc_cmd_mailbox(dev);
 164         if (IS_ERR(mailbox))
 165                 return PTR_ERR(mailbox);
 166         inbox = mailbox->buf;
 167
 168         memset(inbox, 0, MOD_STAT_CFG_IN_SIZE);
 169
 170         MLX4_PUT(inbox, cfg->log_pg_sz, MOD_STAT_CFG_PG_SZ_OFFSET);
 171         MLX4_PUT(inbox, cfg->log_pg_sz_m, MOD_STAT_CFG_PG_SZ_M_OFFSET);
 172
 173         err = mlx4_cmd(dev, mailbox->dma, 0, 0, MLX4_CMD_MOD_STAT_CFG,
 174                         MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
 175
 176         mlx4_free_cmd_mailbox(dev, mailbox);
 177         return err;
 178 }
 179
 180 int mlx4_QUERY_FUNC(struct mlx4_dev *dev, struct mlx4_func *func, int slave)
 181 {
 182         struct mlx4_cmd_mailbox *mailbox;
 183         u32 *outbox;
 184         u8 in_modifier;
 185         u8 field;
 186         u16 field16;
 187         int err;
 188
 189 #define QUERY_FUNC_BUS_OFFSET                   0x00
 190 #define QUERY_FUNC_DEVICE_OFFSET                0x01
 191 #define QUERY_FUNC_FUNCTION_OFFSET              0x01
 192 #define QUERY_FUNC_PHYSICAL_FUNCTION_OFFSET     0x03
 193 #define QUERY_FUNC_RSVD_EQS_OFFSET              0x04
 194 #define QUERY_FUNC_MAX_EQ_OFFSET                0x06
 195 #define QUERY_FUNC_RSVD_UARS_OFFSET             0x0b
 196
 197         mailbox = mlx4_alloc_cmd_mailbox(dev);
 198         if (IS_ERR(mailbox))
 199                 return PTR_ERR(mailbox);
 200         outbox = mailbox->buf;
 201
 202         in_modifier = slave;
 203
 204         err = mlx4_cmd_box(dev, 0, mailbox->dma, in_modifier, 0,
 205                         MLX4_CMD_QUERY_FUNC,
 206                         MLX4_CMD_TIME_CLASS_A,
 207                         MLX4_CMD_NATIVE);
 208         if (err)
 209                 goto out;
 210
 211         MLX4_GET(field, outbox, QUERY_FUNC_BUS_OFFSET);
 212         func->bus = field & 0xf;
 213         MLX4_GET(field, outbox, QUERY_FUNC_DEVICE_OFFSET);
 214         func->device = field & 0xf1;
 215         MLX4_GET(field, outbox, QUERY_FUNC_FUNCTION_OFFSET);
 216         func->function = field & 0x7;
 217         MLX4_GET(field, outbox, QUERY_FUNC_PHYSICAL_FUNCTION_OFFSET);
 218         func->physical_function = field & 0xf;
 219         MLX4_GET(field16, outbox, QUERY_FUNC_RSVD_EQS_OFFSET);
 220         func->rsvd_eqs = field16 & 0xffff;
 221         MLX4_GET(field16, outbox, QUERY_FUNC_MAX_EQ_OFFSET);
 222         func->max_eq = field16 & 0xffff;
 223         MLX4_GET(field, outbox, QUERY_FUNC_RSVD_UARS_OFFSET);
 224         func->rsvd_uars = field & 0x0f;
 225
 226         mlx4_dbg(dev, "Bus: %d, Device: %d, Function: %d, Physical function: %d, Max EQs: %d, Reserved EQs: %d, Reserved UARs: %d\n",
 227                 func->bus, func->device, func->function, func->physical_function,
 228                 func->max_eq, func->rsvd_eqs, func->rsvd_uars);
 229 out:
 230         mlx4_free_cmd_mailbox(dev, mailbox);
 231         return err;
 232 }
 233
 234 int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
 235                                 struct mlx4_vhcr *vhcr,
 236                                 struct mlx4_cmd_mailbox *inbox,
 237                                 struct mlx4_cmd_mailbox *outbox,
 238                                 struct mlx4_cmd_info *cmd)
 239 {
 240         struct mlx4_priv *priv = mlx4_priv(dev);
 241         u8      field, port;
 242         u32     size;
 243         int     err = 0;
 244         struct mlx4_func func;
 245
 246 #define QUERY_FUNC_CAP_FLAGS_OFFSET             0x0
 247 #define QUERY_FUNC_CAP_NUM_PORTS_OFFSET         0x1
 248 #define QUERY_FUNC_CAP_PF_BHVR_OFFSET           0x4
 249 #define QUERY_FUNC_CAP_FMR_OFFSET               0x8
 250 #define QUERY_FUNC_CAP_QP_QUOTA_OFFSET_DEP      0x10
 251 #define QUERY_FUNC_CAP_CQ_QUOTA_OFFSET_DEP      0x14
 252 #define QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET_DEP     0x18
 253 #define QUERY_FUNC_CAP_MPT_QUOTA_OFFSET_DEP     0x20
 254 #define QUERY_FUNC_CAP_MTT_QUOTA_OFFSET_DEP     0x24
 255 #define QUERY_FUNC_CAP_MCG_QUOTA_OFFSET_DEP     0x28
 256 #define QUERY_FUNC_CAP_MAX_EQ_OFFSET            0x2c
 257 #define QUERY_FUNC_CAP_RESERVED_EQ_OFFSET       0x30
 258
 259 #define QUERY_FUNC_CAP_QP_QUOTA_OFFSET          0x50
 260 #define QUERY_FUNC_CAP_CQ_QUOTA_OFFSET          0x54
 261 #define QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET         0x58
 262 #define QUERY_FUNC_CAP_MPT_QUOTA_OFFSET         0x60
 263 #define QUERY_FUNC_CAP_MTT_QUOTA_OFFSET         0x64
 264 #define QUERY_FUNC_CAP_MCG_QUOTA_OFFSET         0x68
 265
 266 #define QUERY_FUNC_CAP_EXTRA_FLAGS_OFFSET       0x6c
 267
 268 #define QUERY_FUNC_CAP_FMR_FLAG                 0x80
 269 #define QUERY_FUNC_CAP_FLAG_RDMA                0x40
 270 #define QUERY_FUNC_CAP_FLAG_ETH                 0x80
 271 #define QUERY_FUNC_CAP_FLAG_QUOTAS              0x10
 272 #define QUERY_FUNC_CAP_FLAG_VALID_MAILBOX       0x04
 273
 274 #define QUERY_FUNC_CAP_EXTRA_FLAGS_BF_QP_ALLOC_FLAG     (1UL << 31)
 275
 276 /* when opcode modifier = 1 */
 277 #define QUERY_FUNC_CAP_PHYS_PORT_OFFSET         0x3
 278 #define QUERY_FUNC_CAP_FLAGS0_OFFSET            0x8
 279 #define QUERY_FUNC_CAP_FLAGS1_OFFSET            0xc
 280 #define QUERY_FUNC_CAP_COUNTER_INDEX_OFFSET     0xd
 281
 282 #define QUERY_FUNC_CAP_QP0_TUNNEL               0x10
 283 #define QUERY_FUNC_CAP_QP0_PROXY                0x14
 284 #define QUERY_FUNC_CAP_QP1_TUNNEL               0x18
 285 #define QUERY_FUNC_CAP_QP1_PROXY                0x1c
 286
 287 #define QUERY_FUNC_CAP_ETH_PROPS_FORCE_MAC      0x40
 288 #define QUERY_FUNC_CAP_ETH_PROPS_FORCE_VLAN     0x80
 289 #define QUERY_FUNC_CAP_PROPS_DEF_COUNTER        0x20
 290
 291 #define QUERY_FUNC_CAP_RDMA_PROPS_FORCE_PHY_WQE_GID 0x80
 292 #define QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS (1 << 31)
 293
 294         if (vhcr->op_modifier == 1) {
 295                 port = vhcr->in_modifier; /* phys-port = logical-port */
 296                 MLX4_PUT(outbox->buf, port, QUERY_FUNC_CAP_PHYS_PORT_OFFSET);
 297
 298                 field = 0;
 299                 /* ensure that phy_wqe_gid bit is not set */
 300                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_FLAGS0_OFFSET);
 301
 302                 /* ensure force vlan and force mac bits are not set
 303                  * and that default counter bit is set
 304                  */
 305                 field = QUERY_FUNC_CAP_PROPS_DEF_COUNTER; /* def counter */
 306                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_FLAGS1_OFFSET);
 307
 308                 /* There is always default counter legal or sink counter */
 309                 field = mlx4_get_default_counter_index(dev, slave, vhcr->in_modifier);
 310                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_COUNTER_INDEX_OFFSET);
 311
 312                 /* size is now the QP number */
 313                 size = dev->phys_caps.base_tunnel_sqpn + 8 * slave + port - 1;
 314                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP0_TUNNEL);
 315
 316                 size += 2;
 317                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP1_TUNNEL);
 318
 319                 size = dev->phys_caps.base_proxy_sqpn + 8 * slave + port - 1;
 320                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP0_PROXY);
 321
 322                 size += 2;
 323                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP1_PROXY);
 324
 325         } else if (vhcr->op_modifier == 0) {
 326                 /* enable rdma and ethernet interfaces, and new quota locations */
 327                 field = (QUERY_FUNC_CAP_FLAG_ETH | QUERY_FUNC_CAP_FLAG_RDMA |
 328                          QUERY_FUNC_CAP_FLAG_QUOTAS | QUERY_FUNC_CAP_FLAG_VALID_MAILBOX);
 329                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_FLAGS_OFFSET);
 330
 331                 field = dev->caps.num_ports;
 332                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_NUM_PORTS_OFFSET);
 333
 334                 size = dev->caps.function_caps; /* set PF behaviours */
 335                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_PF_BHVR_OFFSET);
 336
 337                 field = 0; /* protected FMR support not available as yet */
 338                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_FMR_OFFSET);
 339
 340                 size = priv->mfunc.master.res_tracker.res_alloc[RES_QP].quota[slave];
 341                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP_QUOTA_OFFSET);
 342                 size = dev->caps.num_qps;
 343                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP_QUOTA_OFFSET_DEP);
 344
 345                 size = priv->mfunc.master.res_tracker.res_alloc[RES_SRQ].quota[slave];
 346                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET);
 347                 size = dev->caps.num_srqs;
 348                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET_DEP);
 349
 350                 size = priv->mfunc.master.res_tracker.res_alloc[RES_CQ].quota[slave];
 351                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_CQ_QUOTA_OFFSET);
 352                 size = dev->caps.num_cqs;
 353                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_CQ_QUOTA_OFFSET_DEP);
 354
 355                 if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS) ||
 356                     mlx4_QUERY_FUNC(dev, &func, slave)) {
 357                         size = vhcr->in_modifier &
 358                                 QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS ?
 359                                 dev->caps.num_eqs :
 360                                 rounddown_pow_of_two(dev->caps.num_eqs);
 361                         MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MAX_EQ_OFFSET);
 362                         size = dev->caps.reserved_eqs;
 363                         MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
 364                 } else {
 365                         size = vhcr->in_modifier &
 366                                 QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS ?
 367                                 func.max_eq :
 368                                 rounddown_pow_of_two(func.max_eq);
 369                         MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MAX_EQ_OFFSET);
 370                         size = func.rsvd_eqs;
 371                         MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
 372                 }
 373
 374                 size = priv->mfunc.master.res_tracker.res_alloc[RES_MPT].quota[slave];
 375                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MPT_QUOTA_OFFSET);
 376                 size = dev->caps.num_mpts;
 377                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MPT_QUOTA_OFFSET_DEP);
 378
 379                 size = priv->mfunc.master.res_tracker.res_alloc[RES_MTT].quota[slave];
 380                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MTT_QUOTA_OFFSET);
 381                 size = dev->caps.num_mtts;
 382                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MTT_QUOTA_OFFSET_DEP);
 383
 384                 size = dev->caps.num_mgms + dev->caps.num_amgms;
 385                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MCG_QUOTA_OFFSET);
 386                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MCG_QUOTA_OFFSET_DEP);
 387
 388                 size = QUERY_FUNC_CAP_EXTRA_FLAGS_BF_QP_ALLOC_FLAG;
 389                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_EXTRA_FLAGS_OFFSET);
 390         } else
 391                 err = -EINVAL;
 392
 393         return err;
 394 }
 395
 396 int mlx4_QUERY_FUNC_CAP(struct mlx4_dev *dev, u32 gen_or_port,
 397                         struct mlx4_func_cap *func_cap)
 398 {
 399         struct mlx4_cmd_mailbox *mailbox;
 400         u32                     *outbox;
 401         u8                      field, op_modifier;
 402         u32                     size;
 403         int                     err = 0, quotas = 0;
 404         u32                     in_modifier;
 405
 406         op_modifier = !!gen_or_port; /* 0 = general, 1 = logical port */
 407         in_modifier = op_modifier ? gen_or_port :
 408                 QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS;
 409
 410         mailbox = mlx4_alloc_cmd_mailbox(dev);
 411         if (IS_ERR(mailbox))
 412                 return PTR_ERR(mailbox);
 413
 414         err = mlx4_cmd_box(dev, 0, mailbox->dma, in_modifier, op_modifier,
 415                            MLX4_CMD_QUERY_FUNC_CAP,
 416                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
 417         if (err)
 418                 goto out;
 419
 420         outbox = mailbox->buf;
 421
 422         if (!op_modifier) {
 423                 MLX4_GET(field, outbox, QUERY_FUNC_CAP_FLAGS_OFFSET);
 424                 if (!(field & (QUERY_FUNC_CAP_FLAG_ETH | QUERY_FUNC_CAP_FLAG_RDMA))) {
 425                         mlx4_err(dev, "The host supports neither eth nor rdma interfaces\n");
 426                         err = -EPROTONOSUPPORT;
 427                         goto out;
 428                 }
 429                 func_cap->flags = field;
 430                 quotas = !!(func_cap->flags & QUERY_FUNC_CAP_FLAG_QUOTAS);
 431
 432                 MLX4_GET(field, outbox, QUERY_FUNC_CAP_NUM_PORTS_OFFSET);
 433                 func_cap->num_ports = field;
 434
 435                 MLX4_GET(size, outbox, QUERY_FUNC_CAP_PF_BHVR_OFFSET);
 436                 func_cap->pf_context_behaviour = size;
 437
 438                 if (quotas) {
 439                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP_QUOTA_OFFSET);
 440                         func_cap->qp_quota = size & 0xFFFFFF;
 441
 442                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET);
 443                         func_cap->srq_quota = size & 0xFFFFFF;
 444
 445                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_CQ_QUOTA_OFFSET);
 446                         func_cap->cq_quota = size & 0xFFFFFF;
 447
 448                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MPT_QUOTA_OFFSET);
 449                         func_cap->mpt_quota = size & 0xFFFFFF;
 450
 451                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MTT_QUOTA_OFFSET);
 452                         func_cap->mtt_quota = size & 0xFFFFFF;
 453
 454                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MCG_QUOTA_OFFSET);
 455                         func_cap->mcg_quota = size & 0xFFFFFF;
 456
 457                 } else {
 458                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP_QUOTA_OFFSET_DEP);
 459                         func_cap->qp_quota = size & 0xFFFFFF;
 460
 461                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET_DEP);
 462                         func_cap->srq_quota = size & 0xFFFFFF;
 463
 464                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_CQ_QUOTA_OFFSET_DEP);
 465                         func_cap->cq_quota = size & 0xFFFFFF;
 466
 467                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MPT_QUOTA_OFFSET_DEP);
 468                         func_cap->mpt_quota = size & 0xFFFFFF;
 469
 470                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MTT_QUOTA_OFFSET_DEP);
 471                         func_cap->mtt_quota = size & 0xFFFFFF;
 472
 473                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MCG_QUOTA_OFFSET_DEP);
 474                         func_cap->mcg_quota = size & 0xFFFFFF;
 475                 }
 476                 MLX4_GET(size, outbox, QUERY_FUNC_CAP_MAX_EQ_OFFSET);
 477                 func_cap->max_eq = size & 0xFFFFFF;
 478
 479                 MLX4_GET(size, outbox, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
 480                 func_cap->reserved_eq = size & 0xFFFFFF;
 481
 482                 func_cap->extra_flags = 0;
 483
 484                 /* Mailbox data from 0x6c and onward should only be treated if
 485                  * QUERY_FUNC_CAP_FLAG_VALID_MAILBOX is set in func_cap->flags
 486                  */
 487                 if (func_cap->flags & QUERY_FUNC_CAP_FLAG_VALID_MAILBOX) {
 488                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_EXTRA_FLAGS_OFFSET);
 489                         if (size & QUERY_FUNC_CAP_EXTRA_FLAGS_BF_QP_ALLOC_FLAG)
 490                                 func_cap->extra_flags |= MLX4_QUERY_FUNC_FLAGS_BF_RES_QP;
 491                 }
 492
 493                 goto out;
 494         }
 495
 496         /* logical port query */
 497         if (gen_or_port > dev->caps.num_ports) {
 498                 err = -EINVAL;
 499                 goto out;
 500         }
 501
 502         if (dev->caps.port_type[gen_or_port] == MLX4_PORT_TYPE_ETH) {
 503                 MLX4_GET(field, outbox, QUERY_FUNC_CAP_FLAGS1_OFFSET);
 504                 if (field & QUERY_FUNC_CAP_ETH_PROPS_FORCE_VLAN) {
 505                         mlx4_err(dev, "VLAN is enforced on this port\n");
 506                         err = -EPROTONOSUPPORT;
 507                         goto out;
 508                 }
 509
 510                 if (field & QUERY_FUNC_CAP_ETH_PROPS_FORCE_MAC) {
 511                         mlx4_err(dev, "Force mac is enabled on this port\n");
 512                         err = -EPROTONOSUPPORT;
 513                         goto out;
 514                 }
 515         } else if (dev->caps.port_type[gen_or_port] == MLX4_PORT_TYPE_IB) {
 516                 MLX4_GET(field, outbox, QUERY_FUNC_CAP_FLAGS0_OFFSET);
 517                 if (field & QUERY_FUNC_CAP_RDMA_PROPS_FORCE_PHY_WQE_GID) {
 518                         mlx4_err(dev, "phy_wqe_gid is "
 519                                  "enforced on this ib port\n");
 520                         err = -EPROTONOSUPPORT;
 521                         goto out;
 522                 }
 523         }
 524
 525         MLX4_GET(field, outbox, QUERY_FUNC_CAP_PHYS_PORT_OFFSET);
 526         func_cap->physical_port = field;
 527         if (func_cap->physical_port != gen_or_port) {
 528                 err = -ENOSYS;
 529                 goto out;
 530         }
 531
 532         MLX4_GET(field, outbox, QUERY_FUNC_CAP_FLAGS1_OFFSET);
 533         if (field & QUERY_FUNC_CAP_PROPS_DEF_COUNTER) {
 534                 MLX4_GET(field, outbox, QUERY_FUNC_CAP_COUNTER_INDEX_OFFSET);
 535                 func_cap->def_counter_index = field;
 536         } else {
 537                 func_cap->def_counter_index = MLX4_SINK_COUNTER_INDEX;
 538         }
 539
 540         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP0_TUNNEL);
 541         func_cap->qp0_tunnel_qpn = size & 0xFFFFFF;
 542
 543         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP0_PROXY);
 544         func_cap->qp0_proxy_qpn = size & 0xFFFFFF;
 545
 546         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP1_TUNNEL);
 547         func_cap->qp1_tunnel_qpn = size & 0xFFFFFF;
 548
 549         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP1_PROXY);
 550         func_cap->qp1_proxy_qpn = size & 0xFFFFFF;
 551
 552         /* All other resources are allocated by the master, but we still report
 553          * 'num' and 'reserved' capabilities as follows:
 554          * - num remains the maximum resource index
 555          * - 'num - reserved' is the total available objects of a resource, but
 556          *   resource indices may be less than 'reserved'
 557          * TODO: set per-resource quotas */
 558
 559 out:
 560         mlx4_free_cmd_mailbox(dev, mailbox);
 561
 562         return err;
 563 }
 564
 565 int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
 566 {
 567         struct mlx4_cmd_mailbox *mailbox;
 568         u32 *outbox;
 569         u8 field;
 570         u32 field32, flags, ext_flags;
 571         u16 size;
 572         u16 stat_rate;
 573         int err;
 574         int i;
 575
 576 #define QUERY_DEV_CAP_OUT_SIZE                 0x100
 577 #define QUERY_DEV_CAP_MAX_SRQ_SZ_OFFSET         0x10
 578 #define QUERY_DEV_CAP_MAX_QP_SZ_OFFSET          0x11
 579 #define QUERY_DEV_CAP_RSVD_QP_OFFSET            0x12
 580 #define QUERY_DEV_CAP_MAX_QP_OFFSET             0x13
 581 #define QUERY_DEV_CAP_RSVD_SRQ_OFFSET           0x14
 582 #define QUERY_DEV_CAP_MAX_SRQ_OFFSET            0x15
 583 #define QUERY_DEV_CAP_RSVD_EEC_OFFSET           0x16
 584 #define QUERY_DEV_CAP_MAX_EEC_OFFSET            0x17
 585 #define QUERY_DEV_CAP_MAX_CQ_SZ_OFFSET          0x19
 586 #define QUERY_DEV_CAP_RSVD_CQ_OFFSET            0x1a
 587 #define QUERY_DEV_CAP_MAX_CQ_OFFSET             0x1b
 588 #define QUERY_DEV_CAP_MAX_MPT_OFFSET            0x1d
 589 #define QUERY_DEV_CAP_RSVD_EQ_OFFSET            0x1e
 590 #define QUERY_DEV_CAP_MAX_EQ_OFFSET             0x1f
 591 #define QUERY_DEV_CAP_RSVD_MTT_OFFSET           0x20
 592 #define QUERY_DEV_CAP_MAX_MRW_SZ_OFFSET         0x21
 593 #define QUERY_DEV_CAP_RSVD_MRW_OFFSET           0x22
 594 #define QUERY_DEV_CAP_MAX_MTT_SEG_OFFSET        0x23
 595 #define QUERY_DEV_CAP_NUM_SYS_EQ_OFFSET         0x26
 596 #define QUERY_DEV_CAP_MAX_AV_OFFSET             0x27
 597 #define QUERY_DEV_CAP_MAX_REQ_QP_OFFSET         0x29
 598 #define QUERY_DEV_CAP_MAX_RES_QP_OFFSET         0x2b
 599 #define QUERY_DEV_CAP_MAX_GSO_OFFSET            0x2d
 600 #define QUERY_DEV_CAP_RSS_OFFSET                0x2e
 601 #define QUERY_DEV_CAP_MAX_RDMA_OFFSET           0x2f
 602 #define QUERY_DEV_CAP_RSZ_SRQ_OFFSET            0x33
 603 #define QUERY_DEV_CAP_ACK_DELAY_OFFSET          0x35
 604 #define QUERY_DEV_CAP_MTU_WIDTH_OFFSET          0x36
 605 #define QUERY_DEV_CAP_VL_PORT_OFFSET            0x37
 606 #define QUERY_DEV_CAP_MAX_MSG_SZ_OFFSET         0x38
 607 #define QUERY_DEV_CAP_MAX_GID_OFFSET            0x3b
 608 #define QUERY_DEV_CAP_RATE_SUPPORT_OFFSET       0x3c
 609 #define QUERY_DEV_CAP_CQ_TS_SUPPORT_OFFSET      0x3e
 610 #define QUERY_DEV_CAP_MAX_PKEY_OFFSET           0x3f
 611 #define QUERY_DEV_CAP_EXT_FLAGS_OFFSET          0x40
 612 #define QUERY_DEV_CAP_SYNC_QP_OFFSET            0x42
 613 #define QUERY_DEV_CAP_FLAGS_OFFSET              0x44
 614 #define QUERY_DEV_CAP_RSVD_UAR_OFFSET           0x48
 615 #define QUERY_DEV_CAP_UAR_SZ_OFFSET             0x49
 616 #define QUERY_DEV_CAP_PAGE_SZ_OFFSET            0x4b
 617 #define QUERY_DEV_CAP_BF_OFFSET                 0x4c
 618 #define QUERY_DEV_CAP_LOG_BF_REG_SZ_OFFSET      0x4d
 619 #define QUERY_DEV_CAP_LOG_MAX_BF_REGS_PER_PAGE_OFFSET   0x4e
 620 #define QUERY_DEV_CAP_LOG_MAX_BF_PAGES_OFFSET   0x4f
 621 #define QUERY_DEV_CAP_MAX_SG_SQ_OFFSET          0x51
 622 #define QUERY_DEV_CAP_MAX_DESC_SZ_SQ_OFFSET     0x52
 623 #define QUERY_DEV_CAP_MAX_SG_RQ_OFFSET          0x55
 624 #define QUERY_DEV_CAP_MAX_DESC_SZ_RQ_OFFSET     0x56
 625 #define QUERY_DEV_CAP_MAX_QP_MCG_OFFSET         0x61
 626 #define QUERY_DEV_CAP_RSVD_MCG_OFFSET           0x62
 627 #define QUERY_DEV_CAP_MAX_MCG_OFFSET            0x63
 628 #define QUERY_DEV_CAP_RSVD_PD_OFFSET            0x64
 629 #define QUERY_DEV_CAP_MAX_PD_OFFSET             0x65
 630 #define QUERY_DEV_CAP_RSVD_XRC_OFFSET           0x66
 631 #define QUERY_DEV_CAP_MAX_XRC_OFFSET            0x67
 632 #define QUERY_DEV_CAP_MAX_BASIC_COUNTERS_OFFSET 0x68
 633 #define QUERY_DEV_CAP_MAX_EXTENDED_COUNTERS_OFFSET      0x6c
 634 #define QUERY_DEV_CAP_PORT_FLOWSTATS_COUNTERS_OFFSET    0x70
 635 #define QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET     0x76
 636 #define QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET                0x70
 637 #define QUERY_DEV_CAP_FLOW_STEERING_IPOIB_OFFSET        0x74
 638 #define QUERY_DEV_CAP_FLOW_STEERING_MAX_QP_OFFSET       0x77
 639 #define QUERY_DEV_CAP_RDMARC_ENTRY_SZ_OFFSET    0x80
 640 #define QUERY_DEV_CAP_QPC_ENTRY_SZ_OFFSET       0x82
 641 #define QUERY_DEV_CAP_AUX_ENTRY_SZ_OFFSET       0x84
 642 #define QUERY_DEV_CAP_ALTC_ENTRY_SZ_OFFSET      0x86
 643 #define QUERY_DEV_CAP_EQC_ENTRY_SZ_OFFSET       0x88
 644 #define QUERY_DEV_CAP_CQC_ENTRY_SZ_OFFSET       0x8a
 645 #define QUERY_DEV_CAP_SRQ_ENTRY_SZ_OFFSET       0x8c
 646 #define QUERY_DEV_CAP_C_MPT_ENTRY_SZ_OFFSET     0x8e
 647 #define QUERY_DEV_CAP_MTT_ENTRY_SZ_OFFSET       0x90
 648 #define QUERY_DEV_CAP_D_MPT_ENTRY_SZ_OFFSET     0x92
 649 #define QUERY_DEV_CAP_BMME_FLAGS_OFFSET         0x94
 650 #define QUERY_DEV_CAP_RSVD_LKEY_OFFSET          0x98
 651 #define QUERY_DEV_CAP_ETS_CFG_OFFSET            0x9c
 652 #define QUERY_DEV_CAP_MAX_ICM_SZ_OFFSET         0xa0
 653
 654         dev_cap->flags2 = 0;
 655         mailbox = mlx4_alloc_cmd_mailbox(dev);
 656         if (IS_ERR(mailbox))
 657                 return PTR_ERR(mailbox);
 658         outbox = mailbox->buf;
 659
 660         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0, MLX4_CMD_QUERY_DEV_CAP,
 661                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
 662         if (err)
 663                 goto out;
 664
 665         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_QP_OFFSET);
 666         dev_cap->reserved_qps = 1 << (field & 0xf);
 667         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_QP_OFFSET);
 668         dev_cap->max_qps = 1 << (field & 0x1f);
 669         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_SRQ_OFFSET);
 670         dev_cap->reserved_srqs = 1 << (field >> 4);
 671         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_SRQ_OFFSET);
 672         dev_cap->max_srqs = 1 << (field & 0x1f);
 673         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_CQ_SZ_OFFSET);
 674         dev_cap->max_cq_sz = 1 << field;
 675         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_CQ_OFFSET);
 676         dev_cap->reserved_cqs = 1 << (field & 0xf);
 677         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_CQ_OFFSET);
 678         dev_cap->max_cqs = 1 << (field & 0x1f);
 679         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MPT_OFFSET);
 680         dev_cap->max_mpts = 1 << (field & 0x3f);
 681         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_EQ_OFFSET);
 682         dev_cap->reserved_eqs = field & 0xf;
 683         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_EQ_OFFSET);
 684         dev_cap->max_eqs = 1 << (field & 0xf);
 685         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_MTT_OFFSET);
 686         dev_cap->reserved_mtts = 1 << (field >> 4);
 687         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MRW_SZ_OFFSET);
 688         dev_cap->max_mrw_sz = 1 << field;
 689         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_MRW_OFFSET);
 690         dev_cap->reserved_mrws = 1 << (field & 0xf);
 691         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MTT_SEG_OFFSET);
 692         dev_cap->max_mtt_seg = 1 << (field & 0x3f);
 693         MLX4_GET(size, outbox, QUERY_DEV_CAP_NUM_SYS_EQ_OFFSET);
 694         dev_cap->num_sys_eqs = size & 0xfff;
 695         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_REQ_QP_OFFSET);
 696         dev_cap->max_requester_per_qp = 1 << (field & 0x3f);
 697         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_RES_QP_OFFSET);
 698         dev_cap->max_responder_per_qp = 1 << (field & 0x3f);
 699         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_GSO_OFFSET);
 700         field &= 0x1f;
 701         if (!field)
 702                 dev_cap->max_gso_sz = 0;
 703         else
 704                 dev_cap->max_gso_sz = 1 << field;
 705
 706         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSS_OFFSET);
 707         if (field & 0x20)
 708                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_RSS_XOR;
 709         if (field & 0x10)
 710                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_RSS_TOP;
 711         field &= 0xf;
 712         if (field) {
 713                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_RSS;
 714                 dev_cap->max_rss_tbl_sz = 1 << field;
 715         } else
 716                 dev_cap->max_rss_tbl_sz = 0;
 717         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_RDMA_OFFSET);
 718         dev_cap->max_rdma_global = 1 << (field & 0x3f);
 719         MLX4_GET(field, outbox, QUERY_DEV_CAP_ACK_DELAY_OFFSET);
 720         dev_cap->local_ca_ack_delay = field & 0x1f;
 721         MLX4_GET(field, outbox, QUERY_DEV_CAP_VL_PORT_OFFSET);
 722         dev_cap->num_ports = field & 0xf;
 723         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MSG_SZ_OFFSET);
 724         dev_cap->max_msg_sz = 1 << (field & 0x1f);
 725         MLX4_GET(field, outbox, QUERY_DEV_CAP_PORT_FLOWSTATS_COUNTERS_OFFSET);
 726         if (field & 0x10)
 727                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_FLOWSTATS_EN;
 728         MLX4_GET(field, outbox, QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET);
 729         if (field & 0x80)
 730                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_FS_EN;
 731         MLX4_GET(field, outbox, QUERY_DEV_CAP_FLOW_STEERING_IPOIB_OFFSET);
 732         if (field & 0x80)
 733                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_DMFS_IPOIB;
 734         dev_cap->fs_log_max_ucast_qp_range_size = field & 0x1f;
 735         MLX4_GET(field, outbox, QUERY_DEV_CAP_FLOW_STEERING_MAX_QP_OFFSET);
 736         dev_cap->fs_max_num_qp_per_entry = field;
 737         MLX4_GET(stat_rate, outbox, QUERY_DEV_CAP_RATE_SUPPORT_OFFSET);
 738         dev_cap->stat_rate_support = stat_rate;
 739         MLX4_GET(field, outbox, QUERY_DEV_CAP_CQ_TS_SUPPORT_OFFSET);
 740         if (field & 0x80)
 741                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_TS;
 742         MLX4_GET(ext_flags, outbox, QUERY_DEV_CAP_EXT_FLAGS_OFFSET);
 743         MLX4_GET(flags, outbox, QUERY_DEV_CAP_FLAGS_OFFSET);
 744         dev_cap->flags = flags | (u64)ext_flags << 32;
 745         MLX4_GET(field, outbox, QUERY_DEV_CAP_SYNC_QP_OFFSET);
 746         dev_cap->sync_qp = field & 0x10;
 747         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_UAR_OFFSET);
 748         dev_cap->reserved_uars = field >> 4;
 749         MLX4_GET(field, outbox, QUERY_DEV_CAP_UAR_SZ_OFFSET);
 750         dev_cap->uar_size = 1 << ((field & 0x3f) + 20);
 751         MLX4_GET(field, outbox, QUERY_DEV_CAP_PAGE_SZ_OFFSET);
 752         dev_cap->min_page_sz = 1 << field;
 753
 754         MLX4_GET(field, outbox, QUERY_DEV_CAP_BF_OFFSET);
 755         if (field & 0x80) {
 756                 MLX4_GET(field, outbox, QUERY_DEV_CAP_LOG_BF_REG_SZ_OFFSET);
 757                 dev_cap->bf_reg_size = 1 << (field & 0x1f);
 758                 MLX4_GET(field, outbox, QUERY_DEV_CAP_LOG_MAX_BF_REGS_PER_PAGE_OFFSET);
 759                 if ((1 << (field & 0x3f)) > (PAGE_SIZE / dev_cap->bf_reg_size))
 760                         field = 3;
 761                 dev_cap->bf_regs_per_page = 1 << (field & 0x3f);
 762                 mlx4_dbg(dev, "BlueFlame available (reg size %d, regs/page %d)\n",
 763                          dev_cap->bf_reg_size, dev_cap->bf_regs_per_page);
 764         } else {
 765                 dev_cap->bf_reg_size = 0;
 766                 mlx4_dbg(dev, "BlueFlame not available\n");
 767         }
 768
 769         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_SG_SQ_OFFSET);
 770         dev_cap->max_sq_sg = field;
 771         MLX4_GET(size, outbox, QUERY_DEV_CAP_MAX_DESC_SZ_SQ_OFFSET);
 772         dev_cap->max_sq_desc_sz = size;
 773
 774         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_QP_MCG_OFFSET);
 775         dev_cap->max_qp_per_mcg = 1 << field;
 776         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_MCG_OFFSET);
 777         dev_cap->reserved_mgms = field & 0xf;
 778         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MCG_OFFSET);
 779         dev_cap->max_mcgs = 1 << field;
 780         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_PD_OFFSET);
 781         dev_cap->reserved_pds = field >> 4;
 782         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_PD_OFFSET);
 783         dev_cap->max_pds = 1 << (field & 0x3f);
 784         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_XRC_OFFSET);
 785         dev_cap->reserved_xrcds = field >> 4;
 786         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_XRC_OFFSET);
 787         dev_cap->max_xrcds = 1 << (field & 0x1f);
 788
 789         MLX4_GET(size, outbox, QUERY_DEV_CAP_RDMARC_ENTRY_SZ_OFFSET);
 790         dev_cap->rdmarc_entry_sz = size;
 791         MLX4_GET(size, outbox, QUERY_DEV_CAP_QPC_ENTRY_SZ_OFFSET);
 792         dev_cap->qpc_entry_sz = size;
 793         MLX4_GET(size, outbox, QUERY_DEV_CAP_AUX_ENTRY_SZ_OFFSET);
 794         dev_cap->aux_entry_sz = size;
 795         MLX4_GET(size, outbox, QUERY_DEV_CAP_ALTC_ENTRY_SZ_OFFSET);
 796         dev_cap->altc_entry_sz = size;
 797         MLX4_GET(size, outbox, QUERY_DEV_CAP_EQC_ENTRY_SZ_OFFSET);
 798         dev_cap->eqc_entry_sz = size;
 799         MLX4_GET(size, outbox, QUERY_DEV_CAP_CQC_ENTRY_SZ_OFFSET);
 800         dev_cap->cqc_entry_sz = size;
 801         MLX4_GET(size, outbox, QUERY_DEV_CAP_SRQ_ENTRY_SZ_OFFSET);
 802         dev_cap->srq_entry_sz = size;
 803         MLX4_GET(size, outbox, QUERY_DEV_CAP_C_MPT_ENTRY_SZ_OFFSET);
 804         dev_cap->cmpt_entry_sz = size;
 805         MLX4_GET(size, outbox, QUERY_DEV_CAP_MTT_ENTRY_SZ_OFFSET);
 806         dev_cap->mtt_entry_sz = size;
 807         MLX4_GET(size, outbox, QUERY_DEV_CAP_D_MPT_ENTRY_SZ_OFFSET);
 808         dev_cap->dmpt_entry_sz = size;
 809
 810         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_SRQ_SZ_OFFSET);
 811         dev_cap->max_srq_sz = 1 << field;
 812         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_QP_SZ_OFFSET);
 813         dev_cap->max_qp_sz = 1 << field;
 814         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSZ_SRQ_OFFSET);
 815         dev_cap->resize_srq = field & 1;
 816         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_SG_RQ_OFFSET);
 817         dev_cap->max_rq_sg = field;
 818         MLX4_GET(size, outbox, QUERY_DEV_CAP_MAX_DESC_SZ_RQ_OFFSET);
 819         dev_cap->max_rq_desc_sz = size;
 820
 821         MLX4_GET(dev_cap->bmme_flags, outbox,
 822                  QUERY_DEV_CAP_BMME_FLAGS_OFFSET);
 823         MLX4_GET(dev_cap->reserved_lkey, outbox,
 824                  QUERY_DEV_CAP_RSVD_LKEY_OFFSET);
 825         MLX4_GET(field32, outbox, QUERY_DEV_CAP_ETS_CFG_OFFSET);
 826         if (field32 & (1 << 0))
 827                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP;
 828         if (field32 & (1 << 7))
 829                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_RECOVERABLE_ERROR_EVENT;
 830         if (field32 & (1 << 8))
 831                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_DRIVER_VERSION_TO_FW;
 832         if (field32 & (1 << 13))
 833                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_ETS_CFG;
 834
 835         MLX4_GET(dev_cap->max_icm_sz, outbox,
 836                  QUERY_DEV_CAP_MAX_ICM_SZ_OFFSET);
 837         if (dev_cap->flags & MLX4_DEV_CAP_FLAG_COUNTERS)
 838                 MLX4_GET(dev_cap->max_basic_counters, outbox,
 839                          QUERY_DEV_CAP_MAX_BASIC_COUNTERS_OFFSET);
 840         /* FW reports 256 however real value is 255 */
 841         dev_cap->max_basic_counters = min_t(u32, dev_cap->max_basic_counters, 255);
 842         if (dev_cap->flags & MLX4_DEV_CAP_FLAG_COUNTERS_EXT)
 843                 MLX4_GET(dev_cap->max_extended_counters, outbox,
 844                          QUERY_DEV_CAP_MAX_EXTENDED_COUNTERS_OFFSET);
 845
 846         MLX4_GET(field32, outbox, QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET);
 847         if (field32 & (1 << 16))
 848                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_UPDATE_QP;
 849         if (field32 & (1 << 19))
 850                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_LB_SRC_CHK;
 851         if (field32 & (1 << 20))
 852                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_FSM;
 853         if (field32 & (1 << 26))
 854                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_VLAN_CONTROL;
 855
 856         if (dev->flags & MLX4_FLAG_OLD_PORT_CMDS) {
 857                 for (i = 1; i <= dev_cap->num_ports; ++i) {
 858                         MLX4_GET(field, outbox, QUERY_DEV_CAP_VL_PORT_OFFSET);
 859                         dev_cap->max_vl[i]         = field >> 4;
 860                         MLX4_GET(field, outbox, QUERY_DEV_CAP_MTU_WIDTH_OFFSET);
 861                         dev_cap->ib_mtu[i]         = field >> 4;
 862                         dev_cap->max_port_width[i] = field & 0xf;
 863                         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_GID_OFFSET);
 864                         dev_cap->max_gids[i]       = 1 << (field & 0xf);
 865                         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_PKEY_OFFSET);
 866                         dev_cap->max_pkeys[i]      = 1 << (field & 0xf);
 867                 }
 868         } else {
 869 #define QUERY_PORT_SUPPORTED_TYPE_OFFSET        0x00
 870 #define QUERY_PORT_MTU_OFFSET                   0x01
 871 #define QUERY_PORT_ETH_MTU_OFFSET               0x02
 872 #define QUERY_PORT_WIDTH_OFFSET                 0x06
 873 #define QUERY_PORT_MAX_GID_PKEY_OFFSET          0x07
 874 #define QUERY_PORT_MAX_MACVLAN_OFFSET           0x0a
 875 #define QUERY_PORT_MAX_VL_OFFSET                0x0b
 876 #define QUERY_PORT_MAC_OFFSET                   0x10
 877 #define QUERY_PORT_TRANS_VENDOR_OFFSET          0x18
 878 #define QUERY_PORT_WAVELENGTH_OFFSET            0x1c
 879 #define QUERY_PORT_TRANS_CODE_OFFSET            0x20
 880
 881                 for (i = 1; i <= dev_cap->num_ports; ++i) {
 882                         err = mlx4_cmd_box(dev, 0, mailbox->dma, i, 0, MLX4_CMD_QUERY_PORT,
 883                                            MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
 884                         if (err)
 885                                 goto out;
 886
 887                         MLX4_GET(field, outbox, QUERY_PORT_SUPPORTED_TYPE_OFFSET);
 888                         dev_cap->supported_port_types[i] = field & 3;
 889                         dev_cap->suggested_type[i] = (field >> 3) & 1;
 890                         dev_cap->default_sense[i] = (field >> 4) & 1;
 891                         MLX4_GET(field, outbox, QUERY_PORT_MTU_OFFSET);
 892                         dev_cap->ib_mtu[i]         = field & 0xf;
 893                         MLX4_GET(field, outbox, QUERY_PORT_WIDTH_OFFSET);
 894                         dev_cap->max_port_width[i] = field & 0xf;
 895                         MLX4_GET(field, outbox, QUERY_PORT_MAX_GID_PKEY_OFFSET);
 896                         dev_cap->max_gids[i]       = 1 << (field >> 4);
 897                         dev_cap->max_pkeys[i]      = 1 << (field & 0xf);
 898                         MLX4_GET(field, outbox, QUERY_PORT_MAX_VL_OFFSET);
 899                         dev_cap->max_vl[i]         = field & 0xf;
 900                         MLX4_GET(field, outbox, QUERY_PORT_MAX_MACVLAN_OFFSET);
 901                         dev_cap->log_max_macs[i]  = field & 0xf;
 902                         dev_cap->log_max_vlans[i] = field >> 4;
 903                         MLX4_GET(dev_cap->eth_mtu[i], outbox, QUERY_PORT_ETH_MTU_OFFSET);
 904                         MLX4_GET(dev_cap->def_mac[i], outbox, QUERY_PORT_MAC_OFFSET);
 905                         MLX4_GET(field32, outbox, QUERY_PORT_TRANS_VENDOR_OFFSET);
 906                         dev_cap->trans_type[i] = field32 >> 24;
 907                         dev_cap->vendor_oui[i] = field32 & 0xffffff;
 908                         MLX4_GET(dev_cap->wavelength[i], outbox, QUERY_PORT_WAVELENGTH_OFFSET);
 909                         MLX4_GET(dev_cap->trans_code[i], outbox, QUERY_PORT_TRANS_CODE_OFFSET);
 910                 }
 911         }
 912
 913         mlx4_dbg(dev, "Base MM extensions: flags %08x, rsvd L_Key %08x\n",
 914                  dev_cap->bmme_flags, dev_cap->reserved_lkey);
 915
 916         /*
 917          * Each UAR has 4 EQ doorbells; so if a UAR is reserved, then
 918          * we can't use any EQs whose doorbell falls on that page,
 919          * even if the EQ itself isn't reserved.
 920          */
 921         if (dev_cap->num_sys_eqs == 0)
 922                 dev_cap->reserved_eqs = max(dev_cap->reserved_uars * 4,
 923                                             dev_cap->reserved_eqs);
 924         else
 925                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_SYS_EQS;
 926
 927         mlx4_dbg(dev, "Max ICM size %lld MB\n",
 928                  (unsigned long long) dev_cap->max_icm_sz >> 20);
 929         mlx4_dbg(dev, "Max QPs: %d, reserved QPs: %d, entry size: %d\n",
 930                  dev_cap->max_qps, dev_cap->reserved_qps, dev_cap->qpc_entry_sz);
 931         mlx4_dbg(dev, "Max SRQs: %d, reserved SRQs: %d, entry size: %d\n",
 932                  dev_cap->max_srqs, dev_cap->reserved_srqs, dev_cap->srq_entry_sz);
 933         mlx4_dbg(dev, "Max CQs: %d, reserved CQs: %d, entry size: %d\n",
 934                  dev_cap->max_cqs, dev_cap->reserved_cqs, dev_cap->cqc_entry_sz);
 935         mlx4_dbg(dev, "Num sys EQs: %d, max EQs: %d, reserved EQs: %d, entry size: %d\n",
 936                 dev_cap->num_sys_eqs, dev_cap->max_eqs, dev_cap->reserved_eqs,
 937                 dev_cap->eqc_entry_sz);
 938         mlx4_dbg(dev, "reserved MPTs: %d, reserved MTTs: %d\n",
 939                  dev_cap->reserved_mrws, dev_cap->reserved_mtts);
 940         mlx4_dbg(dev, "Max PDs: %d, reserved PDs: %d, reserved UARs: %d\n",
 941                  dev_cap->max_pds, dev_cap->reserved_pds, dev_cap->reserved_uars);
 942         mlx4_dbg(dev, "Max QP/MCG: %d, reserved MGMs: %d\n",
 943                  dev_cap->max_pds, dev_cap->reserved_mgms);
 944         mlx4_dbg(dev, "Max CQEs: %d, max WQEs: %d, max SRQ WQEs: %d\n",
 945                  dev_cap->max_cq_sz, dev_cap->max_qp_sz, dev_cap->max_srq_sz);
 946         mlx4_dbg(dev, "Local CA ACK delay: %d, max MTU: %d, port width cap: %d\n",
 947                  dev_cap->local_ca_ack_delay, 128 << dev_cap->ib_mtu[1],
 948                  dev_cap->max_port_width[1]);
 949         mlx4_dbg(dev, "Max SQ desc size: %d, max SQ S/G: %d\n",
 950                  dev_cap->max_sq_desc_sz, dev_cap->max_sq_sg);
 951         mlx4_dbg(dev, "Max RQ desc size: %d, max RQ S/G: %d\n",
 952                  dev_cap->max_rq_desc_sz, dev_cap->max_rq_sg);
 953         mlx4_dbg(dev, "Max GSO size: %d\n", dev_cap->max_gso_sz);
 954         mlx4_dbg(dev, "Max basic counters: %d\n", dev_cap->max_basic_counters);
 955         mlx4_dbg(dev, "Max extended counters: %d\n", dev_cap->max_extended_counters);
 956         mlx4_dbg(dev, "Max RSS Table size: %d\n", dev_cap->max_rss_tbl_sz);
 957
 958         dump_dev_cap_flags(dev, dev_cap->flags);
 959         dump_dev_cap_flags2(dev, dev_cap->flags2);
 960
 961 out:
 962         mlx4_free_cmd_mailbox(dev, mailbox);
 963         return err;
 964 }
 965
 966 int mlx4_QUERY_DEV_CAP_wrapper(struct mlx4_dev *dev, int slave,
 967                                struct mlx4_vhcr *vhcr,
 968                                struct mlx4_cmd_mailbox *inbox,
 969                                struct mlx4_cmd_mailbox *outbox,
 970                                struct mlx4_cmd_info *cmd)
 971 {
 972         u64     flags;
 973         int     err = 0;
 974         u8      field;
 975
 976         err = mlx4_cmd_box(dev, 0, outbox->dma, 0, 0, MLX4_CMD_QUERY_DEV_CAP,
 977                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
 978         if (err)
 979                 return err;
 980
 981         /* add port mng change event capability unconditionally to slaves */
 982         MLX4_GET(flags, outbox->buf, QUERY_DEV_CAP_EXT_FLAGS_OFFSET);
 983         flags |= MLX4_DEV_CAP_FLAG_PORT_MNG_CHG_EV;
 984         MLX4_PUT(outbox->buf, flags, QUERY_DEV_CAP_EXT_FLAGS_OFFSET);
 985
 986         /* For guests, report Blueflame disabled */
 987         MLX4_GET(field, outbox->buf, QUERY_DEV_CAP_BF_OFFSET);
 988         field &= 0x7f;
 989         MLX4_PUT(outbox->buf, field, QUERY_DEV_CAP_BF_OFFSET);
 990
 991         /* turn off device-managed steering capability if not enabled */
 992         if (dev->caps.steering_mode != MLX4_STEERING_MODE_DEVICE_MANAGED) {
 993                 MLX4_GET(field, outbox->buf,
 994                          QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET);
 995                 field &= 0x7f;
 996                 MLX4_PUT(outbox->buf, field,
 997                          QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET);
 998         }
 999         return 0;
1000 }
1001
1002 int mlx4_QUERY_PORT_wrapper(struct mlx4_dev *dev, int slave,
1003                             struct mlx4_vhcr *vhcr,
1004                             struct mlx4_cmd_mailbox *inbox,
1005                             struct mlx4_cmd_mailbox *outbox,
1006                             struct mlx4_cmd_info *cmd)
1007 {
1008         struct mlx4_priv *priv = mlx4_priv(dev);
1009         u64 def_mac;
1010         u8 port_type;
1011         u16 short_field;
1012         int err;
1013         int admin_link_state;
1014
1015 #define MLX4_VF_PORT_NO_LINK_SENSE_MASK 0xE0
1016 #define MLX4_PORT_LINK_UP_MASK          0x80
1017 #define QUERY_PORT_CUR_MAX_PKEY_OFFSET  0x0c
1018 #define QUERY_PORT_CUR_MAX_GID_OFFSET   0x0e
1019
1020         err = mlx4_cmd_box(dev, 0, outbox->dma, vhcr->in_modifier, 0,
1021                            MLX4_CMD_QUERY_PORT, MLX4_CMD_TIME_CLASS_B,
1022                            MLX4_CMD_NATIVE);
1023
1024         if (!err && dev->caps.function != slave) {
1025                 /* set slave default_mac address to be zero MAC */
1026                 def_mac = priv->mfunc.master.vf_oper[slave].vport[vhcr->in_modifier].state.mac;
1027                 MLX4_PUT(outbox->buf, def_mac, QUERY_PORT_MAC_OFFSET);
1028
1029                 /* get port type - currently only eth is enabled */
1030                 MLX4_GET(port_type, outbox->buf,
1031                          QUERY_PORT_SUPPORTED_TYPE_OFFSET);
1032
1033                 /* No link sensing allowed */
1034                 port_type &= MLX4_VF_PORT_NO_LINK_SENSE_MASK;
1035                 /* set port type to currently operating port type */
1036                 port_type |= (dev->caps.port_type[vhcr->in_modifier] & 0x3);
1037
1038                 admin_link_state = priv->mfunc.master.vf_oper[slave].vport[vhcr->in_modifier].state.link_state;
1039                 if (IFLA_VF_LINK_STATE_ENABLE == admin_link_state)
1040                         port_type |= MLX4_PORT_LINK_UP_MASK;
1041                 else if (IFLA_VF_LINK_STATE_DISABLE == admin_link_state)
1042                         port_type &= ~MLX4_PORT_LINK_UP_MASK;
1043
1044                 MLX4_PUT(outbox->buf, port_type,
1045                          QUERY_PORT_SUPPORTED_TYPE_OFFSET);
1046
1047                 if (dev->caps.port_type[vhcr->in_modifier] == MLX4_PORT_TYPE_ETH)
1048                         short_field = mlx4_get_slave_num_gids(dev, slave);
1049                 else
1050                         short_field = 1; /* slave max gids */
1051                 MLX4_PUT(outbox->buf, short_field,
1052                          QUERY_PORT_CUR_MAX_GID_OFFSET);
1053
1054                 short_field = dev->caps.pkey_table_len[vhcr->in_modifier];
1055                 MLX4_PUT(outbox->buf, short_field,
1056                          QUERY_PORT_CUR_MAX_PKEY_OFFSET);
1057         }
1058
1059         return err;
1060 }
1061
1062 int mlx4_get_slave_pkey_gid_tbl_len(struct mlx4_dev *dev, u8 port,
1063                                     int *gid_tbl_len, int *pkey_tbl_len)
1064 {
1065         struct mlx4_cmd_mailbox *mailbox;
1066         u32                     *outbox;
1067         u16                     field;
1068         int                     err;
1069
1070         mailbox = mlx4_alloc_cmd_mailbox(dev);
1071         if (IS_ERR(mailbox))
1072                 return PTR_ERR(mailbox);
1073
1074         err =  mlx4_cmd_box(dev, 0, mailbox->dma, port, 0,
1075                             MLX4_CMD_QUERY_PORT, MLX4_CMD_TIME_CLASS_B,
1076                             MLX4_CMD_WRAPPED);
1077         if (err)
1078                 goto out;
1079
1080         outbox = mailbox->buf;
1081
1082         MLX4_GET(field, outbox, QUERY_PORT_CUR_MAX_GID_OFFSET);
1083         *gid_tbl_len = field;
1084
1085         MLX4_GET(field, outbox, QUERY_PORT_CUR_MAX_PKEY_OFFSET);
1086         *pkey_tbl_len = field;
1087
1088 out:
1089         mlx4_free_cmd_mailbox(dev, mailbox);
1090         return err;
1091 }
1092 EXPORT_SYMBOL(mlx4_get_slave_pkey_gid_tbl_len);
1093
1094 int mlx4_map_cmd(struct mlx4_dev *dev, u16 op, struct mlx4_icm *icm, u64 virt)
1095 {
1096         struct mlx4_cmd_mailbox *mailbox;
1097         struct mlx4_icm_iter iter;
1098         __be64 *pages;
1099         int lg;
1100         int nent = 0;
1101         int i;
1102         int err = 0;
1103         int ts = 0, tc = 0;
1104
1105         mailbox = mlx4_alloc_cmd_mailbox(dev);
1106         if (IS_ERR(mailbox))
1107                 return PTR_ERR(mailbox);
1108         memset(mailbox->buf, 0, MLX4_MAILBOX_SIZE);
1109         pages = mailbox->buf;
1110
1111         for (mlx4_icm_first(icm, &iter);
1112              !mlx4_icm_last(&iter);
1113              mlx4_icm_next(&iter)) {
1114                 /*
1115                  * We have to pass pages that are aligned to their
1116                  * size, so find the least significant 1 in the
1117                  * address or size and use that as our log2 size.
1118                  */
1119                 lg = ffs(mlx4_icm_addr(&iter) | mlx4_icm_size(&iter)) - 1;
1120                 if (lg < MLX4_ICM_PAGE_SHIFT) {
1121                         mlx4_warn(dev, "Got FW area not aligned to %d (%llx/%lx).\n",
1122                                    MLX4_ICM_PAGE_SIZE,
1123                                    (unsigned long long) mlx4_icm_addr(&iter),
1124                                    mlx4_icm_size(&iter));
1125                         err = -EINVAL;
1126                         goto out;
1127                 }
1128
1129                 for (i = 0; i < mlx4_icm_size(&iter) >> lg; ++i) {
1130                         if (virt != -1) {
1131                                 pages[nent * 2] = cpu_to_be64(virt);
1132                                 virt += 1 << lg;
1133                         }
1134
1135                         pages[nent * 2 + 1] =
1136                                 cpu_to_be64((mlx4_icm_addr(&iter) + (i << lg)) |
1137                                             (lg - MLX4_ICM_PAGE_SHIFT));
1138                         ts += 1 << (lg - 10);
1139                         ++tc;
1140
1141                         if (++nent == MLX4_MAILBOX_SIZE / 16) {
1142                                 err = mlx4_cmd(dev, mailbox->dma, nent, 0, op,
1143                                                 MLX4_CMD_TIME_CLASS_B,
1144                                                 MLX4_CMD_NATIVE);
1145                                 if (err)
1146                                         goto out;
1147                                 nent = 0;
1148                         }
1149                 }
1150         }
1151
1152         if (nent)
1153                 err = mlx4_cmd(dev, mailbox->dma, nent, 0, op,
1154                                MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
1155         if (err)
1156                 goto out;
1157
1158         switch (op) {
1159         case MLX4_CMD_MAP_FA:
1160                 mlx4_dbg(dev, "Mapped %d chunks/%d KB for FW.\n", tc, ts);
1161                 break;
1162         case MLX4_CMD_MAP_ICM_AUX:
1163                 mlx4_dbg(dev, "Mapped %d chunks/%d KB for ICM aux.\n", tc, ts);
1164                 break;
1165         case MLX4_CMD_MAP_ICM:
1166                 mlx4_dbg(dev, "Mapped %d chunks/%d KB at %llx for ICM.\n",
1167                           tc, ts, (unsigned long long) virt - (ts << 10));
1168                 break;
1169         }
1170
1171 out:
1172         mlx4_free_cmd_mailbox(dev, mailbox);
1173         return err;
1174 }
1175
1176 int mlx4_MAP_FA(struct mlx4_dev *dev, struct mlx4_icm *icm)
1177 {
1178         return mlx4_map_cmd(dev, MLX4_CMD_MAP_FA, icm, -1);
1179 }
1180
1181 int mlx4_UNMAP_FA(struct mlx4_dev *dev)
1182 {
1183         return mlx4_cmd(dev, 0, 0, 0, MLX4_CMD_UNMAP_FA,
1184                         MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
1185 }
1186
1187
1188 int mlx4_RUN_FW(struct mlx4_dev *dev)
1189 {
1190         return mlx4_cmd(dev, 0, 0, 0, MLX4_CMD_RUN_FW,
1191                         MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1192 }
1193
1194 int mlx4_QUERY_FW(struct mlx4_dev *dev)
1195 {
1196         struct mlx4_fw  *fw  = &mlx4_priv(dev)->fw;
1197         struct mlx4_cmd *cmd = &mlx4_priv(dev)->cmd;
1198         struct mlx4_cmd_mailbox *mailbox;
1199         u32 *outbox;
1200         int err = 0;
1201         u64 fw_ver;
1202         u16 cmd_if_rev;
1203         u8 lg;
1204
1205 #define QUERY_FW_OUT_SIZE             0x100
1206 #define QUERY_FW_VER_OFFSET            0x00
1207 #define QUERY_FW_PPF_ID                0x09
1208 #define QUERY_FW_CMD_IF_REV_OFFSET     0x0a
1209 #define QUERY_FW_MAX_CMD_OFFSET        0x0f
1210 #define QUERY_FW_ERR_START_OFFSET      0x30
1211 #define QUERY_FW_ERR_SIZE_OFFSET       0x38
1212 #define QUERY_FW_ERR_BAR_OFFSET        0x3c
1213
1214 #define QUERY_FW_SIZE_OFFSET           0x00
1215 #define QUERY_FW_CLR_INT_BASE_OFFSET   0x20
1216 #define QUERY_FW_CLR_INT_BAR_OFFSET    0x28
1217
1218 #define QUERY_FW_COMM_BASE_OFFSET      0x40
1219 #define QUERY_FW_COMM_BAR_OFFSET       0x48
1220
1221 #define QUERY_FW_CLOCK_OFFSET          0x50
1222 #define QUERY_FW_CLOCK_BAR             0x58
1223
1224         mailbox = mlx4_alloc_cmd_mailbox(dev);
1225         if (IS_ERR(mailbox))
1226                 return PTR_ERR(mailbox);
1227         outbox = mailbox->buf;
1228
1229         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0, MLX4_CMD_QUERY_FW,
1230                             MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1231         if (err)
1232                 goto out;
1233
1234         MLX4_GET(fw_ver, outbox, QUERY_FW_VER_OFFSET);
1235         /*
1236          * FW subminor version is at more significant bits than minor
1237          * version, so swap here.
1238          */
1239         dev->caps.fw_ver = (fw_ver & 0xffff00000000ull) |
1240                 ((fw_ver & 0xffff0000ull) >> 16) |
1241                 ((fw_ver & 0x0000ffffull) << 16);
1242
1243         MLX4_GET(lg, outbox, QUERY_FW_PPF_ID);
1244         dev->caps.function = lg;
1245
1246         if (mlx4_is_slave(dev))
1247                 goto out;
1248
1249
1250         MLX4_GET(cmd_if_rev, outbox, QUERY_FW_CMD_IF_REV_OFFSET);
1251         if (cmd_if_rev < MLX4_COMMAND_INTERFACE_MIN_REV ||
1252             cmd_if_rev > MLX4_COMMAND_INTERFACE_MAX_REV) {
1253                 mlx4_err(dev, "Installed FW has unsupported "
1254                          "command interface revision %d.\n",
1255                          cmd_if_rev);
1256                 mlx4_err(dev, "(Installed FW version is %d.%d.%03d)\n",
1257                          (int) (dev->caps.fw_ver >> 32),
1258                          (int) (dev->caps.fw_ver >> 16) & 0xffff,
1259                          (int) dev->caps.fw_ver & 0xffff);
1260                 mlx4_err(dev, "This driver version supports only revisions %d to %d.\n",
1261                          MLX4_COMMAND_INTERFACE_MIN_REV, MLX4_COMMAND_INTERFACE_MAX_REV);
1262                 err = -ENODEV;
1263                 goto out;
1264         }
1265
1266         if (cmd_if_rev < MLX4_COMMAND_INTERFACE_NEW_PORT_CMDS)
1267                 dev->flags |= MLX4_FLAG_OLD_PORT_CMDS;
1268
1269         MLX4_GET(lg, outbox, QUERY_FW_MAX_CMD_OFFSET);
1270         cmd->max_cmds = 1 << lg;
1271
1272         mlx4_dbg(dev, "FW version %d.%d.%03d (cmd intf rev %d), max commands %d\n",
1273                  (int) (dev->caps.fw_ver >> 32),
1274                  (int) (dev->caps.fw_ver >> 16) & 0xffff,
1275                  (int) dev->caps.fw_ver & 0xffff,
1276                  cmd_if_rev, cmd->max_cmds);
1277
1278         MLX4_GET(fw->catas_offset, outbox, QUERY_FW_ERR_START_OFFSET);
1279         MLX4_GET(fw->catas_size,   outbox, QUERY_FW_ERR_SIZE_OFFSET);
1280         MLX4_GET(fw->catas_bar,    outbox, QUERY_FW_ERR_BAR_OFFSET);
1281         fw->catas_bar = (fw->catas_bar >> 6) * 2;
1282
1283         mlx4_dbg(dev, "Catastrophic error buffer at 0x%llx, size 0x%x, BAR %d\n",
1284                  (unsigned long long) fw->catas_offset, fw->catas_size, fw->catas_bar);
1285
1286         MLX4_GET(fw->fw_pages,     outbox, QUERY_FW_SIZE_OFFSET);
1287         MLX4_GET(fw->clr_int_base, outbox, QUERY_FW_CLR_INT_BASE_OFFSET);
1288         MLX4_GET(fw->clr_int_bar,  outbox, QUERY_FW_CLR_INT_BAR_OFFSET);
1289         fw->clr_int_bar = (fw->clr_int_bar >> 6) * 2;
1290
1291         MLX4_GET(fw->comm_base, outbox, QUERY_FW_COMM_BASE_OFFSET);
1292         MLX4_GET(fw->comm_bar,  outbox, QUERY_FW_COMM_BAR_OFFSET);
1293         fw->comm_bar = (fw->comm_bar >> 6) * 2;
1294         mlx4_dbg(dev, "Communication vector bar:%d offset:0x%llx\n",
1295                  fw->comm_bar, (unsigned long long)fw->comm_base);
1296         mlx4_dbg(dev, "FW size %d KB\n", fw->fw_pages >> 2);
1297
1298         MLX4_GET(fw->clock_offset, outbox, QUERY_FW_CLOCK_OFFSET);
1299         MLX4_GET(fw->clock_bar,    outbox, QUERY_FW_CLOCK_BAR);
1300         fw->clock_bar = (fw->clock_bar >> 6) * 2;
1301         mlx4_dbg(dev, "Internal clock bar:%d offset:0x%llx\n",
1302                  fw->comm_bar, (unsigned long long)fw->comm_base);
1303
1304         /*
1305          * Round up number of system pages needed in case
1306          * MLX4_ICM_PAGE_SIZE < PAGE_SIZE.
1307          */
1308         fw->fw_pages =
1309                 ALIGN(fw->fw_pages, PAGE_SIZE / MLX4_ICM_PAGE_SIZE) >>
1310                 (PAGE_SHIFT - MLX4_ICM_PAGE_SHIFT);
1311
1312         mlx4_dbg(dev, "Clear int @ %llx, BAR %d\n",
1313                  (unsigned long long) fw->clr_int_base, fw->clr_int_bar);
1314
1315 out:
1316         mlx4_free_cmd_mailbox(dev, mailbox);
1317         return err;
1318 }
1319
1320 int mlx4_QUERY_FW_wrapper(struct mlx4_dev *dev, int slave,
1321                           struct mlx4_vhcr *vhcr,
1322                           struct mlx4_cmd_mailbox *inbox,
1323                           struct mlx4_cmd_mailbox *outbox,
1324                           struct mlx4_cmd_info *cmd)
1325 {
1326         u8 *outbuf;
1327         int err;
1328
1329         outbuf = outbox->buf;
1330         err = mlx4_cmd_box(dev, 0, outbox->dma, 0, 0, MLX4_CMD_QUERY_FW,
1331                             MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1332         if (err)
1333                 return err;
1334
1335         /* for slaves, set pci PPF ID to invalid and zero out everything
1336          * else except FW version */
1337         outbuf[0] = outbuf[1] = 0;
1338         memset(&outbuf[8], 0, QUERY_FW_OUT_SIZE - 8);
1339         outbuf[QUERY_FW_PPF_ID] = MLX4_INVALID_SLAVE_ID;
1340
1341         return 0;
1342 }
1343
1344 static void get_board_id(void *vsd, char *board_id, char *vsdstr)
1345 {
1346         int i;
1347
1348 #define VSD_OFFSET_SIG1         0x00
1349 #define VSD_OFFSET_SIG2         0xde
1350 #define VSD_OFFSET_MLX_BOARD_ID 0xd0
1351 #define VSD_OFFSET_TS_BOARD_ID  0x20
1352 #define VSD_LEN                 0xd0
1353
1354 #define VSD_SIGNATURE_TOPSPIN   0x5ad
1355
1356         memset(vsdstr, 0, MLX4_VSD_LEN);
1357
1358         for (i = 0; i < VSD_LEN / 4; i++)
1359                 ((u32 *)vsdstr)[i] =
1360                         swab32(*(u32 *)(vsd + i * 4));
1361
1362         memset(board_id, 0, MLX4_BOARD_ID_LEN);
1363
1364         if (be16_to_cpup(vsd + VSD_OFFSET_SIG1) == VSD_SIGNATURE_TOPSPIN &&
1365             be16_to_cpup(vsd + VSD_OFFSET_SIG2) == VSD_SIGNATURE_TOPSPIN) {
1366                 strlcpy(board_id, vsd + VSD_OFFSET_TS_BOARD_ID, MLX4_BOARD_ID_LEN);
1367         } else {
1368                 /*
1369                  * The board ID is a string but the firmware byte
1370                  * swaps each 4-byte word before passing it back to
1371                  * us.  Therefore we need to swab it before printing.
1372                  */
1373                 for (i = 0; i < 4; ++i)
1374                         ((u32 *) board_id)[i] =
1375                                 swab32(*(u32 *) (vsd + VSD_OFFSET_MLX_BOARD_ID + i * 4));
1376         }
1377 }
1378
1379 int mlx4_QUERY_ADAPTER(struct mlx4_dev *dev, struct mlx4_adapter *adapter)
1380 {
1381         struct mlx4_cmd_mailbox *mailbox;
1382         u32 *outbox;
1383         int err;
1384
1385 #define QUERY_ADAPTER_OUT_SIZE             0x100
1386 #define QUERY_ADAPTER_INTA_PIN_OFFSET      0x10
1387 #define QUERY_ADAPTER_VSD_OFFSET           0x20
1388 #define QUERY_ADAPTER_VSD_VENDOR_ID_OFFSET 0x1e
1389
1390         mailbox = mlx4_alloc_cmd_mailbox(dev);
1391         if (IS_ERR(mailbox))
1392                 return PTR_ERR(mailbox);
1393         outbox = mailbox->buf;
1394
1395         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0, MLX4_CMD_QUERY_ADAPTER,
1396                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1397         if (err)
1398                 goto out;
1399
1400         MLX4_GET(adapter->inta_pin, outbox,    QUERY_ADAPTER_INTA_PIN_OFFSET);
1401
1402         adapter->vsd_vendor_id = be16_to_cpup((u16 *)outbox +
1403                                 QUERY_ADAPTER_VSD_VENDOR_ID_OFFSET / 2);
1404
1405         get_board_id(outbox + QUERY_ADAPTER_VSD_OFFSET / 4,
1406                      adapter->board_id, adapter->vsd);
1407
1408 out:
1409         mlx4_free_cmd_mailbox(dev, mailbox);
1410         return err;
1411 }
1412
1413 int mlx4_INIT_HCA(struct mlx4_dev *dev, struct mlx4_init_hca_param *param)
1414 {
1415         struct mlx4_cmd_mailbox *mailbox;
1416         __be32 *inbox;
1417         u32 mw_enable;
1418         int err;
1419
1420 #define INIT_HCA_IN_SIZE                 0x200
1421 #define INIT_HCA_DRV_NAME_FOR_FW_MAX_SIZE 64
1422 #define INIT_HCA_VERSION_OFFSET          0x000
1423 #define  INIT_HCA_VERSION                2
1424 #define INIT_HCA_CACHELINE_SZ_OFFSET     0x0e
1425 #define INIT_HCA_FLAGS_OFFSET            0x014
1426 #define INIT_HCA_RECOVERABLE_ERROR_EVENT_OFFSET 0x018
1427 #define INIT_HCA_QPC_OFFSET              0x020
1428 #define  INIT_HCA_QPC_BASE_OFFSET        (INIT_HCA_QPC_OFFSET + 0x10)
1429 #define  INIT_HCA_LOG_QP_OFFSET          (INIT_HCA_QPC_OFFSET + 0x17)
1430 #define  INIT_HCA_SRQC_BASE_OFFSET       (INIT_HCA_QPC_OFFSET + 0x28)
1431 #define  INIT_HCA_LOG_SRQ_OFFSET         (INIT_HCA_QPC_OFFSET + 0x2f)
1432 #define  INIT_HCA_CQC_BASE_OFFSET        (INIT_HCA_QPC_OFFSET + 0x30)
1433 #define  INIT_HCA_LOG_CQ_OFFSET          (INIT_HCA_QPC_OFFSET + 0x37)
1434 #define  INIT_HCA_EQE_CQE_OFFSETS        (INIT_HCA_QPC_OFFSET + 0x38)
1435 #define  INIT_HCA_ALTC_BASE_OFFSET       (INIT_HCA_QPC_OFFSET + 0x40)
1436 #define  INIT_HCA_AUXC_BASE_OFFSET       (INIT_HCA_QPC_OFFSET + 0x50)
1437 #define  INIT_HCA_EQC_BASE_OFFSET        (INIT_HCA_QPC_OFFSET + 0x60)
1438 #define  INIT_HCA_LOG_EQ_OFFSET          (INIT_HCA_QPC_OFFSET + 0x67)
1439 #define INIT_HCA_NUM_SYS_EQS_OFFSET     (INIT_HCA_QPC_OFFSET + 0x6a)
1440 #define  INIT_HCA_RDMARC_BASE_OFFSET     (INIT_HCA_QPC_OFFSET + 0x70)
1441 #define  INIT_HCA_LOG_RD_OFFSET          (INIT_HCA_QPC_OFFSET + 0x77)
1442 #define INIT_HCA_MCAST_OFFSET            0x0c0
1443 #define  INIT_HCA_MC_BASE_OFFSET         (INIT_HCA_MCAST_OFFSET + 0x00)
1444 #define  INIT_HCA_LOG_MC_ENTRY_SZ_OFFSET (INIT_HCA_MCAST_OFFSET + 0x12)
1445 #define  INIT_HCA_LOG_MC_HASH_SZ_OFFSET  (INIT_HCA_MCAST_OFFSET + 0x16)
1446 #define  INIT_HCA_UC_STEERING_OFFSET     (INIT_HCA_MCAST_OFFSET + 0x18)
1447 #define  INIT_HCA_LOG_MC_TABLE_SZ_OFFSET (INIT_HCA_MCAST_OFFSET + 0x1b)
1448 #define  INIT_HCA_DEVICE_MANAGED_FLOW_STEERING_EN       0x6
1449 #define  INIT_HCA_DRIVER_VERSION_OFFSET   0x140
1450 #define  INIT_HCA_FS_PARAM_OFFSET         0x1d0
1451 #define  INIT_HCA_FS_BASE_OFFSET          (INIT_HCA_FS_PARAM_OFFSET + 0x00)
1452 #define  INIT_HCA_FS_LOG_ENTRY_SZ_OFFSET  (INIT_HCA_FS_PARAM_OFFSET + 0x12)
1453 #define  INIT_HCA_FS_LOG_TABLE_SZ_OFFSET  (INIT_HCA_FS_PARAM_OFFSET + 0x1b)
1454 #define  INIT_HCA_FS_ETH_BITS_OFFSET      (INIT_HCA_FS_PARAM_OFFSET + 0x21)
1455 #define  INIT_HCA_FS_ETH_NUM_ADDRS_OFFSET (INIT_HCA_FS_PARAM_OFFSET + 0x22)
1456 #define  INIT_HCA_FS_IB_BITS_OFFSET       (INIT_HCA_FS_PARAM_OFFSET + 0x25)
1457 #define  INIT_HCA_FS_IB_NUM_ADDRS_OFFSET  (INIT_HCA_FS_PARAM_OFFSET + 0x26)
1458 #define INIT_HCA_TPT_OFFSET              0x0f0
1459 #define  INIT_HCA_DMPT_BASE_OFFSET       (INIT_HCA_TPT_OFFSET + 0x00)
1460 #define  INIT_HCA_TPT_MW_OFFSET          (INIT_HCA_TPT_OFFSET + 0x08)
1461 #define  INIT_HCA_TPT_MW_ENABLE          (1 << 31)
1462 #define  INIT_HCA_LOG_MPT_SZ_OFFSET      (INIT_HCA_TPT_OFFSET + 0x0b)
1463 #define  INIT_HCA_MTT_BASE_OFFSET        (INIT_HCA_TPT_OFFSET + 0x10)
1464 #define  INIT_HCA_CMPT_BASE_OFFSET       (INIT_HCA_TPT_OFFSET + 0x18)
1465 #define INIT_HCA_UAR_OFFSET              0x120
1466 #define  INIT_HCA_LOG_UAR_SZ_OFFSET      (INIT_HCA_UAR_OFFSET + 0x0a)
1467 #define  INIT_HCA_UAR_PAGE_SZ_OFFSET     (INIT_HCA_UAR_OFFSET + 0x0b)
1468
1469         mailbox = mlx4_alloc_cmd_mailbox(dev);
1470         if (IS_ERR(mailbox))
1471                 return PTR_ERR(mailbox);
1472         inbox = mailbox->buf;
1473
1474         memset(inbox, 0, INIT_HCA_IN_SIZE);
1475
1476         *((u8 *) mailbox->buf + INIT_HCA_VERSION_OFFSET) = INIT_HCA_VERSION;
1477
1478         *((u8 *) mailbox->buf + INIT_HCA_CACHELINE_SZ_OFFSET) =
1479                 ((ilog2(cache_line_size()) - 4) << 5) | (1 << 4);
1480
1481 #if defined(__LITTLE_ENDIAN)
1482         *(inbox + INIT_HCA_FLAGS_OFFSET / 4) &= ~cpu_to_be32(1 << 1);
1483 #elif defined(__BIG_ENDIAN)
1484         *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1 << 1);
1485 #else
1486 #error Host endianness not defined
1487 #endif
1488         /* Check port for UD address vector: */
1489         *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1);
1490
1491         /* Enable IPoIB checksumming if we can: */
1492         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_IPOIB_CSUM)
1493                 *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1 << 3);
1494
1495         /* Enable QoS support if module parameter set */
1496         if (enable_qos)
1497                 *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1 << 2);
1498
1499         /* Enable fast drop performance optimization */
1500         if (dev->caps.fast_drop)
1501                 *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1 << 7);
1502
1503         /* enable counters */
1504         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_COUNTERS)
1505                 *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1 << 4);
1506
1507         /* CX3 is capable of extending CQEs\EQEs from 32 to 64 bytes */
1508         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_64B_EQE) {
1509                 *(inbox + INIT_HCA_EQE_CQE_OFFSETS / 4) |= cpu_to_be32(1 << 29);
1510                 dev->caps.eqe_size   = 64;
1511                 dev->caps.eqe_factor = 1;
1512         } else {
1513                 dev->caps.eqe_size   = 32;
1514                 dev->caps.eqe_factor = 0;
1515         }
1516
1517         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_64B_CQE) {
1518                 *(inbox + INIT_HCA_EQE_CQE_OFFSETS / 4) |= cpu_to_be32(1 << 30);
1519                 dev->caps.cqe_size   = 64;
1520                 dev->caps.userspace_caps |= MLX4_USER_DEV_CAP_64B_CQE;
1521         } else {
1522                 dev->caps.cqe_size   = 32;
1523         }
1524
1525         if (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RECOVERABLE_ERROR_EVENT)
1526                 *(inbox + INIT_HCA_RECOVERABLE_ERROR_EVENT_OFFSET / 4) |= cpu_to_be32(1 << 31);
1527
1528         if (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_DRIVER_VERSION_TO_FW) {
1529                 strncpy((u8 *)mailbox->buf + INIT_HCA_DRIVER_VERSION_OFFSET,
1530                         DRV_NAME_FOR_FW,
1531                         INIT_HCA_DRV_NAME_FOR_FW_MAX_SIZE - 1);
1532                 mlx4_dbg(dev, "Reporting Driver Version to FW: %s\n",
1533                          (u8 *)mailbox->buf + INIT_HCA_DRIVER_VERSION_OFFSET);
1534         }
1535
1536         /* QPC/EEC/CQC/EQC/RDMARC attributes */
1537
1538         MLX4_PUT(inbox, param->qpc_base,      INIT_HCA_QPC_BASE_OFFSET);
1539         MLX4_PUT(inbox, param->log_num_qps,   INIT_HCA_LOG_QP_OFFSET);
1540         MLX4_PUT(inbox, param->srqc_base,     INIT_HCA_SRQC_BASE_OFFSET);
1541         MLX4_PUT(inbox, param->log_num_srqs,  INIT_HCA_LOG_SRQ_OFFSET);
1542         MLX4_PUT(inbox, param->cqc_base,      INIT_HCA_CQC_BASE_OFFSET);
1543         MLX4_PUT(inbox, param->log_num_cqs,   INIT_HCA_LOG_CQ_OFFSET);
1544         MLX4_PUT(inbox, param->altc_base,     INIT_HCA_ALTC_BASE_OFFSET);
1545         MLX4_PUT(inbox, param->auxc_base,     INIT_HCA_AUXC_BASE_OFFSET);
1546         MLX4_PUT(inbox, param->eqc_base,      INIT_HCA_EQC_BASE_OFFSET);
1547         MLX4_PUT(inbox, param->log_num_eqs,   INIT_HCA_LOG_EQ_OFFSET);
1548         MLX4_PUT(inbox, param->num_sys_eqs,   INIT_HCA_NUM_SYS_EQS_OFFSET);
1549         MLX4_PUT(inbox, param->rdmarc_base,   INIT_HCA_RDMARC_BASE_OFFSET);
1550         MLX4_PUT(inbox, param->log_rd_per_qp, INIT_HCA_LOG_RD_OFFSET);
1551
1552         /* steering attributes */
1553         if (dev->caps.steering_mode ==
1554             MLX4_STEERING_MODE_DEVICE_MANAGED) {
1555                 *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |=
1556                         cpu_to_be32(1 <<
1557                                     INIT_HCA_DEVICE_MANAGED_FLOW_STEERING_EN);
1558
1559                 MLX4_PUT(inbox, param->mc_base, INIT_HCA_FS_BASE_OFFSET);
1560                 MLX4_PUT(inbox, param->log_mc_entry_sz,
1561                          INIT_HCA_FS_LOG_ENTRY_SZ_OFFSET);
1562                 MLX4_PUT(inbox, param->log_mc_table_sz,
1563                          INIT_HCA_FS_LOG_TABLE_SZ_OFFSET);
1564                 /* Enable Ethernet flow steering
1565                  * with udp unicast and tcp unicast
1566                  */
1567                 MLX4_PUT(inbox, (u8) (MLX4_FS_UDP_UC_EN | MLX4_FS_TCP_UC_EN),
1568                          INIT_HCA_FS_ETH_BITS_OFFSET);
1569                 MLX4_PUT(inbox, (u16) MLX4_FS_NUM_OF_L2_ADDR,
1570                          INIT_HCA_FS_ETH_NUM_ADDRS_OFFSET);
1571                 /* Enable IPoIB flow steering
1572                  * with udp unicast and tcp unicast
1573                  */
1574                 MLX4_PUT(inbox, (u8) (MLX4_FS_UDP_UC_EN | MLX4_FS_TCP_UC_EN),
1575                          INIT_HCA_FS_IB_BITS_OFFSET);
1576                 MLX4_PUT(inbox, (u16) MLX4_FS_NUM_OF_L2_ADDR,
1577                          INIT_HCA_FS_IB_NUM_ADDRS_OFFSET);
1578         } else {
1579                 MLX4_PUT(inbox, param->mc_base, INIT_HCA_MC_BASE_OFFSET);
1580                 MLX4_PUT(inbox, param->log_mc_entry_sz,
1581                          INIT_HCA_LOG_MC_ENTRY_SZ_OFFSET);
1582                 MLX4_PUT(inbox, param->log_mc_hash_sz,
1583                          INIT_HCA_LOG_MC_HASH_SZ_OFFSET);
1584                 MLX4_PUT(inbox, param->log_mc_table_sz,
1585                          INIT_HCA_LOG_MC_TABLE_SZ_OFFSET);
1586                 if (dev->caps.steering_mode == MLX4_STEERING_MODE_B0)
1587                         MLX4_PUT(inbox, (u8) (1 << 3),
1588                                  INIT_HCA_UC_STEERING_OFFSET);
1589         }
1590
1591         /* TPT attributes */
1592
1593         MLX4_PUT(inbox, param->dmpt_base,  INIT_HCA_DMPT_BASE_OFFSET);
1594         mw_enable = param->mw_enable ? INIT_HCA_TPT_MW_ENABLE : 0;
1595         MLX4_PUT(inbox, mw_enable,         INIT_HCA_TPT_MW_OFFSET);
1596         MLX4_PUT(inbox, param->log_mpt_sz, INIT_HCA_LOG_MPT_SZ_OFFSET);
1597         MLX4_PUT(inbox, param->mtt_base,   INIT_HCA_MTT_BASE_OFFSET);
1598         MLX4_PUT(inbox, param->cmpt_base,  INIT_HCA_CMPT_BASE_OFFSET);
1599
1600         /* UAR attributes */
1601
1602         MLX4_PUT(inbox, param->uar_page_sz,     INIT_HCA_UAR_PAGE_SZ_OFFSET);
1603         MLX4_PUT(inbox, param->log_uar_sz,      INIT_HCA_LOG_UAR_SZ_OFFSET);
1604
1605         err = mlx4_cmd(dev, mailbox->dma, 0, 0, MLX4_CMD_INIT_HCA, 10000,
1606                        MLX4_CMD_NATIVE);
1607
1608         if (err)
1609                 mlx4_err(dev, "INIT_HCA returns %d\n", err);
1610
1611         mlx4_free_cmd_mailbox(dev, mailbox);
1612         return err;
1613 }
1614
1615 int mlx4_QUERY_HCA(struct mlx4_dev *dev,
1616                    struct mlx4_init_hca_param *param)
1617 {
1618         struct mlx4_cmd_mailbox *mailbox;
1619         __be32 *outbox;
1620         u32 dword_field;
1621         u32 mw_enable;
1622         int err;
1623         u8 byte_field;
1624
1625 #define QUERY_HCA_GLOBAL_CAPS_OFFSET    0x04
1626 #define QUERY_HCA_CORE_CLOCK_OFFSET     0x0c
1627
1628         mailbox = mlx4_alloc_cmd_mailbox(dev);
1629         if (IS_ERR(mailbox))
1630                 return PTR_ERR(mailbox);
1631         outbox = mailbox->buf;
1632
1633         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0,
1634                            MLX4_CMD_QUERY_HCA,
1635                            MLX4_CMD_TIME_CLASS_B,
1636                            !mlx4_is_slave(dev));
1637         if (err)
1638                 goto out;
1639
1640         MLX4_GET(param->global_caps, outbox, QUERY_HCA_GLOBAL_CAPS_OFFSET);
1641         MLX4_GET(param->hca_core_clock, outbox, QUERY_HCA_CORE_CLOCK_OFFSET);
1642
1643         /* QPC/EEC/CQC/EQC/RDMARC attributes */
1644
1645         MLX4_GET(param->qpc_base,      outbox, INIT_HCA_QPC_BASE_OFFSET);
1646         MLX4_GET(param->log_num_qps,   outbox, INIT_HCA_LOG_QP_OFFSET);
1647         MLX4_GET(param->srqc_base,     outbox, INIT_HCA_SRQC_BASE_OFFSET);
1648         MLX4_GET(param->log_num_srqs,  outbox, INIT_HCA_LOG_SRQ_OFFSET);
1649         MLX4_GET(param->cqc_base,      outbox, INIT_HCA_CQC_BASE_OFFSET);
1650         MLX4_GET(param->log_num_cqs,   outbox, INIT_HCA_LOG_CQ_OFFSET);
1651         MLX4_GET(param->altc_base,     outbox, INIT_HCA_ALTC_BASE_OFFSET);
1652         MLX4_GET(param->auxc_base,     outbox, INIT_HCA_AUXC_BASE_OFFSET);
1653         MLX4_GET(param->eqc_base,      outbox, INIT_HCA_EQC_BASE_OFFSET);
1654         MLX4_GET(param->log_num_eqs,   outbox, INIT_HCA_LOG_EQ_OFFSET);
1655         MLX4_GET(param->num_sys_eqs,   outbox, INIT_HCA_NUM_SYS_EQS_OFFSET);
1656         MLX4_GET(param->rdmarc_base,   outbox, INIT_HCA_RDMARC_BASE_OFFSET);
1657         MLX4_GET(param->log_rd_per_qp, outbox, INIT_HCA_LOG_RD_OFFSET);
1658
1659         MLX4_GET(dword_field, outbox, INIT_HCA_FLAGS_OFFSET);
1660         if (dword_field & (1 << INIT_HCA_DEVICE_MANAGED_FLOW_STEERING_EN)) {
1661                 param->steering_mode = MLX4_STEERING_MODE_DEVICE_MANAGED;
1662         } else {
1663                 MLX4_GET(byte_field, outbox, INIT_HCA_UC_STEERING_OFFSET);
1664                 if (byte_field & 0x8)
1665                         param->steering_mode = MLX4_STEERING_MODE_B0;
1666                 else
1667                         param->steering_mode = MLX4_STEERING_MODE_A0;
1668         }
1669         /* steering attributes */
1670         if (param->steering_mode == MLX4_STEERING_MODE_DEVICE_MANAGED) {
1671                 MLX4_GET(param->mc_base, outbox, INIT_HCA_FS_BASE_OFFSET);
1672                 MLX4_GET(param->log_mc_entry_sz, outbox,
1673                          INIT_HCA_FS_LOG_ENTRY_SZ_OFFSET);
1674                 MLX4_GET(param->log_mc_table_sz, outbox,
1675                          INIT_HCA_FS_LOG_TABLE_SZ_OFFSET);
1676         } else {
1677                 MLX4_GET(param->mc_base, outbox, INIT_HCA_MC_BASE_OFFSET);
1678                 MLX4_GET(param->log_mc_entry_sz, outbox,
1679                          INIT_HCA_LOG_MC_ENTRY_SZ_OFFSET);
1680                 MLX4_GET(param->log_mc_hash_sz,  outbox,
1681                          INIT_HCA_LOG_MC_HASH_SZ_OFFSET);
1682                 MLX4_GET(param->log_mc_table_sz, outbox,
1683                          INIT_HCA_LOG_MC_TABLE_SZ_OFFSET);
1684         }
1685
1686         /* CX3 is capable of extending CQEs\EQEs from 32 to 64 bytes */
1687         MLX4_GET(byte_field, outbox, INIT_HCA_EQE_CQE_OFFSETS);
1688         if (byte_field & 0x20) /* 64-bytes eqe enabled */
1689                 param->dev_cap_enabled |= MLX4_DEV_CAP_64B_EQE_ENABLED;
1690         if (byte_field & 0x40) /* 64-bytes cqe enabled */
1691                 param->dev_cap_enabled |= MLX4_DEV_CAP_64B_CQE_ENABLED;
1692
1693         /* TPT attributes */
1694
1695         MLX4_GET(param->dmpt_base,  outbox, INIT_HCA_DMPT_BASE_OFFSET);
1696         MLX4_GET(mw_enable,         outbox, INIT_HCA_TPT_MW_OFFSET);
1697         param->mw_enable = (mw_enable & INIT_HCA_TPT_MW_ENABLE) ==
1698                            INIT_HCA_TPT_MW_ENABLE;
1699         MLX4_GET(param->log_mpt_sz, outbox, INIT_HCA_LOG_MPT_SZ_OFFSET);
1700         MLX4_GET(param->mtt_base,   outbox, INIT_HCA_MTT_BASE_OFFSET);
1701         MLX4_GET(param->cmpt_base,  outbox, INIT_HCA_CMPT_BASE_OFFSET);
1702
1703         /* UAR attributes */
1704
1705         MLX4_GET(param->uar_page_sz, outbox, INIT_HCA_UAR_PAGE_SZ_OFFSET);
1706         MLX4_GET(param->log_uar_sz, outbox, INIT_HCA_LOG_UAR_SZ_OFFSET);
1707
1708 out:
1709         mlx4_free_cmd_mailbox(dev, mailbox);
1710
1711         return err;
1712 }
1713
1714 /* for IB-type ports only in SRIOV mode. Checks that both proxy QP0
1715  * and real QP0 are active, so that the paravirtualized QP0 is ready
1716  * to operate */
1717 static int check_qp0_state(struct mlx4_dev *dev, int function, int port)
1718 {
1719         struct mlx4_priv *priv = mlx4_priv(dev);
1720         /* irrelevant if not infiniband */
1721         if (priv->mfunc.master.qp0_state[port].proxy_qp0_active &&
1722             priv->mfunc.master.qp0_state[port].qp0_active)
1723                 return 1;
1724         return 0;
1725 }
1726
1727 int mlx4_INIT_PORT_wrapper(struct mlx4_dev *dev, int slave,
1728                            struct mlx4_vhcr *vhcr,
1729                            struct mlx4_cmd_mailbox *inbox,
1730                            struct mlx4_cmd_mailbox *outbox,
1731                            struct mlx4_cmd_info *cmd)
1732 {
1733         struct mlx4_priv *priv = mlx4_priv(dev);
1734         int port = vhcr->in_modifier;
1735         int err;
1736
1737         if (priv->mfunc.master.slave_state[slave].init_port_mask & (1 << port))
1738                 return 0;
1739
1740         if (dev->caps.port_mask[port] != MLX4_PORT_TYPE_IB) {
1741                 /* Enable port only if it was previously disabled */
1742                 if (!priv->mfunc.master.init_port_ref[port]) {
1743                         err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_INIT_PORT,
1744                                        MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1745                         if (err)
1746                                 return err;
1747                 }
1748                 priv->mfunc.master.slave_state[slave].init_port_mask |= (1 << port);
1749         } else {
1750                 if (slave == mlx4_master_func_num(dev)) {
1751                         if (check_qp0_state(dev, slave, port) &&
1752                             !priv->mfunc.master.qp0_state[port].port_active) {
1753                                 err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_INIT_PORT,
1754                                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1755                                 if (err)
1756                                         return err;
1757                                 priv->mfunc.master.qp0_state[port].port_active = 1;
1758                                 priv->mfunc.master.slave_state[slave].init_port_mask |= (1 << port);
1759                         }
1760                 } else
1761                         priv->mfunc.master.slave_state[slave].init_port_mask |= (1 << port);
1762         }
1763         ++priv->mfunc.master.init_port_ref[port];
1764         return 0;
1765 }
1766
1767 int mlx4_INIT_PORT(struct mlx4_dev *dev, int port)
1768 {
1769         struct mlx4_cmd_mailbox *mailbox;
1770         u32 *inbox;
1771         int err;
1772         u32 flags;
1773         u16 field;
1774
1775         if (dev->flags & MLX4_FLAG_OLD_PORT_CMDS) {
1776 #define INIT_PORT_IN_SIZE          256
1777 #define INIT_PORT_FLAGS_OFFSET     0x00
1778 #define INIT_PORT_FLAG_SIG         (1 << 18)
1779 #define INIT_PORT_FLAG_NG          (1 << 17)
1780 #define INIT_PORT_FLAG_G0          (1 << 16)
1781 #define INIT_PORT_VL_SHIFT         4
1782 #define INIT_PORT_PORT_WIDTH_SHIFT 8
1783 #define INIT_PORT_MTU_OFFSET       0x04
1784 #define INIT_PORT_MAX_GID_OFFSET   0x06
1785 #define INIT_PORT_MAX_PKEY_OFFSET  0x0a
1786 #define INIT_PORT_GUID0_OFFSET     0x10
1787 #define INIT_PORT_NODE_GUID_OFFSET 0x18
1788 #define INIT_PORT_SI_GUID_OFFSET   0x20
1789
1790                 mailbox = mlx4_alloc_cmd_mailbox(dev);
1791                 if (IS_ERR(mailbox))
1792                         return PTR_ERR(mailbox);
1793                 inbox = mailbox->buf;
1794
1795                 memset(inbox, 0, INIT_PORT_IN_SIZE);
1796
1797                 flags = 0;
1798                 flags |= (dev->caps.vl_cap[port] & 0xf) << INIT_PORT_VL_SHIFT;
1799                 flags |= (dev->caps.port_width_cap[port] & 0xf) << INIT_PORT_PORT_WIDTH_SHIFT;
1800                 MLX4_PUT(inbox, flags,            INIT_PORT_FLAGS_OFFSET);
1801
1802                 field = 128 << dev->caps.ib_mtu_cap[port];
1803                 MLX4_PUT(inbox, field, INIT_PORT_MTU_OFFSET);
1804                 field = dev->caps.gid_table_len[port];
1805                 MLX4_PUT(inbox, field, INIT_PORT_MAX_GID_OFFSET);
1806                 field = dev->caps.pkey_table_len[port];
1807                 MLX4_PUT(inbox, field, INIT_PORT_MAX_PKEY_OFFSET);
1808
1809                 err = mlx4_cmd(dev, mailbox->dma, port, 0, MLX4_CMD_INIT_PORT,
1810                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1811
1812                 mlx4_free_cmd_mailbox(dev, mailbox);
1813         } else
1814                 err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_INIT_PORT,
1815                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
1816
1817         return err;
1818 }
1819 EXPORT_SYMBOL_GPL(mlx4_INIT_PORT);
1820
1821 int mlx4_CLOSE_PORT_wrapper(struct mlx4_dev *dev, int slave,
1822                             struct mlx4_vhcr *vhcr,
1823                             struct mlx4_cmd_mailbox *inbox,
1824                             struct mlx4_cmd_mailbox *outbox,
1825                             struct mlx4_cmd_info *cmd)
1826 {
1827         struct mlx4_priv *priv = mlx4_priv(dev);
1828         int port = vhcr->in_modifier;
1829         int err;
1830
1831         if (!(priv->mfunc.master.slave_state[slave].init_port_mask &
1832             (1 << port)))
1833                 return 0;
1834
1835         if (dev->caps.port_mask[port] != MLX4_PORT_TYPE_IB) {
1836                 if (priv->mfunc.master.init_port_ref[port] == 1) {
1837                         err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT,
1838                                        1000, MLX4_CMD_NATIVE);
1839                         if (err)
1840                                 return err;
1841                 }
1842                 priv->mfunc.master.slave_state[slave].init_port_mask &= ~(1 << port);
1843         } else {
1844                 /* infiniband port */
1845                 if (slave == mlx4_master_func_num(dev)) {
1846                         if (!priv->mfunc.master.qp0_state[port].qp0_active &&
1847                             priv->mfunc.master.qp0_state[port].port_active) {
1848                                 err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT,
1849                                                1000, MLX4_CMD_NATIVE);
1850                                 if (err)
1851                                         return err;
1852                                 priv->mfunc.master.slave_state[slave].init_port_mask &= ~(1 << port);
1853                                 priv->mfunc.master.qp0_state[port].port_active = 0;
1854                         }
1855                 } else
1856                         priv->mfunc.master.slave_state[slave].init_port_mask &= ~(1 << port);
1857         }
1858         --priv->mfunc.master.init_port_ref[port];
1859         return 0;
1860 }
1861
1862 int mlx4_CLOSE_PORT(struct mlx4_dev *dev, int port)
1863 {
1864         return mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT, 1000,
1865                         MLX4_CMD_WRAPPED);
1866 }
1867 EXPORT_SYMBOL_GPL(mlx4_CLOSE_PORT);
1868
1869 int mlx4_CLOSE_HCA(struct mlx4_dev *dev, int panic)
1870 {
1871         return mlx4_cmd(dev, 0, 0, panic, MLX4_CMD_CLOSE_HCA, 1000,
1872                         MLX4_CMD_NATIVE);
1873 }
1874
1875 int mlx4_SET_ICM_SIZE(struct mlx4_dev *dev, u64 icm_size, u64 *aux_pages)
1876 {
1877         int ret = mlx4_cmd_imm(dev, icm_size, aux_pages, 0, 0,
1878                                MLX4_CMD_SET_ICM_SIZE,
1879                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1880         if (ret)
1881                 return ret;
1882
1883         /*
1884          * Round up number of system pages needed in case
1885          * MLX4_ICM_PAGE_SIZE < PAGE_SIZE.
1886          */
1887         *aux_pages = ALIGN(*aux_pages, PAGE_SIZE / MLX4_ICM_PAGE_SIZE) >>
1888                 (PAGE_SHIFT - MLX4_ICM_PAGE_SHIFT);
1889
1890         return 0;
1891 }
1892
1893 int mlx4_NOP(struct mlx4_dev *dev)
1894 {
1895         /* Input modifier of 0x1f means "finish as soon as possible." */
1896         return mlx4_cmd(dev, 0, 0x1f, 0, MLX4_CMD_NOP, MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1897 }
1898
1899 int mlx4_query_diag_counters(struct mlx4_dev *dev, int array_length,
1900                              u8 op_modifier, u32 in_offset[],
1901                              u32 counter_out[])
1902 {
1903         struct mlx4_cmd_mailbox *mailbox;
1904         u32 *outbox;
1905         int ret;
1906         int i;
1907
1908         mailbox = mlx4_alloc_cmd_mailbox(dev);
1909         if (IS_ERR(mailbox))
1910                 return PTR_ERR(mailbox);
1911         outbox = mailbox->buf;
1912
1913         ret = mlx4_cmd_box(dev, 0, mailbox->dma, 0, op_modifier,
1914                            MLX4_CMD_DIAG_RPRT, MLX4_CMD_TIME_CLASS_A,
1915                            MLX4_CMD_NATIVE);
1916         if (ret)
1917                 goto out;
1918
1919         for (i = 0; i < array_length; i++) {
1920                 if (in_offset[i] > MLX4_MAILBOX_SIZE) {
1921                         ret = -EINVAL;
1922                         goto out;
1923                 }
1924
1925                 MLX4_GET(counter_out[i], outbox, in_offset[i]);
1926         }
1927
1928 out:
1929         mlx4_free_cmd_mailbox(dev, mailbox);
1930         return ret;
1931 }
1932 EXPORT_SYMBOL_GPL(mlx4_query_diag_counters);
1933
1934 int mlx4_MOD_STAT_CFG_wrapper(struct mlx4_dev *dev, int slave,
1935                           struct mlx4_vhcr *vhcr,
1936                           struct mlx4_cmd_mailbox *inbox,
1937                           struct mlx4_cmd_mailbox *outbox,
1938                           struct mlx4_cmd_info *cmd)
1939 {
1940         return -EPERM;
1941 }
1942
1943 #define MLX4_WOL_SETUP_MODE (5 << 28)
1944 int mlx4_wol_read(struct mlx4_dev *dev, u64 *config, int port)
1945 {
1946         u32 in_mod = MLX4_WOL_SETUP_MODE | port << 8;
1947
1948         return mlx4_cmd_imm(dev, 0, config, in_mod, 0x3,
1949                             MLX4_CMD_MOD_STAT_CFG, MLX4_CMD_TIME_CLASS_A,
1950                             MLX4_CMD_NATIVE);
1951 }
1952 EXPORT_SYMBOL_GPL(mlx4_wol_read);
1953
1954 int mlx4_wol_write(struct mlx4_dev *dev, u64 config, int port)
1955 {
1956         u32 in_mod = MLX4_WOL_SETUP_MODE | port << 8;
1957
1958         return mlx4_cmd(dev, config, in_mod, 0x1, MLX4_CMD_MOD_STAT_CFG,
1959                         MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1960 }
1961 EXPORT_SYMBOL_GPL(mlx4_wol_write);
1962
1963 enum {
1964         ADD_TO_MCG = 0x26,
1965 };
1966
1967
1968 void mlx4_opreq_action(struct work_struct *work)
1969 {
1970         struct mlx4_priv *priv = container_of(work, struct mlx4_priv, opreq_task);
1971         struct mlx4_dev *dev = &priv->dev;
1972         int num_tasks = atomic_read(&priv->opreq_count);
1973         struct mlx4_cmd_mailbox *mailbox;
1974         struct mlx4_mgm *mgm;
1975         u32 *outbox;
1976         u32 modifier;
1977         u16 token;
1978         u16 type_m;
1979         u16 type;
1980         int err;
1981         u32 num_qps;
1982         struct mlx4_qp qp;
1983         int i;
1984         u8 rem_mcg;
1985         u8 prot;
1986
1987 #define GET_OP_REQ_MODIFIER_OFFSET      0x08
1988 #define GET_OP_REQ_TOKEN_OFFSET         0x14
1989 #define GET_OP_REQ_TYPE_OFFSET          0x1a
1990 #define GET_OP_REQ_DATA_OFFSET          0x20
1991
1992         mailbox = mlx4_alloc_cmd_mailbox(dev);
1993         if (IS_ERR(mailbox)) {
1994                 mlx4_err(dev, "Failed to allocate mailbox for GET_OP_REQ\n");
1995                 return;
1996         }
1997         outbox = mailbox->buf;
1998
1999         while (num_tasks) {
2000                 err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0,
2001                                    MLX4_CMD_GET_OP_REQ, MLX4_CMD_TIME_CLASS_A,
2002                                    MLX4_CMD_NATIVE);
2003                 if (err) {
2004                         mlx4_err(dev, "Failed to retreive required operation: %d\n", err);
2005                         return;
2006                 }
2007                 MLX4_GET(modifier, outbox, GET_OP_REQ_MODIFIER_OFFSET);
2008                 MLX4_GET(token, outbox, GET_OP_REQ_TOKEN_OFFSET);
2009                 MLX4_GET(type, outbox, GET_OP_REQ_TYPE_OFFSET);
2010                 type_m = type >> 12;
2011                 type &= 0xfff;
2012
2013                 switch (type) {
2014                 case ADD_TO_MCG:
2015                         if (dev->caps.steering_mode == MLX4_STEERING_MODE_DEVICE_MANAGED) {
2016                                 mlx4_warn(dev, "ADD MCG operation is not supported in "
2017                                                "DEVICE_MANAGED steerign mode\n");
2018                                 err = EPERM;
2019                                 break;
2020                         }
2021                         mgm = (struct mlx4_mgm *) ((u8 *) (outbox) + GET_OP_REQ_DATA_OFFSET);
2022                         num_qps = be32_to_cpu(mgm->members_count) & MGM_QPN_MASK;
2023                         rem_mcg = ((u8 *) (&mgm->members_count))[0] & 1;
2024                         prot = ((u8 *) (&mgm->members_count))[0] >> 6;
2025
2026                         for (i = 0; i < num_qps; i++) {
2027                                 qp.qpn = be32_to_cpu(mgm->qp[i]);
2028                                 if (rem_mcg)
2029                                         err = mlx4_multicast_detach(dev, &qp, mgm->gid, prot, 0);
2030                                 else
2031                                         err = mlx4_multicast_attach(dev, &qp, mgm->gid, mgm->gid[5] ,0, prot, NULL);
2032                                 if (err)
2033                                         break;
2034                         }
2035                         break;
2036                 default:
2037                         mlx4_warn(dev, "Bad type for required operation\n");
2038                         err = EINVAL;
2039                         break;
2040                 }
2041                 err = mlx4_cmd(dev, 0, ((u32) err | cpu_to_be32(token) << 16), 1,
2042                                MLX4_CMD_GET_OP_REQ, MLX4_CMD_TIME_CLASS_A,
2043                                MLX4_CMD_NATIVE);
2044                 if (err) {
2045                         mlx4_err(dev, "Failed to acknowledge required request: %d\n", err);
2046                         goto out;
2047                 }
2048                 memset(outbox, 0, 0xffc);
2049                 num_tasks = atomic_dec_return(&priv->opreq_count);
2050         }
2051
2052 out:
2053         mlx4_free_cmd_mailbox(dev, mailbox);
2054 }