Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 5be95b7e24bde4d93ff1bff5911b303043753168

Authored by Linus Torvalds 2014-12-20 09:57:51 +0800

Exists in ti-lsk-linux-4.1.y and in 10 other branches

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rkuo/linux-hexagon-kernel

Pull arch/hexagon updates from Richard Kuo:
 "Build cleanup and a few misc fixes"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rkuo/linux-hexagon-kernel:
  Hexagon: fix signal delivery for debug traps
  Hexagon: set ARCH_DMA_MINALIGN
  Hexagon: fix alignment of init_task in RW_DATA_SECTION
  hexagon: Fix build failures in linux-next

Showing 8 changed files Inline Diff

arch/hexagon/include/asm/cache.h
arch/hexagon/include/asm/cacheflush.h
arch/hexagon/include/asm/io.h
arch/hexagon/kernel/setup.c
arch/hexagon/kernel/traps.c
arch/hexagon/kernel/vmlinux.lds.S
arch/hexagon/mm/cache.c
arch/hexagon/mm/ioremap.c

arch/hexagon/include/asm/cache.h

Diff comments View file @ 5be95b7

 /*
  * Cache definitions for the Hexagon architecture
  *
- * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2010-2011,2014 The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */
 #ifndef __ASM_CACHE_H
 #define __ASM_CACHE_H
 /* Bytes per L1 cache line */
 #define L1_CACHE_SHIFT		(5)
 #define L1_CACHE_BYTES		(1 << L1_CACHE_SHIFT)
+#define ARCH_DMA_MINALIGN	L1_CACHE_BYTES
 #define __cacheline_aligned	__aligned(L1_CACHE_BYTES)
 #define ____cacheline_aligned	__aligned(L1_CACHE_BYTES)
 /* See http://lwn.net/Articles/262554/ */
 #define __read_mostly
 #endif

arch/hexagon/include/asm/cacheflush.h

Diff comments View file @ 5be95b7

 /*
  * Cache flush operations for the Hexagon architecture
  *
  * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */
 #ifndef _ASM_CACHEFLUSH_H
 #define _ASM_CACHEFLUSH_H
-#include <linux/cache.h>
+#include <linux/mm_types.h>
-#include <linux/mm.h>
-#include <asm/string.h>
-#include <asm-generic/cacheflush.h>
 /* Cache flushing:
  *
  *  - flush_cache_all() flushes entire cache
  *  - flush_cache_mm(mm) flushes the specified mm context's cache lines
  *  - flush_cache_page(mm, vmaddr, pfn) flushes a single page
  *  - flush_cache_range(vma, start, end) flushes a range of pages
  *  - flush_icache_range(start, end) flush a range of instructions
  *  - flush_dcache_page(pg) flushes(wback&invalidates) a page for dcache
  *  - flush_icache_page(vma, pg) flushes(invalidates) a page for icache
  *
  *  Need to doublecheck which one is really needed for ptrace stuff to work.
  */
 #define LINESIZE	32
 #define LINEBITS	5
+#define flush_cache_all()			do { } while (0)
+#define flush_cache_mm(mm)			do { } while (0)
+#define flush_cache_dup_mm(mm)			do { } while (0)
+#define flush_cache_range(vma, start, end)	do { } while (0)
+#define flush_cache_page(vma, vmaddr, pfn)	do { } while (0)
+#define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 0
+#define flush_dcache_page(page)			do { } while (0)
+#define flush_dcache_mmap_lock(mapping)		do { } while (0)
+#define flush_dcache_mmap_unlock(mapping)	do { } while (0)
+#define flush_icache_page(vma, pg)		do { } while (0)
+#define flush_icache_user_range(vma, pg, adr, len)	do { } while (0)
+#define flush_cache_vmap(start, end)		do { } while (0)
+#define flush_cache_vunmap(start, end)		do { } while (0)
 /*
  * Flush Dcache range through current map.
  */
 extern void flush_dcache_range(unsigned long start, unsigned long end);
 /*
  * Flush Icache range through current map.
  */
-#undef flush_icache_range
 extern void flush_icache_range(unsigned long start, unsigned long end);
 /*
  * Memory-management related flushes are there to ensure in non-physically
  * indexed cache schemes that stale lines belonging to a given ASID aren't
  * in the cache to confuse things.  The prototype Hexagon Virtual Machine
  * only uses a single ASID for all user-mode maps, which should
  * mean that they aren't necessary.  A brute-force, flush-everything
  * implementation, with the name xxxxx_hexagon() is present in
  * arch/hexagon/mm/cache.c, but let's not wire it up until we know
  * it is needed.
  */
 extern void flush_cache_all_hexagon(void);
 /*
  * This may or may not ever have to be non-null, depending on the
  * virtual machine MMU.  For a native kernel, it's definitiely  a no-op
  *
  * This is also the place where deferred cache coherency stuff seems
  * to happen, classically...  but instead we do it like ia64 and
  * clean the cache when the PTE is set.
  *
  */
 static inline void update_mmu_cache(struct vm_area_struct *vma,
 					unsigned long address, pte_t *ptep)
 {
 	/*  generic_ptrace_pokedata doesn't wind up here, does it?  */
 }
-#undef copy_to_user_page
+void copy_to_user_page(struct vm_area_struct *vma, struct page *page,
-static inline void copy_to_user_page(struct vm_area_struct *vma,
+		       unsigned long vaddr, void *dst, void *src, int len);
-					     struct page *page,
-					     unsigned long vaddr,
-					     void *dst, void *src, int len)
-{
-	memcpy(dst, src, len);

arch/hexagon/include/asm/io.h

Diff comments View file @ 5be95b7

 /*
  * IO definitions for the Hexagon architecture
  *
  * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */
 #ifndef _ASM_IO_H
 #define _ASM_IO_H
 #ifdef __KERNEL__
 #include <linux/types.h>
-#include <linux/delay.h>
-#include <linux/vmalloc.h>
-#include <asm/string.h>
-#include <asm/mem-layout.h>
 #include <asm/iomap.h>
 #include <asm/page.h>
 #include <asm/cacheflush.h>
-#include <asm/tlbflush.h>
 /*
  * We don't have PCI yet.
  * _IO_BASE is pointing at what should be unused virtual space.
  */
 #define IO_SPACE_LIMIT 0xffff
 #define _IO_BASE ((void __iomem *)0xfe000000)
 #define IOMEM(x)        ((void __force __iomem *)(x))
 extern int remap_area_pages(unsigned long start, unsigned long phys_addr,
 				unsigned long end, unsigned long flags);
 extern void __iounmap(const volatile void __iomem *addr);
 /* Defined in lib/io.c, needed for smc91x driver. */
 extern void __raw_readsw(const void __iomem *addr, void *data, int wordlen);
 extern void __raw_writesw(void __iomem *addr, const void *data, int wordlen);
 extern void __raw_readsl(const void __iomem *addr, void *data, int wordlen);
 extern void __raw_writesl(void __iomem *addr, const void *data, int wordlen);
 #define readsw(p, d, l)	__raw_readsw(p, d, l)
 #define writesw(p, d, l) __raw_writesw(p, d, l)
 #define readsl(p, d, l)   __raw_readsl(p, d, l)
 #define writesl(p, d, l)  __raw_writesl(p, d, l)
 /*
  * virt_to_phys - map virtual address to physical
  * @address:  address to map
  */
 static inline unsigned long virt_to_phys(volatile void *address)
 {
 	return __pa(address);
 }
 /*
  * phys_to_virt - map physical address to virtual
  * @address: address to map
  */
 static inline void *phys_to_virt(unsigned long address)
 {
 	return __va(address);
 }
 /*
  * convert a physical pointer to a virtual kernel pointer for
  * /dev/mem access.
  */
 #define xlate_dev_kmem_ptr(p)    __va(p)
 #define xlate_dev_mem_ptr(p)    __va(p)
 /*
  * IO port access primitives.  Hexagon doesn't have special IO access
  * instructions; all I/O is memory mapped.
  *
  * in/out are used for "ports", but we don't have "port instructions",
  * so these are really just memory mapped too.
  */
 /*
  * readb - read byte from memory mapped device
  * @addr:  pointer to memory
  *
  * Operates on "I/O bus memory space"
  */
 static inline u8 readb(const volatile void __iomem *addr)
 {
 	u8 val;
 	asm volatile(
 		"%0 = memb(%1);"
 		: "=&r" (val)
 		: "r" (addr)
 	);
 	return val;
 }
 static inline u16 readw(const volatile void __iomem *addr)
 {
 	u16 val;
 	asm volatile(
 		"%0 = memh(%1);"
 		: "=&r" (val)
 		: "r" (addr)
 	);
 	return val;
 }
 static inline u32 readl(const volatile void __iomem *addr)
 {
 	u32 val;
 	asm volatile(
 		"%0 = memw(%1);"
 		: "=&r" (val)
 		: "r" (addr)
 	);
 	return val;
 }
 /*
  * writeb - write a byte to a memory location
  * @data: data to write to
  * @addr:  pointer to memory
  *
  */
 static inline void writeb(u8 data, volatile void __iomem *addr)
 {
 	asm volatile(
 		"memb(%0) = %1;"
 		:
 		: "r" (addr), "r" (data)
 		: "memory"
 	);
 }
 static inline void writew(u16 data, volatile void __iomem *addr)
 {
 	asm volatile(
 		"memh(%0) = %1;"
 		:
 		: "r" (addr), "r" (data)
 		: "memory"
 	);
 }
 static inline void writel(u32 data, volatile void __iomem *addr)
 {
 	asm volatile(
 		"memw(%0) = %1;"
 		:
 		: "r" (addr), "r" (data)
 		: "memory"
 	);
 }
 #define __raw_writeb writeb
 #define __raw_writew writew
 #define __raw_writel writel
 #define __raw_readb readb
 #define __raw_readw readw
 #define __raw_readl readl
 /*
  * http://comments.gmane.org/gmane.linux.ports.arm.kernel/117626
  */
 #define readb_relaxed __raw_readb
 #define readw_relaxed __raw_readw
 #define readl_relaxed __raw_readl
 #define writeb_relaxed __raw_writeb
 #define writew_relaxed __raw_writew
 #define writel_relaxed __raw_writel
 #define mmiowb()
 /*
  * Need an mtype somewhere in here, for cache type deals?
  * This is probably too long for an inline.
  */
 void __iomem *ioremap_nocache(unsigned long phys_addr, unsigned long size);
 static inline void __iomem *ioremap(unsigned long phys_addr, unsigned long size)
 {
 	return ioremap_nocache(phys_addr, size);
 }
 static inline void iounmap(volatile void __iomem *addr)
 {
 	__iounmap(addr);
 }
 #define __raw_writel writel
 static inline void memcpy_fromio(void *dst, const volatile void __iomem *src,
 	int count)
 {
 	memcpy(dst, (void *) src, count);
 }
 static inline void memcpy_toio(volatile void __iomem *dst, const void *src,
 	int count)
 {
 	memcpy((void *) dst, src, count);
 }
 #define PCI_IO_ADDR	(volatile void __iomem *)
 /*
  * inb - read byte from I/O port or something
  * @port:  address in I/O space
  *
  * Operates on "I/O bus I/O space"
  */
 static inline u8 inb(unsigned long port)
 {
 	return readb(_IO_BASE + (port & IO_SPACE_LIMIT));
 }
 static inline u16 inw(unsigned long port)
 {
 	return readw(_IO_BASE + (port & IO_SPACE_LIMIT));
 }
 static inline u32 inl(unsigned long port)
 {
 	return readl(_IO_BASE + (port & IO_SPACE_LIMIT));
 }
 /*
  * outb - write a byte to a memory location
  * @data: data to write to
  * @addr:  address in I/O space
  */
 static inline void outb(u8 data, unsigned long port)
 {
 	writeb(data, _IO_BASE + (port & IO_SPACE_LIMIT));
 }
 static inline void outw(u16 data, unsigned long port)
 {
 	writew(data, _IO_BASE + (port & IO_SPACE_LIMIT));
 }
 static inline void outl(u32 data, unsigned long port)
 {
 	writel(data, _IO_BASE + (port & IO_SPACE_LIMIT));
 }
 #define outb_p outb
 #define outw_p outw
 #define outl_p outl
 #define inb_p inb
 #define inw_p inw
 #define inl_p inl
 static inline void insb(unsigned long port, void *buffer, int count)
 {
 	if (count) {
 		u8 *buf = buffer;
 		do {
 			u8 x = inb(port);
 			*buf++ = x;
 		} while (--count);
 	}
 }
 static inline void insw(unsigned long port, void *buffer, int count)
 {
 	if (count) {
 		u16 *buf = buffer;
 		do {
 			u16 x = inw(port);
 			*buf++ = x;
 		} while (--count);
 	}
 }
 static inline void insl(unsigned long port, void *buffer, int count)
 {
 	if (count) {
 		u32 *buf = buffer;
 		do {
 			u32 x = inw(port);
 			*buf++ = x;
 		} while (--count);
 	}
 }
 static inline void outsb(unsigned long port, const void *buffer, int count)
 {
 	if (count) {
 		const u8 *buf = buffer;
 		do {
 			outb(*buf++, port);
 		} while (--count);
 	}
 }
 static inline void outsw(unsigned long port, const void *buffer, int count)
 {
 	if (count) {
 		const u16 *buf = buffer;
 		do {
 			outw(*buf++, port);
 		} while (--count);
 	}
 }
 static inline void outsl(unsigned long port, const void *buffer, int count)
 {
 	if (count) {
 		const u32 *buf = buffer;
 		do {
 			outl(*buf++, port);
 		} while (--count);
 	}
 }
 #define flush_write_buffers() do { } while (0)
 #endif /* __KERNEL__ */
 #endif

arch/hexagon/kernel/setup.c

Diff comments View file @ 5be95b7

 /*
  * Arch related setup for Hexagon
  *
  * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */
 #include <linux/init.h>
+#include <linux/delay.h>
 #include <linux/bootmem.h>
 #include <linux/mmzone.h>
 #include <linux/mm.h>
 #include <linux/seq_file.h>
 #include <linux/console.h>
 #include <linux/of_fdt.h>
 #include <asm/io.h>
 #include <asm/sections.h>
 #include <asm/setup.h>
 #include <asm/processor.h>
 #include <asm/hexagon_vm.h>
 #include <asm/vm_mmu.h>
 #include <asm/time.h>
 char cmd_line[COMMAND_LINE_SIZE];
 static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;
 int on_simulator;
 void calibrate_delay(void)
 {
 	loops_per_jiffy = thread_freq_mhz * 1000000 / HZ;
 }
 /*
  * setup_arch -  high level architectural setup routine
  * @cmdline_p: pointer to pointer to command-line arguments
  */
 void __init setup_arch(char **cmdline_p)
 {
 	char *p = &external_cmdline_buffer;
 	/*
 	 * These will eventually be pulled in via either some hypervisor
 	 * or devicetree description.  Hardwiring for now.
 	 */
 	pcycle_freq_mhz = 600;
 	thread_freq_mhz = 100;
 	sleep_clk_freq = 32000;
 	/*
 	 * Set up event bindings to handle exceptions and interrupts.
 	 */
 	__vmsetvec(_K_VM_event_vector);
 	printk(KERN_INFO "PHYS_OFFSET=0x%08x\n", PHYS_OFFSET);
 	/*
 	 * Simulator has a few differences from the hardware.
 	 * For now, check uninitialized-but-mapped memory
 	 * prior to invoking setup_arch_memory().
 	 */
 	if (*(int *)((unsigned long)_end + 8) == 0x1f1f1f1f)
 		on_simulator = 1;
 	else
 		on_simulator = 0;
 	if (p[0] != '\0')
 		strlcpy(boot_command_line, p, COMMAND_LINE_SIZE);
 	else
 		strlcpy(boot_command_line, default_command_line,
 			COMMAND_LINE_SIZE);
 	/*
 	 * boot_command_line and the value set up by setup_arch
 	 * are both picked up by the init code. If no reason to
 	 * make them different, pass the same pointer back.
 	 */
 	strlcpy(cmd_line, boot_command_line, COMMAND_LINE_SIZE);
 	*cmdline_p = cmd_line;
 	parse_early_param();
 	setup_arch_memory();
 #ifdef CONFIG_SMP
 	smp_start_cpus();
 #endif
 }
 /*
  * Functions for dumping CPU info via /proc
  * Probably should move to kernel/proc.c or something.
  */
 static void *c_start(struct seq_file *m, loff_t *pos)
 {
 	return *pos < nr_cpu_ids ? (void *)((unsigned long) *pos + 1) : NULL;
 }
 static void *c_next(struct seq_file *m, void *v, loff_t *pos)
 {
 	++*pos;
 	return c_start(m, pos);
 }
 static void c_stop(struct seq_file *m, void *v)
 {
 }
 /*
  * Eventually this will dump information about
  * CPU properties like ISA level, TLB size, etc.
  */
 static int show_cpuinfo(struct seq_file *m, void *v)
 {
 	int cpu = (unsigned long) v - 1;
 #ifdef CONFIG_SMP
 	if (!cpu_online(cpu))
 		return 0;
 #endif
 	seq_printf(m, "processor\t: %d\n", cpu);
 	seq_printf(m, "model name\t: Hexagon Virtual Machine\n");
 	seq_printf(m, "BogoMips\t: %lu.%02lu\n",
 		(loops_per_jiffy * HZ) / 500000,
 		((loops_per_jiffy * HZ) / 5000) % 100);
 	seq_printf(m, "\n");
 	return 0;
 }
 const struct seq_operations cpuinfo_op = {
 	.start  = &c_start,
 	.next   = &c_next,
 	.stop   = &c_stop,
 	.show   = &show_cpuinfo,
 };

arch/hexagon/kernel/traps.c

Diff comments View file @ 5be95b7

1	/*	1	/*
2	* Kernel traps/events for Hexagon processor	2	* Kernel traps/events for Hexagon processor
3	*	3	*
4	* Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.	4	* Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
5	*	5	*
6	* This program is free software; you can redistribute it and/or modify	6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License version 2 and	7	* it under the terms of the GNU General Public License version 2 and
8	* only version 2 as published by the Free Software Foundation.	8	* only version 2 as published by the Free Software Foundation.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.	13	* GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License	15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software	16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18	* 02110-1301, USA.	18	* 02110-1301, USA.
19	*/	19	*/
20		20
21	#include <linux/init.h>	21	#include <linux/init.h>
22	#include <linux/sched.h>	22	#include <linux/sched.h>
23	#include <linux/module.h>	23	#include <linux/module.h>
24	#include <linux/kallsyms.h>	24	#include <linux/kallsyms.h>
25	#include <linux/kdebug.h>	25	#include <linux/kdebug.h>
26	#include <linux/syscalls.h>	26	#include <linux/syscalls.h>
27	#include <linux/signal.h>	27	#include <linux/signal.h>
28	#include <linux/tracehook.h>	28	#include <linux/tracehook.h>
29	#include <asm/traps.h>	29	#include <asm/traps.h>
30	#include <asm/vm_fault.h>	30	#include <asm/vm_fault.h>
31	#include <asm/syscall.h>	31	#include <asm/syscall.h>
32	#include <asm/registers.h>	32	#include <asm/registers.h>
33	#include <asm/unistd.h>	33	#include <asm/unistd.h>
34	#include <asm/sections.h>	34	#include <asm/sections.h>
35	#ifdef CONFIG_KGDB	35	#ifdef CONFIG_KGDB
36	# include <linux/kgdb.h>	36	# include <linux/kgdb.h>
37	#endif	37	#endif
38		38
39	#define TRAP_SYSCALL 1	39	#define TRAP_SYSCALL 1
40	#define TRAP_DEBUG 0xdb	40	#define TRAP_DEBUG 0xdb
41		41
42	void __init trap_init(void)	42	void __init trap_init(void)
43	{	43	{
44	}	44	}
45		45
46	#ifdef CONFIG_GENERIC_BUG	46	#ifdef CONFIG_GENERIC_BUG
47	/* Maybe should resemble arch/sh/kernel/traps.c ?? */	47	/* Maybe should resemble arch/sh/kernel/traps.c ?? */
48	int is_valid_bugaddr(unsigned long addr)	48	int is_valid_bugaddr(unsigned long addr)
49	{	49	{
50	return 1;	50	return 1;
51	}	51	}
52	#endif /* CONFIG_GENERIC_BUG */	52	#endif /* CONFIG_GENERIC_BUG */
53		53
54	static const char *ex_name(int ex)	54	static const char *ex_name(int ex)
55	{	55	{
56	switch (ex) {	56	switch (ex) {
57	case HVM_GE_C_XPROT:	57	case HVM_GE_C_XPROT:
58	case HVM_GE_C_XUSER:	58	case HVM_GE_C_XUSER:
59	return "Execute protection fault";	59	return "Execute protection fault";
60	case HVM_GE_C_RPROT:	60	case HVM_GE_C_RPROT:
61	case HVM_GE_C_RUSER:	61	case HVM_GE_C_RUSER:
62	return "Read protection fault";	62	return "Read protection fault";
63	case HVM_GE_C_WPROT:	63	case HVM_GE_C_WPROT:
64	case HVM_GE_C_WUSER:	64	case HVM_GE_C_WUSER:
65	return "Write protection fault";	65	return "Write protection fault";
66	case HVM_GE_C_XMAL:	66	case HVM_GE_C_XMAL:
67	return "Misaligned instruction";	67	return "Misaligned instruction";
68	case HVM_GE_C_WREG:	68	case HVM_GE_C_WREG:
69	return "Multiple writes to same register in packet";	69	return "Multiple writes to same register in packet";
70	case HVM_GE_C_PCAL:	70	case HVM_GE_C_PCAL:
71	return "Program counter values that are not properly aligned";	71	return "Program counter values that are not properly aligned";
72	case HVM_GE_C_RMAL:	72	case HVM_GE_C_RMAL:
73	return "Misaligned data load";	73	return "Misaligned data load";
74	case HVM_GE_C_WMAL:	74	case HVM_GE_C_WMAL:
75	return "Misaligned data store";	75	return "Misaligned data store";
76	case HVM_GE_C_INVI:	76	case HVM_GE_C_INVI:
77	case HVM_GE_C_PRIVI:	77	case HVM_GE_C_PRIVI:
78	return "Illegal instruction";	78	return "Illegal instruction";
79	case HVM_GE_C_BUS:	79	case HVM_GE_C_BUS:
80	return "Precise bus error";	80	return "Precise bus error";
81	case HVM_GE_C_CACHE:	81	case HVM_GE_C_CACHE:
82	return "Cache error";	82	return "Cache error";
83		83
84	case 0xdb:	84	case 0xdb:
85	return "Debugger trap";	85	return "Debugger trap";
86		86
87	default:	87	default:
88	return "Unrecognized exception";	88	return "Unrecognized exception";
89	}	89	}
90	}	90	}
91		91
92	static void do_show_stack(struct task_struct task, unsigned long fp,	92	static void do_show_stack(struct task_struct task, unsigned long fp,
93	unsigned long ip)	93	unsigned long ip)
94	{	94	{
95	int kstack_depth_to_print = 24;	95	int kstack_depth_to_print = 24;
96	unsigned long offset, size;	96	unsigned long offset, size;
97	const char *name = NULL;	97	const char *name = NULL;
98	unsigned long *newfp;	98	unsigned long *newfp;
99	unsigned long low, high;	99	unsigned long low, high;
100	char tmpstr[128];	100	char tmpstr[128];
101	char *modname;	101	char *modname;
102	int i;	102	int i;
103		103
104	if (task == NULL)	104	if (task == NULL)
105	task = current;	105	task = current;
106		106
107	printk(KERN_INFO "CPU#%d, %s/%d, Call Trace:\n",	107	printk(KERN_INFO "CPU#%d, %s/%d, Call Trace:\n",
108	raw_smp_processor_id(), task->comm,	108	raw_smp_processor_id(), task->comm,
109	task_pid_nr(task));	109	task_pid_nr(task));
110		110
111	if (fp == NULL) {	111	if (fp == NULL) {
112	if (task == current) {	112	if (task == current) {
113	asm("%0 = r30" : "=r" (fp));	113	asm("%0 = r30" : "=r" (fp));
114	} else {	114	} else {
115	fp = (unsigned long *)	115	fp = (unsigned long *)
116	((struct hexagon_switch_stack *)	116	((struct hexagon_switch_stack *)
117	task->thread.switch_sp)->fp;	117	task->thread.switch_sp)->fp;
118	}	118	}
119	}	119	}
120		120
121	if ((((unsigned long) fp) & 0x3) \|\| ((unsigned long) fp < 0x1000)) {	121	if ((((unsigned long) fp) & 0x3) \|\| ((unsigned long) fp < 0x1000)) {
122	printk(KERN_INFO "-- Corrupt frame pointer %p\n", fp);	122	printk(KERN_INFO "-- Corrupt frame pointer %p\n", fp);
123	return;	123	return;
124	}	124	}
125		125
126	/* Saved link reg is one word above FP */	126	/* Saved link reg is one word above FP */
127	if (!ip)	127	if (!ip)
128	ip = *(fp+1);	128	ip = *(fp+1);
129		129
130	/* Expect kernel stack to be in-bounds */	130	/* Expect kernel stack to be in-bounds */
131	low = (unsigned long)task_stack_page(task);	131	low = (unsigned long)task_stack_page(task);
132	high = low + THREAD_SIZE - 8;	132	high = low + THREAD_SIZE - 8;
133	low += sizeof(struct thread_info);	133	low += sizeof(struct thread_info);
134		134
135	for (i = 0; i < kstack_depth_to_print; i++) {	135	for (i = 0; i < kstack_depth_to_print; i++) {
136		136
137	name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);	137	name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);
138		138
139	printk(KERN_INFO "[%p] 0x%lx: %s + 0x%lx", fp, ip, name,	139	printk(KERN_INFO "[%p] 0x%lx: %s + 0x%lx", fp, ip, name,
140	offset);	140	offset);
141	if (((unsigned long) fp < low) \|\| (high < (unsigned long) fp))	141	if (((unsigned long) fp < low) \|\| (high < (unsigned long) fp))
142	printk(KERN_CONT " (FP out of bounds!)");	142	printk(KERN_CONT " (FP out of bounds!)");
143	if (modname)	143	if (modname)
144	printk(KERN_CONT " [%s] ", modname);	144	printk(KERN_CONT " [%s] ", modname);
145	printk(KERN_CONT "\n");	145	printk(KERN_CONT "\n");
146		146
147	newfp = (unsigned long ) fp;	147	newfp = (unsigned long ) fp;
148		148
149	if (((unsigned long) newfp) & 0x3) {	149	if (((unsigned long) newfp) & 0x3) {
150	printk(KERN_INFO "-- Corrupt frame pointer %p\n",	150	printk(KERN_INFO "-- Corrupt frame pointer %p\n",
151	newfp);	151	newfp);
152	break;	152	break;
153	}	153	}
154		154
155	/* Attempt to continue past exception. */	155	/* Attempt to continue past exception. */
156	if (0 == newfp) {	156	if (0 == newfp) {
157	struct pt_regs regs = (struct pt_regs ) (((void *)fp)	157	struct pt_regs regs = (struct pt_regs ) (((void *)fp)
158	+ 8);	158	+ 8);
159		159
160	if (regs->syscall_nr != -1) {	160	if (regs->syscall_nr != -1) {
161	printk(KERN_INFO "-- trap0 -- syscall_nr: %ld",	161	printk(KERN_INFO "-- trap0 -- syscall_nr: %ld",
162	regs->syscall_nr);	162	regs->syscall_nr);
163	printk(KERN_CONT " psp: %lx elr: %lx\n",	163	printk(KERN_CONT " psp: %lx elr: %lx\n",
164	pt_psp(regs), pt_elr(regs));	164	pt_psp(regs), pt_elr(regs));
165	break;	165	break;
166	} else {	166	} else {
167	/* really want to see more ... */	167	/* really want to see more ... */
168	kstack_depth_to_print += 6;	168	kstack_depth_to_print += 6;
169	printk(KERN_INFO "-- %s (0x%lx) badva: %lx\n",	169	printk(KERN_INFO "-- %s (0x%lx) badva: %lx\n",
170	ex_name(pt_cause(regs)), pt_cause(regs),	170	ex_name(pt_cause(regs)), pt_cause(regs),
171	pt_badva(regs));	171	pt_badva(regs));
172	}	172	}
173		173
174	newfp = (unsigned long *) regs->r30;	174	newfp = (unsigned long *) regs->r30;
175	ip = pt_elr(regs);	175	ip = pt_elr(regs);
176	} else {	176	} else {
177	ip = *(newfp + 1);	177	ip = *(newfp + 1);
178	}	178	}
179		179
180	/* If link reg is null, we are done. */	180	/* If link reg is null, we are done. */
181	if (ip == 0x0)	181	if (ip == 0x0)
182	break;	182	break;
183		183
184	/* If newfp isn't larger, we're tracing garbage. */	184	/* If newfp isn't larger, we're tracing garbage. */
185	if (newfp > fp)	185	if (newfp > fp)
186	fp = newfp;	186	fp = newfp;
187	else	187	else
188	break;	188	break;
189	}	189	}
190	}	190	}
191		191
192	void show_stack(struct task_struct task, unsigned long fp)	192	void show_stack(struct task_struct task, unsigned long fp)
193	{	193	{
194	/* Saved link reg is one word above FP */	194	/* Saved link reg is one word above FP */
195	do_show_stack(task, fp, 0);	195	do_show_stack(task, fp, 0);
196	}	196	}
197		197
198	int die(const char str, struct pt_regs regs, long err)	198	int die(const char str, struct pt_regs regs, long err)
199	{	199	{
200	static struct {	200	static struct {
201	spinlock_t lock;	201	spinlock_t lock;
202	int counter;	202	int counter;
203	} die = {	203	} die = {
204	.lock = __SPIN_LOCK_UNLOCKED(die.lock),	204	.lock = __SPIN_LOCK_UNLOCKED(die.lock),
205	.counter = 0	205	.counter = 0
206	};	206	};
207		207
208	console_verbose();	208	console_verbose();
209	oops_enter();	209	oops_enter();
210		210
211	spin_lock_irq(&die.lock);	211	spin_lock_irq(&die.lock);
212	bust_spinlocks(1);	212	bust_spinlocks(1);
213	printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);	213	printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);
214		214
215	if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==	215	if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
216	NOTIFY_STOP)	216	NOTIFY_STOP)
217	return 1;	217	return 1;
218		218
219	print_modules();	219	print_modules();
220	show_regs(regs);	220	show_regs(regs);
221	do_show_stack(current, &regs->r30, pt_elr(regs));	221	do_show_stack(current, &regs->r30, pt_elr(regs));
222		222
223	bust_spinlocks(0);	223	bust_spinlocks(0);
224	add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);	224	add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);
225		225
226	spin_unlock_irq(&die.lock);	226	spin_unlock_irq(&die.lock);
227		227
228	if (in_interrupt())	228	if (in_interrupt())
229	panic("Fatal exception in interrupt");	229	panic("Fatal exception in interrupt");
230		230
231	if (panic_on_oops)	231	if (panic_on_oops)
232	panic("Fatal exception");	232	panic("Fatal exception");
233		233
234	oops_exit();	234	oops_exit();
235	do_exit(err);	235	do_exit(err);
236	return 0;	236	return 0;
237	}	237	}
238		238
239	int die_if_kernel(char str, struct pt_regs regs, long err)	239	int die_if_kernel(char str, struct pt_regs regs, long err)
240	{	240	{
241	if (!user_mode(regs))	241	if (!user_mode(regs))
242	return die(str, regs, err);	242	return die(str, regs, err);
243	else	243	else
244	return 0;	244	return 0;
245	}	245	}
246		246
247	/*	247	/*
248	* It's not clear that misaligned fetches are ever recoverable.	248	* It's not clear that misaligned fetches are ever recoverable.
249	*/	249	*/
250	static void misaligned_instruction(struct pt_regs *regs)	250	static void misaligned_instruction(struct pt_regs *regs)
251	{	251	{
252	die_if_kernel("Misaligned Instruction", regs, 0);	252	die_if_kernel("Misaligned Instruction", regs, 0);
253	force_sig(SIGBUS, current);	253	force_sig(SIGBUS, current);
254	}	254	}
255		255
256	/*	256	/*
257	* Misaligned loads and stores, on the other hand, can be	257	* Misaligned loads and stores, on the other hand, can be
258	* emulated, and probably should be, some day. But for now	258	* emulated, and probably should be, some day. But for now
259	* they will be considered fatal.	259	* they will be considered fatal.
260	*/	260	*/
261	static void misaligned_data_load(struct pt_regs *regs)	261	static void misaligned_data_load(struct pt_regs *regs)
262	{	262	{
263	die_if_kernel("Misaligned Data Load", regs, 0);	263	die_if_kernel("Misaligned Data Load", regs, 0);
264	force_sig(SIGBUS, current);	264	force_sig(SIGBUS, current);
265	}	265	}
266		266
267	static void misaligned_data_store(struct pt_regs *regs)	267	static void misaligned_data_store(struct pt_regs *regs)
268	{	268	{
269	die_if_kernel("Misaligned Data Store", regs, 0);	269	die_if_kernel("Misaligned Data Store", regs, 0);
270	force_sig(SIGBUS, current);	270	force_sig(SIGBUS, current);
271	}	271	}
272		272
273	static void illegal_instruction(struct pt_regs *regs)	273	static void illegal_instruction(struct pt_regs *regs)
274	{	274	{
275	die_if_kernel("Illegal Instruction", regs, 0);	275	die_if_kernel("Illegal Instruction", regs, 0);
276	force_sig(SIGILL, current);	276	force_sig(SIGILL, current);
277	}	277	}
278		278
279	/*	279	/*
280	* Precise bus errors may be recoverable with a a retry,	280	* Precise bus errors may be recoverable with a a retry,
281	* but for now, treat them as irrecoverable.	281	* but for now, treat them as irrecoverable.
282	*/	282	*/
283	static void precise_bus_error(struct pt_regs *regs)	283	static void precise_bus_error(struct pt_regs *regs)
284	{	284	{
285	die_if_kernel("Precise Bus Error", regs, 0);	285	die_if_kernel("Precise Bus Error", regs, 0);
286	force_sig(SIGBUS, current);	286	force_sig(SIGBUS, current);
287	}	287	}
288		288
289	/*	289	/*
290	* If anything is to be done here other than panic,	290	* If anything is to be done here other than panic,
291	* it will probably be complex and migrate to another	291	* it will probably be complex and migrate to another
292	* source module. For now, just die.	292	* source module. For now, just die.
293	*/	293	*/
294	static void cache_error(struct pt_regs *regs)	294	static void cache_error(struct pt_regs *regs)
295	{	295	{
296	die("Cache Error", regs, 0);	296	die("Cache Error", regs, 0);
297	}	297	}
298		298
299	/*	299	/*
300	* General exception handler	300	* General exception handler
301	*/	301	*/
302	void do_genex(struct pt_regs *regs)	302	void do_genex(struct pt_regs *regs)
303	{	303	{
304	/*	304	/*
305	* Decode Cause and Dispatch	305	* Decode Cause and Dispatch
306	*/	306	*/
307	switch (pt_cause(regs)) {	307	switch (pt_cause(regs)) {
308	case HVM_GE_C_XPROT:	308	case HVM_GE_C_XPROT:
309	case HVM_GE_C_XUSER:	309	case HVM_GE_C_XUSER:
310	execute_protection_fault(regs);	310	execute_protection_fault(regs);
311	break;	311	break;
312	case HVM_GE_C_RPROT:	312	case HVM_GE_C_RPROT:
313	case HVM_GE_C_RUSER:	313	case HVM_GE_C_RUSER:
314	read_protection_fault(regs);	314	read_protection_fault(regs);
315	break;	315	break;
316	case HVM_GE_C_WPROT:	316	case HVM_GE_C_WPROT:
317	case HVM_GE_C_WUSER:	317	case HVM_GE_C_WUSER:
318	write_protection_fault(regs);	318	write_protection_fault(regs);
319	break;	319	break;
320	case HVM_GE_C_XMAL:	320	case HVM_GE_C_XMAL:
321	misaligned_instruction(regs);	321	misaligned_instruction(regs);
322	break;	322	break;
323	case HVM_GE_C_WREG:	323	case HVM_GE_C_WREG:
324	illegal_instruction(regs);	324	illegal_instruction(regs);
325	break;	325	break;
326	case HVM_GE_C_PCAL:	326	case HVM_GE_C_PCAL:
327	misaligned_instruction(regs);	327	misaligned_instruction(regs);
328	break;	328	break;
329	case HVM_GE_C_RMAL:	329	case HVM_GE_C_RMAL:
330	misaligned_data_load(regs);	330	misaligned_data_load(regs);
331	break;	331	break;
332	case HVM_GE_C_WMAL:	332	case HVM_GE_C_WMAL:
333	misaligned_data_store(regs);	333	misaligned_data_store(regs);
334	break;	334	break;
335	case HVM_GE_C_INVI:	335	case HVM_GE_C_INVI:
336	case HVM_GE_C_PRIVI:	336	case HVM_GE_C_PRIVI:
337	illegal_instruction(regs);	337	illegal_instruction(regs);
338	break;	338	break;
339	case HVM_GE_C_BUS:	339	case HVM_GE_C_BUS:
340	precise_bus_error(regs);	340	precise_bus_error(regs);
341	break;	341	break;
342	case HVM_GE_C_CACHE:	342	case HVM_GE_C_CACHE:
343	cache_error(regs);	343	cache_error(regs);
344	break;	344	break;
345	default:	345	default:
346	/* Halt and catch fire */	346	/* Halt and catch fire */
347	panic("Unrecognized exception 0x%lx\n", pt_cause(regs));	347	panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
348	break;	348	break;
349	}	349	}
350	}	350	}
351		351
352	/* Indirect system call dispatch */	352	/* Indirect system call dispatch */
353	long sys_syscall(void)	353	long sys_syscall(void)
354	{	354	{
355	printk(KERN_ERR "sys_syscall invoked!\n");	355	printk(KERN_ERR "sys_syscall invoked!\n");
356	return -ENOSYS;	356	return -ENOSYS;
357	}	357	}
358		358
359	void do_trap0(struct pt_regs *regs)	359	void do_trap0(struct pt_regs *regs)
360	{	360	{
361	syscall_fn syscall;	361	syscall_fn syscall;
362		362
363	switch (pt_cause(regs)) {	363	switch (pt_cause(regs)) {
364	case TRAP_SYSCALL:	364	case TRAP_SYSCALL:
365	/* System call is trap0 #1 */	365	/* System call is trap0 #1 */
366		366
367	/* allow strace to catch syscall args */	367	/* allow strace to catch syscall args */
368	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&	368	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
369	tracehook_report_syscall_entry(regs)))	369	tracehook_report_syscall_entry(regs)))
370	return; /* return -ENOSYS somewhere? */	370	return; /* return -ENOSYS somewhere? */
371		371
372	/* Interrupts should be re-enabled for syscall processing */	372	/* Interrupts should be re-enabled for syscall processing */
373	__vmsetie(VM_INT_ENABLE);	373	__vmsetie(VM_INT_ENABLE);
374		374
375	/*	375	/*
376	* System call number is in r6, arguments in r0..r5.	376	* System call number is in r6, arguments in r0..r5.
377	* Fortunately, no Linux syscall has more than 6 arguments,	377	* Fortunately, no Linux syscall has more than 6 arguments,
378	* and Hexagon ABI passes first 6 arguments in registers.	378	* and Hexagon ABI passes first 6 arguments in registers.
379	* 64-bit arguments are passed in odd/even register pairs.	379	* 64-bit arguments are passed in odd/even register pairs.
380	* Fortunately, we have no system calls that take more	380	* Fortunately, we have no system calls that take more
381	* than three arguments with more than one 64-bit value.	381	* than three arguments with more than one 64-bit value.
382	* Should that change, we'd need to redesign to copy	382	* Should that change, we'd need to redesign to copy
383	* between user and kernel stacks.	383	* between user and kernel stacks.
384	*/	384	*/
385	regs->syscall_nr = regs->r06;	385	regs->syscall_nr = regs->r06;
386		386
387	/*	387	/*
388	* GPR R0 carries the first parameter, and is also used	388	* GPR R0 carries the first parameter, and is also used
389	* to report the return value. We need a backup of	389	* to report the return value. We need a backup of
390	* the user's value in case we need to do a late restart	390	* the user's value in case we need to do a late restart
391	* of the system call.	391	* of the system call.
392	*/	392	*/
393	regs->restart_r0 = regs->r00;	393	regs->restart_r0 = regs->r00;
394		394
395	if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {	395	if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
396	regs->r00 = -1;	396	regs->r00 = -1;
397	} else {	397	} else {
398	syscall = (syscall_fn)	398	syscall = (syscall_fn)
399	(sys_call_table[regs->syscall_nr]);	399	(sys_call_table[regs->syscall_nr]);
400	regs->r00 = syscall(regs->r00, regs->r01,	400	regs->r00 = syscall(regs->r00, regs->r01,
401	regs->r02, regs->r03,	401	regs->r02, regs->r03,
402	regs->r04, regs->r05);	402	regs->r04, regs->r05);
403	}	403	}
404		404
405	/* allow strace to get the syscall return state */	405	/* allow strace to get the syscall return state */
406	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))	406	if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
407	tracehook_report_syscall_exit(regs, 0);	407	tracehook_report_syscall_exit(regs, 0);
408		408
409	break;	409	break;
410	case TRAP_DEBUG:	410	case TRAP_DEBUG:
411	/* Trap0 0xdb is debug breakpoint */	411	/* Trap0 0xdb is debug breakpoint */
412	if (user_mode(regs)) {	412	if (user_mode(regs)) {
413	struct siginfo info;	413	struct siginfo info;
414		414
415	info.si_signo = SIGTRAP;	415	info.si_signo = SIGTRAP;
416	info.si_errno = 0;	416	info.si_errno = 0;
417	/*	417	/*
418	* Some architecures add some per-thread state	418	* Some architecures add some per-thread state
419	* to distinguish between breakpoint traps and	419	* to distinguish between breakpoint traps and
420	* trace traps. We may want to do that, and	420	* trace traps. We may want to do that, and
421	* set the si_code value appropriately, or we	421	* set the si_code value appropriately, or we
422	* may want to use a different trap0 flavor.	422	* may want to use a different trap0 flavor.
423	*/	423	*/
424	info.si_code = TRAP_BRKPT;	424	info.si_code = TRAP_BRKPT;
425	info.si_addr = (void __user *) pt_elr(regs);	425	info.si_addr = (void __user *) pt_elr(regs);
426	send_sig_info(SIGTRAP, &info, current);	426	force_sig_info(SIGTRAP, &info, current);
427	} else {	427	} else {
428	#ifdef CONFIG_KGDB	428	#ifdef CONFIG_KGDB
429	kgdb_handle_exception(pt_cause(regs), SIGTRAP,	429	kgdb_handle_exception(pt_cause(regs), SIGTRAP,
430	TRAP_BRKPT, regs);	430	TRAP_BRKPT, regs);
431	#endif	431	#endif
432	}	432	}
433	break;	433	break;
434	}	434	}
435	/* Ignore other trap0 codes for now, especially 0 (Angel calls) */	435	/* Ignore other trap0 codes for now, especially 0 (Angel calls) */
436	}	436	}
437		437
438	/*	438	/*
439	* Machine check exception handler	439	* Machine check exception handler
440	*/	440	*/
441	void do_machcheck(struct pt_regs *regs)	441	void do_machcheck(struct pt_regs *regs)
442	{	442	{
443	/* Halt and catch fire */	443	/* Halt and catch fire */
444	__vmstop();	444	__vmstop();
445	}	445	}
446		446
447	/*	447	/*
448	* Treat this like the old 0xdb trap.	448	* Treat this like the old 0xdb trap.
449	*/	449	*/
450		450
451	void do_debug_exception(struct pt_regs *regs)	451	void do_debug_exception(struct pt_regs *regs)
452	{	452	{
453	regs->hvmer.vmest &= ~HVM_VMEST_CAUSE_MSK;	453	regs->hvmer.vmest &= ~HVM_VMEST_CAUSE_MSK;
454	regs->hvmer.vmest \|= (TRAP_DEBUG << HVM_VMEST_CAUSE_SFT);	454	regs->hvmer.vmest \|= (TRAP_DEBUG << HVM_VMEST_CAUSE_SFT);
455	do_trap0(regs);	455	do_trap0(regs);
456	}	456	}
457		457

arch/hexagon/kernel/vmlinux.lds.S

Diff comments View file @ 5be95b7

1	/*	1	/*
2	* Linker script for Hexagon kernel	2	* Linker script for Hexagon kernel
3	*	3	*
4	* Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.	4	* Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
5	*	5	*
6	* This program is free software; you can redistribute it and/or modify	6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License version 2 and	7	* it under the terms of the GNU General Public License version 2 and
8	* only version 2 as published by the Free Software Foundation.	8	* only version 2 as published by the Free Software Foundation.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.	13	* GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License	15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software	16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18	* 02110-1301, USA.	18	* 02110-1301, USA.
19	*/	19	*/
20		20
21	#include <asm-generic/vmlinux.lds.h>	21	#include <asm-generic/vmlinux.lds.h>
22	#include <asm/asm-offsets.h> /* Most of the kernel defines are here */	22	#include <asm/asm-offsets.h> /* Most of the kernel defines are here */
23	#include <asm/mem-layout.h> /* except for page_offset */	23	#include <asm/mem-layout.h> /* except for page_offset */
24	#include <asm/cache.h> /* and now we're pulling cache line size */	24	#include <asm/cache.h> /* and now we're pulling cache line size */
25	OUTPUT_ARCH(hexagon)	25	OUTPUT_ARCH(hexagon)
26	ENTRY(stext)	26	ENTRY(stext)
27		27
28	jiffies = jiffies_64;	28	jiffies = jiffies_64;
29		29
30	/*	30	/*
31	See asm-generic/vmlinux.lds.h for expansion of some of these macros.	31	See asm-generic/vmlinux.lds.h for expansion of some of these macros.
32	See asm-generic/sections.h for seemingly required labels.	32	See asm-generic/sections.h for seemingly required labels.
33	*/	33	*/
34		34
35	#define PAGE_SIZE _PAGE_SIZE	35	#define PAGE_SIZE _PAGE_SIZE
36		36
37	SECTIONS	37	SECTIONS
38	{	38	{
39	. = PAGE_OFFSET;	39	. = PAGE_OFFSET;
40		40
41	__init_begin = .;	41	__init_begin = .;
42	HEAD_TEXT_SECTION	42	HEAD_TEXT_SECTION
43	INIT_TEXT_SECTION(PAGE_SIZE)	43	INIT_TEXT_SECTION(PAGE_SIZE)
44	PERCPU_SECTION(L1_CACHE_BYTES)	44	PERCPU_SECTION(L1_CACHE_BYTES)
45	__init_end = .;	45	__init_end = .;
46		46
47	. = ALIGN(_PAGE_SIZE);	47	. = ALIGN(_PAGE_SIZE);
48	_stext = .;	48	_stext = .;
49	.text : AT(ADDR(.text)) {	49	.text : AT(ADDR(.text)) {
50	_text = .;	50	_text = .;
51	TEXT_TEXT	51	TEXT_TEXT
52	SCHED_TEXT	52	SCHED_TEXT
53	LOCK_TEXT	53	LOCK_TEXT
54	KPROBES_TEXT	54	KPROBES_TEXT
55	*(.fixup)	55	*(.fixup)
56	}	56	}
57	_etext = .;	57	_etext = .;
58		58
59	INIT_DATA_SECTION(PAGE_SIZE)	59	INIT_DATA_SECTION(PAGE_SIZE)
60		60
61	_sdata = .;	61	_sdata = .;
62	RW_DATA_SECTION(32,PAGE_SIZE,PAGE_SIZE)	62	RW_DATA_SECTION(32,PAGE_SIZE,_THREAD_SIZE)
63	RO_DATA_SECTION(PAGE_SIZE)	63	RO_DATA_SECTION(PAGE_SIZE)
64	_edata = .;	64	_edata = .;
65		65
66	EXCEPTION_TABLE(16)	66	EXCEPTION_TABLE(16)
67	NOTES	67	NOTES
68		68
69	BSS_SECTION(_PAGE_SIZE, _PAGE_SIZE, _PAGE_SIZE)	69	BSS_SECTION(_PAGE_SIZE, _PAGE_SIZE, _PAGE_SIZE)
70		70
71	_end = .;	71	_end = .;
72		72
73	/DISCARD/ : {	73	/DISCARD/ : {
74	EXIT_TEXT	74	EXIT_TEXT
75	EXIT_DATA	75	EXIT_DATA
76	EXIT_CALL	76	EXIT_CALL
77	}	77	}
78		78
79	STABS_DEBUG	79	STABS_DEBUG
80	DWARF_DEBUG	80	DWARF_DEBUG
81		81
82	}	82	}
83		83

arch/hexagon/mm/cache.c

Diff comments View file @ 5be95b7

 /*
  * Cache management functions for Hexagon
  *
  * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */
 #include <linux/mm.h>
 #include <asm/cacheflush.h>
 #include <asm/hexagon_vm.h>
 #define spanlines(start, end) \
 	(((end - (start & ~(LINESIZE - 1))) >> LINEBITS) + 1)
 void flush_dcache_range(unsigned long start, unsigned long end)
 {
 	unsigned long lines = spanlines(start, end-1);
 	unsigned long i, flags;
 	start &= ~(LINESIZE - 1);
 	local_irq_save(flags);
 	for (i = 0; i < lines; i++) {
 		__asm__ __volatile__ (
 		"	dccleaninva(%0);	"
 		:
 		: "r" (start)
 		);
 		start += LINESIZE;
 	}
 	local_irq_restore(flags);
 }
 void flush_icache_range(unsigned long start, unsigned long end)
 {
 	unsigned long lines = spanlines(start, end-1);
 	unsigned long i, flags;
 	start &= ~(LINESIZE - 1);
 	local_irq_save(flags);
 	for (i = 0; i < lines; i++) {
 		__asm__ __volatile__ (
 			"	dccleana(%0); "
 			"	icinva(%0);	"
 			:
 			: "r" (start)
 		);
 		start += LINESIZE;
 	}
 	__asm__ __volatile__ (
 		"isync"
 	);
 	local_irq_restore(flags);
 }
 EXPORT_SYMBOL(flush_icache_range);
 void hexagon_clean_dcache_range(unsigned long start, unsigned long end)
 {
 	unsigned long lines = spanlines(start, end-1);
 	unsigned long i, flags;
 	start &= ~(LINESIZE - 1);
 	local_irq_save(flags);
 	for (i = 0; i < lines; i++) {
 		__asm__ __volatile__ (
 		"	dccleana(%0);	"
 		:
 		: "r" (start)
 		);
 		start += LINESIZE;
 	}
 	local_irq_restore(flags);
 }
 void hexagon_inv_dcache_range(unsigned long start, unsigned long end)
 {
 	unsigned long lines = spanlines(start, end-1);
 	unsigned long i, flags;
 	start &= ~(LINESIZE - 1);
 	local_irq_save(flags);
 	for (i = 0; i < lines; i++) {
 		__asm__ __volatile__ (
 		"	dcinva(%0);	"
 		:
 		: "r" (start)
 		);
 		start += LINESIZE;
 	}
 	local_irq_restore(flags);
 }
 /*
  * This is just really brutal and shouldn't be used anyways,
  * especially on V2.  Left here just in case.
  */
 void flush_cache_all_hexagon(void)
 {
 	unsigned long flags;
 	local_irq_save(flags);
 	__vmcache_ickill();
 	__vmcache_dckill();
 	__vmcache_l2kill();
 	local_irq_restore(flags);
 	mb();
 }
+void copy_to_user_page(struct vm_area_struct *vma, struct page *page,
+		       unsigned long vaddr, void *dst, void *src, int len)
+{
+	memcpy(dst, src, len);
+	if (vma->vm_flags & VM_EXEC) {
+		flush_icache_range((unsigned long) dst,
+		(unsigned long) dst + len);
+	}
+}

arch/hexagon/mm/ioremap.c

Diff comments View file @ 5be95b7

 /*
  * I/O remap functions for Hexagon
  *
  * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  */
 #include <linux/io.h>
 #include <linux/vmalloc.h>
+#include <linux/mm.h>
 void __iomem *ioremap_nocache(unsigned long phys_addr, unsigned long size)
 {
 	unsigned long last_addr, addr;
 	unsigned long offset = phys_addr & ~PAGE_MASK;
 	struct vm_struct *area;
 	pgprot_t prot = __pgprot(_PAGE_PRESENT|_PAGE_READ|_PAGE_WRITE
 					|(__HEXAGON_C_DEV << 6));
 	last_addr = phys_addr + size - 1;
 	/*  Wrapping not allowed  */
 	if (!size || (last_addr < phys_addr))
 		return NULL;
 	/*  Rounds up to next page size, including whole-page offset */
 	size = PAGE_ALIGN(offset + size);
 	area = get_vm_area(size, VM_IOREMAP);
 	addr = (unsigned long)area->addr;
 	if (ioremap_page_range(addr, addr+size, phys_addr, prot)) {
 		vunmap((void *)addr);
 		return NULL;
 	}
 	return (void __iomem *) (offset + addr);
 }
 void __iounmap(const volatile void __iomem *addr)
 {
 	vunmap((void *) ((unsigned long) addr & PAGE_MASK));
 }