Eric Lee / smarc-uboot | Embedian Git Server

Commit 1551df35f296f0a8df32f4f2054254f46e8be252

Authored by Tom Rini 2014-02-25 23:27:01 +0800

Committed by Albert ARIBAUD 2014-02-27 04:19:32 +0800

Exists in master and in 49 other branches

arm: Switch to -mno-unaligned-access when supported by the compiler

When we tell the compiler to optimize for ARMv7 (and ARMv6 for that
matter) it assumes a default of SCTRL.A being cleared and unaligned
accesses being allowed and fast at the hardware level.  We set this bit
and must pass along -mno-unaligned-access so that the compiler will
still breakdown accesses and not trigger a data abort.

To better help understand the requirements of the project with respect
to unaligned memory access, the
Documentation/unaligned-memory-access.txt file has been added as
doc/README.unaligned-memory-access.txt and is taken from the v3.14-rc1
tag of the kernel.

Cc: Albert ARIBAUD <albert.u.boot@aribaud.net>
Cc: Mans Rullgard <mans@mansr.com>
Signed-off-by: Tom Rini <trini@ti.com>

Showing 9 changed files with 248 additions and 138 deletions Inline Diff

README
arch/arm/cpu/armv7/config.mk
arch/arm/cpu/armv8/config.mk
arch/arm/lib/interrupts.c
common/Makefile
doc/README.arm-unaligned-accesses
doc/README.unaligned-memory-access.txt
fs/ubifs/Makefile
lib/Makefile

README

Diff comments View file @ 1551df3

arch/arm/cpu/armv7/config.mk

Diff comments View file @ 1551df3

 #
 # (C) Copyright 2002
 # Gary Jennejohn, DENX Software Engineering, <garyj@denx.de>
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 # If armv7-a is not supported by GCC fall-back to armv5, which is
 # supported by more tool-chains
 PF_CPPFLAGS_ARMV7 := $(call cc-option, -march=armv7-a, -march=armv5)
 PLATFORM_CPPFLAGS += $(PF_CPPFLAGS_ARMV7)
-# SEE README.arm-unaligned-accesses
+# On supported platforms we set the bit which causes us to trap on unaligned
+# memory access.  This is the opposite of what the compiler expects to be
+# the default so we must pass in -mno-unaligned-access so that it is aware
+# of our decision.
 PF_NO_UNALIGNED := $(call cc-option, -mno-unaligned-access,)
-PLATFORM_NO_UNALIGNED := $(PF_NO_UNALIGNED)
+PLATFORM_CPPFLAGS += $(PF_NO_UNALIGNED)
 ifneq ($(CONFIG_IMX_CONFIG),)
 ifdef CONFIG_SPL
 ifdef CONFIG_SPL_BUILD
 ALL-y	+= $(OBJTREE)/SPL
 endif
 else
 ALL-y	+= u-boot.imx
 endif
 endif

arch/arm/cpu/armv8/config.mk

Diff comments View file @ 1551df3

 #
 # (C) Copyright 2002
 # Gary Jennejohn, DENX Software Engineering, <garyj@denx.de>
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 PLATFORM_RELFLAGS += -fno-common -ffixed-x18
-# SEE README.arm-unaligned-accesses
-PF_NO_UNALIGNED := $(call cc-option, -mstrict-align)
-PLATFORM_NO_UNALIGNED := $(PF_NO_UNALIGNED)
 PF_CPPFLAGS_ARMV8 := $(call cc-option, -march=armv8-a)
+PF_NO_UNALIGNED := $(call cc-option, -mstrict-align)
 PLATFORM_CPPFLAGS += $(PF_CPPFLAGS_ARMV8)
 PLATFORM_CPPFLAGS += $(PF_NO_UNALIGNED)

arch/arm/lib/interrupts.c

Diff comments View file @ 1551df3

1	/*	1	/*
2	* (C) Copyright 2003	2	* (C) Copyright 2003
3	* Texas Instruments <www.ti.com>	3	* Texas Instruments <www.ti.com>
4	*	4	*
5	* (C) Copyright 2002	5	* (C) Copyright 2002
6	* Sysgo Real-Time Solutions, GmbH <www.elinos.com>	6	* Sysgo Real-Time Solutions, GmbH <www.elinos.com>
7	* Marius Groeger <mgroeger@sysgo.de>	7	* Marius Groeger <mgroeger@sysgo.de>
8	*	8	*
9	* (C) Copyright 2002	9	* (C) Copyright 2002
10	* Sysgo Real-Time Solutions, GmbH <www.elinos.com>	10	* Sysgo Real-Time Solutions, GmbH <www.elinos.com>
11	* Alex Zuepke <azu@sysgo.de>	11	* Alex Zuepke <azu@sysgo.de>
12	*	12	*
13	* (C) Copyright 2002-2004	13	* (C) Copyright 2002-2004
14	* Gary Jennejohn, DENX Software Engineering, <garyj@denx.de>	14	* Gary Jennejohn, DENX Software Engineering, <garyj@denx.de>
15	*	15	*
16	* (C) Copyright 2004	16	* (C) Copyright 2004
17	* Philippe Robin, ARM Ltd. <philippe.robin@arm.com>	17	* Philippe Robin, ARM Ltd. <philippe.robin@arm.com>
18	*	18	*
19	* SPDX-License-Identifier: GPL-2.0+	19	* SPDX-License-Identifier: GPL-2.0+
20	*/	20	*/
21		21
22	#include <common.h>	22	#include <common.h>
23	#include <asm/proc-armv/ptrace.h>	23	#include <asm/proc-armv/ptrace.h>
24		24
25	DECLARE_GLOBAL_DATA_PTR;	25	DECLARE_GLOBAL_DATA_PTR;
26		26
27	#ifdef CONFIG_USE_IRQ	27	#ifdef CONFIG_USE_IRQ
28	int interrupt_init (void)	28	int interrupt_init (void)
29	{	29	{
30	/*	30	/*
31	* setup up stacks if necessary	31	* setup up stacks if necessary
32	*/	32	*/
33	IRQ_STACK_START = gd->irq_sp - 4;	33	IRQ_STACK_START = gd->irq_sp - 4;
34	IRQ_STACK_START_IN = gd->irq_sp + 8;	34	IRQ_STACK_START_IN = gd->irq_sp + 8;
35	FIQ_STACK_START = IRQ_STACK_START - CONFIG_STACKSIZE_IRQ;	35	FIQ_STACK_START = IRQ_STACK_START - CONFIG_STACKSIZE_IRQ;
36		36
37	return arch_interrupt_init();	37	return arch_interrupt_init();
38	}	38	}
39		39
40	/* enable IRQ interrupts */	40	/* enable IRQ interrupts */
41	void enable_interrupts (void)	41	void enable_interrupts (void)
42	{	42	{
43	unsigned long temp;	43	unsigned long temp;
44	__asm__ __volatile__("mrs %0, cpsr\n"	44	__asm__ __volatile__("mrs %0, cpsr\n"
45	"bic %0, %0, #0x80\n"	45	"bic %0, %0, #0x80\n"
46	"msr cpsr_c, %0"	46	"msr cpsr_c, %0"
47	: "=r" (temp)	47	: "=r" (temp)
48	:	48	:
49	: "memory");	49	: "memory");
50	}	50	}
51		51
52		52
53	/*	53	/*
54	* disable IRQ/FIQ interrupts	54	* disable IRQ/FIQ interrupts
55	* returns true if interrupts had been enabled before we disabled them	55	* returns true if interrupts had been enabled before we disabled them
56	*/	56	*/
57	int disable_interrupts (void)	57	int disable_interrupts (void)
58	{	58	{
59	unsigned long old,temp;	59	unsigned long old,temp;
60	__asm__ __volatile__("mrs %0, cpsr\n"	60	__asm__ __volatile__("mrs %0, cpsr\n"
61	"orr %1, %0, #0xc0\n"	61	"orr %1, %0, #0xc0\n"
62	"msr cpsr_c, %1"	62	"msr cpsr_c, %1"
63	: "=r" (old), "=r" (temp)	63	: "=r" (old), "=r" (temp)
64	:	64	:
65	: "memory");	65	: "memory");
66	return (old & 0x80) == 0;	66	return (old & 0x80) == 0;
67	}	67	}
68	#else	68	#else
69	int interrupt_init (void)	69	int interrupt_init (void)
70	{	70	{
71	/*	71	/*
72	* setup up stacks if necessary	72	* setup up stacks if necessary
73	*/	73	*/
74	IRQ_STACK_START_IN = gd->irq_sp + 8;	74	IRQ_STACK_START_IN = gd->irq_sp + 8;
75		75
76	return 0;	76	return 0;
77	}	77	}
78		78
79	void enable_interrupts (void)	79	void enable_interrupts (void)
80	{	80	{
81	return;	81	return;
82	}	82	}
83	int disable_interrupts (void)	83	int disable_interrupts (void)
84	{	84	{
85	return 0;	85	return 0;
86	}	86	}
87	#endif	87	#endif
88		88
89		89
90	void bad_mode (void)	90	void bad_mode (void)
91	{	91	{
92	panic ("Resetting CPU ...\n");	92	panic ("Resetting CPU ...\n");
93	reset_cpu (0);	93	reset_cpu (0);
94	}	94	}
95		95
96	void show_regs (struct pt_regs *regs)	96	void show_regs (struct pt_regs *regs)
97	{	97	{
98	unsigned long flags;	98	unsigned long flags;
99	const char *processor_modes[] = {	99	const char *processor_modes[] = {
100	"USER_26", "FIQ_26", "IRQ_26", "SVC_26",	100	"USER_26", "FIQ_26", "IRQ_26", "SVC_26",
101	"UK4_26", "UK5_26", "UK6_26", "UK7_26",	101	"UK4_26", "UK5_26", "UK6_26", "UK7_26",
102	"UK8_26", "UK9_26", "UK10_26", "UK11_26",	102	"UK8_26", "UK9_26", "UK10_26", "UK11_26",
103	"UK12_26", "UK13_26", "UK14_26", "UK15_26",	103	"UK12_26", "UK13_26", "UK14_26", "UK15_26",
104	"USER_32", "FIQ_32", "IRQ_32", "SVC_32",	104	"USER_32", "FIQ_32", "IRQ_32", "SVC_32",
105	"UK4_32", "UK5_32", "UK6_32", "ABT_32",	105	"UK4_32", "UK5_32", "UK6_32", "ABT_32",
106	"UK8_32", "UK9_32", "UK10_32", "UND_32",	106	"UK8_32", "UK9_32", "UK10_32", "UND_32",
107	"UK12_32", "UK13_32", "UK14_32", "SYS_32",	107	"UK12_32", "UK13_32", "UK14_32", "SYS_32",
108	};	108	};
109		109
110	flags = condition_codes (regs);	110	flags = condition_codes (regs);
111		111
112	printf ("pc : [<%08lx>] lr : [<%08lx>]\n"	112	printf ("pc : [<%08lx>] lr : [<%08lx>]\n"
113	"sp : %08lx ip : %08lx fp : %08lx\n",	113	"sp : %08lx ip : %08lx fp : %08lx\n",
114	instruction_pointer (regs),	114	instruction_pointer (regs),
115	regs->ARM_lr, regs->ARM_sp, regs->ARM_ip, regs->ARM_fp);	115	regs->ARM_lr, regs->ARM_sp, regs->ARM_ip, regs->ARM_fp);
116	printf ("r10: %08lx r9 : %08lx r8 : %08lx\n",	116	printf ("r10: %08lx r9 : %08lx r8 : %08lx\n",
117	regs->ARM_r10, regs->ARM_r9, regs->ARM_r8);	117	regs->ARM_r10, regs->ARM_r9, regs->ARM_r8);
118	printf ("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n",	118	printf ("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n",
119	regs->ARM_r7, regs->ARM_r6, regs->ARM_r5, regs->ARM_r4);	119	regs->ARM_r7, regs->ARM_r6, regs->ARM_r5, regs->ARM_r4);
120	printf ("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n",	120	printf ("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n",
121	regs->ARM_r3, regs->ARM_r2, regs->ARM_r1, regs->ARM_r0);	121	regs->ARM_r3, regs->ARM_r2, regs->ARM_r1, regs->ARM_r0);
122	printf ("Flags: %c%c%c%c",	122	printf ("Flags: %c%c%c%c",
123	flags & CC_N_BIT ? 'N' : 'n',	123	flags & CC_N_BIT ? 'N' : 'n',
124	flags & CC_Z_BIT ? 'Z' : 'z',	124	flags & CC_Z_BIT ? 'Z' : 'z',
125	flags & CC_C_BIT ? 'C' : 'c', flags & CC_V_BIT ? 'V' : 'v');	125	flags & CC_C_BIT ? 'C' : 'c', flags & CC_V_BIT ? 'V' : 'v');
126	printf (" IRQs %s FIQs %s Mode %s%s\n",	126	printf (" IRQs %s FIQs %s Mode %s%s\n",
127	interrupts_enabled (regs) ? "on" : "off",	127	interrupts_enabled (regs) ? "on" : "off",
128	fast_interrupts_enabled (regs) ? "on" : "off",	128	fast_interrupts_enabled (regs) ? "on" : "off",
129	processor_modes[processor_mode (regs)],	129	processor_modes[processor_mode (regs)],
130	thumb_mode (regs) ? " (T)" : "");	130	thumb_mode (regs) ? " (T)" : "");
131	}	131	}
132		132
133	void do_undefined_instruction (struct pt_regs *pt_regs)	133	void do_undefined_instruction (struct pt_regs *pt_regs)
134	{	134	{
135	printf ("undefined instruction\n");	135	printf ("undefined instruction\n");
136	show_regs (pt_regs);	136	show_regs (pt_regs);
137	bad_mode ();	137	bad_mode ();
138	}	138	}
139		139
140	void do_software_interrupt (struct pt_regs *pt_regs)	140	void do_software_interrupt (struct pt_regs *pt_regs)
141	{	141	{
142	printf ("software interrupt\n");	142	printf ("software interrupt\n");
143	show_regs (pt_regs);	143	show_regs (pt_regs);
144	bad_mode ();	144	bad_mode ();
145	}	145	}
146		146
147	void do_prefetch_abort (struct pt_regs *pt_regs)	147	void do_prefetch_abort (struct pt_regs *pt_regs)
148	{	148	{
149	printf ("prefetch abort\n");	149	printf ("prefetch abort\n");
150	show_regs (pt_regs);	150	show_regs (pt_regs);
151	bad_mode ();	151	bad_mode ();
152	}	152	}
153		153
154	void do_data_abort (struct pt_regs *pt_regs)	154	void do_data_abort (struct pt_regs *pt_regs)
155	{	155	{
156	printf ("data abort\n\n MAYBE you should read doc/README.arm-unaligned-accesses\n\n");	156	printf ("data abort\n");
157	show_regs (pt_regs);	157	show_regs (pt_regs);
158	bad_mode ();	158	bad_mode ();
159	}	159	}
160		160
161	void do_not_used (struct pt_regs *pt_regs)	161	void do_not_used (struct pt_regs *pt_regs)
162	{	162	{
163	printf ("not used\n");	163	printf ("not used\n");
164	show_regs (pt_regs);	164	show_regs (pt_regs);
165	bad_mode ();	165	bad_mode ();
166	}	166	}
167		167
168	void do_fiq (struct pt_regs *pt_regs)	168	void do_fiq (struct pt_regs *pt_regs)
169	{	169	{
170	printf ("fast interrupt request\n");	170	printf ("fast interrupt request\n");
171	show_regs (pt_regs);	171	show_regs (pt_regs);
172	bad_mode ();	172	bad_mode ();
173	}	173	}
174		174
175	#ifndef CONFIG_USE_IRQ	175	#ifndef CONFIG_USE_IRQ
176	void do_irq (struct pt_regs *pt_regs)	176	void do_irq (struct pt_regs *pt_regs)
177	{	177	{
178	printf ("interrupt request\n");	178	printf ("interrupt request\n");
179	show_regs (pt_regs);	179	show_regs (pt_regs);
180	bad_mode ();	180	bad_mode ();
181	}	181	}
182	#endif	182	#endif
183		183

common/Makefile

Diff comments View file @ 1551df3

 #
 # (C) Copyright 2004-2006
 # Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 # core
 ifndef CONFIG_SPL_BUILD
 obj-y += main.o
 obj-y += command.o
 obj-y += exports.o
 obj-y += hash.o
 obj-$(CONFIG_SYS_HUSH_PARSER) += hush.o
 obj-y += s_record.o
 obj-y += xyzModem.o
 obj-y += cmd_disk.o
 # boards
 obj-$(CONFIG_SYS_GENERIC_BOARD) += board_f.o
 obj-$(CONFIG_SYS_GENERIC_BOARD) += board_r.o
 # core command
 obj-y += cmd_boot.o
 obj-$(CONFIG_CMD_BOOTM) += cmd_bootm.o
 obj-y += cmd_help.o
 obj-y += cmd_version.o
 # environment
 obj-y += env_attr.o
 obj-y += env_callback.o
 obj-y += env_flags.o
 obj-$(CONFIG_ENV_IS_IN_DATAFLASH) += env_dataflash.o
 obj-$(CONFIG_ENV_IS_IN_EEPROM) += env_eeprom.o
 extra-$(CONFIG_ENV_IS_EMBEDDED) += env_embedded.o
 obj-$(CONFIG_ENV_IS_IN_EEPROM) += env_embedded.o
 extra-$(CONFIG_ENV_IS_IN_FLASH) += env_embedded.o
 obj-$(CONFIG_ENV_IS_IN_NVRAM) += env_embedded.o
 obj-$(CONFIG_ENV_IS_IN_FLASH) += env_flash.o
 obj-$(CONFIG_ENV_IS_IN_MMC) += env_mmc.o
 obj-$(CONFIG_ENV_IS_IN_FAT) += env_fat.o
 obj-$(CONFIG_ENV_IS_IN_NAND) += env_nand.o
 obj-$(CONFIG_ENV_IS_IN_NVRAM) += env_nvram.o
 obj-$(CONFIG_ENV_IS_IN_ONENAND) += env_onenand.o
 obj-$(CONFIG_ENV_IS_IN_SPI_FLASH) += env_sf.o
 obj-$(CONFIG_ENV_IS_IN_REMOTE) += env_remote.o
 obj-$(CONFIG_ENV_IS_IN_UBI) += env_ubi.o
 obj-$(CONFIG_ENV_IS_NOWHERE) += env_nowhere.o
 # command
 obj-$(CONFIG_CMD_AMBAPP) += cmd_ambapp.o
 obj-$(CONFIG_SOURCE) += cmd_source.o
 obj-$(CONFIG_CMD_SOURCE) += cmd_source.o
 obj-$(CONFIG_CMD_BDI) += cmd_bdinfo.o
 obj-$(CONFIG_CMD_BEDBUG) += bedbug.o cmd_bedbug.o
 obj-$(CONFIG_CMD_BMP) += cmd_bmp.o
 obj-$(CONFIG_CMD_BOOTMENU) += cmd_bootmenu.o
 obj-$(CONFIG_CMD_BOOTLDR) += cmd_bootldr.o
 obj-$(CONFIG_CMD_BOOTSTAGE) += cmd_bootstage.o
 obj-$(CONFIG_CMD_CACHE) += cmd_cache.o
 obj-$(CONFIG_CMD_CBFS) += cmd_cbfs.o
 obj-$(CONFIG_CMD_CLK) += cmd_clk.o
 obj-$(CONFIG_CMD_CONSOLE) += cmd_console.o
 obj-$(CONFIG_CMD_CPLBINFO) += cmd_cplbinfo.o
 obj-$(CONFIG_DATAFLASH_MMC_SELECT) += cmd_dataflash_mmc_mux.o
 obj-$(CONFIG_CMD_DATE) += cmd_date.o
 obj-$(CONFIG_CMD_SOUND) += cmd_sound.o
 ifdef CONFIG_4xx
 obj-$(CONFIG_CMD_SETGETDCR) += cmd_dcr.o
 endif
 ifdef CONFIG_POST
 obj-$(CONFIG_CMD_DIAG) += cmd_diag.o
 endif
 obj-$(CONFIG_CMD_DISPLAY) += cmd_display.o
 obj-$(CONFIG_CMD_DTT) += cmd_dtt.o
 obj-$(CONFIG_CMD_ECHO) += cmd_echo.o
 obj-$(CONFIG_ENV_IS_IN_EEPROM) += cmd_eeprom.o
 obj-$(CONFIG_CMD_EEPROM) += cmd_eeprom.o
 obj-$(CONFIG_CMD_ELF) += cmd_elf.o
 obj-$(CONFIG_SYS_HUSH_PARSER) += cmd_exit.o
 obj-$(CONFIG_CMD_EXT4) += cmd_ext4.o
 obj-$(CONFIG_CMD_EXT2) += cmd_ext2.o
 obj-$(CONFIG_CMD_FAT) += cmd_fat.o
 obj-$(CONFIG_CMD_FDC)$(CONFIG_CMD_FDOS) += cmd_fdc.o
 obj-$(CONFIG_OF_LIBFDT) += cmd_fdt.o fdt_support.o
 obj-$(CONFIG_CMD_FDOS) += cmd_fdos.o
 obj-$(CONFIG_CMD_FITUPD) += cmd_fitupd.o
 obj-$(CONFIG_CMD_FLASH) += cmd_flash.o
 ifdef CONFIG_FPGA
 obj-$(CONFIG_CMD_FPGA) += cmd_fpga.o
 endif
 obj-$(CONFIG_CMD_FPGAD) += cmd_fpgad.o
 obj-$(CONFIG_CMD_FS_GENERIC) += cmd_fs.o
 obj-$(CONFIG_CMD_FUSE) += cmd_fuse.o
 obj-$(CONFIG_CMD_GETTIME) += cmd_gettime.o
 obj-$(CONFIG_CMD_GPIO) += cmd_gpio.o
 obj-$(CONFIG_CMD_I2C) += cmd_i2c.o
 obj-$(CONFIG_CMD_HASH) += cmd_hash.o
 obj-$(CONFIG_CMD_IDE) += cmd_ide.o
 obj-$(CONFIG_CMD_IMMAP) += cmd_immap.o
 obj-$(CONFIG_CMD_INI) += cmd_ini.o
 obj-$(CONFIG_CMD_IRQ) += cmd_irq.o
 obj-$(CONFIG_CMD_ITEST) += cmd_itest.o
 obj-$(CONFIG_CMD_JFFS2) += cmd_jffs2.o
 obj-$(CONFIG_CMD_CRAMFS) += cmd_cramfs.o
 obj-$(CONFIG_CMD_LDRINFO) += cmd_ldrinfo.o
 obj-$(CONFIG_CMD_LED) += cmd_led.o
 obj-$(CONFIG_CMD_LICENSE) += cmd_license.o
 obj-y += cmd_load.o
 obj-$(CONFIG_LOGBUFFER) += cmd_log.o
 obj-$(CONFIG_ID_EEPROM) += cmd_mac.o
 obj-$(CONFIG_CMD_MD5SUM) += cmd_md5sum.o
 obj-$(CONFIG_CMD_MEMORY) += cmd_mem.o
 obj-$(CONFIG_CMD_IO) += cmd_io.o
 obj-$(CONFIG_CMD_MFSL) += cmd_mfsl.o
 obj-$(CONFIG_MII) += miiphyutil.o
 obj-$(CONFIG_CMD_MII) += miiphyutil.o
 obj-$(CONFIG_PHYLIB) += miiphyutil.o
 obj-$(CONFIG_CMD_MII) += cmd_mii.o
 ifdef CONFIG_PHYLIB
 obj-$(CONFIG_CMD_MII) += cmd_mdio.o
 endif
 obj-$(CONFIG_CMD_MISC) += cmd_misc.o
 obj-$(CONFIG_CMD_MMC) += cmd_mmc.o
 obj-$(CONFIG_CMD_MMC_SPI) += cmd_mmc_spi.o
 obj-$(CONFIG_MP) += cmd_mp.o
 obj-$(CONFIG_CMD_MTDPARTS) += cmd_mtdparts.o
 obj-$(CONFIG_CMD_NAND) += cmd_nand.o
 obj-$(CONFIG_CMD_NET) += cmd_net.o
 obj-$(CONFIG_CMD_ONENAND) += cmd_onenand.o
 obj-$(CONFIG_CMD_OTP) += cmd_otp.o
 obj-$(CONFIG_CMD_PART) += cmd_part.o
 ifdef CONFIG_PCI
 obj-$(CONFIG_CMD_PCI) += cmd_pci.o
 endif
 obj-y += cmd_pcmcia.o
 obj-$(CONFIG_CMD_PORTIO) += cmd_portio.o
 obj-$(CONFIG_CMD_PXE) += cmd_pxe.o
 obj-$(CONFIG_CMD_READ) += cmd_read.o
 obj-$(CONFIG_CMD_REGINFO) += cmd_reginfo.o
 obj-$(CONFIG_CMD_REISER) += cmd_reiser.o
 obj-$(CONFIG_SANDBOX) += cmd_sandbox.o
 obj-$(CONFIG_CMD_SATA) += cmd_sata.o
 obj-$(CONFIG_CMD_SF) += cmd_sf.o
 obj-$(CONFIG_CMD_SCSI) += cmd_scsi.o
 obj-$(CONFIG_CMD_SHA1SUM) += cmd_sha1sum.o
 obj-$(CONFIG_CMD_SETEXPR) += cmd_setexpr.o
 obj-$(CONFIG_CMD_SOFTSWITCH) += cmd_softswitch.o
 obj-$(CONFIG_CMD_SPI) += cmd_spi.o
 obj-$(CONFIG_CMD_SPIBOOTLDR) += cmd_spibootldr.o
 obj-$(CONFIG_CMD_STRINGS) += cmd_strings.o
 obj-$(CONFIG_CMD_TERMINAL) += cmd_terminal.o
 obj-$(CONFIG_CMD_TIME) += cmd_time.o
 obj-$(CONFIG_CMD_TRACE) += cmd_trace.o
 obj-$(CONFIG_SYS_HUSH_PARSER) += cmd_test.o
 obj-$(CONFIG_CMD_TPM) += cmd_tpm.o
 obj-$(CONFIG_CMD_TSI148) += cmd_tsi148.o
 obj-$(CONFIG_CMD_UBI) += cmd_ubi.o
 obj-$(CONFIG_CMD_UBIFS) += cmd_ubifs.o
 obj-$(CONFIG_CMD_UNIVERSE) += cmd_universe.o
 obj-$(CONFIG_CMD_UNZIP) += cmd_unzip.o
 ifdef CONFIG_CMD_USB
 obj-y += cmd_usb.o
 obj-y += usb.o usb_hub.o
 obj-$(CONFIG_USB_STORAGE) += usb_storage.o
 endif
 obj-$(CONFIG_CMD_USB_MASS_STORAGE) += cmd_usb_mass_storage.o
 obj-$(CONFIG_CMD_THOR_DOWNLOAD) += cmd_thordown.o
 obj-$(CONFIG_CMD_XIMG) += cmd_ximg.o
 obj-$(CONFIG_YAFFS2) += cmd_yaffs2.o
 obj-$(CONFIG_CMD_SPL) += cmd_spl.o
 obj-$(CONFIG_CMD_ZIP) += cmd_zip.o
 obj-$(CONFIG_CMD_ZFS) += cmd_zfs.o
 # others
 obj-$(CONFIG_BOOTSTAGE) += bootstage.o
 obj-$(CONFIG_CONSOLE_MUX) += iomux.o
 obj-y += flash.o
 obj-$(CONFIG_CMD_KGDB) += kgdb.o kgdb_stubs.o
 obj-$(CONFIG_I2C_EDID) += edid.o
 obj-$(CONFIG_KALLSYMS) += kallsyms.o
 obj-y += splash.o
 obj-$(CONFIG_LCD) += lcd.o
 obj-$(CONFIG_LYNXKDI) += lynxkdi.o
 obj-$(CONFIG_MENU) += menu.o
 obj-$(CONFIG_MODEM_SUPPORT) += modem.o
 obj-$(CONFIG_UPDATE_TFTP) += update.o
 obj-$(CONFIG_USB_KEYBOARD) += usb_kbd.o
 obj-$(CONFIG_CMD_DFU) += cmd_dfu.o
 obj-$(CONFIG_CMD_GPT) += cmd_gpt.o
 endif
 ifdef CONFIG_SPL_BUILD
 obj-$(CONFIG_ENV_IS_IN_FLASH) += env_flash.o
 obj-$(CONFIG_SPL_YMODEM_SUPPORT) += xyzModem.o
 obj-$(CONFIG_SPL_NET_SUPPORT) += miiphyutil.o
 # environment
 obj-$(CONFIG_SPL_ENV_SUPPORT) += env_attr.o
 obj-$(CONFIG_SPL_ENV_SUPPORT) += env_flags.o
 obj-$(CONFIG_SPL_ENV_SUPPORT) += env_callback.o
 ifdef CONFIG_SPL_USB_HOST_SUPPORT
 obj-$(CONFIG_SPL_USB_SUPPORT) += usb.o usb_hub.o
 obj-$(CONFIG_USB_STORAGE) += usb_storage.o
 endif
 ifdef CONFIG_SPL_SATA_SUPPORT
 obj-$(CONFIG_CMD_SCSI) += cmd_scsi.o
 endif
 ifneq ($(CONFIG_SPL_NET_SUPPORT),y)
 obj-$(CONFIG_ENV_IS_NOWHERE) += env_nowhere.o
 obj-$(CONFIG_ENV_IS_IN_MMC) += env_mmc.o
 obj-$(CONFIG_ENV_IS_IN_NAND) += env_nand.o
 obj-$(CONFIG_ENV_IS_IN_SPI_FLASH) += env_sf.o
 obj-$(CONFIG_ENV_IS_IN_FLASH) += env_flash.o
 else
 obj-y += env_nowhere.o
 endif
 endif
 # core command
 obj-y += cmd_nvedit.o
 #environment
 obj-y += env_common.o
 #others
 ifdef CONFIG_DDR_SPD
 SPD := y
 endif
 ifdef CONFIG_SPD_EEPROM
 SPD := y
 endif
 obj-$(SPD) += ddr_spd.o
 obj-$(CONFIG_HWCONFIG) += hwconfig.o
 obj-$(CONFIG_BOUNCE_BUFFER) += bouncebuf.o
 obj-y += console.o
 obj-y += dlmalloc.o
 obj-y += image.o
 obj-$(CONFIG_OF_LIBFDT) += image-fdt.o
 obj-$(CONFIG_FIT) += image-fit.o
 obj-$(CONFIG_FIT_SIGNATURE) += image-sig.o
 obj-y += memsize.o
 obj-y += stdio.o
 CFLAGS_env_embedded.o := -Wa,--no-warn -DENV_CRC=$(shell tools/envcrc 2>/dev/null)
-CFLAGS_hush.o := $(PLATFORM_NO_UNALIGNED)
-CFLAGS_fdt_support.o := $(PLATFORM_NO_UNALIGNED)

doc/README.arm-unaligned-accesses

View file @ 1551df3

1	If you are reading this because of a data abort: the following MIGHT		File was deleted
2	be relevant to your abort, if it was caused by an alignment violation.
3	In order to determine this, use the PC from the abort dump along with
4	an objdump -s -S of the u-boot ELF binary to locate the function where
5	the abort happened; then compare this function with the examples below.
6	If they match, then you've been hit with a compiler generated unaligned
7	access, and you should rewrite your code or add -mno-unaligned-access
8	to the command line of the offending file.
9
10	Note that the PC shown in the abort message is relocated. In order to
11	be able to match it to an address in the ELF binary dump, you will need
12	to know the relocation offset. If your target defines CONFIG_CMD_BDI
13	and if you can get to the prompt and enter commands before the abort
14	happens, then command "bdinfo" will give you the offset. Otherwise you
15	will need to try a build with DEBUG set, which will display the offset,
16	or use a debugger and set a breakpoint at relocate_code() to see the
17	offset (passed as an argument).
18
19	*
20
21	Since U-Boot runs on a variety of hardware, some only able to perform
22	unaligned accesses with a strong penalty, some unable to perform them
23	at all, the policy regarding unaligned accesses is to not perform any,
24	unless absolutely necessary because of hardware or standards.
25
26	Also, on hardware which permits it, the core is configured to throw
27	data abort exceptions on unaligned accesses in order to catch these
28	unallowed accesses as early as possible.
29
30	Until version 4.7, the gcc default for performing unaligned accesses
31	(-mno-unaligned-access) is to emulate unaligned accesses using aligned
32	loads and stores plus shifts and masks. Emulated unaligned accesses
33	will not be caught by hardware. These accesses may be costly and may
34	be actually unnecessary. In order to catch these accesses and remove
35	or optimize them, option -munaligned-access is explicitly set for all
36	versions of gcc which support it.
37
38	From gcc 4.7 onward starting at armv7 architectures, the default for
39	performing unaligned accesses is to use unaligned native loads and
40	stores (-munaligned-access), because the cost of unaligned accesses
41	has dropped on armv7 and beyond. This should not affect U-Boot's
42	policy of controlling unaligned accesses, however the compiler may
43	generate uncontrolled unaligned accesses on its own in at least one
44	known case: when declaring a local initialized char array, e.g.
45
46	function foo()
47	{
48	char buffer[] = "initial value";
49	/* or */
50	char buffer[] = { 'i', 'n', 'i', 't', 0 };
51	...
52	}
53
54	Under -munaligned-accesses with optimizations on, this declaration
55	causes the compiler to generate native loads from the literal string
56	and native stores to the buffer, and the literal string alignment
57	cannot be controlled. If it is misaligned, then the core will throw
58	a data abort exception.
59
60	Quite probably the same might happen for 16-bit array initializations
61	where the constant is aligned on a boundary which is a multiple of 2
62	but not of 4:
63
64	function foo()
65	{
66	u16 buffer[] = { 1, 2, 3 };
67	...
68	}
69
70	The long term solution to this issue is to add an option to gcc to
71	allow controlling the general alignment of data, including constant
72	initialization values.
73
74	However this will only apply to the version of gcc which will have such
75	an option. For other versions, there are four workarounds:
76
77	a) Enforce as a rule that array initializations as described above
78	are forbidden. This is generally not acceptable as they are valid,
79	and usual, C constructs. The only case where they could be rejected
80	is when they actually equate to a const char* declaration, i.e. the
81	array is initialized and never modified in the function's scope.
82
83	b) Drop the requirement on unaligned accesses at least for ARMv7,
84	i.e. do not throw a data abort exception upon unaligned accesses.
85	But that will allow adding badly aligned code to U-Boot, only for
86	it to fail when re-used with a stricter target, possibly once the
87	bad code is already in mainline.
88
89	c) Relax the -munaligned-access rule globally. This will prevent native
90	unaligned accesses of course, but that will also hide any bug caused
91	by a bad unaligned access, making it much harder to diagnose it. It
92	is actually what already happens when building ARM targets with a
93	pre-4.7 gcc, and it may actually already hide some bugs yet unseen
94	until the target gets compiled with -munaligned-access.
95
96	d) Relax the -munaligned-access rule only for for files susceptible to
97	the local initialized array issue and for armv7 architectures and
98	beyond. This minimizes the quantity of code which can hide unwanted
99	misaligned accesses.
100
101	The option retained is d).
102
103	Considering that actual occurrences of the issue are rare (as of this
104	writing, 5 files out of 7840 in U-Boot, or .3%, contain an initialized
105	local char array which cannot actually be replaced with a const char*),
106	contributors should not be required to systematically try and detect
107	the issue in their patches.
108
109	Detecting files susceptible to the issue can be automated through a
110	filter installed as a hook in .git which recognizes local char array
111	initializations. Automation should err on the false positive side, for
112	instance flagging non-local arrays as if they were local if they cannot
113	be told apart.
114
115	In any case, detection shall not prevent committing the patch, but
116	shall pre-populate the commit message with a note to the effect that
117	this patch contains an initialized local char or 16-bit array and thus
118	should be protected from the gcc 4.7 issue.
119
120	Upon a positive detection, either $(PLATFORM_NO_UNALIGNED) should be
121	added to CFLAGS for the affected file(s), or if the array is a pseudo
122	const char*, it should be replaced by an actual one.
123		1	If you are reading this because of a data abort: the following MIGHT

doc/README.unaligned-memory-access.txt

Diff comments View file @ 1551df3

File was created	1	Editors note: This document is _heavily_ cribbed from the Linux Kernel, with
	2	really only the section about "Alignment vs. Networking" removed.
	3
	4	UNALIGNED MEMORY ACCESSES
	5	=========================
	6
	7	Linux runs on a wide variety of architectures which have varying behaviour
	8	when it comes to memory access. This document presents some details about
	9	unaligned accesses, why you need to write code that doesn't cause them,
	10	and how to write such code!
	11
	12
	13	The definition of an unaligned access
	14	=====================================
	15
	16	Unaligned memory accesses occur when you try to read N bytes of data starting
	17	from an address that is not evenly divisible by N (i.e. addr % N != 0).
	18	For example, reading 4 bytes of data from address 0x10004 is fine, but
	19	reading 4 bytes of data from address 0x10005 would be an unaligned memory
	20	access.
	21
	22	The above may seem a little vague, as memory access can happen in different
	23	ways. The context here is at the machine code level: certain instructions read
	24	or write a number of bytes to or from memory (e.g. movb, movw, movl in x86
	25	assembly). As will become clear, it is relatively easy to spot C statements
	26	which will compile to multiple-byte memory access instructions, namely when
	27	dealing with types such as u16, u32 and u64.
	28
	29
	30	Natural alignment
	31	=================
	32
	33	The rule mentioned above forms what we refer to as natural alignment:
	34	When accessing N bytes of memory, the base memory address must be evenly
	35	divisible by N, i.e. addr % N == 0.
	36
	37	When writing code, assume the target architecture has natural alignment
	38	requirements.
	39
	40	In reality, only a few architectures require natural alignment on all sizes
	41	of memory access. However, we must consider ALL supported architectures;
	42	writing code that satisfies natural alignment requirements is the easiest way
	43	to achieve full portability.
	44
	45
	46	Why unaligned access is bad
	47	===========================
	48
	49	The effects of performing an unaligned memory access vary from architecture
	50	to architecture. It would be easy to write a whole document on the differences
	51	here; a summary of the common scenarios is presented below:
	52
	53	- Some architectures are able to perform unaligned memory accesses
	54	transparently, but there is usually a significant performance cost.
	55	- Some architectures raise processor exceptions when unaligned accesses
	56	happen. The exception handler is able to correct the unaligned access,
	57	at significant cost to performance.
	58	- Some architectures raise processor exceptions when unaligned accesses
	59	happen, but the exceptions do not contain enough information for the
	60	unaligned access to be corrected.
	61	- Some architectures are not capable of unaligned memory access, but will
	62	silently perform a different memory access to the one that was requested,
	63	resulting in a subtle code bug that is hard to detect!
	64
	65	It should be obvious from the above that if your code causes unaligned
	66	memory accesses to happen, your code will not work correctly on certain
	67	platforms and will cause performance problems on others.
	68
	69
	70	Code that does not cause unaligned access
	71	=========================================
	72
	73	At first, the concepts above may seem a little hard to relate to actual
	74	coding practice. After all, you don't have a great deal of control over
	75	memory addresses of certain variables, etc.
	76
	77	Fortunately things are not too complex, as in most cases, the compiler
	78	ensures that things will work for you. For example, take the following
	79	structure:
	80
	81	struct foo {
	82	u16 field1;
	83	u32 field2;
	84	u8 field3;
	85	};
	86
	87	Let us assume that an instance of the above structure resides in memory
	88	starting at address 0x10000. With a basic level of understanding, it would
	89	not be unreasonable to expect that accessing field2 would cause an unaligned
	90	access. You'd be expecting field2 to be located at offset 2 bytes into the
	91	structure, i.e. address 0x10002, but that address is not evenly divisible
	92	by 4 (remember, we're reading a 4 byte value here).
	93
	94	Fortunately, the compiler understands the alignment constraints, so in the
	95	above case it would insert 2 bytes of padding in between field1 and field2.
	96	Therefore, for standard structure types you can always rely on the compiler
	97	to pad structures so that accesses to fields are suitably aligned (assuming
	98	you do not cast the field to a type of different length).
	99
	100	Similarly, you can also rely on the compiler to align variables and function
	101	parameters to a naturally aligned scheme, based on the size of the type of
	102	the variable.
	103
	104	At this point, it should be clear that accessing a single byte (u8 or char)
	105	will never cause an unaligned access, because all memory addresses are evenly
	106	divisible by one.
	107
	108	On a related topic, with the above considerations in mind you may observe
	109	that you could reorder the fields in the structure in order to place fields
	110	where padding would otherwise be inserted, and hence reduce the overall
	111	resident memory size of structure instances. The optimal layout of the
	112	above example is:
	113
	114	struct foo {
	115	u32 field2;
	116	u16 field1;
	117	u8 field3;
	118	};
	119
	120	For a natural alignment scheme, the compiler would only have to add a single
	121	byte of padding at the end of the structure. This padding is added in order
	122	to satisfy alignment constraints for arrays of these structures.
	123
	124	Another point worth mentioning is the use of __attribute__((packed)) on a
	125	structure type. This GCC-specific attribute tells the compiler never to
	126	insert any padding within structures, useful when you want to use a C struct
	127	to represent some data that comes in a fixed arrangement 'off the wire'.
	128
	129	You might be inclined to believe that usage of this attribute can easily
	130	lead to unaligned accesses when accessing fields that do not satisfy
	131	architectural alignment requirements. However, again, the compiler is aware
	132	of the alignment constraints and will generate extra instructions to perform
	133	the memory access in a way that does not cause unaligned access. Of course,
	134	the extra instructions obviously cause a loss in performance compared to the
	135	non-packed case, so the packed attribute should only be used when avoiding
	136	structure padding is of importance.
	137
	138
	139	Code that causes unaligned access
	140	=================================
	141
	142	With the above in mind, let's move onto a real life example of a function
	143	that can cause an unaligned memory access. The following function taken
	144	from the Linux Kernel's include/linux/etherdevice.h is an optimized routine
	145	to compare two ethernet MAC addresses for equality.
	146
	147	bool ether_addr_equal(const u8 addr1, const u8 addr2)
	148	{
	149	#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
	150	u32 fold = (((const u32 )addr1) ^ ((const u32 )addr2)) \|
	151	(((const u16 )(addr1 + 4)) ^ ((const u16 )(addr2 + 4)));
	152
	153	return fold == 0;
	154	#else
	155	const u16 a = (const u16 )addr1;
	156	const u16 b = (const u16 )addr2;
	157	return ((a[0] ^ b[0]) \| (a[1] ^ b[1]) \| (a[2] ^ b[2])) != 0;
	158	#endif
	159	}
	160
	161	In the above function, when the hardware has efficient unaligned access
	162	capability, there is no issue with this code. But when the hardware isn't
	163	able to access memory on arbitrary boundaries, the reference to a[0] causes
	164	2 bytes (16 bits) to be read from memory starting at address addr1.
	165
	166	Think about what would happen if addr1 was an odd address such as 0x10003.
	167	(Hint: it'd be an unaligned access.)
	168
	169	Despite the potential unaligned access problems with the above function, it
	170	is included in the kernel anyway but is understood to only work normally on
	171	16-bit-aligned addresses. It is up to the caller to ensure this alignment or
	172	not use this function at all. This alignment-unsafe function is still useful
	173	as it is a decent optimization for the cases when you can ensure alignment,
	174	which is true almost all of the time in ethernet networking context.
	175
	176
	177	Here is another example of some code that could cause unaligned accesses:
	178	void myfunc(u8 *data, u32 value)
	179	{
	180	[...]
	181	((u32 ) data) = cpu_to_le32(value);
	182	[...]
	183	}
	184
	185	This code will cause unaligned accesses every time the data parameter points
	186	to an address that is not evenly divisible by 4.
	187
	188	In summary, the 2 main scenarios where you may run into unaligned access
	189	problems involve:
	190	1. Casting variables to types of different lengths
	191	2. Pointer arithmetic followed by access to at least 2 bytes of data
	192
	193
	194	Avoiding unaligned accesses
	195	===========================
	196
	197	The easiest way to avoid unaligned access is to use the get_unaligned() and
	198	put_unaligned() macros provided by the <asm/unaligned.h> header file.
	199
	200	Going back to an earlier example of code that potentially causes unaligned
	201	access:
	202
	203	void myfunc(u8 *data, u32 value)
	204	{
	205	[...]
	206	((u32 ) data) = cpu_to_le32(value);
	207	[...]
	208	}
	209
	210	To avoid the unaligned memory access, you would rewrite it as follows:
	211
	212	void myfunc(u8 *data, u32 value)
	213	{
	214	[...]
	215	value = cpu_to_le32(value);
	216	put_unaligned(value, (u32 *) data);
	217	[...]
	218	}
	219
	220	The get_unaligned() macro works similarly. Assuming 'data' is a pointer to
	221	memory and you wish to avoid unaligned access, its usage is as follows:
	222
	223	u32 value = get_unaligned((u32 *) data);
	224
	225	These macros work for memory accesses of any length (not just 32 bits as
	226	in the examples above). Be aware that when compared to standard access of
	227	aligned memory, using these macros to access unaligned memory can be costly in
	228	terms of performance.
	229
	230	If use of such macros is not convenient, another option is to use memcpy(),
	231	where the source or destination (or both) are of type u8* or unsigned char*.
	232	Due to the byte-wise nature of this operation, unaligned accesses are avoided.
	233
	234	--
	235	In the Linux Kernel,
	236	Authors: Daniel Drake <dsd@gentoo.org>,
	237	Johannes Berg <johannes@sipsolutions.net>
	238	With help from: Alan Cox, Avuton Olrich, Heikki Orsila, Jan Engelhardt,
	239	Kyle McMartin, Kyle Moffett, Randy Dunlap, Robert Hancock, Uli Kunitz,
	240	Vadim Lobanov
	241

fs/ubifs/Makefile

Diff comments View file @ 1551df3

 #
 # (C) Copyright 2006
 # Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 #
 # (C) Copyright 2003
 # Pavel Bartusek, Sysgo Real-Time Solutions AG, pba@sysgo.de
 #
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 obj-y := ubifs.o io.o super.o sb.o master.o lpt.o
 obj-y += lpt_commit.o scan.o lprops.o
 obj-y += tnc.o tnc_misc.o debug.o crc16.o budget.o
 obj-y += log.o orphan.o recovery.o replay.o
-# SEE README.arm-unaligned-accesses
-CFLAGS_super.o := $(PLATFORM_NO_UNALIGNED)

lib/Makefile

Diff comments View file @ 1551df3

 #
 # (C) Copyright 2000-2006
 # Wolfgang Denk, DENX Software Engineering, wd@denx.de.
 #
 # SPDX-License-Identifier:	GPL-2.0+
 #
 ifndef CONFIG_SPL_BUILD
 obj-$(CONFIG_RSA) += rsa/
 obj-$(CONFIG_LZMA) += lzma/
 obj-$(CONFIG_LZO) += lzo/
 obj-$(CONFIG_ZLIB) += zlib/
 obj-$(CONFIG_TIZEN) += tizen/
 obj-$(CONFIG_AES) += aes.o
 obj-$(CONFIG_BZIP2) += bzlib.o
 obj-$(CONFIG_BZIP2) += bzlib_crctable.o
 obj-$(CONFIG_BZIP2) += bzlib_decompress.o
 obj-$(CONFIG_BZIP2) += bzlib_randtable.o
 obj-$(CONFIG_BZIP2) += bzlib_huffman.o
 obj-$(CONFIG_USB_TTY) += circbuf.o
 obj-y += crc7.o
 obj-y += crc8.o
 obj-y += crc16.o
 obj-$(CONFIG_OF_CONTROL) += fdtdec.o
 obj-$(CONFIG_TEST_FDTDEC) += fdtdec_test.o
 obj-$(CONFIG_GZIP) += gunzip.o
 obj-$(CONFIG_GZIP_COMPRESSED) += gzip.o
 obj-y += initcall.o
 obj-$(CONFIG_LMB) += lmb.o
 obj-y += ldiv.o
 obj-$(CONFIG_MD5) += md5.o
 obj-y += net_utils.o
 obj-$(CONFIG_PHYSMEM) += physmem.o
 obj-y += qsort.o
 obj-$(CONFIG_SHA1) += sha1.o
 obj-$(CONFIG_SHA256) += sha256.o
 obj-y	+= strmhz.o
 obj-$(CONFIG_TPM) += tpm.o
 obj-$(CONFIG_RBTREE)	+= rbtree.o
 obj-$(CONFIG_BITREVERSE) += bitrev.o
 endif
 ifdef CONFIG_SPL_BUILD
 obj-$(CONFIG_SPL_YMODEM_SUPPORT) += crc16.o
 obj-$(CONFIG_SPL_NET_SUPPORT) += net_utils.o
 endif
 obj-$(CONFIG_ADDR_MAP) += addr_map.o
 obj-y += hashtable.o
 obj-y += errno.o
 obj-y += display_options.o
 obj-$(CONFIG_BCH) += bch.o
 obj-y += crc32.o
 obj-y += ctype.o
 obj-y += div64.o
 obj-y += hang.o
 obj-y += linux_string.o
 obj-$(CONFIG_REGEX) += slre.o
 obj-y += string.o
 obj-y += time.o
 obj-$(CONFIG_TRACE) += trace.o
 obj-$(CONFIG_BOOTP_PXE) += uuid.o
 obj-y += vsprintf.o
 obj-$(CONFIG_RANDOM_MACADDR) += rand.o
 obj-$(CONFIG_BOOTP_RANDOM_DELAY) += rand.o
 obj-$(CONFIG_CMD_LINK_LOCAL) += rand.o
-# SEE README.arm-unaligned-accesses
-CFLAGS_bzlib.o := $(PLATFORM_NO_UNALIGNED)

1	#	1	#
2	# (C) Copyright 2000 - 2013	2	# (C) Copyright 2000 - 2013
3	# Wolfgang Denk, DENX Software Engineering, wd@denx.de.	3	# Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4	#	4	#
5	# SPDX-License-Identifier: GPL-2.0+	5	# SPDX-License-Identifier: GPL-2.0+
6	#	6	#
7		7
8	Summary:	8	Summary:
9	========	9	========
10		10
11	This directory contains the source code for U-Boot, a boot loader for	11	This directory contains the source code for U-Boot, a boot loader for
12	Embedded boards based on PowerPC, ARM, MIPS and several other	12	Embedded boards based on PowerPC, ARM, MIPS and several other
13	processors, which can be installed in a boot ROM and used to	13	processors, which can be installed in a boot ROM and used to
14	initialize and test the hardware or to download and run application	14	initialize and test the hardware or to download and run application
15	code.	15	code.
16		16
17	The development of U-Boot is closely related to Linux: some parts of	17	The development of U-Boot is closely related to Linux: some parts of
18	the source code originate in the Linux source tree, we have some	18	the source code originate in the Linux source tree, we have some
19	header files in common, and special provision has been made to	19	header files in common, and special provision has been made to
20	support booting of Linux images.	20	support booting of Linux images.
21		21
22	Some attention has been paid to make this software easily	22	Some attention has been paid to make this software easily
23	configurable and extendable. For instance, all monitor commands are	23	configurable and extendable. For instance, all monitor commands are
24	implemented with the same call interface, so that it's very easy to	24	implemented with the same call interface, so that it's very easy to
25	add new commands. Also, instead of permanently adding rarely used	25	add new commands. Also, instead of permanently adding rarely used
26	code (for instance hardware test utilities) to the monitor, you can	26	code (for instance hardware test utilities) to the monitor, you can
27	load and run it dynamically.	27	load and run it dynamically.
28		28
29		29
30	Status:	30	Status:
31	=======	31	=======
32		32
33	In general, all boards for which a configuration option exists in the	33	In general, all boards for which a configuration option exists in the
34	Makefile have been tested to some extent and can be considered	34	Makefile have been tested to some extent and can be considered
35	"working". In fact, many of them are used in production systems.	35	"working". In fact, many of them are used in production systems.
36		36
37	In case of problems see the CHANGELOG and CREDITS files to find out	37	In case of problems see the CHANGELOG and CREDITS files to find out
38	who contributed the specific port. The boards.cfg file lists board	38	who contributed the specific port. The boards.cfg file lists board
39	maintainers.	39	maintainers.
40		40