[linux-2.6-block.git] / drivers / infiniband / hw / mlx4 / mr.c

/*
 * Copyright (c) 2007 Cisco Systems, Inc. All rights reserved.
 * Copyright (c) 2007, 2008 Mellanox Technologies. 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 "mlx4_ib.h"

static u32 convert_access(int acc)
{
	return (acc & IB_ACCESS_REMOTE_ATOMIC ? MLX4_PERM_ATOMIC       : 0) |
	       (acc & IB_ACCESS_REMOTE_WRITE  ? MLX4_PERM_REMOTE_WRITE : 0) |
	       (acc & IB_ACCESS_REMOTE_READ   ? MLX4_PERM_REMOTE_READ  : 0) |
	       (acc & IB_ACCESS_LOCAL_WRITE   ? MLX4_PERM_LOCAL_WRITE  : 0) |
	       MLX4_PERM_LOCAL_READ;
}

struct ib_mr *mlx4_ib_get_dma_mr(struct ib_pd *pd, int acc)
{
	struct mlx4_ib_mr *mr;
	int err;

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

	err = mlx4_mr_alloc(to_mdev(pd->device)->dev, to_mpd(pd)->pdn, 0,
			    ~0ull, convert_access(acc), 0, 0, &mr->mmr);
	if (err)
		goto err_free;

	err = mlx4_mr_enable(to_mdev(pd->device)->dev, &mr->mmr);
	if (err)
		goto err_mr;

	mr->ibmr.rkey = mr->ibmr.lkey = mr->mmr.key;
	mr->umem = NULL;

	return &mr->ibmr;

err_mr:
	mlx4_mr_free(to_mdev(pd->device)->dev, &mr->mmr);

err_free:
	kfree(mr);

	return ERR_PTR(err);
}

int mlx4_ib_umem_write_mtt(struct mlx4_ib_dev *dev, struct mlx4_mtt *mtt,
			   struct ib_umem *umem)
{
	u64 *pages;
	struct ib_umem_chunk *chunk;
	int i, j, k;
	int n;
	int len;
	int err = 0;

	pages = (u64 *) __get_free_page(GFP_KERNEL);
	if (!pages)
		return -ENOMEM;

	i = n = 0;

	list_for_each_entry(chunk, &umem->chunk_list, list)
		for (j = 0; j < chunk->nmap; ++j) {
			len = sg_dma_len(&chunk->page_list[j]) >> mtt->page_shift;
			for (k = 0; k < len; ++k) {
				pages[i++] = sg_dma_address(&chunk->page_list[j]) +
					umem->page_size * k;
				/*
				 * Be friendly to mlx4_write_mtt() and
				 * pass it chunks of appropriate size.
				 */
				if (i == PAGE_SIZE / sizeof (u64)) {
					err = mlx4_write_mtt(dev->dev, mtt, n,
							     i, pages);
					if (err)
						goto out;
					n += i;
					i = 0;
				}
			}
		}

	if (i)
		err = mlx4_write_mtt(dev->dev, mtt, n, i, pages);

out:
	free_page((unsigned long) pages);
	return err;
}

struct ib_mr *mlx4_ib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
				  u64 virt_addr, int access_flags,
				  struct ib_udata *udata)
{
	struct mlx4_ib_dev *dev = to_mdev(pd->device);
	struct mlx4_ib_mr *mr;
	int shift;
	int err;
	int n;

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

	mr->umem = ib_umem_get(pd->uobject->context, start, length,
			       access_flags, 0);
	if (IS_ERR(mr->umem)) {
		err = PTR_ERR(mr->umem);
		goto err_free;
	}

	n = ib_umem_page_count(mr->umem);
	shift = ilog2(mr->umem->page_size);

	err = mlx4_mr_alloc(dev->dev, to_mpd(pd)->pdn, virt_addr, length,
			    convert_access(access_flags), n, shift, &mr->mmr);
	if (err)
		goto err_umem;

	err = mlx4_ib_umem_write_mtt(dev, &mr->mmr.mtt, mr->umem);
	if (err)
		goto err_mr;

	err = mlx4_mr_enable(dev->dev, &mr->mmr);
	if (err)
		goto err_mr;

	mr->ibmr.rkey = mr->ibmr.lkey = mr->mmr.key;

	return &mr->ibmr;

err_mr:
	mlx4_mr_free(to_mdev(pd->device)->dev, &mr->mmr);

err_umem:
	ib_umem_release(mr->umem);

err_free:
	kfree(mr);

	return ERR_PTR(err);
}

int mlx4_ib_dereg_mr(struct ib_mr *ibmr)
{
	struct mlx4_ib_mr *mr = to_mmr(ibmr);

	mlx4_mr_free(to_mdev(ibmr->device)->dev, &mr->mmr);
	if (mr->umem)
		ib_umem_release(mr->umem);
	kfree(mr);

	return 0;
}

struct ib_mr *mlx4_ib_alloc_fast_reg_mr(struct ib_pd *pd,
					int max_page_list_len)
{
	struct mlx4_ib_dev *dev = to_mdev(pd->device);
	struct mlx4_ib_mr *mr;
	int err;

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

	err = mlx4_mr_alloc(dev->dev, to_mpd(pd)->pdn, 0, 0, 0,
			    max_page_list_len, 0, &mr->mmr);
	if (err)
		goto err_free;

	err = mlx4_mr_enable(dev->dev, &mr->mmr);
	if (err)
		goto err_mr;

	return &mr->ibmr;

err_mr:
	mlx4_mr_free(dev->dev, &mr->mmr);

err_free:
	kfree(mr);
	return ERR_PTR(err);
}

struct ib_fast_reg_page_list *mlx4_ib_alloc_fast_reg_page_list(struct ib_device *ibdev,
							       int page_list_len)
{
	struct mlx4_ib_dev *dev = to_mdev(ibdev);
	struct mlx4_ib_fast_reg_page_list *mfrpl;
	int size = page_list_len * sizeof (u64);

	if (size > PAGE_SIZE)
		return ERR_PTR(-EINVAL);

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

	mfrpl->ibfrpl.page_list = dma_alloc_coherent(&dev->dev->pdev->dev,
						     size, &mfrpl->map,
						     GFP_KERNEL);
	if (!mfrpl->ibfrpl.page_list)
		goto err_free;

	WARN_ON(mfrpl->map & 0x3f);

	return &mfrpl->ibfrpl;

err_free:
	kfree(mfrpl);
	return ERR_PTR(-ENOMEM);
}

void mlx4_ib_free_fast_reg_page_list(struct ib_fast_reg_page_list *page_list)
{
	struct mlx4_ib_dev *dev = to_mdev(page_list->device);
	struct mlx4_ib_fast_reg_page_list *mfrpl = to_mfrpl(page_list);
	int size = page_list->max_page_list_len * sizeof (u64);

	dma_free_coherent(&dev->dev->pdev->dev, size, page_list->page_list,
			  mfrpl->map);
	kfree(mfrpl);
}

struct ib_fmr *mlx4_ib_fmr_alloc(struct ib_pd *pd, int acc,
				 struct ib_fmr_attr *fmr_attr)
{
	struct mlx4_ib_dev *dev = to_mdev(pd->device);
	struct mlx4_ib_fmr *fmr;
	int err = -ENOMEM;

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

	err = mlx4_fmr_alloc(dev->dev, to_mpd(pd)->pdn, convert_access(acc),
			     fmr_attr->max_pages, fmr_attr->max_maps,
			     fmr_attr->page_shift, &fmr->mfmr);
	if (err)
		goto err_free;

	err = mlx4_fmr_enable(to_mdev(pd->device)->dev, &fmr->mfmr);
	if (err)
		goto err_mr;

	fmr->ibfmr.rkey = fmr->ibfmr.lkey = fmr->mfmr.mr.key;

	return &fmr->ibfmr;

err_mr:
	mlx4_mr_free(to_mdev(pd->device)->dev, &fmr->mfmr.mr);

err_free:
	kfree(fmr);

	return ERR_PTR(err);
}

int mlx4_ib_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
		      int npages, u64 iova)
{
	struct mlx4_ib_fmr *ifmr = to_mfmr(ibfmr);
	struct mlx4_ib_dev *dev = to_mdev(ifmr->ibfmr.device);

	return mlx4_map_phys_fmr(dev->dev, &ifmr->mfmr, page_list, npages, iova,
				 &ifmr->ibfmr.lkey, &ifmr->ibfmr.rkey);
}

int mlx4_ib_unmap_fmr(struct list_head *fmr_list)
{
	struct ib_fmr *ibfmr;
	int err;
	struct mlx4_dev *mdev = NULL;

	list_for_each_entry(ibfmr, fmr_list, list) {
		if (mdev && to_mdev(ibfmr->device)->dev != mdev)
			return -EINVAL;
		mdev = to_mdev(ibfmr->device)->dev;
	}

	if (!mdev)
		return 0;

	list_for_each_entry(ibfmr, fmr_list, list) {
		struct mlx4_ib_fmr *ifmr = to_mfmr(ibfmr);

		mlx4_fmr_unmap(mdev, &ifmr->mfmr, &ifmr->ibfmr.lkey, &ifmr->ibfmr.rkey);
	}

	/*
	 * Make sure all MPT status updates are visible before issuing
	 * SYNC_TPT firmware command.
	 */
	wmb();

	err = mlx4_SYNC_TPT(mdev);
	if (err)
		printk(KERN_WARNING "mlx4_ib: SYNC_TPT error %d when "
		       "unmapping FMRs\n", err);

	return 0;
}

int mlx4_ib_fmr_dealloc(struct ib_fmr *ibfmr)
{
	struct mlx4_ib_fmr *ifmr = to_mfmr(ibfmr);
	struct mlx4_ib_dev *dev = to_mdev(ibfmr->device);
	int err;

	err = mlx4_fmr_free(dev->dev, &ifmr->mfmr);

	if (!err)
		kfree(ifmr);

	return err;
}
Commit	Line	Data
225c7b1f RD	1	/*
225c7b1f RD	2	* Copyright (c) 2007 Cisco Systems, Inc. All rights reserved.
51a379d0	3	* Copyright (c) 2007, 2008 Mellanox Technologies. All rights reserved.
225c7b1f RD	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 "mlx4_ib.h"
	35
	36	static u32 convert_access(int acc)
	37	{
	38	return (acc & IB_ACCESS_REMOTE_ATOMIC ? MLX4_PERM_ATOMIC : 0) \|
	39	(acc & IB_ACCESS_REMOTE_WRITE ? MLX4_PERM_REMOTE_WRITE : 0) \|
	40	(acc & IB_ACCESS_REMOTE_READ ? MLX4_PERM_REMOTE_READ : 0) \|
	41	(acc & IB_ACCESS_LOCAL_WRITE ? MLX4_PERM_LOCAL_WRITE : 0) \|
	42	MLX4_PERM_LOCAL_READ;
	43	}
	44
	45	struct ib_mr mlx4_ib_get_dma_mr(struct ib_pd pd, int acc)
	46	{
	47	struct mlx4_ib_mr *mr;
	48	int err;
	49
	50	mr = kmalloc(sizeof *mr, GFP_KERNEL);
	51	if (!mr)
	52	return ERR_PTR(-ENOMEM);
	53
	54	err = mlx4_mr_alloc(to_mdev(pd->device)->dev, to_mpd(pd)->pdn, 0,
	55	~0ull, convert_access(acc), 0, 0, &mr->mmr);
	56	if (err)
	57	goto err_free;
	58
	59	err = mlx4_mr_enable(to_mdev(pd->device)->dev, &mr->mmr);
	60	if (err)
	61	goto err_mr;
	62
	63	mr->ibmr.rkey = mr->ibmr.lkey = mr->mmr.key;
	64	mr->umem = NULL;
	65
	66	return &mr->ibmr;
	67
68	err_mr:
69	mlx4_mr_free(to_mdev(pd->device)->dev, &mr->mmr);
70
71	err_free:
72	kfree(mr);
73
74	return ERR_PTR(err);
75	}
76
77	int mlx4_ib_umem_write_mtt(struct mlx4_ib_dev dev, struct mlx4_mtt mtt,
78	struct ib_umem *umem)
79	{
80	u64 *pages;
81	struct ib_umem_chunk *chunk;
82	int i, j, k;
83	int n;
84	int len;
85	int err = 0;
86
87	pages = (u64 *) __get_free_page(GFP_KERNEL);
88	if (!pages)
89	return -ENOMEM;
90
91	i = n = 0;
92
93	list_for_each_entry(chunk, &umem->chunk_list, list)
94	for (j = 0; j < chunk->nmap; ++j) {
95	len = sg_dma_len(&chunk->page_list[j]) >> mtt->page_shift;
96	for (k = 0; k < len; ++k) {
97	pages[i++] = sg_dma_address(&chunk->page_list[j]) +
98	umem->page_size * k;
99	/*
d7bb58fb JM	100	* Be friendly to mlx4_write_mtt() and
d7bb58fb JM	101	* pass it chunks of appropriate size.
225c7b1f	102	*/
d7bb58fb	103	if (i == PAGE_SIZE / sizeof (u64)) {
225c7b1f RD	104	err = mlx4_write_mtt(dev->dev, mtt, n,
	105	i, pages);
	106	if (err)
	107	goto out;
	108	n += i;
	109	i = 0;
	110	}
	111	}
	112	}
	113
	114	if (i)
	115	err = mlx4_write_mtt(dev->dev, mtt, n, i, pages);
	116
	117	out:
	118	free_page((unsigned long) pages);
	119	return err;
	120	}
	121
	122	struct ib_mr mlx4_ib_reg_user_mr(struct ib_pd pd, u64 start, u64 length,
	123	u64 virt_addr, int access_flags,
	124	struct ib_udata *udata)
	125	{
	126	struct mlx4_ib_dev *dev = to_mdev(pd->device);
	127	struct mlx4_ib_mr *mr;
	128	int shift;
	129	int err;
	130	int n;
	131
	132	mr = kmalloc(sizeof *mr, GFP_KERNEL);
	133	if (!mr)
	134	return ERR_PTR(-ENOMEM);
	135
cb9fbc5c AK	136	mr->umem = ib_umem_get(pd->uobject->context, start, length,
cb9fbc5c AK	137	access_flags, 0);
225c7b1f RD	138	if (IS_ERR(mr->umem)) {
	139	err = PTR_ERR(mr->umem);
	140	goto err_free;
	141	}
	142
	143	n = ib_umem_page_count(mr->umem);
	144	shift = ilog2(mr->umem->page_size);
	145
	146	err = mlx4_mr_alloc(dev->dev, to_mpd(pd)->pdn, virt_addr, length,
	147	convert_access(access_flags), n, shift, &mr->mmr);
	148	if (err)
	149	goto err_umem;
	150
	151	err = mlx4_ib_umem_write_mtt(dev, &mr->mmr.mtt, mr->umem);
	152	if (err)
	153	goto err_mr;
	154
	155	err = mlx4_mr_enable(dev->dev, &mr->mmr);
	156	if (err)
	157	goto err_mr;
	158
	159	mr->ibmr.rkey = mr->ibmr.lkey = mr->mmr.key;
	160
	161	return &mr->ibmr;
	162
	163	err_mr:
	164	mlx4_mr_free(to_mdev(pd->device)->dev, &mr->mmr);
	165
	166	err_umem:
	167	ib_umem_release(mr->umem);
	168
	169	err_free:
	170	kfree(mr);
	171
	172	return ERR_PTR(err);
	173	}
	174
	175	int mlx4_ib_dereg_mr(struct ib_mr *ibmr)
	176	{
	177	struct mlx4_ib_mr *mr = to_mmr(ibmr);
	178
	179	mlx4_mr_free(to_mdev(ibmr->device)->dev, &mr->mmr);
	180	if (mr->umem)
	181	ib_umem_release(mr->umem);
	182	kfree(mr);
	183
	184	return 0;
	185	}
8ad11fb6	186
95d04f07 RD	187	struct ib_mr mlx4_ib_alloc_fast_reg_mr(struct ib_pd pd,
	188	int max_page_list_len)
	189	{
	190	struct mlx4_ib_dev *dev = to_mdev(pd->device);
	191	struct mlx4_ib_mr *mr;
	192	int err;
	193
	194	mr = kmalloc(sizeof *mr, GFP_KERNEL);
	195	if (!mr)
	196	return ERR_PTR(-ENOMEM);
	197
	198	err = mlx4_mr_alloc(dev->dev, to_mpd(pd)->pdn, 0, 0, 0,
	199	max_page_list_len, 0, &mr->mmr);
	200	if (err)
	201	goto err_free;
	202
	203	err = mlx4_mr_enable(dev->dev, &mr->mmr);
	204	if (err)
	205	goto err_mr;
	206
	207	return &mr->ibmr;
	208
	209	err_mr:
	210	mlx4_mr_free(dev->dev, &mr->mmr);
	211
	212	err_free:
	213	kfree(mr);
	214	return ERR_PTR(err);
	215	}
	216
	217	struct ib_fast_reg_page_list mlx4_ib_alloc_fast_reg_page_list(struct ib_device ibdev,
	218	int page_list_len)
	219	{
	220	struct mlx4_ib_dev *dev = to_mdev(ibdev);
	221	struct mlx4_ib_fast_reg_page_list *mfrpl;
	222	int size = page_list_len * sizeof (u64);
	223
	224	if (size > PAGE_SIZE)
	225	return ERR_PTR(-EINVAL);
	226
	227	mfrpl = kmalloc(sizeof *mfrpl, GFP_KERNEL);
	228	if (!mfrpl)
	229	return ERR_PTR(-ENOMEM);
	230
	231	mfrpl->ibfrpl.page_list = dma_alloc_coherent(&dev->dev->pdev->dev,
	232	size, &mfrpl->map,
	233	GFP_KERNEL);
	234	if (!mfrpl->ibfrpl.page_list)
	235	goto err_free;
	236
	237	WARN_ON(mfrpl->map & 0x3f);
	238
	239	return &mfrpl->ibfrpl;
	240
	241	err_free:
	242	kfree(mfrpl);
	243	return ERR_PTR(-ENOMEM);
	244	}
	245
	246	void mlx4_ib_free_fast_reg_page_list(struct ib_fast_reg_page_list *page_list)
	247	{
	248	struct mlx4_ib_dev *dev = to_mdev(page_list->device);
	249	struct mlx4_ib_fast_reg_page_list *mfrpl = to_mfrpl(page_list);
	250	int size = page_list->max_page_list_len * sizeof (u64);
251
252	dma_free_coherent(&dev->dev->pdev->dev, size, page_list->page_list,
253	mfrpl->map);
254	kfree(mfrpl);
255	}
256
8ad11fb6 JM	257	struct ib_fmr mlx4_ib_fmr_alloc(struct ib_pd pd, int acc,
	258	struct ib_fmr_attr *fmr_attr)
	259	{
	260	struct mlx4_ib_dev *dev = to_mdev(pd->device);
	261	struct mlx4_ib_fmr *fmr;
	262	int err = -ENOMEM;
	263
	264	fmr = kmalloc(sizeof *fmr, GFP_KERNEL);
	265	if (!fmr)
	266	return ERR_PTR(-ENOMEM);
	267
	268	err = mlx4_fmr_alloc(dev->dev, to_mpd(pd)->pdn, convert_access(acc),
	269	fmr_attr->max_pages, fmr_attr->max_maps,
	270	fmr_attr->page_shift, &fmr->mfmr);
	271	if (err)
	272	goto err_free;
	273
e6028c0e	274	err = mlx4_fmr_enable(to_mdev(pd->device)->dev, &fmr->mfmr);
8ad11fb6 JM	275	if (err)
	276	goto err_mr;
	277
	278	fmr->ibfmr.rkey = fmr->ibfmr.lkey = fmr->mfmr.mr.key;
	279
	280	return &fmr->ibfmr;
	281
	282	err_mr:
	283	mlx4_mr_free(to_mdev(pd->device)->dev, &fmr->mfmr.mr);
	284
	285	err_free:
	286	kfree(fmr);
	287
	288	return ERR_PTR(err);
	289	}
	290
	291	int mlx4_ib_map_phys_fmr(struct ib_fmr ibfmr, u64 page_list,
	292	int npages, u64 iova)
	293	{
	294	struct mlx4_ib_fmr *ifmr = to_mfmr(ibfmr);
	295	struct mlx4_ib_dev *dev = to_mdev(ifmr->ibfmr.device);
	296
	297	return mlx4_map_phys_fmr(dev->dev, &ifmr->mfmr, page_list, npages, iova,
	298	&ifmr->ibfmr.lkey, &ifmr->ibfmr.rkey);
	299	}
	300
	301	int mlx4_ib_unmap_fmr(struct list_head *fmr_list)
	302	{
	303	struct ib_fmr *ibfmr;
	304	int err;
	305	struct mlx4_dev *mdev = NULL;
	306
	307	list_for_each_entry(ibfmr, fmr_list, list) {
	308	if (mdev && to_mdev(ibfmr->device)->dev != mdev)
	309	return -EINVAL;
	310	mdev = to_mdev(ibfmr->device)->dev;
	311	}
	312
	313	if (!mdev)
	314	return 0;
	315
	316	list_for_each_entry(ibfmr, fmr_list, list) {
	317	struct mlx4_ib_fmr *ifmr = to_mfmr(ibfmr);
	318
	319	mlx4_fmr_unmap(mdev, &ifmr->mfmr, &ifmr->ibfmr.lkey, &ifmr->ibfmr.rkey);
	320	}
	321
	322	/*
	323	* Make sure all MPT status updates are visible before issuing
	324	* SYNC_TPT firmware command.
	325	*/
	326	wmb();
	327
	328	err = mlx4_SYNC_TPT(mdev);
	329	if (err)
	330	printk(KERN_WARNING "mlx4_ib: SYNC_TPT error %d when "
	331	"unmapping FMRs\n", err);
	332
	333	return 0;
	334	}
	335
	336	int mlx4_ib_fmr_dealloc(struct ib_fmr *ibfmr)
	337	{
	338	struct mlx4_ib_fmr *ifmr = to_mfmr(ibfmr);
339	struct mlx4_ib_dev *dev = to_mdev(ibfmr->device);
340	int err;
341
342	err = mlx4_fmr_free(dev->dev, &ifmr->mfmr);
343
344	if (!err)
345	kfree(ifmr);
346
347	return err;
348	}