1 files changed, 139 insertions, 0 deletions
diff --git a/arch/avr32/kernel/vmlinux.lds.c b/arch/avr32/kernel/vmlinux.lds.c
new file mode 100644
index 000000000000..cdd627c6b7dc
--- /dev/null
+++ b/arch/avr32/kernel/vmlinux.lds.c
@@ -0,0 +1,139 @@
+/*
+ * AVR32 linker script for the Linux kernel
+ *
+ * Copyright (C) 2004-2006 Atmel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#define LOAD_OFFSET 0x00000000
+#include <asm-generic/vmlinux.lds.h>
+OUTPUT_FORMAT("elf32-avr32", "elf32-avr32", "elf32-avr32")
+OUTPUT_ARCH(avr32)
+ENTRY(_start)
+/* Big endian */
+jiffies = jiffies_64 + 4;
+SECTIONS
+{
+        . = CONFIG_ENTRY_ADDRESS;
+        .init           : AT(ADDR(.init) - LOAD_OFFSET) {
+                _stext = .;
+                __init_begin = .;
+                        _sinittext = .;
+                        *(.text.reset)
+                        *(.init.text)
+                        _einittext = .;
+                . = ALIGN(4);
+                __tagtable_begin = .;
+                        *(.taglist)
+                __tagtable_end = .;
+                        *(.init.data)
+                . = ALIGN(16);
+                __setup_start = .;
+                        *(.init.setup)
+                __setup_end = .;
+                . = ALIGN(4);
+                __initcall_start = .;
+                        *(.initcall1.init)
+                        *(.initcall2.init)
+                        *(.initcall3.init)
+                        *(.initcall4.init)
+                        *(.initcall5.init)
+                        *(.initcall6.init)
+                        *(.initcall7.init)
+                __initcall_end = .;
+                __con_initcall_start = .;
+                        *(.con_initcall.init)
+                __con_initcall_end = .;
+                __security_initcall_start = .;
+                        *(.security_initcall.init)
+                __security_initcall_end = .;
+                . = ALIGN(32);
+                __initramfs_start = .;
+                        *(.init.ramfs)
+                __initramfs_end = .;
+                . = ALIGN(4096);
+                __init_end = .;
+        }
+        . = ALIGN(8192);
+        .text           : AT(ADDR(.text) - LOAD_OFFSET) {
+                _evba = .;
+                _text = .;
+                *(.ex.text)
+                . = 0x50;
+                *(.tlbx.ex.text)
+                . = 0x60;
+                *(.tlbr.ex.text)
+                . = 0x70;
+                *(.tlbw.ex.text)
+                . = 0x100;
+                *(.scall.text)
+                *(.irq.text)
+                *(.text)
+                SCHED_TEXT
+                LOCK_TEXT
+                KPROBES_TEXT
+                *(.fixup)
+                *(.gnu.warning)
+                _etext = .;
+        } = 0xd703d703
+        . = ALIGN(4);
+        __ex_table      : AT(ADDR(__ex_table) - LOAD_OFFSET) {
+                __start___ex_table = .;
+                *(__ex_table)
+                __stop___ex_table = .;
+        }
+        RODATA
+        . = ALIGN(8192);
+        .data           : AT(ADDR(.data) - LOAD_OFFSET) {
+                _data = .;
+                _sdata = .;
+                /*
+                 * First, the init task union, aligned to an 8K boundary.
+                 */
+                *(.data.init_task)
+                /* Then, the cacheline aligned data */
+                . = ALIGN(32);
+                *(.data.cacheline_aligned)
+                /* And the rest... */
+                *(.data.rel*)
+                *(.data)
+                CONSTRUCTORS
+                _edata = .;
+        }
+        . = ALIGN(8);
+        .bss            : AT(ADDR(.bss) - LOAD_OFFSET) {
+                __bss_start = .;
+                *(.bss)
+                *(COMMON)
+                . = ALIGN(8);
+                __bss_stop = .;
+                _end = .;
+        }
+        /* When something in the kernel is NOT compiled as a module, the module
+         * cleanup code and data are put into these segments. Both can then be
+         * thrown away, as cleanup code is never called unless it's a module.
+         */
+        /DISCARD/               : {
+                *(.exit.text)
+                *(.exit.data)
+                *(.exitcall.exit)
+        }
+        DWARF_DEBUG
+}

diff --git a/arch/avr32/kernel/vmlinux.lds.c b/arch/avr32/kernel/vmlinux.lds.c new file mode 100644 index 000000000000..cdd627c6b7dc --- /dev/null +++ b/arch/avr32/kernel/vmlinux.lds.c
@@ -0,0 +1,139 @@
	1	/*
	2	* AVR32 linker script for the Linux kernel
	3	*
	4	* Copyright (C) 2004-2006 Atmel Corporation
	5	*
	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 as
	8	* published by the Free Software Foundation.
	9	*/
	10	#define LOAD_OFFSET 0x00000000
	11	#include <asm-generic/vmlinux.lds.h>
	12
	13	OUTPUT_FORMAT("elf32-avr32", "elf32-avr32", "elf32-avr32")
	14	OUTPUT_ARCH(avr32)
	15	ENTRY(_start)
	16
	17	/* Big endian */
	18	jiffies = jiffies_64 + 4;
	19
	20	SECTIONS
	21	{
	22	. = CONFIG_ENTRY_ADDRESS;
	23	.init : AT(ADDR(.init) - LOAD_OFFSET) {
	24	_stext = .;
	25	__init_begin = .;
	26	_sinittext = .;
	27	*(.text.reset)
	28	*(.init.text)
	29	_einittext = .;
	30	. = ALIGN(4);
	31	__tagtable_begin = .;
	32	*(.taglist)
	33	__tagtable_end = .;
	34	*(.init.data)
	35	. = ALIGN(16);
	36	__setup_start = .;
	37	*(.init.setup)
	38	__setup_end = .;
	39	. = ALIGN(4);
	40	__initcall_start = .;
	41	*(.initcall1.init)
	42	*(.initcall2.init)
	43	*(.initcall3.init)
	44	*(.initcall4.init)
	45	*(.initcall5.init)
	46	*(.initcall6.init)
	47	*(.initcall7.init)
	48	__initcall_end = .;
	49	__con_initcall_start = .;
	50	*(.con_initcall.init)
	51	__con_initcall_end = .;
	52	__security_initcall_start = .;
	53	*(.security_initcall.init)
	54	__security_initcall_end = .;
	55	. = ALIGN(32);
	56	__initramfs_start = .;
	57	*(.init.ramfs)
	58	__initramfs_end = .;
	59	. = ALIGN(4096);
	60	__init_end = .;
	61	}
	62
	63	. = ALIGN(8192);
	64	.text : AT(ADDR(.text) - LOAD_OFFSET) {
	65	_evba = .;
	66	_text = .;
	67	*(.ex.text)
	68	. = 0x50;
	69	*(.tlbx.ex.text)
	70	. = 0x60;
	71	*(.tlbr.ex.text)
	72	. = 0x70;
	73	*(.tlbw.ex.text)
	74	. = 0x100;
	75	*(.scall.text)
	76	*(.irq.text)
	77	*(.text)
	78	SCHED_TEXT
	79	LOCK_TEXT
	80	KPROBES_TEXT
	81	*(.fixup)
	82	*(.gnu.warning)
	83	_etext = .;
	84	} = 0xd703d703
	85
	86	. = ALIGN(4);
	87	__ex_table : AT(ADDR(__ex_table) - LOAD_OFFSET) {
	88	__start___ex_table = .;
	89	*(__ex_table)
	90	__stop___ex_table = .;
	91	}
	92
	93	RODATA
	94
	95	. = ALIGN(8192);
	96
	97	.data : AT(ADDR(.data) - LOAD_OFFSET) {
	98	_data = .;
	99	_sdata = .;
	100	/*
	101	* First, the init task union, aligned to an 8K boundary.
	102	*/
	103	*(.data.init_task)
	104
	105	/* Then, the cacheline aligned data */
	106	. = ALIGN(32);
	107	*(.data.cacheline_aligned)
	108
	109	/* And the rest... */
	110	(.data.rel)
	111	*(.data)
	112	CONSTRUCTORS
	113
	114	_edata = .;
	115	}
	116
	117
	118	. = ALIGN(8);
	119	.bss : AT(ADDR(.bss) - LOAD_OFFSET) {
	120	__bss_start = .;
	121	*(.bss)
	122	*(COMMON)
	123	. = ALIGN(8);
	124	__bss_stop = .;
	125	_end = .;
	126	}
	127
	128	/* When something in the kernel is NOT compiled as a module, the module
	129	* cleanup code and data are put into these segments. Both can then be
	130	* thrown away, as cleanup code is never called unless it's a module.
	131	*/
	132	/DISCARD/ : {
	133	*(.exit.text)
	134	*(.exit.data)
	135	*(.exitcall.exit)
	136	}
	137
	138	DWARF_DEBUG
	139	}