diff mbox

[13/20] intel-iommu: switch from ioremap_cache to memremap

Message ID 20151009221646.32203.98367.stgit@dwillia2-desk3.jf.intel.com (mailing list archive)
State New, archived
Headers show

Commit Message

Dan Williams Oct. 9, 2015, 10:16 p.m. UTC
In preparation for deprecating ioremap_cache() convert its usage in
intel-iommu to memremap.  This also eliminates the mishandling of the
__iomem annotation in the implementation.

Cc: David Woodhouse <dwmw2@infradead.org>
Acked-by: Joerg Roedel <jroedel@suse.de>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
---
 drivers/iommu/intel-iommu.c         |   20 +++++++++++---------
 drivers/iommu/intel_irq_remapping.c |    8 ++++----
 2 files changed, 15 insertions(+), 13 deletions(-)

Comments

Joerg Roedel Oct. 12, 2015, 9:58 p.m. UTC | #1
Hi Dan,

On Fri, Oct 09, 2015 at 06:16:46PM -0400, Dan Williams wrote:
> In preparation for deprecating ioremap_cache() convert its usage in
> intel-iommu to memremap.  This also eliminates the mishandling of the
> __iomem annotation in the implementation.

I appreciate the change, but in the cover letter you write the API is
only implemented for x86 so far? The VT-d driver is also used on ia64,
will it still work there with this patch?


	Joerg
Dan Williams Oct. 12, 2015, 10:05 p.m. UTC | #2
On Mon, Oct 12, 2015 at 2:58 PM, Joerg Roedel <jroedel@suse.de> wrote:
> Hi Dan,
>
> On Fri, Oct 09, 2015 at 06:16:46PM -0400, Dan Williams wrote:
>> In preparation for deprecating ioremap_cache() convert its usage in
>> intel-iommu to memremap.  This also eliminates the mishandling of the
>> __iomem annotation in the implementation.
>
> I appreciate the change, but in the cover letter you write the API is
> only implemented for x86 so far? The VT-d driver is also used on ia64,
> will it still work there with this patch?
>
>

I did convert ia64 in the series [1]  but you're right this patch
can't go in independently of that conversion.  If you ack this one
I'll carry them in order.

[1]: https://lkml.org/lkml/2015/10/9/702
Dan Williams Oct. 12, 2015, 10:19 p.m. UTC | #3
On Mon, Oct 12, 2015 at 3:05 PM, Dan Williams <dan.j.williams@intel.com> wrote:
> On Mon, Oct 12, 2015 at 2:58 PM, Joerg Roedel <jroedel@suse.de> wrote:
>> Hi Dan,
>>
>> On Fri, Oct 09, 2015 at 06:16:46PM -0400, Dan Williams wrote:
>>> In preparation for deprecating ioremap_cache() convert its usage in
>>> intel-iommu to memremap.  This also eliminates the mishandling of the
>>> __iomem annotation in the implementation.
>>
>> I appreciate the change, but in the cover letter you write the API is
>> only implemented for x86 so far? The VT-d driver is also used on ia64,
>> will it still work there with this patch?
>>
>>
>
> I did convert ia64 in the series [1]  but you're right this patch
> can't go in independently of that conversion.  If you ack this one
> I'll carry them in order.
>
> [1]: https://lkml.org/lkml/2015/10/9/702

Ah sorry, got ahead of myself ;-p.  You can safely take this patch
through your tree.  The ia64 patch can happen asynchronously because
kernel/memremap.c has:

__weak void *arch_memremap(resource_size_t offset, size_t size,
unsigned long flags)

...as a temporary fallback until the conversion is complete.
Joerg Roedel Oct. 14, 2015, 1:22 p.m. UTC | #4
On Mon, Oct 12, 2015 at 03:19:24PM -0700, Dan Williams wrote:
> On Mon, Oct 12, 2015 at 3:05 PM, Dan Williams <dan.j.williams@intel.com> wrote:
> > On Mon, Oct 12, 2015 at 2:58 PM, Joerg Roedel <jroedel@suse.de> wrote:
> >> Hi Dan,
> >>
> >> On Fri, Oct 09, 2015 at 06:16:46PM -0400, Dan Williams wrote:
> >>> In preparation for deprecating ioremap_cache() convert its usage in
> >>> intel-iommu to memremap.  This also eliminates the mishandling of the
> >>> __iomem annotation in the implementation.
> >>
> >> I appreciate the change, but in the cover letter you write the API is
> >> only implemented for x86 so far? The VT-d driver is also used on ia64,
> >> will it still work there with this patch?
> >>
> >>
> >
> > I did convert ia64 in the series [1]  but you're right this patch
> > can't go in independently of that conversion.  If you ack this one
> > I'll carry them in order.
> >
> > [1]: https://lkml.org/lkml/2015/10/9/702
> 
> Ah sorry, got ahead of myself ;-p.  You can safely take this patch
> through your tree.  The ia64 patch can happen asynchronously because
> kernel/memremap.c has:
> 
> __weak void *arch_memremap(resource_size_t offset, size_t size,
> unsigned long flags)
> 
> ...as a temporary fallback until the conversion is complete.

Okay, thanks, applied.
diff mbox

Patch

diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
index 041bc1810a86..a089177db372 100644
--- a/drivers/iommu/intel-iommu.c
+++ b/drivers/iommu/intel-iommu.c
@@ -34,6 +34,7 @@ 
 #include <linux/mempool.h>
 #include <linux/memory.h>
 #include <linux/timer.h>
+#include <linux/io.h>
 #include <linux/iova.h>
 #include <linux/iommu.h>
 #include <linux/intel-iommu.h>
@@ -2807,18 +2808,18 @@  static void intel_iommu_init_qi(struct intel_iommu *iommu)
 }
 
 static int copy_context_table(struct intel_iommu *iommu,
-			      struct root_entry __iomem *old_re,
+			      struct root_entry *old_re,
 			      struct context_entry **tbl,
 			      int bus, bool ext)
 {
 	int tbl_idx, pos = 0, idx, devfn, ret = 0, did;
-	struct context_entry __iomem *old_ce = NULL;
 	struct context_entry *new_ce = NULL, ce;
+	struct context_entry *old_ce = NULL;
 	struct root_entry re;
 	phys_addr_t old_ce_phys;
 
 	tbl_idx = ext ? bus * 2 : bus;
-	memcpy_fromio(&re, old_re, sizeof(re));
+	memcpy(&re, old_re, sizeof(re));
 
 	for (devfn = 0; devfn < 256; devfn++) {
 		/* First calculate the correct index */
@@ -2853,7 +2854,8 @@  static int copy_context_table(struct intel_iommu *iommu,
 			}
 
 			ret = -ENOMEM;
-			old_ce = ioremap_cache(old_ce_phys, PAGE_SIZE);
+			old_ce = memremap(old_ce_phys, PAGE_SIZE,
+					MEMREMAP_WB);
 			if (!old_ce)
 				goto out;
 
@@ -2865,7 +2867,7 @@  static int copy_context_table(struct intel_iommu *iommu,
 		}
 
 		/* Now copy the context entry */
-		memcpy_fromio(&ce, old_ce + idx, sizeof(ce));
+		memcpy(&ce, old_ce + idx, sizeof(ce));
 
 		if (!__context_present(&ce))
 			continue;
@@ -2901,7 +2903,7 @@  static int copy_context_table(struct intel_iommu *iommu,
 	__iommu_flush_cache(iommu, new_ce, VTD_PAGE_SIZE);
 
 out_unmap:
-	iounmap(old_ce);
+	memunmap(old_ce);
 
 out:
 	return ret;
@@ -2909,8 +2911,8 @@  out:
 
 static int copy_translation_tables(struct intel_iommu *iommu)
 {
-	struct root_entry __iomem *old_rt;
 	struct context_entry **ctxt_tbls;
+	struct root_entry *old_rt;
 	phys_addr_t old_rt_phys;
 	int ctxt_table_entries;
 	unsigned long flags;
@@ -2935,7 +2937,7 @@  static int copy_translation_tables(struct intel_iommu *iommu)
 	if (!old_rt_phys)
 		return -EINVAL;
 
-	old_rt = ioremap_cache(old_rt_phys, PAGE_SIZE);
+	old_rt = memremap(old_rt_phys, PAGE_SIZE, MEMREMAP_WB);
 	if (!old_rt)
 		return -ENOMEM;
 
@@ -2984,7 +2986,7 @@  static int copy_translation_tables(struct intel_iommu *iommu)
 	ret = 0;
 
 out_unmap:
-	iounmap(old_rt);
+	memunmap(old_rt);
 
 	return ret;
 }
diff --git a/drivers/iommu/intel_irq_remapping.c b/drivers/iommu/intel_irq_remapping.c
index 9ec4e0d94ffd..bdc52cc6ed23 100644
--- a/drivers/iommu/intel_irq_remapping.c
+++ b/drivers/iommu/intel_irq_remapping.c
@@ -384,7 +384,7 @@  static int set_msi_sid(struct irte *irte, struct pci_dev *dev)
 
 static int iommu_load_old_irte(struct intel_iommu *iommu)
 {
-	struct irte __iomem *old_ir_table;
+	struct irte *old_ir_table;
 	phys_addr_t irt_phys;
 	unsigned int i;
 	size_t size;
@@ -408,12 +408,12 @@  static int iommu_load_old_irte(struct intel_iommu *iommu)
 	size     = INTR_REMAP_TABLE_ENTRIES*sizeof(struct irte);
 
 	/* Map the old IR table */
-	old_ir_table = ioremap_cache(irt_phys, size);
+	old_ir_table = memremap(irt_phys, size, MEMREMAP_WB);
 	if (!old_ir_table)
 		return -ENOMEM;
 
 	/* Copy data over */
-	memcpy_fromio(iommu->ir_table->base, old_ir_table, size);
+	memcpy(iommu->ir_table->base, old_ir_table, size);
 
 	__iommu_flush_cache(iommu, iommu->ir_table->base, size);
 
@@ -426,7 +426,7 @@  static int iommu_load_old_irte(struct intel_iommu *iommu)
 			bitmap_set(iommu->ir_table->bitmap, i, 1);
 	}
 
-	iounmap(old_ir_table);
+	memunmap(old_ir_table);
 
 	return 0;
 }