diff --git a/build-jenkins.sh b/build-jenkins.sh
deleted file mode 100755
index bba849a..0000000
--- a/build-jenkins.sh
+++ /dev/null
@@ -1,267 +0,0 @@
-#!/bin/bash
-################################################################################
-#
-# Script used to create a Jenkins master that can run amd64 or ppc64le. It can
-# be used to launch the Jenkins master as a Docker container locally or as a
-# Kubernetes Deployment in a Kubernetes cluster.
-#
-################################################################################
-#
-# Script Variables:
-#  build_scripts_dir  The path of the openbmc-build-scripts directory.
-#                     Default: The directory containing this script
-#  workspace          The directory that holds files used to build the Jenkins
-#                     master master image and volumes used to deploy it.
-#                     Default: "~/jenkins-build-${RANDOM}"
-#
-# Jenkins Dockerfile Variables:
-#  agent_port         The port used as the Jenkins slave agent port.
-#                     Default: "50000"
-#  http_port          The port used as Jenkins UI port.
-#                     Default: "8080"
-#  img_name           The name given to the Docker image when it is built.
-#                     Default: "openbmc/jenkins-master-${ARCH}:${JENKINS_VRSN}"
-#  img_tag            The tag of the OpenJDK image used as the base image.
-#                     Default: "/8-jdk"
-#  j_gid              Jenkins group ID the container will use to run Jenkins.
-#                     Default: "1000"
-#  j_group            Group name tag the container will use to run Jenkins.
-#                     Default: "jenkins"
-#  j_home             Directory used as the Jenkins Home in the container.
-#                     Default: "/var/jenkins_home"
-#  j_uid              Jenkins user ID the container will use to run Jenkins.
-#                     Default: "1000"
-#  j_user             Username tag the container will use to run Jenkins.
-#                     Default: "jenkins"
-#  j_vrsn             The version of the Jenkins war file you wish to use.
-#                     Default: "2.60.3"
-#  tini_vrsn          The version of Tini to use in the Dockerfile, 0.16.1 is
-#                     the first release with ppc64le release support.
-#                     Default: "0.16.1"
-#
-# Deployment Variables:
-#  cont_import_mnt    The directory on the container used to import extra files.
-#                     Default: "/mnt/jenkins_import", ignored if above not set
-#  home_mnt           The directory on the host used as the Jenkins home.
-#                     Default: "${WORKSPACE}/jenkins_home"
-#  host_import_mnt    The directory on the host used to import extra files.
-#                     Default: "", import mount is ignored if not set
-#  java_options       What will be passed as the environment variable for the
-#                     JAVA_OPTS environment variable.
-#                     Default: "-Xmx4096m"
-#  jenkins_options    What will be passed as the environment variable for the
-#                     JENKINS_OPTS environment variable.
-#                     Default: "--prefix=/jenkins"
-#  launch             docker|k8s
-#                     Method in which the container will be launched. Either as
-#                     a Docker container launched via Docker, or by using a
-#                     helper script to launch into a Kubernetes cluster.
-#                     Default: "docker"
-#
-################################################################################
-set -xeo pipefail
-ARCH=$(uname -m)
-
-# Script Variables
-build_scripts_dir=${build_scripts_dir:-"$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"}
-workspace=${workspace:-${HOME}/jenkins-build-${RANDOM}}
-
-# Jenkins Dockerfile Variables
-agent_port=${agent_port:-50000}
-http_port=${http_port:-8080}
-img_name=${img_name:-openbmc/jenkins-master-${ARCH}:${j_vrsn}}
-j_gid=${j_gid:-1000}
-j_group=${j_group:-jenkins}
-j_home=${j_home:-/var/jenkins_home}
-j_uid=${j_uid:-1000}
-j_user=${j_user:-jenkins}
-j_vrsn=${j_vrsn:-2.60.3}
-img_tag=${img_tag:-8-jdk}
-tini_vrsn=${tini_vrsn:-0.16.1}
-
-# Deployment Variables
-cont_import_mnt=${cont_import_mnt:-/mnt/jenkins_import}
-home_mnt=${home_mnt:-${workspace}/jenkins_home}
-host_import_mnt=${host_import_mnt:-}
-java_options=${java_options:-"-Xmx4096m"}
-jenkins_options=${jenkins_options:-"--prefix=/jenkins"}
-launch=${launch:-docker}
-
-# Save the Jenkins.war URL to a variable and SHA if we care about verification
-j_url=https://repo.jenkins-ci.org/public/org/jenkins-ci/main/jenkins-war/${j_vrsn}/jenkins-war-${j_vrsn}.war
-
-# Make or Clean WORKSPACE
-if [[ -d "${workspace}" ]]; then
-    rm -rf "${workspace}/Dockerfile" \
-        "${workspace}/docker-jenkins" \
-        "${workspace}/plugins.*" \
-        "${workspace}/install-plugins.sh" \
-        "${workspace}/jenkins.sh" \
-        "${workspace}/jenkins-support" \
-        "${workspace}/init.groovy"
-else
-    mkdir -p "${workspace}"
-fi
-
-# Determine the prefix of the Dockerfile's base image
-case ${ARCH} in
-    "ppc64le")
-        docker_base="ppc64le/"
-        tini_arch="ppc64el"
-        ;;
-    "x86_64")
-        docker_base=""
-        tini_arch="amd64"
-        ;;
-    "aarch64")
-        docker_base="arm64v8/"
-        tini_arch="arm64"
-        ;;
-    *)
-        echo "Unsupported system architecture(${ARCH}) found for docker image"
-        exit 1
-esac
-
-# Move Into the WORKSPACE
-cd "${workspace}"
-
-# Make the Dockerfile
-################################################################################
-cat >> Dockerfile << EOF
-FROM ${docker_base}openjdk:${img_tag}
-
-RUN apt-get update && apt-get install -y git curl
-
-ENV JENKINS_HOME ${j_home}
-ENV JENKINS_SLAVE_AGENT_PORT ${agent_port}
-
-# Jenkins will default to run with user jenkins, uid = 1000
-# If you bind mount a volume from the host or a data container,
-# ensure you use the same uid
-RUN groupadd -g ${j_gid} ${j_group} && \
-    useradd -d ${j_home} -u ${j_uid} -g ${j_gid} -m -s /bin/bash ${j_user}
-
-# Jenkins home directory is a volume, so configuration and build history
-# can be persisted and survive image upgrades
-VOLUME ${j_home}
-
-# /usr/share/jenkins/ref/ contains all reference configuration we want
-# to set on a fresh new installation. Use it to bundle additional plugins
-# or config file with your custom jenkins Docker image.
-RUN mkdir -p /usr/share/jenkins/ref/init.groovy.d
-
-# Use tini as subreaper in Docker container to adopt zombie processes
-RUN curl -fsSL https://github.com/krallin/tini/releases/download/v${tini_vrsn}/tini-static-${tini_arch} \
-    -o /bin/tini && \
-    chmod +x /bin/tini
-
-COPY init.groovy /usr/share/jenkins/ref/init.groovy.d/tcp-slave-agent-port.groovy
-
-# could use ADD but this one does not check Last-Modified header neither does it allow to control checksum
-# see https://github.com/docker/docker/issues/8331
-RUN curl -fsSL ${j_url} -o /usr/share/jenkins/jenkins.war
-
-ENV JENKINS_UC https://updates.jenkins.io
-ENV JENKINS_UC_EXPERIMENTAL=https://updates.jenkins.io/experimental
-RUN chown -R ${j_user} ${j_home} /usr/share/jenkins/ref
-
-# for main web interface:
-EXPOSE ${http_port}
-
-# will be used by attached slave agents:
-EXPOSE ${agent_port}
-
-ENV COPY_REFERENCE_FILE_LOG ${j_home}/copy_reference_file.log
-USER ${j_user}
-
-COPY jenkins-support /usr/local/bin/jenkins-support
-COPY jenkins.sh /usr/local/bin/jenkins.sh
-ENTRYPOINT ["/bin/tini", "--", "/usr/local/bin/jenkins.sh"]
-
-# from a derived Dockerfile, can use RUN plugins.sh active.txt to setup /usr/share/jenkins/ref/plugins from a support bundle
-COPY plugins.sh /usr/local/bin/plugins.sh
-COPY install-plugins.sh /usr/local/bin/install-plugins.sh
-
-# Install plugins.txt plugins
-COPY plugins.txt /usr/share/jenkins/ref/plugins.txt
-RUN /usr/local/bin/install-plugins.sh < /usr/share/jenkins/ref/plugins.txt
-EOF
-################################################################################
-
-# Clone in the jenkinsci docker jenkins repo and copy some files into WORKSPACE
-git clone https://github.com/jenkinsci/docker.git docker-jenkins
-cp docker-jenkins/init.groovy .
-cp docker-jenkins/jenkins-support .
-cp docker-jenkins/jenkins.sh .
-cp docker-jenkins/plugins.sh .
-cp docker-jenkins/install-plugins.sh .
-
-# Generate Plugins.txt, the plugins you want installed automatically go here
-################################################################################
-cat >> plugins.txt << EOF
-kubernetes
-EOF
-################################################################################
-
-# Build the image
-docker build -t "${img_name}" .
-
-if [[ "${launch}" == "docker" ]]; then
-
-    # Ensure directories that will be mounted exist
-    if [[ -n "${host_import_mnt}" && ! -d "${host_import_mnt}" ]]; then
-        mkdir -p "${host_import_mnt}"
-    fi
-
-    if [[ ! -d "${home_mnt}" ]]; then
-        mkdir -p "${home_mnt}"
-    fi
-
-    # Ensure directories that will be mounted are owned by the jenkins user
-    if [[ "$(id -u)" != 0 ]]; then
-        echo "Not running as root:"
-        echo "Checking if j_gid and j_uid are the owners of mounted directories"
-        # shellcheck disable=SC2012 # use ls to get permissions.
-        test_1="$(ls -nd "${home_mnt}" | awk '{print $3 " " $4}')"
-        if [[ "${test_1}" != "${j_uid} ${j_gid}" ]]; then
-            echo "Owner of ${home_mnt} is not the jenkins user"
-            echo "${test_1} != ${j_uid} ${j_gid}"
-            will_fail=1
-        fi
-        if [[ -n "${host_import_mnt}" ]]; then
-            # shellcheck disable=SC2012 # use ls to get permissions.
-            test_2="$(ls -nd "${host_import_mnt}" | awk '{print $3 " " $4}' )"
-            if [[ "${test_2}" != "${j_uid} ${j_gid}" ]]; then
-                echo "Owner of ${host_import_mnt} is not the jenkins user"
-                echo "${test_2} != ${j_uid} ${j_gid}"
-                will_fail=1
-            fi
-        fi
-        if [[ "${will_fail}" == 1 ]]; then
-            echo "Failing before attempting to launch container"
-            echo "Try again as root or use correct uid/gid pairs"
-            exit 1
-        fi
-    else
-        if [[ -n "${host_import_mnt}" ]]; then
-            chown -R "${j_uid}:${j_gid}" "${host_import_mnt}"
-        fi
-        chown -R "${j_uid}:${j_gid}" "${home_mnt}"
-    fi
-
-    #If we don't have import mount don't add to docker command
-    if [[ -n "${host_import_mnt}" ]]; then
-        import_vol_cmd="-v ${host_import_mnt}:${cont_import_mnt}"
-    fi
-    # Launch the jenkins image with Docker
-    # shellcheck disable=SC2086 # import_vol_cmd is intentionally word-split.
-    docker run -d \
-        ${import_vol_cmd} \
-        -v "${home_mnt}:${j_home}" \
-        -p "${http_port}:8080" \
-        -p "${agent_port}:${agent_port}" \
-        --env JAVA_OPTS=\""${java_options}"\" \
-        --env JENKINS_OPTS=\""${jenkins_options}"\" \
-        "${img_name}"
-
-fi
diff --git a/docs-build.sh b/docs-build.sh
deleted file mode 100755
index 438c3d7..0000000
--- a/docs-build.sh
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-
-# Trace bash processing
-set -x
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
-    PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:16.04
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
-	make \
-	texlive-xetex \
-	pandoc \
-	fonts-inconsolata \
-	fonts-linuxlibertine
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t linux-build/ubuntu - <<< "${Dockerfile}" ; then
-    echo "Failed to build docker container."
-    exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-cd ${WORKSPACE}
-
-# Go into the linux directory (the script will put us in a build subdir)
-cd docs
-
-make
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}/build.sh"
-
-# Run the docker container, execute the build script we just built
-docker run --cap-add=sys_admin --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
-    -w "${HOME}" -v "${HOME}":"${HOME}" -t linux-build/ubuntu "${WORKSPACE}/build.sh"
diff --git a/initramfs-build.sh b/initramfs-build.sh
deleted file mode 100755
index f3af769..0000000
--- a/initramfs-build.sh
+++ /dev/null
@@ -1,161 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-
-# Debug
-if grep -q debug <<< "$@"; then
-    set -x
-fi
-set -o errexit
-set -o pipefail
-set -o nounset
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-ENDIANNESS=${ENDIANNESS:-le}
-PROXY=""
-
-function usage() {
-    cat << EOF_USAGE
-Usage: $0 [options]
-
-Options:
---endianness <le|be>	build an LE or BE initramfs
-
-Short Options:
--e			same as --endianness
-
-EOF_USAGE
-    exit 1
-}
-
-# Arguments
-CMD_LINE=$(getopt -o d,e: --longoptions debug,endianness: -n "$0" -- "$@")
-eval set -- "${CMD_LINE}"
-
-while true ; do
-    case "${1}" in
-        -e|--endianness)
-            if [[ "${2,,}" == "be" ]]; then
-                ENDIANNESS=""
-            fi
-            shift 2
-            ;;
-        -d|--debug)
-            set -x
-            shift
-            ;;
-        --)
-            shift
-            break
-            ;;
-        *)
-            usage
-            ;;
-    esac
-done
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
-    PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:18.04
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
-	bc \
-	build-essential \
-	ccache \
-	cpio \
-	git \
-	python \
-	unzip \
-	wget \
-	rsync \
-	iputils-ping \
-	locales
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-RUN locale-gen en_AU.utf8
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t initramfs-build/ubuntu - <<< "${Dockerfile}" ; then
-    echo "Failed to build docker container."
-    exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}/build.sh" << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-export http_proxy=${http_proxy}
-export https_proxy=${http_proxy}
-export ftp_proxy=${http_proxy}
-
-cd "${WORKSPACE}"
-
-# Go into the linux directory (the script will put us in a build subdir)
-cd buildroot && make clean
-
-# Build PPC64 defconfig
-cat >> configs/powerpc64${ENDIANNESS}_openpower_defconfig << EOF_BUILDROOT
-BR2_powerpc64${ENDIANNESS}=y
-BR2_CCACHE=y
-BR2_SYSTEM_BIN_SH_BASH=y
-BR2_TARGET_GENERIC_GETTY_PORT="hvc0"
-BR2_PACKAGE_BUSYBOX_SHOW_OTHERS=y
-BR2_TARGET_ROOTFS_CPIO=y
-BR2_TARGET_ROOTFS_CPIO_XZ=y
-BR2_PACKAGE_IPMITOOL=y
-# BR2_TARGET_ROOTFS_TAR is not set
-EOF_BUILDROOT
-
-# Build buildroot
-export BR2_DL_DIR="${HOME}/buildroot_downloads"
-make powerpc64${ENDIANNESS}_openpower_defconfig
-make
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}/build.sh"
-
-# Run the docker container, execute the build script we just built
-docker run \
-    --cap-add=sys_admin \
-    --net=host \
-    --rm=true \
-    -e WORKSPACE="${WORKSPACE}" \
-    --user="${USER}" \
-    -w "${HOME}" \
-    -v "${HOME}":"${HOME}" \
-    -t initramfs-build/ubuntu \
-    "${WORKSPACE}/build.sh"
-
-# Timestamp for build
-echo "Build completed, $(date)"
-
diff --git a/kernel-build-setup.sh b/kernel-build-setup.sh
deleted file mode 100755
index 6b5d6f4..0000000
--- a/kernel-build-setup.sh
+++ /dev/null
@@ -1,134 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-# It expects a variable as part of Jenkins build job matrix:
-#   distro = fedora|ubuntu
-#   WORKSPACE =
-
-# Trace bash processing
-set -x
-
-# Default variables
-distro=${distro:-ubuntu}
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ "${distro}" == fedora ]];then
-
-    if [[ -n "${http_proxy}" ]]; then
-        PROXY="RUN echo \"proxy=${http_proxy}\" >> /etc/dnf/dnf.conf"
-    fi
-
-    Dockerfile=$(cat << EOF
-FROM fedora:latest
-
-${PROXY}
-
-RUN dnf --refresh install -y \
-	bc \
-	findutils \
-	git \
-	gcc \
-	gcc-arm-linux-gnu \
-	hostname \
-	make \
-	uboot-tools xz
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-    )
-
-elif [[ "${distro}" == ubuntu ]]; then
-    if [[ -n "${http_proxy}" ]]; then
-        PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-    fi
-
-    Dockerfile=$(cat << EOF
-FROM ubuntu:latest
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
-	bc \
-	build-essential \
-	git \
-	gcc-arm-linux-gnueabi \
-	binutils-arm-linux-gnueabi \
-	libssl-dev \
-	bison \
-	flex \
-	u-boot-tools
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-    )
-fi
-
-# Build the docker container
-if ! docker build -t "linux-aspeed/${distro}" - <<< "${Dockerfile}" ; then
-    echo "Failed to build docker container."
-    exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-cd ${WORKSPACE}
-
-# Go into the linux-aspeed directory (the script will put us in a build subdir)
-cd linux-aspeed
-
-# Configure a build
-if [ "${distro}" == "fedora" ]; then
-  CROSS_COMPILER="arm-linux-gnu-"
-else
-  CROSS_COMPILER="arm-linux-gnueabi-"
-fi
-
-# Record the version in the logs
-$\{CROSS_COMPILER}gcc --version
-
-ARCH=arm CROSS_COMPILE=\${CROSS_COMPILER} make aspeed_defconfig
-ARCH=arm CROSS_COMPILE=\${CROSS_COMPILER} make -j$(($(nproc) / 4))
-
-# build palmetto image
-ARCH=arm CROSS_COMPILE=\${CROSS_COMPILER} make aspeed-bmc-opp-palmetto.dtb
-cat arch/arm/boot/zImage arch/arm/boot/dts/aspeed-bmc-opp-palmetto.dtb > palmetto-zimage
-./scripts/mkuboot.sh -A arm -O linux -C none  -T kernel -a 0x40008000 -e 0x40008000 -d-e 0x40008000 -n obmc-palm-\$(date +%Y%m%d%H%M) -d palmetto-zimage uImage.palmetto
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --cap-add=sys_admin --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
-    -w "${HOME}" -v "${HOME}":"${HOME}" -t linux-aspeed/"${distro}" "${WORKSPACE}"/build.sh
-
-# Timestamp for build
-echo "Build completed, $(date)"
-
diff --git a/kernel-build.sh b/kernel-build.sh
deleted file mode 100755
index 22348ea..0000000
--- a/kernel-build.sh
+++ /dev/null
@@ -1,109 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-
-# Trace bash processing
-#set -x
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
-    PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:latest
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
-	bc \
-	build-essential \
-	git \
-	gcc-powerpc64le-linux-gnu \
-	software-properties-common \
-	libssl-dev \
-	bison \
-	flex \
-	iputils-ping
-
-RUN apt-add-repository -y multiverse && apt-get update && apt-get install -yy \
-	dwarves \
-	sparse
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t linux-build/ubuntu - <<< "${Dockerfile}" ; then
-    echo "Failed to build docker container."
-    exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-set -e -o pipefail
-
-cd "${WORKSPACE}"
-
-# Go into the linux directory (the script will put us in a build subdir)
-cd linux
-
-# Record the version in the logs
-powerpc64le-linux-gnu-gcc --version
-
-# Build kernel prep
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make mrproper
-
-# Build kernel
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -s pseries_le_defconfig
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -s -j$(nproc)
-
-# Build kernel with debug
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -s pseries_le_defconfig
-echo "CONFIG_DEBUG_INFO=y" >> .config
-# Enable virtio-net driver for QEMU virtio-net-pci driver
-echo "CONFIG_VIRTIO=y" >> .config
-echo "CONFIG_VIRTIO_NET=y" >> .config
-echo "CONFIG_VIRTIO_PCI=y" >> .config
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make olddefconfig
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -j$(nproc) -s C=2 CF=-D__CHECK_ENDIAN__ 2>&1 | gzip > sparse.log.gz
-pahole vmlinux 2>&1 | gzip > structs.dump.gz
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --cap-add=sys_admin --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
-    -w "${WORKSPACE}" -v "${WORKSPACE}":"${WORKSPACE}" -t linux-build/ubuntu "${WORKSPACE}"/build.sh
-
-result=${?}
-
-# Timestamp for build
-echo "Build completed, $(date)"
-
-exit ${result}
diff --git a/openpower-build-setup.sh b/openpower-build-setup.sh
deleted file mode 100755
index efb3ebc..0000000
--- a/openpower-build-setup.sh
+++ /dev/null
@@ -1,183 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-# It expects a few variables which are part of Jenkins build job matrix:
-#   target = palmetto|qemu|habanero|firestone|garrison
-#   distro = ubuntu|fedora
-#   WORKSPACE = Random Number by Default
-
-# Trace bash processing
-set -x
-
-# Default variables
-target=${target:-palmetto}
-distro=${distro:-ubuntu}
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# if there is no open-power directory clone in master into workspace
-if [ ! -e "${WORKSPACE}"/op-build ]; then
-    echo "Clone in openpower master to ${WORKSPACE}/op-build"
-    git clone --recursive https://github.com/open-power/op-build "${WORKSPACE}"/op-build
-fi
-
-# Determine the architecture
-ARCH=$(uname -m)
-
-# Determine the prefix of the Dockerfile's base image
-case ${ARCH} in
-    "ppc64le")
-        DOCKER_BASE="ppc64le/"
-        ;;
-    "x86_64")
-        DOCKER_BASE=""
-        ;;
-    "aarch64")
-        DOCKER_BASE="arm64v8/"
-        ;;
-    *)
-        echo "Unsupported system architecture(${ARCH}) found for docker image"
-        exit 1
-esac
-
-
-# Configure docker build
-if [[ "${distro}" == fedora ]];then
-
-    Dockerfile=$(cat << EOF
-FROM ${DOCKER_BASE}fedora:latest
-
-RUN dnf --refresh repolist && dnf install -y \
-	bc \
-	bison \
-	bzip2 \
-	cpio \
-	cscope \
-	ctags \
-	expat-devel \
-	findutils \
-	flex \
-	gcc-c++ \
-	git \
-	libxml2-devel \
-	ncurses-devel \
-	openssl-devel \
-	patch \
-	perl \
-	perl-bignum \
-	"perl(Digest::SHA1)" \
-	"perl(Env)" \
-	"perl(Fatal)" \
-	"perl(Thread::Queue)" \
-	"perl(XML::SAX)" \
-	"perl(XML::Simple)" \
-	"perl(YAML)" \
-	"perl(XML::LibXML)" \
-	python \
-	python3 \
-	tar \
-	unzip \
-	vim \
-	wget \
-	which \
-	zlib-devel \
-	zlib-static \
-	iputils-ping
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-    )
-
-elif [[ "${distro}" == ubuntu ]]; then
-
-    Dockerfile=$(cat << EOF
-FROM ${DOCKER_BASE}ubuntu:latest
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
-	bc \
-	bison \
-	build-essential \
-	cscope \
-	cpio \
-	ctags \
-	flex \
-	g++ \
-	git \
-	libssl-dev \
-	libexpat-dev \
-	libz-dev \
-	libxml-sax-perl \
-	libxml-simple-perl \
-	libxml2-dev \
-	libxml2-utils \
-	language-pack-en \
-	python \
-	python3 \
-	texinfo \
-	unzip \
-	vim-common \
-	wget\
-	xsltproc \
-        libssl-dev \
-	iputils-ping
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-    )
-fi
-
-# Build the docker container
-if ! docker build -t op-build/"${distro}" - <<< "${Dockerfile}" ; then
-    echo "Failed to build docker container."
-    exit 1
-fi
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-# This ensures that the alias set in op-build-env is
-# available in this script
-shopt -s expand_aliases
-
-cd "${WORKSPACE}"/op-build
-
-# Source our build env
-. op-build-env
-
-# Configure
-op-build "${target}_defconfig"
-
-# Kick off a build
-op-build
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
-    -w "${HOME}" -v "${HOME}":"${HOME}" -t op-build/"${distro}" "${WORKSPACE}"/build.sh
-
-# Create link to images for archiving
-ln -sf "${WORKSPACE}"/op-build/output/images "${WORKSPACE}"/images
-
-# Timestamp for build
-echo "Build completed, $(date)"
diff --git a/test-distro.sh b/test-distro.sh
deleted file mode 100755
index 394567b..0000000
--- a/test-distro.sh
+++ /dev/null
@@ -1,104 +0,0 @@
-#!/bin/bash
-
-set -eou pipefail
-set -x
-
-function util_ensure_available() {
-    local bin=$1
-    if ! which "${bin}"
-    then
-        echo "Please install ${bin}"
-        return 1
-    fi
-    return 0
-}
-
-function jenkins_get_job_config() {
-    local host="$1"
-    local job="$2"
-    local config
-    config="$(mktemp --suffix=.xml config.XXXXXX)"
-    local url="https://${host}/job/${job}/config.xml"
-    wget --output-document="${config}" "${url}"
-    echo "${config}"
-}
-
-function jenkins_get_job_repos() {
-    local config="$1"
-    if [ -n "${REPO}" ]
-    then
-        echo "${REPO}"
-        return 0
-    fi
-    # xmllint is rubbish, so we need sed(1) to separate the results
-    xmllint --xpath '//com.sonyericsson.hudson.plugins.gerrit.trigger.hudsontrigger.data.GerritProject/pattern' "${config}" | sed -e 's/<pattern>//g' -e 's/<\/pattern>/\n/g'
-}
-
-: "${JENKINS_HOST:=openpower.xyz}"
-: "${JENKINS_JOB:=openbmc-repository-ci}"
-
-util_ensure_available wget
-util_ensure_available xmllint
-util_ensure_available git
-
-CONFIG=
-REPO=
-
-while [[ $# -gt 0 ]]
-do
-    key="$1"
-    case "${key}" in
-        -c|--config)
-            CONFIG="$2"
-            shift 2
-            ;;
-        -r|--repo|--repository)
-            REPO="$2"
-            shift 2
-            ;;
-        -h|--help)
-            echo "USAGE: DISTRO=DOCKERBASE $0 --config config.xml"
-            echo
-            echo "DOCKERBASE is the Docker Hub tag of the base image against which to"
-            echo "build and test the repositories described in config.xml. Individual"
-            echo "repositories can be tested against DOCKERBASE with the --repository"
-            echo "option \(in place of --config\)."
-            exit 0
-            ;;
-        *)
-            (>&2 echo Unrecognised argument \'"$1"\')
-            shift
-            ;;
-    esac
-done
-
-if [ -z "${CONFIG}" ]
-then
-    CONFIG="$(jenkins_get_job_config "${JENKINS_HOST}" "${JENKINS_JOB}")"
-fi
-
-export UNIT_TEST_PKG=
-export WORKSPACE=
-
-function git_clone_repo() {
-    local prj_package="$1"
-    local package
-    package="$(basename "${prj_package}")"
-    local workspace="$2"
-    if [ -d "${prj_package}" ]
-    then
-        git clone "${prj_package}" "${workspace}"/"${package}"
-        return
-    fi
-    git clone https://gerrit.openbmc.org/openbmc/"${package}" "${workspace}"/"${package}"
-}
-
-jenkins_get_job_repos "${CONFIG}" | while read -r GERRIT_PROJECT
-do
-    UNIT_TEST_PKG=$(basename "${GERRIT_PROJECT}")
-    WORKSPACE="$(mktemp -d --tmpdir openbmc-build-scripts.XXXXXX)"
-    git clone . "${WORKSPACE}"/openbmc-build-scripts
-    git_clone_repo "${GERRIT_PROJECT}" "${WORKSPACE}"
-    ./run-unit-test-docker.sh
-    rm -rf "${WORKSPACE}"
-done
diff --git a/trace-kernel-build.sh b/trace-kernel-build.sh
deleted file mode 100755
index 63691e2..0000000
--- a/trace-kernel-build.sh
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-#
-
-# Trace bash processing
-#set -x
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
-    PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:latest
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
-	bc \
-	build-essential \
-	git \
-	gcc-powerpc64le-linux-gnu \
-	software-properties-common \
-	libssl-dev \
-	iputils-ping \
-	bison \
-	flex
-
-RUN apt-add-repository -y multiverse && apt-get update && apt-get install -yy \
-	dwarves \
-	sparse
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t trace-linux-build/ubuntu - <<< "${Dockerfile}" ; then
-    echo "Failed to build docker container."
-    exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -xe
-
-cd ${WORKSPACE}
-
-# Go into the linux directory (the script will put us in a build subdir)
-cd linux
-
-# Record the version in the logs
-powerpc64le-linux-gnu-gcc --version
-
-# Build kernel prep
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make mrproper
-
-# Generate the config
-echo "CONFIG_PPC_PSERIES=y" >> fragment.config
-echo "CONFIG_PPC_POWERNV=y" >> fragment.config
-echo "CONFIG_MTD=y" >> fragment.config
-echo "CONFIG_MTD_BLOCK=y" >> fragment.config
-echo "CONFIG_MTD_POWERNV_FLASH=y" >> fragment.config
-ARCH=powerpc scripts/kconfig/merge_config.sh \
-    arch/powerpc/configs/ppc64_defconfig \
-    arch/powerpc/configs/le.config \
-    fragment.config
-
-# Ensure config is up to date and no questions will be asked
-yes "" | ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make oldconfig
-
-# Build kernel
-ARCH=powerpc CROSS_COMPILE=powerpc64le-linux-gnu- make -j$(nproc) vmlinux
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --cap-add=sys_admin --net=host --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
-    -w "${WORKSPACE}" -v "${WORKSPACE}":"${WORKSPACE}" \
-    -t trace-linux-build/ubuntu "${WORKSPACE}"/build.sh
-
-result=${?}
-
-# Timestamp for build
-echo "Build completed, $(date)"
-
-exit ${result}
diff --git a/u-boot-build.sh b/u-boot-build.sh
deleted file mode 100755
index b8917a0..0000000
--- a/u-boot-build.sh
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/bin/bash
-
-# This build script is for running the Jenkins builds using docker.
-
-# Trace bash processing
-set -x
-
-# Default variables
-WORKSPACE=${WORKSPACE:-${HOME}/${RANDOM}${RANDOM}}
-BOARD_DEFCONFIG=${BOARD_DEFCONFIG:-ast_g5_defconfig}
-http_proxy=${http_proxy:-}
-
-# Timestamp for job
-echo "Build started, $(date)"
-
-# Configure docker build
-if [[ -n "${http_proxy}" ]]; then
-    PROXY="RUN echo \"Acquire::http::Proxy \\"\"${http_proxy}/\\"\";\" > /etc/apt/apt.conf.d/000apt-cacher-ng-proxy"
-fi
-
-Dockerfile=$(cat << EOF
-FROM ubuntu:16.04
-
-${PROXY}
-
-ENV DEBIAN_FRONTEND noninteractive
-RUN apt-get update && apt-get install -yy \
-	make bc gcc gcc-arm-linux-gnueabi
-
-RUN grep -q ${GROUPS[0]} /etc/group || groupadd -g ${GROUPS[0]} ${USER}
-RUN grep -q ${UID} /etc/passwd || useradd -d ${HOME} -m -u ${UID} -g ${GROUPS[0]} ${USER}
-
-USER ${USER}
-ENV HOME ${HOME}
-RUN /bin/bash
-EOF
-)
-
-# Build the docker container
-if ! docker build -t u-boot-build/ubuntu - <<< "${Dockerfile}" ; then
-    echo "Failed to build docker container."
-    exit 1
-fi
-
-# Create the docker run script
-export PROXY_HOST=${http_proxy/#http*:\/\/}
-export PROXY_HOST=${PROXY_HOST/%:[0-9]*}
-export PROXY_PORT=${http_proxy/#http*:\/\/*:}
-
-mkdir -p "${WORKSPACE}"
-
-cat > "${WORKSPACE}"/build.sh << EOF_SCRIPT
-#!/bin/bash
-
-set -x
-
-cd "${WORKSPACE}"
-
-gcc --version
-arm-linux-gnueabi-gcc --version
-
-# Go into the source directory (the script will put us in a build subdir)
-cd u-boot
-CROSS_COMPILE=arm-linux-gnueabi- make ${BOARD_DEFCONFIG}
-CROSS_COMPILE=arm-linux-gnueabi- make
-
-EOF_SCRIPT
-
-chmod a+x "${WORKSPACE}"/build.sh
-
-# Run the docker container, execute the build script we just built
-docker run --rm=true -e WORKSPACE="${WORKSPACE}" --user="${USER}" \
-    -w "${HOME}" -v "${HOME}":"${HOME}" -t u-boot-build/ubuntu \
-    "${WORKSPACE}"/build.sh