# Copyright 2004-2010 Sabayon Project
# Copyright 2013 Sablink Project
# Distributed under the terms of the GNU General Public License v2
# $

# @ECLASS-VARIABLE: K_SABPATCHES_VER
# @DESCRIPTION:
# The version of the sablink patches tarball(s) to apply.
# A value of "5" would apply 2.6.12-5 to my-sources-2.6.12.ebuild

# @ECLASS-VARIABLE: K_SABKERNEL_NAME
# @DESCRIPTION:
# The kernel name used by the ebuild, it should be the ending ${PN} part
# for example, of linux-sablink it is "${PN/${PN/-*}-}" (sablink)
K_SABKERNEL_NAME="${K_SABKERNEL_NAME:-${PN/${PN/-*}-}}"

# @ECLASS-VARIABLE: K_SABKERNEL_URI_CONFIG
# @DESCRIPTION:
# Set this either to "no" or "yes" depending on the location of the
# kernel config files.  If they are inside FILESDIR (old location)
# leave this option set to "no", otherwise set this to "yes"
K_SABKERNEL_URI_CONFIG="${K_SABKERNEL_URI_CONFIG:-no}"

# @ECLASS-VARIABLE: K_SABKERNEL_SELF_TARBALL_NAME
# @DESCRIPTION:
# If the main kernel sources tarball is generated in-house and available
# on the "sablink" mirror, set this variable to the extension name (see example
# below). This will disable ALL the extra/local patches (since they have to
# be applied inside the tarball). Moreover, K_SABKERNEL_URI_CONFIG,
# K_SABPATCHES_VER, K_SABKERNEL_NAME, K_KERNEL_PATCH_VER will be ignored.
# Example:
#   K_SABKERNEL_SELF_TARBALL_NAME="sablink"
#   This would generate:
#   SRC_URI="mirror://sablink/sys-kernel/linux-${PV}+sablink.tar.${K_TARBALL_EXT}"
K_SABKERNEL_SELF_TARBALL_NAME="${K_SABKERNEL_SELF_TARBALL_NAME:-}"

# @ECLASS-VARIABLE: K_SABKERNEL_FORCE_SUBLEVEL
# @DESCRIPTION:
# Force the rewrite of SUBLEVEL in kernel sources Makefile
K_SABKERNEL_FORCE_SUBLEVEL="${K_SABKERNEL_FORCE_SUBLEVEL:-}"

# @ECLASS-VARIABLE: K_SABKERNEL_RESET_EXTRAVERSION
# @DESCRIPTION:
# Force the rewrite of EXTRAVERSION in kernel sources Makefile (setting it to "")
K_SABKERNEL_RESET_EXTRAVERSION="${K_SABKERNEL_RESET_EXTRAVERSION:-}"

# @ECLASS-VARIABLE: K_SABKERNEL_LONGTERM
# @DESCRIPTION:
# Consider Kernel stable patchset as longterm (changing URL)
K_SABKERNEL_LONGTERM="${K_SABKERNEL_LONGTERM:-}"

# @ECLASS-VARIABLE: K_KERNEL_SOURCES_PKG
# @DESCRIPTION:
# The kernel sources package used to build this kernel binary
K_KERNEL_SOURCES_PKG="${K_KERNEL_SOURCES_PKG:-${CATEGORY}/${PN/*-}-sources-${PVR}}"

# @ECLASS-VARIABLE: K_KERNEL_PATCH_VER
# @DESCRIPTION:
# If set to "3" for example, it applies the upstream kernel
# patch corresponding to patch-${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.3.${K_TARBALL_EXT}
# @TODO: deprecate and remove once 2.6.x kernels are retired
K_KERNEL_PATCH_VER="${K_KERNEL_PATCH_VER:-}"

# @ECLASS-VARIABLE: K_KERNEL_PATCH_HOTFIXES
# @DESCRIPTION:
# If there is the need to quickly apply patches to the kernel
# without bumping the kernel patch tarball (for eg. in case
# of just released security fixes), set this variable in your ebuild
# pointing to space separated list of patch paths.
K_KERNEL_PATCH_HOTFIXES="${K_KERNEL_PATCH_HOTFIXES:-}"

# @ECLASS-VARIABLE: K_KERNEL_DISABLE_PR_EXTRAVERSION
# @DESCRIPTION:
# Set this to "1" if you want to tell kernel-2 eclass to
# not use ${PR} in kernel EXTRAVERSION (K_NOUSEPR). Otherwise, set
# this to "0" to not set K_NOUSEPR at all.
K_KERNEL_DISABLE_PR_EXTRAVERSION="${K_KERNEL_DISABLE_PR_EXTRAVERSION:-1}"

# @ECLASS-VARIABLE: K_KERNEL_SLOT_USEPVR
# @DESCRIPTION:
# Set this to "1" if you want to use ${PVR} in SLOT variable, instead of ${PV}
# sys-kernel/linux-vserver (vserver-sources) require this. This won't work for
# firmware pkgs.
K_KERNEL_SLOT_USEPVR="${K_KERNEL_SLOT_USEPVR:-0}"

# @ECLASS-VARIABLE: K_KERNEL_NEW_VERSIONING
# @DESCRIPTION:
# Set this to "1" if your kernel ebuild uses the new Linux kernel upstream
# versioning and ${PV} contains the stable revision, like 3.7.1.
# In the example above, this makes the SLOT variable contain only "3.7".
# The sublevel version can be forced using K_SABKERNEL_FORCE_SUBLEVEL
K_KERNEL_NEW_VERSIONING="${K_KERNEL_NEW_VERSIONING:-0}"

# @ECLASS-VARIABLE: K_KERNEL_IMAGE_NAME
# @DESCRIPTION:
# Set this to a custom kernel image make target if the default does not
# fit your needs. This value if set, is passed to genkernel through the
# --kernel-target= flag.
K_KERNEL_IMAGE_NAME="${K_KERNEL_IMAGE_NAME:-}"

# @ECLASS-VARIABLE: K_KERNEL_LTS
# @DESCRIPTION:
# Set this to 1 to mark the kernel as Long Term Stable. "virtual/linux-binary-lts"
# shall be appended to ${PROVIDE}.
K_KERNEL_LTS="${K_KERNEL_LTS:-}"

# @ECLASS-VARIABLE: K_KERNEL_IMAGE_PATH
# @DESCRIPTION:
# Set this to a custom relative kernel image path to override the default
# one. This value if set, is passed to genkernel through the
# --kernel-binary= flag.
K_KERNEL_IMAGE_PATH="${K_KERNEL_IMAGE_PATH:-}"

# @ECLASS-VARIABLE: K_SABKERNEL_FIRMWARE
# @DESCRIPTION:
# Set this to "1" if your ebuild is a kernel firmware package
K_FIRMWARE_PACKAGE="${K_FIRMWARE_PACKAGE:-}"

# @ECLASS-VARIABLE: K_ONLY_SOURCES
# @DESCRIPTION:
# For every kernel binary package, there is a kernel source package associated
# if your ebuild is one of them, set this to "1"
K_ONLY_SOURCES="${K_ONLY_SOURCES:-}"

# @ECLASS-VARIABLE: K_REQUIRED_LINUX_FIRMWARE_VER
# @DESCRIPTION:
# Minimum required version of sys-kernel/linux-formware package, if any
K_REQUIRED_LINUX_FIRMWARE_VER="${K_REQUIRED_LINUX_FIRMWARE_VER:-}"

# @ECLASS-VARIABLE: K_WORKAROUND_SOURCES_COLLISION
# @DESCRIPTION:
# For kernel binary packages, Workaround file collisions with kernel
# sources already providing certain files (like Makefile). Used
# by linux-openvz and linux-vserver
K_WORKAROUND_SOURCES_COLLISION="${K_WORKAROUND_SOURCES_COLLISION:-}"

# @ECLASS-VARIABLE: K_WORKAROUND_USE_REAL_EXTRAVERSION
# @DESCRIPTION:
# Some kernel sources are shipped with their own EXTRAVERSION and
# we're kindly asked to not touch it, if this is your case, set
# this variable and depmod will work correctly.
K_WORKAROUND_USE_REAL_EXTRAVERSION="${K_WORKAROUND_USE_REAL_EXTRAVERSION:-}"

# @ECLASS-VARIABLE: K_SABKERNEL_ZFS
# @DESCRIPTION:
# If set, this kernel features ZFS.
K_SABKERNEL_ZFS="${K_SABKERNEL_ZFS:-}"

# @ECLASS-VARIABLE: K_GENKERNEL_ARGS
# @DESCRIPTION:
# Provide extra genkernel arguments using K_GENKERNEL_ARGS
K_GENKERNEL_ARGS="${K_GENKERNEL_ARGS:-}"

# @ECLASS-VARIABLE: K_MKIMAGE_RAMDISK_ADDRESS
# @DESCRIPTION:
# [ARM ONLY] Provide the ramdisk load address to be used with mkimage
K_MKIMAGE_RAMDISK_ADDRESS="${K_MKIMAGE_RAMDISK_ADDRESS:-}"

# @ECLASS-VARIABLE: K_MKIMAGE_RAMDISK_ENTRYPOINT
# @DESCRIPTION:
# [ARM ONLY] Provide the ramdisk entry point address to be used with mkimage
K_MKIMAGE_RAMDISK_ENTRYPOINT="${K_MKIMAGE_RAMDISK_ENTRYPOINT:-}"

# @ECLASS-VARIABLE: K_MKIMAGE_WRAP_INITRAMFS
# @DESCRIPTION:
# [ARM ONLY] Execute mkimage against the generated initramfs Default is yes ("1").
K_MKIMAGE_WRAP_INITRAMFS="${K_MKIMAGE_WRAP_INITRAMFS:-1}"

# @ECLASS-VARIABLE: K_MKIMAGE_KERNEL_ADDRESS
# @DESCRIPTION:
# [ARM ONLY] Provide the kernel load address to be used with mkimage
K_MKIMAGE_KERNEL_ADDRESS="${K_MKIMAGE_KERNEL_ADDRESS:-}"

KERN_INITRAMFS_SEARCH_NAME="${KERN_INITRAMFS_SEARCH_NAME:-initramfs-genkernel*${K_SABKERNEL_NAME}}"

# Disable deblobbing feature
K_DEBLOB_AVAILABLE=0
ETYPE="sources"
K_TARBALL_EXT="${K_TARBALL_EXT:-xz}"

inherit versionator
if [ "${K_KERNEL_NEW_VERSIONING}" = "1" ]; then
	CKV="$(get_version_component_range 1-2)"
fi

inherit eutils multilib kernel-2 mount-boot linux-info

# from kernel-2 eclass
detect_version
detect_arch

DESCRIPTION="Sablink Linux kernel functions and phases"


K_LONGTERM_URL_STR=""
if [ -n "${K_SABKERNEL_LONGTERM}" ]; then
	K_LONGTERM_URL_STR="/longterm/v${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}"
fi

## kernel-2 eclass settings
if [ -n "${K_SABKERNEL_SELF_TARBALL_NAME}" ]; then
	SRC_URI="mirror://sablink/${CATEGORY}/linux-${PVR}+${K_SABKERNEL_SELF_TARBALL_NAME}.tar.${K_TARBALL_EXT}"
elif [ -n "${K_SABPATCHES_VER}" ]; then
	UNIPATCH_STRICTORDER="yes"
	K_SABPATCHES_PKG="sablink-patches-${PV}-${K_SABPATCHES_VER}.tar.${K_TARBALL_EXT}"
	UNIPATCH_LIST="${DISTFILES}/${K_SABPATCHES_PKG}"
	SRC_URI="${KERNEL_URI}
		mirror://sablink/${CATEGORY}/linux-sablink-patches/${K_SABPATCHES_PKG}"
else
	SRC_URI="${KERNEL_URI}"
fi

if [ -z "${K_SABKERNEL_SELF_TARBALL_NAME}" ]; then
	if [ -n "${K_KERNEL_PATCH_VER}" ]; then
		K_PATCH_NAME="patch-${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}.${K_KERNEL_PATCH_VER}.${K_TARBALL_EXT}"
		SRC_URI="${SRC_URI}
			mirror://kernel/linux/kernel/v${KV_MAJOR}.${KV_MINOR}${K_LONGTERM_URL_STR}/${K_PATCH_NAME}"
		UNIPATCH_LIST="${DISTDIR}/${K_PATCH_NAME}
			${UNIPATCH_LIST}"
	fi
fi
if [ -n "${K_KERNEL_PATCH_HOTFIXES}" ]; then
	UNIPATCH_LIST="${K_KERNEL_PATCH_HOTFIXES} ${UNIPATCH_LIST}"
fi

_get_real_kv_full() {
	if [[ "${KV_MAJOR}${KV_MINOR}" -eq 26 ]]; then
		echo "${ORIGINAL_KV_FULL}"
	elif [[ "${OKV/.*}" = "3" ]]; then
		# Linux 3.x support, KV_FULL is set to: 3.0-sablink
		# need to add another final .0 to the version part
		echo "${ORIGINAL_KV_FULL/-/.0-}"
	else
		echo "${ORIGINAL_KV_FULL}"
	fi
}

# replace "linux" with K_SABKERNEL_NAME, usually replaces
# "linux" with "sablink" or "server" or "openvz"
KV_FULL="${KV_FULL/${PN/-*}/${K_SABKERNEL_NAME}}"
EXTRAVERSION="${EXTRAVERSION/${PN/-*}/${K_SABKERNEL_NAME}}"
# drop -rX if exists
if [[ -n "${PR//r0}" ]] && [[ "${K_KERNEL_DISABLE_PR_EXTRAVERSION}" = "1" ]] \
		&& [[ -z "${K_NOSETEXTRAVERSION}" ]]; then
	EXTRAVERSION="${EXTRAVERSION%-r*}"
	KV_FULL="${KV_FULL%-r*}"
	KV="${KV%-r*}"
fi
# rewrite it
ORIGINAL_KV_FULL="${KV_FULL}"
KV_FULL="$(_get_real_kv_full)"

# Starting from linux-3.0, we still have to install
# sources stuff into /usr/src/linux-3.0.0-sablink (example)
# where the last part must always match uname -r
# otherwise kernel-switcher (and RELEASE_LEVEL file)
# will complain badly
KV_OUT_DIR="/usr/src/linux-${KV_FULL}"
S="${WORKDIR}/linux-${KV_FULL}"


if [ -n "${K_FIRMWARE_PACKAGE}" ]; then
	SLOT="0"
elif [ "${K_KERNEL_SLOT_USEPVR}" = "1" ]; then
	SLOT="${PVR}"
elif [ "${K_KERNEL_NEW_VERSIONING}" = "1" ]; then
	SLOT="$(get_version_component_range 1-2)"
else
	SLOT="${PV}"
fi

_is_kernel_binary() {
	if [ -z "${K_ONLY_SOURCES}" ] && [ -z "${K_FIRMWARE_PACKAGE}" ]; then
		# yes it is
		return 0
	else
		# no it isn't
		return 1
	fi
}

_is_kernel_lts() {
	local _ver="$(get_version_component_range 1-2)"
	[ "${_ver}" = "3.0" ] && return 0
	[ "${_ver}" = "3.2" ] && return 0
	[ "${_ver}" = "3.4" ] && return 0
	[ "${_ver}" = "3.10" ] && return 0
	return 1
}

# provide extra virtual pkg
if _is_kernel_binary; then
	PROVIDE="virtual/linux-binary"
# LTS support
	if [ "${K_KERNEL_LTS}" = "1" ] || _is_kernel_lts; then
		PROVIDE+=" virtual/linux-binary-lts"
	fi
fi

if [ -n "${K_SABKERNEL_SELF_TARBALL_NAME}" ]; then
	HOMEPAGE="http://git.disconnected-by-peer.at/sablink/kernel/"
else
	HOMEPAGE="http://www.sablink.org"
fi

# set SRC_URI
if [ -z "${K_SABKERNEL_SELF_TARBALL_NAME}" ]; then
	if [ "${K_SABKERNEL_URI_CONFIG}" = "yes" ]; then
		tmp_K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE:-${K_SABKERNEL_NAME}-${PVR}-__ARCH__.config}"
		# ARM not supported, if put in SRC_URI it tries to fetch it
		tmp_K_SABKERNEL_FW_CONFIG_FILE="${K_SABKERNEL_FW_CONFIG_FILE:-${K_SABKERNEL_NAME}-fw_env-__ARCH__.config}"
		if [ -n "${K_SABCONFIGS_VER}" ]; then
			K_SABCONFIGS_PKG="sablink-configs-${PV}-${K_SABCONFIGS_VER}.tar.${K_TARBALL_EXT}"
			SRC_URI="${SRC_URI}
				mirror://sablink/${CATEGORY}/linux-sablink-configs/${K_SABCONFIGS_PKG}"
		else
			SRC_URI="${SRC_URI}
				arm? ( mirror://sablink/${CATEGORY}/linux-sablink-patches/config/${tmp_K_SABKERNEL_FW_CONFIG_FILE/__ARCH__/arm} )
				amd64? ( mirror://sablink/${CATEGORY}/linux-sablink-patches/config/${tmp_K_SABKERNEL_CONFIG_FILE/__ARCH__/amd64} )
				x86? ( mirror://sablink/${CATEGORY}/linux-sablink-patches/config/${tmp_K_SABKERNEL_CONFIG_FILE/__ARCH__/x86} )"
		fi
		# K_SABKERNEL_CONFIG_FILE will be set in _set_config_file_vars
		unset tmp_K_SABKERNEL_CONFIG_FILE
		unset tmp_K_SABKERNEL_FW_CONFIG_FILE
	fi
fi

# Returns success if _set_config_file_vars was called.
_is_config_file_set() {
	[[ ${_config_file_set} = 1 ]]
}

# Returns the arm kernel config file extension for the current subarch
_get_arm_subarch() {
	local target="${CTARGET:-${CHOST}}"
	local arm_arch=${target%%-*}
	if [[ ${arm_arch} == armv7? ]]; then
		echo "armv7"
	elif [[ ${arm_arch} == armv6? ]]; then
		echo "armv6"
	elif [[ ${arm_arch} == armv5? ]]; then
		echo "armv5"
	fi
}

_set_config_file_vars() {
	# Setup kernel configuration file name
	local pvr="${PVR}"
	local pv="${PV}"
	if [ "${K_KERNEL_NEW_VERSIONING}" = "1" ]; then
		pvr="$(get_version_component_range 1-2)"
		pv="${pvr}"
		if [ "${PR}" != "r0" ]; then
			pvr+="-${PR}"
		fi
	fi
	if [ -z "${K_SABKERNEL_SELF_TARBALL_NAME}" ]; then
		if [ "${K_SABKERNEL_URI_CONFIG}" = "yes" ]; then
			K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE:-${K_SABKERNEL_NAME}-${pvr}-__ARCH__.config}"
			K_SABKERNEL_FW_CONFIG_FILE="${K_SABKERNEL_FW_CONFIG_FILE:-${K_SABKERNEL_NAME}-fw_env-__ARCH__.config}"
			use arm && K_SABKERNEL_CONFIG_FILE=${K_SABKERNEL_CONFIG_FILE/__ARCH__/$(_get_arm_subarch)}
			use arm && K_SABKERNEL_FW_CONFIG_FILE=${K_SABKERNEL_FW_CONFIG_FILE/__ARCH__/$(_get_arm_subarch)}
			use amd64 && K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE/__ARCH__/amd64}"
			use x86 && K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE/__ARCH__/x86}"
		else
			use arm && K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE:-${K_SABKERNEL_NAME}-${pvr}-$(_get_arm_subarch).config}"
			use amd64 && K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE:-${K_SABKERNEL_NAME}-${pvr}-amd64.config}"
			use x86 && K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE:-${K_SABKERNEL_NAME}-${pvr}-x86.config}"
		fi
	else
		K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE:-${K_SABKERNEL_NAME}-${pvr}-__ARCH__.config}"
		K_SABKERNEL_ALT_CONFIG_FILE="${K_SABKERNEL_ALT_CONFIG_FILE:-${K_SABKERNEL_NAME}-${pv}-__ARCH__.config}"
		K_SABKERNEL_FW_CONFIG_FILE="${K_SABKERNEL_FW_CONFIG_FILE:-${K_SABKERNEL_NAME}-${pvr}-fw_env-__ARCH__.config}"
		if use amd64; then
			K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE/__ARCH__/amd64}"
			K_SABKERNEL_ALT_CONFIG_FILE="${K_SABKERNEL_ALT_CONFIG_FILE/__ARCH__/amd64}"
		elif use x86; then
			K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE/__ARCH__/x86}"
			K_SABKERNEL_ALT_CONFIG_FILE="${K_SABKERNEL_ALT_CONFIG_FILE/__ARCH__/x86}"
		elif use arm; then
			K_SABKERNEL_CONFIG_FILE="${K_SABKERNEL_CONFIG_FILE/__ARCH__/$(_get_arm_subarch)}"
			K_SABKERNEL_ALT_CONFIG_FILE="${K_SABKERNEL_ALT_CONFIG_FILE/__ARCH__/$(_get_arm_subarch)}"
			K_SABKERNEL_FW_CONFIG_FILE="${K_SABKERNEL_FW_CONFIG_FILE/__ARCH__/$(_get_arm_subarch)}"
		fi
	fi

	_config_file_set=1
}

if [ -n "${K_ONLY_SOURCES}" ] || [ -n "${K_FIRMWARE_PACKAGE}" ]; then
	IUSE="${IUSE}"
	DEPEND="sys-apps/sed"
	RDEPEND="${RDEPEND}"
else
	IUSE="dmraid dracut iscsi luks lvm mdadm"
	if [ -n "${K_SABKERNEL_ZFS}" ]; then
		IUSE="${IUSE} zfs"
	fi
	DEPEND="app-arch/xz-utils
		sys-apps/sed
		sys-devel/autoconf
		sys-devel/make
		sys-fs/dosfstools
		|| ( >=sys-kernel/genkernel-next-5 >=sys-kernel/genkernel-3.4.45-r2 )
		arm? ( dev-embedded/u-boot-tools sys-block/devio )
		amd64? ( sys-apps/v86d )
		x86? ( sys-apps/v86d )
		lvm? ( sys-fs/lvm2 sys-block/thin-provisioning-tools )
		dracut? ( sys-apps/v86d sys-kernel/dracut )"
	RDEPEND="sys-apps/sed
		sys-kernel/linux-firmware"
	if [ -n "${K_REQUIRED_LINUX_FIRMWARE_VER}" ]; then
		RDEPEND+=" >=sys-kernel/linux-firmware-${K_REQUIRED_LINUX_FIRMWARE_VER}"
	fi
fi

# internal function
#
# FUNCTION: _update_depmod
# @USAGE: _update_depmod <-r depmod>
# DESCRIPTION:
# It updates the modules.dep file for the current kernel.
# This is more or less the same of linux-mod update_depmod, with the
# exception of accepting parameter which is passed to depmod -r switch
_update_depmod() {

        # if we haven't determined the version yet, we need too.
        get_version;

	ebegin "Updating module dependencies for ${KV_FULL}"
	if [ -r "${KV_OUT_DIR}"/System.map ]; then
		depmod -ae -F "${KV_OUT_DIR}"/System.map -b "${ROOT}" -r "${1}"
		eend $?
	else
		ewarn
		ewarn "${KV_OUT_DIR}/System.map not found."
		ewarn "You must manually update the kernel module dependencies using depmod."
		eend 1
		ewarn
	fi
}

sablink-kernel_pkg_setup() {
	if [ -n "${K_FIRMWARE_PACKAGE}" ]; then
		einfo "Preparing kernel firmwares"
	else
		einfo "Preparing kernel and its modules"
	fi
}

sablink-kernel_src_unpack() {
	local okv="${OKV}"
	if [ -n "${K_SABKERNEL_SELF_TARBALL_NAME}" ]; then
		OKV="${PVR}+${K_SABKERNEL_SELF_TARBALL_NAME}"
	fi
	if [ -n "${K_SabCONFIGS_VER}" ]; then
		unpack "${K_SABCONFIGS_PKG}"
 	fi
	if [ "${K_KERNEL_NEW_VERSIONING}" = "1" ]; then
		# workaround for kernel-2's universal_unpack assumptions
		UNIPATCH_LIST_DEFAULT= KV_MAJOR=0 kernel-2_src_unpack
	else
		kernel-2_src_unpack
	fi
	if [ -n "${K_SABKERNEL_FORCE_SUBLEVEL}" ]; then
		# patch out Makefile with proper sublevel
		sed -i "s:^SUBLEVEL = .*:SUBLEVEL = ${K_SABKERNEL_FORCE_SUBLEVEL}:" \
			"${S}/Makefile" || die
	fi

	#comment out Extra verion change by CK patch
	sed -i -e 's/\(^EXTRAVERSION :=.*$\)/# \1/' "${S}/Makefile"

	if [ -n "${K_SABKERNEL_RESET_EXTRAVERSION}" ]; then
		sed -i "s:^EXTRAVERSION =.*:EXTRAVERSION = :" "${S}/Makefile" || die
		# some sources could have multiple append-based EXTRAVERSIONs
		sed -i "s/^EXTRAVERSION :=.*//" "${S}/Makefile" || die
	fi
	OKV="${okv}"

	# Let's handle EAPIs 0 and 1...
	case ${EAPI:-0} in
		0|1) sablink-kernel_src_prepare ;;
	esac

	# delete empty directories
	pushd "${S}"
	find . -depth -type d -empty -delete
	popd
}

sablink-kernel_src_prepare() {
	_set_config_file_vars
}

sablink-kernel_src_compile() {
	if [ -n "${K_FIRMWARE_PACKAGE}" ]; then
		_firmwares_src_compile
	elif [ -n "${K_ONLY_SOURCES}" ]; then
		kernel-2_src_compile
	else
		_kernel_src_compile
	fi
}

_firmwares_src_compile() {
	einfo "Starting to compile firmwares..."
	_kernel_copy_config "${S}/.config"
	cd "${S}" || die "cannot find source dir"

	export LDFLAGS=""
	OLDARCH="${ARCH}"
	unset ARCH
	emake firmware || die "cannot compile firmwares"
	ARCH="${OLDARCH}"
}

_kernel_copy_config() {
	_is_config_file_set \
		|| die "Kernel configuration file not set. Was sablink-kernel_src_prepare() called?"

	if [ -n "${K_SABKERNEL_SELF_TARBALL_NAME}" ]; then
		local base_path="${S}/sablink/config"
		if [ -f "${base_path}/${K_SABKERNEL_ALT_CONFIG_FILE}" ]; then
			# new path, without revision
			cp "${base_path}/${K_SABKERNEL_ALT_CONFIG_FILE}" "${1}" || die "cannot copy kernel config 1"
		else
			# PVR path (old)
			cp "${base_path}/${K_SABKERNEL_CONFIG_FILE}" "${1}" || die "cannot copy kernel config 2"
		fi
	else
		if [ "${K_SABKERNEL_URI_CONFIG}" = "no" ]; then
			# Legacy stuff, not supporting K_KERNEL_NEW_VERSIONING
			cp "${FILESDIR}/${PF/-r0/}-${ARCH}.config" "${1}" || die "cannot copy kernel config 3"
		else
			if [ -n "${K_SABCONFIGS_VER}" ]; then
				rm -rf "${S}/sablink"
				cp -rf "${WORKDIR}"/sablink "${S}"
				pushd "${S}"
				sablink/scripts/prepareconfig ${K_SABKERNEL_NAME}-${CHOST/-*/}
				mv .config "${1}.tmp"
				mv "${1}.tmp" "${1}"
				popd
			else
				cp "${DISTDIR}/${K_SABKERNEL_CONFIG_FILE}" "${1}" || die "cannot copy kernel config 4"
			fi
		fi
	fi
}

_kernel_src_compile() {
	# disable sandbox
	export SANDBOX_ON=0

	# needed anyway, even if grub use flag is not used here
	if use amd64 || use x86; then
		mkdir -p "${WORKDIR}"/boot/grub
	else
		if use arm; then
			mkdir -p "${WORKDIR}"/boot/dtb
		else
			mkdir -p "${WORKDIR}"/boot
		fi
	fi

	einfo "Starting to compile kernel..."
	_kernel_copy_config "${WORKDIR}"/config

	# do some cleanup
	rm -rf "${WORKDIR}"/lib
	rm -rf "${WORKDIR}"/cache
	rm -rf "${S}"/temp

	# creating workdirs
	# some kernels fail with make 3.82 if firmware dir is not created
	mkdir "${WORKDIR}"/lib/lib/firmware -p
	mkdir "${WORKDIR}"/cache
	mkdir "${S}"/temp

	cd "${S}" || die
	local GKARGS=()
	GKARGS+=( "--no-save-config" "--e2fsprogs" "--udev" )
	use dmraid && GKARGS+=( "--dmraid" )
	use iscsi && GKARGS+=( "--iscsi" )
	use mdadm && GKARGS+=( "--mdadm" )
	use luks && GKARGS+=( "--luks" )
	use lvm && GKARGS+=( "--lvm" )
	if [ -n "${K_SABKERNEL_ZFS}" ]; then
		use zfs && GKARGS+=( "--zfs" )
	fi

	export DEFAULT_KERNEL_SOURCE="${S}"
	export CMD_KERNEL_DIR="${S}"
	for opt in ${MAKEOPTS}; do
		if [ "${opt:0:2}" = "-j" ]; then
			mkopts="${opt}"
			break
		fi
	done
	[ -z "${mkopts}" ] && mkopts="-j3"

	if [ -n "${K_KERNEL_IMAGE_NAME}" ]; then
		GKARGS+=( "--kernel-target=${K_KERNEL_IMAGE_NAME}" )
#	elif use arm; then
#		# backward compat + provide sane defaults.
#		GKARGS+=( "--kernel-target=uImage" )
	fi
	if [ -n "${K_KERNEL_IMAGE_PATH}" ]; then
		GKARGS+=( "--kernel-binary=${K_KERNEL_IMAGE_PATH}" )
#	elif use arm; then
#		# backward compat + provide sane defaults.
#		GKARGS+=( "--kernel-binary=arch/arm/boot/uImage" )
	fi

	# Workaround bug in splash_geninitramfs corrupting the initramfs
	# if xz compression is used (newer genkernel >3.4.24)
	local support_comp=$(genkernel --help | grep compress-initramfs-type)
	if [ -n "${support_comp}" ]; then
		GKARGS+=( "--compress-initramfs-type=gzip" )
	fi

	# Use --disklabel if genkernel supports it
	local support_disklabel=$(genkernel --help | grep -- --disklabel)
	if [ -n "${support_disklabel}" ]; then
		GKARGS+=( "--disklabel" )
	fi

	if [ -n "${K_MKIMAGE_KERNEL_ADDRESS}" ]; then
		export LOADADDR="${K_MKIMAGE_KERNEL_ADDRESS}"
	fi

	K_SABKERNEL_DTB="none"

	#################################### ARM V5 ######################################
	# Buffalo anounced a new box named Pro Live (video transcode streaming)
	# so the old ls_pro_live has to be split to ls_pro ls_live
	# for now let it stay but a move schould be done to ls_pro
	if [ "${K_SABKERNEL_NAME}" = "buffalo_kb_pro" ]; then
		devio > foo 'wl 0xe3a01c05,4' 'wl 0xe38110e5,4' # KuroBox Pro 1509
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo/Revogear Kurobox Pro"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_chl" ]; then
		devio > foo 'wl 0xe3a01c0b,4' 'wl 0xe3811061,4' # Linkstation Live V3 (2.6.34) 2913
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation LiveV3 (LS-CHL)"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_chl2" ]; then
		if [[ "${KV_MAJOR}${KV_MINOR}" -ge 35 ]]; then
			# new Device tree no need for devio
			K_SABKERNEL_DTB="kirkwood-lschlv2.dtb"
		else
			devio > foo 'wl 0xe3a01c0b,4' 'wl 0xe38110be,4' # Linkstation XHL/CHLv2 3006
		fi
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation LS-CHLv2"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_hgl" ]; then
		devio > foo 'wl 0xe3a01c07,4' 'wl 0xe38110d5,4' # Linkstation HGL (2.6.31) 2005
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation LS-HGL"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_mini" ]; then
		devio > foo 'wl 0xe3a01c07,4' 'wl 0xe3811042,4' # Linkstation mini (2.6.29) 1858
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation Mini"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_pro_live" ]; then
		devio > foo 'wl 0xe3a01c06,4' 'wl 0xe3811031,4' # Linkstation Pro/Live (2.6.26) 1585
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation Pro/Live"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_pro_duo_rev1" ]; then
		devio > foo 'wl 0xe3a01c07,4' 'wl 0xe3811027,4' # Linkstation Pro Duo (2.6.30) 1831
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation Pro Duo - Revision 1"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_pro_duo_rev2" ]; then
		devio > foo 'wl 0xe3a01c07,4' 'wl 0xe3811027,4' # Linkstation Pro Duo (2.6.30) 1831
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation Pro Duo - Revision 2"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_ql" ]; then
		devio > foo 'wl 0xe3a01c10,4' 'wl 0xe381108e,4' # Buffalo Linkstation Quad LSQL. Registered 2012.06.15. 4238
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation Quad"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_vl" ]; then
		devio > foo 'wl 0xe3a01c14,4' 'wl 0xe381109d,4' # Linkstation vl is not in the db so took one 5277
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo LS-VL Series"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_wvl" ]; then
		if [[ "${KV_MAJOR}${KV_MINOR}" -ge 39 ]]; then
			# new Device tree no need for devio
			K_SABKERNEL_DTB="kirkwood-lswvl.dtb"
		else
			devio > foo 'wl 0xe3a01c14,4' 'wl 0xe381109e,4' # Linkstation wvl is not in the db so took one 5278
		fi
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation LS-WVL"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ts_wxl" ]; then
		devio > foo 'wl 0xe3a01c0a,4' 'wl 0xe3811089,4' # Terastation WXL (2.6.35) 2697
		K_SABKERNEL_TYPE="buffalo"
		# Broken hardware name needs to be correct in u-boot firmware
		K_SABKERNEL_DEVICE="Buffalo Linkstation Pro/Live"
	fi
	if [ "${K_SABKERNEL_NAME}" = "buffalo_ls_xhl" ]; then
		if [[ "${KV_MAJOR}${KV_MINOR}" -ge 35 ]]; then
			# new Device tree no need for devio
			K_SABKERNEL_DTB="kirkwood-lsxhl.dtb"
		else
			devio > foo 'wl 0xe3a01c0a,4' 'wl 0xe3811067,4' # Linkstation XHL/CHLv2 (2.6.30) 2663
		fi
		K_SABKERNEL_TYPE="buffalo"
		K_SABKERNEL_DEVICE="Buffalo Linkstation LS-XHL"
	fi

	#################################### ARM V6 ######################################
	# oxnas
	if [ "${K_SABKERNEL_NAME}" = "medion_stg212" ]; then
		K_SABKERNEL_TYPE="default"
		K_SABKERNEL_DEVICE="Oxford NAS"
		K_GENKERNEL_ARGS+=" --kernel-target=uImage --kernel-binary=arch/arm/boot/uImage"
	fi
	if [ "${K_SABKERNEL_NAME}" = "pogoplug_pro" ]; then
		K_SABKERNEL_TYPE="default"
		K_SABKERNEL_DEVICE="Oxford NAS"
		K_GENKERNEL_ARGS+=" --kernel-target=uImage --kernel-binary=arch/arm/boot/uImage"
	fi
	if [ "${K_SABKERNEL_NAME}" = "pogoplug_pro_pci" ]; then
		K_SABKERNEL_TYPE="default"
		K_SABKERNEL_DEVICE="Oxford NAS"
		K_GENKERNEL_ARGS+=" --kernel-target=uImage --kernel-binary=arch/arm/boot/uImage"
	fi
	if [ "${K_SABKERNEL_NAME}" = "iomega_hmnd_ce" ]; then
		K_SABKERNEL_TYPE="default"
		K_SABKERNEL_DEVICE="Oxford NAS"
		K_GENKERNEL_ARGS+=" --kernel-target=uImage --kernel-binary=arch/arm/boot/uImage"
	fi


	#################################### ARM V7 ######################################
	# Freescale
	if [ "${K_SABKERNEL_NAME}" = "freescale_mx53_loco" ]; then
		K_SABKERNEL_TYPE="default"
		K_SABKERNEL_DEVICE="Freescale MX53 LOCO Board"
		K_GENKERNEL_ARGS+=" --kernel-target=uImage --kernel-binary=arch/arm/boot/uImage"
	fi

	# Freescale
	if [ "${K_SABKERNEL_NAME}" = "pandaboard" ]; then
		K_SABKERNEL_TYPE="default"
		K_SABKERNEL_DEVICE="OMAP4 Panda board"
		K_GENKERNEL_ARGS+=" --kernel-target=uImage --kernel-binary=arch/arm/boot/uImage"
	fi	
	
	OLDARCH="${ARCH}"
	unset ARCH
	unset LDFLAGS

	if [ "${K_SABKERNEL_DTB}" != "none" ]; then
		cp "${WORKDIR}/config" .config
		emake ${K_SABKERNEL_DTB}
		cp "${S}"/arch/arm/boot/${K_SABKERNEL_DTB} "${S}"
		emake mrproper
	fi

	emake 3rdparty
	
	DEFAULT_KERNEL_SOURCE="${S}" CMD_KERNEL_DIR="${S}" genkernel "${GKARGS[@]}" ${K_GENKERNEL_ARGS} \
		--kerneldir="${S}" \
		--kernel-config="${WORKDIR}"/config \
		--cachedir="${WORKDIR}"/cache \
		--makeopts="${mkopts}" \
		--tempdir="${S}"/temp \
		--logfile="${WORKDIR}"/genkernel.log \
		--bootdir="${WORKDIR}"/boot \
		--mountboot \
		--module-prefix="${WORKDIR}"/lib \
		all || die "genkernel failed"

	if [ -n "${K_MKIMAGE_KERNEL_ADDRESS}" ]; then
		unset LOADADDR
	fi

	ARCH=${OLDARCH}

	# Buffalo Boxes have a special naming and start address
	if [ "${K_SABKERNEL_TYPE}" = "buffalo" ]; then
		if [ "${K_SABKERNEL_DTB}" = "none" ]; then
			einfo "Prepend the correct Device ID to the Kenel Image"
			cat foo "${WORKDIR}"/boot/kernel-genkernel-${ARCH}-${KV_FULL} > zImage.new
			einfo "Create uImage of the resulting Image"
			mkimage -A arm -O linux -T kernel -C none -a 0x00008000 -e 0x00008000 -n uImage-${KV_FULL} \
				-d zImage.new "${WORKDIR}"/boot/uImage-genkernel-${ARCH}-${KV_FULL}.buffalo
			einfo "Create uInitrd with correct start address"
			mkimage -A arm -O linux -T ramdisk -C none -a 0x00000000 -e 0x00000000 -n initrd-${KV_FULL} \
				-d "${WORKDIR}"/boot/initramfs-genkernel-${ARCH}-${KV_FULL} "${WORKDIR}"/boot/uInitramfs-genkernel-${ARCH}-${KV_FULL}.buffalo
		else
			einfo "Append the device-tree-blob to the Kenel Image"
			cat "${WORKDIR}"/boot/kernel-genkernel-${ARCH}-${KV_FULL} "${S}"/${K_SABKERNEL_DTB} > zImage.new
			cp "${S}"/${K_SABKERNEL_DTB} "${WORKDIR}"/boot/dtb/
			einfo "Create uImage of the resulting Image"
			mkimage -A arm -O linux -T kernel -C none -a 0x00008000 -e 0x00008000 -n uImage-${KV_FULL} \
				-d zImage.new "${WORKDIR}"/boot/uImage-genkernel-${ARCH}-${KV_FULL}.buffalo
			einfo "Create uInitrd with correct start address"
			mkimage -A arm -O linux -T ramdisk -C none -a 0x00000000 -e 0x00000000 -n initrd-${KV_FULL} \
				-d "${WORKDIR}"/boot/initramfs-genkernel-${ARCH}-${KV_FULL} "${WORKDIR}"/boot/uInitramfs-genkernel-${ARCH}-${KV_FULL}.buffalo
		fi
	fi

	if [ "${K_SABKERNEL_TYPE}" = "default" ]; then
		einfo "Rename Kernel Image for consistency"
		mv "${WORKDIR}"/boot/kernel-genkernel-${ARCH}-${KV_FULL} "${WORKDIR}"/boot/uImage-genkernel-${ARCH}-${KV_FULL}
		einfo "Create uInitrd with correct start address"
		mkimage -A arm -O linux -T ramdisk -C none -a 0x00000000 -e 0x00000000 -n initrd-${KV_FULL} \
			-d "${WORKDIR}"/boot/initramfs-genkernel-${ARCH}-${KV_FULL} "${WORKDIR}"/boot/uInitramfs-genkernel-${ARCH}-${KV_FULL}
	fi

	# cleanup
	rm -rf foo zImage.new ${K_SABKERNEL_DTB}
	rm "${WORKDIR}"/boot/kernel-genkernel-${ARCH}-${KV_FULL} "${WORKDIR}"/boot/initramfs-genkernel-${ARCH}-${KV_FULL}
}

_setup_mkimage_ramdisk() {
	local initramfs=$(ls "${WORKDIR}"/boot/${KERN_INITRAMFS_SEARCH_NAME}* 2> /dev/null)
	if [ ! -e "${initramfs}" ] || [ ! -f "${initramfs}" ]; then
		ewarn "No initramfs at ${initramfs}, cannot run mkimage on it!"
	elif [ "${K_MKIMAGE_WRAP_INITRAMFS}" = "1" ]; then
		einfo "Setting up u-boot initramfs for: ${initramfs}"
		mkimage -A arm -O linux -T ramdisk -C none -a \
			"${K_MKIMAGE_RAMDISK_ADDRESS}" \
			-e "${K_MKIMAGE_RAMDISK_ENTRYPOINT}" -d "${initramfs}" \
			"${initramfs}.u-boot" || return 1
		mv "${initramfs}.u-boot" "${initramfs}" || return 1
	else
		einfo "mkimage won't be called for: ${initramfs}"
	fi
	return 0
}

sablink-kernel_src_install() {
	if [ -n "${K_FIRMWARE_PACKAGE}" ]; then
		_firmwares_src_install
	elif [ -n "${K_ONLY_SOURCES}" ]; then
		_kernel_sources_src_install
	else
		_kernel_src_install
	fi
	# File collisions between slots, debug stuff
	# not really needed for a kernel
	rm -rf "${D}/usr/lib/debug"
}

_firmwares_src_install() {
	dodir /lib/firmware
	keepdir /lib/firmware
	cd "${S}" || die
	emake INSTALL_FW_PATH="${D}/lib/firmware" firmware_install || die "cannot install firmwares"
}

_kernel_sources_src_install() {
	_kernel_copy_config ".config"
	kernel-2_src_install
	cd "${D}${KV_OUT_DIR}" || die
	local oldarch="${ARCH}"
	unset ARCH
	if ! use sources_standalone; then
		make modules_prepare || die "failed to run modules_prepare"
		rm .config || die "cannot remove .config"
		rm Makefile || die "cannot remove Makefile"
		rm -f include/linux/version.h
		rm -f include/generated/uapi/linux/version.h
	fi
	ARCH="${oldarch}"
}

_kernel_src_install() {
	if use arm; then
		_setup_mkimage_ramdisk || die "cannot setup mkimage"
	fi

	dodir "${KV_OUT_DIR}"
	insinto "${KV_OUT_DIR}"

	_kernel_copy_config ".config"
	doins ".config" || die "cannot copy kernel config"
	doins Makefile || die "cannot copy Makefile"
	doins Module.symvers || die "cannot copy Module.symvers"
	doins System.map || die "cannot copy System.map"

	# NOTE: this is a workaround caused by linux-info.eclass not
	# being ported to EAPI=2 yet
	local version_h_dir="include/linux"
	local version_h_dir2="include/generated/uapi/linux"
	local version_h=
	local version_h_src=
	for ver_dir in "${version_h_dir}" "${version_h_dir2}"; do
		version_h="${ROOT}${KV_OUT_DIR/\//}/${ver_dir}/version.h"
		if [ -f "${version_h}" ]; then
			einfo "Discarding previously installed version.h to avoid collisions"
			addwrite "${version_h}"
			rm -f "${version_h}"
		fi

		# Include include/linux/version.h to make Portage happy
		version_h_src="${S}/${ver_dir}/version.h"
		if [ -f "${version_h_src}" ]; then
			dodir "${KV_OUT_DIR}/${ver_dir}"
			insinto "${KV_OUT_DIR}/${ver_dir}"
			doins "${version_h_src}" || die "cannot copy version.h"
		fi
	done

	insinto "/boot"
	doins "${WORKDIR}"/boot/* || die "cannot copy /boot over"
	cp -Rp "${WORKDIR}"/lib/* "${D}/" || die "cannot copy /lib over"

	# Install dtbs if found
	if use arm; then
		local dtb_dir="/lib/dts/${KV_FULL}"
		elog "Installing .dtbs (if any) into ${dtb_dir}"
		insinto "${dtb_dir}"
		local dtb=
		for dtb in "${S}/arch/arm/boot/dts"/*.dtb; do
			if [ -f "${dtb}" ]; then
				elog "Installing dtb: ${dtb}"
				doins "${dtb}"
			fi
		done
	fi

	# This doesn't always work because KV_FULL (when K_NOSETEXTRAVERSION=1) doesn't
	# reflect the real value used in Makefile
	#dosym "../../..${KV_OUT_DIR}" "/lib/modules/${KV_FULL}/source" || die "cannot install source symlink"
	#dosym "../../..${KV_OUT_DIR}" "/lib/modules/${KV_FULL}/build" || die "cannot install build symlink"
	cd "${D}"/lib/modules/* || die "cannot enter /lib/modules directory, more than one element?"
	# cleanup previous
	rm -f build source || die
	# create sane symlinks
	ln -sf "../../..${KV_OUT_DIR}" source || die "cannot create source symlink"
	ln -sf "../../..${KV_OUT_DIR}" build || die "cannot create build symlink"
	cd "${S}" || die

	# drop ${D}/lib/firmware, virtual/linux-firmwares provides it
	rm -rf "${D}/lib/firmware"

	if [ -n "${K_WORKAROUND_SOURCES_COLLISION}" ]; then
		# Fixing up Makefile collision if already installed by
		# openvz-sources
		einfo "Workarounding source package collisions"
		make_file="${KV_OUT_DIR/\//}/Makefile"
		einfo "Makefile: ${make_file}"
		if [ -f "${ROOT}/${make_file}" ]; then
			elog "Removing ${D}/${make_file}"
			rm -f "${D}/${make_file}"
		fi
	fi

	# Install kernel configuration information
	# useful for Entropy kernel-switcher
	# release level is enough for now
	base_dir="/etc/kernels/${P}"
	dodir "${base_dir}"
	insinto "${base_dir}"
	echo "${KV_FULL}" > "RELEASE_LEVEL"
	doins "RELEASE_LEVEL"
	einfo "Installing ${base_dir}/RELEASE_LEVEL file: ${KV_FULL}"

	use dracut && \
		_dracut_initramfs_create "${KV_FULL}"

	# copy firmware config file to propper location
	if [ -n "${K_SABKERNEL_SELF_TARBALL_NAME}" ]; then
		local base_path="${S}/sablink/config"
		cp "${base_path}/${K_SABKERNEL_FW_CONFIG_FILE}" "${D}/etc/fw_env.config.${K_SABKERNEL_NAME}" || die "cannot copy firmware config"
	else
		if [ "${K_SABKERNEL_URI_CONFIG}" = "no" ]; then
			cp "${FILESDIR}/${PF/-r0/}-${ARCH}.config" "${D}/etc/fw_env.config.${K_SABKERNEL_NAME}" || die "cannot copy firmware config"
		else
			cp "${DISTDIR}/${K_SABKERNEL_FW_CONFIG_FILE}" "${D}/etc/fw_env.config.${K_SABKERNEL_NAME}" || die "cannot copy firmware config"
		fi
	fi
}

sablink-kernel_pkg_preinst() {
	if _is_kernel_binary; then
		mount-boot_pkg_preinst
	fi
}
sablink-kernel_grub2_mkconfig() {
	if [ -x "${ROOT}usr/sbin/grub2-mkconfig" ]; then
		# Grub 2.00
		"${ROOT}usr/sbin/grub2-mkconfig" -o "${ROOT}boot/grub/grub.cfg"
	elif [ -x "${ROOT}sbin/grub-mkconfig" ]; then
		# Grub 1.99
		"${ROOT}sbin/grub-mkdevicemap" --device-map="${ROOT}boot/grub/device.map"
		"${ROOT}sbin/grub-mkconfig" -o "${ROOT}boot/grub/grub.cfg"
	else
		echo
		ewarn "Attention, Grub2 is not installed !!!"
		ewarn "Grub2 bootloader configuration won't be updated"
		echo
	fi
}

_get_real_extraversion() {
	make_file="${ROOT}${KV_OUT_DIR}/Makefile"
	local extraver=$(grep -r "^EXTRAVERSION =" "${make_file}" | cut -d "=" -f 2 | head -n 1)
	local trimmed=${extraver%% }
	echo ${trimmed## }
}

_get_release_level() {
	if [[ -n "${K_WORKAROUND_USE_REAL_EXTRAVERSION}" ]]; then
		echo "${KV_MAJOR}.${KV_MINOR}.${KV_PATCH}$(_get_real_extraversion)"
	elif [[ "${KV_MAJOR}${KV_MINOR}" -eq 26 ]]; then
		echo "${KV_FULL}"
	elif [[ "${OKV/.*}" = "3" ]] && [[ "${KV_PATCH}" = "0" ]]; then
		# Linux 3.x support, KV_FULL is set to: 3.0-sablink
		# need to add another final .0 to the version part
		echo "${KV_FULL/-/.0-}"
	else
		echo "${KV_FULL}"
	fi
}

sablink-kernel_uimage_config() {
	# Two cases here:
	# 1. /boot/uImage symlink is broken (pkg_postrm)
	# 2. /boot/uImage symlink doesn't exist (pkg_postinst)

	if ! has_version app-admin/eselect-uimage; then
		ewarn "app-admin/eselect-uimage not installed"
		ewarn "If you are using this tool, please install it"
		return 0
	fi

	local uimage_file=$(eselect uimage show --quiet 2> /dev/null)
	if [ -z "${uimage_file}" ]; then
		# pick the first listed, sorry!
		local eselect_list=$(eselect uimage list --quiet 2> /dev/null)
		if [ -n "${eselect_list}" ]; then
			eselect uimage set 1
		else
			echo
			ewarn "No more kernels available, you won't be able to boot"
			echo
		fi
	else
		echo
		elog "If you use eselect-bzimage, you are currently booting with kernel:"
		elog "${uimage_file}"
		elog
		elog "Use 'eselect uimage' in order to switch between the available ones"
		echo
	fi
}

sablink-kernel_bzimage_config() {
	# Two cases here:
	# 1. /boot/bzImage symlink is broken (pkg_postrm)
	# 2. /boot/bzImage symlink doesn't exist (pkg_postinst)
	local kern_arch
	use x86 && kern_arch="x86"
	use amd64 && kern_arch="x86_64"

	if ! has_version app-admin/eselect-bzimage; then
		ewarn "app-admin/eselect-bzimage not installed"
		ewarn "If you are using this tool, please install it"
		return 0
	fi

	local bzimage_file=$(eselect bzimage show --quiet 2> /dev/null)
	if [ -z "${bzimage_file}" ]; then
		# try to pic what's being installed
		local eselect_list=$(eselect bzimage list --quiet 2> /dev/null)
		if [ -n "${eselect_list}" ]; then
			eselect bzimage set "kernel-genkernel-${kern_arch}-${KV_FULL}"
			if [ "${?}" != "0" ]; then
				# pick the first available, sorry!
				echo
				eselect bzimage set 1
				ewarn "Unable to select the right kernel, falling back"
				ewarn "to the first available entry. You have been warned"
				echo
			fi
		else
			echo
			ewarn "No more kernels available, you might not be able to boot"
			echo
		fi
	else
		echo
		ewarn "You are currently booting with kernel:"
		ewarn "${bzimage_file}"
		ewarn
		ewarn "Use 'eselect bzimage' in order to switch between the available ones"
		echo
	fi
}

_dracut_initramfs_create() {
	local kver="${1}"

	elog "Creating dracut initramfs for ${kver}"
	addpredict /etc/ld.so.cache~
	dracut -q -N -f --kver="${kver}" "${D}/boot/initramfs-dracut-${kver}"
}

sablink-kernel_pkg_postinst() {
	if _is_kernel_binary; then
		fstab_file="${ROOT}etc/fstab"
		einfo "Removing extents option for ext4 drives from ${fstab_file}"
		# Remove "extents" from /etc/fstab
		if [ -f "${fstab_file}" ]; then
			sed -i '/ext4/ s/extents//g' "${fstab_file}"
		fi

		# Add kernel to grub.conf
		if use amd64 || use x86; then
			if use amd64; then
				local kern_arch="x86_64"
			else
				local kern_arch="x86"
			fi
			# grub-legacy
			if [ -x "${ROOT}usr/sbin/grub-handler" ]; then
				"${ROOT}usr/sbin/grub-handler" add \
					"/boot/kernel-genkernel-${kern_arch}-${KV_FULL}" \
					"/boot/initramfs-genkernel-${kern_arch}-${KV_FULL}"
			fi

			sablink-kernel_grub2_mkconfig
		fi

		# Setup newly installed kernel on ARM
		if use arm; then
			sablink-kernel_uimage_config
		fi
		# Setup newly installed kernel on x86/amd64
		# This is quite handy for static grub1/grub2
		# configurations (like on Amazon EC2)
		if use x86 || use amd64; then
			sablink-kernel_bzimage_config
		fi

		kernel-2_pkg_postinst
		local depmod_r=$(_get_release_level)
		_update_depmod "${depmod_r}"

		elog "Please report kernel bugs at:"
		elog "http://bugs.sablink.org"

		elog "The source code of this kernel is located at"
		elog "=${K_KERNEL_SOURCES_PKG}."
		elog "Sablink Linux recommends that portage users install"
		elog "${K_KERNEL_SOURCES_PKG} if you want"
		elog "to build any packages that install kernel modules"
		elog "(such as ati-drivers, nvidia-drivers, virtualbox, etc...)."

		# copy the firmware config for the actual hardware to the right place
		device=$(grep "Hardware[[:space:]]*:" /proc/cpuinfo 2>/dev/null | head -n1 | sed "s/^[^:]*: //")
		if [ "${K_SABKERNEL_DEVICE}" = "$device" ]; then
			cp ${ROOT}/etc/fw_env.config.${K_SABKERNEL_NAME} ${ROOT}/etc/fw_env.config
		fi
	else
		kernel-2_pkg_postinst
	fi
}

sablink-kernel_pkg_prerm() {
	if _is_kernel_binary; then
		mount-boot_pkg_prerm
	fi
}

sablink-kernel_pkg_postrm() {
	if _is_kernel_binary; then
		# Remove kernel from grub.conf
		if use amd64 || use x86; then
			if use amd64; then
				local kern_arch="x86_64"
			else
				local kern_arch="x86"
			fi
			if [ -x "${ROOT}usr/sbin/grub-handler" ]; then
				"${ROOT}usr/sbin/grub-handler" remove \
					"/boot/kernel-genkernel-${kern_arch}-${KV_FULL}" \
					"/boot/initramfs-genkernel-${kern_arch}-${KV_FULL}"
			fi

			sablink-kernel_grub2_mkconfig
		fi

		# Setup newly installed kernel on ARM
		if use arm; then
			sablink-kernel_uimage_config
		fi
		# Setup newly installed kernel on x86/amd64
		# This is quite handy for static grub1/grub2
		# configurations (like on Amazon EC2)
		if use x86 || use amd64; then
			sablink-kernel_bzimage_config
		fi
	fi
}

# export all the available functions here
case ${EAPI:-0} in
	0|1) extra_export_funcs= ;;
	*) extra_export_funcs=src_prepare ;;
esac

EXPORT_FUNCTIONS pkg_setup src_unpack ${extra_export_funcs} \
	src_compile src_install pkg_preinst pkg_postinst pkg_prerm pkg_postrm