#
# Linux Alpha Miniloader make file.  Build this against the kernel.
# It produces:
#
# milo	- the Miniloader
#
# This file is subject to the terms and conditions of the GNU General Public
# License.  See the file "COPYING" in the main directory of this archive
# for more details.
#
# This Makefile is made by  david.rusling@reo.mts.dec.com  with
# model from Linux original system Makefile, and with some changes
# by  Matti.Aarnio@utu.fi (did cross-compiling at OSF/1)
#

CONFIG_SHELL := $(shell if [ -x "$$BASH" ]; then echo $$BASH; \
	  else if [ -x /bin/bash ]; then echo /bin/bash; \
	  else if [ -x /usr/local/bin/bash ]; then echo /usr/local/bin/bash ;\
          else echo sh; fi ; fi; fi)

#
# Make "config" the default target if there is no configuration file or
# "depend" the target if there is no top-level dependency information.
#
ifeq (.config,$(wildcard .config))
include .config
ALL	= milo
else
ALL	= config
endif


#
# First, where's the linux kernel that we're building against?
#
KSRC	= /usr/src/linux
include $(KSRC)/.config

#
# Now, what tools should we be using?
# 
# Choose your compiler -- GCC it must be...
# Leave these othervice on, uncommenting OSF/1 aka DEC UNIX
# cross-compile specific lines below can override these.
#
# If doing cross-compilation at OSF/1, do install GNU-tools
# (source from RedHat AXP kit) in cross-compile mode, and
# define  CROSS_COMPILE= below (uncomment it)
# (gcc:  ./configure --target=alpha-linux --prefix=..... --with-gas )
#
# CROSS_COMPILE = alpha-linux-
#
AS     = $(CROSS_COMPILE)as
LD     = $(CROSS_COMPILE)ld
HOSTCC = gcc -I$(KSRC)/include
#CC     = $(CROSS_COMPILE)gcc -D__KERNEL__  -D__linux__  -DBOOT_VERBOSE  -DDEBUG_MINIBOOT
CC    = $(CROSS_COMPILE)gcc -D__KERNEL__  -D__linux__
#MAKE  = make  # this is spurious -- and default..
CPP    = $(CC) -E
AR     = $(CROSS_COMPILE)ar
NM     = $(CROSS_COMPILE)nm
STRIP  = $(CROSS_COMPILE)strip
RANLIB = $(CROSS_COMPILE)ranlib
OBJSTRIP = $(KSRC)/arch/alpha/boot/tools/objstrip

#
# Set up some of our own linkflags, libraries and so on.
#
LINKFLAGS = -non_shared -N 
CFLAGS	=  -O2 -Wall -mno-fp-regs 
LIBS	= $(KSRC)/arch/alpha/lib/lib.a $(KSRC)/lib/lib.a	\
	  $(KSRC)/arch/alpha/lib/lib.a

#
# Local libraries that Milo needs
#
ifdef MINI_DIGITAL_BIOSEMU
X86LIB	= x86-digital/biosem.a
else
X86LIB	= x86/libx86-milo.a
endif
LIBS	:= $(LIBS) $(X86LIB) $(LIBS)

ifndef MINI_EMBED_LINUX
FSLIB  		= fs-milo.a
MINI_LIBS	:= $(LIBS) fs/$(FSLIB)
endif

#
#  Where do things go in memory?  Be careful with this as you need to have 
#  things like relocate.S and milo.ld agree with these numbers.
#
PALCODE_AT =     0xfffffc0000200000
STUB_AT	=	 0xfffffc0000210000
LOADER_AT =      0xfffffc0000d00000
FMU_AT =	0xfffffc0000310000
DECOMP_PALBASE = 0x300000
DECOMP_BASE =	 0x300B00

#
#  ...and how big are they?
#
PALCODE_SIZE =	0x10000
LOADER_SIZE =	0x20000

ifndef CONFIG_CROSSCOMPILE # not cross-compile ? Must be at Linux with gnu-ld
 elf=$(shell if $(LD) --help | grep elf64alpha >/dev/null; then echo yes; fi)
 ifeq ($(elf),yes)
  LD := $(LD)
  FULLLINKFLAGS := $(LINKFLAGS) -Ttext $(LOADER_AT)
  STUBLINKFLAGS := $(LINKFLAGS) -Ttext $(STUB_AT)
  FMULINKFLAGS :=  $(LINKFLAGS) -Ttext $(FMU_AT)
  MILOLINKFLAGS := $(LINKFLAGS) -Ttext $(DECOMP_BASE)
 else
  FULLLINKFLAGS := $(LINKFLAGS) -T milo.ld
  STUBLINKFLAGS := $(LINKFLAGS) -T stub.ld
  FMULINKFLAGS :=  $(LINKFLAGS) -T fmu.ld
  MILOLINKFLAGS := $(LINKFLAGS) -T relocate.ld
 endif
else # we (propably) are cross-compiling with GNU tools..
ifdef CROSS_COMPILE
FULLLINKFLAGS := $(LINKFLAGS) -T milo.ld
STUBLINKFLAGS := $(LINKFLAGS) -T stub.ld
FMULINKFLAGS :=  $(LINKFLAGS) -T fmu.ld
MILOLINKFLAGS := $(LINKFLAGS) -T relocate.ld
else # we (propably) are cross-compiling at OSF/1 with its ld ...
FULLLINKFLAGS := $(LINKFLAGS) -T $(LOADER_AT)
STUBLINKFLAGS := $(LINKFLAGS) -T $(STUB_AT)
FMULINKFLAGS :=  $(LINKFLAGS) -T $(FMU_AT)
MILOLINKFLAGS := $(LINKFLAGS) -T $(DECOMP_BASE)
endif
endif

TOOLS=	tools/bin/data  tools/bin/sysgen \
	tools/bin/clist tools/bin/makerom


#
#  The main config utility tells us what sort of system it is.  Here we derive
#  some more information from this, like where's the PALcode?  Some of these control 
#  the things that get built later on.
#
ifdef CONFIG_ALPHA_NONAME
MACHINE_TYPE 	=	-DDC21066
PALCODE_DIR  	= palcode/noname
RELOCATE_MINI   = 1
SYSTEM_SPECIFIC = -DMINI_NVRAM
ALL		:= $(ALL) mboot milo.dd fmu.gz
ASFLAGS   	= -m21066
endif

ifdef CONFIG_ALPHA_P2K
MACHINE_TYPE 	= -DDC21066
PALCODE_DIR  	= palcode/p2k
RELOCATE_MINI   = 1
SYSTEM_SPECIFIC = 
ASFLAGS   	= -m21066
endif

ifdef CONFIG_ALPHA_CABRIOLET
MACHINE_TYPE =	-DDC21064
PALCODE_DIR  = palcode/eb64p
SYSTEM_SPECIFIC = -DI28F008SA -DMINI_NVRAM
ALL		:= $(ALL) mboot  milo.dd milo.rom fmu.gz
ASFLAGS   	= -m21064
endif

ifdef CONFIG_ALPHA_EB164
MACHINE_TYPE =	-DDC21164
PALCODE_DIR  = palcode/eb164
SYSTEM_SPECIFIC = -DI28F008SA -DMINI_NVRAM
ALL		:= $(ALL) mboot  milo.dd milo.rom fmu.gz
ASFLAGS   	= -m21164
endif

ifdef CONFIG_ALPHA_PC164
MACHINE_TYPE =	-DDC21164
PALCODE_DIR  = palcode/pc164
SYSTEM_SPECIFIC = -DI28F008SA -DMINI_NVRAM
ALL		:= $(ALL) mboot  milo.dd milo.rom fmu.gz
ASFLAGS   	= -m21164
endif

ifdef CONFIG_ALPHA_LX164
MACHINE_TYPE =	-DDC21164
PALCODE_DIR  = palcode/lx164
SYSTEM_SPECIFIC = -DI28F008SA -DMINI_NVRAM
ALL		:= $(ALL) mboot  milo.dd milo.rom fmu.gz
ASFLAGS   	= -m21164
endif

ifdef CONFIG_ALPHA_SX164
MACHINE_TYPE =	-DDC21164 -DDC21164PC
PALCODE_DIR  = palcode/sx164
SYSTEM_SPECIFIC = -DI28F008SA #-DMINI_NVRAM
ALL		:= $(ALL) mboot  milo.dd milo.rom fmu.gz
ASFLAGS   	= -m21164
endif

ifdef CONFIG_ALPHA_RUFFIAN
MACHINE_TYPE =  -DDC21164
PALCODE_DIR  =  palcode/pc164
SYSTEM_SPECIFIC =
ALL         :=  $(ALL) mboot
ASFLAGS      =  -m21164
endif

ifdef CONFIG_ALPHA_TAKARA
MACHINE_TYPE =	-DDC21164
PALCODE_DIR  = palcode/takara
SYSTEM_SPECIFIC = -DI28F008SA #-DMINI_NVRAM
ALL		:= $(ALL) mboot milo.dd milo.rom fmu.gz
ASFLAGS   	= -m21164
endif

ifdef CONFIG_ALPHA_ALCOR
MACHINE_TYPE =	-DDC21164
PALCODE_DIR  = palcode/eb164
SYSTEM_SPECIFIC = 
ALL		:= $(ALL) mboot  milo.dd
ASFLAGS   	= -m21164
endif

ifdef CONFIG_ALPHA_XLT
MACHINE_TYPE =	-DDC21164
PALCODE_DIR  = palcode/eb164
SYSTEM_SPECIFIC = 
ALL		:= $(ALL) mboot  milo.dd
ASFLAGS   	= -m21164
endif

ifdef CONFIG_ALPHA_MIATA
MACHINE_TYPE =	-DDC21164
PALCODE_DIR  = palcode/miata
SYSTEM_SPECIFIC = 
ALL		:= $(ALL) mboot  milo.dd
ASFLAGS   	= -m21164
endif

ifdef CONFIG_ALPHA_EB66
MACHINE_TYPE =	-DDC21066 
PALCODE_DIR  = palcode/eb66
SYSTEM_SPECIFIC = 
ASFLAGS   	= -m21066
endif

ifdef CONFIG_ALPHA_EB64P
MACHINE_TYPE =	-DDC21064
PALCODE_DIR  = palcode/eb64p
SYSTEM_SPECIFIC = 
ASFLAGS   	= -m21064
ALL		:= $(ALL) 
endif

ifdef CONFIG_ALPHA_AVANTI
MACHINE_TYPE =	-DDC21064
PALCODE_DIR  = palcode/avanti
SYSTEM_SPECIFIC =  
ASFLAGS   	= -m21064
ALL		:= $(ALL) mboot  milo.dd
endif

ifdef CONFIG_ALPHA_MIKASA
MACHINE_TYPE =	-DDC21064
PALCODE_DIR  = palcode/mikasa
SYSTEM_SPECIFIC = 
ASFLAGS   	= -m21064
ALL		:= $(ALL) mboot  milo.dd
endif

ifdef CONFIG_ALPHA_EB66P
MACHINE_TYPE = -DDC21066
PALCODE_DIR  = palcode/eb66p
BUILD_FLASH = 1
SYSTEM_SPECIFIC = -DI28F008SA -DMINI_NVRAM
ALL		:= $(ALL) fmu.gz
ASFLAGS   	= -m21066
endif

#
#  Set up the compile and build time constants that we need.
#
WHERE   =    	-DPALCODE_AT=$(PALCODE_AT) \
		-DLOADER_AT=$(LOADER_AT) \
		-DSTUB_AT=$(STUB_AT) \
		-DDECOMP_PALBASE=$(DECOMP_PALBASE) \
		-DDECOMP_BASE=$(DECOMP_BASE)

SIZES   =	-DPALCODE_SIZE=$(PALCODE_SIZE) \
		-DLOADER_SIZE=$(LOADER_SIZE) 

DEFINES = $(WHERE) $(SIZES) \
	$(MACHINE_TYPE) \
	$(SYSTEM_SPECIFIC)

INCLUDES = -I. -Ix86 -Ifs -I$(KSRC)/include -I$(KSRC) -I$(PALCODE_DIR)/

.c.s:
	$(CC) $(CFLAGS) $(DEFINES) $(INCLUDES) -S -o $*.s $<
.s.o:
	$(AS) $(ASFLAGS) -o $*.o $<
.c.o:
	$(CC) $(CFLAGS) $(DEFINES) $(INCLUDES) -c -o $*.o $<
.S.s:
	$(CC) -D__ASSEMBLY__ -traditional -E -o $*.s $<
.S.o:
	$(CC) -D__ASSEMBLY__ $(DEFINES) $(INCLUDES) \
		-traditional -E -o $*.s_p $<
	$(AS) $(ASFLAGS) -o $*.o $*.s_p || rm $*.s_p
	rm -f $*.s_p

COMMON_OBJECTS = \
	video.o biosvga.o x86_sysenv.o tga.o \
	kbd.o printf.o \
	support.o \
	uart.o 

ZIPOBJECTS = zip/misc.o zip/inflate.o zip/unzip.o

OBJECTS = \
	head.o entry.o boot_main.o hwrpb.o cpu.o milo.o nvram.o $(ZIPOBJECTS) \
	memory.o env.o 28f008sa.o timer.o \
	devices.o \
	$(KSRC)/kernel/softirq.o \
	$(KSRC)/arch/alpha/kernel/irq.o \
	$(KSRC)/init/version.o  

FLASH_OBJECTS = head.o flash_main.o flash.o noname.o eb.o 28f008sa.o

STUB_OBJECTS = \
	head.o stub_main.o uart.o printf.o support.o zip/inflate.o zip/unzip.o

RELOCATE_OBJECTS = \
	head.o relocate.o

ifdef CONFIG_ALPHA_PC164
#OBJECTS	:= $(OBJECTS) smc.o
#FLASH_OBJECTS	:= $(FLASH_OBJECTS) smc.o
STUB_OBJECTS	:= $(STUB_OBJECTS) smc.o
endif

ifdef CONFIG_ALPHA_LX164
#OBJECTS	:= $(OBJECTS) smc.o
#FLASH_OBJECTS	:= $(FLASH_OBJECTS) smc.o
STUB_OBJECTS	:= $(STUB_OBJECTS) smc.o
endif

ifdef CONFIG_ALPHA_MIKASA
OBJECTS		:= $(OBJECTS) pceb.o
endif

ifdef CONFIG_ALPHA_ALCOR
OBJECTS		:= $(OBJECTS) pceb.o
endif

# if we're going to embed it, then we need the kernel
ifdef MINI_EMBED_LINUX
OBJECTS := $(OBJECTS) vmlinux_image.o 
endif

#
#  What objects/libraries that we need from the Linux kernel depends on what 
#  we're building.
#
ifdef CONFIG_PCI

ifdef CONFIG_ALPHA_LCA
COMMON_OBJECTS := $(COMMON_OBJECTS) $(KSRC)/arch/alpha/kernel/lca.o 
endif

ifdef CONFIG_ALPHA_APECS
COMMON_OBJECTS := $(COMMON_OBJECTS) $(KSRC)/arch/alpha/kernel/apecs.o 
endif

ifdef CONFIG_ALPHA_CIA
COMMON_OBJECTS := $(COMMON_OBJECTS) $(KSRC)/arch/alpha/kernel/cia.o 
endif

ifdef CONFIG_ALPHA_PYXIS
COMMON_OBJECTS := $(COMMON_OBJECTS) $(KSRC)/arch/alpha/kernel/pyxis.o 
endif

COMMON_OBJECTS := $(COMMON_OBJECTS)  \
	$(KSRC)/arch/alpha/kernel/bios32.o \
	$(KSRC)/arch/alpha/kernel/smc.o \
	$(KSRC)/drivers/pci/pci.a

endif

ifdef CONFIG_SCSI
OBJECTS := $(OBJECTS) $(KSRC)/drivers/block/block.a 
OBJECTS := $(OBJECTS) $(KSRC)/kernel/resource.o $(KSRC)/drivers/scsi/scsi.a
endif

ifdef CONFIG_FLOPPY
ifndef CONFIG_SCSI
OBJECTS := $(OBJECTS) $(KSRC)/drivers/block/block.a
endif
endif


#
#  The set of targets for this directory depends on what system we're 
#  building the miniloader for.
#
all:	$(ALL)
	@echo now build a rom, burn some flash or load an image!

ifndef MINI_DIGITAL_BIOSEMU
$(X86LIB):
	$(MAKE) -C x86 DEFINES="" X86LIB=../$(X86LIB) ../$(X86LIB)
endif

fs/$(FSLIB):
	$(MAKE) -C fs KSRC=$(KSRC) FSLIB=$(FSLIB) CC="$(CC)" $(FSLIB)

$(PALCODE_DIR)/osfpal.nh:
	$(MAKE) -C $(PALCODE_DIR) 

msb:	all
	@echo dummy action for miniloader

config: 
	$(CONFIG_SHELL) Configure config.in


# ----------------------------------------------------------------------------
#	milo (a relocatable image that can be loaded by _anything_!
# ----------------------------------------------------------------------------

micropal.i:	micropal.S
	$(CPP) $(DEFINES) -D__ASSEMBLY__ $(INCLUDES) $< > micropal.i

micropal.o:	micropal.i
	$(AS) $(ASFLAGS) -o micropal.o micropal.i

micropal:	micropal.o
	$(LD) -e Start $(LINKFLAGS) -o $@ micropal.o

milo.compressed.s:	tools/bin/data milo.compressed
	tools/bin/data -v milo.compressed milo.compressed.s

milo.compressed.o:	milo.compressed.s

micropal.nh:	micropal $(OBJSTRIP)
	strip micropal
	$(OBJSTRIP) -v micropal micropal.nh

relocate.o:	relocate.c

smc.o:		smc.c

pceb.o:		pceb.c

milo.exe: $(RELOCATE_OBJECTS) milo.compressed.o
	$(LD) $(MILOLINKFLAGS) \
		$(RELOCATE_OBJECTS) milo.compressed.o \
uart.o printf.o \
		$(LIBS) \
		-o milo.exe || \
		(rm -f milo.exe && exit 1)
	$(NM) milo.exe | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | sort > relocate.map
	strip $@

milo.nh:	milo.exe $(OBJSTRIP)
	$(OBJSTRIP) -v milo.exe milo.nh

milo:	micropal.nh milo.nh tools/bin/sysgen $(X86LIB)
	tools/bin/sysgen \
		-s -e$(DECOMP_PALBASE) micropal.nh \
		-s -e$(DECOMP_BASE) milo.nh \
		-o milo

# ----------------------------------------------------------------------------
#	gunzip stub code (milo.compressed)
# ----------------------------------------------------------------------------

milo.full.s:	tools/bin/data milo.full
	rm -f milo.full.gz
	cp -f milo.full tmp
	gzip tmp
	mv tmp.gz milo.full.gz
	tools/bin/data -v milo.full.gz milo.full.s

milo.full.o:	milo.full.s

milo.compressed.exe: $(STUB_OBJECTS) milo.full.o
	$(LD) $(STUBLINKFLAGS) \
		$(STUB_OBJECTS) milo.full.o \
		$(LIBS) \
		-o milo.compressed.exe || \
		(rm -f milo.compressed.exe && exit 1)
	$(NM) milo.compressed.exe | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | sort > stub.map

milo.compressed.nh:	milo.compressed.exe $(OBJSTRIP)
	cp -f milo.compressed.exe milo.compressed.stripped
	$(STRIP) milo.compressed.stripped
	$(OBJSTRIP) -v milo.compressed.stripped milo.compressed.nh

milo.compressed: $(PALCODE_DIR)/osfpal.nh milo.compressed.nh tools/bin/sysgen 
	tools/bin/sysgen \
		-s -e$(PALCODE_AT) $(PALCODE_DIR)/osfpal.nh \
		-s -e$(STUB_AT) milo.compressed.nh \
		-o milo.compressed

# ----------------------------------------------------------------------------
#	The miniloader itself (milo.full)
# ----------------------------------------------------------------------------

milo.full.exe: $(OBJECTS) $(COMMON_OBJECTS) $(MINI_LIBS)
	$(LD) $(FULLLINKFLAGS)  \
		$(OBJECTS) $(COMMON_OBJECTS) \
		$(MINI_LIBS) \
		-o milo.full.exe || \
		(rm -f milo.full.exe && exit 1)
	$(NM) milo.full.exe | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | sort > milo.map

milo.full.stripped: milo.full.exe
	cp -f milo.full.exe milo.full.stripped
	$(STRIP) milo.full.stripped

milo.full:	milo.full.stripped $(OBJSTRIP)
	$(OBJSTRIP) -v milo.full.stripped milo.full

# -----------------------------------------------------------------------------
#	embedded image code                           
# -----------------------------------------------------------------------------
ifdef MINI_EMBED_LINUX

vmlinux_image.s:	$(KSRC)/vmlinux.stripped.gz tools/bin/data
	tools/bin/data -v $(KSRC)/vmlinux.stripped.gz vmlinux_image.s

vmlinux_image.o:	vmlinux_image.s

endif

# ----------------------------------------------------------------------------
#	boot block loadable milo.
# ----------------------------------------------------------------------------

mboot:	milo $(OBJSTRIP)
	$(OBJSTRIP) -v -p milo mboot >/dev/null

#bootm:	milo.exe $(OBJSTRIP)
#	$(OBJSTRIP) -v milo.exe bootm

milo.dd: mboot milo
	cat mboot milo > milo.dd

# ----------------------------------------------------------------------------
#	rom images
# ----------------------------------------------------------------------------
milo.rom:	milo tools/bin/makerom
	tools/bin/makerom -v -c -l200000 -i7 -s"MILO" milo -o milo.rom

# ----------------------------------------------------------------------------
#	flash update tool
# ----------------------------------------------------------------------------
ifdef CONFIG_ALPHA_NONAME
flash_image.s:	tools/bin/data milo 
	tools/bin/data -v milo flash_image.s
else
flash_image.s:	tools/bin/data milo.rom
	tools/bin/data -v milo.rom flash_image.s
endif

flash_image.o:	flash_image.s

fmu.gz:	fmu
	cp -f fmu tmp
	gzip tmp
	mv tmp.gz fmu.gz

fmu: $(FLASH_OBJECTS) $(COMMON_OBJECTS) flash_image.o
	$(LD) $(FMULINKFLAGS) \
		$(FLASH_OBJECTS) $(COMMON_OBJECTS) flash_image.o \
		$(LIBS) \
		-o fmu || \
		(rm -f fmu && exit 1)
	$(NM) fmu | grep -v '\(compiled\)\|\(\.o$$\)\|\( a \)' | sort > fmu.map
	$(STRIP) fmu

# ----------------------------------------------------------------------------
#	The tools that we need to build the miniloader.
# ----------------------------------------------------------------------------

tools:	$(TOOLS)

tools/bin/clist:	tools/list/clist.c tools/common/commlib.a
	(cd tools/list ; make install)

tools/bin/sysgen:	tools/sysgen/sysgen.c
	(cd tools/sysgen ; make install)

tools/bin/data:	tools/data/data.c
	(cd tools/data ; make install)

tools/bin/makerom:	tools/makerom/makerom.c
	(cd tools/makerom ; make install)

tools/common/commlib.a:	tools/common/c_32_64.c tools/common/disassm.c 
	tools/common/romhead.c
	(cd tools/common ; make all) 

clean:
	rm -f $(ALL) *.nh *.map *.lis *.exe *.o flash_image.s *.gz  \
		mboot *~ milo.exe milo.full* milo.compressed* \
		*.stripped *.i
	$(MAKE) -C fs FSLIB=$(FSLIB) KSRC=$(KSRC) clean
	$(MAKE) -C $(PALCODE_DIR) clean
	rm -f ./*/*.o ./*/*~ *.gz *.stripped $(TOOLS)
ifndef MINI_DIGITAL_BIOSEMU
	$(MAKE) -C x86 DEFINES="" X86LIB=$(X86LIB) clean
endif
	(cd tools/list ; make clean) 
	(cd tools/makerom ; make clean) 
	(cd tools/data ; make clean) 
	(cd tools/common ; make clean) 
	(cd tools/sysgen ; make clean) 

dep:
