Index: sys/ofed/drivers/infiniband/hw/mlx4/main.c
===================================================================
--- sys/ofed/drivers/infiniband/hw/mlx4/main.c
+++ sys/ofed/drivers/infiniband/hw/mlx4/main.c
@@ -2556,7 +2556,7 @@
 	}
 
 err_map:
-	iounmap(ibdev->priv_uar.map);
+	iounmap(ibdev->priv_uar.map, PAGE_SIZE);
 	mlx4_ib_free_eqs(dev, ibdev);
 
 err_uar:
@@ -2679,7 +2679,7 @@
 			pr_warn("failure unregistering notifier\n");
 		ibdev->iboe.nb.notifier_call = NULL;
 	}
-	iounmap(ibdev->priv_uar.map);
+	iounmap(ibdev->priv_uar.map, PAGE_SIZE);
 
 	for (p = 0; p < ibdev->num_ports; ++p) {
 		if (mlx4_ib_port_link_layer(&ibdev->ib_dev, p + 1) ==
Index: sys/ofed/drivers/infiniband/hw/mthca/mthca_av.c
===================================================================
--- sys/ofed/drivers/infiniband/hw/mthca/mthca_av.c
+++ sys/ofed/drivers/infiniband/hw/mthca/mthca_av.c
@@ -368,7 +368,8 @@
 		return;
 
 	if (dev->av_table.av_map)
-		iounmap(dev->av_table.av_map);
+		iounmap(dev->av_table.av_map,
+		    dev->av_table.num_ddr_avs * MTHCA_AV_SIZE);
 	pci_pool_destroy(dev->av_table.pool);
 	mthca_alloc_cleanup(&dev->av_table.alloc);
 }
Index: sys/ofed/drivers/infiniband/hw/mthca/mthca_catas.c
===================================================================
--- sys/ofed/drivers/infiniband/hw/mthca/mthca_catas.c
+++ sys/ofed/drivers/infiniband/hw/mthca/mthca_catas.c
@@ -174,7 +174,7 @@
 	del_timer_sync(&dev->catas_err.timer);
 
 	if (dev->catas_err.map)
-		iounmap(dev->catas_err.map);
+		iounmap(dev->catas_err.map, dev->catas_err.size * 4);
 
 	spin_lock_irq(&catas_lock);
 	list_del(&dev->catas_err.list);
Index: sys/ofed/drivers/infiniband/hw/mthca/mthca_cmd.c
===================================================================
--- sys/ofed/drivers/infiniband/hw/mthca/mthca_cmd.c
+++ sys/ofed/drivers/infiniband/hw/mthca/mthca_cmd.c
@@ -490,7 +490,7 @@
 					MTHCA_MAILBOX_SIZE,
 					MTHCA_MAILBOX_SIZE, 0);
 	if (!dev->cmd.pool) {
-		iounmap(dev->hcr);
+		iounmap(dev->hcr, MTHCA_HCR_SIZE);
 		return -ENOMEM;
 	}
 
@@ -500,9 +500,9 @@
 void mthca_cmd_cleanup(struct mthca_dev *dev)
 {
 	pci_pool_destroy(dev->cmd.pool);
-	iounmap(dev->hcr);
+	iounmap(dev->hcr, MTHCA_HCR_SIZE);
 	if (dev->cmd.flags & MTHCA_CMD_POST_DOORBELLS)
-		iounmap(dev->cmd.dbell_map);
+		iounmap(dev->cmd.dbell_map, dev->cmd.dbell_size);
 }
 
 /*
@@ -721,6 +721,7 @@
 	addr = pci_resource_start(dev->pdev, 2) +
 		((pci_resource_len(dev->pdev, 2) - 1) & base);
 	dev->cmd.dbell_map = ioremap(addr, max_off + sizeof(u32));
+	dev->cmd.dbell_size = max_off + sizeof(u32);
 	if (!dev->cmd.dbell_map)
 		return;
 
Index: sys/ofed/drivers/infiniband/hw/mthca/mthca_dev.h
===================================================================
--- sys/ofed/drivers/infiniband/hw/mthca/mthca_dev.h
+++ sys/ofed/drivers/infiniband/hw/mthca/mthca_dev.h
@@ -128,6 +128,7 @@
 	struct mthca_cmd_context *context;
 	u16                       token_mask;
 	u32                       flags;
+	u32			  dbell_size;
 	void __iomem             *dbell_map;
 	u16                       dbell_offsets[MTHCA_CMD_NUM_DBELL_DWORDS];
 };
@@ -217,6 +218,8 @@
 	struct mthca_icm_table *mtt_table;
 	struct mthca_icm_table *mpt_table;
 	struct {
+		unsigned long	mpt_size;
+		unsigned long	mtt_size;
 		void __iomem   *mpt_base;
 		void __iomem   *mtt_base;
 		struct mthca_buddy mtt_buddy;
Index: sys/ofed/drivers/infiniband/hw/mthca/mthca_eq.c
===================================================================
--- sys/ofed/drivers/infiniband/hw/mthca/mthca_eq.c
+++ sys/ofed/drivers/infiniband/hw/mthca/mthca_eq.c
@@ -687,7 +687,7 @@
 					dev->fw.arbel.eq_arm_base) + 4, 4,
 				  &dev->eq_regs.arbel.eq_arm)) {
 			mthca_err(dev, "Couldn't map EQ arm register, aborting.\n");
-			iounmap(dev->clr_base);
+			iounmap(dev->clr_base, MTHCA_CLR_INT_SIZE);
 			return -ENOMEM;
 		}
 
@@ -696,8 +696,8 @@
 				  MTHCA_EQ_SET_CI_SIZE,
 				  &dev->eq_regs.arbel.eq_set_ci_base)) {
 			mthca_err(dev, "Couldn't map EQ CI register, aborting.\n");
-			iounmap(dev->eq_regs.arbel.eq_arm);
-			iounmap(dev->clr_base);
+			iounmap(dev->eq_regs.arbel.eq_arm, 4);
+			iounmap(dev->clr_base, MTHCA_CLR_INT_SIZE);
 			return -ENOMEM;
 		}
 	} else {
@@ -713,7 +713,7 @@
 				  &dev->eq_regs.tavor.ecr_base)) {
 			mthca_err(dev, "Couldn't map ecr register, "
 				  "aborting.\n");
-			iounmap(dev->clr_base);
+			iounmap(dev->clr_base, MTHCA_CLR_INT_SIZE);
 			return -ENOMEM;
 		}
 	}
@@ -725,12 +725,12 @@
 static void mthca_unmap_eq_regs(struct mthca_dev *dev)
 {
 	if (mthca_is_memfree(dev)) {
-		iounmap(dev->eq_regs.arbel.eq_set_ci_base);
-		iounmap(dev->eq_regs.arbel.eq_arm);
-		iounmap(dev->clr_base);
+		iounmap(dev->eq_regs.arbel.eq_set_ci_base, MTHCA_EQ_SET_CI_SIZE);
+		iounmap(dev->eq_regs.arbel.eq_arm, 4);
+		iounmap(dev->clr_base, MTHCA_CLR_INT_SIZE);
 	} else {
-		iounmap(dev->eq_regs.tavor.ecr_base);
-		iounmap(dev->clr_base);
+		iounmap(dev->eq_regs.tavor.ecr_base, MTHCA_ECR_SIZE + MTHCA_ECR_CLR_SIZE);
+		iounmap(dev->clr_base, MTHCA_CLR_INT_SIZE);
 	}
 }
 
Index: sys/ofed/drivers/infiniband/hw/mthca/mthca_main.c
===================================================================
--- sys/ofed/drivers/infiniband/hw/mthca/mthca_main.c
+++ sys/ofed/drivers/infiniband/hw/mthca/mthca_main.c
@@ -917,7 +917,7 @@
 	mthca_cleanup_pd_table(dev);
 
 err_kar_unmap:
-	iounmap(dev->kar);
+	iounmap(dev->kar, PAGE_SIZE);
 
 err_uar_free:
 	mthca_uar_free(dev, &dev->driver_uar);
@@ -1186,7 +1186,7 @@
 		mthca_cleanup_mr_table(mdev);
 		mthca_cleanup_pd_table(mdev);
 
-		iounmap(mdev->kar);
+		iounmap(mdev->kar, PAGE_SIZE);
 		mthca_uar_free(mdev, &mdev->driver_uar);
 		mthca_cleanup_uar_table(mdev);
 		mthca_close_hca(mdev);
Index: sys/ofed/drivers/infiniband/hw/mthca/mthca_mr.c
===================================================================
--- sys/ofed/drivers/infiniband/hw/mthca/mthca_mr.c
+++ sys/ofed/drivers/infiniband/hw/mthca/mthca_mr.c
@@ -894,8 +894,9 @@
 			((pci_resource_len(dev->pdev, 4) - 1) &
 			 dev->mr_table.mpt_base);
 
+		dev->mr_table.tavor_fmr.mpt_size = mpts * sizeof(struct mthca_mpt_entry);
 		dev->mr_table.tavor_fmr.mpt_base =
-			ioremap(addr, mpts * sizeof(struct mthca_mpt_entry));
+			ioremap(addr, dev->mr_table.tavor_fmr.mpt_size);
 
 		if (!dev->mr_table.tavor_fmr.mpt_base) {
 			mthca_warn(dev, "MPT ioremap for FMR failed.\n");
@@ -907,8 +908,9 @@
 			((pci_resource_len(dev->pdev, 4) - 1) &
 			 dev->mr_table.mtt_base);
 
+		dev->mr_table.tavor_fmr.mtt_size = mtts * dev->limits.mtt_seg_size;
 		dev->mr_table.tavor_fmr.mtt_base =
-			ioremap(addr, mtts * dev->limits.mtt_seg_size);
+			ioremap(addr, dev->mr_table.tavor_fmr.mtt_size);
 		if (!dev->mr_table.tavor_fmr.mtt_base) {
 			mthca_warn(dev, "MTT ioremap for FMR failed.\n");
 			err = -ENOMEM;
@@ -953,11 +955,13 @@
 
 err_fmr_mtt_buddy:
 	if (dev->mr_table.tavor_fmr.mtt_base)
-		iounmap(dev->mr_table.tavor_fmr.mtt_base);
+		iounmap(dev->mr_table.tavor_fmr.mtt_base,
+		    dev->mr_table.tavor_fmr.mtt_size);
 
 err_fmr_mtt:
 	if (dev->mr_table.tavor_fmr.mpt_base)
-		iounmap(dev->mr_table.tavor_fmr.mpt_base);
+		iounmap(dev->mr_table.tavor_fmr.mpt_base,
+		    dev->mr_table.tavor_fmr.mpt_size);
 
 err_fmr_mpt:
 	mthca_buddy_cleanup(&dev->mr_table.mtt_buddy);
@@ -977,9 +981,11 @@
 	mthca_buddy_cleanup(&dev->mr_table.mtt_buddy);
 
 	if (dev->mr_table.tavor_fmr.mtt_base)
-		iounmap(dev->mr_table.tavor_fmr.mtt_base);
+		iounmap(dev->mr_table.tavor_fmr.mtt_base,
+		    dev->mr_table.tavor_fmr.mtt_size);
 	if (dev->mr_table.tavor_fmr.mpt_base)
-		iounmap(dev->mr_table.tavor_fmr.mpt_base);
+		iounmap(dev->mr_table.tavor_fmr.mpt_base,
+		    dev->mr_table.tavor_fmr.mpt_size);
 
 	mthca_alloc_cleanup(&dev->mr_table.mpt_alloc);
 }
Index: sys/ofed/drivers/infiniband/hw/mthca/mthca_reset.c
===================================================================
--- sys/ofed/drivers/infiniband/hw/mthca/mthca_reset.c
+++ sys/ofed/drivers/infiniband/hw/mthca/mthca_reset.c
@@ -163,7 +163,7 @@
 		}
 
 		writel(MTHCA_RESET_VALUE, reset);
-		iounmap(reset);
+		iounmap(reset, 4);
 	}
 
 	/* Docs say to wait one second before accessing device */
Index: sys/ofed/drivers/net/mlx4/alloc.c
===================================================================
--- sys/ofed/drivers/net/mlx4/alloc.c
+++ sys/ofed/drivers/net/mlx4/alloc.c
@@ -285,7 +285,7 @@
 				  buf->direct.map);
 	else {
 		if (BITS_PER_LONG == 64 && buf->direct.buf)
-			vunmap(buf->direct.buf);
+			vunmap(buf->direct.buf, buf->nbufs);
 
 		for (i = 0; i < buf->nbufs; ++i)
 			if (buf->page_list[i].buf)
Index: sys/ofed/drivers/net/mlx4/catas.c
===================================================================
--- sys/ofed/drivers/net/mlx4/catas.c
+++ sys/ofed/drivers/net/mlx4/catas.c
@@ -158,7 +158,7 @@
 	del_timer_sync(&priv->catas_err.timer);
 
 	if (priv->catas_err.map) {
-		iounmap(priv->catas_err.map);
+		iounmap(priv->catas_err.map, priv->fw.catas_size * 4);
 		priv->catas_err.map = NULL;
 	}
 
Index: sys/ofed/drivers/net/mlx4/cmd.c
===================================================================
--- sys/ofed/drivers/net/mlx4/cmd.c
+++ sys/ofed/drivers/net/mlx4/cmd.c
@@ -2239,7 +2239,7 @@
 err_comm_admin:
 	kfree(priv->mfunc.master.slave_state);
 err_comm:
-	iounmap(priv->mfunc.comm);
+	iounmap(priv->mfunc.comm, MLX4_COMM_PAGESIZE);
 err_vhcr:
 	dma_free_coherent(&(dev->pdev->dev), PAGE_SIZE,
 					     priv->mfunc.vhcr,
@@ -2296,7 +2296,7 @@
 
 err_hcr:
 	if (!mlx4_is_slave(dev))
-		iounmap(priv->cmd.hcr);
+		iounmap(priv->cmd.hcr, MLX4_HCR_SIZE);
 	return -ENOMEM;
 }
 
@@ -2317,7 +2317,7 @@
 		kfree(priv->mfunc.master.vf_oper);
 	}
 
-	iounmap(priv->mfunc.comm);
+	iounmap(priv->mfunc.comm, MLX4_COMM_PAGESIZE);
 }
 
 void mlx4_cmd_cleanup(struct mlx4_dev *dev)
@@ -2327,7 +2327,7 @@
 	pci_pool_destroy(priv->cmd.pool);
 
 	if (!mlx4_is_slave(dev))
-		iounmap(priv->cmd.hcr);
+		iounmap(priv->cmd.hcr, MLX4_HCR_SIZE);
 	if (mlx4_is_mfunc(dev))
 		dma_free_coherent(&(dev->pdev->dev), PAGE_SIZE,
 				  priv->mfunc.vhcr, priv->mfunc.vhcr_dma);
Index: sys/ofed/drivers/net/mlx4/en_main.c
===================================================================
--- sys/ofed/drivers/net/mlx4/en_main.c
+++ sys/ofed/drivers/net/mlx4/en_main.c
@@ -164,7 +164,7 @@
 	ret = mlx4_mr_free(dev, &mdev->mr);
 	if (ret)
 		mlx4_err(mdev, "Error deregistering MR. The system may have become unstable.");
-	iounmap(mdev->uar_map);
+	iounmap(mdev->uar_map, PAGE_SIZE);
 	mlx4_uar_free(dev, &mdev->priv_uar);
 	mlx4_pd_free(dev, mdev->priv_pdn);
 	kfree(mdev);
@@ -277,7 +277,7 @@
 		mlx4_err(mdev, "Error deregistering MR. The system may have become unstable.");
 err_map:
 	if (mdev->uar_map)
-		iounmap(mdev->uar_map);
+		iounmap(mdev->uar_map, PAGE_SIZE);
 err_uar:
 	mlx4_uar_free(dev, &mdev->priv_uar);
 err_pd:
Index: sys/ofed/drivers/net/mlx4/en_resources.c
===================================================================
--- sys/ofed/drivers/net/mlx4/en_resources.c
+++ sys/ofed/drivers/net/mlx4/en_resources.c
@@ -111,7 +111,7 @@
 	if (BITS_PER_LONG == 64 || buf->nbufs == 1)
 		return;
 
-	vunmap(buf->direct.buf);
+	vunmap(buf->direct.buf, buf->nbufs);
 }
 
 void mlx4_en_sqp_event(struct mlx4_qp *qp, enum mlx4_event event)
Index: sys/ofed/drivers/net/mlx4/eq.c
===================================================================
--- sys/ofed/drivers/net/mlx4/eq.c
+++ sys/ofed/drivers/net/mlx4/eq.c
@@ -895,7 +895,7 @@
 
 	for (i = 0; i < mlx4_num_eq_uar(dev); ++i)
 		if (priv->eq_table.uar_map[i]) {
-			iounmap(priv->eq_table.uar_map[i]);
+			iounmap(priv->eq_table.uar_map[i], PAGE_SIZE);
 			priv->eq_table.uar_map[i] = NULL;
 		}
 }
@@ -1102,7 +1102,7 @@
 {
 	struct mlx4_priv *priv = mlx4_priv(dev);
 
-	iounmap(priv->clr_base);
+	iounmap(priv->clr_base, MLX4_CLR_INT_SIZE);
 }
 
 int mlx4_alloc_eq_table(struct mlx4_dev *dev)
Index: sys/ofed/drivers/net/mlx4/main.c
===================================================================
--- sys/ofed/drivers/net/mlx4/main.c
+++ sys/ofed/drivers/net/mlx4/main.c
@@ -1786,7 +1786,7 @@
 	struct mlx4_priv *priv = mlx4_priv(dev);
 
 	if (priv->clock_mapping)
-		iounmap(priv->clock_mapping);
+		iounmap(priv->clock_mapping, MLX4_CLOCK_SIZE);
 }
 
 static void mlx4_close_hca(struct mlx4_dev *dev)
@@ -2854,7 +2854,7 @@
 	mlx4_cleanup_pd_table(dev);
 
 err_kar_unmap:
-	iounmap(priv->kar);
+	iounmap(priv->kar, PAGE_SIZE);
 
 err_uar_free:
 	mlx4_uar_free(dev, &priv->driver_uar);
@@ -3074,7 +3074,7 @@
 	}
 
 	ret = readl(owner);
-	iounmap(owner);
+	iounmap(owner, MLX4_OWNER_SIZE);
 	return (int) !!ret;
 }
 
@@ -3093,7 +3093,7 @@
 	}
 	writel(0, owner);
 	msleep(1000);
-	iounmap(owner);
+	iounmap(owner, MLX4_OWNER_SIZE);
 }
 
 static int __mlx4_init_one(struct pci_dev *pdev, int pci_dev_data)
@@ -3484,7 +3484,7 @@
 			mlx4_free_resource_tracker(dev,
 						   RES_TR_FREE_STRUCTS_ONLY);
 
-		iounmap(priv->kar);
+		iounmap(priv->kar, PAGE_SIZE);
 		mlx4_uar_free(dev, &priv->driver_uar);
 		mlx4_cleanup_uar_table(dev);
 		if (!mlx4_is_slave(dev))
Index: sys/ofed/drivers/net/mlx4/pd.c
===================================================================
--- sys/ofed/drivers/net/mlx4/pd.c
+++ sys/ofed/drivers/net/mlx4/pd.c
@@ -227,7 +227,7 @@
 
 unamp_uar:
 	bf->uar = NULL;
-	iounmap(uar->map);
+	iounmap(uar->map, PAGE_SIZE);
 
 free_uar:
 	mlx4_uar_free(dev, uar);
@@ -257,7 +257,7 @@
 			list_del(&bf->uar->bf_list);
 
 		io_mapping_unmap(bf->uar->bf_map);
-		iounmap(bf->uar->map);
+		iounmap(bf->uar->map, PAGE_SIZE);
 		mlx4_uar_free(dev, bf->uar);
 		kfree(bf->uar);
 	} else if (list_empty(&bf->uar->bf_list))
Index: sys/ofed/drivers/net/mlx4/reset.c
===================================================================
--- sys/ofed/drivers/net/mlx4/reset.c
+++ sys/ofed/drivers/net/mlx4/reset.c
@@ -111,13 +111,13 @@
 	if (sem) {
 		mlx4_err(dev, "Failed to obtain HW semaphore, aborting\n");
 		err = -EAGAIN;
-		iounmap(reset);
+		iounmap(reset, MLX4_RESET_SIZE);
 		goto out;
 	}
 
 	/* actually hit reset */
 	writel(MLX4_RESET_VALUE, reset + MLX4_RESET_OFFSET);
-	iounmap(reset);
+	iounmap(reset, MLX4_RESET_SIZE);
 
 	/* wait half a second before accessing device */
 	msleep(500);
Index: sys/ofed/include/linux/io-mapping.h
===================================================================
--- sys/ofed/include/linux/io-mapping.h
+++ sys/ofed/include/linux/io-mapping.h
@@ -2,7 +2,8 @@
  * Copyright (c) 2010 Isilon Systems, Inc.
  * Copyright (c) 2010 iX Systems, Inc.
  * Copyright (c) 2010 Panasas, Inc.
- * Copyright (c) 2013, 2014 Mellanox Technologies, Ltd.
+ * Copyright (c) 2013-2015 Mellanox Technologies, Ltd.
+ * Copyright (c) 2015 François Tigeot
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -33,46 +34,64 @@
 #include <linux/types.h>
 #include <linux/io.h>
 
-struct io_mapping;
+#include <machine/pmap.h>
+
+struct io_mapping {
+	resource_size_t base;
+	unsigned long size;
+	unsigned long prot;
+	caddr_t vaddr;
+};
 
 static inline struct io_mapping *
 io_mapping_create_wc(resource_size_t base, unsigned long size)
 {
+	struct io_mapping *map;
 
-	return ioremap_wc(base, size);
+	map = malloc(sizeof(struct io_mapping), M_KMALLOC, M_WAITOK);
+	map->base = base;
+	map->size = size;
+	map->prot = VM_MEMATTR_WRITE_COMBINING;
+
+	map->vaddr = pmap_mapdev_attr(base, size,
+	    VM_MEMATTR_WRITE_COMBINING);
+	if (map->vaddr == NULL) {
+		free(map, M_KMALLOC);
+		return (NULL);
+	}
+	return (map);
 }
 
 static inline void
 io_mapping_free(struct io_mapping *mapping)
 {
-
-	iounmap(mapping);
+	/* Default memory attribute is write-back */
+	pmap_mapdev_attr(mapping->base, mapping->size, VM_MEMATTR_WRITE_BACK);
+	free(mapping, M_KMALLOC);
 }
 
 static inline void *
 io_mapping_map_atomic_wc(struct io_mapping *mapping, unsigned long offset)
 {
-
-	return (((char *)mapping) + offset);
-}
-
-static inline void
-io_mapping_unmap_atomic(void *vaddr)
-{
-
+	return ((void *)(mapping->vaddr + offset));
 }
 
 static inline void *
 io_mapping_map_wc(struct io_mapping *mapping, unsigned long offset)
 {
+	return (io_mapping_map_atomic_wc(mapping, offset));
+}
 
-	return (((char *) mapping) + offset);
+static inline void
+io_mapping_unmap_atomic(void *vaddr)
+{
+	/* NOP */
 }
 
 static inline void
 io_mapping_unmap(void *vaddr)
 {
-
+	/* NOP */
 }
 
 #endif	/* _LINUX_IO_MAPPING_H_ */
Index: sys/ofed/include/linux/io.h
===================================================================
--- sys/ofed/include/linux/io.h
+++ sys/ofed/include/linux/io.h
@@ -2,7 +2,7 @@
  * Copyright (c) 2010 Isilon Systems, Inc.
  * Copyright (c) 2010 iX Systems, Inc.
  * Copyright (c) 2010 Panasas, Inc.
- * Copyright (c) 2013, 2014 Mellanox Technologies, Ltd.
+ * Copyright (c) 2013-2015 Mellanox Technologies, Ltd.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -60,7 +60,7 @@
 /*
  * XXX This is all x86 specific.  It should be bus space access.
  */
-#define mmiowb()
+#define mmiowb() do { } while (0)
 
 #undef writel
 static inline void
@@ -104,13 +104,10 @@
 	*(volatile uint32_t *)addr = htobe32(v);
 }
 
-void *_ioremap_attr(vm_paddr_t phys_addr, unsigned long size, int attr);
-#define	ioremap_nocache(addr, size)					\
-    _ioremap_attr((addr), (size), VM_MEMATTR_UNCACHEABLE)
-#define	ioremap_wc(addr, size)						\
-    _ioremap_attr((addr), (size), VM_MEMATTR_WRITE_COMBINING)
-#define	ioremap	ioremap_nocache
-void iounmap(void *addr);
+void *ioremap(resource_size_t offset, unsigned long size);
+void *ioremap_nocache(resource_size_t offset, unsigned long size);
+void *ioremap_wc(resource_size_t offset, unsigned long size);
+void iounmap(void *addr, unsigned long size);
 
 #define	memset_io(a, b, c)	memset((a), (b), (c))
 #define	memcpy_fromio(a, b, c)	memcpy((a), (b), (c))
Index: sys/ofed/include/linux/linux_compat.c
===================================================================
--- sys/ofed/include/linux/linux_compat.c
+++ sys/ofed/include/linux/linux_compat.c
@@ -606,81 +606,30 @@
 	.fo_sendfile = invfo_sendfile,
 };
 
-/*
- * Hash of vmmap addresses.  This is infrequently accessed and does not
- * need to be particularly large.  This is done because we must store the
- * caller's idea of the map size to properly unmap.
- */
-struct vmmap {
-	LIST_ENTRY(vmmap)	vm_next;
-	void 			*vm_addr;
-	unsigned long		vm_size;
-};
-
-struct vmmaphd {
-	struct vmmap *lh_first;
-};
-#define	VMMAP_HASH_SIZE	64
-#define	VMMAP_HASH_MASK	(VMMAP_HASH_SIZE - 1)
-#define	VM_HASH(addr)	((uintptr_t)(addr) >> PAGE_SHIFT) & VMMAP_HASH_MASK
-static struct vmmaphd vmmaphead[VMMAP_HASH_SIZE];
-static struct mtx vmmaplock;
-
-static void
-vmmap_add(void *addr, unsigned long size)
+void *
+ioremap(resource_size_t offset, unsigned long size)
 {
-	struct vmmap *vmmap;
-
-	vmmap = kmalloc(sizeof(*vmmap), GFP_KERNEL);
-	mtx_lock(&vmmaplock);
-	vmmap->vm_size = size;
-	vmmap->vm_addr = addr;
-	LIST_INSERT_HEAD(&vmmaphead[VM_HASH(addr)], vmmap, vm_next);
-	mtx_unlock(&vmmaplock);
+	return (pmap_mapdev_attr(offset, size, VM_MEMATTR_UNCACHEABLE));
 }
 
-static struct vmmap *
-vmmap_remove(void *addr)
+void *
+ioremap_nocache(resource_size_t offset, unsigned long size)
 {
-	struct vmmap *vmmap;
-
-	mtx_lock(&vmmaplock);
-	LIST_FOREACH(vmmap, &vmmaphead[VM_HASH(addr)], vm_next)
-		if (vmmap->vm_addr == addr)
-			break;
-	if (vmmap)
-		LIST_REMOVE(vmmap, vm_next);
-	mtx_unlock(&vmmaplock);
-
-	return (vmmap);
+	return (pmap_mapdev_attr(offset, size, VM_MEMATTR_UNCACHEABLE));
 }
 
 void *
-_ioremap_attr(vm_paddr_t phys_addr, unsigned long size, int attr)
+ioremap_wc(resource_size_t offset, unsigned long size)
 {
-	void *addr;
-
-	addr = pmap_mapdev_attr(phys_addr, size, attr);
-	if (addr == NULL)
-		return (NULL);
-	vmmap_add(addr, size);
-
-	return (addr);
+	return (pmap_mapdev_attr(offset, size, VM_MEMATTR_WRITE_COMBINING));
 }
 
 void
-iounmap(void *addr)
+iounmap(void *addr, unsigned long size)
 {
-	struct vmmap *vmmap;
-
-	vmmap = vmmap_remove(addr);
-	if (vmmap == NULL)
-		return;
-	pmap_unmapdev((vm_offset_t)addr, vmmap->vm_size);
-	kfree(vmmap);
+	pmap_unmapdev((vm_offset_t)addr, size);
 }
 
-
 void *
 vmap(struct page **pages, unsigned int count, unsigned long flags, int prot)
 {
@@ -691,23 +640,19 @@
 	off = kva_alloc(size);
 	if (off == 0)
 		return (NULL);
-	vmmap_add((void *)off, size);
 	pmap_qenter(off, pages, count);
 
 	return ((void *)off);
 }
 
 void
-vunmap(void *addr)
+vunmap(void *addr, unsigned int count)
 {
-	struct vmmap *vmmap;
+	size_t size;
 
-	vmmap = vmmap_remove(addr);
-	if (vmmap == NULL)
-		return;
-	pmap_qremove((vm_offset_t)addr, vmmap->vm_size / PAGE_SIZE);
-	kva_free((vm_offset_t)addr, vmmap->vm_size);
-	kfree(vmmap);
+	size = count * PAGE_SIZE;
+	pmap_qremove((vm_offset_t)addr, count);
+	kva_free((vm_offset_t)addr, size);
 }
 
 char *
@@ -910,7 +855,6 @@
 linux_compat_init(void *arg)
 {
 	struct sysctl_oid *rootoid;
-	int i;
 
 	rootoid = SYSCTL_ADD_ROOT_NODE(NULL,
 	    OID_AUTO, "sys", CTLFLAG_RD|CTLFLAG_MPSAFE, NULL, "sys");
@@ -929,9 +873,6 @@
 	INIT_LIST_HEAD(&pci_drivers);
 	INIT_LIST_HEAD(&pci_devices);
 	spin_lock_init(&pci_lock);
-	mtx_init(&vmmaplock, "IO Map lock", NULL, MTX_DEF);
-	for (i = 0; i < VMMAP_HASH_SIZE; i++)
-		LIST_INIT(&vmmaphead[i]);
 }
 SYSINIT(linux_compat, SI_SUB_DRIVERS, SI_ORDER_SECOND, linux_compat_init, NULL);
 
Index: sys/ofed/include/linux/vmalloc.h
===================================================================
--- sys/ofed/include/linux/vmalloc.h
+++ sys/ofed/include/linux/vmalloc.h
@@ -37,6 +37,6 @@
 
 void *vmap(struct page **pages, unsigned int count, unsigned long flags,
     int prot);
-void vunmap(void *addr);
+void vunmap(void *addr, unsigned int count);
 
 #endif	/* _LINUX_VMALLOC_H_ */