# SPDX-License-Identifier: GPL-2.0+

VERSION = 2025

PATCHLEVEL = 04

SUBLEVEL =

EXTRAVERSION =

NAME =

PATCHESVERSION = -jookia20251112

# *DOCUMENTATION*

# To see a list of typical targets execute "make help"

# More info can be located in ./README

# Comments in this file are targeted only to the developer, do not

# expect to learn how to build the kernel reading this file.

# Do not use make's built-in rules and variables

# (this increases performance and avoids hard-to-debug behaviour)

MAKEFLAGS += -rR

# Determine target architecture for the sandbox

include include/host_arch.h

ifeq ("", "$(CROSS_COMPILE)")

MK_ARCH="${shell uname -m}"

else

MK_ARCH="${shell echo $(CROSS_COMPILE) | sed -n 's/^\(.*ccache\)\{0,1\}[[:space:]]*\([^\/]*\/\)*\([^-]*\)-[^[:space:]]*/\3/p'}"

endif

unexport HOST_ARCH

ifeq ("x86_64", $(MK_ARCH))

export HOST_ARCH=$(HOST_ARCH_X86_64)

else ifneq (,$(findstring $(MK_ARCH), "i386" "i486" "i586" "i686"))

export HOST_ARCH=$(HOST_ARCH_X86)

else ifneq (,$(findstring $(MK_ARCH), "aarch64" "armv8l"))

export HOST_ARCH=$(HOST_ARCH_AARCH64)

else ifneq (,$(findstring $(MK_ARCH), "arm" "armv7" "armv7a" "armv7l"))

export HOST_ARCH=$(HOST_ARCH_ARM)

else ifeq ("riscv32", $(MK_ARCH))

export HOST_ARCH=$(HOST_ARCH_RISCV32)

else ifeq ("riscv64", $(MK_ARCH))

export HOST_ARCH=$(HOST_ARCH_RISCV64)

endif

undefine MK_ARCH

# Avoid funny character set dependencies

unexport LC_ALL

LC_COLLATE=C

LC_NUMERIC=C

export LC_COLLATE LC_NUMERIC

# Avoid interference with shell env settings

unexport GREP_OPTIONS

# We are using a recursive build, so we need to do a little thinking

# to get the ordering right.

#

# Most importantly: sub-Makefiles should only ever modify files in

# their own directory. If in some directory we have a dependency on

# a file in another dir (which doesn't happen often, but it's often

# unavoidable when linking the built-in.o targets which finally

# turn into vmlinux), we will call a sub make in that other dir, and

# after that we are sure that everything which is in that other dir

# is now up to date.

#

# The only cases where we need to modify files which have global

# effects are thus separated out and done before the recursive

# descending is started. They are now explicitly listed as the

# prepare rule.

# Beautify output

# ---------------------------------------------------------------------------

#

# Normally, we echo the whole command before executing it. By making

# that echo $($(quiet)$(cmd)), we now have the possibility to set

# $(quiet) to choose other forms of output instead, e.g.

#

# quiet_cmd_cc_o_c = Compiling $(RELDIR)/$@

# cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<

#

# If $(quiet) is empty, the whole command will be printed.

# If it is set to "quiet_", only the short version will be printed.

# If it is set to "silent_", nothing will be printed at all, since

# the variable $(silent_cmd_cc_o_c) doesn't exist.

#

# A simple variant is to prefix commands with $(Q) - that's useful

# for commands that shall be hidden in non-verbose mode.

#

# $(Q)ln $@ :<

#

# If KBUILD_VERBOSE equals 0 then the above command will be hidden.

# If KBUILD_VERBOSE equals 1 then the above command is displayed.

#

# To put more focus on warnings, be less verbose as default

# Use 'make V=1' to see the full commands

ifeq ("$(origin V)", "command line")

KBUILD_VERBOSE = $(V)

endif

ifndef KBUILD_VERBOSE

KBUILD_VERBOSE = 0

endif

ifeq ($(KBUILD_VERBOSE),1)

quiet =

Q =

else

quiet=quiet_

Q = @

endif

# If the user is running make -s (silent mode), suppress echoing of

# commands

ifneq ($(filter 4.%,$(MAKE_VERSION)),) # make-4

ifneq ($(filter %s ,$(firstword x$(MAKEFLAGS))),)

quiet=silent_

endif

else # make-3.8x

ifneq ($(filter s% -s%,$(MAKEFLAGS)),)

quiet=silent_

endif

endif

export quiet Q KBUILD_VERBOSE

# kbuild supports saving output files in a separate directory.

# To locate output files in a separate directory two syntaxes are supported.

# In both cases the working directory must be the root of the kernel src.

# 1) O=

# Use "make O=dir/to/store/output/files/"

#

# 2) Set KBUILD_OUTPUT

# Set the environment variable KBUILD_OUTPUT to point to the directory

# where the output files shall be placed.

# export KBUILD_OUTPUT=dir/to/store/output/files/

# make

#

# The O= assignment takes precedence over the KBUILD_OUTPUT environment

# variable.

# KBUILD_SRC is set on invocation of make in OBJ directory

# KBUILD_SRC is not intended to be used by the regular user (for now)

ifeq ($(KBUILD_SRC),)

# OK, Make called in directory where kernel src resides

# Do we want to locate output files in a separate directory?

ifeq ("$(origin O)", "command line")

KBUILD_OUTPUT := $(O)

endif

# That's our default target when none is given on the command line

PHONY := _all

_all:

# Cancel implicit rules on top Makefile

$(CURDIR)/Makefile Makefile: ;

ifneq ($(KBUILD_OUTPUT),)

# Invoke a second make in the output directory, passing relevant variables

# check that the output directory actually exists

saved-output := $(KBUILD_OUTPUT)

KBUILD_OUTPUT := $(shell mkdir -p $(KBUILD_OUTPUT) && cd $(KBUILD_OUTPUT) \

&& /bin/pwd)

$(if $(KBUILD_OUTPUT),, \

$(error failed to create output directory "$(saved-output)"))

# Look for make include files relative to root of kernel src

#

# This does not become effective immediately because MAKEFLAGS is re-parsed

# once after the Makefile is read. It is OK since we are going to invoke

# 'sub-make' below.

MAKEFLAGS += --include-dir=$(CURDIR)

PHONY += $(MAKECMDGOALS) sub-make

$(filter-out _all sub-make $(CURDIR)/Makefile, $(MAKECMDGOALS)) _all: sub-make

@:

sub-make: FORCE

$(Q)$(MAKE) -C $(KBUILD_OUTPUT) KBUILD_SRC=$(CURDIR) \

-f $(CURDIR)/Makefile $(filter-out _all sub-make,$(MAKECMDGOALS))

# Leave processing to above invocation of make

skip-makefile := 1

endif # ifneq ($(KBUILD_OUTPUT),)

endif # ifeq ($(KBUILD_SRC),)

# We process the rest of the Makefile if this is the final invocation of make

ifeq ($(skip-makefile),)

# Do not print "Entering directory ...",

# but we want to display it when entering to the output directory

# so that IDEs/editors are able to understand relative filenames.

MAKEFLAGS += --no-print-directory

# Call a source code checker (by default, "sparse") as part of the

# C compilation.

#

# Use 'make C=1' to enable checking of only re-compiled files.

# Use 'make C=2' to enable checking of *all* source files, regardless

# of whether they are re-compiled or not.

#

# See the file "doc/sparse.txt" for more details, including

# where to get the "sparse" utility.

ifeq ("$(origin C)", "command line")

KBUILD_CHECKSRC = $(C)

endif

ifndef KBUILD_CHECKSRC

KBUILD_CHECKSRC = 0

endif

# Use make M=dir to specify directory of external module to build

# Old syntax make ... SUBDIRS=$PWD is still supported

# Setting the environment variable KBUILD_EXTMOD take precedence

ifdef SUBDIRS

KBUILD_EXTMOD ?= $(SUBDIRS)

endif

ifeq ("$(origin M)", "command line")

KBUILD_EXTMOD := $(M)

endif

# If building an external module we do not care about the all: rule

# but instead _all depend on modules

PHONY += all

ifeq ($(KBUILD_EXTMOD),)

_all: all

else

_all: modules

endif

ifeq ($(KBUILD_SRC),)

# building in the source tree

srctree := .

else

ifeq ($(KBUILD_SRC)/,$(dir $(CURDIR)))

# building in a subdirectory of the source tree

srctree := ..

else

srctree := $(KBUILD_SRC)

endif

endif

objtree := .

src := $(srctree)

obj := $(objtree)

VPATH := $(srctree)$(if $(KBUILD_EXTMOD),:$(KBUILD_EXTMOD))

export srctree objtree VPATH

# Make sure CDPATH settings don't interfere

unexport CDPATH

#########################################################################

HOSTARCH := $(shell uname -m | \

sed -e s/i.86/x86/ \

-e s/sun4u/sparc64/ \

-e s/arm.*/arm/ \

-e s/sa110/arm/ \

-e s/ppc64/powerpc/ \

-e s/ppc/powerpc/ \

-e s/macppc/powerpc/\

-e s/sh.*/sh/)

HOSTOS := $(shell uname -s | tr '[:upper:]' '[:lower:]' | \

sed -e 's/\(cygwin\).*/cygwin/')

export HOSTARCH HOSTOS

#########################################################################

# set default to nothing for native builds

ifeq ($(HOSTARCH),$(ARCH))

CROSS_COMPILE ?=

endif

KCONFIG_CONFIG ?= .config

export KCONFIG_CONFIG

# SHELL used by kbuild

CONFIG_SHELL := $(shell if [ -x "$$BASH" ]; then echo $$BASH; \

else if [ -x /bin/bash ]; then echo /bin/bash; \

else echo sh; fi ; fi)

HOST_LFS_CFLAGS := $(shell getconf LFS_CFLAGS 2>/dev/null)

HOST_LFS_LDFLAGS := $(shell getconf LFS_LDFLAGS 2>/dev/null)

HOST_LFS_LIBS := $(shell getconf LFS_LIBS 2>/dev/null)

HOSTCC = cc

HOSTCXX = c++

KBUILD_HOSTCFLAGS := -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer \

$(HOST_LFS_CFLAGS) $(HOSTCFLAGS)

KBUILD_HOSTCXXFLAGS := -O2 $(HOST_LFS_CFLAGS) $(HOSTCXXFLAGS)

KBUILD_HOSTLDFLAGS := $(HOST_LFS_LDFLAGS) $(HOSTLDFLAGS)

KBUILD_HOSTLDLIBS := $(HOST_LFS_LIBS) $(HOSTLDLIBS)

# With the move to GCC 6, we have implicitly upgraded our language

# standard to GNU11 (see https://gcc.gnu.org/gcc-5/porting_to.html).

# Some Linux distributions (including RHEL7, SLES13, Debian 8) still

# have older compilers as their default, so we make it explicit for

# these that our host tools are GNU11 (i.e. C11 w/ GNU extensions).

CSTD_FLAG := -std=gnu11

KBUILD_HOSTCFLAGS += $(CSTD_FLAG)

ifeq ($(HOSTOS),cygwin)

KBUILD_HOSTCFLAGS += -ansi

endif

# Mac OS X / Darwin's C preprocessor is Apple specific. It

# generates numerous errors and warnings. We want to bypass it

# and use GNU C's cpp. To do this we pass the -traditional-cpp

# option to the compiler. Note that the -traditional-cpp flag

# DOES NOT have the same semantics as GNU C's flag, all it does

# is invoke the GNU preprocessor in stock ANSI/ISO C fashion.

#

# Apple's linker is similar, thanks to the new 2 stage linking

# multiple symbol definitions are treated as errors, hence the

# -multiply_defined suppress option to turn off this error.

#

ifeq ($(HOSTOS),darwin)

# get major and minor product version (e.g. '10' and '6' for Snow Leopard)

DARWIN_MAJOR_VERSION := $(shell sw_vers -productVersion | cut -f 1 -d '.')

DARWIN_MINOR_VERSION := $(shell sw_vers -productVersion | cut -f 2 -d '.')

os_x_before = $(shell if [ $(DARWIN_MAJOR_VERSION) -le $(1) -a \

$(DARWIN_MINOR_VERSION) -le $(2) ] ; then echo "$(3)"; else echo "$(4)"; fi ;)

os_x_after = $(shell if [ $(DARWIN_MAJOR_VERSION) -ge $(1) -a \

$(DARWIN_MINOR_VERSION) -ge $(2) ] ; then echo "$(3)"; else echo "$(4)"; fi ;)

# Snow Leopards build environment has no longer restrictions as described above

HOSTCC = $(call os_x_before, 10, 5, "cc", "gcc")

KBUILD_HOSTCFLAGS += $(call os_x_before, 10, 4, "-traditional-cpp")

KBUILD_HOSTLDFLAGS += $(call os_x_before, 10, 5, "-multiply_defined suppress")

# macOS Mojave (10.14.X)

# Undefined symbols for architecture x86_64: "_PyArg_ParseTuple"

KBUILD_HOSTLDFLAGS += $(call os_x_after, 10, 14, "-lpython -dynamclib", "")

endif

# Decide whether to build built-in, modular, or both.

# Normally, just do built-in.

KBUILD_MODULES :=

KBUILD_BUILTIN := 1

# If we have only "make modules", don't compile built-in objects.

# When we're building modules with modversions, we need to consider

# the built-in objects during the descend as well, in order to

# make sure the checksums are up to date before we record them.

ifeq ($(MAKECMDGOALS),modules)

KBUILD_BUILTIN := $(if $(CONFIG_MODVERSIONS),1)

endif

# If we have "make <whatever> modules", compile modules

# in addition to whatever we do anyway.

# Just "make" or "make all" shall build modules as well

# U-Boot does not need modules

#ifneq ($(filter all _all modules,$(MAKECMDGOALS)),)

# KBUILD_MODULES := 1

#endif

#ifeq ($(MAKECMDGOALS),)

# KBUILD_MODULES := 1

#endif

# Check ths size of a binary:

# Args:

# $1: File to check

# #2: Size limit in bytes (decimal or 0xhex)

define size_check

actual=$$( wc -c $1 | awk '{print $$1}'); \

limit=$$( printf "%d" $2 ); \

if test $$actual -gt $$limit; then \

echo "$1 exceeds file size limit:" >&2; \

echo " limit: $$(printf %#x $$limit) bytes" >&2; \

echo " actual: $$(printf %#x $$actual) bytes" >&2; \

echo " excess: $$(printf %#x $$((actual - limit))) bytes" >&2;\

exit 1; \

fi

endef

export size_check

export KBUILD_MODULES KBUILD_BUILTIN

export KBUILD_CHECKSRC KBUILD_SRC KBUILD_EXTMOD

# We need some generic definitions (do not try to remake the file).

scripts/Kbuild.include: ;

include scripts/Kbuild.include

# Make variables (CC, etc...)

AS = $(CROSS_COMPILE)as

# Always use GNU ld

ifneq ($(shell $(CROSS_COMPILE)ld.bfd -v 2> /dev/null),)

LD = $(CROSS_COMPILE)ld.bfd

else

LD = $(CROSS_COMPILE)ld

endif

CC = $(CROSS_COMPILE)gcc

CPP = $(CC) -E

AR = $(CROSS_COMPILE)ar

NM = $(CROSS_COMPILE)nm

LDR = $(CROSS_COMPILE)ldr

STRIP = $(CROSS_COMPILE)strip

OBJCOPY = $(CROSS_COMPILE)objcopy

OBJDUMP = $(CROSS_COMPILE)objdump

LEX = flex

YACC = bison

AWK = awk

PERL = perl

PYTHON ?= python

PYTHON2 = python2

PYTHON3 ?= python3

# The devicetree compiler and pylibfdt are automatically built unless DTC is

# provided. If DTC is provided, it is assumed the pylibfdt is available too.

DTC_INTREE := $(objtree)/scripts/dtc/dtc

DTC ?= $(DTC_INTREE)

DTC_MIN_VERSION := 010406

CHECK = sparse

CHECKFLAGS := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ \

-Wbitwise -Wno-return-void -Wno-unknown-attribute \

-D__CHECK_ENDIAN__ $(CF)

KBUILD_CPPFLAGS := -D__KERNEL__ -D__UBOOT__

KBUILD_CFLAGS := -Wall -Wstrict-prototypes \

-Wno-format-security \

-fno-builtin -ffreestanding $(CSTD_FLAG)

KBUILD_CFLAGS += -fshort-wchar -fno-strict-aliasing

KBUILD_AFLAGS := -D__ASSEMBLY__

KBUILD_LDFLAGS :=

ifeq ($(cc-name),clang)

ifneq ($(CROSS_COMPILE),)

CLANG_TARGET := --target=$(notdir $(CROSS_COMPILE:%-=%))

LDPPFLAGS += $(CLANG_TARGET)

GCC_TOOLCHAIN_DIR := $(dir $(shell which $(LD)))

CLANG_PREFIX := --prefix=$(GCC_TOOLCHAIN_DIR)

GCC_TOOLCHAIN := $(realpath $(GCC_TOOLCHAIN_DIR)/..)

endif

ifneq ($(GCC_TOOLCHAIN),)

CLANG_GCC_TC := --gcc-toolchain=$(GCC_TOOLCHAIN)

endif

KBUILD_CFLAGS += $(CLANG_TARGET) $(CLANG_GCC_TC) $(CLANG_PREFIX)

KBUILD_AFLAGS += $(CLANG_TARGET) $(CLANG_GCC_TC) $(CLANG_PREFIX)

KBUILD_CFLAGS += $(call cc-option, -no-integrated-as)

KBUILD_AFLAGS += $(call cc-option, -no-integrated-as)

endif

# Don't generate position independent code

KBUILD_CFLAGS += $(call cc-option,-fno-PIE)

KBUILD_AFLAGS += $(call cc-option,-fno-PIE)

# Read UBOOTRELEASE from include/config/uboot.release (if it exists)

UBOOTRELEASE = $(shell cat include/config/uboot.release 2> /dev/null)

UBOOTVERSION = $(VERSION)$(if $(PATCHLEVEL),.$(PATCHLEVEL)$(if $(SUBLEVEL),.$(SUBLEVEL)))$(EXTRAVERSION)$(PATCHESVERSION)

export VERSION PATCHLEVEL SUBLEVEL UBOOTRELEASE UBOOTVERSION

export ARCH CPU BOARD VENDOR SOC CPUDIR BOARDDIR

export CONFIG_SHELL HOSTCC KBUILD_HOSTCFLAGS CROSS_COMPILE AS LD CC

export CPP AR NM LDR STRIP OBJCOPY OBJDUMP KBUILD_HOSTLDFLAGS KBUILD_HOSTLDLIBS

export MAKE LEX YACC AWK PERL PYTHON PYTHON2 PYTHON3

export HOSTCXX KBUILD_HOSTCXXFLAGS CHECK CHECKFLAGS DTC DTC_FLAGS

export KBUILD_CPPFLAGS NOSTDINC_FLAGS UBOOTINCLUDE OBJCOPYFLAGS KBUILD_LDFLAGS

export KBUILD_CFLAGS KBUILD_AFLAGS

export CC_VERSION_TEXT := $(shell $(CC) --version | head -n 1)

# When compiling out-of-tree modules, put MODVERDIR in the module

# tree rather than in the kernel tree. The kernel tree might

# even be read-only.

export MODVERDIR := $(if $(KBUILD_EXTMOD),$(firstword $(KBUILD_EXTMOD))/).tmp_versions

# Files to ignore in find ... statements

export RCS_FIND_IGNORE := \( -name SCCS -o -name BitKeeper -o -name .svn -o \

-name CVS -o -name .pc -o -name .hg -o -name .git \) \

-prune -o

export RCS_TAR_IGNORE := --exclude SCCS --exclude BitKeeper --exclude .svn \

--exclude CVS --exclude .pc --exclude .hg --exclude .git

export PYTHON_ENABLE

# This is y if U-Boot should not build any Python tools or libraries. Typically

# you would need to set this if those tools/libraries (typically binman and

# pylibfdt) cannot be built by your environment and are provided separately.

ifeq ($(NO_PYTHON),)

PYTHON_ENABLE=y

endif

# ===========================================================================

# Rules shared between *config targets and build targets

# Basic helpers built in scripts/

PHONY += scripts_basic

scripts_basic:

$(Q)$(MAKE) $(build)=scripts/basic

$(Q)rm -f .tmp_quiet_recordmcount

# To avoid any implicit rule to kick in, define an empty command.

scripts/basic/%: scripts_basic ;

PHONY += outputmakefile

# outputmakefile generates a Makefile in the output directory, if using a

# separate output directory. This allows convenient use of make in the

# output directory.

outputmakefile:

ifneq ($(KBUILD_SRC),)

$(Q)ln -fsn $(srctree) source

$(Q)$(CONFIG_SHELL) $(srctree)/scripts/mkmakefile $(srctree)

endif

# To make sure we do not include .config for any of the *config targets

# catch them early, and hand them over to scripts/kconfig/Makefile

# It is allowed to specify more targets when calling make, including

# mixing *config targets and build targets.

# For example 'make oldconfig all'.

# Detect when mixed targets is specified, and make a second invocation

# of make so .config is not included in this case either (for *config).

version_h := include/generated/version_autogenerated.h

timestamp_h := include/generated/timestamp_autogenerated.h

defaultenv_h := include/generated/defaultenv_autogenerated.h

dt_h := include/generated/dt.h

env_h := include/generated/environment.h

no-dot-config-targets := clean clobber mrproper distclean \

help %docs check% coccicheck \

ubootversion backup tests check pcheck qcheck tcheck \

pylint pylint_err _pip pip pip_test pip_release

config-targets := 0

mixed-targets := 0

dot-config := 1

ifneq ($(filter $(no-dot-config-targets), $(MAKECMDGOALS)),)

ifeq ($(filter-out $(no-dot-config-targets), $(MAKECMDGOALS)),)

dot-config := 0

endif

endif

ifeq ($(KBUILD_EXTMOD),)

ifneq ($(filter config %config,$(MAKECMDGOALS)),)

config-targets := 1

ifneq ($(words $(MAKECMDGOALS)),1)

mixed-targets := 1

endif

endif

endif

ifeq ($(mixed-targets),1)

# ===========================================================================

# We're called with mixed targets (*config and build targets).

# Handle them one by one.

PHONY += $(MAKECMDGOALS) __build_one_by_one

$(filter-out __build_one_by_one, $(MAKECMDGOALS)): __build_one_by_one

@:

__build_one_by_one:

$(Q)set -e; \

for i in $(MAKECMDGOALS); do \

$(MAKE) -f $(srctree)/Makefile $$i; \

done

else

ifeq ($(config-targets),1)

# ===========================================================================

# *config targets only - make sure prerequisites are updated, and descend

# in scripts/kconfig to make the *config target

KBUILD_DEFCONFIG := sandbox_defconfig

export KBUILD_DEFCONFIG KBUILD_KCONFIG

config: scripts_basic outputmakefile FORCE

$(Q)$(MAKE) $(build)=scripts/kconfig $@

%config: scripts_basic outputmakefile FORCE

$(Q)$(MAKE) $(build)=scripts/kconfig $@

else

# ===========================================================================

# Build targets only - this includes vmlinux, arch specific targets, clean

# targets and others. In general all targets except *config targets.

# Additional helpers built in scripts/

# Carefully list dependencies so we do not try to build scripts twice

# in parallel

PHONY += scripts

scripts: scripts_basic scripts_dtc include/config/auto.conf

$(Q)$(MAKE) $(build)=$(@)

ifeq ($(dot-config),1)

# Read in config

-include include/config/auto.conf

# Read in dependencies to all Kconfig* files, make sure to run

# oldconfig if changes are detected.

-include include/config/auto.conf.cmd

# To avoid any implicit rule to kick in, define an empty command

$(KCONFIG_CONFIG) include/config/auto.conf.cmd: ;

# If .config is newer than include/config/auto.conf, someone tinkered

# with it and forgot to run make oldconfig.

# if auto.conf.cmd is missing then we are probably in a cleaned tree so

# we execute the config step to be sure to catch updated Kconfig files

include/config/%.conf: $(KCONFIG_CONFIG) include/config/auto.conf.cmd

$(Q)$(MAKE) -f $(srctree)/Makefile syncconfig

@# If the following part fails, include/config/auto.conf should be

@# deleted so "make silentoldconfig" will be re-run on the next build.

$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.autoconf || \

{ rm -f include/config/auto.conf; false; }

@# include/config.h has been updated after "make silentoldconfig".

@# We need to touch include/config/auto.conf so it gets newer

@# than include/config.h.

@# Otherwise, 'make silentoldconfig' would be invoked twice.

$(Q)touch include/config/auto.conf

u-boot.cfg spl/u-boot.cfg tpl/u-boot.cfg vpl/u-boot.cfg:

$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.autoconf $(@)

-include include/autoconf.mk

-include include/autoconf.mk.dep

# We want to include arch/$(ARCH)/config.mk only when include/config/auto.conf

# is up-to-date. When we switch to a different board configuration, old CONFIG

# macros are still remaining in include/config/auto.conf. Without the following

# gimmick, wrong config.mk would be included leading nasty warnings/errors.

ifneq ($(wildcard $(KCONFIG_CONFIG)),)

ifneq ($(wildcard include/config/auto.conf),)

autoconf_is_old := $(shell find . -path ./$(KCONFIG_CONFIG) -newer \

include/config/auto.conf)

ifeq ($(autoconf_is_old),)

include config.mk

include arch/$(ARCH)/Makefile

endif

endif

endif

# These are set by the arch-specific config.mk. Make sure they are exported

# so they can be used when building an EFI application.

export EFI_LDS # Filename of EFI link script in arch/$(ARCH)/lib

export EFI_CRT0 # Filename of EFI CRT0 in arch/$(ARCH)/lib

export EFI_RELOC # Filename of EFU relocation code in arch/$(ARCH)/lib

export CFLAGS_EFI # Compiler flags to add when building EFI app

export CFLAGS_NON_EFI # Compiler flags to remove when building EFI app

export EFI_TARGET # binutils target if EFI is natively supported

export LTO_ENABLE

# This is y if LTO is enabled for this build. See NO_LTO=1 to disable LTO

ifeq ($(NO_LTO),)

LTO_ENABLE=$(if $(CONFIG_LTO),y)

endif

# If board code explicitly specified LDSCRIPT or CONFIG_SYS_LDSCRIPT, use

# that (or fail if absent). Otherwise, search for a linker script in a

# standard location.

ifndef LDSCRIPT

#LDSCRIPT := $(srctree)/board/$(BOARDDIR)/u-boot.lds.debug

ifdef CONFIG_SYS_LDSCRIPT

# need to strip off double quotes

LDSCRIPT := $(srctree)/$(CONFIG_SYS_LDSCRIPT:"%"=%)

endif

endif

# If there is no specified link script, we look in a number of places for it

ifndef LDSCRIPT

ifeq ($(wildcard $(LDSCRIPT)),)

LDSCRIPT := $(srctree)/board/$(BOARDDIR)/u-boot.lds

endif

ifeq ($(wildcard $(LDSCRIPT)),)

LDSCRIPT := $(srctree)/$(CPUDIR)/u-boot.lds

endif

ifeq ($(wildcard $(LDSCRIPT)),)

LDSCRIPT := $(srctree)/arch/$(ARCH)/cpu/u-boot.lds

endif

endif

else

# Dummy target needed, because used as prerequisite

include/config/auto.conf: ;

endif # $(dot-config)

ifdef CONFIG_CC_OPTIMIZE_FOR_DEBUG

KBUILD_HOSTCFLAGS := -Wall -Wstrict-prototypes -Og -g -fomit-frame-pointer \

$(HOST_LFS_CFLAGS) $(HOSTCFLAGS)

# Avoid false positives -Wmaybe-uninitialized

# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78394

KBUILD_HOSTCFLAGS += -Wno-maybe-uninitialized

KBUILD_HOSTCXXFLAGS := -Og -g $(HOST_LFS_CFLAGS) $(HOSTCXXFLAGS)

endif

#

# Xtensa linker script cannot be preprocessed with -ansi because of

# preprocessor operations on strings that don't make C identifiers.

#

ifeq ($(CONFIG_XTENSA),)

LDPPFLAGS += -ansi

endif

ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE

KBUILD_CFLAGS += -Os

endif

ifdef CONFIG_CC_OPTIMIZE_FOR_SPEED

KBUILD_CFLAGS += -O2

endif

ifdef CONFIG_CC_OPTIMIZE_FOR_DEBUG

KBUILD_CFLAGS += -Og

# Avoid false positives -Wmaybe-uninitialized

# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78394

KBUILD_CFLAGS += -Wno-maybe-uninitialized

endif

LTO_CFLAGS :=

LTO_FINAL_LDFLAGS :=

export LTO_CFLAGS LTO_FINAL_LDFLAGS

ifeq ($(LTO_ENABLE),y)

ifeq ($(cc-name),clang)

LTO_CFLAGS += -DLTO_ENABLE -flto

LTO_FINAL_LDFLAGS += -flto

AR = $(shell $(CC) -print-prog-name=llvm-ar)

NM = $(shell $(CC) -print-prog-name=llvm-nm)

else

NPROC := $(shell nproc 2>/dev/null || echo 1)

LTO_CFLAGS += -DLTO_ENABLE -flto=$(NPROC)

LTO_FINAL_LDFLAGS += -fuse-linker-plugin -flto=$(NPROC)

# use plugin aware tools

AR = $(CROSS_COMPILE)gcc-ar

NM = $(CROSS_COMPILE)gcc-nm

endif

CFLAGS_NON_EFI += $(LTO_CFLAGS)

KBUILD_CFLAGS += $(LTO_CFLAGS)

endif

ifeq ($(CONFIG_STACKPROTECTOR),y)

KBUILD_CFLAGS += $(call cc-option,-fstack-protector-strong)

KBUILD_CFLAGS += $(call cc-option,-mstack-protector-guard=global)

CFLAGS_EFI += $(call cc-option,-fno-stack-protector)

else

KBUILD_CFLAGS += $(call cc-option,-fno-stack-protector)

endif

KBUILD_CFLAGS += $(call cc-option,-fno-delete-null-pointer-checks)

# disable pointer signed / unsigned warnings in gcc 4.0

KBUILD_CFLAGS += -Wno-pointer-sign

# disable stringop warnings in gcc 8+

KBUILD_CFLAGS += $(call cc-disable-warning, stringop-truncation)

KBUILD_CFLAGS += $(call cc-disable-warning, zero-length-bounds)

KBUILD_CFLAGS += $(call cc-disable-warning, array-bounds)

KBUILD_CFLAGS += $(call cc-disable-warning, stringop-overflow)

# Enabled with W=2, disabled by default as noisy

KBUILD_CFLAGS += $(call cc-disable-warning, maybe-uninitialized)

# change __FILE__ to the relative path from the srctree

KBUILD_CFLAGS += $(call cc-option,-fmacro-prefix-map=$(srctree)/=)

KBUILD_CFLAGS += -gdwarf-4

# $(KBUILD_AFLAGS) sets -g, which causes gcc to pass a suitable -g<format>

# option to the assembler.

KBUILD_AFLAGS += -gdwarf-4

# Report stack usage if supported

# ARC tools based on GCC 7.1 has an issue with stack usage

# with naked functions, see commit message for more details

ifndef CONFIG_ARC

ifeq ($(shell $(CONFIG_SHELL) $(srctree)/scripts/gcc-stack-usage.sh $(CC)),y)

KBUILD_CFLAGS += -fstack-usage

endif

endif

KBUILD_CFLAGS += $(call cc-option,-Wno-format-nonliteral)

KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member)

ifdef CONFIG_CC_IS_CLANG

KBUILD_CPPFLAGS += $(call cc-option,-Qunused-arguments,)

KBUILD_CFLAGS += $(call cc-disable-warning, format-invalid-specifier)

KBUILD_CFLAGS += $(call cc-disable-warning, gnu)

KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member)

# Quiet clang warning: comparison of unsigned expression < 0 is always false

KBUILD_CFLAGS += $(call cc-disable-warning, tautological-compare)

# CLANG uses a _MergedGlobals as optimization, but this breaks modpost, as the

# source of a reference will be _MergedGlobals and not on of the whitelisted names.

# See modpost pattern 2

KBUILD_CFLAGS += $(call cc-option, -mno-global-merge,)

KBUILD_CFLAGS += $(call cc-option, -fcatch-undefined-behavior)

KBUILD_CFLAGS += $(call cc-disable-warning, deprecated-non-prototype)

endif

# These warnings generated too much noise in a regular build.

# Use make W=1 to enable them (see scripts/Makefile.extrawarn)

KBUILD_CFLAGS += $(call cc-disable-warning, unused-but-set-variable)

# Prohibit date/time macros, which would make the build non-deterministic

KBUILD_CFLAGS += $(call cc-option,-Werror=date-time)

include scripts/Makefile.extrawarn

# Add user supplied CPPFLAGS, AFLAGS and CFLAGS as the last assignments

KBUILD_CPPFLAGS += $(KCPPFLAGS)

KBUILD_AFLAGS += $(KAFLAGS)

KBUILD_CFLAGS += $(KCFLAGS)

KBUILD_LDFLAGS += -z noexecstack

KBUILD_LDFLAGS += $(call ld-option,--no-warn-rwx-segments)

KBUILD_HOSTCFLAGS += $(if $(CONFIG_TOOLS_DEBUG),-g)

# Use UBOOTINCLUDE when you must reference the include/ directory.

# Needed to be compatible with the O= option

UBOOTINCLUDE := \

-Iinclude \

$(if $(KBUILD_SRC), -I$(srctree)/include) \

$(if $(CONFIG_$(XPL_)MBEDTLS_LIB), \

"-DMBEDTLS_CONFIG_FILE=\"mbedtls_def_config.h\"" \

-I$(srctree)/lib/mbedtls \

-I$(srctree)/lib/mbedtls/port \

-I$(srctree)/lib/mbedtls/external/mbedtls \

-I$(srctree)/lib/mbedtls/external/mbedtls/include) \

$(if $(CONFIG_$(XPL_)SYS_THUMB_BUILD), \

$(if $(CONFIG_HAS_THUMB2), \

$(if $(CONFIG_CPU_V7M), \

-I$(srctree)/arch/arm/thumb1/include), \

-I$(srctree)/arch/arm/thumb1/include)) \

-I$(srctree)/arch/$(ARCH)/include \

-include $(srctree)/include/linux/kconfig.h \

-I$(srctree)/dts/upstream/include \

$(if $(CONFIG_NET_LWIP), -I$(srctree)/lib/lwip/lwip/src/include \

-I$(srctree)/lib/lwip/u-boot)

NOSTDINC_FLAGS += -nostdinc -isystem $(shell $(CC) -print-file-name=include)

# FIX ME

cpp_flags := $(KBUILD_CPPFLAGS) $(PLATFORM_CPPFLAGS) $(UBOOTINCLUDE) \

$(NOSTDINC_FLAGS)

c_flags := $(KBUILD_CFLAGS) $(cpp_flags)

#########################################################################

# U-Boot objects....order is important (i.e. start must be first)

HAVE_VENDOR_COMMON_LIB = $(if $(wildcard $(srctree)/board/$(VENDOR)/common/Makefile),y,n)

libs-$(CONFIG_API) += api/

libs-$(HAVE_VENDOR_COMMON_LIB) += board/$(VENDOR)/common/

libs-y += boot/

libs-$(CONFIG_CMDLINE) += cmd/

libs-y += common/

libs-$(CONFIG_OF_EMBED) += dts/

libs-y += env/

libs-y += lib/

libs-y += fs/

libs-$(filter y,$(CONFIG_NET) $(CONFIG_NET_LWIP)) += net/

libs-y += disk/

libs-y += drivers/

libs-$(CONFIG_SYS_FSL_DDR) += drivers/ddr/fsl/

libs-$(CONFIG_SYS_FSL_MMDC) += drivers/ddr/fsl/

libs-$(CONFIG_$(XPL_)ALTERA_SDRAM) += drivers/ddr/altera/

libs-y += drivers/usb/cdns3/

libs-y += drivers/usb/dwc3/

libs-y += drivers/usb/common/

libs-y += drivers/usb/emul/

libs-y += drivers/usb/eth/

libs-$(CONFIG_USB_DEVICE) += drivers/usb/gadget/

libs-$(CONFIG_USB_GADGET) += drivers/usb/gadget/

libs-$(CONFIG_USB_GADGET) += drivers/usb/gadget/udc/

libs-y += drivers/usb/host/

libs-y += drivers/usb/mtu3/

libs-y += drivers/usb/musb/

libs-y += drivers/usb/musb-new/

libs-y += drivers/usb/isp1760/

libs-y += drivers/usb/phy/

libs-y += drivers/usb/tcpm/

libs-y += drivers/usb/ulpi/

ifdef CONFIG_POST

libs-y += post/

endif

libs-$(CONFIG_$(PHASE_)UNIT_TEST) += test/

libs-$(CONFIG_UT_ENV) += test/env/

libs-$(CONFIG_UT_OPTEE) += test/optee/

libs-$(CONFIG_UT_OVERLAY) += test/overlay/

libs-y += $(if $(wildcard $(srctree)/board/$(BOARDDIR)/Makefile),board/$(BOARDDIR)/)

libs-y := $(sort $(libs-y))

u-boot-dirs := $(patsubst %/,%,$(filter %/, $(libs-y))) tools examples

u-boot-alldirs := $(sort $(u-boot-dirs) $(patsubst %/,%,$(filter %/, $(libs-))))

libs-y := $(patsubst %/, %/built-in.o, $(libs-y))

u-boot-init := $(head-y)

u-boot-main := $(libs-y)

# Add GCC lib

ifeq ($(CONFIG_USE_PRIVATE_LIBGCC),y)

PLATFORM_LIBGCC = arch/$(ARCH)/lib/lib.a

else

ifndef CONFIG_CC_IS_CLANG

PLATFORM_LIBGCC := -L $(shell dirname `$(CC) $(c_flags) -print-libgcc-file-name`) -lgcc

endif

endif

PLATFORM_LIBS += $(PLATFORM_LIBGCC)

ifdef CONFIG_CC_COVERAGE

KBUILD_CFLAGS += --coverage

PLATFORM_LIBGCC += -lgcov

endif

export PLATFORM_LIBS

export PLATFORM_LIBGCC

# Special flags for CPP when processing the linker script.

# Pass the version down so we can handle backwards compatibility

# on the fly.

LDPPFLAGS += \

-include $(srctree)/include/u-boot/u-boot.lds.h \

-DCPUDIR=$(CPUDIR) \

$(shell $(LD) --version | \

sed -ne 's/GNU ld version \([0-9][0-9]*\)\.\([0-9][0-9]*\).*/-DLD_MAJOR=\1 -DLD_MINOR=\2/p')

#########################################################################

#########################################################################

ifneq ($(CONFIG_BOARD_SIZE_LIMIT),)

BOARD_SIZE_CHECK= @ $(call size_check,$@,$(CONFIG_BOARD_SIZE_LIMIT))

else

BOARD_SIZE_CHECK =

endif

ifneq ($(CONFIG_SPL_SIZE_LIMIT),0x0)

SPL_SIZE_CHECK = @$(call size_check,$@,$$(tools/spl_size_limit))

else

SPL_SIZE_CHECK =

endif

ifneq ($(CONFIG_TPL_SIZE_LIMIT),0x0)

TPL_SIZE_CHECK = @$(call size_check,$@,$(CONFIG_TPL_SIZE_LIMIT))

else

TPL_SIZE_CHECK =

endif

ifneq ($(CONFIG_VPL_SIZE_LIMIT),0x0)

VPL_SIZE_CHECK = @$(call size_check,$@,$(CONFIG_VPL_SIZE_LIMIT))

else

VPL_SIZE_CHECK =

endif

# Statically apply RELA-style relocations (currently arm64 only)

# This is useful for arm64 where static relocation needs to be performed on

# the raw binary, but certain simulators only accept an ELF file (but don't

# do the relocation).

ifneq ($(CONFIG_STATIC_RELA),)

# $(2) is u-boot ELF, $(3) is u-boot bin, $(4) is text base

quiet_cmd_static_rela = RELOC $@

cmd_static_rela = \

tools/relocate-rela $(3) $(2)

else

quiet_cmd_static_rela =

cmd_static_rela =

endif

# Always append INPUTS so that arch config.mk's can add custom ones

INPUTS-y += u-boot.srec u-boot.bin u-boot.sym System.map binary_size_check

ifeq ($(CONFIG_SPL_FSL_PBL),y)

INPUTS-$(CONFIG_RAMBOOT_PBL) += u-boot-with-spl-pbl.bin

else

ifneq ($(CONFIG_NXP_ESBC), y)

# For Secure Boot The Image needs to be signed and Header must also

# be included. So The image has to be built explicitly

INPUTS-$(CONFIG_RAMBOOT_PBL) += u-boot.pbl

endif

endif

INPUTS-$(CONFIG_SPL) += spl/u-boot-spl.bin

ifeq ($(CONFIG_MX6)$(CONFIG_IMX_HAB), yy)

INPUTS-$(CONFIG_SPL_FRAMEWORK) += u-boot-ivt.img

else

ifeq ($(CONFIG_MX7)$(CONFIG_IMX_HAB), yy)