drivers/net/ethernet/mellanox/mlx4/fw.c

   1 /*
   2  * Copyright (c) 2004, 2005 Topspin Communications.  All rights reserved.
   3  * Copyright (c) 2005, 2006, 2007, 2008 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] = "Dual Port Different Protocol (DPDP) support",
  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                 [48] = "Counters support",
 112                 [53] = "Port ETS Scheduler support",
 113                 [55] = "Port link type sensing support",
 114                 [59] = "Port management change event 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 managed flow steering support",
 133                 [4] = "Automatic MAC reassignment support",
 134                 [5] = "Time stamping support",
 135                 [6] = "VST (control vlan insertion/stripping) support",
 136                 [7] = "FSM (MAC anti-spoofing) support",
 137                 [8] = "Dynamic QP updates support",
 138                 [9] = "Device managed flow steering IPoIB support",
 139                 [10] = "TCP/IP offloads/flow-steering for VXLAN support",
 140                 [11] = "MAD DEMUX (Secure-Host) support",
 141                 [12] = "Large cache line (>64B) CQE stride support",
 142                 [13] = "Large cache line (>64B) EQE stride support",
 143                 [14] = "Ethernet protocol control support",
 144                 [15] = "Ethernet Backplane autoneg support",
 145                 [16] = "CONFIG DEV support",
 146                 [17] = "Asymmetric EQs support",
 147                 [18] = "More than 80 VFs support",
 148                 [19] = "Performance optimized for limited rule configuration flow steering support",
 149                 [20] = "Recoverable error events support"
 150         };
 151         int i;
 152
 153         for (i = 0; i < ARRAY_SIZE(fname); ++i)
 154                 if (fname[i] && (flags & (1LL << i)))
 155                         mlx4_dbg(dev, "    %s\n", fname[i]);
 156 }
 157
 158 int mlx4_MOD_STAT_CFG(struct mlx4_dev *dev, struct mlx4_mod_stat_cfg *cfg)
 159 {
 160         struct mlx4_cmd_mailbox *mailbox;
 161         u32 *inbox;
 162         int err = 0;
 163
 164 #define MOD_STAT_CFG_IN_SIZE            0x100
 165
 166 #define MOD_STAT_CFG_PG_SZ_M_OFFSET     0x002
 167 #define MOD_STAT_CFG_PG_SZ_OFFSET       0x003
 168
 169         mailbox = mlx4_alloc_cmd_mailbox(dev);
 170         if (IS_ERR(mailbox))
 171                 return PTR_ERR(mailbox);
 172         inbox = mailbox->buf;
 173
 174         MLX4_PUT(inbox, cfg->log_pg_sz, MOD_STAT_CFG_PG_SZ_OFFSET);
 175         MLX4_PUT(inbox, cfg->log_pg_sz_m, MOD_STAT_CFG_PG_SZ_M_OFFSET);
 176
 177         err = mlx4_cmd(dev, mailbox->dma, 0, 0, MLX4_CMD_MOD_STAT_CFG,
 178                         MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
 179
 180         mlx4_free_cmd_mailbox(dev, mailbox);
 181         return err;
 182 }
 183
 184 int mlx4_QUERY_FUNC(struct mlx4_dev *dev, struct mlx4_func *func, int slave)
 185 {
 186         struct mlx4_cmd_mailbox *mailbox;
 187         u32 *outbox;
 188         u8 in_modifier;
 189         u8 field;
 190         u16 field16;
 191         int err;
 192
 193 #define QUERY_FUNC_BUS_OFFSET                   0x00
 194 #define QUERY_FUNC_DEVICE_OFFSET                0x01
 195 #define QUERY_FUNC_FUNCTION_OFFSET              0x01
 196 #define QUERY_FUNC_PHYSICAL_FUNCTION_OFFSET     0x03
 197 #define QUERY_FUNC_RSVD_EQS_OFFSET              0x04
 198 #define QUERY_FUNC_MAX_EQ_OFFSET                0x06
 199 #define QUERY_FUNC_RSVD_UARS_OFFSET             0x0b
 200
 201         mailbox = mlx4_alloc_cmd_mailbox(dev);
 202         if (IS_ERR(mailbox))
 203                 return PTR_ERR(mailbox);
 204         outbox = mailbox->buf;
 205
 206         in_modifier = slave;
 207
 208         err = mlx4_cmd_box(dev, 0, mailbox->dma, in_modifier, 0,
 209                            MLX4_CMD_QUERY_FUNC,
 210                            MLX4_CMD_TIME_CLASS_A,
 211                            MLX4_CMD_NATIVE);
 212         if (err)
 213                 goto out;
 214
 215         MLX4_GET(field, outbox, QUERY_FUNC_BUS_OFFSET);
 216         func->bus = field & 0xf;
 217         MLX4_GET(field, outbox, QUERY_FUNC_DEVICE_OFFSET);
 218         func->device = field & 0xf1;
 219         MLX4_GET(field, outbox, QUERY_FUNC_FUNCTION_OFFSET);
 220         func->function = field & 0x7;
 221         MLX4_GET(field, outbox, QUERY_FUNC_PHYSICAL_FUNCTION_OFFSET);
 222         func->physical_function = field & 0xf;
 223         MLX4_GET(field16, outbox, QUERY_FUNC_RSVD_EQS_OFFSET);
 224         func->rsvd_eqs = field16 & 0xffff;
 225         MLX4_GET(field16, outbox, QUERY_FUNC_MAX_EQ_OFFSET);
 226         func->max_eq = field16 & 0xffff;
 227         MLX4_GET(field, outbox, QUERY_FUNC_RSVD_UARS_OFFSET);
 228         func->rsvd_uars = field & 0x0f;
 229
 230         mlx4_dbg(dev, "Bus: %d, Device: %d, Function: %d, Physical function: %d, Max EQs: %d, Reserved EQs: %d, Reserved UARs: %d\n",
 231                  func->bus, func->device, func->function, func->physical_function,
 232                  func->max_eq, func->rsvd_eqs, func->rsvd_uars);
 233
 234 out:
 235         mlx4_free_cmd_mailbox(dev, mailbox);
 236         return err;
 237 }
 238
 239 int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
 240                                 struct mlx4_vhcr *vhcr,
 241                                 struct mlx4_cmd_mailbox *inbox,
 242                                 struct mlx4_cmd_mailbox *outbox,
 243                                 struct mlx4_cmd_info *cmd)
 244 {
 245         struct mlx4_priv *priv = mlx4_priv(dev);
 246         u8      field, port;
 247         u32     size, proxy_qp, qkey;
 248         int     err = 0;
 249         struct mlx4_func func;
 250
 251 #define QUERY_FUNC_CAP_FLAGS_OFFSET             0x0
 252 #define QUERY_FUNC_CAP_NUM_PORTS_OFFSET         0x1
 253 #define QUERY_FUNC_CAP_PF_BHVR_OFFSET           0x4
 254 #define QUERY_FUNC_CAP_FMR_OFFSET               0x8
 255 #define QUERY_FUNC_CAP_QP_QUOTA_OFFSET_DEP      0x10
 256 #define QUERY_FUNC_CAP_CQ_QUOTA_OFFSET_DEP      0x14
 257 #define QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET_DEP     0x18
 258 #define QUERY_FUNC_CAP_MPT_QUOTA_OFFSET_DEP     0x20
 259 #define QUERY_FUNC_CAP_MTT_QUOTA_OFFSET_DEP     0x24
 260 #define QUERY_FUNC_CAP_MCG_QUOTA_OFFSET_DEP     0x28
 261 #define QUERY_FUNC_CAP_MAX_EQ_OFFSET            0x2c
 262 #define QUERY_FUNC_CAP_RESERVED_EQ_OFFSET       0x30
 263
 264 #define QUERY_FUNC_CAP_QP_QUOTA_OFFSET          0x50
 265 #define QUERY_FUNC_CAP_CQ_QUOTA_OFFSET          0x54
 266 #define QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET         0x58
 267 #define QUERY_FUNC_CAP_MPT_QUOTA_OFFSET         0x60
 268 #define QUERY_FUNC_CAP_MTT_QUOTA_OFFSET         0x64
 269 #define QUERY_FUNC_CAP_MCG_QUOTA_OFFSET         0x68
 270
 271 #define QUERY_FUNC_CAP_EXTRA_FLAGS_OFFSET       0x6c
 272
 273 #define QUERY_FUNC_CAP_FMR_FLAG                 0x80
 274 #define QUERY_FUNC_CAP_FLAG_RDMA                0x40
 275 #define QUERY_FUNC_CAP_FLAG_ETH                 0x80
 276 #define QUERY_FUNC_CAP_FLAG_QUOTAS              0x10
 277 #define QUERY_FUNC_CAP_FLAG_VALID_MAILBOX       0x04
 278
 279 #define QUERY_FUNC_CAP_EXTRA_FLAGS_BF_QP_ALLOC_FLAG     (1UL << 31)
 280 #define QUERY_FUNC_CAP_EXTRA_FLAGS_A0_QP_ALLOC_FLAG     (1UL << 30)
 281
 282 /* when opcode modifier = 1 */
 283 #define QUERY_FUNC_CAP_PHYS_PORT_OFFSET         0x3
 284 #define QUERY_FUNC_CAP_PRIV_VF_QKEY_OFFSET      0x4
 285 #define QUERY_FUNC_CAP_FLAGS0_OFFSET            0x8
 286 #define QUERY_FUNC_CAP_FLAGS1_OFFSET            0xc
 287
 288 #define QUERY_FUNC_CAP_QP0_TUNNEL               0x10
 289 #define QUERY_FUNC_CAP_QP0_PROXY                0x14
 290 #define QUERY_FUNC_CAP_QP1_TUNNEL               0x18
 291 #define QUERY_FUNC_CAP_QP1_PROXY                0x1c
 292 #define QUERY_FUNC_CAP_PHYS_PORT_ID             0x28
 293
 294 #define QUERY_FUNC_CAP_FLAGS1_FORCE_MAC         0x40
 295 #define QUERY_FUNC_CAP_FLAGS1_FORCE_VLAN        0x80
 296 #define QUERY_FUNC_CAP_FLAGS1_NIC_INFO                  0x10
 297 #define QUERY_FUNC_CAP_VF_ENABLE_QP0            0x08
 298
 299 #define QUERY_FUNC_CAP_FLAGS0_FORCE_PHY_WQE_GID 0x80
 300 #define QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS (1 << 31)
 301
 302         if (vhcr->op_modifier == 1) {
 303                 struct mlx4_active_ports actv_ports =
 304                         mlx4_get_active_ports(dev, slave);
 305                 int converted_port = mlx4_slave_convert_port(
 306                                 dev, slave, vhcr->in_modifier);
 307
 308                 if (converted_port < 0)
 309                         return -EINVAL;
 310
 311                 vhcr->in_modifier = converted_port;
 312                 /* phys-port = logical-port */
 313                 field = vhcr->in_modifier -
 314                         find_first_bit(actv_ports.ports, dev->caps.num_ports);
 315                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_PHYS_PORT_OFFSET);
 316
 317                 port = vhcr->in_modifier;
 318                 proxy_qp = dev->phys_caps.base_proxy_sqpn + 8 * slave + port - 1;
 319
 320                 /* Set nic_info bit to mark new fields support */
 321                 field  = QUERY_FUNC_CAP_FLAGS1_NIC_INFO;
 322
 323                 if (mlx4_vf_smi_enabled(dev, slave, port) &&
 324                     !mlx4_get_parav_qkey(dev, proxy_qp, &qkey)) {
 325                         field |= QUERY_FUNC_CAP_VF_ENABLE_QP0;
 326                         MLX4_PUT(outbox->buf, qkey,
 327                                  QUERY_FUNC_CAP_PRIV_VF_QKEY_OFFSET);
 328                 }
 329                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_FLAGS1_OFFSET);
 330
 331                 /* size is now the QP number */
 332                 size = dev->phys_caps.base_tunnel_sqpn + 8 * slave + port - 1;
 333                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP0_TUNNEL);
 334
 335                 size += 2;
 336                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP1_TUNNEL);
 337
 338                 MLX4_PUT(outbox->buf, proxy_qp, QUERY_FUNC_CAP_QP0_PROXY);
 339                 proxy_qp += 2;
 340                 MLX4_PUT(outbox->buf, proxy_qp, QUERY_FUNC_CAP_QP1_PROXY);
 341
 342                 MLX4_PUT(outbox->buf, dev->caps.phys_port_id[vhcr->in_modifier],
 343                          QUERY_FUNC_CAP_PHYS_PORT_ID);
 344
 345         } else if (vhcr->op_modifier == 0) {
 346                 struct mlx4_active_ports actv_ports =
 347                         mlx4_get_active_ports(dev, slave);
 348                 /* enable rdma and ethernet interfaces, and new quota locations */
 349                 field = (QUERY_FUNC_CAP_FLAG_ETH | QUERY_FUNC_CAP_FLAG_RDMA |
 350                          QUERY_FUNC_CAP_FLAG_QUOTAS | QUERY_FUNC_CAP_FLAG_VALID_MAILBOX);
 351                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_FLAGS_OFFSET);
 352
 353                 field = min(
 354                         bitmap_weight(actv_ports.ports, dev->caps.num_ports),
 355                         dev->caps.num_ports);
 356                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_NUM_PORTS_OFFSET);
 357
 358                 size = dev->caps.function_caps; /* set PF behaviours */
 359                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_PF_BHVR_OFFSET);
 360
 361                 field = 0; /* protected FMR support not available as yet */
 362                 MLX4_PUT(outbox->buf, field, QUERY_FUNC_CAP_FMR_OFFSET);
 363
 364                 size = priv->mfunc.master.res_tracker.res_alloc[RES_QP].quota[slave];
 365                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP_QUOTA_OFFSET);
 366                 size = dev->caps.num_qps;
 367                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_QP_QUOTA_OFFSET_DEP);
 368
 369                 size = priv->mfunc.master.res_tracker.res_alloc[RES_SRQ].quota[slave];
 370                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET);
 371                 size = dev->caps.num_srqs;
 372                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET_DEP);
 373
 374                 size = priv->mfunc.master.res_tracker.res_alloc[RES_CQ].quota[slave];
 375                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_CQ_QUOTA_OFFSET);
 376                 size = dev->caps.num_cqs;
 377                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_CQ_QUOTA_OFFSET_DEP);
 378
 379                 if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS) ||
 380                     mlx4_QUERY_FUNC(dev, &func, slave)) {
 381                         size = vhcr->in_modifier &
 382                                 QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS ?
 383                                 dev->caps.num_eqs :
 384                                 rounddown_pow_of_two(dev->caps.num_eqs);
 385                         MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MAX_EQ_OFFSET);
 386                         size = dev->caps.reserved_eqs;
 387                         MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
 388                 } else {
 389                         size = vhcr->in_modifier &
 390                                 QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS ?
 391                                 func.max_eq :
 392                                 rounddown_pow_of_two(func.max_eq);
 393                         MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MAX_EQ_OFFSET);
 394                         size = func.rsvd_eqs;
 395                         MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
 396                 }
 397
 398                 size = priv->mfunc.master.res_tracker.res_alloc[RES_MPT].quota[slave];
 399                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MPT_QUOTA_OFFSET);
 400                 size = dev->caps.num_mpts;
 401                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MPT_QUOTA_OFFSET_DEP);
 402
 403                 size = priv->mfunc.master.res_tracker.res_alloc[RES_MTT].quota[slave];
 404                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MTT_QUOTA_OFFSET);
 405                 size = dev->caps.num_mtts;
 406                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MTT_QUOTA_OFFSET_DEP);
 407
 408                 size = dev->caps.num_mgms + dev->caps.num_amgms;
 409                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MCG_QUOTA_OFFSET);
 410                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MCG_QUOTA_OFFSET_DEP);
 411
 412                 size = QUERY_FUNC_CAP_EXTRA_FLAGS_BF_QP_ALLOC_FLAG |
 413                         QUERY_FUNC_CAP_EXTRA_FLAGS_A0_QP_ALLOC_FLAG;
 414                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_EXTRA_FLAGS_OFFSET);
 415         } else
 416                 err = -EINVAL;
 417
 418         return err;
 419 }
 420
 421 int mlx4_QUERY_FUNC_CAP(struct mlx4_dev *dev, u8 gen_or_port,
 422                         struct mlx4_func_cap *func_cap)
 423 {
 424         struct mlx4_cmd_mailbox *mailbox;
 425         u32                     *outbox;
 426         u8                      field, op_modifier;
 427         u32                     size, qkey;
 428         int                     err = 0, quotas = 0;
 429         u32                     in_modifier;
 430
 431         op_modifier = !!gen_or_port; /* 0 = general, 1 = logical port */
 432         in_modifier = op_modifier ? gen_or_port :
 433                 QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS;
 434
 435         mailbox = mlx4_alloc_cmd_mailbox(dev);
 436         if (IS_ERR(mailbox))
 437                 return PTR_ERR(mailbox);
 438
 439         err = mlx4_cmd_box(dev, 0, mailbox->dma, in_modifier, op_modifier,
 440                            MLX4_CMD_QUERY_FUNC_CAP,
 441                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
 442         if (err)
 443                 goto out;
 444
 445         outbox = mailbox->buf;
 446
 447         if (!op_modifier) {
 448                 MLX4_GET(field, outbox, QUERY_FUNC_CAP_FLAGS_OFFSET);
 449                 if (!(field & (QUERY_FUNC_CAP_FLAG_ETH | QUERY_FUNC_CAP_FLAG_RDMA))) {
 450                         mlx4_err(dev, "The host supports neither eth nor rdma interfaces\n");
 451                         err = -EPROTONOSUPPORT;
 452                         goto out;
 453                 }
 454                 func_cap->flags = field;
 455                 quotas = !!(func_cap->flags & QUERY_FUNC_CAP_FLAG_QUOTAS);
 456
 457                 MLX4_GET(field, outbox, QUERY_FUNC_CAP_NUM_PORTS_OFFSET);
 458                 func_cap->num_ports = field;
 459
 460                 MLX4_GET(size, outbox, QUERY_FUNC_CAP_PF_BHVR_OFFSET);
 461                 func_cap->pf_context_behaviour = size;
 462
 463                 if (quotas) {
 464                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP_QUOTA_OFFSET);
 465                         func_cap->qp_quota = size & 0xFFFFFF;
 466
 467                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET);
 468                         func_cap->srq_quota = size & 0xFFFFFF;
 469
 470                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_CQ_QUOTA_OFFSET);
 471                         func_cap->cq_quota = size & 0xFFFFFF;
 472
 473                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MPT_QUOTA_OFFSET);
 474                         func_cap->mpt_quota = size & 0xFFFFFF;
 475
 476                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MTT_QUOTA_OFFSET);
 477                         func_cap->mtt_quota = size & 0xFFFFFF;
 478
 479                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MCG_QUOTA_OFFSET);
 480                         func_cap->mcg_quota = size & 0xFFFFFF;
 481
 482                 } else {
 483                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP_QUOTA_OFFSET_DEP);
 484                         func_cap->qp_quota = size & 0xFFFFFF;
 485
 486                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_SRQ_QUOTA_OFFSET_DEP);
 487                         func_cap->srq_quota = size & 0xFFFFFF;
 488
 489                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_CQ_QUOTA_OFFSET_DEP);
 490                         func_cap->cq_quota = size & 0xFFFFFF;
 491
 492                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MPT_QUOTA_OFFSET_DEP);
 493                         func_cap->mpt_quota = size & 0xFFFFFF;
 494
 495                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MTT_QUOTA_OFFSET_DEP);
 496                         func_cap->mtt_quota = size & 0xFFFFFF;
 497
 498                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_MCG_QUOTA_OFFSET_DEP);
 499                         func_cap->mcg_quota = size & 0xFFFFFF;
 500                 }
 501                 MLX4_GET(size, outbox, QUERY_FUNC_CAP_MAX_EQ_OFFSET);
 502                 func_cap->max_eq = size & 0xFFFFFF;
 503
 504                 MLX4_GET(size, outbox, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
 505                 func_cap->reserved_eq = size & 0xFFFFFF;
 506
 507                 func_cap->extra_flags = 0;
 508
 509                 /* Mailbox data from 0x6c and onward should only be treated if
 510                  * QUERY_FUNC_CAP_FLAG_VALID_MAILBOX is set in func_cap->flags
 511                  */
 512                 if (func_cap->flags & QUERY_FUNC_CAP_FLAG_VALID_MAILBOX) {
 513                         MLX4_GET(size, outbox, QUERY_FUNC_CAP_EXTRA_FLAGS_OFFSET);
 514                         if (size & QUERY_FUNC_CAP_EXTRA_FLAGS_BF_QP_ALLOC_FLAG)
 515                                 func_cap->extra_flags |= MLX4_QUERY_FUNC_FLAGS_BF_RES_QP;
 516                         if (size & QUERY_FUNC_CAP_EXTRA_FLAGS_A0_QP_ALLOC_FLAG)
 517                                 func_cap->extra_flags |= MLX4_QUERY_FUNC_FLAGS_A0_RES_QP;
 518                 }
 519
 520                 goto out;
 521         }
 522
 523         /* logical port query */
 524         if (gen_or_port > dev->caps.num_ports) {
 525                 err = -EINVAL;
 526                 goto out;
 527         }
 528
 529         MLX4_GET(func_cap->flags1, outbox, QUERY_FUNC_CAP_FLAGS1_OFFSET);
 530         if (dev->caps.port_type[gen_or_port] == MLX4_PORT_TYPE_ETH) {
 531                 if (func_cap->flags1 & QUERY_FUNC_CAP_FLAGS1_FORCE_VLAN) {
 532                         mlx4_err(dev, "VLAN is enforced on this port\n");
 533                         err = -EPROTONOSUPPORT;
 534                         goto out;
 535                 }
 536
 537                 if (func_cap->flags1 & QUERY_FUNC_CAP_FLAGS1_FORCE_MAC) {
 538                         mlx4_err(dev, "Force mac is enabled on this port\n");
 539                         err = -EPROTONOSUPPORT;
 540                         goto out;
 541                 }
 542         } else if (dev->caps.port_type[gen_or_port] == MLX4_PORT_TYPE_IB) {
 543                 MLX4_GET(field, outbox, QUERY_FUNC_CAP_FLAGS0_OFFSET);
 544                 if (field & QUERY_FUNC_CAP_FLAGS0_FORCE_PHY_WQE_GID) {
 545                         mlx4_err(dev, "phy_wqe_gid is enforced on this ib port\n");
 546                         err = -EPROTONOSUPPORT;
 547                         goto out;
 548                 }
 549         }
 550
 551         MLX4_GET(field, outbox, QUERY_FUNC_CAP_PHYS_PORT_OFFSET);
 552         func_cap->physical_port = field;
 553         if (func_cap->physical_port != gen_or_port) {
 554                 err = -ENOSYS;
 555                 goto out;
 556         }
 557
 558         if (func_cap->flags1 & QUERY_FUNC_CAP_VF_ENABLE_QP0) {
 559                 MLX4_GET(qkey, outbox, QUERY_FUNC_CAP_PRIV_VF_QKEY_OFFSET);
 560                 func_cap->qp0_qkey = qkey;
 561         } else {
 562                 func_cap->qp0_qkey = 0;
 563         }
 564
 565         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP0_TUNNEL);
 566         func_cap->qp0_tunnel_qpn = size & 0xFFFFFF;
 567
 568         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP0_PROXY);
 569         func_cap->qp0_proxy_qpn = size & 0xFFFFFF;
 570
 571         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP1_TUNNEL);
 572         func_cap->qp1_tunnel_qpn = size & 0xFFFFFF;
 573
 574         MLX4_GET(size, outbox, QUERY_FUNC_CAP_QP1_PROXY);
 575         func_cap->qp1_proxy_qpn = size & 0xFFFFFF;
 576
 577         if (func_cap->flags1 & QUERY_FUNC_CAP_FLAGS1_NIC_INFO)
 578                 MLX4_GET(func_cap->phys_port_id, outbox,
 579                          QUERY_FUNC_CAP_PHYS_PORT_ID);
 580
 581         /* All other resources are allocated by the master, but we still report
 582          * 'num' and 'reserved' capabilities as follows:
 583          * - num remains the maximum resource index
 584          * - 'num - reserved' is the total available objects of a resource, but
 585          *   resource indices may be less than 'reserved'
 586          * TODO: set per-resource quotas */
 587
 588 out:
 589         mlx4_free_cmd_mailbox(dev, mailbox);
 590
 591         return err;
 592 }
 593
 594 int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
 595 {
 596         struct mlx4_cmd_mailbox *mailbox;
 597         u32 *outbox;
 598         u8 field;
 599         u32 field32, flags, ext_flags;
 600         u16 size;
 601         u16 stat_rate;
 602         int err;
 603         int i;
 604
 605 #define QUERY_DEV_CAP_OUT_SIZE                 0x100
 606 #define QUERY_DEV_CAP_MAX_SRQ_SZ_OFFSET         0x10
 607 #define QUERY_DEV_CAP_MAX_QP_SZ_OFFSET          0x11
 608 #define QUERY_DEV_CAP_RSVD_QP_OFFSET            0x12
 609 #define QUERY_DEV_CAP_MAX_QP_OFFSET             0x13
 610 #define QUERY_DEV_CAP_RSVD_SRQ_OFFSET           0x14
 611 #define QUERY_DEV_CAP_MAX_SRQ_OFFSET            0x15
 612 #define QUERY_DEV_CAP_RSVD_EEC_OFFSET           0x16
 613 #define QUERY_DEV_CAP_MAX_EEC_OFFSET            0x17
 614 #define QUERY_DEV_CAP_MAX_CQ_SZ_OFFSET          0x19
 615 #define QUERY_DEV_CAP_RSVD_CQ_OFFSET            0x1a
 616 #define QUERY_DEV_CAP_MAX_CQ_OFFSET             0x1b
 617 #define QUERY_DEV_CAP_MAX_MPT_OFFSET            0x1d
 618 #define QUERY_DEV_CAP_RSVD_EQ_OFFSET            0x1e
 619 #define QUERY_DEV_CAP_MAX_EQ_OFFSET             0x1f
 620 #define QUERY_DEV_CAP_RSVD_MTT_OFFSET           0x20
 621 #define QUERY_DEV_CAP_MAX_MRW_SZ_OFFSET         0x21
 622 #define QUERY_DEV_CAP_RSVD_MRW_OFFSET           0x22
 623 #define QUERY_DEV_CAP_MAX_MTT_SEG_OFFSET        0x23
 624 #define QUERY_DEV_CAP_NUM_SYS_EQ_OFFSET         0x26
 625 #define QUERY_DEV_CAP_MAX_AV_OFFSET             0x27
 626 #define QUERY_DEV_CAP_MAX_REQ_QP_OFFSET         0x29
 627 #define QUERY_DEV_CAP_MAX_RES_QP_OFFSET         0x2b
 628 #define QUERY_DEV_CAP_MAX_GSO_OFFSET            0x2d
 629 #define QUERY_DEV_CAP_RSS_OFFSET                0x2e
 630 #define QUERY_DEV_CAP_MAX_RDMA_OFFSET           0x2f
 631 #define QUERY_DEV_CAP_RSZ_SRQ_OFFSET            0x33
 632 #define QUERY_DEV_CAP_ACK_DELAY_OFFSET          0x35
 633 #define QUERY_DEV_CAP_MTU_WIDTH_OFFSET          0x36
 634 #define QUERY_DEV_CAP_VL_PORT_OFFSET            0x37
 635 #define QUERY_DEV_CAP_MAX_MSG_SZ_OFFSET         0x38
 636 #define QUERY_DEV_CAP_MAX_GID_OFFSET            0x3b
 637 #define QUERY_DEV_CAP_RATE_SUPPORT_OFFSET       0x3c
 638 #define QUERY_DEV_CAP_CQ_TS_SUPPORT_OFFSET      0x3e
 639 #define QUERY_DEV_CAP_MAX_PKEY_OFFSET           0x3f
 640 #define QUERY_DEV_CAP_EXT_FLAGS_OFFSET          0x40
 641 #define QUERY_DEV_CAP_FLAGS_OFFSET              0x44
 642 #define QUERY_DEV_CAP_RSVD_UAR_OFFSET           0x48
 643 #define QUERY_DEV_CAP_UAR_SZ_OFFSET             0x49
 644 #define QUERY_DEV_CAP_PAGE_SZ_OFFSET            0x4b
 645 #define QUERY_DEV_CAP_BF_OFFSET                 0x4c
 646 #define QUERY_DEV_CAP_LOG_BF_REG_SZ_OFFSET      0x4d
 647 #define QUERY_DEV_CAP_LOG_MAX_BF_REGS_PER_PAGE_OFFSET   0x4e
 648 #define QUERY_DEV_CAP_LOG_MAX_BF_PAGES_OFFSET   0x4f
 649 #define QUERY_DEV_CAP_MAX_SG_SQ_OFFSET          0x51
 650 #define QUERY_DEV_CAP_MAX_DESC_SZ_SQ_OFFSET     0x52
 651 #define QUERY_DEV_CAP_MAX_SG_RQ_OFFSET          0x55
 652 #define QUERY_DEV_CAP_MAX_DESC_SZ_RQ_OFFSET     0x56
 653 #define QUERY_DEV_CAP_MAX_QP_MCG_OFFSET         0x61
 654 #define QUERY_DEV_CAP_RSVD_MCG_OFFSET           0x62
 655 #define QUERY_DEV_CAP_MAX_MCG_OFFSET            0x63
 656 #define QUERY_DEV_CAP_RSVD_PD_OFFSET            0x64
 657 #define QUERY_DEV_CAP_MAX_PD_OFFSET             0x65
 658 #define QUERY_DEV_CAP_RSVD_XRC_OFFSET           0x66
 659 #define QUERY_DEV_CAP_MAX_XRC_OFFSET            0x67
 660 #define QUERY_DEV_CAP_MAX_COUNTERS_OFFSET       0x68
 661 #define QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET        0x70
 662 #define QUERY_DEV_CAP_FLOW_STEERING_IPOIB_OFFSET        0x74
 663 #define QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET     0x76
 664 #define QUERY_DEV_CAP_FLOW_STEERING_MAX_QP_OFFSET       0x77
 665 #define QUERY_DEV_CAP_CQ_EQ_CACHE_LINE_STRIDE   0x7a
 666 #define QUERY_DEV_CAP_ETH_PROT_CTRL_OFFSET      0x7a
 667 #define QUERY_DEV_CAP_RDMARC_ENTRY_SZ_OFFSET    0x80
 668 #define QUERY_DEV_CAP_QPC_ENTRY_SZ_OFFSET       0x82
 669 #define QUERY_DEV_CAP_AUX_ENTRY_SZ_OFFSET       0x84
 670 #define QUERY_DEV_CAP_ALTC_ENTRY_SZ_OFFSET      0x86
 671 #define QUERY_DEV_CAP_EQC_ENTRY_SZ_OFFSET       0x88
 672 #define QUERY_DEV_CAP_CQC_ENTRY_SZ_OFFSET       0x8a
 673 #define QUERY_DEV_CAP_SRQ_ENTRY_SZ_OFFSET       0x8c
 674 #define QUERY_DEV_CAP_C_MPT_ENTRY_SZ_OFFSET     0x8e
 675 #define QUERY_DEV_CAP_MTT_ENTRY_SZ_OFFSET       0x90
 676 #define QUERY_DEV_CAP_D_MPT_ENTRY_SZ_OFFSET     0x92
 677 #define QUERY_DEV_CAP_BMME_FLAGS_OFFSET         0x94
 678 #define QUERY_DEV_CAP_CONFIG_DEV_OFFSET         0x94
 679 #define QUERY_DEV_CAP_RSVD_LKEY_OFFSET          0x98
 680 #define QUERY_DEV_CAP_MAX_ICM_SZ_OFFSET         0xa0
 681 #define QUERY_DEV_CAP_ETH_BACKPL_OFFSET         0x9c
 682 #define QUERY_DEV_CAP_FW_REASSIGN_MAC           0x9d
 683 #define QUERY_DEV_CAP_VXLAN                     0x9e
 684 #define QUERY_DEV_CAP_MAD_DEMUX_OFFSET          0xb0
 685 #define QUERY_DEV_CAP_DMFS_HIGH_RATE_QPN_BASE_OFFSET    0xa8
 686 #define QUERY_DEV_CAP_DMFS_HIGH_RATE_QPN_RANGE_OFFSET   0xac
 687
 688         dev_cap->flags2 = 0;
 689         mailbox = mlx4_alloc_cmd_mailbox(dev);
 690         if (IS_ERR(mailbox))
 691                 return PTR_ERR(mailbox);
 692         outbox = mailbox->buf;
 693
 694         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0, MLX4_CMD_QUERY_DEV_CAP,
 695                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
 696         if (err)
 697                 goto out;
 698
 699         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_QP_OFFSET);
 700         dev_cap->reserved_qps = 1 << (field & 0xf);
 701         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_QP_OFFSET);
 702         dev_cap->max_qps = 1 << (field & 0x1f);
 703         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_SRQ_OFFSET);
 704         dev_cap->reserved_srqs = 1 << (field >> 4);
 705         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_SRQ_OFFSET);
 706         dev_cap->max_srqs = 1 << (field & 0x1f);
 707         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_CQ_SZ_OFFSET);
 708         dev_cap->max_cq_sz = 1 << field;
 709         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_CQ_OFFSET);
 710         dev_cap->reserved_cqs = 1 << (field & 0xf);
 711         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_CQ_OFFSET);
 712         dev_cap->max_cqs = 1 << (field & 0x1f);
 713         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MPT_OFFSET);
 714         dev_cap->max_mpts = 1 << (field & 0x3f);
 715         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_EQ_OFFSET);
 716         dev_cap->reserved_eqs = 1 << (field & 0xf);
 717         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_EQ_OFFSET);
 718         dev_cap->max_eqs = 1 << (field & 0xf);
 719         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_MTT_OFFSET);
 720         dev_cap->reserved_mtts = 1 << (field >> 4);
 721         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MRW_SZ_OFFSET);
 722         dev_cap->max_mrw_sz = 1 << field;
 723         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_MRW_OFFSET);
 724         dev_cap->reserved_mrws = 1 << (field & 0xf);
 725         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MTT_SEG_OFFSET);
 726         dev_cap->max_mtt_seg = 1 << (field & 0x3f);
 727         MLX4_GET(size, outbox, QUERY_DEV_CAP_NUM_SYS_EQ_OFFSET);
 728         dev_cap->num_sys_eqs = size & 0xfff;
 729         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_REQ_QP_OFFSET);
 730         dev_cap->max_requester_per_qp = 1 << (field & 0x3f);
 731         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_RES_QP_OFFSET);
 732         dev_cap->max_responder_per_qp = 1 << (field & 0x3f);
 733         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_GSO_OFFSET);
 734         field &= 0x1f;
 735         if (!field)
 736                 dev_cap->max_gso_sz = 0;
 737         else
 738                 dev_cap->max_gso_sz = 1 << field;
 739
 740         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSS_OFFSET);
 741         if (field & 0x20)
 742                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_RSS_XOR;
 743         if (field & 0x10)
 744                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_RSS_TOP;
 745         field &= 0xf;
 746         if (field) {
 747                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_RSS;
 748                 dev_cap->max_rss_tbl_sz = 1 << field;
 749         } else
 750                 dev_cap->max_rss_tbl_sz = 0;
 751         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_RDMA_OFFSET);
 752         dev_cap->max_rdma_global = 1 << (field & 0x3f);
 753         MLX4_GET(field, outbox, QUERY_DEV_CAP_ACK_DELAY_OFFSET);
 754         dev_cap->local_ca_ack_delay = field & 0x1f;
 755         MLX4_GET(field, outbox, QUERY_DEV_CAP_VL_PORT_OFFSET);
 756         dev_cap->num_ports = field & 0xf;
 757         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MSG_SZ_OFFSET);
 758         dev_cap->max_msg_sz = 1 << (field & 0x1f);
 759         MLX4_GET(field, outbox, QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET);
 760         if (field & 0x80)
 761                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_FS_EN;
 762         dev_cap->fs_log_max_ucast_qp_range_size = field & 0x1f;
 763         MLX4_GET(field, outbox, QUERY_DEV_CAP_FLOW_STEERING_IPOIB_OFFSET);
 764         if (field & 0x80)
 765                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_DMFS_IPOIB;
 766         MLX4_GET(field, outbox, QUERY_DEV_CAP_FLOW_STEERING_MAX_QP_OFFSET);
 767         dev_cap->fs_max_num_qp_per_entry = field;
 768         MLX4_GET(stat_rate, outbox, QUERY_DEV_CAP_RATE_SUPPORT_OFFSET);
 769         dev_cap->stat_rate_support = stat_rate;
 770         MLX4_GET(field, outbox, QUERY_DEV_CAP_CQ_TS_SUPPORT_OFFSET);
 771         if (field & 0x80)
 772                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_TS;
 773         MLX4_GET(ext_flags, outbox, QUERY_DEV_CAP_EXT_FLAGS_OFFSET);
 774         MLX4_GET(flags, outbox, QUERY_DEV_CAP_FLAGS_OFFSET);
 775         dev_cap->flags = flags | (u64)ext_flags << 32;
 776         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_UAR_OFFSET);
 777         dev_cap->reserved_uars = field >> 4;
 778         MLX4_GET(field, outbox, QUERY_DEV_CAP_UAR_SZ_OFFSET);
 779         dev_cap->uar_size = 1 << ((field & 0x3f) + 20);
 780         MLX4_GET(field, outbox, QUERY_DEV_CAP_PAGE_SZ_OFFSET);
 781         dev_cap->min_page_sz = 1 << field;
 782
 783         MLX4_GET(field, outbox, QUERY_DEV_CAP_BF_OFFSET);
 784         if (field & 0x80) {
 785                 MLX4_GET(field, outbox, QUERY_DEV_CAP_LOG_BF_REG_SZ_OFFSET);
 786                 dev_cap->bf_reg_size = 1 << (field & 0x1f);
 787                 MLX4_GET(field, outbox, QUERY_DEV_CAP_LOG_MAX_BF_REGS_PER_PAGE_OFFSET);
 788                 if ((1 << (field & 0x3f)) > (PAGE_SIZE / dev_cap->bf_reg_size))
 789                         field = 3;
 790                 dev_cap->bf_regs_per_page = 1 << (field & 0x3f);
 791         } else {
 792                 dev_cap->bf_reg_size = 0;
 793         }
 794
 795         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_SG_SQ_OFFSET);
 796         dev_cap->max_sq_sg = field;
 797         MLX4_GET(size, outbox, QUERY_DEV_CAP_MAX_DESC_SZ_SQ_OFFSET);
 798         dev_cap->max_sq_desc_sz = size;
 799
 800         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_QP_MCG_OFFSET);
 801         dev_cap->max_qp_per_mcg = 1 << field;
 802         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_MCG_OFFSET);
 803         dev_cap->reserved_mgms = field & 0xf;
 804         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MCG_OFFSET);
 805         dev_cap->max_mcgs = 1 << field;
 806         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_PD_OFFSET);
 807         dev_cap->reserved_pds = field >> 4;
 808         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_PD_OFFSET);
 809         dev_cap->max_pds = 1 << (field & 0x3f);
 810         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSVD_XRC_OFFSET);
 811         dev_cap->reserved_xrcds = field >> 4;
 812         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_XRC_OFFSET);
 813         dev_cap->max_xrcds = 1 << (field & 0x1f);
 814
 815         MLX4_GET(size, outbox, QUERY_DEV_CAP_RDMARC_ENTRY_SZ_OFFSET);
 816         dev_cap->rdmarc_entry_sz = size;
 817         MLX4_GET(size, outbox, QUERY_DEV_CAP_QPC_ENTRY_SZ_OFFSET);
 818         dev_cap->qpc_entry_sz = size;
 819         MLX4_GET(size, outbox, QUERY_DEV_CAP_AUX_ENTRY_SZ_OFFSET);
 820         dev_cap->aux_entry_sz = size;
 821         MLX4_GET(size, outbox, QUERY_DEV_CAP_ALTC_ENTRY_SZ_OFFSET);
 822         dev_cap->altc_entry_sz = size;
 823         MLX4_GET(size, outbox, QUERY_DEV_CAP_EQC_ENTRY_SZ_OFFSET);
 824         dev_cap->eqc_entry_sz = size;
 825         MLX4_GET(size, outbox, QUERY_DEV_CAP_CQC_ENTRY_SZ_OFFSET);
 826         dev_cap->cqc_entry_sz = size;
 827         MLX4_GET(size, outbox, QUERY_DEV_CAP_SRQ_ENTRY_SZ_OFFSET);
 828         dev_cap->srq_entry_sz = size;
 829         MLX4_GET(size, outbox, QUERY_DEV_CAP_C_MPT_ENTRY_SZ_OFFSET);
 830         dev_cap->cmpt_entry_sz = size;
 831         MLX4_GET(size, outbox, QUERY_DEV_CAP_MTT_ENTRY_SZ_OFFSET);
 832         dev_cap->mtt_entry_sz = size;
 833         MLX4_GET(size, outbox, QUERY_DEV_CAP_D_MPT_ENTRY_SZ_OFFSET);
 834         dev_cap->dmpt_entry_sz = size;
 835
 836         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_SRQ_SZ_OFFSET);
 837         dev_cap->max_srq_sz = 1 << field;
 838         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_QP_SZ_OFFSET);
 839         dev_cap->max_qp_sz = 1 << field;
 840         MLX4_GET(field, outbox, QUERY_DEV_CAP_RSZ_SRQ_OFFSET);
 841         dev_cap->resize_srq = field & 1;
 842         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_SG_RQ_OFFSET);
 843         dev_cap->max_rq_sg = field;
 844         MLX4_GET(size, outbox, QUERY_DEV_CAP_MAX_DESC_SZ_RQ_OFFSET);
 845         dev_cap->max_rq_desc_sz = size;
 846         MLX4_GET(field, outbox, QUERY_DEV_CAP_CQ_EQ_CACHE_LINE_STRIDE);
 847         if (field & (1 << 5))
 848                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL;
 849         if (field & (1 << 6))
 850                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_CQE_STRIDE;
 851         if (field & (1 << 7))
 852                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_EQE_STRIDE;
 853         MLX4_GET(dev_cap->bmme_flags, outbox,
 854                  QUERY_DEV_CAP_BMME_FLAGS_OFFSET);
 855         MLX4_GET(field, outbox, QUERY_DEV_CAP_CONFIG_DEV_OFFSET);
 856         if (field & 0x20)
 857                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_CONFIG_DEV;
 858         MLX4_GET(dev_cap->reserved_lkey, outbox,
 859                  QUERY_DEV_CAP_RSVD_LKEY_OFFSET);
 860         MLX4_GET(field32, outbox, QUERY_DEV_CAP_ETH_BACKPL_OFFSET);
 861         if (field32 & (1 << 0))
 862                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP;
 863         if (field32 & (1 << 7))
 864                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_RECOVERABLE_ERROR_EVENT;
 865         MLX4_GET(field, outbox, QUERY_DEV_CAP_FW_REASSIGN_MAC);
 866         if (field & 1<<6)
 867                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_REASSIGN_MAC_EN;
 868         MLX4_GET(field, outbox, QUERY_DEV_CAP_VXLAN);
 869         if (field & 1<<3)
 870                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_VXLAN_OFFLOADS;
 871         MLX4_GET(dev_cap->max_icm_sz, outbox,
 872                  QUERY_DEV_CAP_MAX_ICM_SZ_OFFSET);
 873         if (dev_cap->flags & MLX4_DEV_CAP_FLAG_COUNTERS)
 874                 MLX4_GET(dev_cap->max_counters, outbox,
 875                          QUERY_DEV_CAP_MAX_COUNTERS_OFFSET);
 876
 877         MLX4_GET(field32, outbox,
 878                  QUERY_DEV_CAP_MAD_DEMUX_OFFSET);
 879         if (field32 & (1 << 0))
 880                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_MAD_DEMUX;
 881
 882         MLX4_GET(dev_cap->dmfs_high_rate_qpn_base, outbox,
 883                  QUERY_DEV_CAP_DMFS_HIGH_RATE_QPN_BASE_OFFSET);
 884         dev_cap->dmfs_high_rate_qpn_base &= MGM_QPN_MASK;
 885         MLX4_GET(dev_cap->dmfs_high_rate_qpn_range, outbox,
 886                  QUERY_DEV_CAP_DMFS_HIGH_RATE_QPN_RANGE_OFFSET);
 887         dev_cap->dmfs_high_rate_qpn_range &= MGM_QPN_MASK;
 888
 889         MLX4_GET(field32, outbox, QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET);
 890         if (field32 & (1 << 16))
 891                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_UPDATE_QP;
 892         if (field32 & (1 << 26))
 893                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_VLAN_CONTROL;
 894         if (field32 & (1 << 20))
 895                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_FSM;
 896         if (field32 & (1 << 21))
 897                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_80_VFS;
 898
 899         for (i = 1; i <= dev_cap->num_ports; i++) {
 900                 err = mlx4_QUERY_PORT(dev, i, dev_cap->port_cap + i);
 901                 if (err)
 902                         goto out;
 903         }
 904
 905         /*
 906          * Each UAR has 4 EQ doorbells; so if a UAR is reserved, then
 907          * we can't use any EQs whose doorbell falls on that page,
 908          * even if the EQ itself isn't reserved.
 909          */
 910         if (dev_cap->num_sys_eqs == 0)
 911                 dev_cap->reserved_eqs = max(dev_cap->reserved_uars * 4,
 912                                             dev_cap->reserved_eqs);
 913         else
 914                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_SYS_EQS;
 915
 916 out:
 917         mlx4_free_cmd_mailbox(dev, mailbox);
 918         return err;
 919 }
 920
 921 void mlx4_dev_cap_dump(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
 922 {
 923         if (dev_cap->bf_reg_size > 0)
 924                 mlx4_dbg(dev, "BlueFlame available (reg size %d, regs/page %d)\n",
 925                          dev_cap->bf_reg_size, dev_cap->bf_regs_per_page);
 926         else
 927                 mlx4_dbg(dev, "BlueFlame not available\n");
 928
 929         mlx4_dbg(dev, "Base MM extensions: flags %08x, rsvd L_Key %08x\n",
 930                  dev_cap->bmme_flags, dev_cap->reserved_lkey);
 931         mlx4_dbg(dev, "Max ICM size %lld MB\n",
 932                  (unsigned long long) dev_cap->max_icm_sz >> 20);
 933         mlx4_dbg(dev, "Max QPs: %d, reserved QPs: %d, entry size: %d\n",
 934                  dev_cap->max_qps, dev_cap->reserved_qps, dev_cap->qpc_entry_sz);
 935         mlx4_dbg(dev, "Max SRQs: %d, reserved SRQs: %d, entry size: %d\n",
 936                  dev_cap->max_srqs, dev_cap->reserved_srqs, dev_cap->srq_entry_sz);
 937         mlx4_dbg(dev, "Max CQs: %d, reserved CQs: %d, entry size: %d\n",
 938                  dev_cap->max_cqs, dev_cap->reserved_cqs, dev_cap->cqc_entry_sz);
 939         mlx4_dbg(dev, "Num sys EQs: %d, max EQs: %d, reserved EQs: %d, entry size: %d\n",
 940                  dev_cap->num_sys_eqs, dev_cap->max_eqs, dev_cap->reserved_eqs,
 941                  dev_cap->eqc_entry_sz);
 942         mlx4_dbg(dev, "reserved MPTs: %d, reserved MTTs: %d\n",
 943                  dev_cap->reserved_mrws, dev_cap->reserved_mtts);
 944         mlx4_dbg(dev, "Max PDs: %d, reserved PDs: %d, reserved UARs: %d\n",
 945                  dev_cap->max_pds, dev_cap->reserved_pds, dev_cap->reserved_uars);
 946         mlx4_dbg(dev, "Max QP/MCG: %d, reserved MGMs: %d\n",
 947                  dev_cap->max_pds, dev_cap->reserved_mgms);
 948         mlx4_dbg(dev, "Max CQEs: %d, max WQEs: %d, max SRQ WQEs: %d\n",
 949                  dev_cap->max_cq_sz, dev_cap->max_qp_sz, dev_cap->max_srq_sz);
 950         mlx4_dbg(dev, "Local CA ACK delay: %d, max MTU: %d, port width cap: %d\n",
 951                  dev_cap->local_ca_ack_delay, 128 << dev_cap->port_cap[1].ib_mtu,
 952                  dev_cap->port_cap[1].max_port_width);
 953         mlx4_dbg(dev, "Max SQ desc size: %d, max SQ S/G: %d\n",
 954                  dev_cap->max_sq_desc_sz, dev_cap->max_sq_sg);
 955         mlx4_dbg(dev, "Max RQ desc size: %d, max RQ S/G: %d\n",
 956                  dev_cap->max_rq_desc_sz, dev_cap->max_rq_sg);
 957         mlx4_dbg(dev, "Max GSO size: %d\n", dev_cap->max_gso_sz);
 958         mlx4_dbg(dev, "Max counters: %d\n", dev_cap->max_counters);
 959         mlx4_dbg(dev, "Max RSS Table size: %d\n", dev_cap->max_rss_tbl_sz);
 960         mlx4_dbg(dev, "DMFS high rate steer QPn base: %d\n",
 961                  dev_cap->dmfs_high_rate_qpn_base);
 962         mlx4_dbg(dev, "DMFS high rate steer QPn range: %d\n",
 963                  dev_cap->dmfs_high_rate_qpn_range);
 964         dump_dev_cap_flags(dev, dev_cap->flags);
 965         dump_dev_cap_flags2(dev, dev_cap->flags2);
 966 }
 967
 968 int mlx4_QUERY_PORT(struct mlx4_dev *dev, int port, struct mlx4_port_cap *port_cap)
 969 {
 970         struct mlx4_cmd_mailbox *mailbox;
 971         u32 *outbox;
 972         u8 field;
 973         u32 field32;
 974         int err;
 975
 976         mailbox = mlx4_alloc_cmd_mailbox(dev);
 977         if (IS_ERR(mailbox))
 978                 return PTR_ERR(mailbox);
 979         outbox = mailbox->buf;
 980
 981         if (dev->flags & MLX4_FLAG_OLD_PORT_CMDS) {
 982                 err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0, MLX4_CMD_QUERY_DEV_CAP,
 983                                    MLX4_CMD_TIME_CLASS_A,
 984                                    MLX4_CMD_NATIVE);
 985
 986                 if (err)
 987                         goto out;
 988
 989                 MLX4_GET(field, outbox, QUERY_DEV_CAP_VL_PORT_OFFSET);
 990                 port_cap->max_vl           = field >> 4;
 991                 MLX4_GET(field, outbox, QUERY_DEV_CAP_MTU_WIDTH_OFFSET);
 992                 port_cap->ib_mtu           = field >> 4;
 993                 port_cap->max_port_width = field & 0xf;
 994                 MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_GID_OFFSET);
 995                 port_cap->max_gids         = 1 << (field & 0xf);
 996                 MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_PKEY_OFFSET);
 997                 port_cap->max_pkeys        = 1 << (field & 0xf);
 998         } else {
 999 #define QUERY_PORT_SUPPORTED_TYPE_OFFSET        0x00
1000 #define QUERY_PORT_MTU_OFFSET                   0x01
1001 #define QUERY_PORT_ETH_MTU_OFFSET               0x02
1002 #define QUERY_PORT_WIDTH_OFFSET                 0x06
1003 #define QUERY_PORT_MAX_GID_PKEY_OFFSET          0x07
1004 #define QUERY_PORT_MAX_MACVLAN_OFFSET           0x0a
1005 #define QUERY_PORT_MAX_VL_OFFSET                0x0b
1006 #define QUERY_PORT_MAC_OFFSET                   0x10
1007 #define QUERY_PORT_TRANS_VENDOR_OFFSET          0x18
1008 #define QUERY_PORT_WAVELENGTH_OFFSET            0x1c
1009 #define QUERY_PORT_TRANS_CODE_OFFSET            0x20
1010
1011                 err = mlx4_cmd_box(dev, 0, mailbox->dma, port, 0, MLX4_CMD_QUERY_PORT,
1012                                    MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
1013                 if (err)
1014                         goto out;
1015
1016                 MLX4_GET(field, outbox, QUERY_PORT_SUPPORTED_TYPE_OFFSET);
1017                 port_cap->supported_port_types = field & 3;
1018                 port_cap->suggested_type = (field >> 3) & 1;
1019                 port_cap->default_sense = (field >> 4) & 1;
1020                 port_cap->dmfs_optimized_state = (field >> 5) & 1;
1021                 MLX4_GET(field, outbox, QUERY_PORT_MTU_OFFSET);
1022                 port_cap->ib_mtu           = field & 0xf;
1023                 MLX4_GET(field, outbox, QUERY_PORT_WIDTH_OFFSET);
1024                 port_cap->max_port_width = field & 0xf;
1025                 MLX4_GET(field, outbox, QUERY_PORT_MAX_GID_PKEY_OFFSET);
1026                 port_cap->max_gids         = 1 << (field >> 4);
1027                 port_cap->max_pkeys        = 1 << (field & 0xf);
1028                 MLX4_GET(field, outbox, QUERY_PORT_MAX_VL_OFFSET);
1029                 port_cap->max_vl           = field & 0xf;
1030                 MLX4_GET(field, outbox, QUERY_PORT_MAX_MACVLAN_OFFSET);
1031                 port_cap->log_max_macs  = field & 0xf;
1032                 port_cap->log_max_vlans = field >> 4;
1033                 MLX4_GET(port_cap->eth_mtu, outbox, QUERY_PORT_ETH_MTU_OFFSET);
1034                 MLX4_GET(port_cap->def_mac, outbox, QUERY_PORT_MAC_OFFSET);
1035                 MLX4_GET(field32, outbox, QUERY_PORT_TRANS_VENDOR_OFFSET);
1036                 port_cap->trans_type = field32 >> 24;
1037                 port_cap->vendor_oui = field32 & 0xffffff;
1038                 MLX4_GET(port_cap->wavelength, outbox, QUERY_PORT_WAVELENGTH_OFFSET);
1039                 MLX4_GET(port_cap->trans_code, outbox, QUERY_PORT_TRANS_CODE_OFFSET);
1040         }
1041
1042 out:
1043         mlx4_free_cmd_mailbox(dev, mailbox);
1044         return err;
1045 }
1046
1047 #define DEV_CAP_EXT_2_FLAG_VLAN_CONTROL (1 << 26)
1048 #define DEV_CAP_EXT_2_FLAG_80_VFS       (1 << 21)
1049 #define DEV_CAP_EXT_2_FLAG_FSM          (1 << 20)
1050
1051 int mlx4_QUERY_DEV_CAP_wrapper(struct mlx4_dev *dev, int slave,
1052                                struct mlx4_vhcr *vhcr,
1053                                struct mlx4_cmd_mailbox *inbox,
1054                                struct mlx4_cmd_mailbox *outbox,
1055                                struct mlx4_cmd_info *cmd)
1056 {
1057         u64     flags;
1058         int     err = 0;
1059         u8      field;
1060         u32     bmme_flags, field32;
1061         int     real_port;
1062         int     slave_port;
1063         int     first_port;
1064         struct mlx4_active_ports actv_ports;
1065
1066         err = mlx4_cmd_box(dev, 0, outbox->dma, 0, 0, MLX4_CMD_QUERY_DEV_CAP,
1067                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1068         if (err)
1069                 return err;
1070
1071         /* add port mng change event capability and disable mw type 1
1072          * unconditionally to slaves
1073          */
1074         MLX4_GET(flags, outbox->buf, QUERY_DEV_CAP_EXT_FLAGS_OFFSET);
1075         flags |= MLX4_DEV_CAP_FLAG_PORT_MNG_CHG_EV;
1076         flags &= ~MLX4_DEV_CAP_FLAG_MEM_WINDOW;
1077         actv_ports = mlx4_get_active_ports(dev, slave);
1078         first_port = find_first_bit(actv_ports.ports, dev->caps.num_ports);
1079         for (slave_port = 0, real_port = first_port;
1080              real_port < first_port +
1081              bitmap_weight(actv_ports.ports, dev->caps.num_ports);
1082              ++real_port, ++slave_port) {
1083                 if (flags & (MLX4_DEV_CAP_FLAG_WOL_PORT1 << real_port))
1084                         flags |= MLX4_DEV_CAP_FLAG_WOL_PORT1 << slave_port;
1085                 else
1086                         flags &= ~(MLX4_DEV_CAP_FLAG_WOL_PORT1 << slave_port);
1087         }
1088         for (; slave_port < dev->caps.num_ports; ++slave_port)
1089                 flags &= ~(MLX4_DEV_CAP_FLAG_WOL_PORT1 << slave_port);
1090         MLX4_PUT(outbox->buf, flags, QUERY_DEV_CAP_EXT_FLAGS_OFFSET);
1091
1092         MLX4_GET(field, outbox->buf, QUERY_DEV_CAP_VL_PORT_OFFSET);
1093         field &= ~0x0F;
1094         field |= bitmap_weight(actv_ports.ports, dev->caps.num_ports) & 0x0F;
1095         MLX4_PUT(outbox->buf, field, QUERY_DEV_CAP_VL_PORT_OFFSET);
1096
1097         /* For guests, disable timestamp */
1098         MLX4_GET(field, outbox->buf, QUERY_DEV_CAP_CQ_TS_SUPPORT_OFFSET);
1099         field &= 0x7f;
1100         MLX4_PUT(outbox->buf, field, QUERY_DEV_CAP_CQ_TS_SUPPORT_OFFSET);
1101
1102         /* For guests, disable vxlan tunneling */
1103         MLX4_GET(field, outbox->buf, QUERY_DEV_CAP_VXLAN);
1104         field &= 0xf7;
1105         MLX4_PUT(outbox->buf, field, QUERY_DEV_CAP_VXLAN);
1106
1107         /* For guests, report Blueflame disabled */
1108         MLX4_GET(field, outbox->buf, QUERY_DEV_CAP_BF_OFFSET);
1109         field &= 0x7f;
1110         MLX4_PUT(outbox->buf, field, QUERY_DEV_CAP_BF_OFFSET);
1111
1112         /* For guests, disable mw type 2 */
1113         MLX4_GET(bmme_flags, outbox->buf, QUERY_DEV_CAP_BMME_FLAGS_OFFSET);
1114         bmme_flags &= ~MLX4_BMME_FLAG_TYPE_2_WIN;
1115         MLX4_PUT(outbox->buf, bmme_flags, QUERY_DEV_CAP_BMME_FLAGS_OFFSET);
1116
1117         /* turn off device-managed steering capability if not enabled */
1118         if (dev->caps.steering_mode != MLX4_STEERING_MODE_DEVICE_MANAGED) {
1119                 MLX4_GET(field, outbox->buf,
1120                          QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET);
1121                 field &= 0x7f;
1122                 MLX4_PUT(outbox->buf, field,
1123                          QUERY_DEV_CAP_FLOW_STEERING_RANGE_EN_OFFSET);
1124         }
1125
1126         /* turn off ipoib managed steering for guests */
1127         MLX4_GET(field, outbox->buf, QUERY_DEV_CAP_FLOW_STEERING_IPOIB_OFFSET);
1128         field &= ~0x80;
1129         MLX4_PUT(outbox->buf, field, QUERY_DEV_CAP_FLOW_STEERING_IPOIB_OFFSET);
1130
1131         /* turn off host side virt features (VST, FSM, etc) for guests */
1132         MLX4_GET(field32, outbox->buf, QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET);
1133         field32 &= ~(DEV_CAP_EXT_2_FLAG_VLAN_CONTROL | DEV_CAP_EXT_2_FLAG_80_VFS |
1134                      DEV_CAP_EXT_2_FLAG_FSM);
1135         MLX4_PUT(outbox->buf, field32, QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET);
1136
1137         return 0;
1138 }
1139
1140 int mlx4_QUERY_PORT_wrapper(struct mlx4_dev *dev, int slave,
1141                             struct mlx4_vhcr *vhcr,
1142                             struct mlx4_cmd_mailbox *inbox,
1143                             struct mlx4_cmd_mailbox *outbox,
1144                             struct mlx4_cmd_info *cmd)
1145 {
1146         struct mlx4_priv *priv = mlx4_priv(dev);
1147         u64 def_mac;
1148         u8 port_type;
1149         u16 short_field;
1150         int err;
1151         int admin_link_state;
1152         int port = mlx4_slave_convert_port(dev, slave,
1153                                            vhcr->in_modifier & 0xFF);
1154
1155 #define MLX4_VF_PORT_NO_LINK_SENSE_MASK 0xE0
1156 #define MLX4_PORT_LINK_UP_MASK          0x80
1157 #define QUERY_PORT_CUR_MAX_PKEY_OFFSET  0x0c
1158 #define QUERY_PORT_CUR_MAX_GID_OFFSET   0x0e
1159
1160         if (port < 0)
1161                 return -EINVAL;
1162
1163         /* Protect against untrusted guests: enforce that this is the
1164          * QUERY_PORT general query.
1165          */
1166         if (vhcr->op_modifier || vhcr->in_modifier & ~0xFF)
1167                 return -EINVAL;
1168
1169         vhcr->in_modifier = port;
1170
1171         err = mlx4_cmd_box(dev, 0, outbox->dma, vhcr->in_modifier, 0,
1172                            MLX4_CMD_QUERY_PORT, MLX4_CMD_TIME_CLASS_B,
1173                            MLX4_CMD_NATIVE);
1174
1175         if (!err && dev->caps.function != slave) {
1176                 def_mac = priv->mfunc.master.vf_oper[slave].vport[vhcr->in_modifier].state.mac;
1177                 MLX4_PUT(outbox->buf, def_mac, QUERY_PORT_MAC_OFFSET);
1178
1179                 /* get port type - currently only eth is enabled */
1180                 MLX4_GET(port_type, outbox->buf,
1181                          QUERY_PORT_SUPPORTED_TYPE_OFFSET);
1182
1183                 /* No link sensing allowed */
1184                 port_type &= MLX4_VF_PORT_NO_LINK_SENSE_MASK;
1185                 /* set port type to currently operating port type */
1186                 port_type |= (dev->caps.port_type[vhcr->in_modifier] & 0x3);
1187
1188                 admin_link_state = priv->mfunc.master.vf_oper[slave].vport[vhcr->in_modifier].state.link_state;
1189                 if (IFLA_VF_LINK_STATE_ENABLE == admin_link_state)
1190                         port_type |= MLX4_PORT_LINK_UP_MASK;
1191                 else if (IFLA_VF_LINK_STATE_DISABLE == admin_link_state)
1192                         port_type &= ~MLX4_PORT_LINK_UP_MASK;
1193
1194                 MLX4_PUT(outbox->buf, port_type,
1195                          QUERY_PORT_SUPPORTED_TYPE_OFFSET);
1196
1197                 if (dev->caps.port_type[vhcr->in_modifier] == MLX4_PORT_TYPE_ETH)
1198                         short_field = mlx4_get_slave_num_gids(dev, slave, port);
1199                 else
1200                         short_field = 1; /* slave max gids */
1201                 MLX4_PUT(outbox->buf, short_field,
1202                          QUERY_PORT_CUR_MAX_GID_OFFSET);
1203
1204                 short_field = dev->caps.pkey_table_len[vhcr->in_modifier];
1205                 MLX4_PUT(outbox->buf, short_field,
1206                          QUERY_PORT_CUR_MAX_PKEY_OFFSET);
1207         }
1208
1209         return err;
1210 }
1211
1212 int mlx4_get_slave_pkey_gid_tbl_len(struct mlx4_dev *dev, u8 port,
1213                                     int *gid_tbl_len, int *pkey_tbl_len)
1214 {
1215         struct mlx4_cmd_mailbox *mailbox;
1216         u32                     *outbox;
1217         u16                     field;
1218         int                     err;
1219
1220         mailbox = mlx4_alloc_cmd_mailbox(dev);
1221         if (IS_ERR(mailbox))
1222                 return PTR_ERR(mailbox);
1223
1224         err =  mlx4_cmd_box(dev, 0, mailbox->dma, port, 0,
1225                             MLX4_CMD_QUERY_PORT, MLX4_CMD_TIME_CLASS_B,
1226                             MLX4_CMD_WRAPPED);
1227         if (err)
1228                 goto out;
1229
1230         outbox = mailbox->buf;
1231
1232         MLX4_GET(field, outbox, QUERY_PORT_CUR_MAX_GID_OFFSET);
1233         *gid_tbl_len = field;
1234
1235         MLX4_GET(field, outbox, QUERY_PORT_CUR_MAX_PKEY_OFFSET);
1236         *pkey_tbl_len = field;
1237
1238 out:
1239         mlx4_free_cmd_mailbox(dev, mailbox);
1240         return err;
1241 }
1242 EXPORT_SYMBOL(mlx4_get_slave_pkey_gid_tbl_len);
1243
1244 int mlx4_map_cmd(struct mlx4_dev *dev, u16 op, struct mlx4_icm *icm, u64 virt)
1245 {
1246         struct mlx4_cmd_mailbox *mailbox;
1247         struct mlx4_icm_iter iter;
1248         __be64 *pages;
1249         int lg;
1250         int nent = 0;
1251         int i;
1252         int err = 0;
1253         int ts = 0, tc = 0;
1254
1255         mailbox = mlx4_alloc_cmd_mailbox(dev);
1256         if (IS_ERR(mailbox))
1257                 return PTR_ERR(mailbox);
1258         pages = mailbox->buf;
1259
1260         for (mlx4_icm_first(icm, &iter);
1261              !mlx4_icm_last(&iter);
1262              mlx4_icm_next(&iter)) {
1263                 /*
1264                  * We have to pass pages that are aligned to their
1265                  * size, so find the least significant 1 in the
1266                  * address or size and use that as our log2 size.
1267                  */
1268                 lg = ffs(mlx4_icm_addr(&iter) | mlx4_icm_size(&iter)) - 1;
1269                 if (lg < MLX4_ICM_PAGE_SHIFT) {
1270                         mlx4_warn(dev, "Got FW area not aligned to %d (%llx/%lx)\n",
1271                                   MLX4_ICM_PAGE_SIZE,
1272                                   (unsigned long long) mlx4_icm_addr(&iter),
1273                                   mlx4_icm_size(&iter));
1274                         err = -EINVAL;
1275                         goto out;
1276                 }
1277
1278                 for (i = 0; i < mlx4_icm_size(&iter) >> lg; ++i) {
1279                         if (virt != -1) {
1280                                 pages[nent * 2] = cpu_to_be64(virt);
1281                                 virt += 1 << lg;
1282                         }
1283
1284                         pages[nent * 2 + 1] =
1285                                 cpu_to_be64((mlx4_icm_addr(&iter) + (i << lg)) |
1286                                             (lg - MLX4_ICM_PAGE_SHIFT));
1287                         ts += 1 << (lg - 10);
1288                         ++tc;
1289
1290                         if (++nent == MLX4_MAILBOX_SIZE / 16) {
1291                                 err = mlx4_cmd(dev, mailbox->dma, nent, 0, op,
1292                                                 MLX4_CMD_TIME_CLASS_B,
1293                                                 MLX4_CMD_NATIVE);
1294                                 if (err)
1295                                         goto out;
1296                                 nent = 0;
1297                         }
1298                 }
1299         }
1300
1301         if (nent)
1302                 err = mlx4_cmd(dev, mailbox->dma, nent, 0, op,
1303                                MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
1304         if (err)
1305                 goto out;
1306
1307         switch (op) {
1308         case MLX4_CMD_MAP_FA:
1309                 mlx4_dbg(dev, "Mapped %d chunks/%d KB for FW\n", tc, ts);
1310                 break;
1311         case MLX4_CMD_MAP_ICM_AUX:
1312                 mlx4_dbg(dev, "Mapped %d chunks/%d KB for ICM aux\n", tc, ts);
1313                 break;
1314         case MLX4_CMD_MAP_ICM:
1315                 mlx4_dbg(dev, "Mapped %d chunks/%d KB at %llx for ICM\n",
1316                          tc, ts, (unsigned long long) virt - (ts << 10));
1317                 break;
1318         }
1319
1320 out:
1321         mlx4_free_cmd_mailbox(dev, mailbox);
1322         return err;
1323 }
1324
1325 int mlx4_MAP_FA(struct mlx4_dev *dev, struct mlx4_icm *icm)
1326 {
1327         return mlx4_map_cmd(dev, MLX4_CMD_MAP_FA, icm, -1);
1328 }
1329
1330 int mlx4_UNMAP_FA(struct mlx4_dev *dev)
1331 {
1332         return mlx4_cmd(dev, 0, 0, 0, MLX4_CMD_UNMAP_FA,
1333                         MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
1334 }
1335
1336
1337 int mlx4_RUN_FW(struct mlx4_dev *dev)
1338 {
1339         return mlx4_cmd(dev, 0, 0, 0, MLX4_CMD_RUN_FW,
1340                         MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1341 }
1342
1343 int mlx4_QUERY_FW(struct mlx4_dev *dev)
1344 {
1345         struct mlx4_fw  *fw  = &mlx4_priv(dev)->fw;
1346         struct mlx4_cmd *cmd = &mlx4_priv(dev)->cmd;
1347         struct mlx4_cmd_mailbox *mailbox;
1348         u32 *outbox;
1349         int err = 0;
1350         u64 fw_ver;
1351         u16 cmd_if_rev;
1352         u8 lg;
1353
1354 #define QUERY_FW_OUT_SIZE             0x100
1355 #define QUERY_FW_VER_OFFSET            0x00
1356 #define QUERY_FW_PPF_ID                0x09
1357 #define QUERY_FW_CMD_IF_REV_OFFSET     0x0a
1358 #define QUERY_FW_MAX_CMD_OFFSET        0x0f
1359 #define QUERY_FW_ERR_START_OFFSET      0x30
1360 #define QUERY_FW_ERR_SIZE_OFFSET       0x38
1361 #define QUERY_FW_ERR_BAR_OFFSET        0x3c
1362
1363 #define QUERY_FW_SIZE_OFFSET           0x00
1364 #define QUERY_FW_CLR_INT_BASE_OFFSET   0x20
1365 #define QUERY_FW_CLR_INT_BAR_OFFSET    0x28
1366
1367 #define QUERY_FW_COMM_BASE_OFFSET      0x40
1368 #define QUERY_FW_COMM_BAR_OFFSET       0x48
1369
1370 #define QUERY_FW_CLOCK_OFFSET          0x50
1371 #define QUERY_FW_CLOCK_BAR             0x58
1372
1373         mailbox = mlx4_alloc_cmd_mailbox(dev);
1374         if (IS_ERR(mailbox))
1375                 return PTR_ERR(mailbox);
1376         outbox = mailbox->buf;
1377
1378         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0, MLX4_CMD_QUERY_FW,
1379                             MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1380         if (err)
1381                 goto out;
1382
1383         MLX4_GET(fw_ver, outbox, QUERY_FW_VER_OFFSET);
1384         /*
1385          * FW subminor version is at more significant bits than minor
1386          * version, so swap here.
1387          */
1388         dev->caps.fw_ver = (fw_ver & 0xffff00000000ull) |
1389                 ((fw_ver & 0xffff0000ull) >> 16) |
1390                 ((fw_ver & 0x0000ffffull) << 16);
1391
1392         MLX4_GET(lg, outbox, QUERY_FW_PPF_ID);
1393         dev->caps.function = lg;
1394
1395         if (mlx4_is_slave(dev))
1396                 goto out;
1397
1398
1399         MLX4_GET(cmd_if_rev, outbox, QUERY_FW_CMD_IF_REV_OFFSET);
1400         if (cmd_if_rev < MLX4_COMMAND_INTERFACE_MIN_REV ||
1401             cmd_if_rev > MLX4_COMMAND_INTERFACE_MAX_REV) {
1402                 mlx4_err(dev, "Installed FW has unsupported command interface revision %d\n",
1403                          cmd_if_rev);
1404                 mlx4_err(dev, "(Installed FW version is %d.%d.%03d)\n",
1405                          (int) (dev->caps.fw_ver >> 32),
1406                          (int) (dev->caps.fw_ver >> 16) & 0xffff,
1407                          (int) dev->caps.fw_ver & 0xffff);
1408                 mlx4_err(dev, "This driver version supports only revisions %d to %d\n",
1409                          MLX4_COMMAND_INTERFACE_MIN_REV, MLX4_COMMAND_INTERFACE_MAX_REV);
1410                 err = -ENODEV;
1411                 goto out;
1412         }
1413
1414         if (cmd_if_rev < MLX4_COMMAND_INTERFACE_NEW_PORT_CMDS)
1415                 dev->flags |= MLX4_FLAG_OLD_PORT_CMDS;
1416
1417         MLX4_GET(lg, outbox, QUERY_FW_MAX_CMD_OFFSET);
1418         cmd->max_cmds = 1 << lg;
1419
1420         mlx4_dbg(dev, "FW version %d.%d.%03d (cmd intf rev %d), max commands %d\n",
1421                  (int) (dev->caps.fw_ver >> 32),
1422                  (int) (dev->caps.fw_ver >> 16) & 0xffff,
1423                  (int) dev->caps.fw_ver & 0xffff,
1424                  cmd_if_rev, cmd->max_cmds);
1425
1426         MLX4_GET(fw->catas_offset, outbox, QUERY_FW_ERR_START_OFFSET);
1427         MLX4_GET(fw->catas_size,   outbox, QUERY_FW_ERR_SIZE_OFFSET);
1428         MLX4_GET(fw->catas_bar,    outbox, QUERY_FW_ERR_BAR_OFFSET);
1429         fw->catas_bar = (fw->catas_bar >> 6) * 2;
1430
1431         mlx4_dbg(dev, "Catastrophic error buffer at 0x%llx, size 0x%x, BAR %d\n",
1432                  (unsigned long long) fw->catas_offset, fw->catas_size, fw->catas_bar);
1433
1434         MLX4_GET(fw->fw_pages,     outbox, QUERY_FW_SIZE_OFFSET);
1435         MLX4_GET(fw->clr_int_base, outbox, QUERY_FW_CLR_INT_BASE_OFFSET);
1436         MLX4_GET(fw->clr_int_bar,  outbox, QUERY_FW_CLR_INT_BAR_OFFSET);
1437         fw->clr_int_bar = (fw->clr_int_bar >> 6) * 2;
1438
1439         MLX4_GET(fw->comm_base, outbox, QUERY_FW_COMM_BASE_OFFSET);
1440         MLX4_GET(fw->comm_bar,  outbox, QUERY_FW_COMM_BAR_OFFSET);
1441         fw->comm_bar = (fw->comm_bar >> 6) * 2;
1442         mlx4_dbg(dev, "Communication vector bar:%d offset:0x%llx\n",
1443                  fw->comm_bar, fw->comm_base);
1444         mlx4_dbg(dev, "FW size %d KB\n", fw->fw_pages >> 2);
1445
1446         MLX4_GET(fw->clock_offset, outbox, QUERY_FW_CLOCK_OFFSET);
1447         MLX4_GET(fw->clock_bar,    outbox, QUERY_FW_CLOCK_BAR);
1448         fw->clock_bar = (fw->clock_bar >> 6) * 2;
1449         mlx4_dbg(dev, "Internal clock bar:%d offset:0x%llx\n",
1450                  fw->clock_bar, fw->clock_offset);
1451
1452         /*
1453          * Round up number of system pages needed in case
1454          * MLX4_ICM_PAGE_SIZE < PAGE_SIZE.
1455          */
1456         fw->fw_pages =
1457                 ALIGN(fw->fw_pages, PAGE_SIZE / MLX4_ICM_PAGE_SIZE) >>
1458                 (PAGE_SHIFT - MLX4_ICM_PAGE_SHIFT);
1459
1460         mlx4_dbg(dev, "Clear int @ %llx, BAR %d\n",
1461                  (unsigned long long) fw->clr_int_base, fw->clr_int_bar);
1462
1463 out:
1464         mlx4_free_cmd_mailbox(dev, mailbox);
1465         return err;
1466 }
1467
1468 int mlx4_QUERY_FW_wrapper(struct mlx4_dev *dev, int slave,
1469                           struct mlx4_vhcr *vhcr,
1470                           struct mlx4_cmd_mailbox *inbox,
1471                           struct mlx4_cmd_mailbox *outbox,
1472                           struct mlx4_cmd_info *cmd)
1473 {
1474         u8 *outbuf;
1475         int err;
1476
1477         outbuf = outbox->buf;
1478         err = mlx4_cmd_box(dev, 0, outbox->dma, 0, 0, MLX4_CMD_QUERY_FW,
1479                             MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1480         if (err)
1481                 return err;
1482
1483         /* for slaves, set pci PPF ID to invalid and zero out everything
1484          * else except FW version */
1485         outbuf[0] = outbuf[1] = 0;
1486         memset(&outbuf[8], 0, QUERY_FW_OUT_SIZE - 8);
1487         outbuf[QUERY_FW_PPF_ID] = MLX4_INVALID_SLAVE_ID;
1488
1489         return 0;
1490 }
1491
1492 static void get_board_id(void *vsd, char *board_id)
1493 {
1494         int i;
1495
1496 #define VSD_OFFSET_SIG1         0x00
1497 #define VSD_OFFSET_SIG2         0xde
1498 #define VSD_OFFSET_MLX_BOARD_ID 0xd0
1499 #define VSD_OFFSET_TS_BOARD_ID  0x20
1500
1501 #define VSD_SIGNATURE_TOPSPIN   0x5ad
1502
1503         memset(board_id, 0, MLX4_BOARD_ID_LEN);
1504
1505         if (be16_to_cpup(vsd + VSD_OFFSET_SIG1) == VSD_SIGNATURE_TOPSPIN &&
1506             be16_to_cpup(vsd + VSD_OFFSET_SIG2) == VSD_SIGNATURE_TOPSPIN) {
1507                 strlcpy(board_id, vsd + VSD_OFFSET_TS_BOARD_ID, MLX4_BOARD_ID_LEN);
1508         } else {
1509                 /*
1510                  * The board ID is a string but the firmware byte
1511                  * swaps each 4-byte word before passing it back to
1512                  * us.  Therefore we need to swab it before printing.
1513                  */
1514                 for (i = 0; i < 4; ++i)
1515                         ((u32 *) board_id)[i] =
1516                                 swab32(*(u32 *) (vsd + VSD_OFFSET_MLX_BOARD_ID + i * 4));
1517         }
1518 }
1519
1520 int mlx4_QUERY_ADAPTER(struct mlx4_dev *dev, struct mlx4_adapter *adapter)
1521 {
1522         struct mlx4_cmd_mailbox *mailbox;
1523         u32 *outbox;
1524         int err;
1525
1526 #define QUERY_ADAPTER_OUT_SIZE             0x100
1527 #define QUERY_ADAPTER_INTA_PIN_OFFSET      0x10
1528 #define QUERY_ADAPTER_VSD_OFFSET           0x20
1529
1530         mailbox = mlx4_alloc_cmd_mailbox(dev);
1531         if (IS_ERR(mailbox))
1532                 return PTR_ERR(mailbox);
1533         outbox = mailbox->buf;
1534
1535         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0, MLX4_CMD_QUERY_ADAPTER,
1536                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1537         if (err)
1538                 goto out;
1539
1540         MLX4_GET(adapter->inta_pin, outbox,    QUERY_ADAPTER_INTA_PIN_OFFSET);
1541
1542         get_board_id(outbox + QUERY_ADAPTER_VSD_OFFSET / 4,
1543                      adapter->board_id);
1544
1545 out:
1546         mlx4_free_cmd_mailbox(dev, mailbox);
1547         return err;
1548 }
1549
1550 int mlx4_INIT_HCA(struct mlx4_dev *dev, struct mlx4_init_hca_param *param)
1551 {
1552         struct mlx4_cmd_mailbox *mailbox;
1553         __be32 *inbox;
1554         int err;
1555         static const u8 a0_dmfs_hw_steering[] =  {
1556                 [MLX4_STEERING_DMFS_A0_DEFAULT]         = 0,
1557                 [MLX4_STEERING_DMFS_A0_DYNAMIC]         = 1,
1558                 [MLX4_STEERING_DMFS_A0_STATIC]          = 2,
1559                 [MLX4_STEERING_DMFS_A0_DISABLE]         = 3
1560         };
1561
1562 #define INIT_HCA_IN_SIZE                 0x200
1563 #define INIT_HCA_VERSION_OFFSET          0x000
1564 #define  INIT_HCA_VERSION                2
1565 #define INIT_HCA_VXLAN_OFFSET            0x0c
1566 #define INIT_HCA_CACHELINE_SZ_OFFSET     0x0e
1567 #define INIT_HCA_FLAGS_OFFSET            0x014
1568 #define INIT_HCA_RECOVERABLE_ERROR_EVENT_OFFSET 0x018
1569 #define INIT_HCA_QPC_OFFSET              0x020
1570 #define  INIT_HCA_QPC_BASE_OFFSET        (INIT_HCA_QPC_OFFSET + 0x10)
1571 #define  INIT_HCA_LOG_QP_OFFSET          (INIT_HCA_QPC_OFFSET + 0x17)
1572 #define  INIT_HCA_SRQC_BASE_OFFSET       (INIT_HCA_QPC_OFFSET + 0x28)
1573 #define  INIT_HCA_LOG_SRQ_OFFSET         (INIT_HCA_QPC_OFFSET + 0x2f)
1574 #define  INIT_HCA_CQC_BASE_OFFSET        (INIT_HCA_QPC_OFFSET + 0x30)
1575 #define  INIT_HCA_LOG_CQ_OFFSET          (INIT_HCA_QPC_OFFSET + 0x37)
1576 #define  INIT_HCA_EQE_CQE_OFFSETS        (INIT_HCA_QPC_OFFSET + 0x38)
1577 #define  INIT_HCA_EQE_CQE_STRIDE_OFFSET  (INIT_HCA_QPC_OFFSET + 0x3b)
1578 #define  INIT_HCA_ALTC_BASE_OFFSET       (INIT_HCA_QPC_OFFSET + 0x40)
1579 #define  INIT_HCA_AUXC_BASE_OFFSET       (INIT_HCA_QPC_OFFSET + 0x50)
1580 #define  INIT_HCA_EQC_BASE_OFFSET        (INIT_HCA_QPC_OFFSET + 0x60)
1581 #define  INIT_HCA_LOG_EQ_OFFSET          (INIT_HCA_QPC_OFFSET + 0x67)
1582 #define INIT_HCA_NUM_SYS_EQS_OFFSET     (INIT_HCA_QPC_OFFSET + 0x6a)
1583 #define  INIT_HCA_RDMARC_BASE_OFFSET     (INIT_HCA_QPC_OFFSET + 0x70)
1584 #define  INIT_HCA_LOG_RD_OFFSET          (INIT_HCA_QPC_OFFSET + 0x77)
1585 #define INIT_HCA_MCAST_OFFSET            0x0c0
1586 #define  INIT_HCA_MC_BASE_OFFSET         (INIT_HCA_MCAST_OFFSET + 0x00)
1587 #define  INIT_HCA_LOG_MC_ENTRY_SZ_OFFSET (INIT_HCA_MCAST_OFFSET + 0x12)
1588 #define  INIT_HCA_LOG_MC_HASH_SZ_OFFSET  (INIT_HCA_MCAST_OFFSET + 0x16)
1589 #define  INIT_HCA_UC_STEERING_OFFSET     (INIT_HCA_MCAST_OFFSET + 0x18)
1590 #define  INIT_HCA_LOG_MC_TABLE_SZ_OFFSET (INIT_HCA_MCAST_OFFSET + 0x1b)
1591 #define  INIT_HCA_DEVICE_MANAGED_FLOW_STEERING_EN       0x6
1592 #define  INIT_HCA_FS_PARAM_OFFSET         0x1d0
1593 #define  INIT_HCA_FS_BASE_OFFSET          (INIT_HCA_FS_PARAM_OFFSET + 0x00)
1594 #define  INIT_HCA_FS_LOG_ENTRY_SZ_OFFSET  (INIT_HCA_FS_PARAM_OFFSET + 0x12)
1595 #define  INIT_HCA_FS_A0_OFFSET            (INIT_HCA_FS_PARAM_OFFSET + 0x18)
1596 #define  INIT_HCA_FS_LOG_TABLE_SZ_OFFSET  (INIT_HCA_FS_PARAM_OFFSET + 0x1b)
1597 #define  INIT_HCA_FS_ETH_BITS_OFFSET      (INIT_HCA_FS_PARAM_OFFSET + 0x21)
1598 #define  INIT_HCA_FS_ETH_NUM_ADDRS_OFFSET (INIT_HCA_FS_PARAM_OFFSET + 0x22)
1599 #define  INIT_HCA_FS_IB_BITS_OFFSET       (INIT_HCA_FS_PARAM_OFFSET + 0x25)
1600 #define  INIT_HCA_FS_IB_NUM_ADDRS_OFFSET  (INIT_HCA_FS_PARAM_OFFSET + 0x26)
1601 #define INIT_HCA_TPT_OFFSET              0x0f0
1602 #define  INIT_HCA_DMPT_BASE_OFFSET       (INIT_HCA_TPT_OFFSET + 0x00)
1603 #define  INIT_HCA_TPT_MW_OFFSET          (INIT_HCA_TPT_OFFSET + 0x08)
1604 #define  INIT_HCA_LOG_MPT_SZ_OFFSET      (INIT_HCA_TPT_OFFSET + 0x0b)
1605 #define  INIT_HCA_MTT_BASE_OFFSET        (INIT_HCA_TPT_OFFSET + 0x10)
1606 #define  INIT_HCA_CMPT_BASE_OFFSET       (INIT_HCA_TPT_OFFSET + 0x18)
1607 #define INIT_HCA_UAR_OFFSET              0x120
1608 #define  INIT_HCA_LOG_UAR_SZ_OFFSET      (INIT_HCA_UAR_OFFSET + 0x0a)
1609 #define  INIT_HCA_UAR_PAGE_SZ_OFFSET     (INIT_HCA_UAR_OFFSET + 0x0b)
1610
1611         mailbox = mlx4_alloc_cmd_mailbox(dev);
1612         if (IS_ERR(mailbox))
1613                 return PTR_ERR(mailbox);
1614         inbox = mailbox->buf;
1615
1616         *((u8 *) mailbox->buf + INIT_HCA_VERSION_OFFSET) = INIT_HCA_VERSION;
1617
1618         *((u8 *) mailbox->buf + INIT_HCA_CACHELINE_SZ_OFFSET) =
1619                 (ilog2(cache_line_size()) - 4) << 5;
1620
1621 #if defined(__LITTLE_ENDIAN)
1622         *(inbox + INIT_HCA_FLAGS_OFFSET / 4) &= ~cpu_to_be32(1 << 1);
1623 #elif defined(__BIG_ENDIAN)
1624         *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1 << 1);
1625 #else
1626 #error Host endianness not defined
1627 #endif
1628         /* Check port for UD address vector: */
1629         *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1);
1630
1631         /* Enable IPoIB checksumming if we can: */
1632         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_IPOIB_CSUM)
1633                 *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1 << 3);
1634
1635         /* Enable QoS support if module parameter set */
1636         if (enable_qos)
1637                 *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1 << 2);
1638
1639         /* enable counters */
1640         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_COUNTERS)
1641                 *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |= cpu_to_be32(1 << 4);
1642
1643         /* CX3 is capable of extending CQEs/EQEs from 32 to 64 bytes */
1644         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_64B_EQE) {
1645                 *(inbox + INIT_HCA_EQE_CQE_OFFSETS / 4) |= cpu_to_be32(1 << 29);
1646                 dev->caps.eqe_size   = 64;
1647                 dev->caps.eqe_factor = 1;
1648         } else {
1649                 dev->caps.eqe_size   = 32;
1650                 dev->caps.eqe_factor = 0;
1651         }
1652
1653         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_64B_CQE) {
1654                 *(inbox + INIT_HCA_EQE_CQE_OFFSETS / 4) |= cpu_to_be32(1 << 30);
1655                 dev->caps.cqe_size   = 64;
1656                 dev->caps.userspace_caps |= MLX4_USER_DEV_CAP_LARGE_CQE;
1657         } else {
1658                 dev->caps.cqe_size   = 32;
1659         }
1660
1661         /* CX3 is capable of extending CQEs\EQEs to strides larger than 64B */
1662         if ((dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_EQE_STRIDE) &&
1663             (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_CQE_STRIDE)) {
1664                 dev->caps.eqe_size = cache_line_size();
1665                 dev->caps.cqe_size = cache_line_size();
1666                 dev->caps.eqe_factor = 0;
1667                 MLX4_PUT(inbox, (u8)((ilog2(dev->caps.eqe_size) - 5) << 4 |
1668                                       (ilog2(dev->caps.eqe_size) - 5)),
1669                          INIT_HCA_EQE_CQE_STRIDE_OFFSET);
1670
1671                 /* User still need to know to support CQE > 32B */
1672                 dev->caps.userspace_caps |= MLX4_USER_DEV_CAP_LARGE_CQE;
1673         }
1674
1675         if (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_RECOVERABLE_ERROR_EVENT)
1676                 *(inbox + INIT_HCA_RECOVERABLE_ERROR_EVENT_OFFSET / 4) |= cpu_to_be32(1 << 31);
1677
1678         /* QPC/EEC/CQC/EQC/RDMARC attributes */
1679
1680         MLX4_PUT(inbox, param->qpc_base,      INIT_HCA_QPC_BASE_OFFSET);
1681         MLX4_PUT(inbox, param->log_num_qps,   INIT_HCA_LOG_QP_OFFSET);
1682         MLX4_PUT(inbox, param->srqc_base,     INIT_HCA_SRQC_BASE_OFFSET);
1683         MLX4_PUT(inbox, param->log_num_srqs,  INIT_HCA_LOG_SRQ_OFFSET);
1684         MLX4_PUT(inbox, param->cqc_base,      INIT_HCA_CQC_BASE_OFFSET);
1685         MLX4_PUT(inbox, param->log_num_cqs,   INIT_HCA_LOG_CQ_OFFSET);
1686         MLX4_PUT(inbox, param->altc_base,     INIT_HCA_ALTC_BASE_OFFSET);
1687         MLX4_PUT(inbox, param->auxc_base,     INIT_HCA_AUXC_BASE_OFFSET);
1688         MLX4_PUT(inbox, param->eqc_base,      INIT_HCA_EQC_BASE_OFFSET);
1689         MLX4_PUT(inbox, param->log_num_eqs,   INIT_HCA_LOG_EQ_OFFSET);
1690         MLX4_PUT(inbox, param->num_sys_eqs,   INIT_HCA_NUM_SYS_EQS_OFFSET);
1691         MLX4_PUT(inbox, param->rdmarc_base,   INIT_HCA_RDMARC_BASE_OFFSET);
1692         MLX4_PUT(inbox, param->log_rd_per_qp, INIT_HCA_LOG_RD_OFFSET);
1693
1694         /* steering attributes */
1695         if (dev->caps.steering_mode ==
1696             MLX4_STEERING_MODE_DEVICE_MANAGED) {
1697                 *(inbox + INIT_HCA_FLAGS_OFFSET / 4) |=
1698                         cpu_to_be32(1 <<
1699                                     INIT_HCA_DEVICE_MANAGED_FLOW_STEERING_EN);
1700
1701                 MLX4_PUT(inbox, param->mc_base, INIT_HCA_FS_BASE_OFFSET);
1702                 MLX4_PUT(inbox, param->log_mc_entry_sz,
1703                          INIT_HCA_FS_LOG_ENTRY_SZ_OFFSET);
1704                 MLX4_PUT(inbox, param->log_mc_table_sz,
1705                          INIT_HCA_FS_LOG_TABLE_SZ_OFFSET);
1706                 /* Enable Ethernet flow steering
1707                  * with udp unicast and tcp unicast
1708                  */
1709                 if (dev->caps.dmfs_high_steer_mode !=
1710                     MLX4_STEERING_DMFS_A0_STATIC)
1711                         MLX4_PUT(inbox,
1712                                  (u8)(MLX4_FS_UDP_UC_EN | MLX4_FS_TCP_UC_EN),
1713                                  INIT_HCA_FS_ETH_BITS_OFFSET);
1714                 MLX4_PUT(inbox, (u16) MLX4_FS_NUM_OF_L2_ADDR,
1715                          INIT_HCA_FS_ETH_NUM_ADDRS_OFFSET);
1716                 /* Enable IPoIB flow steering
1717                  * with udp unicast and tcp unicast
1718                  */
1719                 MLX4_PUT(inbox, (u8) (MLX4_FS_UDP_UC_EN | MLX4_FS_TCP_UC_EN),
1720                          INIT_HCA_FS_IB_BITS_OFFSET);
1721                 MLX4_PUT(inbox, (u16) MLX4_FS_NUM_OF_L2_ADDR,
1722                          INIT_HCA_FS_IB_NUM_ADDRS_OFFSET);
1723
1724                 if (dev->caps.dmfs_high_steer_mode !=
1725                     MLX4_STEERING_DMFS_A0_NOT_SUPPORTED)
1726                         MLX4_PUT(inbox,
1727                                  ((u8)(a0_dmfs_hw_steering[dev->caps.dmfs_high_steer_mode]
1728                                        << 6)),
1729                                  INIT_HCA_FS_A0_OFFSET);
1730         } else {
1731                 MLX4_PUT(inbox, param->mc_base, INIT_HCA_MC_BASE_OFFSET);
1732                 MLX4_PUT(inbox, param->log_mc_entry_sz,
1733                          INIT_HCA_LOG_MC_ENTRY_SZ_OFFSET);
1734                 MLX4_PUT(inbox, param->log_mc_hash_sz,
1735                          INIT_HCA_LOG_MC_HASH_SZ_OFFSET);
1736                 MLX4_PUT(inbox, param->log_mc_table_sz,
1737                          INIT_HCA_LOG_MC_TABLE_SZ_OFFSET);
1738                 if (dev->caps.steering_mode == MLX4_STEERING_MODE_B0)
1739                         MLX4_PUT(inbox, (u8) (1 << 3),
1740                                  INIT_HCA_UC_STEERING_OFFSET);
1741         }
1742
1743         /* TPT attributes */
1744
1745         MLX4_PUT(inbox, param->dmpt_base,  INIT_HCA_DMPT_BASE_OFFSET);
1746         MLX4_PUT(inbox, param->mw_enabled, INIT_HCA_TPT_MW_OFFSET);
1747         MLX4_PUT(inbox, param->log_mpt_sz, INIT_HCA_LOG_MPT_SZ_OFFSET);
1748         MLX4_PUT(inbox, param->mtt_base,   INIT_HCA_MTT_BASE_OFFSET);
1749         MLX4_PUT(inbox, param->cmpt_base,  INIT_HCA_CMPT_BASE_OFFSET);
1750
1751         /* UAR attributes */
1752
1753         MLX4_PUT(inbox, param->uar_page_sz,     INIT_HCA_UAR_PAGE_SZ_OFFSET);
1754         MLX4_PUT(inbox, param->log_uar_sz,      INIT_HCA_LOG_UAR_SZ_OFFSET);
1755
1756         /* set parser VXLAN attributes */
1757         if (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_VXLAN_OFFLOADS) {
1758                 u8 parser_params = 0;
1759                 MLX4_PUT(inbox, parser_params,  INIT_HCA_VXLAN_OFFSET);
1760         }
1761
1762         err = mlx4_cmd(dev, mailbox->dma, 0, 0, MLX4_CMD_INIT_HCA, 10000,
1763                        MLX4_CMD_NATIVE);
1764
1765         if (err)
1766                 mlx4_err(dev, "INIT_HCA returns %d\n", err);
1767
1768         mlx4_free_cmd_mailbox(dev, mailbox);
1769         return err;
1770 }
1771
1772 int mlx4_QUERY_HCA(struct mlx4_dev *dev,
1773                    struct mlx4_init_hca_param *param)
1774 {
1775         struct mlx4_cmd_mailbox *mailbox;
1776         __be32 *outbox;
1777         u32 dword_field;
1778         int err;
1779         u8 byte_field;
1780         static const u8 a0_dmfs_query_hw_steering[] =  {
1781                 [0] = MLX4_STEERING_DMFS_A0_DEFAULT,
1782                 [1] = MLX4_STEERING_DMFS_A0_DYNAMIC,
1783                 [2] = MLX4_STEERING_DMFS_A0_STATIC,
1784                 [3] = MLX4_STEERING_DMFS_A0_DISABLE
1785         };
1786
1787 #define QUERY_HCA_GLOBAL_CAPS_OFFSET    0x04
1788 #define QUERY_HCA_CORE_CLOCK_OFFSET     0x0c
1789
1790         mailbox = mlx4_alloc_cmd_mailbox(dev);
1791         if (IS_ERR(mailbox))
1792                 return PTR_ERR(mailbox);
1793         outbox = mailbox->buf;
1794
1795         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0,
1796                            MLX4_CMD_QUERY_HCA,
1797                            MLX4_CMD_TIME_CLASS_B,
1798                            !mlx4_is_slave(dev));
1799         if (err)
1800                 goto out;
1801
1802         MLX4_GET(param->global_caps, outbox, QUERY_HCA_GLOBAL_CAPS_OFFSET);
1803         MLX4_GET(param->hca_core_clock, outbox, QUERY_HCA_CORE_CLOCK_OFFSET);
1804
1805         /* QPC/EEC/CQC/EQC/RDMARC attributes */
1806
1807         MLX4_GET(param->qpc_base,      outbox, INIT_HCA_QPC_BASE_OFFSET);
1808         MLX4_GET(param->log_num_qps,   outbox, INIT_HCA_LOG_QP_OFFSET);
1809         MLX4_GET(param->srqc_base,     outbox, INIT_HCA_SRQC_BASE_OFFSET);
1810         MLX4_GET(param->log_num_srqs,  outbox, INIT_HCA_LOG_SRQ_OFFSET);
1811         MLX4_GET(param->cqc_base,      outbox, INIT_HCA_CQC_BASE_OFFSET);
1812         MLX4_GET(param->log_num_cqs,   outbox, INIT_HCA_LOG_CQ_OFFSET);
1813         MLX4_GET(param->altc_base,     outbox, INIT_HCA_ALTC_BASE_OFFSET);
1814         MLX4_GET(param->auxc_base,     outbox, INIT_HCA_AUXC_BASE_OFFSET);
1815         MLX4_GET(param->eqc_base,      outbox, INIT_HCA_EQC_BASE_OFFSET);
1816         MLX4_GET(param->log_num_eqs,   outbox, INIT_HCA_LOG_EQ_OFFSET);
1817         MLX4_GET(param->num_sys_eqs,   outbox, INIT_HCA_NUM_SYS_EQS_OFFSET);
1818         MLX4_GET(param->rdmarc_base,   outbox, INIT_HCA_RDMARC_BASE_OFFSET);
1819         MLX4_GET(param->log_rd_per_qp, outbox, INIT_HCA_LOG_RD_OFFSET);
1820
1821         MLX4_GET(dword_field, outbox, INIT_HCA_FLAGS_OFFSET);
1822         if (dword_field & (1 << INIT_HCA_DEVICE_MANAGED_FLOW_STEERING_EN)) {
1823                 param->steering_mode = MLX4_STEERING_MODE_DEVICE_MANAGED;
1824         } else {
1825                 MLX4_GET(byte_field, outbox, INIT_HCA_UC_STEERING_OFFSET);
1826                 if (byte_field & 0x8)
1827                         param->steering_mode = MLX4_STEERING_MODE_B0;
1828                 else
1829                         param->steering_mode = MLX4_STEERING_MODE_A0;
1830         }
1831         /* steering attributes */
1832         if (param->steering_mode == MLX4_STEERING_MODE_DEVICE_MANAGED) {
1833                 MLX4_GET(param->mc_base, outbox, INIT_HCA_FS_BASE_OFFSET);
1834                 MLX4_GET(param->log_mc_entry_sz, outbox,
1835                          INIT_HCA_FS_LOG_ENTRY_SZ_OFFSET);
1836                 MLX4_GET(param->log_mc_table_sz, outbox,
1837                          INIT_HCA_FS_LOG_TABLE_SZ_OFFSET);
1838                 MLX4_GET(byte_field, outbox,
1839                          INIT_HCA_FS_A0_OFFSET);
1840                 param->dmfs_high_steer_mode =
1841                         a0_dmfs_query_hw_steering[(byte_field >> 6) & 3];
1842         } else {
1843                 MLX4_GET(param->mc_base, outbox, INIT_HCA_MC_BASE_OFFSET);
1844                 MLX4_GET(param->log_mc_entry_sz, outbox,
1845                          INIT_HCA_LOG_MC_ENTRY_SZ_OFFSET);
1846                 MLX4_GET(param->log_mc_hash_sz,  outbox,
1847                          INIT_HCA_LOG_MC_HASH_SZ_OFFSET);
1848                 MLX4_GET(param->log_mc_table_sz, outbox,
1849                          INIT_HCA_LOG_MC_TABLE_SZ_OFFSET);
1850         }
1851
1852         /* CX3 is capable of extending CQEs/EQEs from 32 to 64 bytes */
1853         MLX4_GET(byte_field, outbox, INIT_HCA_EQE_CQE_OFFSETS);
1854         if (byte_field & 0x20) /* 64-bytes eqe enabled */
1855                 param->dev_cap_enabled |= MLX4_DEV_CAP_64B_EQE_ENABLED;
1856         if (byte_field & 0x40) /* 64-bytes cqe enabled */
1857                 param->dev_cap_enabled |= MLX4_DEV_CAP_64B_CQE_ENABLED;
1858
1859         /* CX3 is capable of extending CQEs\EQEs to strides larger than 64B */
1860         MLX4_GET(byte_field, outbox, INIT_HCA_EQE_CQE_STRIDE_OFFSET);
1861         if (byte_field) {
1862                 param->dev_cap_enabled |= MLX4_DEV_CAP_EQE_STRIDE_ENABLED;
1863                 param->dev_cap_enabled |= MLX4_DEV_CAP_CQE_STRIDE_ENABLED;
1864                 param->cqe_size = 1 << ((byte_field &
1865                                          MLX4_CQE_SIZE_MASK_STRIDE) + 5);
1866                 param->eqe_size = 1 << (((byte_field &
1867                                           MLX4_EQE_SIZE_MASK_STRIDE) >> 4) + 5);
1868         }
1869
1870         /* TPT attributes */
1871
1872         MLX4_GET(param->dmpt_base,  outbox, INIT_HCA_DMPT_BASE_OFFSET);
1873         MLX4_GET(param->mw_enabled, outbox, INIT_HCA_TPT_MW_OFFSET);
1874         MLX4_GET(param->log_mpt_sz, outbox, INIT_HCA_LOG_MPT_SZ_OFFSET);
1875         MLX4_GET(param->mtt_base,   outbox, INIT_HCA_MTT_BASE_OFFSET);
1876         MLX4_GET(param->cmpt_base,  outbox, INIT_HCA_CMPT_BASE_OFFSET);
1877
1878         /* UAR attributes */
1879
1880         MLX4_GET(param->uar_page_sz, outbox, INIT_HCA_UAR_PAGE_SZ_OFFSET);
1881         MLX4_GET(param->log_uar_sz, outbox, INIT_HCA_LOG_UAR_SZ_OFFSET);
1882
1883 out:
1884         mlx4_free_cmd_mailbox(dev, mailbox);
1885
1886         return err;
1887 }
1888
1889 /* for IB-type ports only in SRIOV mode. Checks that both proxy QP0
1890  * and real QP0 are active, so that the paravirtualized QP0 is ready
1891  * to operate */
1892 static int check_qp0_state(struct mlx4_dev *dev, int function, int port)
1893 {
1894         struct mlx4_priv *priv = mlx4_priv(dev);
1895         /* irrelevant if not infiniband */
1896         if (priv->mfunc.master.qp0_state[port].proxy_qp0_active &&
1897             priv->mfunc.master.qp0_state[port].qp0_active)
1898                 return 1;
1899         return 0;
1900 }
1901
1902 int mlx4_INIT_PORT_wrapper(struct mlx4_dev *dev, int slave,
1903                            struct mlx4_vhcr *vhcr,
1904                            struct mlx4_cmd_mailbox *inbox,
1905                            struct mlx4_cmd_mailbox *outbox,
1906                            struct mlx4_cmd_info *cmd)
1907 {
1908         struct mlx4_priv *priv = mlx4_priv(dev);
1909         int port = mlx4_slave_convert_port(dev, slave, vhcr->in_modifier);
1910         int err;
1911
1912         if (port < 0)
1913                 return -EINVAL;
1914
1915         if (priv->mfunc.master.slave_state[slave].init_port_mask & (1 << port))
1916                 return 0;
1917
1918         if (dev->caps.port_mask[port] != MLX4_PORT_TYPE_IB) {
1919                 /* Enable port only if it was previously disabled */
1920                 if (!priv->mfunc.master.init_port_ref[port]) {
1921                         err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_INIT_PORT,
1922                                        MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1923                         if (err)
1924                                 return err;
1925                 }
1926                 priv->mfunc.master.slave_state[slave].init_port_mask |= (1 << port);
1927         } else {
1928                 if (slave == mlx4_master_func_num(dev)) {
1929                         if (check_qp0_state(dev, slave, port) &&
1930                             !priv->mfunc.master.qp0_state[port].port_active) {
1931                                 err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_INIT_PORT,
1932                                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1933                                 if (err)
1934                                         return err;
1935                                 priv->mfunc.master.qp0_state[port].port_active = 1;
1936                                 priv->mfunc.master.slave_state[slave].init_port_mask |= (1 << port);
1937                         }
1938                 } else
1939                         priv->mfunc.master.slave_state[slave].init_port_mask |= (1 << port);
1940         }
1941         ++priv->mfunc.master.init_port_ref[port];
1942         return 0;
1943 }
1944
1945 int mlx4_INIT_PORT(struct mlx4_dev *dev, int port)
1946 {
1947         struct mlx4_cmd_mailbox *mailbox;
1948         u32 *inbox;
1949         int err;
1950         u32 flags;
1951         u16 field;
1952
1953         if (dev->flags & MLX4_FLAG_OLD_PORT_CMDS) {
1954 #define INIT_PORT_IN_SIZE          256
1955 #define INIT_PORT_FLAGS_OFFSET     0x00
1956 #define INIT_PORT_FLAG_SIG         (1 << 18)
1957 #define INIT_PORT_FLAG_NG          (1 << 17)
1958 #define INIT_PORT_FLAG_G0          (1 << 16)
1959 #define INIT_PORT_VL_SHIFT         4
1960 #define INIT_PORT_PORT_WIDTH_SHIFT 8
1961 #define INIT_PORT_MTU_OFFSET       0x04
1962 #define INIT_PORT_MAX_GID_OFFSET   0x06
1963 #define INIT_PORT_MAX_PKEY_OFFSET  0x0a
1964 #define INIT_PORT_GUID0_OFFSET     0x10
1965 #define INIT_PORT_NODE_GUID_OFFSET 0x18
1966 #define INIT_PORT_SI_GUID_OFFSET   0x20
1967
1968                 mailbox = mlx4_alloc_cmd_mailbox(dev);
1969                 if (IS_ERR(mailbox))
1970                         return PTR_ERR(mailbox);
1971                 inbox = mailbox->buf;
1972
1973                 flags = 0;
1974                 flags |= (dev->caps.vl_cap[port] & 0xf) << INIT_PORT_VL_SHIFT;
1975                 flags |= (dev->caps.port_width_cap[port] & 0xf) << INIT_PORT_PORT_WIDTH_SHIFT;
1976                 MLX4_PUT(inbox, flags,            INIT_PORT_FLAGS_OFFSET);
1977
1978                 field = 128 << dev->caps.ib_mtu_cap[port];
1979                 MLX4_PUT(inbox, field, INIT_PORT_MTU_OFFSET);
1980                 field = dev->caps.gid_table_len[port];
1981                 MLX4_PUT(inbox, field, INIT_PORT_MAX_GID_OFFSET);
1982                 field = dev->caps.pkey_table_len[port];
1983                 MLX4_PUT(inbox, field, INIT_PORT_MAX_PKEY_OFFSET);
1984
1985                 err = mlx4_cmd(dev, mailbox->dma, port, 0, MLX4_CMD_INIT_PORT,
1986                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
1987
1988                 mlx4_free_cmd_mailbox(dev, mailbox);
1989         } else
1990                 err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_INIT_PORT,
1991                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
1992
1993         return err;
1994 }
1995 EXPORT_SYMBOL_GPL(mlx4_INIT_PORT);
1996
1997 int mlx4_CLOSE_PORT_wrapper(struct mlx4_dev *dev, int slave,
1998                             struct mlx4_vhcr *vhcr,
1999                             struct mlx4_cmd_mailbox *inbox,
2000                             struct mlx4_cmd_mailbox *outbox,
2001                             struct mlx4_cmd_info *cmd)
2002 {
2003         struct mlx4_priv *priv = mlx4_priv(dev);
2004         int port = mlx4_slave_convert_port(dev, slave, vhcr->in_modifier);
2005         int err;
2006
2007         if (port < 0)
2008                 return -EINVAL;
2009
2010         if (!(priv->mfunc.master.slave_state[slave].init_port_mask &
2011             (1 << port)))
2012                 return 0;
2013
2014         if (dev->caps.port_mask[port] != MLX4_PORT_TYPE_IB) {
2015                 if (priv->mfunc.master.init_port_ref[port] == 1) {
2016                         err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT,
2017                                        1000, MLX4_CMD_NATIVE);
2018                         if (err)
2019                                 return err;
2020                 }
2021                 priv->mfunc.master.slave_state[slave].init_port_mask &= ~(1 << port);
2022         } else {
2023                 /* infiniband port */
2024                 if (slave == mlx4_master_func_num(dev)) {
2025                         if (!priv->mfunc.master.qp0_state[port].qp0_active &&
2026                             priv->mfunc.master.qp0_state[port].port_active) {
2027                                 err = mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT,
2028                                                1000, MLX4_CMD_NATIVE);
2029                                 if (err)
2030                                         return err;
2031                                 priv->mfunc.master.slave_state[slave].init_port_mask &= ~(1 << port);
2032                                 priv->mfunc.master.qp0_state[port].port_active = 0;
2033                         }
2034                 } else
2035                         priv->mfunc.master.slave_state[slave].init_port_mask &= ~(1 << port);
2036         }
2037         --priv->mfunc.master.init_port_ref[port];
2038         return 0;
2039 }
2040
2041 int mlx4_CLOSE_PORT(struct mlx4_dev *dev, int port)
2042 {
2043         return mlx4_cmd(dev, 0, port, 0, MLX4_CMD_CLOSE_PORT, 1000,
2044                         MLX4_CMD_WRAPPED);
2045 }
2046 EXPORT_SYMBOL_GPL(mlx4_CLOSE_PORT);
2047
2048 int mlx4_CLOSE_HCA(struct mlx4_dev *dev, int panic)
2049 {
2050         return mlx4_cmd(dev, 0, 0, panic, MLX4_CMD_CLOSE_HCA, 1000,
2051                         MLX4_CMD_NATIVE);
2052 }
2053
2054 struct mlx4_config_dev {
2055         __be32  update_flags;
2056         __be32  rsvd1[3];
2057         __be16  vxlan_udp_dport;
2058         __be16  rsvd2;
2059         __be32  rsvd3[27];
2060         __be16  rsvd4;
2061         u8      rsvd5;
2062         u8      rx_checksum_val;
2063 };
2064
2065 #define MLX4_VXLAN_UDP_DPORT (1 << 0)
2066
2067 static int mlx4_CONFIG_DEV_set(struct mlx4_dev *dev, struct mlx4_config_dev *config_dev)
2068 {
2069         int err;
2070         struct mlx4_cmd_mailbox *mailbox;
2071
2072         mailbox = mlx4_alloc_cmd_mailbox(dev);
2073         if (IS_ERR(mailbox))
2074                 return PTR_ERR(mailbox);
2075
2076         memcpy(mailbox->buf, config_dev, sizeof(*config_dev));
2077
2078         err = mlx4_cmd(dev, mailbox->dma, 0, 0, MLX4_CMD_CONFIG_DEV,
2079                        MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
2080
2081         mlx4_free_cmd_mailbox(dev, mailbox);
2082         return err;
2083 }
2084
2085 static int mlx4_CONFIG_DEV_get(struct mlx4_dev *dev, struct mlx4_config_dev *config_dev)
2086 {
2087         int err;
2088         struct mlx4_cmd_mailbox *mailbox;
2089
2090         mailbox = mlx4_alloc_cmd_mailbox(dev);
2091         if (IS_ERR(mailbox))
2092                 return PTR_ERR(mailbox);
2093
2094         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 1, MLX4_CMD_CONFIG_DEV,
2095                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
2096
2097         if (!err)
2098                 memcpy(config_dev, mailbox->buf, sizeof(*config_dev));
2099
2100         mlx4_free_cmd_mailbox(dev, mailbox);
2101         return err;
2102 }
2103
2104 /* Conversion between the HW values and the actual functionality.
2105  * The value represented by the array index,
2106  * and the functionality determined by the flags.
2107  */
2108 static const u8 config_dev_csum_flags[] = {
2109         [0] =   0,
2110         [1] =   MLX4_RX_CSUM_MODE_VAL_NON_TCP_UDP,
2111         [2] =   MLX4_RX_CSUM_MODE_VAL_NON_TCP_UDP       |
2112                 MLX4_RX_CSUM_MODE_L4,
2113         [3] =   MLX4_RX_CSUM_MODE_L4                    |
2114                 MLX4_RX_CSUM_MODE_IP_OK_IP_NON_TCP_UDP  |
2115                 MLX4_RX_CSUM_MODE_MULTI_VLAN
2116 };
2117
2118 int mlx4_config_dev_retrieval(struct mlx4_dev *dev,
2119                               struct mlx4_config_dev_params *params)
2120 {
2121         struct mlx4_config_dev config_dev;
2122         int err;
2123         u8 csum_mask;
2124
2125 #define CONFIG_DEV_RX_CSUM_MODE_MASK                    0x7
2126 #define CONFIG_DEV_RX_CSUM_MODE_PORT1_BIT_OFFSET        0
2127 #define CONFIG_DEV_RX_CSUM_MODE_PORT2_BIT_OFFSET        4
2128
2129         if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_CONFIG_DEV))
2130                 return -ENOTSUPP;
2131
2132         err = mlx4_CONFIG_DEV_get(dev, &config_dev);
2133         if (err)
2134                 return err;
2135
2136         csum_mask = (config_dev.rx_checksum_val >> CONFIG_DEV_RX_CSUM_MODE_PORT1_BIT_OFFSET) &
2137                         CONFIG_DEV_RX_CSUM_MODE_MASK;
2138
2139         if (csum_mask >= sizeof(config_dev_csum_flags)/sizeof(config_dev_csum_flags[0]))
2140                 return -EINVAL;
2141         params->rx_csum_flags_port_1 = config_dev_csum_flags[csum_mask];
2142
2143         csum_mask = (config_dev.rx_checksum_val >> CONFIG_DEV_RX_CSUM_MODE_PORT2_BIT_OFFSET) &
2144                         CONFIG_DEV_RX_CSUM_MODE_MASK;
2145
2146         if (csum_mask >= sizeof(config_dev_csum_flags)/sizeof(config_dev_csum_flags[0]))
2147                 return -EINVAL;
2148         params->rx_csum_flags_port_2 = config_dev_csum_flags[csum_mask];
2149
2150         params->vxlan_udp_dport = be16_to_cpu(config_dev.vxlan_udp_dport);
2151
2152         return 0;
2153 }
2154 EXPORT_SYMBOL_GPL(mlx4_config_dev_retrieval);
2155
2156 int mlx4_config_vxlan_port(struct mlx4_dev *dev, __be16 udp_port)
2157 {
2158         struct mlx4_config_dev config_dev;
2159
2160         memset(&config_dev, 0, sizeof(config_dev));
2161         config_dev.update_flags    = cpu_to_be32(MLX4_VXLAN_UDP_DPORT);
2162         config_dev.vxlan_udp_dport = udp_port;
2163
2164         return mlx4_CONFIG_DEV_set(dev, &config_dev);
2165 }
2166 EXPORT_SYMBOL_GPL(mlx4_config_vxlan_port);
2167
2168
2169 int mlx4_SET_ICM_SIZE(struct mlx4_dev *dev, u64 icm_size, u64 *aux_pages)
2170 {
2171         int ret = mlx4_cmd_imm(dev, icm_size, aux_pages, 0, 0,
2172                                MLX4_CMD_SET_ICM_SIZE,
2173                                MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
2174         if (ret)
2175                 return ret;
2176
2177         /*
2178          * Round up number of system pages needed in case
2179          * MLX4_ICM_PAGE_SIZE < PAGE_SIZE.
2180          */
2181         *aux_pages = ALIGN(*aux_pages, PAGE_SIZE / MLX4_ICM_PAGE_SIZE) >>
2182                 (PAGE_SHIFT - MLX4_ICM_PAGE_SHIFT);
2183
2184         return 0;
2185 }
2186
2187 int mlx4_NOP(struct mlx4_dev *dev)
2188 {
2189         /* Input modifier of 0x1f means "finish as soon as possible." */
2190         return mlx4_cmd(dev, 0, 0x1f, 0, MLX4_CMD_NOP, 100, MLX4_CMD_NATIVE);
2191 }
2192
2193 int mlx4_get_phys_port_id(struct mlx4_dev *dev)
2194 {
2195         u8 port;
2196         u32 *outbox;
2197         struct mlx4_cmd_mailbox *mailbox;
2198         u32 in_mod;
2199         u32 guid_hi, guid_lo;
2200         int err, ret = 0;
2201 #define MOD_STAT_CFG_PORT_OFFSET 8
2202 #define MOD_STAT_CFG_GUID_H      0X14
2203 #define MOD_STAT_CFG_GUID_L      0X1c
2204
2205         mailbox = mlx4_alloc_cmd_mailbox(dev);
2206         if (IS_ERR(mailbox))
2207                 return PTR_ERR(mailbox);
2208         outbox = mailbox->buf;
2209
2210         for (port = 1; port <= dev->caps.num_ports; port++) {
2211                 in_mod = port << MOD_STAT_CFG_PORT_OFFSET;
2212                 err = mlx4_cmd_box(dev, 0, mailbox->dma, in_mod, 0x2,
2213                                    MLX4_CMD_MOD_STAT_CFG, MLX4_CMD_TIME_CLASS_A,
2214                                    MLX4_CMD_NATIVE);
2215                 if (err) {
2216                         mlx4_err(dev, "Fail to get port %d uplink guid\n",
2217                                  port);
2218                         ret = err;
2219                 } else {
2220                         MLX4_GET(guid_hi, outbox, MOD_STAT_CFG_GUID_H);
2221                         MLX4_GET(guid_lo, outbox, MOD_STAT_CFG_GUID_L);
2222                         dev->caps.phys_port_id[port] = (u64)guid_lo |
2223                                                        (u64)guid_hi << 32;
2224                 }
2225         }
2226         mlx4_free_cmd_mailbox(dev, mailbox);
2227         return ret;
2228 }
2229
2230 #define MLX4_WOL_SETUP_MODE (5 << 28)
2231 int mlx4_wol_read(struct mlx4_dev *dev, u64 *config, int port)
2232 {
2233         u32 in_mod = MLX4_WOL_SETUP_MODE | port << 8;
2234
2235         return mlx4_cmd_imm(dev, 0, config, in_mod, 0x3,
2236                             MLX4_CMD_MOD_STAT_CFG, MLX4_CMD_TIME_CLASS_A,
2237                             MLX4_CMD_NATIVE);
2238 }
2239 EXPORT_SYMBOL_GPL(mlx4_wol_read);
2240
2241 int mlx4_wol_write(struct mlx4_dev *dev, u64 config, int port)
2242 {
2243         u32 in_mod = MLX4_WOL_SETUP_MODE | port << 8;
2244
2245         return mlx4_cmd(dev, config, in_mod, 0x1, MLX4_CMD_MOD_STAT_CFG,
2246                         MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
2247 }
2248 EXPORT_SYMBOL_GPL(mlx4_wol_write);
2249
2250 enum {
2251         ADD_TO_MCG = 0x26,
2252 };
2253
2254
2255 void mlx4_opreq_action(struct work_struct *work)
2256 {
2257         struct mlx4_priv *priv = container_of(work, struct mlx4_priv,
2258                                               opreq_task);
2259         struct mlx4_dev *dev = &priv->dev;
2260         int num_tasks = atomic_read(&priv->opreq_count);
2261         struct mlx4_cmd_mailbox *mailbox;
2262         struct mlx4_mgm *mgm;
2263         u32 *outbox;
2264         u32 modifier;
2265         u16 token;
2266         u16 type;
2267         int err;
2268         u32 num_qps;
2269         struct mlx4_qp qp;
2270         int i;
2271         u8 rem_mcg;
2272         u8 prot;
2273
2274 #define GET_OP_REQ_MODIFIER_OFFSET      0x08
2275 #define GET_OP_REQ_TOKEN_OFFSET         0x14
2276 #define GET_OP_REQ_TYPE_OFFSET          0x1a
2277 #define GET_OP_REQ_DATA_OFFSET          0x20
2278
2279         mailbox = mlx4_alloc_cmd_mailbox(dev);
2280         if (IS_ERR(mailbox)) {
2281                 mlx4_err(dev, "Failed to allocate mailbox for GET_OP_REQ\n");
2282                 return;
2283         }
2284         outbox = mailbox->buf;
2285
2286         while (num_tasks) {
2287                 err = mlx4_cmd_box(dev, 0, mailbox->dma, 0, 0,
2288                                    MLX4_CMD_GET_OP_REQ, MLX4_CMD_TIME_CLASS_A,
2289                                    MLX4_CMD_NATIVE);
2290                 if (err) {
2291                         mlx4_err(dev, "Failed to retrieve required operation: %d\n",
2292                                  err);
2293                         return;
2294                 }
2295                 MLX4_GET(modifier, outbox, GET_OP_REQ_MODIFIER_OFFSET);
2296                 MLX4_GET(token, outbox, GET_OP_REQ_TOKEN_OFFSET);
2297                 MLX4_GET(type, outbox, GET_OP_REQ_TYPE_OFFSET);
2298                 type &= 0xfff;
2299
2300                 switch (type) {
2301                 case ADD_TO_MCG:
2302                         if (dev->caps.steering_mode ==
2303                             MLX4_STEERING_MODE_DEVICE_MANAGED) {
2304                                 mlx4_warn(dev, "ADD MCG operation is not supported in DEVICE_MANAGED steering mode\n");
2305                                 err = EPERM;
2306                                 break;
2307                         }
2308                         mgm = (struct mlx4_mgm *)((u8 *)(outbox) +
2309                                                   GET_OP_REQ_DATA_OFFSET);
2310                         num_qps = be32_to_cpu(mgm->members_count) &
2311                                   MGM_QPN_MASK;
2312                         rem_mcg = ((u8 *)(&mgm->members_count))[0] & 1;
2313                         prot = ((u8 *)(&mgm->members_count))[0] >> 6;
2314
2315                         for (i = 0; i < num_qps; i++) {
2316                                 qp.qpn = be32_to_cpu(mgm->qp[i]);
2317                                 if (rem_mcg)
2318                                         err = mlx4_multicast_detach(dev, &qp,
2319                                                                     mgm->gid,
2320                                                                     prot, 0);
2321                                 else
2322                                         err = mlx4_multicast_attach(dev, &qp,
2323                                                                     mgm->gid,
2324                                                                     mgm->gid[5]
2325                                                                     , 0, prot,
2326                                                                     NULL);
2327                                 if (err)
2328                                         break;
2329                         }
2330                         break;
2331                 default:
2332                         mlx4_warn(dev, "Bad type for required operation\n");
2333                         err = EINVAL;
2334                         break;
2335                 }
2336                 err = mlx4_cmd(dev, 0, ((u32) err |
2337                                         (__force u32)cpu_to_be32(token) << 16),
2338                                1, MLX4_CMD_GET_OP_REQ, MLX4_CMD_TIME_CLASS_A,
2339                                MLX4_CMD_NATIVE);
2340                 if (err) {
2341                         mlx4_err(dev, "Failed to acknowledge required request: %d\n",
2342                                  err);
2343                         goto out;
2344                 }
2345                 memset(outbox, 0, 0xffc);
2346                 num_tasks = atomic_dec_return(&priv->opreq_count);
2347         }
2348
2349 out:
2350         mlx4_free_cmd_mailbox(dev, mailbox);
2351 }
2352
2353 static int mlx4_check_smp_firewall_active(struct mlx4_dev *dev,
2354                                           struct mlx4_cmd_mailbox *mailbox)
2355 {
2356 #define MLX4_CMD_MAD_DEMUX_SET_ATTR_OFFSET              0x10
2357 #define MLX4_CMD_MAD_DEMUX_GETRESP_ATTR_OFFSET          0x20
2358 #define MLX4_CMD_MAD_DEMUX_TRAP_ATTR_OFFSET             0x40
2359 #define MLX4_CMD_MAD_DEMUX_TRAP_REPRESS_ATTR_OFFSET     0x70
2360
2361         u32 set_attr_mask, getresp_attr_mask;
2362         u32 trap_attr_mask, traprepress_attr_mask;
2363
2364         MLX4_GET(set_attr_mask, mailbox->buf,
2365                  MLX4_CMD_MAD_DEMUX_SET_ATTR_OFFSET);
2366         mlx4_dbg(dev, "SMP firewall set_attribute_mask = 0x%x\n",
2367                  set_attr_mask);
2368
2369         MLX4_GET(getresp_attr_mask, mailbox->buf,
2370                  MLX4_CMD_MAD_DEMUX_GETRESP_ATTR_OFFSET);
2371         mlx4_dbg(dev, "SMP firewall getresp_attribute_mask = 0x%x\n",
2372                  getresp_attr_mask);
2373
2374         MLX4_GET(trap_attr_mask, mailbox->buf,
2375                  MLX4_CMD_MAD_DEMUX_TRAP_ATTR_OFFSET);
2376         mlx4_dbg(dev, "SMP firewall trap_attribute_mask = 0x%x\n",
2377                  trap_attr_mask);
2378
2379         MLX4_GET(traprepress_attr_mask, mailbox->buf,
2380                  MLX4_CMD_MAD_DEMUX_TRAP_REPRESS_ATTR_OFFSET);
2381         mlx4_dbg(dev, "SMP firewall traprepress_attribute_mask = 0x%x\n",
2382                  traprepress_attr_mask);
2383
2384         if (set_attr_mask && getresp_attr_mask && trap_attr_mask &&
2385             traprepress_attr_mask)
2386                 return 1;
2387
2388         return 0;
2389 }
2390
2391 int mlx4_config_mad_demux(struct mlx4_dev *dev)
2392 {
2393         struct mlx4_cmd_mailbox *mailbox;
2394         int secure_host_active;
2395         int err;
2396
2397         /* Check if mad_demux is supported */
2398         if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_MAD_DEMUX))
2399                 return 0;
2400
2401         mailbox = mlx4_alloc_cmd_mailbox(dev);
2402         if (IS_ERR(mailbox)) {
2403                 mlx4_warn(dev, "Failed to allocate mailbox for cmd MAD_DEMUX");
2404                 return -ENOMEM;
2405         }
2406
2407         /* Query mad_demux to find out which MADs are handled by internal sma */
2408         err = mlx4_cmd_box(dev, 0, mailbox->dma, 0x01 /* subn mgmt class */,
2409                            MLX4_CMD_MAD_DEMUX_QUERY_RESTR, MLX4_CMD_MAD_DEMUX,
2410                            MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
2411         if (err) {
2412                 mlx4_warn(dev, "MLX4_CMD_MAD_DEMUX: query restrictions failed (%d)\n",
2413                           err);
2414                 goto out;
2415         }
2416
2417         secure_host_active = mlx4_check_smp_firewall_active(dev, mailbox);
2418
2419         /* Config mad_demux to handle all MADs returned by the query above */
2420         err = mlx4_cmd(dev, mailbox->dma, 0x01 /* subn mgmt class */,
2421                        MLX4_CMD_MAD_DEMUX_CONFIG, MLX4_CMD_MAD_DEMUX,
2422                        MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
2423         if (err) {
2424                 mlx4_warn(dev, "MLX4_CMD_MAD_DEMUX: configure failed (%d)\n", err);
2425                 goto out;
2426         }
2427
2428         if (secure_host_active)
2429                 mlx4_warn(dev, "HCA operating in secure-host mode. SMP firewall activated.\n");
2430 out:
2431         mlx4_free_cmd_mailbox(dev, mailbox);
2432         return err;
2433 }
2434
2435 /* Access Reg commands */
2436 enum mlx4_access_reg_masks {
2437         MLX4_ACCESS_REG_STATUS_MASK = 0x7f,
2438         MLX4_ACCESS_REG_METHOD_MASK = 0x7f,
2439         MLX4_ACCESS_REG_LEN_MASK = 0x7ff
2440 };
2441
2442 struct mlx4_access_reg {
2443         __be16 constant1;
2444         u8 status;
2445         u8 resrvd1;
2446         __be16 reg_id;
2447         u8 method;
2448         u8 constant2;
2449         __be32 resrvd2[2];
2450         __be16 len_const;
2451         __be16 resrvd3;
2452 #define MLX4_ACCESS_REG_HEADER_SIZE (20)
2453         u8 reg_data[MLX4_MAILBOX_SIZE-MLX4_ACCESS_REG_HEADER_SIZE];
2454 } __attribute__((__packed__));
2455
2456 /**
2457  * mlx4_ACCESS_REG - Generic access reg command.
2458  * @dev: mlx4_dev.
2459  * @reg_id: register ID to access.
2460  * @method: Access method Read/Write.
2461  * @reg_len: register length to Read/Write in bytes.
2462  * @reg_data: reg_data pointer to Read/Write From/To.
2463  *
2464  * Access ConnectX registers FW command.
2465  * Returns 0 on success and copies outbox mlx4_access_reg data
2466  * field into reg_data or a negative error code.
2467  */
2468 static int mlx4_ACCESS_REG(struct mlx4_dev *dev, u16 reg_id,
2469                            enum mlx4_access_reg_method method,
2470                            u16 reg_len, void *reg_data)
2471 {
2472         struct mlx4_cmd_mailbox *inbox, *outbox;
2473         struct mlx4_access_reg *inbuf, *outbuf;
2474         int err;
2475
2476         inbox = mlx4_alloc_cmd_mailbox(dev);
2477         if (IS_ERR(inbox))
2478                 return PTR_ERR(inbox);
2479
2480         outbox = mlx4_alloc_cmd_mailbox(dev);
2481         if (IS_ERR(outbox)) {
2482                 mlx4_free_cmd_mailbox(dev, inbox);
2483                 return PTR_ERR(outbox);
2484         }
2485
2486         inbuf = inbox->buf;
2487         outbuf = outbox->buf;
2488
2489         inbuf->constant1 = cpu_to_be16(0x1<<11 | 0x4);
2490         inbuf->constant2 = 0x1;
2491         inbuf->reg_id = cpu_to_be16(reg_id);
2492         inbuf->method = method & MLX4_ACCESS_REG_METHOD_MASK;
2493
2494         reg_len = min(reg_len, (u16)(sizeof(inbuf->reg_data)));
2495         inbuf->len_const =
2496                 cpu_to_be16(((reg_len/4 + 1) & MLX4_ACCESS_REG_LEN_MASK) |
2497                             ((0x3) << 12));
2498
2499         memcpy(inbuf->reg_data, reg_data, reg_len);
2500         err = mlx4_cmd_box(dev, inbox->dma, outbox->dma, 0, 0,
2501                            MLX4_CMD_ACCESS_REG, MLX4_CMD_TIME_CLASS_C,
2502                            MLX4_CMD_WRAPPED);
2503         if (err)
2504                 goto out;
2505
2506         if (outbuf->status & MLX4_ACCESS_REG_STATUS_MASK) {
2507                 err = outbuf->status & MLX4_ACCESS_REG_STATUS_MASK;
2508                 mlx4_err(dev,
2509                          "MLX4_CMD_ACCESS_REG(%x) returned REG status (%x)\n",
2510                          reg_id, err);
2511                 goto out;
2512         }
2513
2514         memcpy(reg_data, outbuf->reg_data, reg_len);
2515 out:
2516         mlx4_free_cmd_mailbox(dev, inbox);
2517         mlx4_free_cmd_mailbox(dev, outbox);
2518         return err;
2519 }
2520
2521 /* ConnectX registers IDs */
2522 enum mlx4_reg_id {
2523         MLX4_REG_ID_PTYS = 0x5004,
2524 };
2525
2526 /**
2527  * mlx4_ACCESS_PTYS_REG - Access PTYs (Port Type and Speed)
2528  * register
2529  * @dev: mlx4_dev.
2530  * @method: Access method Read/Write.
2531  * @ptys_reg: PTYS register data pointer.
2532  *
2533  * Access ConnectX PTYS register, to Read/Write Port Type/Speed
2534  * configuration
2535  * Returns 0 on success or a negative error code.
2536  */
2537 int mlx4_ACCESS_PTYS_REG(struct mlx4_dev *dev,
2538                          enum mlx4_access_reg_method method,
2539                          struct mlx4_ptys_reg *ptys_reg)
2540 {
2541         return mlx4_ACCESS_REG(dev, MLX4_REG_ID_PTYS,
2542                                method, sizeof(*ptys_reg), ptys_reg);
2543 }
2544 EXPORT_SYMBOL_GPL(mlx4_ACCESS_PTYS_REG);
2545
2546 int mlx4_ACCESS_REG_wrapper(struct mlx4_dev *dev, int slave,
2547                             struct mlx4_vhcr *vhcr,
2548                             struct mlx4_cmd_mailbox *inbox,
2549                             struct mlx4_cmd_mailbox *outbox,
2550                             struct mlx4_cmd_info *cmd)
2551 {
2552         struct mlx4_access_reg *inbuf = inbox->buf;
2553         u8 method = inbuf->method & MLX4_ACCESS_REG_METHOD_MASK;
2554         u16 reg_id = be16_to_cpu(inbuf->reg_id);
2555
2556         if (slave != mlx4_master_func_num(dev) &&
2557             method == MLX4_ACCESS_REG_WRITE)
2558                 return -EPERM;
2559
2560         if (reg_id == MLX4_REG_ID_PTYS) {
2561                 struct mlx4_ptys_reg *ptys_reg =
2562                         (struct mlx4_ptys_reg *)inbuf->reg_data;
2563
2564                 ptys_reg->local_port =
2565                         mlx4_slave_convert_port(dev, slave,
2566                                                 ptys_reg->local_port);
2567         }
2568
2569         return mlx4_cmd_box(dev, inbox->dma, outbox->dma, vhcr->in_modifier,
2570                             0, MLX4_CMD_ACCESS_REG, MLX4_CMD_TIME_CLASS_C,
2571                             MLX4_CMD_NATIVE);
2572 }