Merge branch 'next' of git://git.monstr.eu/linux-2.6-microblaze (30eebb54) · Commits · e / devices / android_kernel_samsung_universal8890

arch/microblaze/Kconfig

+21 −12

Original line number	Diff line number	Diff line
		config MICROBLAZE
		def_bool y
		select HAVE_MEMBLOCK
		select HAVE_MEMBLOCK_NODE_MAP
		select HAVE_FUNCTION_TRACER
		select HAVE_FUNCTION_TRACE_MCOUNT_TEST
		select HAVE_FUNCTION_GRAPH_TRACER
		@@ -28,6 +29,12 @@ config SWAP
		config RWSEM_GENERIC_SPINLOCK
		def_bool y

		config ZONE_DMA
		def_bool y

		config ARCH_POPULATES_NODE_MAP
		def_bool y

		config RWSEM_XCHGADD_ALGORITHM
		bool

		@@ -153,20 +160,18 @@ config XILINX_UNCACHED_SHADOW
		The feature requires the design to define the RAM memory controller
		window to be twice as large as the actual physical memory.

		config HIGHMEM_START_BOOL
		bool "Set high memory pool address"
		depends on ADVANCED_OPTIONS && HIGHMEM
		config HIGHMEM
		bool "High memory support"
		depends on MMU
		help
		This option allows you to set the base address of the kernel virtual
		area used to map high memory pages. This can be useful in
		optimizing the layout of kernel virtual memory.
		The address space of Microblaze processors is only 4 Gigabytes large
		and it has to accommodate user address space, kernel address
		space as well as some memory mapped IO. That means that, if you
		have a large amount of physical memory and/or IO, not all of the
		memory can be "permanently mapped" by the kernel. The physical
		memory that is not permanently mapped is called "high memory".

		Say N here unless you know what you are doing.

		config HIGHMEM_START
		hex "Virtual start address of high memory pool" if HIGHMEM_START_BOOL
		depends on MMU
		default "0xfe000000"
		If unsure, say n.

		config LOWMEM_SIZE_BOOL
		bool "Set maximum low memory"
		@@ -255,6 +260,10 @@ config MICROBLAZE_32K_PAGES

		endchoice

		config KERNEL_PAD
		hex "Kernel PAD for unpacking" if ADVANCED_OPTIONS
		default "0x80000" if MMU

		endmenu

		source "mm/Kconfig"

arch/microblaze/boot/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -8,7 +8,7 @@ obj-y += linked_dtb.o

		targets := linux.bin linux.bin.gz simpleImage.%

		OBJCOPYFLAGS := -O binary
		OBJCOPYFLAGS := -R .note -R .comment -R .note.gnu.build-id -O binary

		# Ensure system.dtb exists
		$(obj)/linked_dtb.o: $(obj)/system.dtb

arch/microblaze/include/asm/fixmap.h

0 → 100644

+109 −0

Original line number	Diff line number	Diff line
		/*
		* fixmap.h: compile-time virtual memory allocation
		*
		* This file is subject to the terms and conditions of the GNU General Public
		* License. See the file "COPYING" in the main directory of this archive
		* for more details.
		*
		* Copyright (C) 1998 Ingo Molnar
		*
		* Copyright 2008 Freescale Semiconductor Inc.
		* Port to powerpc added by Kumar Gala
		*
		* Copyright 2011 Michal Simek <monstr@monstr.eu>
		* Copyright 2011 PetaLogix Qld Pty Ltd
		* Port to Microblaze
		*/

		#ifndef _ASM_FIXMAP_H
		#define _ASM_FIXMAP_H

		#ifndef __ASSEMBLY__
		#include <linux/kernel.h>
		#include <asm/page.h>
		#ifdef CONFIG_HIGHMEM
		#include <linux/threads.h>
		#include <asm/kmap_types.h>
		#endif

		#define FIXADDR_TOP ((unsigned long)(-PAGE_SIZE))

		/*
		* Here we define all the compile-time 'special' virtual
		* addresses. The point is to have a constant address at
		* compile time, but to set the physical address only
		* in the boot process. We allocate these special addresses
		* from the end of virtual memory (0xfffff000) backwards.
		* Also this lets us do fail-safe vmalloc(), we
		* can guarantee that these special addresses and
		* vmalloc()-ed addresses never overlap.
		*
		* these 'compile-time allocated' memory buffers are
		* fixed-size 4k pages. (or larger if used with an increment
		* highger than 1) use fixmap_set(idx,phys) to associate
		* physical memory with fixmap indices.
		*
		* TLB entries of such buffers will not be flushed across
		* task switches.
		*/
		enum fixed_addresses {
		FIX_HOLE,
		#ifdef CONFIG_HIGHMEM
		FIX_KMAP_BEGIN, /* reserved pte's for temporary kernel mappings */
		FIX_KMAP_END = FIX_KMAP_BEGIN + (KM_TYPE_NR * num_possible_cpus()) - 1,
		#endif
		__end_of_fixed_addresses
		};

		extern void __set_fixmap(enum fixed_addresses idx,
		phys_addr_t phys, pgprot_t flags);

		#define set_fixmap(idx, phys) \
		__set_fixmap(idx, phys, PAGE_KERNEL)
		/*
		* Some hardware wants to get fixmapped without caching.
		*/
		#define set_fixmap_nocache(idx, phys) \
		__set_fixmap(idx, phys, PAGE_KERNEL_CI)

		#define clear_fixmap(idx) \
		__set_fixmap(idx, 0, __pgprot(0))

		#define __FIXADDR_SIZE (__end_of_fixed_addresses << PAGE_SHIFT)
		#define FIXADDR_START (FIXADDR_TOP - __FIXADDR_SIZE)

		#define __fix_to_virt(x) (FIXADDR_TOP - ((x) << PAGE_SHIFT))
		#define __virt_to_fix(x) ((FIXADDR_TOP - ((x)&PAGE_MASK)) >> PAGE_SHIFT)

		extern void __this_fixmap_does_not_exist(void);

		/*
		* 'index to address' translation. If anyone tries to use the idx
		* directly without tranlation, we catch the bug with a NULL-deference
		* kernel oops. Illegal ranges of incoming indices are caught too.
		*/
		static __always_inline unsigned long fix_to_virt(const unsigned int idx)
		{
		/*
		* this branch gets completely eliminated after inlining,
		* except when someone tries to use fixaddr indices in an
		* illegal way. (such as mixing up address types or using
		* out-of-range indices).
		*
		* If it doesn't get removed, the linker will complain
		* loudly with a reasonably clear error message..
		*/
		if (idx >= __end_of_fixed_addresses)
		__this_fixmap_does_not_exist();

		return __fix_to_virt(idx);
		}

		static inline unsigned long virt_to_fix(const unsigned long vaddr)
		{
		BUG_ON(vaddr >= FIXADDR_TOP \|\| vaddr < FIXADDR_START);
		return __virt_to_fix(vaddr);
		}

		#endif /* !__ASSEMBLY__ */
		#endif

arch/microblaze/include/asm/highmem.h

0 → 100644

+96 −0

Original line number	Diff line number	Diff line
		/*
		* highmem.h: virtual kernel memory mappings for high memory
		*
		* Used in CONFIG_HIGHMEM systems for memory pages which
		* are not addressable by direct kernel virtual addresses.
		*
		* Copyright (C) 1999 Gerhard Wichert, Siemens AG
		* Gerhard.Wichert@pdb.siemens.de
		*
		*
		* Redesigned the x86 32-bit VM architecture to deal with
		* up to 16 Terabyte physical memory. With current x86 CPUs
		* we now support up to 64 Gigabytes physical RAM.
		*
		* Copyright (C) 1999 Ingo Molnar <mingo@redhat.com>
		*/
		#ifndef _ASM_HIGHMEM_H
		#define _ASM_HIGHMEM_H

		#ifdef __KERNEL__

		#include <linux/init.h>
		#include <linux/interrupt.h>
		#include <linux/uaccess.h>
		#include <asm/fixmap.h>

		extern pte_t *kmap_pte;
		extern pgprot_t kmap_prot;
		extern pte_t *pkmap_page_table;

		/*
		* Right now we initialize only a single pte table. It can be extended
		* easily, subsequent pte tables have to be allocated in one physical
		* chunk of RAM.
		*/
		/*
		* We use one full pte table with 4K pages. And with 16K/64K/256K pages pte
		* table covers enough memory (32MB/512MB/2GB resp.), so that both FIXMAP
		* and PKMAP can be placed in a single pte table. We use 512 pages for PKMAP
		* in case of 16K/64K/256K page sizes.
		*/

		#define PKMAP_ORDER PTE_SHIFT
		#define LAST_PKMAP (1 << PKMAP_ORDER)

		#define PKMAP_BASE ((FIXADDR_START - PAGE_SIZE * (LAST_PKMAP + 1)) \
		& PMD_MASK)

		#define LAST_PKMAP_MASK (LAST_PKMAP - 1)
		#define PKMAP_NR(virt) ((virt - PKMAP_BASE) >> PAGE_SHIFT)
		#define PKMAP_ADDR(nr) (PKMAP_BASE + ((nr) << PAGE_SHIFT))

		extern void kmap_high(struct page page);
		extern void kunmap_high(struct page *page);
		extern void kmap_atomic_prot(struct page page, pgprot_t prot);
		extern void __kunmap_atomic(void *kvaddr);

		static inline void kmap(struct page page)
		{
		might_sleep();
		if (!PageHighMem(page))
		return page_address(page);
		return kmap_high(page);
		}

		static inline void kunmap(struct page *page)
		{
		BUG_ON(in_interrupt());
		if (!PageHighMem(page))
		return;
		kunmap_high(page);
		}

		static inline void __kmap_atomic(struct page page)
		{
		return kmap_atomic_prot(page, kmap_prot);
		}

		static inline struct page kmap_atomic_to_page(void ptr)
		{
		unsigned long idx, vaddr = (unsigned long) ptr;
		pte_t *pte;

		if (vaddr < FIXADDR_START)
		return virt_to_page(ptr);

		idx = virt_to_fix(vaddr);
		pte = kmap_pte - (idx - FIX_KMAP_BEGIN);
		return pte_page(*pte);
		}

		#define flush_cache_kmaps() { flush_icache(); flush_dcache(); }

		#endif /* __KERNEL__ */

		#endif /* _ASM_HIGHMEM_H */

arch/microblaze/include/asm/mmu.h

+12 −0

Original line number	Diff line number	Diff line
		@@ -56,6 +56,12 @@ typedef struct _SEGREG {

		extern void _tlbie(unsigned long va); /* invalidate a TLB entry */
		extern void _tlbia(void); /* invalidate all TLB entries */

		/*
		* tlb_skip size stores actual number skipped TLBs from TLB0 - every directy TLB
		* mapping has to increase tlb_skip size.
		*/
		extern u32 tlb_skip;
		# endif /* __ASSEMBLY__ */

		/*
		@@ -69,6 +75,12 @@ extern void _tlbia(void); /* invalidate all TLB entries */

		# define MICROBLAZE_TLB_SIZE 64

		/* For cases when you want to skip some TLB entries */
		# define MICROBLAZE_TLB_SKIP 0

		/* Use the last TLB for temporary access to LMB */
		# define MICROBLAZE_LMB_TLB_ID 63

		/*
		* TLB entries are defined by a "high" tag portion and a "low" data
		* portion. The data portion is 32-bits.