VERSION = 4

PATCHLEVEL = 0

SUBLEVEL = 0

EXTRAVERSION =

NAME = MELIS SDK

# *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.

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

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

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

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

# 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 melis-eng), 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

ifeq ($(MELIS_BASE),)

$(error Please execute 'source melis-env.sh' first.)

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 ($(words $(subst :, ,$(CURDIR))), 1)

$(error main directory cannot contain spaces nor colons)

endif

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)"))

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 "Documentation/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 := .

prjtree := $(srctree)/projects

src := $(srctree)

obj := $(objtree)

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

export prjtree srctree objtree VPATH eboard-libs elibrary-libs

# SUBARCH tells the usermode build what the underlying arch is. That is set

# first, and if a usermode build is happening, the "ARCH=um" on the command

# line overrides the setting of ARCH below. If a native build is happening,

# then ARCH is assigned, getting whatever value it gets normally, and

# SUBARCH is subsequently ignored.

SUBARCH := $(shell uname -m | sed -e s/i.86/x86/ -e s/x86_64/x86/ \

-e s/sun4u/sparc64/ \

-e s/arm.*/arm/ -e s/sa110/arm/ \

-e s/s390x/s390/ -e s/parisc64/parisc/ \

-e s/ppc.*/powerpc/ -e s/mips.*/mips/ \

-e s/sh[234].*/sh/ -e s/aarch64.*/arm64/ )

include scripts/toolchain.mk

# Cross compiling and selecting different set of gcc/bin-utils

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

#

# When performing cross compilation for other architectures ARCH shall be set

# to the target architecture. (See arch/* for the possibilities).

# ARCH can be set during invocation of make:

# make ARCH=ia64

# Another way is to have ARCH set in the environment.

# The default ARCH is the host where make is executed.

# CROSS_COMPILE specify the prefix used for all executables used

# during compilation. Only gcc and related bin-utils executables

# are prefixed with $(CROSS_COMPILE).

# CROSS_COMPILE can be set on the command line

# make CROSS_COMPILE=ia64-linux-

# Alternatively CROSS_COMPILE can be set in the environment.

# A third alternative is to store a setting in .config so that plain

# "make" in the configured kernel build directory always uses that.

# Default value for CROSS_COMPILE is not to prefix executables

# Note: Some architectures assign CROSS_COMPILE in their arch/*/Makefile

ARCH ?= $(SUBARCH)

CROSS_COMPILE ?= $(CONFIG_CROSS_COMPILE:"%"=%)

# Architecture as present in compile.h

UTS_MACHINE := $(ARCH)

SRCARCH := $(ARCH)

# Additional ARCH settings for x86

ifeq ($(ARCH),i386)

SRCARCH := x86

endif

ifeq ($(ARCH),x86_64)

SRCARCH := x86

endif

# Additional ARCH settings for sparc

ifeq ($(ARCH),sparc32)

SRCARCH := sparc

endif

ifeq ($(ARCH),sparc64)

SRCARCH := sparc

endif

# Additional ARCH settings for sh

ifeq ($(ARCH),sh64)

SRCARCH := sh

endif

# Additional ARCH settings for tile

ifeq ($(ARCH),tilepro)

SRCARCH := tile

endif

ifeq ($(ARCH),tilegx)

SRCARCH := tile

endif

# Where to locate arch specific headers

hdr-arch := $(SRCARCH)

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)

HOSTCC = gcc

HOSTCXX = g++

HOSTCFLAGS = -Wall -Wmissing-prototypes -Wstrict-prototypes -O2 -fomit-frame-pointer -std=gnu89

HOSTCXXFLAGS = -O2

ifeq ($(shell $(HOSTCC) -v 2>&1 | grep -c "clang version"), 1)

HOSTCFLAGS += -Wno-unused-value -Wno-unused-parameter \

-Wno-missing-field-initializers -fno-delete-null-pointer-checks

endif

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

# Normally, just do built-in.

# Compile modules on melis by default.

# So ach sub-dir of Top can be compile seperately.

# make projects, ekernel ... ex.

KBUILD_MODULES := 1

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

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

KBUILD_MODULES := 1

endif

ifeq ($(MAKECMDGOALS),)

KBUILD_MODULES := 1

endif

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 include/config/auto.conf

include scripts/Kbuild.include

# Make variables (CC, etc...)

AS = $(CROSS_COMPILE)as

LD = $(CROSS_COMPILE)ld

CC = $(CROSS_COMPILE)gcc

CPP = $(CC) -E

AR = $(CROSS_COMPILE)ar

NM = $(CROSS_COMPILE)nm

STRIP = $(CROSS_COMPILE)strip

OBJCOPY = $(CROSS_COMPILE)objcopy

OBJDUMP = $(CROSS_COMPILE)objdump

SIZE = $(CROSS_COMPILE)size

AWK = awk

GENKSYMS = scripts/genksyms/genksyms

INSTALLKERNEL := installkernel

DEPMOD = /sbin/depmod

PERL = perl

PYTHON = python

CHECK = sparse

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

-Wbitwise -Wno-return-void $(CF)

CFLAGS_MODULE =

AFLAGS_MODULE =

LDFLAGS_MODULE =

CFLAGS_KERNEL =

AFLAGS_KERNEL =

CFLAGS_GCOV = -fprofile-arcs -ftest-coverage

# Use USERINCLUDE when you must reference the UAPI directories only.

USERINCLUDE := \

-Iinclude/generated \

-Iinclude/generated/uapi/melis \

-I$(srctree)/include/melis/elibrary \

-include $(srctree)/include/melis/kconfig.h

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

# Needed to be compatible with the O= option

MELISINCLUDE := \

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

-Iinclude \

-Iinclude/melis \

-Iinclude/melis/common \

-Iinclude/melis/eboot \

-Iinclude/melis/eboard \

-Iinclude/melis/ekernel \

-Iinclude/melis/ekernel/arch \

-Iinclude/melis/ekernel/csp \

-Iinclude/melis/ekernel/drivers \

-Iinclude/melis/ekernel/filesystem \

-Iinclude/melis/ekernel/pthread \

-Iinclude/melis/elibrary \

-Iinclude/melis/elibrary/libc \

-Iinclude/melis/elibrary/libc/mediainfo \

-Iinclude/melis/elibrary/libc/misc \

-Iinclude/melis/elibrary/libc/misc/pub0 \

-Iinclude/melis/emodules \

-Iinclude/melis/ipc \

-Iinclude/melis/misc \

-Iinclude/melis/of \

-Iinclude/melis/sys \

-Iinclude/melis/video \

-Iekernel/components/thirdparty/finsh_cli \

-Iekernel/core/rt-thread/include \

-Iekernel/components/thirdparty/dfs/include \

-Iekernel/drivers/hal/source \

-Iekernel/drivers/include/osal \

$(USERINCLUDE)

ifeq (${CONFIG_ARMV7_A}, y)

MELISINCLUDE += -Iinclude/melis/ekernel/arch/cortex-v7a

endif

ifeq (${CONFIG_RISCV}, y)

MELISINCLUDE += -Iinclude/melis/ekernel/arch/riscv

#for application in the livedesk directory

SOLUTION := livedesk

#head file include at beetles -- top directory of the application solution

SOLUTION_INCLUDE := -I${MELIS_BASE}/${SOLUTION}/beetles/elibs/libapps/module_adapter \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/libapps/scene/listbar \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/anole \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey/bookmark \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey/formats \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey/formats/encode_parser \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey/formats/encode_parser/gbk \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey/formats/encode_parser/utf16_big \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey/formats/encode_parser/utf16_little \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey/formats/encode_parser/utf8 \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey/mnpl \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/monkey/regedit \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/robin \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/robin/foundation \

-I${MELIS_BASE}/${SOLUTION}/beetles/elibs/lib_ex/robin/lib \

-I${MELIS_BASE}/${SOLUTION}/beetles/include \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/applets \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/ab \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/channel \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/disp_output \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/eq \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/ff_rr_speed \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/fsm_ctrl \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/lyric \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/media_info \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/npl \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/palette \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/play_mode \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/play_speed \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/spectrum \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/star \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/subtitle \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/track \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/video_layer \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/video_win \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/vision_effect \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/volume \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/robin/zoom \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/elibs/lib_ex/scanfile \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init/alarm \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init/background \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init/bookengine \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init/display \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init/headbar \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init/mini_music \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init/screen_lock \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init/tp_adjust \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/init/ui/tp_adjust_scene \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/libapps \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/libapps/module_adapter \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/libapps/scene \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/libapps/srf \

-I${MELIS_BASE}/${SOLUTION}/beetles/include/mod_desktop \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/ \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/background/fb_lib \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/headbar/ \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/headbar/prog_bar \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/mini_music \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/screen_lock \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/ui \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/ui/assistant_scene \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/ui/dialog_scene \

-I${MELIS_BASE}/${SOLUTION}/beetles/init/ui/tp_adjust_scene \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/engine \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/engine/radio \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/engine/radio/receive \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/engine/radio/send \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/engine/walkman \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/engine/walkman/foundation \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/engine/walkman/lib \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/framework \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/functions \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/include \

-I${MELIS_BASE}/${SOLUTION}/beetles/mod_desktop/util

export SOLUTION SOLUTION_INCLUDE

endif #ifeq (${CONFIG_RISCV}, y)

#KBUILD_CPPFLAGS := -D__KERNEL__

KBUILD_CPPFLAGS :=

KBUILD_CFLAGS := -Wall -Wundef -Wstrict-prototypes -Wno-trigraphs \

-fno-strict-aliasing -fno-common \

-Werror-implicit-function-declaration \

-Wno-format-security \

-fno-builtin-printf \

-D_SYS__PTHREADTYPES_H_

KBUILD_AFLAGS_KERNEL :=

KBUILD_CFLAGS_KERNEL :=

KBUILD_AFLAGS := -D__ASSEMBLY__

KBUILD_AFLAGS_MODULE := -DMODULE

KBUILD_CFLAGS_MODULE := -DMODULE

KBUILD_LDFLAGS_MODULE := -T $(srctree)/scripts/module-common.lds

# Read KERNELRELEASE from include/config/kernel.release (if it exists)

KERNELRELEASE = $(shell cat include/config/kernel.release 2> /dev/null)

KERNELVERSION = $(VERSION)$(if $(PATCHLEVEL),.$(PATCHLEVEL)$(if $(SUBLEVEL),.$(SUBLEVEL)))$(EXTRAVERSION)

export VERSION PATCHLEVEL SUBLEVEL KERNELRELEASE KERNELVERSION

export ARCH SRCARCH CONFIG_SHELL HOSTCC HOSTCFLAGS CROSS_COMPILE AS LD CC

export CPP AR NM STRIP OBJCOPY OBJDUMP SIZE

export MAKE AWK GENKSYMS INSTALLKERNEL PERL PYTHON UTS_MACHINE

export HOSTCXX HOSTCXXFLAGS LDFLAGS_MODULE CHECK CHECKFLAGS

export KBUILD_CPPFLAGS NOSTDINC_FLAGS MELISINCLUDE OBJCOPYFLAGS LDFLAGS

export KBUILD_CFLAGS CFLAGS_KERNEL CFLAGS_MODULE CFLAGS_GCOV CFLAGS_KASAN

export KBUILD_AFLAGS AFLAGS_KERNEL AFLAGS_MODULE

export KBUILD_AFLAGS_MODULE KBUILD_CFLAGS_MODULE KBUILD_LDFLAGS_MODULE

export KBUILD_AFLAGS_KERNEL KBUILD_CFLAGS_KERNEL

export KBUILD_ARFLAGS

# 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

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

# 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) $(objtree) $(VERSION) $(PATCHLEVEL)

endif

# Support for using generic headers in asm-generic

PHONY += asm-generic

asm-generic:

$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.asm-generic \

src=asm obj=arch/$(SRCARCH)/include/generated/asm

$(Q)$(MAKE) -f $(srctree)/scripts/Makefile.asm-generic \

src=uapi/asm obj=arch/$(SRCARCH)/include/generated/uapi/asm

# 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/uapi/melis/version.h

old_version_h := include/melis/version.h

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

cscope gtags TAGS tags help% %docs check% coccicheck \

$(version_h) headers_% archheaders archscripts \

kernelversion %src-pkg

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

# Read arch specific Makefile to set KBUILD_DEFCONFIG as needed.

# KBUILD_DEFCONFIG may point out an alternative default configuration

# used for 'make defconfig'

#include arch/$(SRCARCH)/Makefile

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 melis, arch specific targets, clean

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

ifeq ($(KBUILD_EXTMOD),)

# Additional helpers built in scripts/

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

# in parallel

PHONY += scripts

scripts: scripts_basic include/config/auto.conf include/config/tristate.conf

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

# Objects we will link into melis / subdirs we need to visit

init-y :=

drivers-y :=

net-y :=

libs-y :=

core-y :=

virt-y :=

apps-y :=

endif # KBUILD_EXTMOD

ifeq ($(dot-config),1)

# Read in config

ifeq ($(KBUILD_EXTMOD),)

# 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 silentoldconfig

else

# external modules needs include/generated/autoconf.h and include/config/auto.conf

# but do not care if they are up-to-date. Use auto.conf to trigger the test

PHONY += include/config/auto.conf

include/config/auto.conf:

$(Q)test -e include/generated/autoconf.h -a -e $@ || ( \

echo >&2; \

echo >&2 " ERROR: Kernel configuration is invalid."; \

echo >&2 " include/generated/autoconf.h or $@ are missing.";\

echo >&2 " Run 'make oldconfig && make prepare' on kernel src to fix it."; \

echo >&2 ; \

/bin/false)

endif # KBUILD_EXTMOD

else

# Dummy target needed, because used as prerequisite

include/config/auto.conf: ;

endif # $(dot-config)

# The all: target is the default when no target is given on the

# command line.

# This allow a user to issue only 'make' to build a kernel including modules

# Defaults to melis, but the arch makefile usually adds further targets

all: melis

# The arch Makefile can set ARCH_{CPP,A,C}FLAGS to override the default

# values of the respective KBUILD_* variables

#

include ekernel/arch/arch.mk

include ekernel/arch/boot/Makefile

ARCH_CPPFLAGS := $(ARCH_VFPUSED)

ARCH_AFLAGS := $(ARCH_VFPUSED)

ARCH_CFLAGS := -Wno-declaration-after-statement $(ARCH_VFPUSED)

export ARCH_VFPUSED

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

KBUILD_CFLAGS += $(call cc-option,-ffunction-sections,)

KBUILD_CFLAGS += $(call cc-option,-fdata-sections,)

KBUILD_CFLAGS += $(call cc-option,-fzero-initialized-in-bss,)

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

KBUILD_CFLAGS += $(call cc-option,-Wmaybe-uninitialized,)

ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE

KBUILD_CFLAGS += -Os -g -gdwarf-2 -gstrict-dwarf

#KBUILD_CFLAGS += -Ofast -g -gdwarf-2 -gstrict-dwarf

else

KBUILD_CFLAGS += -O$(CONFIG_CC_OPTIMIZE_LEVEL) -g -gdwarf-2 -gstrict-dwarf

endif

KBUILD_CFLAGS += -Wstrict-prototypes -Wundef

#KBUILD_CFLAGS += -Wshadow

ifdef CONFIG_ARM_UNWIND

KBUILD_CFLAGS += -funwind-tables

endif

#KBUILD_CFLAGS += -pg

ifdef CONFIG_USE_DUMP_STACK

KBUILD_CFLAGS += -mapcs

endif

#debug macro with GDB

ifdef CONFIG_DEBUG_MACROS

KBUILD_CFLAGS += -g3

endif

KBUILD_CFLAGS += $(call cc-option,-Wno-unused-function,)

KBUILD_CFLAGS += $(call cc-option,-Wno-unused-variable,)

#KBUILD_CFLAGS += $(call cc-option,-fshort-wchar,)

KBUILD_CFLAGS += $(call cc-option,-fshort-enums,)

KBUILD_CFLAGS += $(call cc-option,-Wsizeof-pointer-memaccess,)

# Tell gcc to never replace conditional load with a non-conditional one

KBUILD_CFLAGS += $(call cc-option,--param=allow-store-data-races=0)

ifdef CONFIG_READABLE_ASM

# Disable optimizations that make assembler listings hard to read.

# reorder blocks reorders the control in the function

# ipa clone creates specialized cloned functions

# partial inlining inlines only parts of functions

KBUILD_CFLAGS += $(call cc-option,-fno-reorder-blocks,) \

$(call cc-option,-fno-ipa-cp-clone,) \

$(call cc-option,-fno-partial-inlining)

endif

ifneq ($(CONFIG_FRAME_WARN),0)

KBUILD_CFLAGS += $(call cc-option,-Wframe-larger-than=${CONFIG_FRAME_WARN})

endif

# Handle stack protector mode.

#

# Since kbuild can potentially perform two passes (first with the old

# .config values and then with updated .config values), we cannot error out

# if a desired compiler option is unsupported. If we were to error, kbuild

# could never get to the second pass and actually notice that we changed

# the option to something that was supported.

#

# Additionally, we don't want to fallback and/or silently change which compiler

# flags will be used, since that leads to producing kernels with different

# security feature characteristics depending on the compiler used. ("But I

# selected CC_STACKPROTECTOR_STRONG! Why did it build with _REGULAR?!")

#

# The middle ground is to warn here so that the failed option is obvious, but

# to let the build fail with bad compiler flags so that we can't produce a

# kernel when there is a CONFIG and compiler mismatch.

#

ifdef CONFIG_CC_STACKPROTECTOR_REGULAR

stackp-flag := -fstack-protector

ifeq ($(call cc-option, $(stackp-flag)),)

$(warning Cannot use CONFIG_CC_STACKPROTECTOR_REGULAR: \

-fstack-protector not supported by compiler)

endif

else

ifdef CONFIG_CC_STACKPROTECTOR_STRONG

stackp-flag := -fstack-protector-strong

ifeq ($(call cc-option, $(stackp-flag)),)

$(warning Cannot use CONFIG_CC_STACKPROTECTOR_STRONG: \

-fstack-protector-strong not supported by compiler)

endif

else

# Force off for distro compilers that enable stack protector by default.

stackp-flag := $(call cc-option, -fno-stack-protector)

endif

endif

KBUILD_CFLAGS += $(stackp-flag)

ifeq ($(cc-name),clang)

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

KBUILD_CPPFLAGS += $(call cc-option,-Wno-unknown-warning-option,)

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

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

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

# 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)

else

# This warning generated too much noise in a regular build.

# Use make W=1 to enable this warning (see scripts/Makefile.build)

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

endif

#ifdef CONFIG_FRAME_POINTER

ifdef CONFIG_CC_OPTIMIZE_FOR_DEBUG

KBUILD_CFLAGS += -fno-omit-frame-pointer -fno-optimize-sibling-calls

else

# Some targets (ARM with Thumb2, for example), can't be built with frame

# pointers. For those, we don't have FUNCTION_TRACER automatically

# select FRAME_POINTER. However, FUNCTION_TRACER adds -pg, and this is

# incompatible with -fomit-frame-pointer with current GCC, so we don't use

# -fomit-frame-pointer with FUNCTION_TRACER.

ifndef CONFIG_FUNCTION_TRACER

KBUILD_CFLAGS += -fomit-frame-pointer

endif

endif

KBUILD_CFLAGS += $(call cc-option, -fno-var-tracking-assignments)

ifdef CONFIG_DEBUG_INFO

ifdef CONFIG_DEBUG_INFO_SPLIT

KBUILD_CFLAGS += $(call cc-option, -gsplit-dwarf, -g)

else

KBUILD_CFLAGS += -g

endif

KBUILD_AFLAGS += -Wa,-gdwarf-2

endif

ifdef CONFIG_DEBUG_INFO_DWARF4

KBUILD_CFLAGS += $(call cc-option, -gdwarf-4,)

endif

ifdef CONFIG_DEBUG_INFO_REDUCED

KBUILD_CFLAGS += $(call cc-option, -femit-struct-debug-baseonly) \

$(call cc-option,-fno-var-tracking)

endif

ifdef CONFIG_FUNCTION_TRACER

ifndef CC_FLAGS_FTRACE

CC_FLAGS_FTRACE := -pg

endif

export CC_FLAGS_FTRACE

ifdef CONFIG_HAVE_FENTRY

CC_USING_FENTRY := $(call cc-option, -mfentry -DCC_USING_FENTRY)

endif

KBUILD_CFLAGS += $(CC_FLAGS_FTRACE) $(CC_USING_FENTRY)

KBUILD_AFLAGS += $(CC_USING_FENTRY)

ifdef CONFIG_DYNAMIC_FTRACE

ifdef CONFIG_HAVE_C_RECORDMCOUNT

BUILD_C_RECORDMCOUNT := y

export BUILD_C_RECORDMCOUNT

endif

endif

endif

# We trigger additional mismatches with less inlining

ifdef CONFIG_DEBUG_SECTION_MISMATCH

KBUILD_CFLAGS += $(call cc-option, -fno-inline-functions-called-once)

endif

# arch Makefile may override CC so keep this after arch Makefile is included

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

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

CHECKFLAGS += $(NOSTDINC_FLAGS)

# warn about C99 declaration after statement

KBUILD_CFLAGS += $(call cc-option,-Wdeclaration-after-statement,)

# disable pointer signed / unsigned warnings in gcc 4.0

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

# disable invalid "can't wrap" optimizations for signed / pointers

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

# conserve stack if available

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

# disallow errors like 'EXPORT_GPL(foo);' with missing header

KBUILD_CFLAGS += $(call cc-option,-Werror=implicit-int)

# require functions to have arguments in prototypes, not empty 'int foo()'

KBUILD_CFLAGS += $(call cc-option,-Werror=strict-prototypes)

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

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

# use the deterministic mode of AR if available

KBUILD_ARFLAGS := $(call ar-option,D)

# check for 'asm goto'

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

KBUILD_CFLAGS += -DCC_HAVE_ASM_GOTO

KBUILD_AFLAGS += -DCC_HAVE_ASM_GOTO

endif

include scripts/Makefile.kasan

include scripts/Makefile.extrawarn

# Add any arch overrides and user supplied CPPFLAGS, AFLAGS and CFLAGS as the

# last assignments

KBUILD_CPPFLAGS += $(ARCH_CPPFLAGS) $(KCPPFLAGS)

KBUILD_AFLAGS += $(ARCH_AFLAGS) $(KAFLAGS)

KBUILD_CFLAGS += $(ARCH_CFLAGS) $(KCFLAGS)

KBUILD_CFLAGS += $(call cc-option,-Wno-unused-label)

KBUILD_CFLAGS += $(call cc-option,-Wextra)

KBUILD_CFLAGS += $(call cc-option,-Wno-unused-parameter)

KBUILD_CFLAGS += $(call cc-option,-Wno-old-style-declaration)

KBUILD_CFLAGS += $(call cc-option,-Wno-sign-compare)

KBUILD_CFLAGS += $(call cc-option,-mfloat-abi=hard)

ifdef CONFIG_DEBUG_INFO

#KBUILD_CFLAGS += $(call cc-option,-O0)

#KBUILD_CFLAGS += $(call cc-option,-g3)

#KBUILD_CFLAGS += $(call cc-option,-gdwarf-2,)

#KBUILD_CFLAGS += $(call cc-option,-gstrict-dwarf,)

endif

# Use --build-id when available.

LDFLAGS_BUILD_ID = $(patsubst -Wl$(comma)%,%,\

$(call cc-ldoption, -Wl$(comma)--build-id,))

KBUILD_LDFLAGS_MODULE += $(LDFLAGS_BUILD_ID)

LDFLAGS_melis += $(LDFLAGS_BUILD_ID)

ifeq ($(CONFIG_STRIP_ASM_SYMS),y)

LDFLAGS_melis += $(call ld-option, -X,)

endif

# Library directory

ifdef CONFIG_ARM

LIB_DIR := toolchain-sunxi-arm32

else

ifdef CONFIG_RISCV

LIB_DIR := toolchain-sunxi-riscv64

endif

endif

export LIB_DIR

# Default kernel image to build when no specific target is given.

# KBUILD_IMAGE may be overruled on the command line or

# set in the environment

# Also any assignments in arch/$(ARCH)/Makefile take precedence over

# this default value

export KBUILD_IMAGE ?= melis

#

# INSTALL_PATH specifies where to place the updated kernel and system map

# images. Default is /boot, but you can set it to other values

export INSTALL_PATH ?= /boot

#

# INSTALL_DTBS_PATH specifies a prefix for relocations required by build roots.