764 lines
34 KiB
Bash
Executable File
764 lines
34 KiB
Bash
Executable File
#!/bin/bash
|
|
#========================================================================================================
|
|
# NAME
|
|
# build.sh - Shell script to build a ZPU/K64F/M68K program or OS.
|
|
#
|
|
# SYNOPSIS
|
|
# build.sh [-CIOoMBAsTZdxh]
|
|
#
|
|
# DESCRIPTION
|
|
#
|
|
# OPTIONS
|
|
# -C <CPU> = Small, Medium, Flex, Evo, EvoMin, K64F, M68K - defaults to Evo.
|
|
# -I <iocp ver> = 0 - Full, 1 - Medium, 2 - Minimum, 3 - Tiny (bootstrap only)
|
|
# -O <os> = zputa, zos
|
|
# -o <os ver> = 0 - Standalone, 1 - As app with IOCP Bootloader,
|
|
# 2 - As app with tiny IOCP Bootloader, 3 - As app in RAM
|
|
# -M <size> = Max size of the boot ROM/BRAM (needed for setting Stack).
|
|
# -B <addr> = Base address of <os>, default -o == 0 : 0x00000 else 0x01000
|
|
# -A <addr> = App address of <os>, default 0x0C000
|
|
# -N <size> = Required size of heap
|
|
# -n <size> = Required size of application heap
|
|
# -S <size> = Required size of stack
|
|
# -s <size> = Required size of application stack
|
|
# -a <size> = Maximum size of an app, defaults to (BRAM SIZE - App Start Address - Stack Size)
|
|
# if the App Start is located within BRAM otherwise defaults to 0x10000.
|
|
# -T = TranZPUter specific build, adds initialisation and setup code.
|
|
# -Z = Sharp MZ series ZPU build, zOS runs as an OS host on Sharp MZ hardware.
|
|
# -d = Debug mode.
|
|
# -x = Shell trace mode.
|
|
# -h = This help screen.
|
|
#
|
|
# EXAMPLES
|
|
# build.sh -O zputa -B 0x00000 -A 0x50000
|
|
#
|
|
# EXIT STATUS
|
|
# 0 The command ran successfully
|
|
#
|
|
# >0 An error ocurred.
|
|
#
|
|
#EndOfUsage <- do not remove this line
|
|
#========================================================================================================
|
|
# History:
|
|
# v1.00 : Initial version (C) P. Smart January 2019.
|
|
# v1.10 : Changes to better calculate mode and addresses and setup linker scripts.
|
|
# v1.11 : Added CPU as it is clear certain features must be disabled in the original
|
|
# CPU's, ie. small where the emulated mul and div arent working as they should.
|
|
# v1.2 : Added more zOS logic and the K64F processor target for the tranZPUter board.
|
|
# v1.21 : Additional changes to manage heap.
|
|
# v1.22 : Added code to build the libraries.
|
|
# v1.23 : Added flags for Sharp MZ series specific build.
|
|
# v1.24 : Added M68000 support
|
|
#========================================================================================================
|
|
# This source file is free software: you can redistribute it and#or modify
|
|
# it under the terms of the GNU General Public License as published
|
|
# by the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This source file is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
#========================================================================================================
|
|
|
|
PROG=${0##*/}
|
|
#PARAMS="`basename ${PROG} '.sh'`.params"
|
|
ARGS=$*
|
|
|
|
##############################################################################
|
|
# Load program specific variables
|
|
##############################################################################
|
|
|
|
# VERSION of this RELEASE.
|
|
#
|
|
VERSION="1.23"
|
|
|
|
# Constants.
|
|
BUILDPATH=`pwd`
|
|
|
|
# Temporary files.
|
|
TMP_DIR=/tmp
|
|
TMP_OUTPUT_FILE=${TMP_DIR}/tmpoutput_$$.log
|
|
TMP_STDERR_FILE=${TMP_DIR}/tmperror_$$.log
|
|
|
|
# Log mechanism setup.
|
|
#
|
|
LOG="/tmp/${PROG}_`date +"%Y_%m_%d"`.log"
|
|
LOGTIMEWIDTH=40
|
|
LOGMODULE="MAIN"
|
|
|
|
# Mutex's - prevent multiple threads entering a sensitive block at the same time.
|
|
#
|
|
MUTEXDIR="/var/tmp"
|
|
|
|
##############################################################################
|
|
# Utility procedures
|
|
##############################################################################
|
|
|
|
# Function to output Usage instructions, which is soley a copy of this script header.
|
|
#
|
|
function Usage
|
|
{
|
|
# Output the lines at the start of this script from NAME to EndOfUsage
|
|
cat $0 | nawk 'BEGIN {s=0} /EndOfUsage/ { exit } /NAME/ {s=1} { if (s==1) print substr( $0, 3 ) }'
|
|
exit 1
|
|
}
|
|
|
|
# Function to output a message in Log format, ie. includes date, time and issuing module.
|
|
#
|
|
function Log
|
|
{
|
|
DATESTR=`date "+%d/%m/%Y %H:%M:%S"`
|
|
PADLEN=`expr ${LOGTIMEWIDTH} + -${#DATESTR} + -1 + -${#LOGMODULE} + -15`
|
|
printf "%s %-${PADLEN}s %s\n" "${DATESTR} [$LOGMODULE]" " " "$*"
|
|
}
|
|
|
|
# Function to terminate the script after logging an error message.
|
|
#
|
|
function Fatal
|
|
{
|
|
Log "ERROR: $*"
|
|
Log "$PROG aborted"
|
|
exit 2
|
|
}
|
|
|
|
# Function to output the Usage, then invoke Fatal to exit with a terminal message.
|
|
#
|
|
function FatalUsage
|
|
{
|
|
# Output the lines at the start of this script from NAME to EndOfUsage
|
|
cat $0 | nawk 'BEGIN {s=0} /EndOfUsage/ { exit } /NAME/ {s=1} { if (s==1) print substr( $0, 3 ) }'
|
|
echo " "
|
|
echo "ERROR: $*"
|
|
echo "$PROG aborted"
|
|
exit 3
|
|
}
|
|
|
|
# Function to output a message if DEBUG mode is enabled. Primarily to see debug messages should a
|
|
# problem occur.
|
|
#
|
|
function Debug
|
|
{
|
|
if [ $DEBUGMODE -eq 1 ]; then
|
|
Log "$*"
|
|
fi
|
|
}
|
|
|
|
# Function to output a file if DEBUG mode is enabled.
|
|
#
|
|
function DebugFile
|
|
{
|
|
if [ $DEBUGMODE -eq 1 ]; then
|
|
cat $1
|
|
fi
|
|
}
|
|
|
|
# Take an input value to be hex, validate it and format correctly.
|
|
function getHex
|
|
{
|
|
local __resultvar=$2
|
|
local inputHex=`echo $1 | tr 'a-z' 'A-Z'|sed 's/0X//g'`
|
|
TEST=$(( 16#$inputHex )) 2> /dev/null
|
|
if [ $? != 0 ]; then
|
|
FatalUsage "Value:$1 is not hexadecimal."
|
|
fi
|
|
local decimal=`echo "16 i $inputHex p" | dc`
|
|
local outputHex=`printf '0x%08X' "$((10#$decimal))"`
|
|
eval $__resultvar="'$outputHex'"
|
|
}
|
|
|
|
# Add two hexadecimal values of the form result = 0xAAAAAA + 0xBBBBBB
|
|
function addHex
|
|
{
|
|
local __resultvar=$3
|
|
local inputHex1=`echo $1 | tr 'a-z' 'A-Z'|sed 's/0X//g'`
|
|
TEST=$(( 16#$inputHex1 )) 2> /dev/null
|
|
if [ $? != 0 ]; then
|
|
FatalUsage "Param 1:$1/$inputHex1 is not hexadecimal."
|
|
fi
|
|
local inputHex2=`echo $2 | tr 'a-z' 'A-Z'|sed 's/0X//g'`
|
|
TEST=$(( 16#$inputHex2 )) 2> /dev/null
|
|
if [ $? != 0 ]; then
|
|
FatalUsage "Param 2:$2/$inputHex2 is not hexadecimal."
|
|
fi
|
|
local sumDecimal=`echo "16 i $inputHex1 $inputHex2 + p" | dc`
|
|
local outputHex=`printf '0x%08X' "$((10#$sumDecimal))"`
|
|
eval $__resultvar="'$outputHex'"
|
|
}
|
|
|
|
# Subtract two hexadecimal values of the form result = 0xAAAAAA - 0xBBBBBB
|
|
function subHex
|
|
{
|
|
local __resultvar=$3
|
|
local inputHex1=`echo $1 | tr 'a-z' 'A-Z'|sed 's/0X//g'`
|
|
TEST=$(( 16#$inputHex1 )) 2> /dev/null
|
|
if [ $? != 0 ]; then
|
|
FatalUsage "Param 1:$1/$inputHex1 is not hexadecimal."
|
|
fi
|
|
local inputHex2=`echo $2 | tr 'a-z' 'A-Z'|sed 's/0X//g'`
|
|
TEST=$(( 16#$inputHex2 )) 2> /dev/null
|
|
if [ $? != 0 ]; then
|
|
FatalUsage "Param 2:$2/$inputHex2 is not hexadecimal."
|
|
fi
|
|
local sumDecimal=`echo "16 i $inputHex1 $inputHex2 - p" | dc`
|
|
local outputHex=`printf '0x%08X' "$((10#$sumDecimal))"`
|
|
eval $__resultvar="'$outputHex'"
|
|
}
|
|
|
|
# Function to round, via masking, a hex value with another value.
|
|
# ie. 0x20028932 & 0x2002F000 = 0x20028000
|
|
function roundHex
|
|
{
|
|
local __resultvar=$3
|
|
local inputHex1=`echo $1 | tr 'a-z' 'A-Z'|sed 's/0X//g'`
|
|
TEST=$(( 16#$inputHex1 )) 2> /dev/null
|
|
if [ $? != 0 ]; then
|
|
FatalUsage "Param 1:$1/$inputHex1 is not hexadecimal."
|
|
fi
|
|
local inputHex2=`echo $2 | tr 'a-z' 'A-Z'|sed 's/0X//g'`
|
|
TEST=$(( 16#$inputHex2 )) 2> /dev/null
|
|
if [ $? != 0 ]; then
|
|
FatalUsage "Param 2:$2/$inputHex2 is not hexadecimal."
|
|
fi
|
|
local outputHex=`printf '0x%08X' "$((16#$inputHex1 & 16#$inputHex2))"`
|
|
eval $__resultvar="'$outputHex'"
|
|
}
|
|
|
|
|
|
#########################################################################################
|
|
# Check enviroment
|
|
#########################################################################################
|
|
|
|
# Correct directory to start.
|
|
cd ${BUILDPATH}
|
|
|
|
# Preload default values into parameter/control variables.
|
|
#
|
|
DEBUGMODE=0;
|
|
TRACEMODE=0;
|
|
CPU=EVO;
|
|
OS=ZPUTA;
|
|
IOCP_VERSION=3;
|
|
BRAM_SIZE=0x10000;
|
|
getHex 0x01000 OS_BASEADDR;
|
|
getHex 0x0C000 APP_BASEADDR;
|
|
APP_LEN=0x02000;
|
|
APP_BOOTLEN=0x20; # Fixed size as this is the jump table to make calls within ZPUTA.
|
|
APP_HEAP_SIZE=0x1000;
|
|
APP_STACK_SIZE=0x400;
|
|
OS_HEAP_SIZE=0x4000;
|
|
OS_STACK_SIZE=0x1000;
|
|
TRANZPUTER=0
|
|
SHARPMZ=0
|
|
OSVER=2;
|
|
|
|
# Process parameters, loading up variables as necessary.
|
|
#
|
|
if [ $# -gt 0 ]; then
|
|
while getopts ":hC:I:O:o:M:B:A:N:n:S:s:da:xTZ" opt; do
|
|
case $opt in
|
|
d) DEBUGMODE=1;;
|
|
C) CPU=`echo ${OPTARG} | tr 'a-z' 'A-Z'`;;
|
|
I) IOCP_VERSION=${OPTARG};;
|
|
O) OS=`echo ${OPTARG} | tr 'a-z' 'A-Z'`;;
|
|
o) OSVER=${OPTARG};;
|
|
M) getHex ${OPTARG} BRAM_SIZE;;
|
|
B) getHex ${OPTARG} OS_BASEADDR;;
|
|
A) getHex ${OPTARG} APP_BASEADDR;;
|
|
N) getHex ${OPTARG} OS_HEAP_SIZE;;
|
|
n) getHex ${OPTARG} APP_HEAP_SIZE;;
|
|
S) getHex ${OPTARG} OS_STACK_SIZE;;
|
|
s) getHex ${OPTARG} APP_STACK_SIZE;;
|
|
a) getHex ${OPTARG} APP_LEN;;
|
|
T) TRANZPUTER=1;;
|
|
Z) SHARPMZ=1;;
|
|
x) set -x; TRACEMODE=1;;
|
|
h) Usage;;
|
|
\?) FatalUsage "Unknown option: -${OPTARG}";;
|
|
esac
|
|
done
|
|
shift $(($OPTIND - 1 ))
|
|
fi
|
|
|
|
# Check the program to build is correct
|
|
if [ "${OS}" != "ZPUTA" -a "${OS}" != "ZOS" ]; then
|
|
FatalUsage "Given <os> is not valid, must be 'zputa' or 'zos'"
|
|
fi
|
|
if [ "${OS}" = "ZPUTA" ]; then
|
|
OSTYPE="__ZPUTA__"
|
|
else
|
|
OSTYPE="__ZOS__"
|
|
fi
|
|
OSNAME=`echo ${OS} | tr 'A-Z' 'a-z'`
|
|
|
|
# -C <CPU> = Small, Medium, Flex, Evo, K64F - defaults to Evo.
|
|
# Check the CPU is correctly defined.
|
|
if [ "${CPU}" != "SMALL" -a "${CPU}" != "MEDIUM" -a "${CPU}" != "FLEX" -a "${CPU}" != "EVO" -a "${CPU}" != "EVOMIN" -a "${CPU}" != "K64F" -a "${CPU}" != "M68K" ]; then
|
|
FatalUsage "Given <cpu> is not valid, must be one of 'Small', 'Medium', 'Flex', 'Evo', 'K64F', 'M68K'"
|
|
fi
|
|
if [ ${CPU} = "K64F" ]; then
|
|
CPUTYPE="__K64F__"
|
|
elif [ ${CPU} = "M68K" ]; then
|
|
CPUTYPE="__M68K__"
|
|
else
|
|
CPUTYPE="__ZPU__"
|
|
fi
|
|
|
|
# Check the addresses for K64F, cannot use the default ZPU values.
|
|
if [ "${CPU}" = "K64F" -a "${OS_BASEADDR}" = "0x00001000" -a "${APP_BASEADDR}" = "0x0000C000" ]; then
|
|
getHex 0x00000000 OS_BASEADDR;
|
|
getHex 0x1fff0000 APP_BASEADDR;
|
|
fi
|
|
|
|
# Check IOCP_VERSION which has no meaning for the K64F/M68K processors.
|
|
if [ "${CPU}" = "K64F" -a "${IOCP_VERSION}" != "3" ]; then
|
|
Fatal "-I < iocp ver> has no meaning for the K64F, there is no version or indeed no need for IOCP on this processor."
|
|
elif [ "${CPU}" = "M68K" -a "${IOCP_VERSION}" != "3" ]; then
|
|
Fatal "-I < iocp ver> has no meaning for the M68K, there is no version or indeed no need for IOCP on this processor."
|
|
fi
|
|
|
|
# Check OSVER which has no meaning for the K64F/M68K processors.
|
|
if [ "${CPU}" = "K64F" -a "${OSVER}" != "2" ]; then
|
|
Fatal "-o <os ver> has no meaning for the K64F, base is in Flash RAM and applications, if SD card enabled, are in RAM."
|
|
elif [ "${CPU}" = "M68K" -a "${OSVER}" != "2" ]; then
|
|
Fatal "-o <os ver> has no meaning for the M68K, base is in Flash RAM and applications, if SD card enabled, are in RAM."
|
|
fi
|
|
|
|
# Setup any specific build options.
|
|
if [ ${TRANZPUTER} -eq 1 ]; then
|
|
if [ "${CPU}" = "K64F" -a "${OS}" = "ZOS" ]; then
|
|
BUILDFLAGS="__TRANZPUTER__=1"
|
|
fi
|
|
fi
|
|
|
|
# Setup any specific build options.
|
|
if [ ${SHARPMZ} -eq 1 ]; then
|
|
if [[ "${CPU}" != "EVO" && "${CPU}" != "M68K" ]] || [[ "${OS}" != "ZOS" ]]; then
|
|
Fatal "-Z only valid for zOS build on ZPU hardware."
|
|
fi
|
|
if [[ "${CPU}" = "EVO" || "${CPU}" = "M68K" ]] && [[ "${OS}" = "ZOS" ]]; then
|
|
BUILDFLAGS="__SHARPMZ__=1"
|
|
fi
|
|
fi
|
|
|
|
# Clear out the build target directory.
|
|
rm -fr ${BUILDPATH}/build
|
|
mkdir -p ${BUILDPATH}/build
|
|
mkdir -p ${BUILDPATH}/build/SD
|
|
|
|
# Build message according to CPU Type
|
|
if [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
Log "Building: ${OS}, OS_BASEADDR=${OS_BASEADDR}, APP_BASEADDR=${APP_BASEADDR} ..."
|
|
elif [ "${CPUTYPE}" = "__K64F__" ]; then
|
|
Log "Building: ${OS} ..."
|
|
elif [ "${CPUTYPE}" = "__M68K__" ]; then
|
|
Log "Building: ${OS} ..."
|
|
else
|
|
Fatal "Internal error, unrecognised CPUTYPE at Build Info"
|
|
fi
|
|
|
|
# Stack start address (at the moment) is top of BRAM less 8 bytes (2 words), standard for the ZPU. There is
|
|
# no reason though why this cant be a fixed address determined by the developer in any memory location.
|
|
subHex ${BRAM_SIZE} 8 STACK_STARTADDR
|
|
|
|
# Build the libraries for this platform.
|
|
cd ${BUILDPATH}/libraries
|
|
make ${CPUTYPE}=1 CPU=${CPU} all
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to build the libraries for the ${CPUTYPE} processor."
|
|
fi
|
|
|
|
# Setup the bootloader if the OS is not standalone.
|
|
#
|
|
#if [ "${OSVER}" -ne 0 ]; then
|
|
|
|
# IOCP is only needed by the ZPU family.
|
|
if [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
|
|
# Setup variables to meet the required IOCP configuration.
|
|
#
|
|
FUNCTIONALITY=${IOCP_VERSION}
|
|
if [ ${IOCP_VERSION} = 0 ]; then
|
|
IOCP_BASEADDR=0x000000;
|
|
IOCP_BOOTLEN=0x000400;
|
|
IOCP_STARTADDR=0x000400;
|
|
IOCP_LEN=0x003700;
|
|
OS_SD_TARGET="BOOT.ROM"
|
|
elif [ ${IOCP_VERSION} = 1 ]; then
|
|
IOCP_BASEADDR=0x000000;
|
|
IOCP_BOOTLEN=0x000400;
|
|
IOCP_STARTADDR=0x000400;
|
|
IOCP_LEN=0x002000;
|
|
OS_SD_TARGET="BOOT.ROM"
|
|
elif [ ${IOCP_VERSION} = 2 ]; then
|
|
IOCP_BASEADDR=0x000000;
|
|
IOCP_BOOTLEN=0x000400;
|
|
IOCP_STARTADDR=0x000400;
|
|
IOCP_LEN=0x002000;
|
|
OS_SD_TARGET="BOOT.ROM"
|
|
elif [ ${IOCP_VERSION} = 3 ]; then
|
|
IOCP_BASEADDR=0x000000;
|
|
IOCP_BOOTLEN=0x000400;
|
|
IOCP_STARTADDR=0x000400;
|
|
IOCP_LEN=0x001000;
|
|
OS_SD_TARGET="BOOTTINY.ROM"
|
|
else
|
|
FatalUsage "Illegal IOCP Version."
|
|
fi
|
|
IOCP_SD_TARGET="IOCP_${FUNCTIONALITY}_${IOCP_BASEADDR}.bin"
|
|
addHex ${IOCP_BASEADDR} ${IOCP_LEN} IOCP_APPADDR
|
|
|
|
if [ $DEBUGMODE -eq 1 ]; then
|
|
Log "IOCP_BASEADDR=${IOCP_BASEADDR}, IOCP_BOOTLEN=${IOCP_BOOTLEN}, IOCP_STARTADDR=${IOCP_STARTADDR}, IOCP_LEN=${IOCP_LEN}, OS_SD_TARGET=${OS_SD_TARGET}"
|
|
fi
|
|
|
|
Log "Building IOCP version - ${IOCP_VERSION}"
|
|
cat ${BUILDPATH}/startup/iocp_bram.tmpl | sed -e "s/BOOTADDR/${IOCP_BASEADDR}/g" \
|
|
-e "s/BOOTLEN/${IOCP_BOOTLEN}/g" \
|
|
-e "s/IOCPSTART/${IOCP_STARTADDR}/g" \
|
|
-e "s/IOCPLEN/${IOCP_LEN}/g" \
|
|
-e "s/STACK_SIZE/${STACK_SIZE}/g" \
|
|
-e "s/STACK_ADDR/${STACK_STARTADDR}/g" > ${BUILDPATH}/startup/iocp_bram_${IOCP_BASEADDR}.ld
|
|
cd ${BUILDPATH}/iocp
|
|
make ${CPUTYPE}=1 clean
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to clean IOCP build environment!"
|
|
fi
|
|
|
|
Log "make ${CPUTYPE}=1 IOCP_BASEADDR=${IOCP_BASEADDR} IOCP_APPADDR=${IOCP_APPADDR} FUNCTIONALITY=${FUNCTIONALITY} CPU=${CPU}"
|
|
make ${CPUTYPE}=1 IOCP_BASEADDR=${IOCP_BASEADDR} IOCP_APPADDR=${IOCP_APPADDR} FUNCTIONALITY=${FUNCTIONALITY} CPU=${CPU}
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to build IOCP!"
|
|
fi
|
|
cp ${BUILDPATH}/iocp/iocp.bin ${BUILDPATH}/build/${IOCP_SD_TARGET}
|
|
fi
|
|
#fi
|
|
|
|
# Setup variables to meet the required zOS/ZPUTA configuration.
|
|
# 0 - Standalone, 1 - As app with IOCP Bootloader, 2 - As app with tiny IOCP Bootloader, 3 - As app in RAM
|
|
# For CPU Type K64F all parameters are static.
|
|
if [ "${CPUTYPE}" = "__K64F__" ]; then
|
|
OSBUILDSTR="${OSNAME}_k64f"
|
|
OS_BOOTADDR=0x000000;
|
|
OS_BASEADDR=0x000000;
|
|
OS_BOOTLEN=0x000000;
|
|
|
|
elif [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
if [ ${OSVER} = 0 ]; then
|
|
OSBUILDSTR="${OSNAME}_standalone_boot_in_bram"
|
|
OS_BOOTADDR=0x000000;
|
|
OS_BASEADDR=0x000000;
|
|
OS_BOOTLEN=0x000600;
|
|
elif [ ${OSVER} = 1 ]; then
|
|
OSBUILDSTR="${OSNAME}_with_iocp_in_bram"
|
|
OS_BOOTADDR=${OS_BASEADDR};
|
|
OS_BOOTLEN=0x000200;
|
|
elif [ ${OSVER} = 2 ]; then
|
|
OSBUILDSTR="${OSNAME}_with_tiny_iocp_in_bram"
|
|
OS_BOOTADDR=${OS_BASEADDR};
|
|
OS_BOOTLEN=0x000200;
|
|
elif [ ${OSVER} = 3 ]; then
|
|
OSBUILDSTR="${OSNAME}_as_app_in_ram"
|
|
OS_BOOTADDR=${OS_BASEADDR};
|
|
OS_BOOTLEN=0x000200;
|
|
else
|
|
FatalUsage "Illegal OS Version."
|
|
fi
|
|
elif [ "${CPUTYPE}" = "__M68K__" ]; then
|
|
#OSBUILDSTR="${OSNAME}_m68k"
|
|
OSBUILDSTR="${OSNAME}_standalone_boot_in_bram"
|
|
OS_BOOTADDR=0x000000;
|
|
OS_BASEADDR=0x000000;
|
|
OS_BOOTLEN=0x000000;
|
|
fi
|
|
|
|
# For the ZPU, the start of the Boot loader, OS and application can change so need to calculate the Boot start and len, OS start and len, application Start and len.
|
|
if [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
# Calculate the Start address of the OS. The OS has a Boot Address followed by a reserved space for microcode and hooks before the main OS code.
|
|
addHex ${OS_BOOTLEN} ${OS_BASEADDR} OS_STARTADDR
|
|
|
|
# Calculate the Start address of the Application. An Application has a Boot Address, a reserved space for OS Hooks and then the application start.
|
|
addHex ${APP_BOOTLEN} ${APP_BASEADDR} APP_STARTADDR
|
|
|
|
# Calculate the maximum Application length by subtracting the size of the BRAM - Application Start - Stack Space
|
|
if [ "${APP_LEN}" = "" -a $(( 16#`echo ${APP_STARTADDR} | tr 'a-z' 'A-Z'|sed 's/0X//g'` )) -lt $(( 16#`echo ${BRAM_SIZE} | tr 'a-z' 'A-Z'|sed 's/0X//g'` )) ]; then
|
|
subHex ${BRAM_SIZE} ${APP_STARTADDR} APP_LEN
|
|
subHex ${APP_LEN} 0x20 APP_LEN
|
|
|
|
# If the APPLEN isnt set, give it a meaningful default.
|
|
elif [ $(( 16#`echo ${APP_LEN} | tr 'a-z' 'A-Z'|sed 's/0X//g'` )) -eq 0 ]; then
|
|
APP_LEN=0x10000;
|
|
fi
|
|
|
|
# Calculate the start of the Operating system code as the first section from the boot address is reserved.
|
|
addHex ${OS_BOOTADDR} ${OS_BOOTLEN} OS_STARTADDR
|
|
|
|
# Calculate the length of the OS which is the start address of the App less the Boot address of the OS.
|
|
subHex ${APP_BASEADDR} ${OS_BOOTADDR} OS_LEN
|
|
subHex ${OS_LEN} ${OS_BOOTLEN} OS_LEN
|
|
|
|
# Calculate the heap and stack vars.
|
|
subHex ${BRAM_SIZE} 8 OS_STACK_ENDADDR
|
|
subHex ${OS_STACK_ENDADDR} ${OS_STACK_SIZE} OS_STACK_STARTADDR
|
|
subHex ${OS_STACK_STARTADDR} 4 OS_HEAP_ENDADDR
|
|
subHex ${OS_HEAP_ENDADDR} ${OS_HEAP_SIZE} OS_HEAP_STARTADDR
|
|
|
|
# Stack start address for the APP. Normally this isnt used as the stack from zOS/ZPUTA is maintained, but available incase of
|
|
# need for a local stack.
|
|
addHex ${APP_STARTADDR} ${APP_LEN} APP_ENDADDR
|
|
#subHex ${APP_ENDADDR} ${OS_STACK_SIZE} APP_ENDADDR
|
|
subHex ${APP_ENDADDR} 8 APP_STACK_ENDADDR
|
|
subHex ${APP_STACK_ENDADDR} ${APP_STACK_SIZE} APP_STACK_STARTADDR
|
|
|
|
# Calculate the heap start and end.
|
|
subHex ${APP_STACK_STARTADDR} 4 APP_HEAP_ENDADDR
|
|
subHex ${APP_HEAP_ENDADDR} ${APP_HEAP_SIZE} APP_HEAP_STARTADDR
|
|
|
|
elif [ "${CPUTYPE}" = "__K64F__" ]; then
|
|
|
|
# For the K64F the OS location and size is the 512K Flash RAM, this can be changed if a bootloader is installed before zOS.
|
|
OS_STARTADDR=0x00000000
|
|
addHex ${OS_STARTADDR} 0x00080000 OS_LEN
|
|
|
|
# Calculate the heap, stack and RAM start address vars.
|
|
OS_RAM_ENDADDR=0x20030000
|
|
OS_RAM_MASK=0x3FFFF000
|
|
OS_RAM_OSMEM=0x010000
|
|
subHex ${OS_RAM_ENDADDR} 8 OS_STACK_ENDADDR
|
|
subHex ${OS_RAM_ENDADDR} ${OS_STACK_SIZE} OS_STACK_STARTADDR
|
|
roundHex ${OS_STACK_STARTADDR} ${OS_RAM_MASK} OS_STACK_STARTADDR
|
|
subHex ${OS_STACK_STARTADDR} 4 OS_HEAP_ENDADDR
|
|
subHex ${OS_HEAP_ENDADDR} ${OS_HEAP_SIZE} OS_HEAP_STARTADDR
|
|
roundHex ${OS_HEAP_STARTADDR} ${OS_RAM_MASK} OS_HEAP_STARTADDR
|
|
subHex ${OS_HEAP_STARTADDR} ${OS_RAM_OSMEM} OS_RAM_STARTADDR
|
|
roundHex ${OS_RAM_STARTADDR} ${OS_RAM_MASK} OS_RAM_STARTADDR
|
|
subHex ${OS_RAM_ENDADDR} ${OS_RAM_STARTADDR} OS_RAM_LEN
|
|
|
|
# For the K64F, the APP address start is as given on the command line or inbuilt default. The APPLEN is MAX RAM - APP Start Address.
|
|
APP_STARTADDR=${APP_BASEADDR}
|
|
APP_ENDADDR=${OS_RAM_STARTADDR}
|
|
APP_RAM_MASK=0xFFFFF000
|
|
subHex ${APP_ENDADDR} ${APP_BASEADDR} APP_LEN
|
|
|
|
# Stack start address for the APP. Normally this isnt used as the stack from zOS/ZPUTA is maintained, but available incase of
|
|
# need for a local stack.
|
|
subHex ${APP_ENDADDR} 8 APP_STACK_ENDADDR
|
|
subHex ${APP_STACK_ENDADDR} ${APP_STACK_SIZE} APP_STACK_STARTADDR
|
|
roundHex ${APP_STACK_STARTADDR} ${APP_RAM_MASK} APP_STACK_STARTADDR
|
|
|
|
# Calculate the heap start and end.
|
|
subHex ${APP_STACK_STARTADDR} 0 APP_HEAP_ENDADDR
|
|
subHex ${APP_HEAP_ENDADDR} ${APP_HEAP_SIZE} APP_HEAP_STARTADDR
|
|
roundHex ${APP_HEAP_STARTADDR} ${APP_RAM_MASK} APP_HEAP_STARTADDR
|
|
|
|
#subHex ${APP_STACK_STARTADDR} ${APP_STARTADDR} APP_STACK_STARTADDR
|
|
# subHex ${APP_HEAP_STARTADDR} ${APP_STARTADDR} APP_HEAP_STARTADDR
|
|
|
|
elif [ "${CPUTYPE}" = "__M68K__" ]; then
|
|
|
|
# Calculate the Start address of the OS. The OS has a Boot Address followed by a reserved space for microcode and hooks before the main OS code.
|
|
addHex ${OS_BOOTLEN} ${OS_BASEADDR} OS_STARTADDR
|
|
|
|
# Calculate the Start address of the Application. An Application has a Boot Address, a reserved space for OS Hooks and then the application start.
|
|
addHex ${APP_BOOTLEN} ${APP_BASEADDR} APP_STARTADDR
|
|
|
|
# Calculate the maximum Application length by subtracting the size of the BRAM - Application Start - Stack Space
|
|
if [ "${APP_LEN}" = "" -a $(( 16#`echo ${APP_STARTADDR} | tr 'a-z' 'A-Z'|sed 's/0X//g'` )) -lt $(( 16#`echo ${BRAM_SIZE} | tr 'a-z' 'A-Z'|sed 's/0X//g'` )) ]; then
|
|
subHex ${BRAM_SIZE} ${APP_STARTADDR} APP_LEN
|
|
subHex ${APP_LEN} 0x20 APP_LEN
|
|
|
|
# If the APPLEN isnt set, give it a meaningful default.
|
|
elif [ $(( 16#`echo ${APP_LEN} | tr 'a-z' 'A-Z'|sed 's/0X//g'` )) -eq 0 ]; then
|
|
APP_LEN=0x10000;
|
|
fi
|
|
|
|
# Calculate the start of the Operating system code as the first section from the boot address is reserved.
|
|
addHex ${OS_BOOTADDR} ${OS_BOOTLEN} OS_STARTADDR
|
|
|
|
# Calculate the length of the OS which is the start address of the App less the Boot address of the OS.
|
|
subHex ${APP_BASEADDR} ${OS_BOOTADDR} OS_LEN
|
|
subHex ${OS_LEN} ${OS_BOOTLEN} OS_LEN
|
|
|
|
# Calculate the heap and stack vars.
|
|
subHex ${BRAM_SIZE} 8 OS_STACK_ENDADDR
|
|
subHex ${OS_STACK_ENDADDR} ${OS_STACK_SIZE} OS_STACK_STARTADDR
|
|
subHex ${OS_STACK_STARTADDR} 4 OS_HEAP_ENDADDR
|
|
subHex ${OS_HEAP_ENDADDR} ${OS_HEAP_SIZE} OS_HEAP_STARTADDR
|
|
|
|
# Stack start address for the APP. Normally this isnt used as the stack from zOS/ZPUTA is maintained, but available incase of
|
|
# need for a local stack.
|
|
addHex ${APP_STARTADDR} ${APP_LEN} APP_ENDADDR
|
|
#subHex ${APP_ENDADDR} ${OS_STACK_SIZE} APP_ENDADDR
|
|
subHex ${APP_ENDADDR} 8 APP_STACK_ENDADDR
|
|
subHex ${APP_STACK_ENDADDR} ${APP_STACK_SIZE} APP_STACK_STARTADDR
|
|
|
|
# Calculate the heap start and end.
|
|
subHex ${APP_STACK_STARTADDR} 4 APP_HEAP_ENDADDR
|
|
subHex ${APP_HEAP_ENDADDR} ${APP_HEAP_SIZE} APP_HEAP_STARTADDR
|
|
|
|
else
|
|
Fatal "Internal error, unrecognised CPUTYPE at calcblock"
|
|
fi
|
|
|
|
Debug "OS_BASEADDR=${OS_BASEADDR}, OS_BOOTLEN=${OS_BOOTLEN}, OS_STARTADDR=${OS_STARTADDR}, OS_LEN=${OS_LEN}"
|
|
Debug "OS_RAM_STARTADDR=${OS_RAM_STARTADDR}, OS_RAM_ENDADDR=${OS_RAM_ENDADDR}, OS_RAM_LEN=${OS_RAM_LEN}, OS_RAM_MASK=${OS_RAM_MASK}, OS_RAM_OSMEM=${OS_RAM_OSMEM}"
|
|
Debug "OS_STACK_STARTADDR=${OS_STACK_STARTADDR}, OS_STACK_ENDADDR=${OS_STACK_ENDADDR}, OS_STACK_SIZE=${OS_STACK_SIZE}, OS_HEAP_STARTADDR=${OS_HEAP_STARTADDR}, OS_HEAP_ENDADDR=${OS_HEAP_ENDADDR} OS_HEAP_SIZE=${OS_HEAP_SIZE}"
|
|
Debug "APP_BASEADDR=${APP_BASEADDR}, APP_BOOTLEN=${APP_BOOTLEN}, APP_STARTADDR=${APP_STARTADDR}, APP_ENDADDR=${APP_ENDADDR}, APP_RAM_MASK=${APP_RAM_MASK}, APP_LEN=${APP_LEN}"
|
|
Debug "APP_STACK_STARTADDR=${APP_STACK_STARTADDR}, APP_STACK_ENDADDR=${APP_STACK_ENDADDR}, APP_STACK_SIZE=${APP_STACK_SIZE}, APP_HEAP_STARTADDR=${APP_HEAP_STARTADDR}, APP_HEAP_ENDADDR=${APP_HEAP_ENDADDR}, APP_HEAP_SIZE=${APP_HEAP_SIZE}"
|
|
|
|
# Build according to desired OS and target processor.
|
|
if [ "${OS}" = "ZPUTA" ]; then
|
|
|
|
# Build the ZPUTA link script based on given and calculated values.
|
|
Log "ZPUTA - ${OSBUILDSTR}"
|
|
if [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
TMPLFILE=${BUILDPATH}/startup/zputa_zpu.tmpl
|
|
elif [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
TMPLFILE=${BUILDPATH}/startup/zputa_k64f.tmpl
|
|
elif [ "${CPUTYPE}" = "__M68K__" ]; then
|
|
TMPLFILE=${BUILDPATH}/startup/zputa_m68k.tmpl
|
|
else
|
|
Fatal "Internal error, unrecognised CPUTYPE at zputa cfg"
|
|
fi
|
|
cat ${TMPLFILE} | sed -e "s/BOOTADDR/${OS_BOOTADDR}/g" \
|
|
-e "s/BOOTLEN/${OS_BOOTLEN}/g" \
|
|
-e "s/OS_START/${OS_STARTADDR}/g" \
|
|
-e "s/OS_LEN/${OS_LEN}/g" \
|
|
-e "s/OS_RAM_STARTADDR/${OS_RAM_STARTADDR}/g" \
|
|
-e "s/OS_RAM_LEN/${OS_RAM_LEN}/g" \
|
|
-e "s/HEAP_SIZE/${OS_HEAP_SIZE}/g" \
|
|
-e "s/HEAP_STARTADDR/${OS_HEAP_STARTADDR}/g" \
|
|
-e "s/HEAP_ENDADDR/${OS_HEAP_ENDADDR}/g" \
|
|
-e "s/STACK_SIZE/${OS_STACK_SIZE}/g" \
|
|
-e "s/STACK_STARTADDR/${OS_STACK_STARTADDR}/g" \
|
|
-e "s/STACK_ENDADDR/${OS_STACK_ENDADDR}/g" \
|
|
-e "s/STACK_ADDR/${OS_STACK_STARTADDR}/g" > ${BUILDPATH}/startup/${OSBUILDSTR}.ld
|
|
|
|
cd ${BUILDPATH}/zputa
|
|
make ${CPUTYPE}=1 ${OSTYPE}=1 ${BUILDFLAGS} clean
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to clean ZPUTA build environment!"
|
|
fi
|
|
|
|
if [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
Log "make ${OSBUILDSTR} ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} ${BUILDFLAGS}"
|
|
make ${OSBUILDSTR} ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} ${BUILDFLAGS}
|
|
elif [ "${CPUTYPE}" = "__K64F__" ]; then
|
|
Log "make ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} ${BUILDFLAGS}"
|
|
make ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} ${BUILDFLAGS}
|
|
elif [ "${CPUTYPE}" = "__M68K__" ]; then
|
|
Log "make ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} ${BUILDFLAGS}"
|
|
make ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} ${BUILDFLAGS}
|
|
else
|
|
Fatal "Internal error, unrecognised CPUTYPE at ZPUTA Make"
|
|
fi
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to build ZPUTA!"
|
|
fi
|
|
cp ${BUILDPATH}/zputa/${OSBUILDSTR}.bin ${BUILDPATH}/build/SD/${OS_SD_TARGET}
|
|
|
|
elif [ "${OS}" = "ZOS" ]; then
|
|
|
|
# Build the zOS link script based on given and calculated values.
|
|
Log "zOS - ${OSBUILDSTR}"
|
|
if [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
TMPLFILE=${BUILDPATH}/startup/zos_zpu.tmpl
|
|
elif [ "${CPUTYPE}" = "__K64F__" ]; then
|
|
TMPLFILE=${BUILDPATH}/startup/zos_k64f.tmpl
|
|
elif [ "${CPUTYPE}" = "__M68K__" ]; then
|
|
TMPLFILE=${BUILDPATH}/startup/zos_m68k.tmpl
|
|
else
|
|
Fatal "Internal error, unrecognised CPUTYPE at zos cfg"
|
|
fi
|
|
cat ${TMPLFILE} | sed -e "s/BOOTADDR/${OS_BOOTADDR}/g" \
|
|
-e "s/BOOTLEN/${OS_BOOTLEN}/g" \
|
|
-e "s/OS_START/${OS_STARTADDR}/g" \
|
|
-e "s/OS_LEN/${OS_LEN}/g" \
|
|
-e "s/OS_RAM_STARTADDR/${OS_RAM_STARTADDR}/g" \
|
|
-e "s/OS_RAM_LEN/${OS_RAM_LEN}/g" \
|
|
-e "s/HEAP_SIZE/${OS_HEAP_SIZE}/g" \
|
|
-e "s/HEAP_STARTADDR/${OS_HEAP_STARTADDR}/g" \
|
|
-e "s/HEAP_ENDADDR/${OS_HEAP_ENDADDR}/g" \
|
|
-e "s/STACK_SIZE/${OS_STACK_SIZE}/g" \
|
|
-e "s/STACK_STARTADDR/${OS_STACK_STARTADDR}/g" \
|
|
-e "s/STACK_ENDADDR/${OS_STACK_ENDADDR}/g" \
|
|
-e "s/STACK_ADDR/${OS_STACK_STARTADDR}/g" > ${BUILDPATH}/startup/${OSBUILDSTR}.ld
|
|
|
|
cd ${BUILDPATH}/zOS
|
|
make ${CPUTYPE}=1 ${OSTYPE}=1 clean
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to clean zOS build environment!"
|
|
fi
|
|
if [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
Log "make ${OSBUILDSTR} ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} HEAPADDR=${OS_HEAP_STARTADDR} HEAPSIZE=${OS_HEAP_SIZE} STACKADDR=${OS_STACK_STARTADDR} STACKENDADDR=${OS_STACK_ENDADDR} STACKSIZE=${OS_STACK_SIZE} ${BUILDFLAGS}"
|
|
make ${OSBUILDSTR} ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} HEAPADDR=${OS_HEAP_STARTADDR} HEAPSIZE=${OS_HEAP_SIZE} STACKADDR=${OS_STACK_STARTADDR} STACKENDADDR=${OS_STACK_ENDADDR} STACKSIZE=${OS_STACK_SIZE} ${BUILDFLAGS}
|
|
elif [ "${CPUTYPE}" = "__K64F__" ]; then
|
|
Log "make ${OSBUILDSTR} ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} HEAPADDR=${OS_HEAP_STARTADDR} HEAPSIZE=${OS_HEAP_SIZE} STACKADDR=${OS_STACK_STARTADDR} STACKENDADDR=${OS_STACK_ENDADDR} STACKSIZE=${OS_STACK_SIZE} ${BUILDFLAGS}"
|
|
Log "make ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} HEAPADDR=${OS_HEAP_STARTADDR} HEAPSIZE=${OS_HEAP_SIZE} STACKADDR=${OS_STACK_STARTADDR} STACKENDADDR=${OS_STACK_ENDADDR} STACKSIZE=${OS_STACK_SIZE} ${BUILDFLAGS}"
|
|
make ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} HEAPADDR=${OS_HEAP_STARTADDR} HEAPSIZE=${OS_HEAP_SIZE} STACKADDR=${OS_STACK_STARTADDR} STACKENDADDR=${OS_STACK_ENDADDR} STACKSIZE=${OS_STACK_SIZE} ${BUILDFLAGS}
|
|
elif [ "${CPUTYPE}" = "__M68K__" ]; then
|
|
Log "make ${OSBUILDSTR} ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} HEAPADDR=${OS_HEAP_STARTADDR} HEAPSIZE=${OS_HEAP_SIZE} STACKADDR=${OS_STACK_STARTADDR} STACKENDADDR=${OS_STACK_ENDADDR} STACKSIZE=${OS_STACK_SIZE} ${BUILDFLAGS}"
|
|
make ${OSBUILDSTR} ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} HEAPADDR=${OS_HEAP_STARTADDR} HEAPSIZE=${OS_HEAP_SIZE} STACKADDR=${OS_STACK_STARTADDR} STACKENDADDR=${OS_STACK_ENDADDR} STACKSIZE=${OS_STACK_SIZE} ${BUILDFLAGS}
|
|
else
|
|
Fatal "Internal error, unrecognised CPUTYPE at ZOS Make"
|
|
fi
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to build zOS!"
|
|
fi
|
|
|
|
# Also create a copy of the OS for use by the tranZPUter SW-700 project.
|
|
mkdir -p ${BUILDPATH}/build/SD/ZOS
|
|
if [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
cp ${BUILDPATH}/zOS/${OSBUILDSTR}.bin ${BUILDPATH}/build/SD/${OS_SD_TARGET}
|
|
cp ${BUILDPATH}/zOS/${OSBUILDSTR}.bin ${BUILDPATH}/build/SD/ZOS/ZOS.ROM
|
|
elif [ "${CPUTYPE}" = "__K64F__" ]; then
|
|
cp ${BUILDPATH}/zOS/main.bin ${BUILDPATH}/build/SD/${OS_SD_TARGET}
|
|
cp ${BUILDPATH}/zOS/main.bin ${BUILDPATH}/build/SD/ZOS/ZOS.K64F.ROM
|
|
elif [ "${CPUTYPE}" = "__M68K__" ]; then
|
|
cp ${BUILDPATH}/zOS/main.bin ${BUILDPATH}/build/SD/${OS_SD_TARGET}
|
|
cp ${BUILDPATH}/zOS/main.bin ${BUILDPATH}/build/SD/ZOS/ZOS.M68K.ROM
|
|
else
|
|
Fatal "Internal error, unrecognised CPUTYPE at ZOS Copy"
|
|
fi
|
|
fi
|
|
|
|
# Build the apps and install into the build tree.
|
|
# For ZPU the location and size depends on FPGA resources so create a dynamic linker template. For K64F it is a static design but the heap size is variable so we also
|
|
# need to generate a dynamic linker template. This is now performed within the Makefile passing necessary variables to Make.
|
|
#
|
|
if [ "${CPUTYPE}" = "__ZPU__" ]; then
|
|
TMPLFILE=${BUILDPATH}/startup/app_${OSNAME}_zpu.tmpl
|
|
LDFILE=${BUILDPATH}/startup/app_zpu_${OS_BOOTADDR}_${APP_BASEADDR}.ld
|
|
elif [ "${CPUTYPE}" = "__K64F__" ]; then
|
|
TMPLFILE=${BUILDPATH}/startup/app_${OSNAME}_k64f.tmpl
|
|
LDFILE=${BUILDPATH}/startup/app_k64f_${OS_BOOTADDR}_${APP_BASEADDR}.ld
|
|
elif [ "${CPUTYPE}" = "__M68K__" ]; then
|
|
TMPLFILE=${BUILDPATH}/startup/app_${OSNAME}_m68k.tmpl
|
|
LDFILE=${BUILDPATH}/startup/app_m68k_${OS_BOOTADDR}_${APP_BASEADDR}.ld
|
|
else
|
|
Fatal "Internal error, unrecognised CPUTYPE at LD tmpl setup"
|
|
fi
|
|
|
|
cd ${BUILDPATH}/apps
|
|
Log "make ${CPUTYPE}=1 ${OSTYPE}=1 ${BUILDFLAGS} clean"
|
|
make ${CPUTYPE}=1 ${OSTYPE}=1 ${BUILDFLAGS} clean
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to clean Apps build environment!"
|
|
fi
|
|
Log "make ${CPUTYPE} ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} TMPLFILE=${TMPLFILE} BASEADDR=${APP_BASEADDR} BASELEN=${APP_BOOTLEN} HEAPADDR=${APP_HEAP_STARTADDR} HEAPSIZE=${APP_HEAP_SIZE} STACKADDR=${APP_STACK_STARTADDR} STACKENDADDR=${APP_STACK_ENDADDR} STACKSIZE=${APP_STACK_SIZE} APPSTART=${APP_STARTADDR} APPSIZE=${APP_LEN} ${BUILDFLAGS}"
|
|
make ${CPUTYPE}=1 ${OSTYPE}=1 OS_BASEADDR=${OS_BOOTADDR} OS_APPADDR=${APP_BASEADDR} CPU=${CPU} TMPLFILE=${TMPLFILE} BASEADDR=${APP_BASEADDR} BASELEN=${APP_BOOTLEN} HEAPADDR=${APP_HEAP_STARTADDR} HEAPSIZE=${APP_HEAP_SIZE} STACKADDR=${APP_STACK_STARTADDR} STACKENDADDR=${APP_STACK_ENDADDR} STACKSIZE=${APP_STACK_SIZE} APPSTART=${APP_STARTADDR} APPSIZE=${APP_LEN} ${BUILDFLAGS}
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to build Apps!"
|
|
fi
|
|
mkdir -p bin
|
|
rm -f bin/*
|
|
Log "make ${CPUTYPE}=1 ${OSTYPE}=1 ${BUILDFLAGS} install"
|
|
make ${CPUTYPE}=1 ${OSTYPE}=1 ${BUILDFLAGS} install
|
|
if [ $? != 0 ]; then
|
|
Fatal "Aborting, failed to install generated binaries!"
|
|
fi
|
|
cp -r ${BUILDPATH}/apps/bin ${BUILDPATH}/build/SD/bin
|