drivers/infiniband/hw/mlx4/main.c

   1 /*
   2  * Copyright (c) 2006, 2007 Cisco Systems, Inc. All rights reserved.
   3  * Copyright (c) 2007, 2008 Mellanox Technologies. All rights reserved.
   4  *
   5  * This software is available to you under a choice of one of two
   6  * licenses.  You may choose to be licensed under the terms of the GNU
   7  * General Public License (GPL) Version 2, available from the file
   8  * COPYING in the main directory of this source tree, or the
   9  * OpenIB.org BSD license below:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      - Redistributions of source code must retain the above
  16  *        copyright notice, this list of conditions and the following
  17  *        disclaimer.
  18  *
  19  *      - Redistributions in binary form must reproduce the above
  20  *        copyright notice, this list of conditions and the following
  21  *        disclaimer in the documentation and/or other materials
  22  *        provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33
  34 #include <linux/module.h>
  35 #include <linux/init.h>
  36 #include <linux/slab.h>
  37 #include <linux/errno.h>
  38 #include <linux/netdevice.h>
  39 #include <linux/inetdevice.h>
  40 #include <linux/rtnetlink.h>
  41 #include <linux/if_vlan.h>
  42
  43 #include <rdma/ib_smi.h>
  44 #include <rdma/ib_user_verbs.h>
  45 #include <rdma/ib_addr.h>
  46
  47 #include <linux/mlx4/driver.h>
  48 #include <linux/mlx4/cmd.h>
  49
  50 #include "mlx4_ib.h"
  51 #include "user.h"
  52
  53 #define DRV_NAME        MLX4_IB_DRV_NAME
  54 #define DRV_VERSION     "1.0"
  55 #define DRV_RELDATE     "April 4, 2008"
  56
  57 MODULE_AUTHOR("Roland Dreier");
  58 MODULE_DESCRIPTION("Mellanox ConnectX HCA InfiniBand driver");
  59 MODULE_LICENSE("Dual BSD/GPL");
  60 MODULE_VERSION(DRV_VERSION);
  61
  62 int mlx4_ib_sm_guid_assign = 1;
  63 module_param_named(sm_guid_assign, mlx4_ib_sm_guid_assign, int, 0444);
  64 MODULE_PARM_DESC(sm_guid_assign, "Enable SM alias_GUID assignment if sm_guid_assign > 0 (Default: 1)");
  65
  66 static const char mlx4_ib_version[] =
  67         DRV_NAME ": Mellanox ConnectX InfiniBand driver v"
  68         DRV_VERSION " (" DRV_RELDATE ")\n";
  69
  70 struct update_gid_work {
  71         struct work_struct      work;
  72         union ib_gid            gids[128];
  73         struct mlx4_ib_dev     *dev;
  74         int                     port;
  75 };
  76
  77 static void do_slave_init(struct mlx4_ib_dev *ibdev, int slave, int do_init);
  78
  79 static struct workqueue_struct *wq;
  80
  81 static void init_query_mad(struct ib_smp *mad)
  82 {
  83         mad->base_version  = 1;
  84         mad->mgmt_class    = IB_MGMT_CLASS_SUBN_LID_ROUTED;
  85         mad->class_version = 1;
  86         mad->method        = IB_MGMT_METHOD_GET;
  87 }
  88
  89 static union ib_gid zgid;
  90
  91 static int mlx4_ib_query_device(struct ib_device *ibdev,
  92                                 struct ib_device_attr *props)
  93 {
  94         struct mlx4_ib_dev *dev = to_mdev(ibdev);
  95         struct ib_smp *in_mad  = NULL;
  96         struct ib_smp *out_mad = NULL;
  97         int err = -ENOMEM;
  98
  99         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
 100         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
 101         if (!in_mad || !out_mad)
 102                 goto out;
 103
 104         init_query_mad(in_mad);
 105         in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
 106
 107         err = mlx4_MAD_IFC(to_mdev(ibdev), MLX4_MAD_IFC_IGNORE_KEYS,
 108                            1, NULL, NULL, in_mad, out_mad);
 109         if (err)
 110                 goto out;
 111
 112         memset(props, 0, sizeof *props);
 113
 114         props->fw_ver = dev->dev->caps.fw_ver;
 115         props->device_cap_flags    = IB_DEVICE_CHANGE_PHY_PORT |
 116                 IB_DEVICE_PORT_ACTIVE_EVENT             |
 117                 IB_DEVICE_SYS_IMAGE_GUID                |
 118                 IB_DEVICE_RC_RNR_NAK_GEN                |
 119                 IB_DEVICE_BLOCK_MULTICAST_LOOPBACK;
 120         if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_BAD_PKEY_CNTR)
 121                 props->device_cap_flags |= IB_DEVICE_BAD_PKEY_CNTR;
 122         if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_BAD_QKEY_CNTR)
 123                 props->device_cap_flags |= IB_DEVICE_BAD_QKEY_CNTR;
 124         if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_APM)
 125                 props->device_cap_flags |= IB_DEVICE_AUTO_PATH_MIG;
 126         if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_UD_AV_PORT)
 127                 props->device_cap_flags |= IB_DEVICE_UD_AV_PORT_ENFORCE;
 128         if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_IPOIB_CSUM)
 129                 props->device_cap_flags |= IB_DEVICE_UD_IP_CSUM;
 130         if (dev->dev->caps.max_gso_sz && dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_BLH)
 131                 props->device_cap_flags |= IB_DEVICE_UD_TSO;
 132         if (dev->dev->caps.bmme_flags & MLX4_BMME_FLAG_RESERVED_LKEY)
 133                 props->device_cap_flags |= IB_DEVICE_LOCAL_DMA_LKEY;
 134         if ((dev->dev->caps.bmme_flags & MLX4_BMME_FLAG_LOCAL_INV) &&
 135             (dev->dev->caps.bmme_flags & MLX4_BMME_FLAG_REMOTE_INV) &&
 136             (dev->dev->caps.bmme_flags & MLX4_BMME_FLAG_FAST_REG_WR))
 137                 props->device_cap_flags |= IB_DEVICE_MEM_MGT_EXTENSIONS;
 138         if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_XRC)
 139                 props->device_cap_flags |= IB_DEVICE_XRC;
 140
 141         props->vendor_id           = be32_to_cpup((__be32 *) (out_mad->data + 36)) &
 142                 0xffffff;
 143         props->vendor_part_id      = dev->dev->pdev->device;
 144         props->hw_ver              = be32_to_cpup((__be32 *) (out_mad->data + 32));
 145         memcpy(&props->sys_image_guid, out_mad->data +  4, 8);
 146
 147         props->max_mr_size         = ~0ull;
 148         props->page_size_cap       = dev->dev->caps.page_size_cap;
 149         props->max_qp              = dev->dev->caps.num_qps - dev->dev->caps.reserved_qps;
 150         props->max_qp_wr           = dev->dev->caps.max_wqes - MLX4_IB_SQ_MAX_SPARE;
 151         props->max_sge             = min(dev->dev->caps.max_sq_sg,
 152                                          dev->dev->caps.max_rq_sg);
 153         props->max_cq              = dev->dev->caps.num_cqs - dev->dev->caps.reserved_cqs;
 154         props->max_cqe             = dev->dev->caps.max_cqes;
 155         props->max_mr              = dev->dev->caps.num_mpts - dev->dev->caps.reserved_mrws;
 156         props->max_pd              = dev->dev->caps.num_pds - dev->dev->caps.reserved_pds;
 157         props->max_qp_rd_atom      = dev->dev->caps.max_qp_dest_rdma;
 158         props->max_qp_init_rd_atom = dev->dev->caps.max_qp_init_rdma;
 159         props->max_res_rd_atom     = props->max_qp_rd_atom * props->max_qp;
 160         props->max_srq             = dev->dev->caps.num_srqs - dev->dev->caps.reserved_srqs;
 161         props->max_srq_wr          = dev->dev->caps.max_srq_wqes - 1;
 162         props->max_srq_sge         = dev->dev->caps.max_srq_sge;
 163         props->max_fast_reg_page_list_len = MLX4_MAX_FAST_REG_PAGES;
 164         props->local_ca_ack_delay  = dev->dev->caps.local_ca_ack_delay;
 165         props->atomic_cap          = dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_ATOMIC ?
 166                 IB_ATOMIC_HCA : IB_ATOMIC_NONE;
 167         props->masked_atomic_cap   = props->atomic_cap;
 168         props->max_pkeys           = dev->dev->caps.pkey_table_len[1];
 169         props->max_mcast_grp       = dev->dev->caps.num_mgms + dev->dev->caps.num_amgms;
 170         props->max_mcast_qp_attach = dev->dev->caps.num_qp_per_mgm;
 171         props->max_total_mcast_qp_attach = props->max_mcast_qp_attach *
 172                                            props->max_mcast_grp;
 173         props->max_map_per_fmr = dev->dev->caps.max_fmr_maps;
 174
 175 out:
 176         kfree(in_mad);
 177         kfree(out_mad);
 178
 179         return err;
 180 }
 181
 182 static enum rdma_link_layer
 183 mlx4_ib_port_link_layer(struct ib_device *device, u8 port_num)
 184 {
 185         struct mlx4_dev *dev = to_mdev(device)->dev;
 186
 187         return dev->caps.port_mask[port_num] == MLX4_PORT_TYPE_IB ?
 188                 IB_LINK_LAYER_INFINIBAND : IB_LINK_LAYER_ETHERNET;
 189 }
 190
 191 static int ib_link_query_port(struct ib_device *ibdev, u8 port,
 192                               struct ib_port_attr *props, int netw_view)
 193 {
 194         struct ib_smp *in_mad  = NULL;
 195         struct ib_smp *out_mad = NULL;
 196         int ext_active_speed;
 197         int mad_ifc_flags = MLX4_MAD_IFC_IGNORE_KEYS;
 198         int err = -ENOMEM;
 199
 200         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
 201         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
 202         if (!in_mad || !out_mad)
 203                 goto out;
 204
 205         init_query_mad(in_mad);
 206         in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
 207         in_mad->attr_mod = cpu_to_be32(port);
 208
 209         if (mlx4_is_mfunc(to_mdev(ibdev)->dev) && netw_view)
 210                 mad_ifc_flags |= MLX4_MAD_IFC_NET_VIEW;
 211
 212         err = mlx4_MAD_IFC(to_mdev(ibdev), mad_ifc_flags, port, NULL, NULL,
 213                                 in_mad, out_mad);
 214         if (err)
 215                 goto out;
 216
 217
 218         props->lid              = be16_to_cpup((__be16 *) (out_mad->data + 16));
 219         props->lmc              = out_mad->data[34] & 0x7;
 220         props->sm_lid           = be16_to_cpup((__be16 *) (out_mad->data + 18));
 221         props->sm_sl            = out_mad->data[36] & 0xf;
 222         props->state            = out_mad->data[32] & 0xf;
 223         props->phys_state       = out_mad->data[33] >> 4;
 224         props->port_cap_flags   = be32_to_cpup((__be32 *) (out_mad->data + 20));
 225         if (netw_view)
 226                 props->gid_tbl_len = out_mad->data[50];
 227         else
 228                 props->gid_tbl_len = to_mdev(ibdev)->dev->caps.gid_table_len[port];
 229         props->max_msg_sz       = to_mdev(ibdev)->dev->caps.max_msg_sz;
 230         props->pkey_tbl_len     = to_mdev(ibdev)->dev->caps.pkey_table_len[port];
 231         props->bad_pkey_cntr    = be16_to_cpup((__be16 *) (out_mad->data + 46));
 232         props->qkey_viol_cntr   = be16_to_cpup((__be16 *) (out_mad->data + 48));
 233         props->active_width     = out_mad->data[31] & 0xf;
 234         props->active_speed     = out_mad->data[35] >> 4;
 235         props->max_mtu          = out_mad->data[41] & 0xf;
 236         props->active_mtu       = out_mad->data[36] >> 4;
 237         props->subnet_timeout   = out_mad->data[51] & 0x1f;
 238         props->max_vl_num       = out_mad->data[37] >> 4;
 239         props->init_type_reply  = out_mad->data[41] >> 4;
 240
 241         /* Check if extended speeds (EDR/FDR/...) are supported */
 242         if (props->port_cap_flags & IB_PORT_EXTENDED_SPEEDS_SUP) {
 243                 ext_active_speed = out_mad->data[62] >> 4;
 244
 245                 switch (ext_active_speed) {
 246                 case 1:
 247                         props->active_speed = IB_SPEED_FDR;
 248                         break;
 249                 case 2:
 250                         props->active_speed = IB_SPEED_EDR;
 251                         break;
 252                 }
 253         }
 254
 255         /* If reported active speed is QDR, check if is FDR-10 */
 256         if (props->active_speed == IB_SPEED_QDR) {
 257                 init_query_mad(in_mad);
 258                 in_mad->attr_id = MLX4_ATTR_EXTENDED_PORT_INFO;
 259                 in_mad->attr_mod = cpu_to_be32(port);
 260
 261                 err = mlx4_MAD_IFC(to_mdev(ibdev), mad_ifc_flags, port,
 262                                    NULL, NULL, in_mad, out_mad);
 263                 if (err)
 264                         goto out;
 265
 266                 /* Checking LinkSpeedActive for FDR-10 */
 267                 if (out_mad->data[15] & 0x1)
 268                         props->active_speed = IB_SPEED_FDR10;
 269         }
 270
 271         /* Avoid wrong speed value returned by FW if the IB link is down. */
 272         if (props->state == IB_PORT_DOWN)
 273                  props->active_speed = IB_SPEED_SDR;
 274
 275 out:
 276         kfree(in_mad);
 277         kfree(out_mad);
 278         return err;
 279 }
 280
 281 static u8 state_to_phys_state(enum ib_port_state state)
 282 {
 283         return state == IB_PORT_ACTIVE ? 5 : 3;
 284 }
 285
 286 static int eth_link_query_port(struct ib_device *ibdev, u8 port,
 287                                struct ib_port_attr *props, int netw_view)
 288 {
 289
 290         struct mlx4_ib_dev *mdev = to_mdev(ibdev);
 291         struct mlx4_ib_iboe *iboe = &mdev->iboe;
 292         struct net_device *ndev;
 293         enum ib_mtu tmp;
 294         struct mlx4_cmd_mailbox *mailbox;
 295         int err = 0;
 296
 297         mailbox = mlx4_alloc_cmd_mailbox(mdev->dev);
 298         if (IS_ERR(mailbox))
 299                 return PTR_ERR(mailbox);
 300
 301         err = mlx4_cmd_box(mdev->dev, 0, mailbox->dma, port, 0,
 302                            MLX4_CMD_QUERY_PORT, MLX4_CMD_TIME_CLASS_B,
 303                            MLX4_CMD_WRAPPED);
 304         if (err)
 305                 goto out;
 306
 307         props->active_width     =  (((u8 *)mailbox->buf)[5] == 0x40) ?
 308                                                 IB_WIDTH_4X : IB_WIDTH_1X;
 309         props->active_speed     = IB_SPEED_QDR;
 310         props->port_cap_flags   = IB_PORT_CM_SUP;
 311         props->gid_tbl_len      = mdev->dev->caps.gid_table_len[port];
 312         props->max_msg_sz       = mdev->dev->caps.max_msg_sz;
 313         props->pkey_tbl_len     = 1;
 314         props->max_mtu          = IB_MTU_4096;
 315         props->max_vl_num       = 2;
 316         props->state            = IB_PORT_DOWN;
 317         props->phys_state       = state_to_phys_state(props->state);
 318         props->active_mtu       = IB_MTU_256;
 319         spin_lock(&iboe->lock);
 320         ndev = iboe->netdevs[port - 1];
 321         if (!ndev)
 322                 goto out_unlock;
 323
 324         tmp = iboe_get_mtu(ndev->mtu);
 325         props->active_mtu = tmp ? min(props->max_mtu, tmp) : IB_MTU_256;
 326
 327         props->state            = (netif_running(ndev) && netif_carrier_ok(ndev)) ?
 328                                         IB_PORT_ACTIVE : IB_PORT_DOWN;
 329         props->phys_state       = state_to_phys_state(props->state);
 330 out_unlock:
 331         spin_unlock(&iboe->lock);
 332 out:
 333         mlx4_free_cmd_mailbox(mdev->dev, mailbox);
 334         return err;
 335 }
 336
 337 int __mlx4_ib_query_port(struct ib_device *ibdev, u8 port,
 338                          struct ib_port_attr *props, int netw_view)
 339 {
 340         int err;
 341
 342         memset(props, 0, sizeof *props);
 343
 344         err = mlx4_ib_port_link_layer(ibdev, port) == IB_LINK_LAYER_INFINIBAND ?
 345                 ib_link_query_port(ibdev, port, props, netw_view) :
 346                                 eth_link_query_port(ibdev, port, props, netw_view);
 347
 348         return err;
 349 }
 350
 351 static int mlx4_ib_query_port(struct ib_device *ibdev, u8 port,
 352                               struct ib_port_attr *props)
 353 {
 354         /* returns host view */
 355         return __mlx4_ib_query_port(ibdev, port, props, 0);
 356 }
 357
 358 int __mlx4_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
 359                         union ib_gid *gid, int netw_view)
 360 {
 361         struct ib_smp *in_mad  = NULL;
 362         struct ib_smp *out_mad = NULL;
 363         int err = -ENOMEM;
 364         struct mlx4_ib_dev *dev = to_mdev(ibdev);
 365         int clear = 0;
 366         int mad_ifc_flags = MLX4_MAD_IFC_IGNORE_KEYS;
 367
 368         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
 369         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
 370         if (!in_mad || !out_mad)
 371                 goto out;
 372
 373         init_query_mad(in_mad);
 374         in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
 375         in_mad->attr_mod = cpu_to_be32(port);
 376
 377         if (mlx4_is_mfunc(dev->dev) && netw_view)
 378                 mad_ifc_flags |= MLX4_MAD_IFC_NET_VIEW;
 379
 380         err = mlx4_MAD_IFC(dev, mad_ifc_flags, port, NULL, NULL, in_mad, out_mad);
 381         if (err)
 382                 goto out;
 383
 384         memcpy(gid->raw, out_mad->data + 8, 8);
 385
 386         if (mlx4_is_mfunc(dev->dev) && !netw_view) {
 387                 if (index) {
 388                         /* For any index > 0, return the null guid */
 389                         err = 0;
 390                         clear = 1;
 391                         goto out;
 392                 }
 393         }
 394
 395         init_query_mad(in_mad);
 396         in_mad->attr_id  = IB_SMP_ATTR_GUID_INFO;
 397         in_mad->attr_mod = cpu_to_be32(index / 8);
 398
 399         err = mlx4_MAD_IFC(dev, mad_ifc_flags, port,
 400                            NULL, NULL, in_mad, out_mad);
 401         if (err)
 402                 goto out;
 403
 404         memcpy(gid->raw + 8, out_mad->data + (index % 8) * 8, 8);
 405
 406 out:
 407         if (clear)
 408                 memset(gid->raw + 8, 0, 8);
 409         kfree(in_mad);
 410         kfree(out_mad);
 411         return err;
 412 }
 413
 414 static int iboe_query_gid(struct ib_device *ibdev, u8 port, int index,
 415                           union ib_gid *gid)
 416 {
 417         struct mlx4_ib_dev *dev = to_mdev(ibdev);
 418
 419         *gid = dev->iboe.gid_table[port - 1][index];
 420
 421         return 0;
 422 }
 423
 424 static int mlx4_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
 425                              union ib_gid *gid)
 426 {
 427         if (rdma_port_get_link_layer(ibdev, port) == IB_LINK_LAYER_INFINIBAND)
 428                 return __mlx4_ib_query_gid(ibdev, port, index, gid, 0);
 429         else
 430                 return iboe_query_gid(ibdev, port, index, gid);
 431 }
 432
 433 int __mlx4_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
 434                          u16 *pkey, int netw_view)
 435 {
 436         struct ib_smp *in_mad  = NULL;
 437         struct ib_smp *out_mad = NULL;
 438         int mad_ifc_flags = MLX4_MAD_IFC_IGNORE_KEYS;
 439         int err = -ENOMEM;
 440
 441         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
 442         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
 443         if (!in_mad || !out_mad)
 444                 goto out;
 445
 446         init_query_mad(in_mad);
 447         in_mad->attr_id  = IB_SMP_ATTR_PKEY_TABLE;
 448         in_mad->attr_mod = cpu_to_be32(index / 32);
 449
 450         if (mlx4_is_mfunc(to_mdev(ibdev)->dev) && netw_view)
 451                 mad_ifc_flags |= MLX4_MAD_IFC_NET_VIEW;
 452
 453         err = mlx4_MAD_IFC(to_mdev(ibdev), mad_ifc_flags, port, NULL, NULL,
 454                            in_mad, out_mad);
 455         if (err)
 456                 goto out;
 457
 458         *pkey = be16_to_cpu(((__be16 *) out_mad->data)[index % 32]);
 459
 460 out:
 461         kfree(in_mad);
 462         kfree(out_mad);
 463         return err;
 464 }
 465
 466 static int mlx4_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index, u16 *pkey)
 467 {
 468         return __mlx4_ib_query_pkey(ibdev, port, index, pkey, 0);
 469 }
 470
 471 static int mlx4_ib_modify_device(struct ib_device *ibdev, int mask,
 472                                  struct ib_device_modify *props)
 473 {
 474         struct mlx4_cmd_mailbox *mailbox;
 475         unsigned long flags;
 476
 477         if (mask & ~IB_DEVICE_MODIFY_NODE_DESC)
 478                 return -EOPNOTSUPP;
 479
 480         if (!(mask & IB_DEVICE_MODIFY_NODE_DESC))
 481                 return 0;
 482
 483         if (mlx4_is_slave(to_mdev(ibdev)->dev))
 484                 return -EOPNOTSUPP;
 485
 486         spin_lock_irqsave(&to_mdev(ibdev)->sm_lock, flags);
 487         memcpy(ibdev->node_desc, props->node_desc, 64);
 488         spin_unlock_irqrestore(&to_mdev(ibdev)->sm_lock, flags);
 489
 490         /*
 491          * If possible, pass node desc to FW, so it can generate
 492          * a 144 trap.  If cmd fails, just ignore.
 493          */
 494         mailbox = mlx4_alloc_cmd_mailbox(to_mdev(ibdev)->dev);
 495         if (IS_ERR(mailbox))
 496                 return 0;
 497
 498         memset(mailbox->buf, 0, 256);
 499         memcpy(mailbox->buf, props->node_desc, 64);
 500         mlx4_cmd(to_mdev(ibdev)->dev, mailbox->dma, 1, 0,
 501                  MLX4_CMD_SET_NODE, MLX4_CMD_TIME_CLASS_A, MLX4_CMD_NATIVE);
 502
 503         mlx4_free_cmd_mailbox(to_mdev(ibdev)->dev, mailbox);
 504
 505         return 0;
 506 }
 507
 508 static int mlx4_SET_PORT(struct mlx4_ib_dev *dev, u8 port, int reset_qkey_viols,
 509                          u32 cap_mask)
 510 {
 511         struct mlx4_cmd_mailbox *mailbox;
 512         int err;
 513         u8 is_eth = dev->dev->caps.port_type[port] == MLX4_PORT_TYPE_ETH;
 514
 515         mailbox = mlx4_alloc_cmd_mailbox(dev->dev);
 516         if (IS_ERR(mailbox))
 517                 return PTR_ERR(mailbox);
 518
 519         memset(mailbox->buf, 0, 256);
 520
 521         if (dev->dev->flags & MLX4_FLAG_OLD_PORT_CMDS) {
 522                 *(u8 *) mailbox->buf         = !!reset_qkey_viols << 6;
 523                 ((__be32 *) mailbox->buf)[2] = cpu_to_be32(cap_mask);
 524         } else {
 525                 ((u8 *) mailbox->buf)[3]     = !!reset_qkey_viols;
 526                 ((__be32 *) mailbox->buf)[1] = cpu_to_be32(cap_mask);
 527         }
 528
 529         err = mlx4_cmd(dev->dev, mailbox->dma, port, is_eth, MLX4_CMD_SET_PORT,
 530                        MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
 531
 532         mlx4_free_cmd_mailbox(dev->dev, mailbox);
 533         return err;
 534 }
 535
 536 static int mlx4_ib_modify_port(struct ib_device *ibdev, u8 port, int mask,
 537                                struct ib_port_modify *props)
 538 {
 539         struct ib_port_attr attr;
 540         u32 cap_mask;
 541         int err;
 542
 543         mutex_lock(&to_mdev(ibdev)->cap_mask_mutex);
 544
 545         err = mlx4_ib_query_port(ibdev, port, &attr);
 546         if (err)
 547                 goto out;
 548
 549         cap_mask = (attr.port_cap_flags | props->set_port_cap_mask) &
 550                 ~props->clr_port_cap_mask;
 551
 552         err = mlx4_SET_PORT(to_mdev(ibdev), port,
 553                             !!(mask & IB_PORT_RESET_QKEY_CNTR),
 554                             cap_mask);
 555
 556 out:
 557         mutex_unlock(&to_mdev(ibdev)->cap_mask_mutex);
 558         return err;
 559 }
 560
 561 static struct ib_ucontext *mlx4_ib_alloc_ucontext(struct ib_device *ibdev,
 562                                                   struct ib_udata *udata)
 563 {
 564         struct mlx4_ib_dev *dev = to_mdev(ibdev);
 565         struct mlx4_ib_ucontext *context;
 566         struct mlx4_ib_alloc_ucontext_resp_v3 resp_v3;
 567         struct mlx4_ib_alloc_ucontext_resp resp;
 568         int err;
 569
 570         if (!dev->ib_active)
 571                 return ERR_PTR(-EAGAIN);
 572
 573         if (ibdev->uverbs_abi_ver == MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION) {
 574                 resp_v3.qp_tab_size      = dev->dev->caps.num_qps;
 575                 resp_v3.bf_reg_size      = dev->dev->caps.bf_reg_size;
 576                 resp_v3.bf_regs_per_page = dev->dev->caps.bf_regs_per_page;
 577         } else {
 578                 resp.dev_caps         = dev->dev->caps.userspace_caps;
 579                 resp.qp_tab_size      = dev->dev->caps.num_qps;
 580                 resp.bf_reg_size      = dev->dev->caps.bf_reg_size;
 581                 resp.bf_regs_per_page = dev->dev->caps.bf_regs_per_page;
 582                 resp.cqe_size         = dev->dev->caps.cqe_size;
 583         }
 584
 585         context = kmalloc(sizeof *context, GFP_KERNEL);
 586         if (!context)
 587                 return ERR_PTR(-ENOMEM);
 588
 589         err = mlx4_uar_alloc(to_mdev(ibdev)->dev, &context->uar);
 590         if (err) {
 591                 kfree(context);
 592                 return ERR_PTR(err);
 593         }
 594
 595         INIT_LIST_HEAD(&context->db_page_list);
 596         mutex_init(&context->db_page_mutex);
 597
 598         if (ibdev->uverbs_abi_ver == MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION)
 599                 err = ib_copy_to_udata(udata, &resp_v3, sizeof(resp_v3));
 600         else
 601                 err = ib_copy_to_udata(udata, &resp, sizeof(resp));
 602
 603         if (err) {
 604                 mlx4_uar_free(to_mdev(ibdev)->dev, &context->uar);
 605                 kfree(context);
 606                 return ERR_PTR(-EFAULT);
 607         }
 608
 609         return &context->ibucontext;
 610 }
 611
 612 static int mlx4_ib_dealloc_ucontext(struct ib_ucontext *ibcontext)
 613 {
 614         struct mlx4_ib_ucontext *context = to_mucontext(ibcontext);
 615
 616         mlx4_uar_free(to_mdev(ibcontext->device)->dev, &context->uar);
 617         kfree(context);
 618
 619         return 0;
 620 }
 621
 622 static int mlx4_ib_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
 623 {
 624         struct mlx4_ib_dev *dev = to_mdev(context->device);
 625
 626         if (vma->vm_end - vma->vm_start != PAGE_SIZE)
 627                 return -EINVAL;
 628
 629         if (vma->vm_pgoff == 0) {
 630                 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 631
 632                 if (io_remap_pfn_range(vma, vma->vm_start,
 633                                        to_mucontext(context)->uar.pfn,
 634                                        PAGE_SIZE, vma->vm_page_prot))
 635                         return -EAGAIN;
 636         } else if (vma->vm_pgoff == 1 && dev->dev->caps.bf_reg_size != 0) {
 637                 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
 638
 639                 if (io_remap_pfn_range(vma, vma->vm_start,
 640                                        to_mucontext(context)->uar.pfn +
 641                                        dev->dev->caps.num_uars,
 642                                        PAGE_SIZE, vma->vm_page_prot))
 643                         return -EAGAIN;
 644         } else
 645                 return -EINVAL;
 646
 647         return 0;
 648 }
 649
 650 static struct ib_pd *mlx4_ib_alloc_pd(struct ib_device *ibdev,
 651                                       struct ib_ucontext *context,
 652                                       struct ib_udata *udata)
 653 {
 654         struct mlx4_ib_pd *pd;
 655         int err;
 656
 657         pd = kmalloc(sizeof *pd, GFP_KERNEL);
 658         if (!pd)
 659                 return ERR_PTR(-ENOMEM);
 660
 661         err = mlx4_pd_alloc(to_mdev(ibdev)->dev, &pd->pdn);
 662         if (err) {
 663                 kfree(pd);
 664                 return ERR_PTR(err);
 665         }
 666
 667         if (context)
 668                 if (ib_copy_to_udata(udata, &pd->pdn, sizeof (__u32))) {
 669                         mlx4_pd_free(to_mdev(ibdev)->dev, pd->pdn);
 670                         kfree(pd);
 671                         return ERR_PTR(-EFAULT);
 672                 }
 673
 674         return &pd->ibpd;
 675 }
 676
 677 static int mlx4_ib_dealloc_pd(struct ib_pd *pd)
 678 {
 679         mlx4_pd_free(to_mdev(pd->device)->dev, to_mpd(pd)->pdn);
 680         kfree(pd);
 681
 682         return 0;
 683 }
 684
 685 static struct ib_xrcd *mlx4_ib_alloc_xrcd(struct ib_device *ibdev,
 686                                           struct ib_ucontext *context,
 687                                           struct ib_udata *udata)
 688 {
 689         struct mlx4_ib_xrcd *xrcd;
 690         int err;
 691
 692         if (!(to_mdev(ibdev)->dev->caps.flags & MLX4_DEV_CAP_FLAG_XRC))
 693                 return ERR_PTR(-ENOSYS);
 694
 695         xrcd = kmalloc(sizeof *xrcd, GFP_KERNEL);
 696         if (!xrcd)
 697                 return ERR_PTR(-ENOMEM);
 698
 699         err = mlx4_xrcd_alloc(to_mdev(ibdev)->dev, &xrcd->xrcdn);
 700         if (err)
 701                 goto err1;
 702
 703         xrcd->pd = ib_alloc_pd(ibdev);
 704         if (IS_ERR(xrcd->pd)) {
 705                 err = PTR_ERR(xrcd->pd);
 706                 goto err2;
 707         }
 708
 709         xrcd->cq = ib_create_cq(ibdev, NULL, NULL, xrcd, 1, 0);
 710         if (IS_ERR(xrcd->cq)) {
 711                 err = PTR_ERR(xrcd->cq);
 712                 goto err3;
 713         }
 714
 715         return &xrcd->ibxrcd;
 716
 717 err3:
 718         ib_dealloc_pd(xrcd->pd);
 719 err2:
 720         mlx4_xrcd_free(to_mdev(ibdev)->dev, xrcd->xrcdn);
 721 err1:
 722         kfree(xrcd);
 723         return ERR_PTR(err);
 724 }
 725
 726 static int mlx4_ib_dealloc_xrcd(struct ib_xrcd *xrcd)
 727 {
 728         ib_destroy_cq(to_mxrcd(xrcd)->cq);
 729         ib_dealloc_pd(to_mxrcd(xrcd)->pd);
 730         mlx4_xrcd_free(to_mdev(xrcd->device)->dev, to_mxrcd(xrcd)->xrcdn);
 731         kfree(xrcd);
 732
 733         return 0;
 734 }
 735
 736 static int add_gid_entry(struct ib_qp *ibqp, union ib_gid *gid)
 737 {
 738         struct mlx4_ib_qp *mqp = to_mqp(ibqp);
 739         struct mlx4_ib_dev *mdev = to_mdev(ibqp->device);
 740         struct mlx4_ib_gid_entry *ge;
 741
 742         ge = kzalloc(sizeof *ge, GFP_KERNEL);
 743         if (!ge)
 744                 return -ENOMEM;
 745
 746         ge->gid = *gid;
 747         if (mlx4_ib_add_mc(mdev, mqp, gid)) {
 748                 ge->port = mqp->port;
 749                 ge->added = 1;
 750         }
 751
 752         mutex_lock(&mqp->mutex);
 753         list_add_tail(&ge->list, &mqp->gid_list);
 754         mutex_unlock(&mqp->mutex);
 755
 756         return 0;
 757 }
 758
 759 int mlx4_ib_add_mc(struct mlx4_ib_dev *mdev, struct mlx4_ib_qp *mqp,
 760                    union ib_gid *gid)
 761 {
 762         u8 mac[6];
 763         struct net_device *ndev;
 764         int ret = 0;
 765
 766         if (!mqp->port)
 767                 return 0;
 768
 769         spin_lock(&mdev->iboe.lock);
 770         ndev = mdev->iboe.netdevs[mqp->port - 1];
 771         if (ndev)
 772                 dev_hold(ndev);
 773         spin_unlock(&mdev->iboe.lock);
 774
 775         if (ndev) {
 776                 rdma_get_mcast_mac((struct in6_addr *)gid, mac);
 777                 rtnl_lock();
 778                 dev_mc_add(mdev->iboe.netdevs[mqp->port - 1], mac);
 779                 ret = 1;
 780                 rtnl_unlock();
 781                 dev_put(ndev);
 782         }
 783
 784         return ret;
 785 }
 786
 787 struct mlx4_ib_steering {
 788         struct list_head list;
 789         u64 reg_id;
 790         union ib_gid gid;
 791 };
 792
 793 static int mlx4_ib_mcg_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 794 {
 795         int err;
 796         struct mlx4_ib_dev *mdev = to_mdev(ibqp->device);
 797         struct mlx4_ib_qp *mqp = to_mqp(ibqp);
 798         u64 reg_id;
 799         struct mlx4_ib_steering *ib_steering = NULL;
 800
 801         if (mdev->dev->caps.steering_mode ==
 802             MLX4_STEERING_MODE_DEVICE_MANAGED) {
 803                 ib_steering = kmalloc(sizeof(*ib_steering), GFP_KERNEL);
 804                 if (!ib_steering)
 805                         return -ENOMEM;
 806         }
 807
 808         err = mlx4_multicast_attach(mdev->dev, &mqp->mqp, gid->raw, mqp->port,
 809                                     !!(mqp->flags &
 810                                        MLX4_IB_QP_BLOCK_MULTICAST_LOOPBACK),
 811                                     MLX4_PROT_IB_IPV6, &reg_id);
 812         if (err)
 813                 goto err_malloc;
 814
 815         err = add_gid_entry(ibqp, gid);
 816         if (err)
 817                 goto err_add;
 818
 819         if (ib_steering) {
 820                 memcpy(ib_steering->gid.raw, gid->raw, 16);
 821                 ib_steering->reg_id = reg_id;
 822                 mutex_lock(&mqp->mutex);
 823                 list_add(&ib_steering->list, &mqp->steering_rules);
 824                 mutex_unlock(&mqp->mutex);
 825         }
 826         return 0;
 827
 828 err_add:
 829         mlx4_multicast_detach(mdev->dev, &mqp->mqp, gid->raw,
 830                               MLX4_PROT_IB_IPV6, reg_id);
 831 err_malloc:
 832         kfree(ib_steering);
 833
 834         return err;
 835 }
 836
 837 static struct mlx4_ib_gid_entry *find_gid_entry(struct mlx4_ib_qp *qp, u8 *raw)
 838 {
 839         struct mlx4_ib_gid_entry *ge;
 840         struct mlx4_ib_gid_entry *tmp;
 841         struct mlx4_ib_gid_entry *ret = NULL;
 842
 843         list_for_each_entry_safe(ge, tmp, &qp->gid_list, list) {
 844                 if (!memcmp(raw, ge->gid.raw, 16)) {
 845                         ret = ge;
 846                         break;
 847                 }
 848         }
 849
 850         return ret;
 851 }
 852
 853 static int mlx4_ib_mcg_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 854 {
 855         int err;
 856         struct mlx4_ib_dev *mdev = to_mdev(ibqp->device);
 857         struct mlx4_ib_qp *mqp = to_mqp(ibqp);
 858         u8 mac[6];
 859         struct net_device *ndev;
 860         struct mlx4_ib_gid_entry *ge;
 861         u64 reg_id = 0;
 862
 863         if (mdev->dev->caps.steering_mode ==
 864             MLX4_STEERING_MODE_DEVICE_MANAGED) {
 865                 struct mlx4_ib_steering *ib_steering;
 866
 867                 mutex_lock(&mqp->mutex);
 868                 list_for_each_entry(ib_steering, &mqp->steering_rules, list) {
 869                         if (!memcmp(ib_steering->gid.raw, gid->raw, 16)) {
 870                                 list_del(&ib_steering->list);
 871                                 break;
 872                         }
 873                 }
 874                 mutex_unlock(&mqp->mutex);
 875                 if (&ib_steering->list == &mqp->steering_rules) {
 876                         pr_err("Couldn't find reg_id for mgid. Steering rule is left attached\n");
 877                         return -EINVAL;
 878                 }
 879                 reg_id = ib_steering->reg_id;
 880                 kfree(ib_steering);
 881         }
 882
 883         err = mlx4_multicast_detach(mdev->dev, &mqp->mqp, gid->raw,
 884                                     MLX4_PROT_IB_IPV6, reg_id);
 885         if (err)
 886                 return err;
 887
 888         mutex_lock(&mqp->mutex);
 889         ge = find_gid_entry(mqp, gid->raw);
 890         if (ge) {
 891                 spin_lock(&mdev->iboe.lock);
 892                 ndev = ge->added ? mdev->iboe.netdevs[ge->port - 1] : NULL;
 893                 if (ndev)
 894                         dev_hold(ndev);
 895                 spin_unlock(&mdev->iboe.lock);
 896                 rdma_get_mcast_mac((struct in6_addr *)gid, mac);
 897                 if (ndev) {
 898                         rtnl_lock();
 899                         dev_mc_del(mdev->iboe.netdevs[ge->port - 1], mac);
 900                         rtnl_unlock();
 901                         dev_put(ndev);
 902                 }
 903                 list_del(&ge->list);
 904                 kfree(ge);
 905         } else
 906                 pr_warn("could not find mgid entry\n");
 907
 908         mutex_unlock(&mqp->mutex);
 909
 910         return 0;
 911 }
 912
 913 static int init_node_data(struct mlx4_ib_dev *dev)
 914 {
 915         struct ib_smp *in_mad  = NULL;
 916         struct ib_smp *out_mad = NULL;
 917         int mad_ifc_flags = MLX4_MAD_IFC_IGNORE_KEYS;
 918         int err = -ENOMEM;
 919
 920         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
 921         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
 922         if (!in_mad || !out_mad)
 923                 goto out;
 924
 925         init_query_mad(in_mad);
 926         in_mad->attr_id = IB_SMP_ATTR_NODE_DESC;
 927         if (mlx4_is_master(dev->dev))
 928                 mad_ifc_flags |= MLX4_MAD_IFC_NET_VIEW;
 929
 930         err = mlx4_MAD_IFC(dev, mad_ifc_flags, 1, NULL, NULL, in_mad, out_mad);
 931         if (err)
 932                 goto out;
 933
 934         memcpy(dev->ib_dev.node_desc, out_mad->data, 64);
 935
 936         in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
 937
 938         err = mlx4_MAD_IFC(dev, mad_ifc_flags, 1, NULL, NULL, in_mad, out_mad);
 939         if (err)
 940                 goto out;
 941
 942         dev->dev->rev_id = be32_to_cpup((__be32 *) (out_mad->data + 32));
 943         memcpy(&dev->ib_dev.node_guid, out_mad->data + 12, 8);
 944
 945 out:
 946         kfree(in_mad);
 947         kfree(out_mad);
 948         return err;
 949 }
 950
 951 static ssize_t show_hca(struct device *device, struct device_attribute *attr,
 952                         char *buf)
 953 {
 954         struct mlx4_ib_dev *dev =
 955                 container_of(device, struct mlx4_ib_dev, ib_dev.dev);
 956         return sprintf(buf, "MT%d\n", dev->dev->pdev->device);
 957 }
 958
 959 static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr,
 960                            char *buf)
 961 {
 962         struct mlx4_ib_dev *dev =
 963                 container_of(device, struct mlx4_ib_dev, ib_dev.dev);
 964         return sprintf(buf, "%d.%d.%d\n", (int) (dev->dev->caps.fw_ver >> 32),
 965                        (int) (dev->dev->caps.fw_ver >> 16) & 0xffff,
 966                        (int) dev->dev->caps.fw_ver & 0xffff);
 967 }
 968
 969 static ssize_t show_rev(struct device *device, struct device_attribute *attr,
 970                         char *buf)
 971 {
 972         struct mlx4_ib_dev *dev =
 973                 container_of(device, struct mlx4_ib_dev, ib_dev.dev);
 974         return sprintf(buf, "%x\n", dev->dev->rev_id);
 975 }
 976
 977 static ssize_t show_board(struct device *device, struct device_attribute *attr,
 978                           char *buf)
 979 {
 980         struct mlx4_ib_dev *dev =
 981                 container_of(device, struct mlx4_ib_dev, ib_dev.dev);
 982         return sprintf(buf, "%.*s\n", MLX4_BOARD_ID_LEN,
 983                        dev->dev->board_id);
 984 }
 985
 986 static DEVICE_ATTR(hw_rev,   S_IRUGO, show_rev,    NULL);
 987 static DEVICE_ATTR(fw_ver,   S_IRUGO, show_fw_ver, NULL);
 988 static DEVICE_ATTR(hca_type, S_IRUGO, show_hca,    NULL);
 989 static DEVICE_ATTR(board_id, S_IRUGO, show_board,  NULL);
 990
 991 static struct device_attribute *mlx4_class_attributes[] = {
 992         &dev_attr_hw_rev,
 993         &dev_attr_fw_ver,
 994         &dev_attr_hca_type,
 995         &dev_attr_board_id
 996 };
 997
 998 static void mlx4_addrconf_ifid_eui48(u8 *eui, u16 vlan_id, struct net_device *dev)
 999 {
1000         memcpy(eui, dev->dev_addr, 3);
1001         memcpy(eui + 5, dev->dev_addr + 3, 3);
1002         if (vlan_id < 0x1000) {
1003                 eui[3] = vlan_id >> 8;
1004                 eui[4] = vlan_id & 0xff;
1005         } else {
1006                 eui[3] = 0xff;
1007                 eui[4] = 0xfe;
1008         }
1009         eui[0] ^= 2;
1010 }
1011
1012 static void update_gids_task(struct work_struct *work)
1013 {
1014         struct update_gid_work *gw = container_of(work, struct update_gid_work, work);
1015         struct mlx4_cmd_mailbox *mailbox;
1016         union ib_gid *gids;
1017         int err;
1018         struct mlx4_dev *dev = gw->dev->dev;
1019
1020         mailbox = mlx4_alloc_cmd_mailbox(dev);
1021         if (IS_ERR(mailbox)) {
1022                 pr_warn("update gid table failed %ld\n", PTR_ERR(mailbox));
1023                 return;
1024         }
1025
1026         gids = mailbox->buf;
1027         memcpy(gids, gw->gids, sizeof gw->gids);
1028
1029         err = mlx4_cmd(dev, mailbox->dma, MLX4_SET_PORT_GID_TABLE << 8 | gw->port,
1030                        1, MLX4_CMD_SET_PORT, MLX4_CMD_TIME_CLASS_B,
1031                        MLX4_CMD_WRAPPED);
1032         if (err)
1033                 pr_warn("set port command failed\n");
1034         else {
1035                 memcpy(gw->dev->iboe.gid_table[gw->port - 1], gw->gids, sizeof gw->gids);
1036                 mlx4_ib_dispatch_event(gw->dev, gw->port, IB_EVENT_GID_CHANGE);
1037         }
1038
1039         mlx4_free_cmd_mailbox(dev, mailbox);
1040         kfree(gw);
1041 }
1042
1043 static int update_ipv6_gids(struct mlx4_ib_dev *dev, int port, int clear)
1044 {
1045         struct net_device *ndev = dev->iboe.netdevs[port - 1];
1046         struct update_gid_work *work;
1047         struct net_device *tmp;
1048         int i;
1049         u8 *hits;
1050         int ret;
1051         union ib_gid gid;
1052         int free;
1053         int found;
1054         int need_update = 0;
1055         u16 vid;
1056
1057         work = kzalloc(sizeof *work, GFP_ATOMIC);
1058         if (!work)
1059                 return -ENOMEM;
1060
1061         hits = kzalloc(128, GFP_ATOMIC);
1062         if (!hits) {
1063                 ret = -ENOMEM;
1064                 goto out;
1065         }
1066
1067         rcu_read_lock();
1068         for_each_netdev_rcu(&init_net, tmp) {
1069                 if (ndev && (tmp == ndev || rdma_vlan_dev_real_dev(tmp) == ndev)) {
1070                         gid.global.subnet_prefix = cpu_to_be64(0xfe80000000000000LL);
1071                         vid = rdma_vlan_dev_vlan_id(tmp);
1072                         mlx4_addrconf_ifid_eui48(&gid.raw[8], vid, ndev);
1073                         found = 0;
1074                         free = -1;
1075                         for (i = 0; i < 128; ++i) {
1076                                 if (free < 0 &&
1077                                     !memcmp(&dev->iboe.gid_table[port - 1][i], &zgid, sizeof zgid))
1078                                         free = i;
1079                                 if (!memcmp(&dev->iboe.gid_table[port - 1][i], &gid, sizeof gid)) {
1080                                         hits[i] = 1;
1081                                         found = 1;
1082                                         break;
1083                                 }
1084                         }
1085
1086                         if (!found) {
1087                                 if (tmp == ndev &&
1088                                     (memcmp(&dev->iboe.gid_table[port - 1][0],
1089                                             &gid, sizeof gid) ||
1090                                      !memcmp(&dev->iboe.gid_table[port - 1][0],
1091                                              &zgid, sizeof gid))) {
1092                                         dev->iboe.gid_table[port - 1][0] = gid;
1093                                         ++need_update;
1094                                         hits[0] = 1;
1095                                 } else if (free >= 0) {
1096                                         dev->iboe.gid_table[port - 1][free] = gid;
1097                                         hits[free] = 1;
1098                                         ++need_update;
1099                                 }
1100                         }
1101                 }
1102         }
1103         rcu_read_unlock();
1104
1105         for (i = 0; i < 128; ++i)
1106                 if (!hits[i]) {
1107                         if (memcmp(&dev->iboe.gid_table[port - 1][i], &zgid, sizeof zgid))
1108                                 ++need_update;
1109                         dev->iboe.gid_table[port - 1][i] = zgid;
1110                 }
1111
1112         if (need_update) {
1113                 memcpy(work->gids, dev->iboe.gid_table[port - 1], sizeof work->gids);
1114                 INIT_WORK(&work->work, update_gids_task);
1115                 work->port = port;
1116                 work->dev = dev;
1117                 queue_work(wq, &work->work);
1118         } else
1119                 kfree(work);
1120
1121         kfree(hits);
1122         return 0;
1123
1124 out:
1125         kfree(work);
1126         return ret;
1127 }
1128
1129 static void handle_en_event(struct mlx4_ib_dev *dev, int port, unsigned long event)
1130 {
1131         switch (event) {
1132         case NETDEV_UP:
1133         case NETDEV_CHANGEADDR:
1134                 update_ipv6_gids(dev, port, 0);
1135                 break;
1136
1137         case NETDEV_DOWN:
1138                 update_ipv6_gids(dev, port, 1);
1139                 dev->iboe.netdevs[port - 1] = NULL;
1140         }
1141 }
1142
1143 static void netdev_added(struct mlx4_ib_dev *dev, int port)
1144 {
1145         update_ipv6_gids(dev, port, 0);
1146 }
1147
1148 static void netdev_removed(struct mlx4_ib_dev *dev, int port)
1149 {
1150         update_ipv6_gids(dev, port, 1);
1151 }
1152
1153 static int mlx4_ib_netdev_event(struct notifier_block *this, unsigned long event,
1154                                 void *ptr)
1155 {
1156         struct net_device *dev = ptr;
1157         struct mlx4_ib_dev *ibdev;
1158         struct net_device *oldnd;
1159         struct mlx4_ib_iboe *iboe;
1160         int port;
1161
1162         if (!net_eq(dev_net(dev), &init_net))
1163                 return NOTIFY_DONE;
1164
1165         ibdev = container_of(this, struct mlx4_ib_dev, iboe.nb);
1166         iboe = &ibdev->iboe;
1167
1168         spin_lock(&iboe->lock);
1169         mlx4_foreach_ib_transport_port(port, ibdev->dev) {
1170                 oldnd = iboe->netdevs[port - 1];
1171                 iboe->netdevs[port - 1] =
1172                         mlx4_get_protocol_dev(ibdev->dev, MLX4_PROT_ETH, port);
1173                 if (oldnd != iboe->netdevs[port - 1]) {
1174                         if (iboe->netdevs[port - 1])
1175                                 netdev_added(ibdev, port);
1176                         else
1177                                 netdev_removed(ibdev, port);
1178                 }
1179         }
1180
1181         if (dev == iboe->netdevs[0] ||
1182             (iboe->netdevs[0] && rdma_vlan_dev_real_dev(dev) == iboe->netdevs[0]))
1183                 handle_en_event(ibdev, 1, event);
1184         else if (dev == iboe->netdevs[1]
1185                  || (iboe->netdevs[1] && rdma_vlan_dev_real_dev(dev) == iboe->netdevs[1]))
1186                 handle_en_event(ibdev, 2, event);
1187
1188         spin_unlock(&iboe->lock);
1189
1190         return NOTIFY_DONE;
1191 }
1192
1193 static void init_pkeys(struct mlx4_ib_dev *ibdev)
1194 {
1195         int port;
1196         int slave;
1197         int i;
1198
1199         if (mlx4_is_master(ibdev->dev)) {
1200                 for (slave = 0; slave <= ibdev->dev->num_vfs; ++slave) {
1201                         for (port = 1; port <= ibdev->dev->caps.num_ports; ++port) {
1202                                 for (i = 0;
1203                                      i < ibdev->dev->phys_caps.pkey_phys_table_len[port];
1204                                      ++i) {
1205                                         ibdev->pkeys.virt2phys_pkey[slave][port - 1][i] =
1206                                         /* master has the identity virt2phys pkey mapping */
1207                                                 (slave == mlx4_master_func_num(ibdev->dev) || !i) ? i :
1208                                                         ibdev->dev->phys_caps.pkey_phys_table_len[port] - 1;
1209                                         mlx4_sync_pkey_table(ibdev->dev, slave, port, i,
1210                                                              ibdev->pkeys.virt2phys_pkey[slave][port - 1][i]);
1211                                 }
1212                         }
1213                 }
1214                 /* initialize pkey cache */
1215                 for (port = 1; port <= ibdev->dev->caps.num_ports; ++port) {
1216                         for (i = 0;
1217                              i < ibdev->dev->phys_caps.pkey_phys_table_len[port];
1218                              ++i)
1219                                 ibdev->pkeys.phys_pkey_cache[port-1][i] =
1220                                         (i) ? 0 : 0xFFFF;
1221                 }
1222         }
1223 }
1224
1225 static void mlx4_ib_alloc_eqs(struct mlx4_dev *dev, struct mlx4_ib_dev *ibdev)
1226 {
1227         char name[32];
1228         int eq_per_port = 0;
1229         int added_eqs = 0;
1230         int total_eqs = 0;
1231         int i, j, eq;
1232
1233         /* Legacy mode or comp_pool is not large enough */
1234         if (dev->caps.comp_pool == 0 ||
1235             dev->caps.num_ports > dev->caps.comp_pool)
1236                 return;
1237
1238         eq_per_port = rounddown_pow_of_two(dev->caps.comp_pool/
1239                                         dev->caps.num_ports);
1240
1241         /* Init eq table */
1242         added_eqs = 0;
1243         mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB)
1244                 added_eqs += eq_per_port;
1245
1246         total_eqs = dev->caps.num_comp_vectors + added_eqs;
1247
1248         ibdev->eq_table = kzalloc(total_eqs * sizeof(int), GFP_KERNEL);
1249         if (!ibdev->eq_table)
1250                 return;
1251
1252         ibdev->eq_added = added_eqs;
1253
1254         eq = 0;
1255         mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB) {
1256                 for (j = 0; j < eq_per_port; j++) {
1257                         sprintf(name, "mlx4-ib-%d-%d@%s",
1258                                 i, j, dev->pdev->bus->name);
1259                         /* Set IRQ for specific name (per ring) */
1260                         if (mlx4_assign_eq(dev, name, NULL,
1261                                            &ibdev->eq_table[eq])) {
1262                                 /* Use legacy (same as mlx4_en driver) */
1263                                 pr_warn("Can't allocate EQ %d; reverting to legacy\n", eq);
1264                                 ibdev->eq_table[eq] =
1265                                         (eq % dev->caps.num_comp_vectors);
1266                         }
1267                         eq++;
1268                 }
1269         }
1270
1271         /* Fill the reset of the vector with legacy EQ */
1272         for (i = 0, eq = added_eqs; i < dev->caps.num_comp_vectors; i++)
1273                 ibdev->eq_table[eq++] = i;
1274
1275         /* Advertise the new number of EQs to clients */
1276         ibdev->ib_dev.num_comp_vectors = total_eqs;
1277 }
1278
1279 static void mlx4_ib_free_eqs(struct mlx4_dev *dev, struct mlx4_ib_dev *ibdev)
1280 {
1281         int i;
1282
1283         /* no additional eqs were added */
1284         if (!ibdev->eq_table)
1285                 return;
1286
1287         /* Reset the advertised EQ number */
1288         ibdev->ib_dev.num_comp_vectors = dev->caps.num_comp_vectors;
1289
1290         /* Free only the added eqs */
1291         for (i = 0; i < ibdev->eq_added; i++) {
1292                 /* Don't free legacy eqs if used */
1293                 if (ibdev->eq_table[i] <= dev->caps.num_comp_vectors)
1294                         continue;
1295                 mlx4_release_eq(dev, ibdev->eq_table[i]);
1296         }
1297
1298         kfree(ibdev->eq_table);
1299 }
1300
1301 static void *mlx4_ib_add(struct mlx4_dev *dev)
1302 {
1303         struct mlx4_ib_dev *ibdev;
1304         int num_ports = 0;
1305         int i, j;
1306         int err;
1307         struct mlx4_ib_iboe *iboe;
1308
1309         pr_info_once("%s", mlx4_ib_version);
1310
1311         mlx4_foreach_non_ib_transport_port(i, dev)
1312                 num_ports++;
1313
1314         if (mlx4_is_mfunc(dev) && num_ports) {
1315                 dev_err(&dev->pdev->dev, "RoCE is not supported over SRIOV as yet\n");
1316                 return NULL;
1317         }
1318
1319         num_ports = 0;
1320         mlx4_foreach_ib_transport_port(i, dev)
1321                 num_ports++;
1322
1323         /* No point in registering a device with no ports... */
1324         if (num_ports == 0)
1325                 return NULL;
1326
1327         ibdev = (struct mlx4_ib_dev *) ib_alloc_device(sizeof *ibdev);
1328         if (!ibdev) {
1329                 dev_err(&dev->pdev->dev, "Device struct alloc failed\n");
1330                 return NULL;
1331         }
1332
1333         iboe = &ibdev->iboe;
1334
1335         if (mlx4_pd_alloc(dev, &ibdev->priv_pdn))
1336                 goto err_dealloc;
1337
1338         if (mlx4_uar_alloc(dev, &ibdev->priv_uar))
1339                 goto err_pd;
1340
1341         ibdev->uar_map = ioremap((phys_addr_t) ibdev->priv_uar.pfn << PAGE_SHIFT,
1342                                  PAGE_SIZE);
1343         if (!ibdev->uar_map)
1344                 goto err_uar;
1345         MLX4_INIT_DOORBELL_LOCK(&ibdev->uar_lock);
1346
1347         ibdev->dev = dev;
1348
1349         strlcpy(ibdev->ib_dev.name, "mlx4_%d", IB_DEVICE_NAME_MAX);
1350         ibdev->ib_dev.owner             = THIS_MODULE;
1351         ibdev->ib_dev.node_type         = RDMA_NODE_IB_CA;
1352         ibdev->ib_dev.local_dma_lkey    = dev->caps.reserved_lkey;
1353         ibdev->num_ports                = num_ports;
1354         ibdev->ib_dev.phys_port_cnt     = ibdev->num_ports;
1355         ibdev->ib_dev.num_comp_vectors  = dev->caps.num_comp_vectors;
1356         ibdev->ib_dev.dma_device        = &dev->pdev->dev;
1357
1358         if (dev->caps.userspace_caps)
1359                 ibdev->ib_dev.uverbs_abi_ver = MLX4_IB_UVERBS_ABI_VERSION;
1360         else
1361                 ibdev->ib_dev.uverbs_abi_ver = MLX4_IB_UVERBS_NO_DEV_CAPS_ABI_VERSION;
1362
1363         ibdev->ib_dev.uverbs_cmd_mask   =
1364                 (1ull << IB_USER_VERBS_CMD_GET_CONTEXT)         |
1365                 (1ull << IB_USER_VERBS_CMD_QUERY_DEVICE)        |
1366                 (1ull << IB_USER_VERBS_CMD_QUERY_PORT)          |
1367                 (1ull << IB_USER_VERBS_CMD_ALLOC_PD)            |
1368                 (1ull << IB_USER_VERBS_CMD_DEALLOC_PD)          |
1369                 (1ull << IB_USER_VERBS_CMD_REG_MR)              |
1370                 (1ull << IB_USER_VERBS_CMD_DEREG_MR)            |
1371                 (1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) |
1372                 (1ull << IB_USER_VERBS_CMD_CREATE_CQ)           |
1373                 (1ull << IB_USER_VERBS_CMD_RESIZE_CQ)           |
1374                 (1ull << IB_USER_VERBS_CMD_DESTROY_CQ)          |
1375                 (1ull << IB_USER_VERBS_CMD_CREATE_QP)           |
1376                 (1ull << IB_USER_VERBS_CMD_MODIFY_QP)           |
1377                 (1ull << IB_USER_VERBS_CMD_QUERY_QP)            |
1378                 (1ull << IB_USER_VERBS_CMD_DESTROY_QP)          |
1379                 (1ull << IB_USER_VERBS_CMD_ATTACH_MCAST)        |
1380                 (1ull << IB_USER_VERBS_CMD_DETACH_MCAST)        |
1381                 (1ull << IB_USER_VERBS_CMD_CREATE_SRQ)          |
1382                 (1ull << IB_USER_VERBS_CMD_MODIFY_SRQ)          |
1383                 (1ull << IB_USER_VERBS_CMD_QUERY_SRQ)           |
1384                 (1ull << IB_USER_VERBS_CMD_DESTROY_SRQ)         |
1385                 (1ull << IB_USER_VERBS_CMD_CREATE_XSRQ)         |
1386                 (1ull << IB_USER_VERBS_CMD_OPEN_QP);
1387
1388         ibdev->ib_dev.query_device      = mlx4_ib_query_device;
1389         ibdev->ib_dev.query_port        = mlx4_ib_query_port;
1390         ibdev->ib_dev.get_link_layer    = mlx4_ib_port_link_layer;
1391         ibdev->ib_dev.query_gid         = mlx4_ib_query_gid;
1392         ibdev->ib_dev.query_pkey        = mlx4_ib_query_pkey;
1393         ibdev->ib_dev.modify_device     = mlx4_ib_modify_device;
1394         ibdev->ib_dev.modify_port       = mlx4_ib_modify_port;
1395         ibdev->ib_dev.alloc_ucontext    = mlx4_ib_alloc_ucontext;
1396         ibdev->ib_dev.dealloc_ucontext  = mlx4_ib_dealloc_ucontext;
1397         ibdev->ib_dev.mmap              = mlx4_ib_mmap;
1398         ibdev->ib_dev.alloc_pd          = mlx4_ib_alloc_pd;
1399         ibdev->ib_dev.dealloc_pd        = mlx4_ib_dealloc_pd;
1400         ibdev->ib_dev.create_ah         = mlx4_ib_create_ah;
1401         ibdev->ib_dev.query_ah          = mlx4_ib_query_ah;
1402         ibdev->ib_dev.destroy_ah        = mlx4_ib_destroy_ah;
1403         ibdev->ib_dev.create_srq        = mlx4_ib_create_srq;
1404         ibdev->ib_dev.modify_srq        = mlx4_ib_modify_srq;
1405         ibdev->ib_dev.query_srq         = mlx4_ib_query_srq;
1406         ibdev->ib_dev.destroy_srq       = mlx4_ib_destroy_srq;
1407         ibdev->ib_dev.post_srq_recv     = mlx4_ib_post_srq_recv;
1408         ibdev->ib_dev.create_qp         = mlx4_ib_create_qp;
1409         ibdev->ib_dev.modify_qp         = mlx4_ib_modify_qp;
1410         ibdev->ib_dev.query_qp          = mlx4_ib_query_qp;
1411         ibdev->ib_dev.destroy_qp        = mlx4_ib_destroy_qp;
1412         ibdev->ib_dev.post_send         = mlx4_ib_post_send;
1413         ibdev->ib_dev.post_recv         = mlx4_ib_post_recv;
1414         ibdev->ib_dev.create_cq         = mlx4_ib_create_cq;
1415         ibdev->ib_dev.modify_cq         = mlx4_ib_modify_cq;
1416         ibdev->ib_dev.resize_cq         = mlx4_ib_resize_cq;
1417         ibdev->ib_dev.destroy_cq        = mlx4_ib_destroy_cq;
1418         ibdev->ib_dev.poll_cq           = mlx4_ib_poll_cq;
1419         ibdev->ib_dev.req_notify_cq     = mlx4_ib_arm_cq;
1420         ibdev->ib_dev.get_dma_mr        = mlx4_ib_get_dma_mr;
1421         ibdev->ib_dev.reg_user_mr       = mlx4_ib_reg_user_mr;
1422         ibdev->ib_dev.dereg_mr          = mlx4_ib_dereg_mr;
1423         ibdev->ib_dev.alloc_fast_reg_mr = mlx4_ib_alloc_fast_reg_mr;
1424         ibdev->ib_dev.alloc_fast_reg_page_list = mlx4_ib_alloc_fast_reg_page_list;
1425         ibdev->ib_dev.free_fast_reg_page_list  = mlx4_ib_free_fast_reg_page_list;
1426         ibdev->ib_dev.attach_mcast      = mlx4_ib_mcg_attach;
1427         ibdev->ib_dev.detach_mcast      = mlx4_ib_mcg_detach;
1428         ibdev->ib_dev.process_mad       = mlx4_ib_process_mad;
1429
1430         if (!mlx4_is_slave(ibdev->dev)) {
1431                 ibdev->ib_dev.alloc_fmr         = mlx4_ib_fmr_alloc;
1432                 ibdev->ib_dev.map_phys_fmr      = mlx4_ib_map_phys_fmr;
1433                 ibdev->ib_dev.unmap_fmr         = mlx4_ib_unmap_fmr;
1434                 ibdev->ib_dev.dealloc_fmr       = mlx4_ib_fmr_dealloc;
1435         }
1436
1437         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_XRC) {
1438                 ibdev->ib_dev.alloc_xrcd = mlx4_ib_alloc_xrcd;
1439                 ibdev->ib_dev.dealloc_xrcd = mlx4_ib_dealloc_xrcd;
1440                 ibdev->ib_dev.uverbs_cmd_mask |=
1441                         (1ull << IB_USER_VERBS_CMD_OPEN_XRCD) |
1442                         (1ull << IB_USER_VERBS_CMD_CLOSE_XRCD);
1443         }
1444
1445         mlx4_ib_alloc_eqs(dev, ibdev);
1446
1447         spin_lock_init(&iboe->lock);
1448
1449         if (init_node_data(ibdev))
1450                 goto err_map;
1451
1452         for (i = 0; i < ibdev->num_ports; ++i) {
1453                 if (mlx4_ib_port_link_layer(&ibdev->ib_dev, i + 1) ==
1454                                                 IB_LINK_LAYER_ETHERNET) {
1455                         err = mlx4_counter_alloc(ibdev->dev, &ibdev->counters[i]);
1456                         if (err)
1457                                 ibdev->counters[i] = -1;
1458                 } else
1459                                 ibdev->counters[i] = -1;
1460         }
1461
1462         spin_lock_init(&ibdev->sm_lock);
1463         mutex_init(&ibdev->cap_mask_mutex);
1464
1465         if (ib_register_device(&ibdev->ib_dev, NULL))
1466                 goto err_counter;
1467
1468         if (mlx4_ib_mad_init(ibdev))
1469                 goto err_reg;
1470
1471         if (mlx4_ib_init_sriov(ibdev))
1472                 goto err_mad;
1473
1474         if (dev->caps.flags & MLX4_DEV_CAP_FLAG_IBOE && !iboe->nb.notifier_call) {
1475                 iboe->nb.notifier_call = mlx4_ib_netdev_event;
1476                 err = register_netdevice_notifier(&iboe->nb);
1477                 if (err)
1478                         goto err_sriov;
1479         }
1480
1481         for (j = 0; j < ARRAY_SIZE(mlx4_class_attributes); ++j) {
1482                 if (device_create_file(&ibdev->ib_dev.dev,
1483                                        mlx4_class_attributes[j]))
1484                         goto err_notif;
1485         }
1486
1487         ibdev->ib_active = true;
1488
1489         if (mlx4_is_mfunc(ibdev->dev))
1490                 init_pkeys(ibdev);
1491
1492         /* create paravirt contexts for any VFs which are active */
1493         if (mlx4_is_master(ibdev->dev)) {
1494                 for (j = 0; j < MLX4_MFUNC_MAX; j++) {
1495                         if (j == mlx4_master_func_num(ibdev->dev))
1496                                 continue;
1497                         if (mlx4_is_slave_active(ibdev->dev, j))
1498                                 do_slave_init(ibdev, j, 1);
1499                 }
1500         }
1501         return ibdev;
1502
1503 err_notif:
1504         if (unregister_netdevice_notifier(&ibdev->iboe.nb))
1505                 pr_warn("failure unregistering notifier\n");
1506         flush_workqueue(wq);
1507
1508 err_sriov:
1509         mlx4_ib_close_sriov(ibdev);
1510
1511 err_mad:
1512         mlx4_ib_mad_cleanup(ibdev);
1513
1514 err_reg:
1515         ib_unregister_device(&ibdev->ib_dev);
1516
1517 err_counter:
1518         for (; i; --i)
1519                 if (ibdev->counters[i - 1] != -1)
1520                         mlx4_counter_free(ibdev->dev, ibdev->counters[i - 1]);
1521
1522 err_map:
1523         iounmap(ibdev->uar_map);
1524
1525 err_uar:
1526         mlx4_uar_free(dev, &ibdev->priv_uar);
1527
1528 err_pd:
1529         mlx4_pd_free(dev, ibdev->priv_pdn);
1530
1531 err_dealloc:
1532         ib_dealloc_device(&ibdev->ib_dev);
1533
1534         return NULL;
1535 }
1536
1537 static void mlx4_ib_remove(struct mlx4_dev *dev, void *ibdev_ptr)
1538 {
1539         struct mlx4_ib_dev *ibdev = ibdev_ptr;
1540         int p;
1541
1542         mlx4_ib_close_sriov(ibdev);
1543         mlx4_ib_mad_cleanup(ibdev);
1544         ib_unregister_device(&ibdev->ib_dev);
1545         if (ibdev->iboe.nb.notifier_call) {
1546                 if (unregister_netdevice_notifier(&ibdev->iboe.nb))
1547                         pr_warn("failure unregistering notifier\n");
1548                 ibdev->iboe.nb.notifier_call = NULL;
1549         }
1550         iounmap(ibdev->uar_map);
1551         for (p = 0; p < ibdev->num_ports; ++p)
1552                 if (ibdev->counters[p] != -1)
1553                         mlx4_counter_free(ibdev->dev, ibdev->counters[p]);
1554         mlx4_foreach_port(p, dev, MLX4_PORT_TYPE_IB)
1555                 mlx4_CLOSE_PORT(dev, p);
1556
1557         mlx4_ib_free_eqs(dev, ibdev);
1558
1559         mlx4_uar_free(dev, &ibdev->priv_uar);
1560         mlx4_pd_free(dev, ibdev->priv_pdn);
1561         ib_dealloc_device(&ibdev->ib_dev);
1562 }
1563
1564 static void do_slave_init(struct mlx4_ib_dev *ibdev, int slave, int do_init)
1565 {
1566         struct mlx4_ib_demux_work **dm = NULL;
1567         struct mlx4_dev *dev = ibdev->dev;
1568         int i;
1569         unsigned long flags;
1570
1571         if (!mlx4_is_master(dev))
1572                 return;
1573
1574         dm = kcalloc(dev->caps.num_ports, sizeof *dm, GFP_ATOMIC);
1575         if (!dm) {
1576                 pr_err("failed to allocate memory for tunneling qp update\n");
1577                 goto out;
1578         }
1579
1580         for (i = 0; i < dev->caps.num_ports; i++) {
1581                 dm[i] = kmalloc(sizeof (struct mlx4_ib_demux_work), GFP_ATOMIC);
1582                 if (!dm[i]) {
1583                         pr_err("failed to allocate memory for tunneling qp update work struct\n");
1584                         for (i = 0; i < dev->caps.num_ports; i++) {
1585                                 if (dm[i])
1586                                         kfree(dm[i]);
1587                         }
1588                         goto out;
1589                 }
1590         }
1591         /* initialize or tear down tunnel QPs for the slave */
1592         for (i = 0; i < dev->caps.num_ports; i++) {
1593                 INIT_WORK(&dm[i]->work, mlx4_ib_tunnels_update_work);
1594                 dm[i]->port = i + 1;
1595                 dm[i]->slave = slave;
1596                 dm[i]->do_init = do_init;
1597                 dm[i]->dev = ibdev;
1598                 spin_lock_irqsave(&ibdev->sriov.going_down_lock, flags);
1599                 if (!ibdev->sriov.is_going_down)
1600                         queue_work(ibdev->sriov.demux[i].ud_wq, &dm[i]->work);
1601                 spin_unlock_irqrestore(&ibdev->sriov.going_down_lock, flags);
1602         }
1603 out:
1604         if (dm)
1605                 kfree(dm);
1606         return;
1607 }
1608
1609 static void mlx4_ib_event(struct mlx4_dev *dev, void *ibdev_ptr,
1610                           enum mlx4_dev_event event, unsigned long param)
1611 {
1612         struct ib_event ibev;
1613         struct mlx4_ib_dev *ibdev = to_mdev((struct ib_device *) ibdev_ptr);
1614         struct mlx4_eqe *eqe = NULL;
1615         struct ib_event_work *ew;
1616         int p = 0;
1617
1618         if (event == MLX4_DEV_EVENT_PORT_MGMT_CHANGE)
1619                 eqe = (struct mlx4_eqe *)param;
1620         else
1621                 p = (int) param;
1622
1623         switch (event) {
1624         case MLX4_DEV_EVENT_PORT_UP:
1625                 if (p > ibdev->num_ports)
1626                         return;
1627                 if (mlx4_is_master(dev) &&
1628                     rdma_port_get_link_layer(&ibdev->ib_dev, p) ==
1629                         IB_LINK_LAYER_INFINIBAND) {
1630                         mlx4_ib_invalidate_all_guid_record(ibdev, p);
1631                 }
1632                 ibev.event = IB_EVENT_PORT_ACTIVE;
1633                 break;
1634
1635         case MLX4_DEV_EVENT_PORT_DOWN:
1636                 if (p > ibdev->num_ports)
1637                         return;
1638                 ibev.event = IB_EVENT_PORT_ERR;
1639                 break;
1640
1641         case MLX4_DEV_EVENT_CATASTROPHIC_ERROR:
1642                 ibdev->ib_active = false;
1643                 ibev.event = IB_EVENT_DEVICE_FATAL;
1644                 break;
1645
1646         case MLX4_DEV_EVENT_PORT_MGMT_CHANGE:
1647                 ew = kmalloc(sizeof *ew, GFP_ATOMIC);
1648                 if (!ew) {
1649                         pr_err("failed to allocate memory for events work\n");
1650                         break;
1651                 }
1652
1653                 INIT_WORK(&ew->work, handle_port_mgmt_change_event);
1654                 memcpy(&ew->ib_eqe, eqe, sizeof *eqe);
1655                 ew->ib_dev = ibdev;
1656                 /* need to queue only for port owner, which uses GEN_EQE */
1657                 if (mlx4_is_master(dev))
1658                         queue_work(wq, &ew->work);
1659                 else
1660                         handle_port_mgmt_change_event(&ew->work);
1661                 return;
1662
1663         case MLX4_DEV_EVENT_SLAVE_INIT:
1664                 /* here, p is the slave id */
1665                 do_slave_init(ibdev, p, 1);
1666                 return;
1667
1668         case MLX4_DEV_EVENT_SLAVE_SHUTDOWN:
1669                 /* here, p is the slave id */
1670                 do_slave_init(ibdev, p, 0);
1671                 return;
1672
1673         default:
1674                 return;
1675         }
1676
1677         ibev.device           = ibdev_ptr;
1678         ibev.element.port_num = (u8) p;
1679
1680         ib_dispatch_event(&ibev);
1681 }
1682
1683 static struct mlx4_interface mlx4_ib_interface = {
1684         .add            = mlx4_ib_add,
1685         .remove         = mlx4_ib_remove,
1686         .event          = mlx4_ib_event,
1687         .protocol       = MLX4_PROT_IB_IPV6
1688 };
1689
1690 static int __init mlx4_ib_init(void)
1691 {
1692         int err;
1693
1694         wq = create_singlethread_workqueue("mlx4_ib");
1695         if (!wq)
1696                 return -ENOMEM;
1697
1698         err = mlx4_ib_mcg_init();
1699         if (err)
1700                 goto clean_wq;
1701
1702         err = mlx4_register_interface(&mlx4_ib_interface);
1703         if (err)
1704                 goto clean_mcg;
1705
1706         return 0;
1707
1708 clean_mcg:
1709         mlx4_ib_mcg_destroy();
1710
1711 clean_wq:
1712         destroy_workqueue(wq);
1713         return err;
1714 }
1715
1716 static void __exit mlx4_ib_cleanup(void)
1717 {
1718         mlx4_unregister_interface(&mlx4_ib_interface);
1719         mlx4_ib_mcg_destroy();
1720         destroy_workqueue(wq);
1721 }
1722
1723 module_init(mlx4_ib_init);
1724 module_exit(mlx4_ib_cleanup);