Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ff0daca5 authored by Russell King's avatar Russell King Committed by Russell King
Browse files

[ARM] Add section support to ioremap 



Allow section mappings to be setup using ioremap() and torn down
with iounmap().  This requires additional support in the MM
context switch to ensure that mappings are properly synchronised
when mapped in.

Based an original implementation by Deepak Saxena, reworked and
ARMv6 support added by rmk.

Signed-off-by: default avatarRussell King <rmk+kernel@arm.linux.org.uk>
parent ba532011

arch/arm/mm/ioremap.c

+163 −4
Original line number Diff line number Diff line
@@ -27,7 +27,16 @@ 


#include <asm/cacheflush.h>

#include <asm/io.h>

#include <asm/mmu_context.h>

#include <asm/pgalloc.h>

#include <asm/tlbflush.h>

#include <asm/sizes.h>



/*

 * Used by ioremap() and iounmap() code to mark section-mapped I/O regions

 * in vm_struct->flags field.

 */

#define VM_ARM_SECTION_MAPPING	0x80000000



static inline void

remap_area_pte(pte_t * pte, unsigned long address, unsigned long size,
@@ -113,10 +122,120 @@ remap_area_pages(unsigned long start, unsigned long pfn, 
		dir++;

	} while (address && (address < end));



	flush_cache_vmap(start, end);

	return err;

}





void __check_kvm_seq(struct mm_struct *mm)

{

	unsigned int seq;



	do {

		seq = init_mm.context.kvm_seq;

		memcpy(pgd_offset(mm, VMALLOC_START),

		       pgd_offset_k(VMALLOC_START),

		       sizeof(pgd_t) * (pgd_index(VMALLOC_END) -

					pgd_index(VMALLOC_START)));

		mm->context.kvm_seq = seq;

	} while (seq != init_mm.context.kvm_seq);

}



#ifndef CONFIG_SMP

/*

 * Section support is unsafe on SMP - If you iounmap and ioremap a region,

 * the other CPUs will not see this change until their next context switch.

 * Meanwhile, (eg) if an interrupt comes in on one of those other CPUs

 * which requires the new ioremap'd region to be referenced, the CPU will

 * reference the _old_ region.

 *

 * Note that get_vm_area() allocates a guard 4K page, so we need to mask

 * the size back to 1MB aligned or we will overflow in the loop below.

 */

static void unmap_area_sections(unsigned long virt, unsigned long size)

{

	unsigned long addr = virt, end = virt + (size & ~SZ_1M);

	pgd_t *pgd;



	flush_cache_vunmap(addr, end);

	pgd = pgd_offset_k(addr);

	do {

		pmd_t pmd, *pmdp = pmd_offset(pgd, addr);



		pmd = *pmdp;

		if (!pmd_none(pmd)) {

			/*

			 * Clear the PMD from the page table, and

			 * increment the kvm sequence so others

			 * notice this change.

			 *

			 * Note: this is still racy on SMP machines.

			 */

			pmd_clear(pmdp);

			init_mm.context.kvm_seq++;



			/*

			 * Free the page table, if there was one.

			 */

			if ((pmd_val(pmd) & PMD_TYPE_MASK) == PMD_TYPE_TABLE)

				pte_free_kernel(pmd_page_kernel(pmd));

		}



		addr += PGDIR_SIZE;

		pgd++;

	} while (addr < end);



	/*

	 * Ensure that the active_mm is up to date - we want to

	 * catch any use-after-iounmap cases.

	 */

	if (current->active_mm->context.kvm_seq != init_mm.context.kvm_seq)

		__check_kvm_seq(current->active_mm);



	flush_tlb_kernel_range(virt, end);

}



static int

remap_area_sections(unsigned long virt, unsigned long pfn,

		    unsigned long size, unsigned long flags)

{

	unsigned long prot, addr = virt, end = virt + size;

	pgd_t *pgd;



	/*

	 * Remove and free any PTE-based mapping, and

	 * sync the current kernel mapping.

	 */

	unmap_area_sections(virt, size);



	prot = PMD_TYPE_SECT | PMD_SECT_AP_WRITE | PMD_DOMAIN(DOMAIN_IO) |

	       (flags & (L_PTE_CACHEABLE | L_PTE_BUFFERABLE));



	/*

	 * ARMv6 and above need XN set to prevent speculative prefetches

	 * hitting IO.

	 */

	if (cpu_architecture() >= CPU_ARCH_ARMv6)

		prot |= PMD_SECT_XN;



	pgd = pgd_offset_k(addr);

	do {

		pmd_t *pmd = pmd_offset(pgd, addr);



		pmd[0] = __pmd(__pfn_to_phys(pfn) | prot);

		pfn += SZ_1M >> PAGE_SHIFT;

		pmd[1] = __pmd(__pfn_to_phys(pfn) | prot);

		pfn += SZ_1M >> PAGE_SHIFT;

		flush_pmd_entry(pmd);



		addr += PGDIR_SIZE;

		pgd++;

	} while (addr < end);



	return 0;

}

#endif





/*

 * Remap an arbitrary physical address space into the kernel virtual

 * address space. Needed when the kernel wants to access high addresses
@@ -133,6 +252,7 @@ void __iomem * 
__ioremap_pfn(unsigned long pfn, unsigned long offset, size_t size,

	      unsigned long flags)

{

	int err;

	unsigned long addr;

 	struct vm_struct * area;
@@ -140,11 +260,22 @@ __ioremap_pfn(unsigned long pfn, unsigned long offset, size_t size, 
 	if (!area)

 		return NULL;

 	addr = (unsigned long)area->addr;

 	if (remap_area_pages(addr, pfn, size, flags)) {



#ifndef CONFIG_SMP

	if (!((__pfn_to_phys(pfn) | size | addr) & ~PMD_MASK)) {

		area->flags |= VM_ARM_SECTION_MAPPING;

		err = remap_area_sections(addr, pfn, size, flags);

	} else

#endif

		err = remap_area_pages(addr, pfn, size, flags);



	if (err) {

 		vunmap((void *)addr);

 		return NULL;

 	}

 	return (void __iomem *) (offset + (char *)addr);



	flush_cache_vmap(addr, addr + size);

	return (void __iomem *) (offset + addr);

}

EXPORT_SYMBOL(__ioremap_pfn);
@@ -173,6 +304,34 @@ EXPORT_SYMBOL(__ioremap); 


void __iounmap(void __iomem *addr)

{

	vunmap((void *)(PAGE_MASK & (unsigned long)addr));

	struct vm_struct **p, *tmp;

	unsigned int section_mapping = 0;



	addr = (void __iomem *)(PAGE_MASK & (unsigned long)addr);



	/*

	 * If this is a section based mapping we need to handle it

	 * specially as the VM subysystem does not know how to handle

	 * such a beast. We need the lock here b/c we need to clear

	 * all the mappings before the area can be reclaimed

	 * by someone else.

	 */

	write_lock(&vmlist_lock);

	for (p = &vmlist ; (tmp = *p) ; p = &tmp->next) {

		if((tmp->flags & VM_IOREMAP) && (tmp->addr == addr)) {

			if (tmp->flags & VM_ARM_SECTION_MAPPING) {

				*p = tmp->next;

				unmap_area_sections((unsigned long)tmp->addr,

						    tmp->size);

				kfree(tmp);

				section_mapping = 1;

			}

			break;

		}

	}

	write_unlock(&vmlist_lock);



	if (!section_mapping)

		vunmap(addr);

}

EXPORT_SYMBOL(__iounmap);

include/asm-arm/memory.h

+5 −0
Original line number Diff line number Diff line
@@ -68,6 +68,11 @@ 
 */

#define XIP_VIRT_ADDR(physaddr)  (MODULE_START + ((physaddr) & 0x000fffff))



/*

 * Allow 2MB-aligned ioremap pages

 */

#define IOREMAP_MAX_ORDER	21



#else /* CONFIG_MMU */



/*

include/asm-arm/mmu.h

+1 −0
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ typedef struct { 
#if __LINUX_ARM_ARCH__ >= 6

	unsigned int id;

#endif

	unsigned int kvm_seq;

} mm_context_t;



#if __LINUX_ARM_ARCH__ >= 6

include/asm-arm/mmu_context.h

+11 −1
Original line number Diff line number Diff line
@@ -17,6 +17,8 @@ 
#include <asm/cacheflush.h>

#include <asm/proc-fns.h>



void __check_kvm_seq(struct mm_struct *mm);



#if __LINUX_ARM_ARCH__ >= 6



/*
@@ -45,13 +47,21 @@ static inline void check_context(struct mm_struct *mm) 
{

	if (unlikely((mm->context.id ^ cpu_last_asid) >> ASID_BITS))

		__new_context(mm);



	if (unlikely(mm->context.kvm_seq != init_mm.context.kvm_seq))

		__check_kvm_seq(mm);

}



#define init_new_context(tsk,mm)	(__init_new_context(tsk,mm),0)



#else



#define check_context(mm)		do { } while (0)

static inline void check_context(struct mm_struct *mm)

{

	if (unlikely(mm->context.kvm_seq != init_mm.context.kvm_seq))

		__check_kvm_seq(mm);

}



#define init_new_context(tsk,mm)	0



#endif