D3835.id9529.diff
No OneTemporary
Actions

Size

21 KB

Referenced Files

None

Subscribers

None

D3835.id9529.diff
View Options

	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_ */

File Metadata

Mime Type: text/plain
Expires: Wed, Apr 8, 10:40 AM (12 h, 30 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 31095258
Default Alt Text: D3835.id9529.diff (21 KB)

D3835.id9529.diffNo OneTemporaryActions

D3835.id9529.diffView Options

File Metadata

Event Timeline

D3835.id9529.diff
No OneTemporary
Actions

D3835.id9529.diff
View Options