[net-next-2.6.git] / drivers / infiniband / hw / mlx4 / main.c

/*
 * Copyright (c) 2006, 2007 Cisco Systems, Inc. All rights reserved.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/errno.h>

#include <rdma/ib_smi.h>
#include <rdma/ib_user_verbs.h>

#include <linux/mlx4/driver.h>
#include <linux/mlx4/cmd.h>

#include "mlx4_ib.h"
#include "user.h"

#define DRV_NAME	"mlx4_ib"
#define DRV_VERSION	"0.01"
#define DRV_RELDATE	"May 1, 2006"

MODULE_AUTHOR("Roland Dreier");
MODULE_DESCRIPTION("Mellanox ConnectX HCA InfiniBand driver");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_VERSION(DRV_VERSION);

static const char mlx4_ib_version[] __devinitdata =
	DRV_NAME ": Mellanox ConnectX InfiniBand driver v"
	DRV_VERSION " (" DRV_RELDATE ")\n";

static void init_query_mad(struct ib_smp *mad)
{
	mad->base_version  = 1;
	mad->mgmt_class    = IB_MGMT_CLASS_SUBN_LID_ROUTED;
	mad->class_version = 1;
	mad->method	   = IB_MGMT_METHOD_GET;
}

static int mlx4_ib_query_device(struct ib_device *ibdev,
				struct ib_device_attr *props)
{
	struct mlx4_ib_dev *dev = to_mdev(ibdev);
	struct ib_smp *in_mad  = NULL;
	struct ib_smp *out_mad = NULL;
	int err = -ENOMEM;

	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
	if (!in_mad || !out_mad)
		goto out;

	init_query_mad(in_mad);
	in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;

	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, 1, NULL, NULL, in_mad, out_mad);
	if (err)
		goto out;

	memset(props, 0, sizeof *props);

	props->fw_ver = dev->dev->caps.fw_ver;
	props->device_cap_flags    = IB_DEVICE_CHANGE_PHY_PORT |
		IB_DEVICE_PORT_ACTIVE_EVENT		|
		IB_DEVICE_SYS_IMAGE_GUID		|
		IB_DEVICE_RC_RNR_NAK_GEN;
	if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_BAD_PKEY_CNTR)
		props->device_cap_flags |= IB_DEVICE_BAD_PKEY_CNTR;
	if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_BAD_QKEY_CNTR)
		props->device_cap_flags |= IB_DEVICE_BAD_QKEY_CNTR;
	if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_APM)
		props->device_cap_flags |= IB_DEVICE_AUTO_PATH_MIG;
	if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_UD_AV_PORT)
		props->device_cap_flags |= IB_DEVICE_UD_AV_PORT_ENFORCE;

	props->vendor_id	   = be32_to_cpup((__be32 *) (out_mad->data + 36)) &
		0xffffff;
	props->vendor_part_id	   = be16_to_cpup((__be16 *) (out_mad->data + 30));
	props->hw_ver		   = be32_to_cpup((__be32 *) (out_mad->data + 32));
	memcpy(&props->sys_image_guid, out_mad->data +	4, 8);

	props->max_mr_size	   = ~0ull;
	props->page_size_cap	   = dev->dev->caps.page_size_cap;
	props->max_qp		   = dev->dev->caps.num_qps - dev->dev->caps.reserved_qps;
	props->max_qp_wr	   = dev->dev->caps.max_wqes;
	props->max_sge		   = min(dev->dev->caps.max_sq_sg,
					 dev->dev->caps.max_rq_sg);
	props->max_cq		   = dev->dev->caps.num_cqs - dev->dev->caps.reserved_cqs;
	props->max_cqe		   = dev->dev->caps.max_cqes;
	props->max_mr		   = dev->dev->caps.num_mpts - dev->dev->caps.reserved_mrws;
	props->max_pd		   = dev->dev->caps.num_pds - dev->dev->caps.reserved_pds;
	props->max_qp_rd_atom	   = dev->dev->caps.max_qp_dest_rdma;
	props->max_qp_init_rd_atom = dev->dev->caps.max_qp_init_rdma;
	props->max_res_rd_atom	   = props->max_qp_rd_atom * props->max_qp;
	props->max_srq		   = dev->dev->caps.num_srqs - dev->dev->caps.reserved_srqs;
	props->max_srq_wr	   = dev->dev->caps.max_srq_wqes;
	props->max_srq_sge	   = dev->dev->caps.max_srq_sge;
	props->local_ca_ack_delay  = dev->dev->caps.local_ca_ack_delay;
	props->atomic_cap	   = dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_ATOMIC ?
		IB_ATOMIC_HCA : IB_ATOMIC_NONE;
	props->max_pkeys	   = dev->dev->caps.pkey_table_len;
	props->max_mcast_grp	   = dev->dev->caps.num_mgms + dev->dev->caps.num_amgms;
	props->max_mcast_qp_attach = dev->dev->caps.num_qp_per_mgm;
	props->max_total_mcast_qp_attach = props->max_mcast_qp_attach *
					   props->max_mcast_grp;
	props->max_map_per_fmr = (1 << (32 - ilog2(dev->dev->caps.num_mpts))) - 1;

out:
	kfree(in_mad);
	kfree(out_mad);

	return err;
}

static int mlx4_ib_query_port(struct ib_device *ibdev, u8 port,
			      struct ib_port_attr *props)
{
	struct ib_smp *in_mad  = NULL;
	struct ib_smp *out_mad = NULL;
	int err = -ENOMEM;

	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
	if (!in_mad || !out_mad)
		goto out;

	memset(props, 0, sizeof *props);

	init_query_mad(in_mad);
	in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
	in_mad->attr_mod = cpu_to_be32(port);

	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
	if (err)
		goto out;

	props->lid		= be16_to_cpup((__be16 *) (out_mad->data + 16));
	props->lmc		= out_mad->data[34] & 0x7;
	props->sm_lid		= be16_to_cpup((__be16 *) (out_mad->data + 18));
	props->sm_sl		= out_mad->data[36] & 0xf;
	props->state		= out_mad->data[32] & 0xf;
	props->phys_state	= out_mad->data[33] >> 4;
	props->port_cap_flags	= be32_to_cpup((__be32 *) (out_mad->data + 20));
	props->gid_tbl_len	= to_mdev(ibdev)->dev->caps.gid_table_len;
	props->max_msg_sz	= 0x80000000;
	props->pkey_tbl_len	= to_mdev(ibdev)->dev->caps.pkey_table_len;
	props->bad_pkey_cntr	= be16_to_cpup((__be16 *) (out_mad->data + 46));
	props->qkey_viol_cntr	= be16_to_cpup((__be16 *) (out_mad->data + 48));
	props->active_width	= out_mad->data[31] & 0xf;
	props->active_speed	= out_mad->data[35] >> 4;
	props->max_mtu		= out_mad->data[41] & 0xf;
	props->active_mtu	= out_mad->data[36] >> 4;
	props->subnet_timeout	= out_mad->data[51] & 0x1f;
	props->max_vl_num	= out_mad->data[37] >> 4;
	props->init_type_reply	= out_mad->data[41] >> 4;

out:
	kfree(in_mad);
	kfree(out_mad);

	return err;
}

static int mlx4_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
			     union ib_gid *gid)
{
	struct ib_smp *in_mad  = NULL;
	struct ib_smp *out_mad = NULL;
	int err = -ENOMEM;

	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
	if (!in_mad || !out_mad)
		goto out;

	init_query_mad(in_mad);
	in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
	in_mad->attr_mod = cpu_to_be32(port);

	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
	if (err)
		goto out;

	memcpy(gid->raw, out_mad->data + 8, 8);

	init_query_mad(in_mad);
	in_mad->attr_id  = IB_SMP_ATTR_GUID_INFO;
	in_mad->attr_mod = cpu_to_be32(index / 8);

	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
	if (err)
		goto out;

	memcpy(gid->raw + 8, out_mad->data + (index % 8) * 8, 8);

out:
	kfree(in_mad);
	kfree(out_mad);
	return err;
}

static int mlx4_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
			      u16 *pkey)
{
	struct ib_smp *in_mad  = NULL;
	struct ib_smp *out_mad = NULL;
	int err = -ENOMEM;

	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
	if (!in_mad || !out_mad)
		goto out;

	init_query_mad(in_mad);
	in_mad->attr_id  = IB_SMP_ATTR_PKEY_TABLE;
	in_mad->attr_mod = cpu_to_be32(index / 32);

	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
	if (err)
		goto out;

	*pkey = be16_to_cpu(((__be16 *) out_mad->data)[index % 32]);

out:
	kfree(in_mad);
	kfree(out_mad);
	return err;
}

static int mlx4_ib_modify_device(struct ib_device *ibdev, int mask,
				 struct ib_device_modify *props)
{
	if (mask & ~IB_DEVICE_MODIFY_NODE_DESC)
		return -EOPNOTSUPP;

	if (mask & IB_DEVICE_MODIFY_NODE_DESC) {
		spin_lock(&to_mdev(ibdev)->sm_lock);
		memcpy(ibdev->node_desc, props->node_desc, 64);
		spin_unlock(&to_mdev(ibdev)->sm_lock);
	}

	return 0;
}

static int mlx4_SET_PORT(struct mlx4_ib_dev *dev, u8 port, int reset_qkey_viols,
			 u32 cap_mask)
{
	struct mlx4_cmd_mailbox *mailbox;
	int err;

	mailbox = mlx4_alloc_cmd_mailbox(dev->dev);
	if (IS_ERR(mailbox))
		return PTR_ERR(mailbox);

	memset(mailbox->buf, 0, 256);
	*(u8 *) mailbox->buf	     = !!reset_qkey_viols << 6;
	((__be32 *) mailbox->buf)[2] = cpu_to_be32(cap_mask);

	err = mlx4_cmd(dev->dev, mailbox->dma, port, 0, MLX4_CMD_SET_PORT,
		       MLX4_CMD_TIME_CLASS_B);

	mlx4_free_cmd_mailbox(dev->dev, mailbox);
	return err;
}

static int mlx4_ib_modify_port(struct ib_device *ibdev, u8 port, int mask,
			       struct ib_port_modify *props)
{
	struct ib_port_attr attr;
	u32 cap_mask;
	int err;

	mutex_lock(&to_mdev(ibdev)->cap_mask_mutex);

	err = mlx4_ib_query_port(ibdev, port, &attr);
	if (err)
		goto out;

	cap_mask = (attr.port_cap_flags | props->set_port_cap_mask) &
		~props->clr_port_cap_mask;

	err = mlx4_SET_PORT(to_mdev(ibdev), port,
			    !!(mask & IB_PORT_RESET_QKEY_CNTR),
			    cap_mask);

out:
	mutex_unlock(&to_mdev(ibdev)->cap_mask_mutex);
	return err;
}

static struct ib_ucontext *mlx4_ib_alloc_ucontext(struct ib_device *ibdev,
						  struct ib_udata *udata)
{
	struct mlx4_ib_dev *dev = to_mdev(ibdev);
	struct mlx4_ib_ucontext *context;
	struct mlx4_ib_alloc_ucontext_resp resp;
	int err;

	resp.qp_tab_size      = dev->dev->caps.num_qps;
	resp.bf_reg_size      = dev->dev->caps.bf_reg_size;
	resp.bf_regs_per_page = dev->dev->caps.bf_regs_per_page;

	context = kmalloc(sizeof *context, GFP_KERNEL);
	if (!context)
		return ERR_PTR(-ENOMEM);

	err = mlx4_uar_alloc(to_mdev(ibdev)->dev, &context->uar);
	if (err) {
		kfree(context);
		return ERR_PTR(err);
	}

	INIT_LIST_HEAD(&context->db_page_list);
	mutex_init(&context->db_page_mutex);

	err = ib_copy_to_udata(udata, &resp, sizeof resp);
	if (err) {
		mlx4_uar_free(to_mdev(ibdev)->dev, &context->uar);
		kfree(context);
		return ERR_PTR(-EFAULT);
	}

	return &context->ibucontext;
}

static int mlx4_ib_dealloc_ucontext(struct ib_ucontext *ibcontext)
{
	struct mlx4_ib_ucontext *context = to_mucontext(ibcontext);

	mlx4_uar_free(to_mdev(ibcontext->device)->dev, &context->uar);
	kfree(context);

	return 0;
}

static int mlx4_ib_mmap(struct ib_ucontext *context, struct vm_area_struct *vma)
{
	struct mlx4_ib_dev *dev = to_mdev(context->device);

	if (vma->vm_end - vma->vm_start != PAGE_SIZE)
		return -EINVAL;

	if (vma->vm_pgoff == 0) {
		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

		if (io_remap_pfn_range(vma, vma->vm_start,
				       to_mucontext(context)->uar.pfn,
				       PAGE_SIZE, vma->vm_page_prot))
			return -EAGAIN;
	} else if (vma->vm_pgoff == 1 && dev->dev->caps.bf_reg_size != 0) {
		/* FIXME want pgprot_writecombine() for BlueFlame pages */
		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

		if (io_remap_pfn_range(vma, vma->vm_start,
				       to_mucontext(context)->uar.pfn +
				       dev->dev->caps.num_uars,
				       PAGE_SIZE, vma->vm_page_prot))
			return -EAGAIN;
	} else
		return -EINVAL;

	return 0;
}

static struct ib_pd *mlx4_ib_alloc_pd(struct ib_device *ibdev,
				      struct ib_ucontext *context,
				      struct ib_udata *udata)
{
	struct mlx4_ib_pd *pd;
	int err;

	pd = kmalloc(sizeof *pd, GFP_KERNEL);
	if (!pd)
		return ERR_PTR(-ENOMEM);

	err = mlx4_pd_alloc(to_mdev(ibdev)->dev, &pd->pdn);
	if (err) {
		kfree(pd);
		return ERR_PTR(err);
	}

	if (context)
		if (ib_copy_to_udata(udata, &pd->pdn, sizeof (__u32))) {
			mlx4_pd_free(to_mdev(ibdev)->dev, pd->pdn);
			kfree(pd);
			return ERR_PTR(-EFAULT);
		}

	return &pd->ibpd;
}

static int mlx4_ib_dealloc_pd(struct ib_pd *pd)
{
	mlx4_pd_free(to_mdev(pd->device)->dev, to_mpd(pd)->pdn);
	kfree(pd);

	return 0;
}

static int mlx4_ib_mcg_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
{
	return mlx4_multicast_attach(to_mdev(ibqp->device)->dev,
				     &to_mqp(ibqp)->mqp, gid->raw);
}

static int mlx4_ib_mcg_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
{
	return mlx4_multicast_detach(to_mdev(ibqp->device)->dev,
				     &to_mqp(ibqp)->mqp, gid->raw);
}

static int init_node_data(struct mlx4_ib_dev *dev)
{
	struct ib_smp *in_mad  = NULL;
	struct ib_smp *out_mad = NULL;
	int err = -ENOMEM;

	in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
	if (!in_mad || !out_mad)
		goto out;

	init_query_mad(in_mad);
	in_mad->attr_id = IB_SMP_ATTR_NODE_DESC;

	err = mlx4_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
	if (err)
		goto out;

	memcpy(dev->ib_dev.node_desc, out_mad->data, 64);

	in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;

	err = mlx4_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
	if (err)
		goto out;

	memcpy(&dev->ib_dev.node_guid, out_mad->data + 12, 8);

out:
	kfree(in_mad);
	kfree(out_mad);
	return err;
}

static void *mlx4_ib_add(struct mlx4_dev *dev)
{
	struct mlx4_ib_dev *ibdev;

	ibdev = (struct mlx4_ib_dev *) ib_alloc_device(sizeof *ibdev);
	if (!ibdev) {
		dev_err(&dev->pdev->dev, "Device struct alloc failed\n");
		return NULL;
	}

	if (mlx4_pd_alloc(dev, &ibdev->priv_pdn))
		goto err_dealloc;

	if (mlx4_uar_alloc(dev, &ibdev->priv_uar))
		goto err_pd;

	ibdev->uar_map = ioremap(ibdev->priv_uar.pfn << PAGE_SHIFT, PAGE_SIZE);
	if (!ibdev->uar_map)
		goto err_uar;

	INIT_LIST_HEAD(&ibdev->pgdir_list);
	mutex_init(&ibdev->pgdir_mutex);

	ibdev->dev = dev;

	strlcpy(ibdev->ib_dev.name, "mlx4_%d", IB_DEVICE_NAME_MAX);
	ibdev->ib_dev.owner		= THIS_MODULE;
	ibdev->ib_dev.node_type		= RDMA_NODE_IB_CA;
	ibdev->ib_dev.phys_port_cnt	= dev->caps.num_ports;
	ibdev->ib_dev.num_comp_vectors	= 1;
	ibdev->ib_dev.dma_device	= &dev->pdev->dev;

	ibdev->ib_dev.uverbs_abi_ver	= MLX4_IB_UVERBS_ABI_VERSION;
	ibdev->ib_dev.uverbs_cmd_mask	=
		(1ull << IB_USER_VERBS_CMD_GET_CONTEXT)		|
		(1ull << IB_USER_VERBS_CMD_QUERY_DEVICE)	|
		(1ull << IB_USER_VERBS_CMD_QUERY_PORT)		|
		(1ull << IB_USER_VERBS_CMD_ALLOC_PD)		|
		(1ull << IB_USER_VERBS_CMD_DEALLOC_PD)		|
		(1ull << IB_USER_VERBS_CMD_REG_MR)		|
		(1ull << IB_USER_VERBS_CMD_DEREG_MR)		|
		(1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL)	|
		(1ull << IB_USER_VERBS_CMD_CREATE_CQ)		|
		(1ull << IB_USER_VERBS_CMD_DESTROY_CQ)		|
		(1ull << IB_USER_VERBS_CMD_CREATE_QP)		|
		(1ull << IB_USER_VERBS_CMD_MODIFY_QP)		|
		(1ull << IB_USER_VERBS_CMD_DESTROY_QP)		|
		(1ull << IB_USER_VERBS_CMD_ATTACH_MCAST)	|
		(1ull << IB_USER_VERBS_CMD_DETACH_MCAST)	|
		(1ull << IB_USER_VERBS_CMD_CREATE_SRQ)		|
		(1ull << IB_USER_VERBS_CMD_MODIFY_SRQ)		|
		(1ull << IB_USER_VERBS_CMD_DESTROY_SRQ);

	ibdev->ib_dev.query_device	= mlx4_ib_query_device;
	ibdev->ib_dev.query_port	= mlx4_ib_query_port;
	ibdev->ib_dev.query_gid		= mlx4_ib_query_gid;
	ibdev->ib_dev.query_pkey	= mlx4_ib_query_pkey;
	ibdev->ib_dev.modify_device	= mlx4_ib_modify_device;
	ibdev->ib_dev.modify_port	= mlx4_ib_modify_port;
	ibdev->ib_dev.alloc_ucontext	= mlx4_ib_alloc_ucontext;
	ibdev->ib_dev.dealloc_ucontext	= mlx4_ib_dealloc_ucontext;
	ibdev->ib_dev.mmap		= mlx4_ib_mmap;
	ibdev->ib_dev.alloc_pd		= mlx4_ib_alloc_pd;
	ibdev->ib_dev.dealloc_pd	= mlx4_ib_dealloc_pd;
	ibdev->ib_dev.create_ah		= mlx4_ib_create_ah;
	ibdev->ib_dev.query_ah		= mlx4_ib_query_ah;
	ibdev->ib_dev.destroy_ah	= mlx4_ib_destroy_ah;
	ibdev->ib_dev.create_srq	= mlx4_ib_create_srq;
	ibdev->ib_dev.modify_srq	= mlx4_ib_modify_srq;
	ibdev->ib_dev.destroy_srq	= mlx4_ib_destroy_srq;
	ibdev->ib_dev.post_srq_recv	= mlx4_ib_post_srq_recv;
	ibdev->ib_dev.create_qp		= mlx4_ib_create_qp;
	ibdev->ib_dev.modify_qp		= mlx4_ib_modify_qp;
	ibdev->ib_dev.destroy_qp	= mlx4_ib_destroy_qp;
	ibdev->ib_dev.post_send		= mlx4_ib_post_send;
	ibdev->ib_dev.post_recv		= mlx4_ib_post_recv;
	ibdev->ib_dev.create_cq		= mlx4_ib_create_cq;
	ibdev->ib_dev.destroy_cq	= mlx4_ib_destroy_cq;
	ibdev->ib_dev.poll_cq		= mlx4_ib_poll_cq;
	ibdev->ib_dev.req_notify_cq	= mlx4_ib_arm_cq;
	ibdev->ib_dev.get_dma_mr	= mlx4_ib_get_dma_mr;
	ibdev->ib_dev.reg_user_mr	= mlx4_ib_reg_user_mr;
	ibdev->ib_dev.dereg_mr		= mlx4_ib_dereg_mr;
	ibdev->ib_dev.attach_mcast	= mlx4_ib_mcg_attach;
	ibdev->ib_dev.detach_mcast	= mlx4_ib_mcg_detach;
	ibdev->ib_dev.process_mad	= mlx4_ib_process_mad;

	if (init_node_data(ibdev))
		goto err_map;

	spin_lock_init(&ibdev->sm_lock);
	mutex_init(&ibdev->cap_mask_mutex);

	if (ib_register_device(&ibdev->ib_dev))
		goto err_map;

	if (mlx4_ib_mad_init(ibdev))
		goto err_reg;

	return ibdev;

err_reg:
	ib_unregister_device(&ibdev->ib_dev);

err_map:
	iounmap(ibdev->uar_map);

err_uar:
	mlx4_uar_free(dev, &ibdev->priv_uar);

err_pd:
	mlx4_pd_free(dev, ibdev->priv_pdn);

err_dealloc:
	ib_dealloc_device(&ibdev->ib_dev);

	return NULL;
}

static void mlx4_ib_remove(struct mlx4_dev *dev, void *ibdev_ptr)
{
	struct mlx4_ib_dev *ibdev = ibdev_ptr;
	int p;

	for (p = 1; p <= dev->caps.num_ports; ++p)
		mlx4_CLOSE_PORT(dev, p);

	mlx4_ib_mad_cleanup(ibdev);
	ib_unregister_device(&ibdev->ib_dev);
	iounmap(ibdev->uar_map);
	mlx4_uar_free(dev, &ibdev->priv_uar);
	mlx4_pd_free(dev, ibdev->priv_pdn);
	ib_dealloc_device(&ibdev->ib_dev);
}

static void mlx4_ib_event(struct mlx4_dev *dev, void *ibdev_ptr,
			  enum mlx4_dev_event event, int subtype,
			  int port)
{
	struct ib_event ibev;

	switch (event) {
	case MLX4_EVENT_TYPE_PORT_CHANGE:
		ibev.event = subtype == MLX4_PORT_CHANGE_SUBTYPE_ACTIVE ?
			IB_EVENT_PORT_ACTIVE : IB_EVENT_PORT_ERR;
		break;

	case MLX4_EVENT_TYPE_LOCAL_CATAS_ERROR:
		ibev.event = IB_EVENT_DEVICE_FATAL;
		break;

	default:
		return;
	}

	ibev.device	      = ibdev_ptr;
	ibev.element.port_num = port;

	ib_dispatch_event(&ibev);
}

static struct mlx4_interface mlx4_ib_interface = {
	.add	= mlx4_ib_add,
	.remove	= mlx4_ib_remove,
	.event	= mlx4_ib_event
};

static int __init mlx4_ib_init(void)
{
	return mlx4_register_interface(&mlx4_ib_interface);
}

static void __exit mlx4_ib_cleanup(void)
{
	mlx4_unregister_interface(&mlx4_ib_interface);
}

module_init(mlx4_ib_init);
module_exit(mlx4_ib_cleanup);
Commit	Line	Data
225c7b1f RD	1	/*
	2	* Copyright (c) 2006, 2007 Cisco Systems, Inc. All rights reserved.
	3	*
	4	* This software is available to you under a choice of one of two
	5	* licenses. You may choose to be licensed under the terms of the GNU
	6	* General Public License (GPL) Version 2, available from the file
	7	* COPYING in the main directory of this source tree, or the
	8	* OpenIB.org BSD license below:
	9	*
	10	* Redistribution and use in source and binary forms, with or
	11	* without modification, are permitted provided that the following
	12	* conditions are met:
	13	*
	14	* - Redistributions of source code must retain the above
	15	* copyright notice, this list of conditions and the following
	16	* disclaimer.
	17	*
	18	* - Redistributions in binary form must reproduce the above
	19	* copyright notice, this list of conditions and the following
	20	* disclaimer in the documentation and/or other materials
	21	* provided with the distribution.
	22	*
	23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	24	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	25	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	26	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	27	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	28	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	29	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	30	* SOFTWARE.
	31	*/
	32
	33	#include <linux/module.h>
	34	#include <linux/init.h>
	35	#include <linux/errno.h>
	36
	37	#include <rdma/ib_smi.h>
	38	#include <rdma/ib_user_verbs.h>
	39
	40	#include <linux/mlx4/driver.h>
	41	#include <linux/mlx4/cmd.h>
	42
	43	#include "mlx4_ib.h"
	44	#include "user.h"
	45
	46	#define DRV_NAME "mlx4_ib"
	47	#define DRV_VERSION "0.01"
	48	#define DRV_RELDATE "May 1, 2006"
	49
	50	MODULE_AUTHOR("Roland Dreier");
	51	MODULE_DESCRIPTION("Mellanox ConnectX HCA InfiniBand driver");
	52	MODULE_LICENSE("Dual BSD/GPL");
	53	MODULE_VERSION(DRV_VERSION);
	54
	55	static const char mlx4_ib_version[] __devinitdata =
	56	DRV_NAME ": Mellanox ConnectX InfiniBand driver v"
	57	DRV_VERSION " (" DRV_RELDATE ")\n";
	58
	59	static void init_query_mad(struct ib_smp *mad)
	60	{
	61	mad->base_version = 1;
	62	mad->mgmt_class = IB_MGMT_CLASS_SUBN_LID_ROUTED;
	63	mad->class_version = 1;
	64	mad->method = IB_MGMT_METHOD_GET;
65	}
66
67	static int mlx4_ib_query_device(struct ib_device *ibdev,
68	struct ib_device_attr *props)
69	{
70	struct mlx4_ib_dev *dev = to_mdev(ibdev);
71	struct ib_smp *in_mad = NULL;
72	struct ib_smp *out_mad = NULL;
73	int err = -ENOMEM;
74
75	in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
76	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
77	if (!in_mad \|\| !out_mad)
78	goto out;
79
80	init_query_mad(in_mad);
81	in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
82
83	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, 1, NULL, NULL, in_mad, out_mad);
84	if (err)
85	goto out;
86
87	memset(props, 0, sizeof *props);
88
89	props->fw_ver = dev->dev->caps.fw_ver;
90	props->device_cap_flags = IB_DEVICE_CHANGE_PHY_PORT \|
91	IB_DEVICE_PORT_ACTIVE_EVENT \|
92	IB_DEVICE_SYS_IMAGE_GUID \|
93	IB_DEVICE_RC_RNR_NAK_GEN;
94	if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_BAD_PKEY_CNTR)
95	props->device_cap_flags \|= IB_DEVICE_BAD_PKEY_CNTR;
96	if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_BAD_QKEY_CNTR)
97	props->device_cap_flags \|= IB_DEVICE_BAD_QKEY_CNTR;
98	if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_APM)
99	props->device_cap_flags \|= IB_DEVICE_AUTO_PATH_MIG;
100	if (dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_UD_AV_PORT)
101	props->device_cap_flags \|= IB_DEVICE_UD_AV_PORT_ENFORCE;
102
103	props->vendor_id = be32_to_cpup((__be32 *) (out_mad->data + 36)) &
104	0xffffff;
105	props->vendor_part_id = be16_to_cpup((__be16 *) (out_mad->data + 30));
106	props->hw_ver = be32_to_cpup((__be32 *) (out_mad->data + 32));
107	memcpy(&props->sys_image_guid, out_mad->data + 4, 8);
108
109	props->max_mr_size = ~0ull;
110	props->page_size_cap = dev->dev->caps.page_size_cap;
111	props->max_qp = dev->dev->caps.num_qps - dev->dev->caps.reserved_qps;
112	props->max_qp_wr = dev->dev->caps.max_wqes;
113	props->max_sge = min(dev->dev->caps.max_sq_sg,
114	dev->dev->caps.max_rq_sg);
115	props->max_cq = dev->dev->caps.num_cqs - dev->dev->caps.reserved_cqs;
116	props->max_cqe = dev->dev->caps.max_cqes;
117	props->max_mr = dev->dev->caps.num_mpts - dev->dev->caps.reserved_mrws;
118	props->max_pd = dev->dev->caps.num_pds - dev->dev->caps.reserved_pds;
119	props->max_qp_rd_atom = dev->dev->caps.max_qp_dest_rdma;
120	props->max_qp_init_rd_atom = dev->dev->caps.max_qp_init_rdma;
121	props->max_res_rd_atom = props->max_qp_rd_atom * props->max_qp;
122	props->max_srq = dev->dev->caps.num_srqs - dev->dev->caps.reserved_srqs;
123	props->max_srq_wr = dev->dev->caps.max_srq_wqes;
124	props->max_srq_sge = dev->dev->caps.max_srq_sge;
125	props->local_ca_ack_delay = dev->dev->caps.local_ca_ack_delay;
126	props->atomic_cap = dev->dev->caps.flags & MLX4_DEV_CAP_FLAG_ATOMIC ?
127	IB_ATOMIC_HCA : IB_ATOMIC_NONE;
128	props->max_pkeys = dev->dev->caps.pkey_table_len;
129	props->max_mcast_grp = dev->dev->caps.num_mgms + dev->dev->caps.num_amgms;
130	props->max_mcast_qp_attach = dev->dev->caps.num_qp_per_mgm;
131	props->max_total_mcast_qp_attach = props->max_mcast_qp_attach *
132	props->max_mcast_grp;
133	props->max_map_per_fmr = (1 << (32 - ilog2(dev->dev->caps.num_mpts))) - 1;
134
135	out:
136	kfree(in_mad);
137	kfree(out_mad);
138
139	return err;
140	}
141
142	static int mlx4_ib_query_port(struct ib_device *ibdev, u8 port,
143	struct ib_port_attr *props)
144	{
145	struct ib_smp *in_mad = NULL;
146	struct ib_smp *out_mad = NULL;
147	int err = -ENOMEM;
148
149	in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
150	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
151	if (!in_mad \|\| !out_mad)
152	goto out;
153
154	memset(props, 0, sizeof *props);
155
156	init_query_mad(in_mad);
157	in_mad->attr_id = IB_SMP_ATTR_PORT_INFO;
158	in_mad->attr_mod = cpu_to_be32(port);
159
160	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
161	if (err)
162	goto out;
163
164	props->lid = be16_to_cpup((__be16 *) (out_mad->data + 16));
165	props->lmc = out_mad->data[34] & 0x7;
166	props->sm_lid = be16_to_cpup((__be16 *) (out_mad->data + 18));
167	props->sm_sl = out_mad->data[36] & 0xf;
168	props->state = out_mad->data[32] & 0xf;
169	props->phys_state = out_mad->data[33] >> 4;
170	props->port_cap_flags = be32_to_cpup((__be32 *) (out_mad->data + 20));
171	props->gid_tbl_len = to_mdev(ibdev)->dev->caps.gid_table_len;
172	props->max_msg_sz = 0x80000000;
173	props->pkey_tbl_len = to_mdev(ibdev)->dev->caps.pkey_table_len;
174	props->bad_pkey_cntr = be16_to_cpup((__be16 *) (out_mad->data + 46));
175	props->qkey_viol_cntr = be16_to_cpup((__be16 *) (out_mad->data + 48));
176	props->active_width = out_mad->data[31] & 0xf;
177	props->active_speed = out_mad->data[35] >> 4;
178	props->max_mtu = out_mad->data[41] & 0xf;
179	props->active_mtu = out_mad->data[36] >> 4;
180	props->subnet_timeout = out_mad->data[51] & 0x1f;
181	props->max_vl_num = out_mad->data[37] >> 4;
182	props->init_type_reply = out_mad->data[41] >> 4;
183
184	out:
185	kfree(in_mad);
186	kfree(out_mad);
187
188	return err;
189	}
190
191	static int mlx4_ib_query_gid(struct ib_device *ibdev, u8 port, int index,
192	union ib_gid *gid)
193	{
194	struct ib_smp *in_mad = NULL;
195	struct ib_smp *out_mad = NULL;
196	int err = -ENOMEM;
197
198	in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
199	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
200	if (!in_mad \|\| !out_mad)
201	goto out;
202
203	init_query_mad(in_mad);
204	in_mad->attr_id = IB_SMP_ATTR_PORT_INFO;
205	in_mad->attr_mod = cpu_to_be32(port);
206
207	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
208	if (err)
209	goto out;
210
211	memcpy(gid->raw, out_mad->data + 8, 8);
212
213	init_query_mad(in_mad);
214	in_mad->attr_id = IB_SMP_ATTR_GUID_INFO;
215	in_mad->attr_mod = cpu_to_be32(index / 8);
216
217	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
218	if (err)
219	goto out;
220
221	memcpy(gid->raw + 8, out_mad->data + (index % 8) * 8, 8);
222
223	out:
224	kfree(in_mad);
225	kfree(out_mad);
226	return err;
227	}
228
229	static int mlx4_ib_query_pkey(struct ib_device *ibdev, u8 port, u16 index,
230	u16 *pkey)
231	{
232	struct ib_smp *in_mad = NULL;
233	struct ib_smp *out_mad = NULL;
234	int err = -ENOMEM;
235
236	in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
237	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
238	if (!in_mad \|\| !out_mad)
239	goto out;
240
241	init_query_mad(in_mad);
242	in_mad->attr_id = IB_SMP_ATTR_PKEY_TABLE;
243	in_mad->attr_mod = cpu_to_be32(index / 32);
244
245	err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
246	if (err)
247	goto out;
248
249	pkey = be16_to_cpu(((__be16 ) out_mad->data)[index % 32]);
250
251	out:
252	kfree(in_mad);
253	kfree(out_mad);
254	return err;
255	}
256
257	static int mlx4_ib_modify_device(struct ib_device *ibdev, int mask,
258	struct ib_device_modify *props)
259	{
260	if (mask & ~IB_DEVICE_MODIFY_NODE_DESC)
261	return -EOPNOTSUPP;
262
263	if (mask & IB_DEVICE_MODIFY_NODE_DESC) {
264	spin_lock(&to_mdev(ibdev)->sm_lock);
265	memcpy(ibdev->node_desc, props->node_desc, 64);
266	spin_unlock(&to_mdev(ibdev)->sm_lock);
267	}
268
269	return 0;
270	}
271
272	static int mlx4_SET_PORT(struct mlx4_ib_dev *dev, u8 port, int reset_qkey_viols,
273	u32 cap_mask)
274	{
275	struct mlx4_cmd_mailbox *mailbox;
276	int err;
277
278	mailbox = mlx4_alloc_cmd_mailbox(dev->dev);
279	if (IS_ERR(mailbox))
280	return PTR_ERR(mailbox);
281
282	memset(mailbox->buf, 0, 256);
283	(u8 ) mailbox->buf = !!reset_qkey_viols << 6;
284	((__be32 *) mailbox->buf)[2] = cpu_to_be32(cap_mask);
285
286	err = mlx4_cmd(dev->dev, mailbox->dma, port, 0, MLX4_CMD_SET_PORT,
287	MLX4_CMD_TIME_CLASS_B);
288
289	mlx4_free_cmd_mailbox(dev->dev, mailbox);
290	return err;
291	}
292
293	static int mlx4_ib_modify_port(struct ib_device *ibdev, u8 port, int mask,
294	struct ib_port_modify *props)
295	{
296	struct ib_port_attr attr;
297	u32 cap_mask;
298	int err;
299
300	mutex_lock(&to_mdev(ibdev)->cap_mask_mutex);
301
302	err = mlx4_ib_query_port(ibdev, port, &attr);
303	if (err)
304	goto out;
305
306	cap_mask = (attr.port_cap_flags \| props->set_port_cap_mask) &
307	~props->clr_port_cap_mask;
308
309	err = mlx4_SET_PORT(to_mdev(ibdev), port,
310	!!(mask & IB_PORT_RESET_QKEY_CNTR),
311	cap_mask);
312
313	out:
314	mutex_unlock(&to_mdev(ibdev)->cap_mask_mutex);
315	return err;
316	}
317
318	static struct ib_ucontext mlx4_ib_alloc_ucontext(struct ib_device ibdev,
319	struct ib_udata *udata)
320	{
321	struct mlx4_ib_dev *dev = to_mdev(ibdev);
322	struct mlx4_ib_ucontext *context;
323	struct mlx4_ib_alloc_ucontext_resp resp;
324	int err;
325
326	resp.qp_tab_size = dev->dev->caps.num_qps;
327	resp.bf_reg_size = dev->dev->caps.bf_reg_size;
328	resp.bf_regs_per_page = dev->dev->caps.bf_regs_per_page;
329
330	context = kmalloc(sizeof *context, GFP_KERNEL);
331	if (!context)
332	return ERR_PTR(-ENOMEM);
333
334	err = mlx4_uar_alloc(to_mdev(ibdev)->dev, &context->uar);
335	if (err) {
336	kfree(context);
337	return ERR_PTR(err);
338	}
339
340	INIT_LIST_HEAD(&context->db_page_list);
341	mutex_init(&context->db_page_mutex);
342
343	err = ib_copy_to_udata(udata, &resp, sizeof resp);
344	if (err) {
345	mlx4_uar_free(to_mdev(ibdev)->dev, &context->uar);
346	kfree(context);
347	return ERR_PTR(-EFAULT);
348	}
349
350	return &context->ibucontext;
351	}
352
353	static int mlx4_ib_dealloc_ucontext(struct ib_ucontext *ibcontext)
354	{
355	struct mlx4_ib_ucontext *context = to_mucontext(ibcontext);
356
357	mlx4_uar_free(to_mdev(ibcontext->device)->dev, &context->uar);
358	kfree(context);
359
360	return 0;
361	}
362
363	static int mlx4_ib_mmap(struct ib_ucontext context, struct vm_area_struct vma)
364	{
365	struct mlx4_ib_dev *dev = to_mdev(context->device);
366
367	if (vma->vm_end - vma->vm_start != PAGE_SIZE)
368	return -EINVAL;
369
370	if (vma->vm_pgoff == 0) {
371	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
372
373	if (io_remap_pfn_range(vma, vma->vm_start,
374	to_mucontext(context)->uar.pfn,
375	PAGE_SIZE, vma->vm_page_prot))
376	return -EAGAIN;
377	} else if (vma->vm_pgoff == 1 && dev->dev->caps.bf_reg_size != 0) {
378	/* FIXME want pgprot_writecombine() for BlueFlame pages */
379	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
380
381	if (io_remap_pfn_range(vma, vma->vm_start,
382	to_mucontext(context)->uar.pfn +
383	dev->dev->caps.num_uars,
384	PAGE_SIZE, vma->vm_page_prot))
385	return -EAGAIN;
386	} else
387	return -EINVAL;
388
389	return 0;
390	}
391
392	static struct ib_pd mlx4_ib_alloc_pd(struct ib_device ibdev,
393	struct ib_ucontext *context,
394	struct ib_udata *udata)
395	{
396	struct mlx4_ib_pd *pd;
397	int err;
398
399	pd = kmalloc(sizeof *pd, GFP_KERNEL);
400	if (!pd)
401	return ERR_PTR(-ENOMEM);
402
403	err = mlx4_pd_alloc(to_mdev(ibdev)->dev, &pd->pdn);
404	if (err) {
405	kfree(pd);
406	return ERR_PTR(err);
407	}
408
409	if (context)
410	if (ib_copy_to_udata(udata, &pd->pdn, sizeof (__u32))) {
411	mlx4_pd_free(to_mdev(ibdev)->dev, pd->pdn);
412	kfree(pd);
413	return ERR_PTR(-EFAULT);
414	}
415
416	return &pd->ibpd;
417	}
418
419	static int mlx4_ib_dealloc_pd(struct ib_pd *pd)
420	{
421	mlx4_pd_free(to_mdev(pd->device)->dev, to_mpd(pd)->pdn);
422	kfree(pd);
423
424	return 0;
425	}
426
427	static int mlx4_ib_mcg_attach(struct ib_qp ibqp, union ib_gid gid, u16 lid)
428	{
429	return mlx4_multicast_attach(to_mdev(ibqp->device)->dev,
430	&to_mqp(ibqp)->mqp, gid->raw);
431	}
432
433	static int mlx4_ib_mcg_detach(struct ib_qp ibqp, union ib_gid gid, u16 lid)
434	{
435	return mlx4_multicast_detach(to_mdev(ibqp->device)->dev,
436	&to_mqp(ibqp)->mqp, gid->raw);
437	}
438
439	static int init_node_data(struct mlx4_ib_dev *dev)
440	{
441	struct ib_smp *in_mad = NULL;
442	struct ib_smp *out_mad = NULL;
443	int err = -ENOMEM;
444
445	in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
446	out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
447	if (!in_mad \|\| !out_mad)
448	goto out;
449
450	init_query_mad(in_mad);
451	in_mad->attr_id = IB_SMP_ATTR_NODE_DESC;
452
453	err = mlx4_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
454	if (err)
455	goto out;
456
457	memcpy(dev->ib_dev.node_desc, out_mad->data, 64);
458
459	in_mad->attr_id = IB_SMP_ATTR_NODE_INFO;
460
461	err = mlx4_MAD_IFC(dev, 1, 1, 1, NULL, NULL, in_mad, out_mad);
462	if (err)
463	goto out;
464
465	memcpy(&dev->ib_dev.node_guid, out_mad->data + 12, 8);
466
467	out:
468	kfree(in_mad);
469	kfree(out_mad);
470	return err;
471	}
472
473	static void mlx4_ib_add(struct mlx4_dev dev)
474	{
475	struct mlx4_ib_dev *ibdev;
476
477	ibdev = (struct mlx4_ib_dev ) ib_alloc_device(sizeof ibdev);
478	if (!ibdev) {
479	dev_err(&dev->pdev->dev, "Device struct alloc failed\n");
480	return NULL;
481	}
482
483	if (mlx4_pd_alloc(dev, &ibdev->priv_pdn))
484	goto err_dealloc;
485
486	if (mlx4_uar_alloc(dev, &ibdev->priv_uar))
487	goto err_pd;
488
489	ibdev->uar_map = ioremap(ibdev->priv_uar.pfn << PAGE_SHIFT, PAGE_SIZE);
490	if (!ibdev->uar_map)
491	goto err_uar;
492
493	INIT_LIST_HEAD(&ibdev->pgdir_list);
494	mutex_init(&ibdev->pgdir_mutex);
495
496	ibdev->dev = dev;
497
498	strlcpy(ibdev->ib_dev.name, "mlx4_%d", IB_DEVICE_NAME_MAX);
499	ibdev->ib_dev.owner = THIS_MODULE;
500	ibdev->ib_dev.node_type = RDMA_NODE_IB_CA;
501	ibdev->ib_dev.phys_port_cnt = dev->caps.num_ports;
502	ibdev->ib_dev.num_comp_vectors = 1;
503	ibdev->ib_dev.dma_device = &dev->pdev->dev;
504
505	ibdev->ib_dev.uverbs_abi_ver = MLX4_IB_UVERBS_ABI_VERSION;
506	ibdev->ib_dev.uverbs_cmd_mask =
507	(1ull << IB_USER_VERBS_CMD_GET_CONTEXT) \|
508	(1ull << IB_USER_VERBS_CMD_QUERY_DEVICE) \|
509	(1ull << IB_USER_VERBS_CMD_QUERY_PORT) \|
510	(1ull << IB_USER_VERBS_CMD_ALLOC_PD) \|
511	(1ull << IB_USER_VERBS_CMD_DEALLOC_PD) \|
512	(1ull << IB_USER_VERBS_CMD_REG_MR) \|
513	(1ull << IB_USER_VERBS_CMD_DEREG_MR) \|
514	(1ull << IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL) \|
515	(1ull << IB_USER_VERBS_CMD_CREATE_CQ) \|
516	(1ull << IB_USER_VERBS_CMD_DESTROY_CQ) \|
517	(1ull << IB_USER_VERBS_CMD_CREATE_QP) \|
518	(1ull << IB_USER_VERBS_CMD_MODIFY_QP) \|
519	(1ull << IB_USER_VERBS_CMD_DESTROY_QP) \|
520	(1ull << IB_USER_VERBS_CMD_ATTACH_MCAST) \|
521	(1ull << IB_USER_VERBS_CMD_DETACH_MCAST) \|
522	(1ull << IB_USER_VERBS_CMD_CREATE_SRQ) \|
523	(1ull << IB_USER_VERBS_CMD_MODIFY_SRQ) \|
524	(1ull << IB_USER_VERBS_CMD_DESTROY_SRQ);
525
526	ibdev->ib_dev.query_device = mlx4_ib_query_device;
527	ibdev->ib_dev.query_port = mlx4_ib_query_port;
528	ibdev->ib_dev.query_gid = mlx4_ib_query_gid;
529	ibdev->ib_dev.query_pkey = mlx4_ib_query_pkey;
530	ibdev->ib_dev.modify_device = mlx4_ib_modify_device;
531	ibdev->ib_dev.modify_port = mlx4_ib_modify_port;
532	ibdev->ib_dev.alloc_ucontext = mlx4_ib_alloc_ucontext;
533	ibdev->ib_dev.dealloc_ucontext = mlx4_ib_dealloc_ucontext;
534	ibdev->ib_dev.mmap = mlx4_ib_mmap;
535	ibdev->ib_dev.alloc_pd = mlx4_ib_alloc_pd;
536	ibdev->ib_dev.dealloc_pd = mlx4_ib_dealloc_pd;
537	ibdev->ib_dev.create_ah = mlx4_ib_create_ah;
538	ibdev->ib_dev.query_ah = mlx4_ib_query_ah;
539	ibdev->ib_dev.destroy_ah = mlx4_ib_destroy_ah;
540	ibdev->ib_dev.create_srq = mlx4_ib_create_srq;
541	ibdev->ib_dev.modify_srq = mlx4_ib_modify_srq;
542	ibdev->ib_dev.destroy_srq = mlx4_ib_destroy_srq;
543	ibdev->ib_dev.post_srq_recv = mlx4_ib_post_srq_recv;
544	ibdev->ib_dev.create_qp = mlx4_ib_create_qp;
545	ibdev->ib_dev.modify_qp = mlx4_ib_modify_qp;
546	ibdev->ib_dev.destroy_qp = mlx4_ib_destroy_qp;
547	ibdev->ib_dev.post_send = mlx4_ib_post_send;
548	ibdev->ib_dev.post_recv = mlx4_ib_post_recv;
549	ibdev->ib_dev.create_cq = mlx4_ib_create_cq;
550	ibdev->ib_dev.destroy_cq = mlx4_ib_destroy_cq;
551	ibdev->ib_dev.poll_cq = mlx4_ib_poll_cq;
552	ibdev->ib_dev.req_notify_cq = mlx4_ib_arm_cq;
553	ibdev->ib_dev.get_dma_mr = mlx4_ib_get_dma_mr;
554	ibdev->ib_dev.reg_user_mr = mlx4_ib_reg_user_mr;
555	ibdev->ib_dev.dereg_mr = mlx4_ib_dereg_mr;
556	ibdev->ib_dev.attach_mcast = mlx4_ib_mcg_attach;
557	ibdev->ib_dev.detach_mcast = mlx4_ib_mcg_detach;
558	ibdev->ib_dev.process_mad = mlx4_ib_process_mad;
559
560	if (init_node_data(ibdev))
561	goto err_map;
562
563	spin_lock_init(&ibdev->sm_lock);
564	mutex_init(&ibdev->cap_mask_mutex);
565
566	if (ib_register_device(&ibdev->ib_dev))
567	goto err_map;
568
569	if (mlx4_ib_mad_init(ibdev))
570	goto err_reg;
571
572	return ibdev;
573
574	err_reg:
575	ib_unregister_device(&ibdev->ib_dev);
576
577	err_map:
578	iounmap(ibdev->uar_map);
579
580	err_uar:
581	mlx4_uar_free(dev, &ibdev->priv_uar);
582
583	err_pd:
584	mlx4_pd_free(dev, ibdev->priv_pdn);
585
586	err_dealloc:
587	ib_dealloc_device(&ibdev->ib_dev);
588
589	return NULL;
590	}
591
592	static void mlx4_ib_remove(struct mlx4_dev dev, void ibdev_ptr)
593	{
594	struct mlx4_ib_dev *ibdev = ibdev_ptr;
595	int p;
596
597	for (p = 1; p <= dev->caps.num_ports; ++p)
598	mlx4_CLOSE_PORT(dev, p);
599
600	mlx4_ib_mad_cleanup(ibdev);
601	ib_unregister_device(&ibdev->ib_dev);
602	iounmap(ibdev->uar_map);
603	mlx4_uar_free(dev, &ibdev->priv_uar);
604	mlx4_pd_free(dev, ibdev->priv_pdn);
605	ib_dealloc_device(&ibdev->ib_dev);
606	}
607
608	static void mlx4_ib_event(struct mlx4_dev dev, void ibdev_ptr,
609	enum mlx4_dev_event event, int subtype,
610	int port)
611	{
612	struct ib_event ibev;
613
614	switch (event) {
615	case MLX4_EVENT_TYPE_PORT_CHANGE:
616	ibev.event = subtype == MLX4_PORT_CHANGE_SUBTYPE_ACTIVE ?
617	IB_EVENT_PORT_ACTIVE : IB_EVENT_PORT_ERR;
618	break;
619
620	case MLX4_EVENT_TYPE_LOCAL_CATAS_ERROR:
621	ibev.event = IB_EVENT_DEVICE_FATAL;
622	break;
623
624	default:
625	return;
626	}
627
628	ibev.device = ibdev_ptr;
629	ibev.element.port_num = port;
630
631	ib_dispatch_event(&ibev);
632	}
633
634	static struct mlx4_interface mlx4_ib_interface = {
635	.add = mlx4_ib_add,
636	.remove = mlx4_ib_remove,
637	.event = mlx4_ib_event
638	};
639
640	static int __init mlx4_ib_init(void)
641	{
642	return mlx4_register_interface(&mlx4_ib_interface);
643	}
644
645	static void __exit mlx4_ib_cleanup(void)
646	{
647	mlx4_unregister_interface(&mlx4_ib_interface);
648	}
649
650	module_init(mlx4_ib_init);
651	module_exit(mlx4_ib_cleanup);