[linux-block.git] / drivers / infiniband / hw / mthca / mthca_mcg.c

/*
 * Copyright (c) 2004 Topspin Communications.  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/string.h>
#include <linux/gfp.h>

#include "mthca_dev.h"
#include "mthca_cmd.h"

struct mthca_mgm {
	__be32 next_gid_index;
	u32    reserved[3];
	u8     gid[16];
	__be32 qp[MTHCA_QP_PER_MGM];
};

static const u8 zero_gid[16];	/* automatically initialized to 0 */

/*
 * Caller must hold MCG table semaphore.  gid and mgm parameters must
 * be properly aligned for command interface.
 *
 *  Returns 0 unless a firmware command error occurs.
 *
 * If GID is found in MGM or MGM is empty, *index = *hash, *prev = -1
 * and *mgm holds MGM entry.
 *
 * if GID is found in AMGM, *index = index in AMGM, *prev = index of
 * previous entry in hash chain and *mgm holds AMGM entry.
 *
 * If no AMGM exists for given gid, *index = -1, *prev = index of last
 * entry in hash chain and *mgm holds end of hash chain.
 */
static int find_mgm(struct mthca_dev *dev,
		    u8 *gid, struct mthca_mailbox *mgm_mailbox,
		    u16 *hash, int *prev, int *index)
{
	struct mthca_mailbox *mailbox;
	struct mthca_mgm *mgm = mgm_mailbox->buf;
	u8 *mgid;
	int err;

	mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
	if (IS_ERR(mailbox))
		return -ENOMEM;
	mgid = mailbox->buf;

	memcpy(mgid, gid, 16);

	err = mthca_MGID_HASH(dev, mailbox, hash);
	if (err) {
		mthca_err(dev, "MGID_HASH failed (%d)\n", err);
		goto out;
	}

	if (0)
		mthca_dbg(dev, "Hash for %pI6 is %04x\n", gid, *hash);

	*index = *hash;
	*prev  = -1;

	do {
		err = mthca_READ_MGM(dev, *index, mgm_mailbox);
		if (err) {
			mthca_err(dev, "READ_MGM failed (%d)\n", err);
			goto out;
		}

		if (!memcmp(mgm->gid, zero_gid, 16)) {
			if (*index != *hash) {
				mthca_err(dev, "Found zero MGID in AMGM.\n");
				err = -EINVAL;
			}
			goto out;
		}

		if (!memcmp(mgm->gid, gid, 16))
			goto out;

		*prev = *index;
		*index = be32_to_cpu(mgm->next_gid_index) >> 6;
	} while (*index);

	*index = -1;

 out:
	mthca_free_mailbox(dev, mailbox);
	return err;
}

int mthca_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
{
	struct mthca_dev *dev = to_mdev(ibqp->device);
	struct mthca_mailbox *mailbox;
	struct mthca_mgm *mgm;
	u16 hash;
	int index, prev;
	int link = 0;
	int i;
	int err;

	mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
	if (IS_ERR(mailbox))
		return PTR_ERR(mailbox);
	mgm = mailbox->buf;

	mutex_lock(&dev->mcg_table.mutex);

	err = find_mgm(dev, gid->raw, mailbox, &hash, &prev, &index);
	if (err)
		goto out;

	if (index != -1) {
		if (!memcmp(mgm->gid, zero_gid, 16))
			memcpy(mgm->gid, gid->raw, 16);
	} else {
		link = 1;

		index = mthca_alloc(&dev->mcg_table.alloc);
		if (index == -1) {
			mthca_err(dev, "No AMGM entries left\n");
			err = -ENOMEM;
			goto out;
		}

		err = mthca_READ_MGM(dev, index, mailbox);
		if (err) {
			mthca_err(dev, "READ_MGM failed (%d)\n", err);
			goto out;
		}
		memset(mgm, 0, sizeof *mgm);
		memcpy(mgm->gid, gid->raw, 16);
	}

	for (i = 0; i < MTHCA_QP_PER_MGM; ++i)
		if (mgm->qp[i] == cpu_to_be32(ibqp->qp_num | (1 << 31))) {
			mthca_dbg(dev, "QP %06x already a member of MGM\n",
				  ibqp->qp_num);
			err = 0;
			goto out;
		} else if (!(mgm->qp[i] & cpu_to_be32(1 << 31))) {
			mgm->qp[i] = cpu_to_be32(ibqp->qp_num | (1 << 31));
			break;
		}

	if (i == MTHCA_QP_PER_MGM) {
		mthca_err(dev, "MGM at index %x is full.\n", index);
		err = -ENOMEM;
		goto out;
	}

	err = mthca_WRITE_MGM(dev, index, mailbox);
	if (err) {
		mthca_err(dev, "WRITE_MGM failed %d\n", err);
		err = -EINVAL;
		goto out;
	}

	if (!link)
		goto out;

	err = mthca_READ_MGM(dev, prev, mailbox);
	if (err) {
		mthca_err(dev, "READ_MGM failed %d\n", err);
		goto out;
	}

	mgm->next_gid_index = cpu_to_be32(index << 6);

	err = mthca_WRITE_MGM(dev, prev, mailbox);
	if (err)
		mthca_err(dev, "WRITE_MGM returned %d\n", err);

 out:
	if (err && link && index != -1) {
		BUG_ON(index < dev->limits.num_mgms);
		mthca_free(&dev->mcg_table.alloc, index);
	}
	mutex_unlock(&dev->mcg_table.mutex);

	mthca_free_mailbox(dev, mailbox);
	return err;
}

int mthca_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
{
	struct mthca_dev *dev = to_mdev(ibqp->device);
	struct mthca_mailbox *mailbox;
	struct mthca_mgm *mgm;
	u16 hash;
	int prev, index;
	int i, loc;
	int err;

	mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
	if (IS_ERR(mailbox))
		return PTR_ERR(mailbox);
	mgm = mailbox->buf;

	mutex_lock(&dev->mcg_table.mutex);

	err = find_mgm(dev, gid->raw, mailbox, &hash, &prev, &index);
	if (err)
		goto out;

	if (index == -1) {
		mthca_err(dev, "MGID %pI6 not found\n", gid->raw);
		err = -EINVAL;
		goto out;
	}

	for (loc = -1, i = 0; i < MTHCA_QP_PER_MGM; ++i) {
		if (mgm->qp[i] == cpu_to_be32(ibqp->qp_num | (1 << 31)))
			loc = i;
		if (!(mgm->qp[i] & cpu_to_be32(1 << 31)))
			break;
	}

	if (loc == -1) {
		mthca_err(dev, "QP %06x not found in MGM\n", ibqp->qp_num);
		err = -EINVAL;
		goto out;
	}

	mgm->qp[loc]   = mgm->qp[i - 1];
	mgm->qp[i - 1] = 0;

	err = mthca_WRITE_MGM(dev, index, mailbox);
	if (err) {
		mthca_err(dev, "WRITE_MGM returned %d\n", err);
		goto out;
	}

	if (i != 1)
		goto out;

	if (prev == -1) {
		/* Remove entry from MGM */
		int amgm_index_to_free = be32_to_cpu(mgm->next_gid_index) >> 6;
		if (amgm_index_to_free) {
			err = mthca_READ_MGM(dev, amgm_index_to_free,
					     mailbox);
			if (err) {
				mthca_err(dev, "READ_MGM returned %d\n", err);
				goto out;
			}
		} else
			memset(mgm->gid, 0, 16);

		err = mthca_WRITE_MGM(dev, index, mailbox);
		if (err) {
			mthca_err(dev, "WRITE_MGM returned %d\n", err);
			goto out;
		}
		if (amgm_index_to_free) {
			BUG_ON(amgm_index_to_free < dev->limits.num_mgms);
			mthca_free(&dev->mcg_table.alloc, amgm_index_to_free);
		}
	} else {
		/* Remove entry from AMGM */
		int curr_next_index = be32_to_cpu(mgm->next_gid_index) >> 6;
		err = mthca_READ_MGM(dev, prev, mailbox);
		if (err) {
			mthca_err(dev, "READ_MGM returned %d\n", err);
			goto out;
		}

		mgm->next_gid_index = cpu_to_be32(curr_next_index << 6);

		err = mthca_WRITE_MGM(dev, prev, mailbox);
		if (err) {
			mthca_err(dev, "WRITE_MGM returned %d\n", err);
			goto out;
		}
		BUG_ON(index < dev->limits.num_mgms);
		mthca_free(&dev->mcg_table.alloc, index);
	}

 out:
	mutex_unlock(&dev->mcg_table.mutex);

	mthca_free_mailbox(dev, mailbox);
	return err;
}

int mthca_init_mcg_table(struct mthca_dev *dev)
{
	int err;
	int table_size = dev->limits.num_mgms + dev->limits.num_amgms;

	err = mthca_alloc_init(&dev->mcg_table.alloc,
			       table_size,
			       table_size - 1,
			       dev->limits.num_mgms);
	if (err)
		return err;

	mutex_init(&dev->mcg_table.mutex);

	return 0;
}

void mthca_cleanup_mcg_table(struct mthca_dev *dev)
{
	mthca_alloc_cleanup(&dev->mcg_table.alloc);
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Copyright (c) 2004 Topspin Communications. 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.
1da177e4 LT	31	*/
1da177e4 LT	32
4e57b681	33	#include <linux/string.h>
5a0e3ad6	34	#include <linux/gfp.h>
1da177e4 LT	35
	36	#include "mthca_dev.h"
	37	#include "mthca_cmd.h"
	38
1da177e4	39	struct mthca_mgm {
97f52eb4 SH	40	__be32 next_gid_index;
	41	u32 reserved[3];
	42	u8 gid[16];
	43	__be32 qp[MTHCA_QP_PER_MGM];
1da177e4 LT	44	};
	45
	46	static const u8 zero_gid[16]; /* automatically initialized to 0 */
	47
	48	/*
	49	* Caller must hold MCG table semaphore. gid and mgm parameters must
	50	* be properly aligned for command interface.
	51	*
	52	* Returns 0 unless a firmware command error occurs.
	53	*
	54	* If GID is found in MGM or MGM is empty, index = hash, *prev = -1
	55	* and *mgm holds MGM entry.
	56	*
	57	* if GID is found in AMGM, index = index in AMGM, prev = index of
	58	* previous entry in hash chain and *mgm holds AMGM entry.
	59	*
	60	* If no AMGM exists for given gid, index = -1, prev = index of last
	61	* entry in hash chain and *mgm holds end of hash chain.
	62	*/
	63	static int find_mgm(struct mthca_dev *dev,
ed878458	64	u8 gid, struct mthca_mailbox mgm_mailbox,
1da177e4 LT	65	u16 hash, int prev, int *index)
1da177e4 LT	66	{
ed878458 RD	67	struct mthca_mailbox *mailbox;
ed878458 RD	68	struct mthca_mgm *mgm = mgm_mailbox->buf;
1da177e4 LT	69	u8 *mgid;
1da177e4 LT	70	int err;
1da177e4	71
ed878458 RD	72	mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
ed878458 RD	73	if (IS_ERR(mailbox))
1da177e4	74	return -ENOMEM;
ed878458	75	mgid = mailbox->buf;
1da177e4 LT	76
	77	memcpy(mgid, gid, 16);
	78
cdb73db0 GR	79	err = mthca_MGID_HASH(dev, mailbox, hash);
	80	if (err) {
	81	mthca_err(dev, "MGID_HASH failed (%d)\n", err);
1da177e4 LT	82	goto out;
	83	}
	84
	85	if (0)
5b095d98	86	mthca_dbg(dev, "Hash for %pI6 is %04x\n", gid, *hash);
1da177e4 LT	87
	88	index = hash;
	89	*prev = -1;
	90
	91	do {
cdb73db0 GR	92	err = mthca_READ_MGM(dev, *index, mgm_mailbox);
	93	if (err) {
	94	mthca_err(dev, "READ_MGM failed (%d)\n", err);
5ceb7455	95	goto out;
1da177e4 LT	96	}
	97
	98	if (!memcmp(mgm->gid, zero_gid, 16)) {
	99	if (index != hash) {
	100	mthca_err(dev, "Found zero MGID in AMGM.\n");
	101	err = -EINVAL;
	102	}
	103	goto out;
	104	}
	105
	106	if (!memcmp(mgm->gid, gid, 16))
	107	goto out;
	108
	109	prev = index;
5ceb7455	110	*index = be32_to_cpu(mgm->next_gid_index) >> 6;
1da177e4 LT	111	} while (*index);
	112
	113	*index = -1;
	114
	115	out:
ed878458	116	mthca_free_mailbox(dev, mailbox);
1da177e4 LT	117	return err;
	118	}
	119
	120	int mthca_multicast_attach(struct ib_qp ibqp, union ib_gid gid, u16 lid)
	121	{
	122	struct mthca_dev *dev = to_mdev(ibqp->device);
ed878458	123	struct mthca_mailbox *mailbox;
1da177e4 LT	124	struct mthca_mgm *mgm;
	125	u16 hash;
	126	int index, prev;
	127	int link = 0;
	128	int i;
	129	int err;
1da177e4	130
ed878458 RD	131	mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
	132	if (IS_ERR(mailbox))
	133	return PTR_ERR(mailbox);
	134	mgm = mailbox->buf;
1da177e4	135
fd9cfdd1	136	mutex_lock(&dev->mcg_table.mutex);
1da177e4	137
ed878458	138	err = find_mgm(dev, gid->raw, mailbox, &hash, &prev, &index);
1da177e4 LT	139	if (err)
	140	goto out;
	141
	142	if (index != -1) {
	143	if (!memcmp(mgm->gid, zero_gid, 16))
	144	memcpy(mgm->gid, gid->raw, 16);
	145	} else {
	146	link = 1;
	147
	148	index = mthca_alloc(&dev->mcg_table.alloc);
	149	if (index == -1) {
	150	mthca_err(dev, "No AMGM entries left\n");
	151	err = -ENOMEM;
	152	goto out;
	153	}
	154
cdb73db0 GR	155	err = mthca_READ_MGM(dev, index, mailbox);
	156	if (err) {
	157	mthca_err(dev, "READ_MGM failed (%d)\n", err);
1da177e4 LT	158	goto out;
1da177e4 LT	159	}
5ceb7455	160	memset(mgm, 0, sizeof *mgm);
1da177e4	161	memcpy(mgm->gid, gid->raw, 16);
1da177e4 LT	162	}
	163
	164	for (i = 0; i < MTHCA_QP_PER_MGM; ++i)
7150bf8a	165	if (mgm->qp[i] == cpu_to_be32(ibqp->qp_num \| (1 << 31))) {
2fa5e2eb	166	mthca_dbg(dev, "QP %06x already a member of MGM\n",
7150bf8a JM	167	ibqp->qp_num);
	168	err = 0;
	169	goto out;
	170	} else if (!(mgm->qp[i] & cpu_to_be32(1 << 31))) {
1da177e4 LT	171	mgm->qp[i] = cpu_to_be32(ibqp->qp_num \| (1 << 31));
	172	break;
	173	}
	174
	175	if (i == MTHCA_QP_PER_MGM) {
	176	mthca_err(dev, "MGM at index %x is full.\n", index);
	177	err = -ENOMEM;
	178	goto out;
	179	}
	180
cdb73db0 GR	181	err = mthca_WRITE_MGM(dev, index, mailbox);
	182	if (err) {
	183	mthca_err(dev, "WRITE_MGM failed %d\n", err);
1da177e4	184	err = -EINVAL;
5ceb7455	185	goto out;
1da177e4 LT	186	}
	187
	188	if (!link)
	189	goto out;
	190
cdb73db0 GR	191	err = mthca_READ_MGM(dev, prev, mailbox);
	192	if (err) {
	193	mthca_err(dev, "READ_MGM failed %d\n", err);
1da177e4 LT	194	goto out;
	195	}
	196
5ceb7455	197	mgm->next_gid_index = cpu_to_be32(index << 6);
1da177e4	198
cdb73db0	199	err = mthca_WRITE_MGM(dev, prev, mailbox);
1da177e4	200	if (err)
cdb73db0	201	mthca_err(dev, "WRITE_MGM returned %d\n", err);
1da177e4 LT	202
1da177e4 LT	203	out:
5ceb7455 JM	204	if (err && link && index != -1) {
	205	BUG_ON(index < dev->limits.num_mgms);
	206	mthca_free(&dev->mcg_table.alloc, index);
	207	}
fd9cfdd1	208	mutex_unlock(&dev->mcg_table.mutex);
e3aa31c5	209
ed878458	210	mthca_free_mailbox(dev, mailbox);
1da177e4 LT	211	return err;
	212	}
	213
	214	int mthca_multicast_detach(struct ib_qp ibqp, union ib_gid gid, u16 lid)
	215	{
	216	struct mthca_dev *dev = to_mdev(ibqp->device);
ed878458	217	struct mthca_mailbox *mailbox;
1da177e4 LT	218	struct mthca_mgm *mgm;
	219	u16 hash;
	220	int prev, index;
	221	int i, loc;
	222	int err;
1da177e4	223
ed878458 RD	224	mailbox = mthca_alloc_mailbox(dev, GFP_KERNEL);
	225	if (IS_ERR(mailbox))
	226	return PTR_ERR(mailbox);
	227	mgm = mailbox->buf;
1da177e4	228
fd9cfdd1	229	mutex_lock(&dev->mcg_table.mutex);
1da177e4	230
ed878458	231	err = find_mgm(dev, gid->raw, mailbox, &hash, &prev, &index);
1da177e4 LT	232	if (err)
	233	goto out;
	234
	235	if (index == -1) {
5b095d98	236	mthca_err(dev, "MGID %pI6 not found\n", gid->raw);
1da177e4 LT	237	err = -EINVAL;
	238	goto out;
	239	}
	240
	241	for (loc = -1, i = 0; i < MTHCA_QP_PER_MGM; ++i) {
	242	if (mgm->qp[i] == cpu_to_be32(ibqp->qp_num \| (1 << 31)))
	243	loc = i;
	244	if (!(mgm->qp[i] & cpu_to_be32(1 << 31)))
	245	break;
	246	}
	247
	248	if (loc == -1) {
	249	mthca_err(dev, "QP %06x not found in MGM\n", ibqp->qp_num);
	250	err = -EINVAL;
	251	goto out;
	252	}
	253
	254	mgm->qp[loc] = mgm->qp[i - 1];
	255	mgm->qp[i - 1] = 0;
	256
cdb73db0 GR	257	err = mthca_WRITE_MGM(dev, index, mailbox);
	258	if (err) {
	259	mthca_err(dev, "WRITE_MGM returned %d\n", err);
1da177e4 LT	260	goto out;
	261	}
	262
	263	if (i != 1)
	264	goto out;
	265
1da177e4 LT	266	if (prev == -1) {
1da177e4 LT	267	/* Remove entry from MGM */
5ceb7455 JM	268	int amgm_index_to_free = be32_to_cpu(mgm->next_gid_index) >> 6;
	269	if (amgm_index_to_free) {
	270	err = mthca_READ_MGM(dev, amgm_index_to_free,
cdb73db0 GR	271	mailbox);
	272	if (err) {
	273	mthca_err(dev, "READ_MGM returned %d\n", err);
1da177e4 LT	274	goto out;
	275	}
	276	} else
	277	memset(mgm->gid, 0, 16);
	278
cdb73db0 GR	279	err = mthca_WRITE_MGM(dev, index, mailbox);
	280	if (err) {
	281	mthca_err(dev, "WRITE_MGM returned %d\n", err);
1da177e4 LT	282	goto out;
1da177e4 LT	283	}
5ceb7455 JM	284	if (amgm_index_to_free) {
	285	BUG_ON(amgm_index_to_free < dev->limits.num_mgms);
	286	mthca_free(&dev->mcg_table.alloc, amgm_index_to_free);
	287	}
1da177e4 LT	288	} else {
1da177e4 LT	289	/* Remove entry from AMGM */
5ceb7455	290	int curr_next_index = be32_to_cpu(mgm->next_gid_index) >> 6;
cdb73db0 GR	291	err = mthca_READ_MGM(dev, prev, mailbox);
	292	if (err) {
	293	mthca_err(dev, "READ_MGM returned %d\n", err);
1da177e4 LT	294	goto out;
	295	}
	296
5ceb7455	297	mgm->next_gid_index = cpu_to_be32(curr_next_index << 6);
1da177e4	298
cdb73db0 GR	299	err = mthca_WRITE_MGM(dev, prev, mailbox);
	300	if (err) {
	301	mthca_err(dev, "WRITE_MGM returned %d\n", err);
1da177e4 LT	302	goto out;
1da177e4 LT	303	}
5ceb7455 JM	304	BUG_ON(index < dev->limits.num_mgms);
5ceb7455 JM	305	mthca_free(&dev->mcg_table.alloc, index);
1da177e4 LT	306	}
	307
	308	out:
fd9cfdd1	309	mutex_unlock(&dev->mcg_table.mutex);
e3aa31c5	310
ed878458	311	mthca_free_mailbox(dev, mailbox);
1da177e4 LT	312	return err;
	313	}
	314
f4f3d0f0	315	int mthca_init_mcg_table(struct mthca_dev *dev)
1da177e4 LT	316	{
1da177e4 LT	317	int err;
5ceb7455	318	int table_size = dev->limits.num_mgms + dev->limits.num_amgms;
1da177e4 LT	319
1da177e4 LT	320	err = mthca_alloc_init(&dev->mcg_table.alloc,
5ceb7455 JM	321	table_size,
	322	table_size - 1,
	323	dev->limits.num_mgms);
1da177e4 LT	324	if (err)
	325	return err;
	326
fd9cfdd1	327	mutex_init(&dev->mcg_table.mutex);
1da177e4 LT	328
	329	return 0;
	330	}
	331
e1f7868c	332	void mthca_cleanup_mcg_table(struct mthca_dev *dev)
1da177e4 LT	333	{
	334	mthca_alloc_cleanup(&dev->mcg_table.alloc);
	335	}